diff --git a/kernel/orbis/include/orbis/Budget.hpp b/kernel/orbis/include/orbis/Budget.hpp
index 8f661bded..9451b85f9 100644
--- a/kernel/orbis/include/orbis/Budget.hpp
+++ b/kernel/orbis/include/orbis/Budget.hpp
@@ -2,8 +2,8 @@
 
 #include "orbis-config.hpp"
 #include "rx/SharedMutex.hpp"
-#include "utils/BitSet.hpp"
-#include "utils/Rc.hpp"
+#include "rx/BitSet.hpp"
+#include "rx/Rc.hpp"
 #include <array>
 #include <cstring>
 #include <mutex>
@@ -44,7 +44,7 @@ static_assert(sizeof(BudgetInfo) == 0x18);
 using BudgetInfoList =
     std::array<BudgetInfo, static_cast<int>(BudgetResource::_count)>;
 
-class Budget : public RcBase {
+class Budget : public rx::RcBase {
   using BudgetList =
       std::array<BudgetItem, static_cast<int>(BudgetResource::_count)>;
 
@@ -134,7 +134,7 @@ public:
 
 private:
   mutable rx::shared_mutex mMtx;
-  orbis::BitSet<static_cast<int>(BudgetResource::_count)> mUsed;
+  rx::BitSet<static_cast<int>(BudgetResource::_count)> mUsed;
   ProcessType mProcessType{};
   BudgetList mList;
   char mName[32]{};
diff --git a/kernel/orbis/include/orbis/KernelAllocator.hpp b/kernel/orbis/include/orbis/KernelAllocator.hpp
index f3dd5dd1b..c298b89e5 100644
--- a/kernel/orbis/include/orbis/KernelAllocator.hpp
+++ b/kernel/orbis/include/orbis/KernelAllocator.hpp
@@ -1,6 +1,6 @@
 #pragma once
 
-#include "utils/Rc.hpp"
+#include "rx/Rc.hpp"
 #include <deque>
 #include <map>
 #include <string>
@@ -56,22 +56,30 @@ using kunmap =
 template <typename T, typename... Args>
   requires(std::is_constructible_v<T, Args...>)
 T *knew(Args &&...args) {
-  auto loc = static_cast<T *>(utils::kalloc(sizeof(T), alignof(T)));
-  auto res = std::construct_at(loc, std::forward<Args>(args)...);
-  if constexpr (requires(T *t) { t->_total_size = sizeof(T); })
-    res->_total_size = sizeof(T);
-  return res;
+  if constexpr (std::is_base_of_v<rx::RcBase, T>) {
+    static_assert(!std::is_final_v<T>);
+    struct DynamicObject final : T {
+      using T::T;
+
+      void operator delete(void *pointer) { utils::kfree(pointer, sizeof(T)); }
+    };
+
+    auto loc = static_cast<DynamicObject *>(
+        utils::kalloc(sizeof(DynamicObject), alignof(DynamicObject)));
+    return std::construct_at(loc, std::forward<Args>(args)...);
+  } else {
+    static_assert(!std::is_polymorphic_v<T>, "Polymorphic type should be derived from rx::RcBase");
+
+    auto loc = static_cast<T *>(utils::kalloc(sizeof(T), alignof(T)));
+    return std::construct_at(loc, std::forward<Args>(args)...);
+  }
 }
 
 // clang-format off
 template <typename T> void kdelete(T *ptr) {
-  auto total_size = sizeof(T);
-  if constexpr (requires(T *t) { t->_total_size = sizeof(T); })
-    total_size = ptr->_total_size;
-  else
-    static_assert(std::is_final_v<T>, "Uncertain type size");
+  static_assert(std::is_final_v<T>, "Uncertain type size");
   ptr->~T();
-  utils::kfree(ptr, total_size);
+  utils::kfree(ptr, sizeof(T));
 }
 // clang-format on
 
diff --git a/kernel/orbis/include/orbis/KernelContext.hpp b/kernel/orbis/include/orbis/KernelContext.hpp
index e95443328..c2317dac4 100644
--- a/kernel/orbis/include/orbis/KernelContext.hpp
+++ b/kernel/orbis/include/orbis/KernelContext.hpp
@@ -9,8 +9,8 @@
 #include "rx/SharedCV.hpp"
 #include "rx/SharedMutex.hpp"
 #include "thread/types.hpp"
-#include "utils/IdMap.hpp"
-#include "utils/LinkedNode.hpp"
+#include "rx/IdMap.hpp"
+#include "rx/LinkedNode.hpp"
 
 #include <cstdint>
 #include <mutex>
@@ -57,7 +57,7 @@ enum class FwType : std::uint8_t {
   Ps5,
 };
 
-struct RcAppInfo : RcBase, AppInfoEx {
+struct RcAppInfo : rx::RcBase, AppInfoEx {
   orbis::uint32_t appState = 0;
 };
 
@@ -71,7 +71,7 @@ public:
   Process *findProcessById(pid_t pid) const;
   Process *findProcessByHostId(std::uint64_t pid) const;
 
-  utils::LinkedNode<Process> *getProcessList() { return m_processes; }
+  rx::LinkedNode<Process> *getProcessList() { return m_processes; }
 
   long allocatePid() {
     std::lock_guard lock(m_thread_id_mtx);
@@ -98,7 +98,7 @@ public:
     return {it->second.get(), inserted};
   }
 
-  Ref<EventFlag> findEventFlag(std::string_view name) {
+  rx::Ref<EventFlag> findEventFlag(std::string_view name) {
     std::lock_guard lock(m_evf_mtx);
 
     if (auto it = m_event_flags.find(name); it != m_event_flags.end()) {
@@ -121,7 +121,7 @@ public:
     return {it->second.get(), inserted};
   }
 
-  Ref<Semaphore> findSemaphore(std::string_view name) {
+  rx::Ref<Semaphore> findSemaphore(std::string_view name) {
     std::lock_guard lock(m_sem_mtx);
     if (auto it = m_semaphores.find(name); it != m_semaphores.end()) {
       return it->second;
@@ -130,7 +130,7 @@ public:
     return {};
   }
 
-  std::pair<Ref<IpmiServer>, ErrorCode> createIpmiServer(utils::kstring name) {
+  std::pair<rx::Ref<IpmiServer>, ErrorCode> createIpmiServer(utils::kstring name) {
     std::lock_guard lock(m_sem_mtx);
     auto [it, inserted] = mIpmiServers.try_emplace(std::move(name), nullptr);
 
@@ -148,7 +148,7 @@ public:
     return {it->second, {}};
   }
 
-  Ref<IpmiServer> findIpmiServer(std::string_view name) {
+  rx::Ref<IpmiServer> findIpmiServer(std::string_view name) {
     std::lock_guard lock(m_sem_mtx);
     if (auto it = mIpmiServers.find(name); it != mIpmiServers.end()) {
       return it->second;
@@ -191,20 +191,20 @@ public:
     return getUmtxChainIndexed(1, t, flags, ptr);
   }
 
-  Ref<EventEmitter> deviceEventEmitter;
-  Ref<RcBase> shmDevice;
-  Ref<RcBase> dmemDevice;
-  Ref<RcBase> blockpoolDevice;
-  Ref<RcBase> gpuDevice;
-  Ref<RcBase> dceDevice;
+  rx::Ref<EventEmitter> deviceEventEmitter;
+  rx::Ref<rx::RcBase> shmDevice;
+  rx::Ref<rx::RcBase> dmemDevice;
+  rx::Ref<rx::RcBase> blockpoolDevice;
+  rx::Ref<rx::RcBase> gpuDevice;
+  rx::Ref<rx::RcBase> dceDevice;
   rx::shared_mutex gpuDeviceMtx;
   uint sdkVersion{};
   uint fwSdkVersion{};
   uint safeMode{};
-  utils::RcIdMap<RcBase, sint, 4097, 1> ipmiMap;
-  RcIdMap<RcAppInfo> appInfos;
-  RcIdMap<Budget, sint, 4097, 1> budgets;
-  Ref<Budget> processTypeBudgets[4];
+  rx::RcIdMap<rx::RcBase, sint, 4097, 1> ipmiMap;
+  rx::RcIdMap<RcAppInfo> appInfos;
+  rx::RcIdMap<Budget, sint, 4097, 1> budgets;
+  rx::Ref<Budget> processTypeBudgets[4];
 
   rx::shared_mutex regMgrMtx;
   kmap<std::uint32_t, std::uint32_t> regMgrInt;
@@ -213,7 +213,7 @@ public:
   FwType fwType = FwType::Unknown;
   bool isDevKit = false;
 
-  Ref<Budget> createProcessTypeBudget(Budget::ProcessType processType,
+  rx::Ref<Budget> createProcessTypeBudget(Budget::ProcessType processType,
                                       std::string_view name,
                                       std::span<const BudgetInfo> items) {
     auto budget = orbis::knew<orbis::Budget>(name, processType, items);
@@ -222,7 +222,7 @@ public:
     return budget;
   }
 
-  Ref<Budget> getProcessTypeBudget(Budget::ProcessType processType) {
+  rx::Ref<Budget> getProcessTypeBudget(Budget::ProcessType processType) {
     return processTypeBudgets[static_cast<int>(processType)];
   }
 
@@ -239,18 +239,18 @@ private:
   std::atomic<long> m_tsc_freq{0};
 
   rx::shared_mutex m_thread_id_mtx;
-  OwningIdMap<char, long, 256, 0> m_thread_id_map;
+  rx::OwningIdMap<char, long, 256, 0> m_thread_id_map;
   mutable rx::shared_mutex m_proc_mtx;
-  utils::LinkedNode<Process> *m_processes = nullptr;
+  rx::LinkedNode<Process> *m_processes = nullptr;
 
   rx::shared_mutex m_evf_mtx;
-  utils::kmap<utils::kstring, Ref<EventFlag>> m_event_flags;
+  utils::kmap<utils::kstring, rx::Ref<EventFlag>> m_event_flags;
 
   rx::shared_mutex m_sem_mtx;
-  utils::kmap<utils::kstring, Ref<Semaphore>> m_semaphores;
+  utils::kmap<utils::kstring, rx::Ref<Semaphore>> m_semaphores;
 
   rx::shared_mutex mIpmiServerMtx;
-  utils::kmap<utils::kstring, Ref<IpmiServer>> mIpmiServers;
+  utils::kmap<utils::kstring, rx::Ref<IpmiServer>> mIpmiServers;
 
   rx::shared_mutex m_kenv_mtx;
   utils::kmap<utils::kstring, char[128]> m_kenv; // max size: 127 + '\0'
diff --git a/kernel/orbis/include/orbis/evf.hpp b/kernel/orbis/include/orbis/evf.hpp
index bdc23ca52..b9536a173 100644
--- a/kernel/orbis/include/orbis/evf.hpp
+++ b/kernel/orbis/include/orbis/evf.hpp
@@ -1,7 +1,7 @@
 #pragma once
 #include "KernelAllocator.hpp"
-#include "thread/Thread.hpp"
 #include "rx/SharedMutex.hpp"
+#include "thread/Thread.hpp"
 #include <atomic>
 
 namespace orbis {
diff --git a/kernel/orbis/include/orbis/file.hpp b/kernel/orbis/include/orbis/file.hpp
index 39ec19882..515769cdf 100644
--- a/kernel/orbis/include/orbis/file.hpp
+++ b/kernel/orbis/include/orbis/file.hpp
@@ -5,7 +5,7 @@
 #include "note.hpp"
 #include "rx/SharedMutex.hpp"
 #include "stat.hpp"
-#include "utils/Rc.hpp"
+#include "rx/Rc.hpp"
 #include <cstdint>
 
 namespace orbis {
@@ -73,11 +73,11 @@ struct FileOps {
                         Thread *thread) = nullptr;
 };
 
-struct File : RcBase {
+struct File : rx::RcBase {
   rx::shared_mutex mtx;
-  Ref<EventEmitter> event;
+  rx::Ref<EventEmitter> event;
   const FileOps *ops = nullptr;
-  Ref<RcBase> device;
+  rx::Ref<RcBase> device;
   std::uint64_t nextOff = 0;
   int flags = 0;
   int mode = 0;
diff --git a/kernel/orbis/include/orbis/ipmi.hpp b/kernel/orbis/include/orbis/ipmi.hpp
index 6411630fc..b7de7a149 100644
--- a/kernel/orbis/include/orbis/ipmi.hpp
+++ b/kernel/orbis/include/orbis/ipmi.hpp
@@ -5,7 +5,7 @@
 #include "orbis-config.hpp"
 #include "rx/SharedCV.hpp"
 #include "rx/SharedMutex.hpp"
-#include "utils/Rc.hpp"
+#include "rx/Rc.hpp"
 #include <list>
 #include <optional>
 
@@ -14,7 +14,7 @@ struct IpmiSession;
 struct IpmiClient;
 struct Thread;
 
-struct IpmiServer : RcBase {
+struct IpmiServer : rx::RcBase {
   struct IpmiPacketInfo {
     ulong inputSize;
     uint type;
@@ -27,12 +27,12 @@ struct IpmiServer : RcBase {
   struct Packet {
     IpmiPacketInfo info;
     lwpid_t clientTid;
-    Ref<IpmiSession> session;
+    rx::Ref<IpmiSession> session;
     kvector<std::byte> message;
   };
 
   struct ConnectionRequest {
-    Ref<IpmiClient> client;
+    rx::Ref<IpmiClient> client;
     slong clientTid{};
     slong clientPid{};
     slong serverTid{};
@@ -53,7 +53,7 @@ struct IpmiServer : RcBase {
   explicit IpmiServer(kstring name) : name(std::move(name)) {}
 };
 
-struct IpmiClient : RcBase {
+struct IpmiClient : rx::RcBase {
   struct MessageQueue {
     rx::shared_cv messageCv;
     kdeque<kvector<std::byte>> messages;
@@ -68,7 +68,7 @@ struct IpmiClient : RcBase {
   kstring name;
   ptr<void> clientImpl;
   ptr<void> userData;
-  Ref<IpmiSession> session;
+  rx::Ref<IpmiSession> session;
   rx::shared_mutex mutex;
   rx::shared_cv sessionCv;
   rx::shared_cv asyncResponseCv;
@@ -82,7 +82,7 @@ struct IpmiClient : RcBase {
   explicit IpmiClient(kstring name) : name(std::move(name)) {}
 };
 
-struct IpmiSession : RcBase {
+struct IpmiSession : rx::RcBase {
   struct SyncResponse {
     sint errorCode;
     std::uint32_t callerTid;
@@ -91,8 +91,8 @@ struct IpmiSession : RcBase {
 
   ptr<void> sessionImpl;
   ptr<void> userData;
-  Ref<IpmiClient> client;
-  Ref<IpmiServer> server;
+  rx::Ref<IpmiClient> client;
+  rx::Ref<IpmiServer> server;
   rx::shared_mutex mutex;
   rx::shared_cv responseCv;
   kdeque<SyncResponse> syncResponses;
@@ -185,12 +185,12 @@ static_assert(sizeof(IpmiClientConnectParams) == 0x20);
 
 ErrorCode ipmiCreateClient(Process *proc, void *clientImpl, const char *name,
                            const IpmiCreateClientConfig &config,
-                           Ref<IpmiClient> &result);
+                           rx::Ref<IpmiClient> &result);
 ErrorCode ipmiCreateServer(Process *proc, void *serverImpl, const char *name,
                            const IpmiCreateServerConfig &config,
-                           Ref<IpmiServer> &result);
+                           rx::Ref<IpmiServer> &result);
 ErrorCode ipmiCreateSession(Thread *thread, void *sessionImpl,
-                            ptr<void> userData, Ref<IpmiSession> &result);
+                            ptr<void> userData, rx::Ref<IpmiSession> &result);
 
 SysResult sysIpmiCreateClient(Thread *thread, ptr<uint> result,
                               ptr<void> params, uint64_t paramsSz);
diff --git a/kernel/orbis/include/orbis/module/Module.hpp b/kernel/orbis/include/orbis/module/Module.hpp
index 8758d39a8..b1f30f84b 100644
--- a/kernel/orbis/include/orbis/module/Module.hpp
+++ b/kernel/orbis/include/orbis/module/Module.hpp
@@ -4,12 +4,10 @@
 #include "ModuleSegment.hpp"
 
 #include "../KernelAllocator.hpp"
-#include "../utils/Rc.hpp"
+#include "rx/Rc.hpp"
 
 #include "orbis-config.hpp"
-#include <cstddef>
 #include <string>
-#include <vector>
 
 namespace orbis {
 struct Thread;
@@ -118,16 +116,13 @@ struct Module final {
   utils::kvector<Relocation> nonPltRelocations;
   utils::kvector<ModuleNeeded> neededModules;
   utils::kvector<ModuleNeeded> neededLibraries;
-  utils::kvector<utils::Ref<Module>> importedModules;
-  utils::kvector<utils::Ref<Module>> namespaceModules;
+  utils::kvector<rx::Ref<Module>> importedModules;
+  utils::kvector<rx::Ref<Module>> namespaceModules;
   utils::kvector<utils::kstring> needed;
 
   std::atomic<unsigned> references{0};
-  unsigned _total_size = 0;
 
   void incRef() {
-    if (_total_size != sizeof(Module))
-      std::abort();
     if (references.fetch_add(1, std::memory_order::relaxed) > 512) {
       assert(!"too many references");
     }
@@ -142,10 +137,11 @@ struct Module final {
 
   orbis::SysResult relocate(Process *process);
 
+  void operator delete(void *pointer);
+
 private:
   void destroy();
 };
 
-utils::Ref<Module> createModule(Thread *p, std::string vfsPath,
-                                const char *name);
+rx::Ref<Module> createModule(Thread *p, std::string vfsPath, const char *name);
 } // namespace orbis
diff --git a/kernel/orbis/include/orbis/note.hpp b/kernel/orbis/include/orbis/note.hpp
index 01612f535..1c7208eed 100644
--- a/kernel/orbis/include/orbis/note.hpp
+++ b/kernel/orbis/include/orbis/note.hpp
@@ -2,7 +2,7 @@
 
 #include "KernelAllocator.hpp"
 #include "orbis-config.hpp"
-#include "orbis/utils/Rc.hpp"
+#include "rx/Rc.hpp"
 #include "rx/SharedMutex.hpp"
 #include <limits>
 #include <set>
@@ -77,17 +77,17 @@ struct KQueue;
 struct KNote {
   rx::shared_mutex mutex;
   KQueue *queue;
-  Ref<File> file;
+  rx::Ref<File> file;
   KEvent event{};
   bool enabled = true;
   bool triggered = false;
-  void *linked = nullptr; // TODO: use Ref<>
-  kvector<Ref<EventEmitter>> emitters;
+  void *linked = nullptr; // TODO: use rx::Ref<>
+  kvector<rx::Ref<EventEmitter>> emitters;
 
   ~KNote();
 };
 
-struct EventEmitter : orbis::RcBase {
+struct EventEmitter : rx::RcBase {
   rx::shared_mutex mutex;
   std::set<KNote *, std::less<>, kallocator<KNote *>> notes;
 
diff --git a/kernel/orbis/include/orbis/pipe.hpp b/kernel/orbis/include/orbis/pipe.hpp
index 0043da543..985141cdb 100644
--- a/kernel/orbis/include/orbis/pipe.hpp
+++ b/kernel/orbis/include/orbis/pipe.hpp
@@ -4,15 +4,15 @@
 #include "file.hpp"
 #include "rx/SharedCV.hpp"
 #include "rx/SharedMutex.hpp"
-#include "utils/Rc.hpp"
+#include "rx/Rc.hpp"
 #include <utility>
 
 namespace orbis {
-struct Pipe final : File {
+struct Pipe : File {
   rx::shared_cv cv;
   kvector<std::byte> data;
-  Ref<Pipe> other;
+  rx::Ref<Pipe> other;
 };
 
-std::pair<Ref<Pipe>, Ref<Pipe>> createPipe();
+std::pair<rx::Ref<Pipe>, rx::Ref<Pipe>> createPipe();
 } // namespace orbis
diff --git a/kernel/orbis/include/orbis/thread/Process.hpp b/kernel/orbis/include/orbis/thread/Process.hpp
index a218359c8..ac9c296db 100644
--- a/kernel/orbis/include/orbis/thread/Process.hpp
+++ b/kernel/orbis/include/orbis/thread/Process.hpp
@@ -14,7 +14,7 @@
 #include "orbis/Budget.hpp"
 #include "orbis/file.hpp"
 #include "orbis/module/Module.hpp"
-#include "orbis/utils/IdMap.hpp"
+#include "rx/IdMap.hpp"
 #include "rx/SharedMutex.hpp"
 #include <optional>
 
@@ -85,16 +85,16 @@ struct Process final {
   std::uint64_t nextTlsSlot = 1;
   std::uint64_t lastTlsOffset = 0;
 
-  utils::RcIdMap<EventFlag, sint, 4097, 1> evfMap;
-  utils::RcIdMap<Semaphore, sint, 4097, 1> semMap;
-  utils::RcIdMap<Module, ModuleHandle> modulesMap;
-  utils::OwningIdMap<Thread, lwpid_t> threadsMap;
-  utils::RcIdMap<orbis::File, sint> fileDescriptors;
+  rx::RcIdMap<EventFlag, sint, 4097, 1> evfMap;
+  rx::RcIdMap<Semaphore, sint, 4097, 1> semMap;
+  rx::RcIdMap<Module, ModuleHandle> modulesMap;
+  rx::OwningIdMap<Thread, lwpid_t> threadsMap;
+  rx::RcIdMap<orbis::File, sint> fileDescriptors;
 
   // Named objects for debugging
   rx::shared_mutex namedObjMutex;
   utils::kmap<void *, utils::kstring> namedObjNames;
-  utils::OwningIdMap<NamedObjInfo, uint, 65535, 1> namedObjIds;
+  rx::OwningIdMap<NamedObjInfo, uint, 65535, 1> namedObjIds;
 
   utils::kmap<std::int32_t, SigAction> sigActions;
 
diff --git a/kernel/orbis/include/orbis/thread/ProcessOps.hpp b/kernel/orbis/include/orbis/thread/ProcessOps.hpp
index 527d77767..717fb8c55 100644
--- a/kernel/orbis/include/orbis/thread/ProcessOps.hpp
+++ b/kernel/orbis/include/orbis/thread/ProcessOps.hpp
@@ -3,7 +3,7 @@
 #include "../module/ModuleHandle.hpp"
 #include "../thread/types.hpp"
 #include "orbis-config.hpp"
-#include "orbis/utils/Rc.hpp"
+#include "rx/Rc.hpp"
 
 namespace orbis {
 struct Thread;
@@ -39,21 +39,21 @@ struct ProcessOps {
                                        ptr<MemoryProtection> protection);
 
   SysResult (*open)(Thread *thread, ptr<const char> path, sint flags, sint mode,
-                    Ref<File> *file);
+                    rx::Ref<File> *file);
   SysResult (*shm_open)(Thread *thread, const char *path, sint flags, sint mode,
-                        Ref<File> *file);
+                        rx::Ref<File> *file);
   SysResult (*unlink)(Thread *thread, ptr<const char> path);
   SysResult (*mkdir)(Thread *thread, ptr<const char> path, sint mode);
   SysResult (*rmdir)(Thread *thread, ptr<const char> path);
   SysResult (*rename)(Thread *thread, ptr<const char> from, ptr<const char> to);
-  SysResult (*blockpool_open)(Thread *thread, Ref<File> *file);
+  SysResult (*blockpool_open)(Thread *thread, rx::Ref<File> *file);
   SysResult (*blockpool_map)(Thread *thread, caddr_t addr, size_t len,
                              sint prot, sint flags);
   SysResult (*blockpool_unmap)(Thread *thread, caddr_t addr, size_t len);
   SysResult (*socket)(Thread *thread, ptr<const char> name, sint domain,
-                      sint type, sint protocol, Ref<File> *file);
+                      sint type, sint protocol, rx::Ref<File> *file);
   SysResult (*socketpair)(Thread *thread, sint domain, sint type, sint protocol,
-                          Ref<File> *a, Ref<File> *b);
+                          rx::Ref<File> *a, rx::Ref<File> *b);
   SysResult (*shm_unlink)(Thread *thread, const char *path);
   SysResult (*dynlib_get_obj_member)(Thread *thread, ModuleHandle handle,
                                      uint64_t index, ptr<ptr<void>> addrp);
diff --git a/kernel/orbis/include/orbis/utils/AtomicOp.hpp b/kernel/orbis/include/orbis/utils/AtomicOp.hpp
deleted file mode 100644
index be6c7849a..000000000
--- a/kernel/orbis/include/orbis/utils/AtomicOp.hpp
+++ /dev/null
@@ -1,74 +0,0 @@
-#pragma once
-
-#include <atomic>
-#include <functional>
-#include <utility>
-
-namespace orbis {
-inline namespace utils {
-// Atomic operation; returns old value, or pair of old value and return value
-// (cancel op if evaluates to false)
-template <typename T, typename F, typename RT = std::invoke_result_t<F, T &>>
-inline std::conditional_t<std::is_void_v<RT>, T, std::pair<T, RT>>
-atomic_fetch_op(std::atomic<T> &v, F func) {
-  T _new, old = v.load();
-  while (true) {
-    _new = old;
-    if constexpr (std::is_void_v<RT>) {
-      std::invoke(func, _new);
-      if (v.compare_exchange_strong(old, _new)) [[likely]] {
-        return old;
-      }
-    } else {
-      RT ret = std::invoke(func, _new);
-      if (!ret || v.compare_exchange_strong(old, _new)) [[likely]] {
-        return {old, std::move(ret)};
-      }
-    }
-  }
-}
-
-// Atomic operation; returns function result value, function is the lambda
-template <typename T, typename F, typename RT = std::invoke_result_t<F, T &>>
-inline RT atomic_op(std::atomic<T> &v, F func) {
-  T _new, old = v.load();
-  while (true) {
-    _new = old;
-    if constexpr (std::is_void_v<RT>) {
-      std::invoke(func, _new);
-      if (v.compare_exchange_strong(old, _new)) [[likely]] {
-        return;
-      }
-    } else {
-      RT result = std::invoke(func, _new);
-      if (v.compare_exchange_strong(old, _new)) [[likely]] {
-        return result;
-      }
-    }
-  }
-}
-
-#if defined(__ATOMIC_HLE_ACQUIRE) && defined(__ATOMIC_HLE_RELEASE)
-static constexpr int s_hle_ack = __ATOMIC_SEQ_CST | __ATOMIC_HLE_ACQUIRE;
-static constexpr int s_hle_rel = __ATOMIC_SEQ_CST | __ATOMIC_HLE_RELEASE;
-#else
-static constexpr int s_hle_ack = __ATOMIC_SEQ_CST;
-static constexpr int s_hle_rel = __ATOMIC_SEQ_CST;
-#endif
-
-template <typename T>
-inline bool compare_exchange_hle_acq(std::atomic<T> &dest, T &comp, T exch) {
-  static_assert(sizeof(T) == 4 || sizeof(T) == 8);
-  static_assert(std::atomic<T>::is_always_lock_free);
-  return __atomic_compare_exchange(reinterpret_cast<T *>(&dest), &comp, &exch,
-                                   false, s_hle_ack, s_hle_ack);
-}
-
-template <typename T>
-inline T fetch_add_hle_rel(std::atomic<T> &dest, T value) {
-  static_assert(sizeof(T) == 4 || sizeof(T) == 8);
-  static_assert(std::atomic<T>::is_always_lock_free);
-  return __atomic_fetch_add(reinterpret_cast<T *>(&dest), value, s_hle_rel);
-}
-} // namespace utils
-} // namespace orbis
diff --git a/kernel/orbis/src/KernelContext.cpp b/kernel/orbis/src/KernelContext.cpp
index bc305611e..e8ef309f7 100644
--- a/kernel/orbis/src/KernelContext.cpp
+++ b/kernel/orbis/src/KernelContext.cpp
@@ -51,7 +51,7 @@ KernelContext::KernelContext() {
 KernelContext::~KernelContext() {}
 
 Process *KernelContext::createProcess(pid_t pid) {
-  auto newProcess = knew<utils::LinkedNode<Process>>();
+  auto newProcess = knew<rx::LinkedNode<Process>>();
   newProcess->object.context = this;
   newProcess->object.pid = pid;
   newProcess->object.state = ProcessState::NEW;
@@ -69,7 +69,7 @@ Process *KernelContext::createProcess(pid_t pid) {
 }
 
 void KernelContext::deleteProcess(Process *proc) {
-  auto procNode = reinterpret_cast<utils::LinkedNode<Process> *>(proc);
+  auto procNode = reinterpret_cast<rx::LinkedNode<Process> *>(proc);
 
   {
     std::lock_guard lock(m_proc_mtx);
diff --git a/kernel/orbis/src/ipmi.cpp b/kernel/orbis/src/ipmi.cpp
index 3271f1dba..fe56efe54 100644
--- a/kernel/orbis/src/ipmi.cpp
+++ b/kernel/orbis/src/ipmi.cpp
@@ -10,7 +10,7 @@
 orbis::ErrorCode orbis::ipmiCreateClient(Process *proc, void *clientImpl,
                                          const char *name,
                                          const IpmiCreateClientConfig &config,
-                                         Ref<IpmiClient> &result) {
+                                         rx::Ref<IpmiClient> &result) {
   auto client = knew<IpmiClient>(name);
   if (client == nullptr) {
     return ErrorCode::NOMEM;
@@ -29,7 +29,7 @@ orbis::ErrorCode orbis::ipmiCreateClient(Process *proc, void *clientImpl,
 orbis::ErrorCode orbis::ipmiCreateServer(Process *proc, void *serverImpl,
                                          const char *name,
                                          const IpmiCreateServerConfig &config,
-                                         Ref<IpmiServer> &result) {
+                                         rx::Ref<IpmiServer> &result) {
   auto [server, errorCode] = g_context.createIpmiServer(name);
   ORBIS_RET_ON_ERROR(errorCode);
 
@@ -43,7 +43,7 @@ orbis::ErrorCode orbis::ipmiCreateServer(Process *proc, void *serverImpl,
 
 orbis::ErrorCode orbis::ipmiCreateSession(Thread *thread, void *sessionImpl,
                                           ptr<void> userData,
-                                          Ref<IpmiSession> &result) {
+                                          rx::Ref<IpmiSession> &result) {
   std::unique_lock ipmiMapLock(g_context.ipmiMap.mutex);
 
   for (auto [kid, obj] : g_context.ipmiMap) {
@@ -96,7 +96,7 @@ orbis::SysResult orbis::sysIpmiCreateClient(Thread *thread, ptr<uint> result,
   IpmiCreateClientParams _params;
   IpmiCreateClientConfig _config;
   char _name[25];
-  Ref<IpmiClient> client;
+  rx::Ref<IpmiClient> client;
 
   ORBIS_RET_ON_ERROR(uread(_params, ptr<IpmiCreateClientParams>(params)));
   ORBIS_RET_ON_ERROR(uread(_config, _params.config));
@@ -132,7 +132,7 @@ orbis::SysResult orbis::sysIpmiCreateServer(Thread *thread, ptr<uint> result,
   IpmiCreateServerParams _params;
   IpmiCreateServerConfig _config;
   char _name[25];
-  Ref<IpmiServer> server;
+  rx::Ref<IpmiServer> server;
 
   ORBIS_RET_ON_ERROR(uread(_params, ptr<IpmiCreateServerParams>(params)));
   ORBIS_RET_ON_ERROR(uread(_config, _params.config));
@@ -172,7 +172,7 @@ orbis::SysResult orbis::sysIpmiCreateSession(Thread *thread, ptr<uint> result,
 
   IpmiCreateSessionParams _params;
   IpmiSessionUserData _userData;
-  Ref<IpmiSession> session;
+  rx::Ref<IpmiSession> session;
 
   ORBIS_RET_ON_ERROR(uread(_params, ptr<IpmiCreateSessionParams>(params)));
   ORBIS_RET_ON_ERROR(uread(_userData, _params.userData));
@@ -306,7 +306,7 @@ orbis::SysResult orbis::sysIpmiSendConnectResult(Thread *thread,
     return ErrorCode::INVAL;
   }
 
-  Ref<IpmiClient> client;
+  rx::Ref<IpmiClient> client;
   if (auto result = ipmiObject.cast<IpmiSession>()) {
     client = result->client;
   } else if (auto result = ipmiObject.cast<IpmiClient>()) {
diff --git a/kernel/orbis/src/module.cpp b/kernel/orbis/src/module.cpp
index 8d002ab5b..f1266d1db 100644
--- a/kernel/orbis/src/module.cpp
+++ b/kernel/orbis/src/module.cpp
@@ -409,6 +409,10 @@ orbis::SysResult orbis::Module::relocate(Process *process) {
   return {};
 }
 
+void orbis::Module::operator delete(void *pointer) {
+  kfree(pointer, sizeof(orbis::Module));
+}
+
 void orbis::Module::destroy() {
   std::lock_guard lock(proc->mtx);
   proc->modulesMap.close(id);
diff --git a/kernel/orbis/src/pipe.cpp b/kernel/orbis/src/pipe.cpp
index 21577b823..36aa60587 100644
--- a/kernel/orbis/src/pipe.cpp
+++ b/kernel/orbis/src/pipe.cpp
@@ -81,7 +81,7 @@ static orbis::FileOps pipe_ops = {
     .write = pipe_write,
 };
 
-std::pair<orbis::Ref<orbis::Pipe>, orbis::Ref<orbis::Pipe>>
+std::pair<rx::Ref<orbis::Pipe>, rx::Ref<orbis::Pipe>>
 orbis::createPipe() {
   auto a = knew<Pipe>();
   auto b = knew<Pipe>();
diff --git a/kernel/orbis/src/sys/sys_descrip.cpp b/kernel/orbis/src/sys/sys_descrip.cpp
index 55ae68bf8..b2a2b9439 100644
--- a/kernel/orbis/src/sys/sys_descrip.cpp
+++ b/kernel/orbis/src/sys/sys_descrip.cpp
@@ -44,7 +44,7 @@ orbis::SysResult orbis::sys_closefrom(Thread *thread, sint lowfd) {
   return ErrorCode::NOSYS;
 }
 orbis::SysResult orbis::sys_fstat(Thread *thread, sint fd, ptr<Stat> ub) {
-  Ref<File> file = thread->tproc->fileDescriptors.get(fd);
+  rx::Ref<File> file = thread->tproc->fileDescriptors.get(fd);
   if (file == nullptr) {
     return ErrorCode::BADF;
   }
diff --git a/kernel/orbis/src/sys/sys_generic.cpp b/kernel/orbis/src/sys/sys_generic.cpp
index c56cf6735..97c1d9f01 100644
--- a/kernel/orbis/src/sys/sys_generic.cpp
+++ b/kernel/orbis/src/sys/sys_generic.cpp
@@ -8,7 +8,7 @@
 
 orbis::SysResult orbis::sys_read(Thread *thread, sint fd, ptr<void> buf,
                                  size_t nbyte) {
-  Ref<File> file = thread->tproc->fileDescriptors.get(fd);
+  rx::Ref<File> file = thread->tproc->fileDescriptors.get(fd);
   if (file == nullptr) {
     return ErrorCode::BADF;
   }
@@ -49,7 +49,7 @@ orbis::SysResult orbis::sys_read(Thread *thread, sint fd, ptr<void> buf,
 orbis::SysResult orbis::sys_pread(Thread *thread, sint fd, ptr<void> buf,
                                   size_t nbyte, off_t offset) {
   // ORBIS_LOG_ERROR(__FUNCTION__, fd, buf, nbyte, offset);
-  Ref<File> file = thread->tproc->fileDescriptors.get(fd);
+  rx::Ref<File> file = thread->tproc->fileDescriptors.get(fd);
   if (file == nullptr) {
     return ErrorCode::BADF;
   }
@@ -86,7 +86,7 @@ orbis::SysResult orbis::sys_freebsd6_pread(Thread *thread, sint fd,
 }
 orbis::SysResult orbis::sys_readv(Thread *thread, sint fd, ptr<IoVec> iovp,
                                   uint iovcnt) {
-  Ref<File> file = thread->tproc->fileDescriptors.get(fd);
+  rx::Ref<File> file = thread->tproc->fileDescriptors.get(fd);
   if (file == nullptr) {
     return ErrorCode::BADF;
   }
@@ -119,7 +119,7 @@ orbis::SysResult orbis::sys_readv(Thread *thread, sint fd, ptr<IoVec> iovp,
 }
 orbis::SysResult orbis::sys_preadv(Thread *thread, sint fd, ptr<IoVec> iovp,
                                    uint iovcnt, off_t offset) {
-  Ref<File> file = thread->tproc->fileDescriptors.get(fd);
+  rx::Ref<File> file = thread->tproc->fileDescriptors.get(fd);
   if (file == nullptr) {
     return ErrorCode::BADF;
   }
@@ -150,7 +150,7 @@ orbis::SysResult orbis::sys_preadv(Thread *thread, sint fd, ptr<IoVec> iovp,
 }
 orbis::SysResult orbis::sys_write(Thread *thread, sint fd, ptr<const void> buf,
                                   size_t nbyte) {
-  Ref<File> file = thread->tproc->fileDescriptors.get(fd);
+  rx::Ref<File> file = thread->tproc->fileDescriptors.get(fd);
   if (file == nullptr) {
     return ErrorCode::BADF;
   }
@@ -185,7 +185,7 @@ orbis::SysResult orbis::sys_write(Thread *thread, sint fd, ptr<const void> buf,
 }
 orbis::SysResult orbis::sys_pwrite(Thread *thread, sint fd, ptr<const void> buf,
                                    size_t nbyte, off_t offset) {
-  Ref<File> file = thread->tproc->fileDescriptors.get(fd);
+  rx::Ref<File> file = thread->tproc->fileDescriptors.get(fd);
   if (file == nullptr) {
     return ErrorCode::BADF;
   }
@@ -222,7 +222,7 @@ orbis::SysResult orbis::sys_freebsd6_pwrite(Thread *thread, sint fd,
 }
 orbis::SysResult orbis::sys_writev(Thread *thread, sint fd, ptr<IoVec> iovp,
                                    uint iovcnt) {
-  Ref<File> file = thread->tproc->fileDescriptors.get(fd);
+  rx::Ref<File> file = thread->tproc->fileDescriptors.get(fd);
   if (file == nullptr) {
     return ErrorCode::BADF;
   }
@@ -256,7 +256,7 @@ orbis::SysResult orbis::sys_writev(Thread *thread, sint fd, ptr<IoVec> iovp,
 }
 orbis::SysResult orbis::sys_pwritev(Thread *thread, sint fd, ptr<IoVec> iovp,
                                     uint iovcnt, off_t offset) {
-  Ref<File> file = thread->tproc->fileDescriptors.get(fd);
+  rx::Ref<File> file = thread->tproc->fileDescriptors.get(fd);
   if (file == nullptr) {
     return ErrorCode::BADF;
   }
@@ -285,7 +285,7 @@ orbis::SysResult orbis::sys_pwritev(Thread *thread, sint fd, ptr<IoVec> iovp,
   return {};
 }
 orbis::SysResult orbis::sys_ftruncate(Thread *thread, sint fd, off_t length) {
-  Ref<File> file = thread->tproc->fileDescriptors.get(fd);
+  rx::Ref<File> file = thread->tproc->fileDescriptors.get(fd);
   if (file == nullptr) {
     return ErrorCode::BADF;
   }
@@ -426,7 +426,7 @@ orbis::SysResult orbis::sys_ioctl(Thread *thread, sint fd, ulong com,
                                   caddr_t data) {
   auto str = ioctlToString(com);
   // ORBIS_LOG_WARNING(__FUNCTION__, fd, com, str);
-  Ref<File> file = thread->tproc->fileDescriptors.get(fd);
+  rx::Ref<File> file = thread->tproc->fileDescriptors.get(fd);
   if (file == nullptr) {
     return ErrorCode::BADF;
   }
diff --git a/kernel/orbis/src/sys/sys_sce.cpp b/kernel/orbis/src/sys/sys_sce.cpp
index 420e8f5bd..9ae80777e 100644
--- a/kernel/orbis/src/sys/sys_sce.cpp
+++ b/kernel/orbis/src/sys/sys_sce.cpp
@@ -44,7 +44,7 @@ orbis::SysResult orbis::sys_socketex(Thread *thread, ptr<const char> name,
                                      sint domain, sint type, sint protocol) {
   ORBIS_LOG_TODO(__FUNCTION__, name, domain, type, protocol);
   if (auto socket = thread->tproc->ops->socket) {
-    Ref<File> file;
+    rx::Ref<File> file;
     auto result = socket(thread, name, domain, type, protocol, &file);
 
     if (result.isError()) {
@@ -250,7 +250,7 @@ orbis::SysResult orbis::sys_evf_create(Thread *thread, ptr<const char[32]> name,
 }
 orbis::SysResult orbis::sys_evf_delete(Thread *thread, sint id) {
   ORBIS_LOG_WARNING(__FUNCTION__, id);
-  Ref<EventFlag> evf = thread->tproc->evfMap.get(id);
+  rx::Ref<EventFlag> evf = thread->tproc->evfMap.get(id);
   if (evf == nullptr) {
     return ErrorCode::NOENT;
   }
@@ -298,7 +298,7 @@ orbis::SysResult orbis::sys_evf_wait(Thread *thread, sint id,
     return ErrorCode::INVAL;
   }
 
-  Ref<EventFlag> evf = thread->tproc->evfMap.get(id);
+  rx::Ref<EventFlag> evf = thread->tproc->evfMap.get(id);
 
   if (evf == nullptr) {
     return ErrorCode::SRCH;
@@ -336,7 +336,7 @@ orbis::SysResult orbis::sys_evf_trywait(Thread *thread, sint id,
     return ErrorCode::INVAL;
   }
 
-  Ref<EventFlag> evf = thread->tproc->evfMap.get(id);
+  rx::Ref<EventFlag> evf = thread->tproc->evfMap.get(id);
 
   if (evf == nullptr) {
     return ErrorCode::SRCH;
@@ -356,7 +356,7 @@ orbis::SysResult orbis::sys_evf_trywait(Thread *thread, sint id,
   return result;
 }
 orbis::SysResult orbis::sys_evf_set(Thread *thread, sint id, uint64_t value) {
-  Ref<EventFlag> evf = thread->tproc->evfMap.get(id);
+  rx::Ref<EventFlag> evf = thread->tproc->evfMap.get(id);
 
   if (evf == nullptr) {
     return ErrorCode::SRCH;
@@ -367,7 +367,7 @@ orbis::SysResult orbis::sys_evf_set(Thread *thread, sint id, uint64_t value) {
   return {};
 }
 orbis::SysResult orbis::sys_evf_clear(Thread *thread, sint id, uint64_t value) {
-  Ref<EventFlag> evf = thread->tproc->evfMap.get(id);
+  rx::Ref<EventFlag> evf = thread->tproc->evfMap.get(id);
 
   if (evf == nullptr) {
     return ErrorCode::SRCH;
@@ -379,7 +379,7 @@ orbis::SysResult orbis::sys_evf_clear(Thread *thread, sint id, uint64_t value) {
 }
 orbis::SysResult orbis::sys_evf_cancel(Thread *thread, sint id, uint64_t value,
                                        ptr<sint> pNumWaitThreads) {
-  Ref<EventFlag> evf = thread->tproc->evfMap.get(id);
+  rx::Ref<EventFlag> evf = thread->tproc->evfMap.get(id);
 
   if (evf == nullptr) {
     return ErrorCode::SRCH;
@@ -522,7 +522,7 @@ orbis::SysResult orbis::sys_osem_create(Thread *thread,
 }
 orbis::SysResult orbis::sys_osem_delete(Thread *thread, sint id) {
   ORBIS_LOG_TRACE(__FUNCTION__, id);
-  Ref<Semaphore> sem = thread->tproc->semMap.get(id);
+  rx::Ref<Semaphore> sem = thread->tproc->semMap.get(id);
   if (sem == nullptr) {
     return ErrorCode::NOENT;
   }
@@ -558,7 +558,7 @@ orbis::SysResult orbis::sys_osem_close(Thread *thread, sint id) {
 orbis::SysResult orbis::sys_osem_wait(Thread *thread, sint id, sint need,
                                       ptr<uint> pTimeout) {
   ORBIS_LOG_TRACE(__FUNCTION__, thread, id, need, pTimeout);
-  Ref<Semaphore> sem = thread->tproc->semMap.get(id);
+  rx::Ref<Semaphore> sem = thread->tproc->semMap.get(id);
   if (sem == nullptr) {
     return ErrorCode::BADF;
   }
@@ -624,7 +624,7 @@ orbis::SysResult orbis::sys_osem_wait(Thread *thread, sint id, sint need,
 }
 orbis::SysResult orbis::sys_osem_trywait(Thread *thread, sint id, sint need) {
   ORBIS_LOG_TRACE(__FUNCTION__, thread, id, need);
-  Ref<Semaphore> sem = thread->tproc->semMap.get(id);
+  rx::Ref<Semaphore> sem = thread->tproc->semMap.get(id);
   if (sem == nullptr) {
     return ErrorCode::BADF;
   }
@@ -641,7 +641,7 @@ orbis::SysResult orbis::sys_osem_trywait(Thread *thread, sint id, sint need) {
 }
 orbis::SysResult orbis::sys_osem_post(Thread *thread, sint id, sint count) {
   ORBIS_LOG_TRACE(__FUNCTION__, thread, id, count);
-  Ref<Semaphore> sem = thread->tproc->semMap.get(id);
+  rx::Ref<Semaphore> sem = thread->tproc->semMap.get(id);
   if (sem == nullptr) {
     return ErrorCode::BADF;
   }
@@ -802,7 +802,7 @@ orbis::SysResult orbis::sys_budget_create(Thread *thread, ptr<char> name,
     return ErrorCode::PERM;
   }
 
-  orbis::Ref budget =
+  rx::Ref budget =
       orbis::knew<Budget>(_name, processType, std::span(_resources, count));
   auto id = g_context.budgets.insert(budget);
   thread->retval[0] = id;
@@ -835,7 +835,7 @@ orbis::SysResult orbis::sys_budget_get(Thread *thread, sint id,
     return ErrorCode::INVAL;
   }
 
-  Ref<Budget> budget;
+  rx::Ref<Budget> budget;
   bool isProcessTypeBudget = id < 0;
   if (isProcessTypeBudget) {
     id = -2 - id;
@@ -1134,7 +1134,7 @@ orbis::SysResult orbis::sys_mdbg_service(Thread *thread, uint32_t op,
 
   case 7: {
     if (auto open = thread->tproc->ops->open) {
-      Ref<File> console;
+      rx::Ref<File> console;
       auto result = open(thread, "/dev/console", 0, 0, &console);
       if (!result.value() && console && console->ops->write) {
         IoVec vec{.base = (char *)arg0, .len = std::strlen((char *)arg0)};
@@ -1680,7 +1680,7 @@ orbis::SysResult orbis::sys_budget_get_ptype_of_budget(Thread *thread,
     return ErrorCode::NOSYS;
   }
 
-  orbis::Ref<Budget> budget = g_context.budgets.get(budgetId);
+  rx::Ref<Budget> budget = g_context.budgets.get(budgetId);
 
   if (!budget) {
     return ErrorCode::SRCH;
@@ -1698,7 +1698,7 @@ orbis::SysResult orbis::sys_process_terminate(Thread *thread /* TODO */) {
 }
 orbis::SysResult orbis::sys_blockpool_open(Thread *thread) {
   if (auto blockpool_open = thread->tproc->ops->blockpool_open) {
-    Ref<File> file;
+    rx::Ref<File> file;
     auto result = blockpool_open(thread, &file);
     if (result.isError()) {
       return result;
@@ -1874,7 +1874,7 @@ orbis::SysResult orbis::sys_begin_app_mount(Thread *thread,
                   _info.appInfo.unk7, _info.appInfo.unk8, _info.appInfo.unk9,
                   _info.appInfo.unk10);
 
-  orbis::Ref appInfo = orbis::knew<RcAppInfo>();
+  rx::Ref appInfo = orbis::knew<RcAppInfo>();
 
   AppInfoEx *appInfoData = appInfo.get();
   auto handle = g_context.appInfos.insert(appInfo);
diff --git a/kernel/orbis/src/sys/sys_uipc.cpp b/kernel/orbis/src/sys/sys_uipc.cpp
index 7266ed877..5ab829efd 100644
--- a/kernel/orbis/src/sys/sys_uipc.cpp
+++ b/kernel/orbis/src/sys/sys_uipc.cpp
@@ -11,7 +11,7 @@ orbis::SysResult orbis::sys_socket(Thread *thread, sint domain, sint type,
                                    sint protocol) {
   ORBIS_LOG_TODO(__FUNCTION__, domain, type, protocol);
   if (auto socket = thread->tproc->ops->socket) {
-    Ref<File> file;
+    rx::Ref<File> file;
     auto result = socket(thread, nullptr, domain, type, protocol, &file);
 
     if (result.isError()) {
@@ -89,8 +89,8 @@ orbis::SysResult orbis::sys_socketpair(Thread *thread, sint domain, sint type,
                                        sint protocol, ptr<sint> rsv) {
   ORBIS_LOG_TODO(__FUNCTION__, domain, type, protocol, rsv);
   if (auto socketpair = thread->tproc->ops->socketpair) {
-    Ref<File> a;
-    Ref<File> b;
+    rx::Ref<File> a;
+    rx::Ref<File> b;
     auto result = socketpair(thread, domain, type, protocol, &a, &b);
 
     if (result.isError()) {
diff --git a/kernel/orbis/src/sys/sys_uipc_shm.cpp b/kernel/orbis/src/sys/sys_uipc_shm.cpp
index b13c3e3e4..8a1369b51 100644
--- a/kernel/orbis/src/sys/sys_uipc_shm.cpp
+++ b/kernel/orbis/src/sys/sys_uipc_shm.cpp
@@ -14,7 +14,7 @@ orbis::SysResult orbis::sys_shm_open(Thread *thread, ptr<const char> path,
   }
 
   if (auto shm_open = thread->tproc->ops->shm_open) {
-    Ref<File> file;
+    rx::Ref<File> file;
     auto result = shm_open(thread, path, flags, mode, &file);
     if (result.isError()) {
       return result;
diff --git a/kernel/orbis/src/sys/sys_vfs.cpp b/kernel/orbis/src/sys/sys_vfs.cpp
index 50cb9ff22..be5942613 100644
--- a/kernel/orbis/src/sys/sys_vfs.cpp
+++ b/kernel/orbis/src/sys/sys_vfs.cpp
@@ -74,7 +74,7 @@ orbis::SysResult orbis::sys_chroot(Thread *thread, ptr<char> path) {
 orbis::SysResult orbis::sys_open(Thread *thread, ptr<const char> path,
                                  sint flags, sint mode) {
   if (auto open = thread->tproc->ops->open) {
-    Ref<File> file;
+    rx::Ref<File> file;
     auto result = open(thread, path, flags, mode, &file);
     if (result.isError()) {
       return result;
@@ -114,7 +114,7 @@ orbis::SysResult orbis::sys_openat(Thread *thread, sint fd, ptr<char> path,
     return sys_open(thread, (cwd + "/" + path).c_str(), flag, mode);
   }
 
-  Ref<File> file = thread->tproc->fileDescriptors.get(fd);
+  rx::Ref<File> file = thread->tproc->fileDescriptors.get(fd);
   if (file == nullptr) {
     return ErrorCode::BADF;
   }
@@ -167,7 +167,7 @@ orbis::SysResult orbis::sys_unlinkat(Thread *thread, sint fd, ptr<char> path,
 }
 orbis::SysResult orbis::sys_lseek(Thread *thread, sint fd, off_t offset,
                                   sint whence) {
-  Ref<File> file = thread->tproc->fileDescriptors.get(fd);
+  rx::Ref<File> file = thread->tproc->fileDescriptors.get(fd);
   if (file == nullptr) {
     return ErrorCode::BADF;
   }
@@ -215,7 +215,7 @@ orbis::SysResult orbis::sys_freebsd6_lseek(Thread *thread, sint fd, sint,
 }
 orbis::SysResult orbis::sys_access(Thread *thread, ptr<char> path, sint flags) {
   if (auto open = thread->tproc->ops->open) {
-    Ref<File> file;
+    rx::Ref<File> file;
     return open(thread, path, flags, 0, &file);
   }
 
@@ -231,7 +231,7 @@ orbis::SysResult orbis::sys_eaccess(Thread *thread, ptr<char> path,
 }
 orbis::SysResult orbis::sys_stat(Thread *thread, ptr<char> path, ptr<Stat> ub) {
   ORBIS_LOG_WARNING(__FUNCTION__, path);
-  Ref<File> file;
+  rx::Ref<File> file;
   auto result = thread->tproc->ops->open(thread, path, 0, 0, &file);
   if (result.isError()) {
     return result;
@@ -289,7 +289,7 @@ orbis::SysResult orbis::sys_readlink(Thread *thread, ptr<char> path,
     return ErrorCode::NAMETOOLONG;
   }
 
-  Ref<File> file;
+  rx::Ref<File> file;
   if (auto error = thread->tproc->ops->open(thread, path, 0, 0, &file);
       error.value()) {
     return error;
@@ -362,7 +362,7 @@ orbis::SysResult orbis::sys_futimes(Thread *thread, sint fd,
 }
 orbis::SysResult orbis::sys_truncate(Thread *thread, ptr<char> path,
                                      off_t length) {
-  Ref<File> file;
+  rx::Ref<File> file;
   auto result = thread->tproc->ops->open(thread, path, 2, 0, &file);
   if (result.isError()) {
     return result;
@@ -400,7 +400,7 @@ orbis::SysResult orbis::sys_mkdir(Thread *thread, ptr<char> path, sint mode) {
 }
 orbis::SysResult orbis::sys_mkdirat(Thread *thread, sint fd, ptr<char> path,
                                     mode_t mode) {
-  Ref<File> file = thread->tproc->fileDescriptors.get(fd);
+  rx::Ref<File> file = thread->tproc->fileDescriptors.get(fd);
   if (file == nullptr) {
     return ErrorCode::BADF;
   }
@@ -425,7 +425,7 @@ orbis::SysResult orbis::sys_getdirentries(Thread *thread, sint fd,
                                           ptr<char> buf, uint count,
                                           ptr<slong> basep) {
   ORBIS_LOG_WARNING(__FUNCTION__, fd, (void *)buf, count, basep);
-  Ref<File> file = thread->tproc->fileDescriptors.get(fd);
+  rx::Ref<File> file = thread->tproc->fileDescriptors.get(fd);
   if (file == nullptr) {
     return ErrorCode::BADF;
   }
diff --git a/orbis-kernel/include/orbis/KernelContext.hpp b/orbis-kernel/include/orbis/KernelContext.hpp
index dcd68edee..3855ebb34 100644
--- a/orbis-kernel/include/orbis/KernelContext.hpp
+++ b/orbis-kernel/include/orbis/KernelContext.hpp
@@ -57,7 +57,7 @@ enum class FwType : std::uint8_t {
   Ps5,
 };
 
-struct RcAppInfo : RcBase, AppInfoEx {
+struct RcAppInfo : rx::RcBase, AppInfoEx {
   orbis::uint32_t appState = 0;
 };
 
@@ -71,7 +71,7 @@ public:
   Process *findProcessById(pid_t pid) const;
   Process *findProcessByHostId(std::uint64_t pid) const;
 
-  utils::LinkedNode<Process> *getProcessList() { return m_processes; }
+  rx::LinkedNode<Process> *getProcessList() { return m_processes; }
 
   long allocatePid() {
     std::lock_guard lock(m_thread_id_mtx);
@@ -98,7 +98,7 @@ public:
     return {it->second.get(), inserted};
   }
 
-  Ref<EventFlag> findEventFlag(std::string_view name) {
+  rx::Ref<EventFlag> findEventFlag(std::string_view name) {
     std::lock_guard lock(m_evf_mtx);
 
     if (auto it = m_event_flags.find(name); it != m_event_flags.end()) {
@@ -121,7 +121,7 @@ public:
     return {it->second.get(), inserted};
   }
 
-  Ref<Semaphore> findSemaphore(std::string_view name) {
+  rx::Ref<Semaphore> findSemaphore(std::string_view name) {
     std::lock_guard lock(m_sem_mtx);
     if (auto it = m_semaphores.find(name); it != m_semaphores.end()) {
       return it->second;
@@ -148,7 +148,7 @@ public:
     return {it->second, {}};
   }
 
-  Ref<IpmiServer> findIpmiServer(std::string_view name) {
+  rx::Ref<IpmiServer> findIpmiServer(std::string_view name) {
     std::lock_guard lock(m_sem_mtx);
     if (auto it = mIpmiServers.find(name); it != mIpmiServers.end()) {
       return it->second;
@@ -191,12 +191,12 @@ public:
     return getUmtxChainIndexed(1, t, flags, ptr);
   }
 
-  Ref<EventEmitter> deviceEventEmitter;
-  Ref<RcBase> shmDevice;
-  Ref<RcBase> dmemDevice;
-  Ref<RcBase> blockpoolDevice;
-  Ref<RcBase> gpuDevice;
-  Ref<RcBase> dceDevice;
+  rx::Ref<EventEmitter> deviceEventEmitter;
+  rx::Ref<RcBase> shmDevice;
+  rx::Ref<RcBase> dmemDevice;
+  rx::Ref<RcBase> blockpoolDevice;
+  rx::Ref<RcBase> gpuDevice;
+  rx::Ref<RcBase> dceDevice;
   rx::shared_mutex gpuDeviceMtx;
   uint sdkVersion{};
   uint fwSdkVersion{};
@@ -204,7 +204,7 @@ public:
   utils::RcIdMap<RcBase, sint, 4097, 1> ipmiMap;
   RcIdMap<RcAppInfo> appInfos;
   RcIdMap<Budget, sint, 4097, 1> budgets;
-  Ref<Budget> processTypeBudgets[4];
+  rx::Ref<Budget> processTypeBudgets[4];
 
   rx::shared_mutex regMgrMtx;
   kmap<std::uint32_t, std::uint32_t> regMgrInt;
@@ -213,7 +213,7 @@ public:
   FwType fwType = FwType::Unknown;
   bool isDevKit = false;
 
-  Ref<Budget> createProcessTypeBudget(Budget::ProcessType processType,
+  rx::Ref<Budget> createProcessTypeBudget(Budget::ProcessType processType,
                                       std::string_view name,
                                       std::span<const BudgetInfo> items) {
     auto budget = orbis::knew<orbis::Budget>(name, processType, items);
@@ -222,7 +222,7 @@ public:
     return budget;
   }
 
-  Ref<Budget> getProcessTypeBudget(Budget::ProcessType processType) {
+  rx::Ref<Budget> getProcessTypeBudget(Budget::ProcessType processType) {
     return processTypeBudgets[static_cast<int>(processType)];
   }
 
@@ -244,13 +244,13 @@ private:
   utils::LinkedNode<Process> *m_processes = nullptr;
 
   rx::shared_mutex m_evf_mtx;
-  utils::kmap<utils::kstring, Ref<EventFlag>> m_event_flags;
+  utils::kmap<utils::kstring, rx::Ref<EventFlag>> m_event_flags;
 
   rx::shared_mutex m_sem_mtx;
-  utils::kmap<utils::kstring, Ref<Semaphore>> m_semaphores;
+  utils::kmap<utils::kstring, rx::Ref<Semaphore>> m_semaphores;
 
   rx::shared_mutex mIpmiServerMtx;
-  utils::kmap<utils::kstring, Ref<IpmiServer>> mIpmiServers;
+  utils::kmap<utils::kstring, rx::Ref<IpmiServer>> mIpmiServers;
 
   rx::shared_mutex m_kenv_mtx;
   utils::kmap<utils::kstring, char[128]> m_kenv; // max size: 127 + '\0'
diff --git a/orbis-kernel/src/ipmi.cpp b/orbis-kernel/src/ipmi.cpp
new file mode 100644
index 000000000..fe56efe54
--- /dev/null
+++ b/orbis-kernel/src/ipmi.cpp
@@ -0,0 +1,1405 @@
+#include "ipmi.hpp"
+#include "KernelContext.hpp"
+#include "thread/Process.hpp"
+#include "thread/Thread.hpp"
+#include "utils/Logs.hpp"
+#include <chrono>
+#include <span>
+#include <sys/mman.h>
+
+orbis::ErrorCode orbis::ipmiCreateClient(Process *proc, void *clientImpl,
+                                         const char *name,
+                                         const IpmiCreateClientConfig &config,
+                                         rx::Ref<IpmiClient> &result) {
+  auto client = knew<IpmiClient>(name);
+  if (client == nullptr) {
+    return ErrorCode::NOMEM;
+  }
+
+  client->clientImpl = clientImpl;
+  client->name = name;
+  client->process = proc;
+  client->userData = config.userData;
+  client->eventFlags.resize(32);
+  client->messageQueues.resize(32);
+  result = client;
+  return {};
+}
+
+orbis::ErrorCode orbis::ipmiCreateServer(Process *proc, void *serverImpl,
+                                         const char *name,
+                                         const IpmiCreateServerConfig &config,
+                                         rx::Ref<IpmiServer> &result) {
+  auto [server, errorCode] = g_context.createIpmiServer(name);
+  ORBIS_RET_ON_ERROR(errorCode);
+
+  server->serverImpl = serverImpl;
+  server->userData = config.userData;
+  server->eventHandler = config.eventHandler;
+  server->pid = proc->pid;
+  result = server;
+  return {};
+}
+
+orbis::ErrorCode orbis::ipmiCreateSession(Thread *thread, void *sessionImpl,
+                                          ptr<void> userData,
+                                          rx::Ref<IpmiSession> &result) {
+  std::unique_lock ipmiMapLock(g_context.ipmiMap.mutex);
+
+  for (auto [kid, obj] : g_context.ipmiMap) {
+    auto server = dynamic_cast<IpmiServer *>(obj);
+    if (server == nullptr) {
+      continue;
+    }
+
+    std::lock_guard serverLock(server->mutex);
+    for (auto &conReq : server->connectionRequests) {
+      if (conReq.serverTid != thread->tid ||
+          conReq.client->session != nullptr ||
+          conReq.client->name != server->name) {
+        continue;
+      }
+
+      std::lock_guard clientLock(conReq.client->mutex);
+      if (conReq.client->session != nullptr) {
+        continue;
+      }
+
+      auto session = knew<IpmiSession>();
+      if (session == nullptr) {
+        return ErrorCode::NOMEM;
+      }
+
+      result = session;
+      session->sessionImpl = sessionImpl;
+      session->userData = userData;
+      session->client = conReq.client;
+      session->server = server;
+      conReq.client->session = session;
+      conReq.client->sessionCv.notify_one(conReq.client->mutex);
+
+      return {};
+    }
+  }
+
+  ORBIS_LOG_ERROR(__FUNCTION__, ": connection request not found");
+  return ErrorCode::INVAL;
+}
+
+orbis::SysResult orbis::sysIpmiCreateClient(Thread *thread, ptr<uint> result,
+                                            ptr<void> params,
+                                            uint64_t paramsSz) {
+  if (paramsSz != sizeof(IpmiCreateClientParams)) {
+    return ErrorCode::INVAL;
+  }
+
+  IpmiCreateClientParams _params;
+  IpmiCreateClientConfig _config;
+  char _name[25];
+  rx::Ref<IpmiClient> client;
+
+  ORBIS_RET_ON_ERROR(uread(_params, ptr<IpmiCreateClientParams>(params)));
+  ORBIS_RET_ON_ERROR(uread(_config, _params.config));
+  ORBIS_RET_ON_ERROR(ureadString(_name, sizeof(_name), _params.name));
+  ORBIS_RET_ON_ERROR(ipmiCreateClient(thread->tproc, _params.clientImpl, _name,
+                                      _config, client));
+
+  auto kid = g_context.ipmiMap.insert(std::move(client));
+
+  if (kid == -1) {
+    return ErrorCode::MFILE;
+  }
+
+  ORBIS_LOG_ERROR(__FUNCTION__, kid, _name);
+  return uwrite<uint>(result, kid);
+}
+
+orbis::SysResult orbis::sysIpmiCreateServer(Thread *thread, ptr<uint> result,
+                                            ptr<void> params,
+                                            uint64_t paramsSz) {
+  struct IpmiCreateServerParams {
+    ptr<void> serverImpl;
+    ptr<const char> name;
+    ptr<IpmiCreateServerConfig> config;
+  };
+
+  static_assert(sizeof(IpmiCreateServerParams) == 0x18);
+
+  if (paramsSz != sizeof(IpmiCreateServerParams)) {
+    return ErrorCode::INVAL;
+  }
+
+  IpmiCreateServerParams _params;
+  IpmiCreateServerConfig _config;
+  char _name[25];
+  rx::Ref<IpmiServer> server;
+
+  ORBIS_RET_ON_ERROR(uread(_params, ptr<IpmiCreateServerParams>(params)));
+  ORBIS_RET_ON_ERROR(uread(_config, _params.config));
+  ORBIS_RET_ON_ERROR(ureadString(_name, sizeof(_name), _params.name));
+  ORBIS_RET_ON_ERROR(ipmiCreateServer(thread->tproc, _params.serverImpl, _name,
+                                      _config, server));
+  auto kid = g_context.ipmiMap.insert(std::move(server));
+
+  if (kid == -1) {
+    return ErrorCode::MFILE;
+  }
+
+  ORBIS_LOG_ERROR(__FUNCTION__, kid, _name);
+  return uwrite<uint>(result, kid);
+}
+
+orbis::SysResult orbis::sysIpmiCreateSession(Thread *thread, ptr<uint> result,
+                                             ptr<void> params,
+                                             uint64_t paramsSz) {
+  struct IpmiSessionUserData {
+    uint64_t size;
+    ptr<void> data;
+  };
+
+  static_assert(sizeof(IpmiSessionUserData) == 0x10);
+
+  struct IpmiCreateSessionParams {
+    ptr<void> sessionImpl;
+    ptr<IpmiSessionUserData> userData;
+  };
+
+  static_assert(sizeof(IpmiCreateSessionParams) == 0x10);
+
+  if (paramsSz != sizeof(IpmiCreateSessionParams)) {
+    return ErrorCode::INVAL;
+  }
+
+  IpmiCreateSessionParams _params;
+  IpmiSessionUserData _userData;
+  rx::Ref<IpmiSession> session;
+
+  ORBIS_RET_ON_ERROR(uread(_params, ptr<IpmiCreateSessionParams>(params)));
+  ORBIS_RET_ON_ERROR(uread(_userData, _params.userData));
+
+  if (_userData.size != sizeof(IpmiSessionUserData)) {
+    return ErrorCode::INVAL;
+  }
+
+  ORBIS_RET_ON_ERROR(
+      ipmiCreateSession(thread, _params.sessionImpl, _userData.data, session));
+
+  auto kid = g_context.ipmiMap.insert(std::move(session));
+
+  if (kid == -1) {
+    return ErrorCode::MFILE;
+  }
+
+  ORBIS_LOG_ERROR(__FUNCTION__, kid);
+  return uwrite<uint>(result, kid);
+}
+
+orbis::SysResult orbis::sysIpmiDestroyClient(Thread *thread, ptr<uint> result,
+                                             uint kid, ptr<void> params,
+                                             uint64_t paramsSz) {
+  ORBIS_LOG_TODO(__FUNCTION__);
+  return uwrite<uint>(result, 0);
+}
+orbis::SysResult orbis::sysIpmiDestroyServer(Thread *thread, ptr<uint> result,
+                                             uint kid, ptr<void> params,
+                                             uint64_t paramsSz) {
+  ORBIS_LOG_TODO(__FUNCTION__);
+  return uwrite<uint>(result, 0);
+}
+orbis::SysResult orbis::sysIpmiDestroySession(Thread *thread, ptr<uint> result,
+                                              uint kid, ptr<void> params,
+                                              uint64_t paramsSz) {
+  ORBIS_LOG_TODO(__FUNCTION__);
+  return uwrite<uint>(result, 0);
+}
+
+orbis::SysResult orbis::sysIpmiServerReceivePacket(Thread *thread,
+                                                   ptr<uint> result, uint kid,
+                                                   ptr<void> params,
+                                                   uint64_t paramsSz) {
+  struct IpmiServerReceivePacketParams {
+    ptr<void> buffer;
+    uint64_t bufferSize;
+    ptr<IpmiServer::IpmiPacketInfo> receivePacketInfo;
+    ptr<uint> unk;
+  };
+
+  if (paramsSz != sizeof(IpmiServerReceivePacketParams)) {
+    return orbis::ErrorCode::INVAL;
+  }
+
+  IpmiServerReceivePacketParams _params;
+
+  ORBIS_RET_ON_ERROR(
+      uread(_params, ptr<IpmiServerReceivePacketParams>(params)));
+
+  auto server = g_context.ipmiMap.get(kid).cast<IpmiServer>();
+
+  if (server == nullptr) {
+    return ErrorCode::INVAL;
+  }
+
+  IpmiServer::Packet _packet;
+
+  {
+    std::lock_guard lock(server->mutex);
+    while (server->packets.empty()) {
+      orbis::scoped_unblock unblock;
+      server->receiveCv.wait(server->mutex);
+    }
+
+    _packet = std::move(server->packets.front());
+    server->packets.pop_front();
+  }
+
+  if (_packet.info.type == 0x1) {
+    // on connection packet
+
+    for (auto &conn : server->connectionRequests) {
+      if (conn.clientTid == _packet.info.inputSize) {
+        conn.serverTid = thread->tid;
+        _packet.info.inputSize = 0;
+        break;
+      }
+    }
+  } else if ((_packet.info.type & ~(0x10 | 0x8000)) == 0x41) {
+    auto syncMessage = (IpmiSyncMessageHeader *)_packet.message.data();
+    ORBIS_LOG_ERROR(__FUNCTION__, server->name, syncMessage->methodId,
+                    syncMessage->numInData, syncMessage->numOutData,
+                    syncMessage->pid);
+  } else if ((_packet.info.type & ~0x10) == 0x43) {
+    auto asyncMessage = (IpmiAsyncMessageHeader *)_packet.message.data();
+    ORBIS_LOG_ERROR(__FUNCTION__, server->name, asyncMessage->methodId,
+                    asyncMessage->numInData, asyncMessage->pid);
+  }
+
+  if (_params.bufferSize < _packet.message.size()) {
+    ORBIS_LOG_ERROR(__FUNCTION__, "too small buffer", _params.bufferSize,
+                    _packet.message.size());
+    return ErrorCode::INVAL;
+  }
+
+  server->tidToClientTid[thread->tid] = _packet.clientTid;
+
+  ORBIS_RET_ON_ERROR(uwriteRaw((ptr<std::byte>)_params.buffer,
+                               _packet.message.data(), _packet.message.size()));
+  _params.bufferSize = _packet.message.size();
+  _packet.info.eventHandler = server->eventHandler;
+  ORBIS_RET_ON_ERROR(uwrite(_params.receivePacketInfo, _packet.info));
+  ORBIS_RET_ON_ERROR(
+      uwrite(ptr<IpmiServerReceivePacketParams>(params), _params));
+
+  return uwrite<uint>(result, 0);
+}
+orbis::SysResult orbis::sysIpmiSendConnectResult(Thread *thread,
+                                                 ptr<uint> result, uint kid,
+                                                 ptr<void> params,
+                                                 uint64_t paramsSz) {
+  if (paramsSz != sizeof(sint)) {
+    return ErrorCode::INVAL;
+  }
+
+  ORBIS_LOG_NOTICE(__FUNCTION__, kid);
+
+  auto ipmiObject = g_context.ipmiMap.get(kid);
+  if (ipmiObject == nullptr) {
+    return ErrorCode::INVAL;
+  }
+
+  rx::Ref<IpmiClient> client;
+  if (auto result = ipmiObject.cast<IpmiSession>()) {
+    client = result->client;
+  } else if (auto result = ipmiObject.cast<IpmiClient>()) {
+    client = result;
+  } else if (auto result = ipmiObject.cast<IpmiServer>()) {
+    for (auto &request : result->connectionRequests) {
+      if (request.serverTid == thread->tid) {
+        client = request.client;
+        break;
+      }
+    }
+  }
+
+  if (client == nullptr) {
+    ORBIS_LOG_FATAL(__FUNCTION__);
+    std::abort();
+  }
+
+  sint status;
+  ORBIS_RET_ON_ERROR(uread(status, ptr<sint>(params)));
+
+  ORBIS_LOG_NOTICE(__FUNCTION__, kid, status);
+  std::lock_guard lock(client->mutex);
+  client->connectionStatus = status;
+  client->connectCv.notify_all(client->mutex);
+  client->sessionCv.notify_all(client->mutex);
+  return uwrite(result, 0u);
+}
+orbis::SysResult orbis::sysIpmiSessionRespondSync(Thread *thread,
+                                                  ptr<uint> result, uint kid,
+                                                  ptr<void> params,
+                                                  uint64_t paramsSz) {
+  struct IpmiRespondParams {
+    sint errorCode;
+    uint32_t bufferCount;
+    ptr<IpmiBufferInfo> buffers;
+    uint32_t flags;
+    uint32_t padding;
+  };
+
+  static_assert(sizeof(IpmiRespondParams) == 0x18);
+  if (paramsSz != sizeof(IpmiRespondParams)) {
+    return ErrorCode::INVAL;
+  }
+
+  auto session = g_context.ipmiMap.get(kid).cast<IpmiSession>();
+
+  if (session == nullptr) {
+    return ErrorCode::INVAL;
+  }
+
+  IpmiRespondParams _params;
+  ORBIS_RET_ON_ERROR(uread(_params, ptr<IpmiRespondParams>(params)));
+
+  kvector<kvector<std::byte>> buffers;
+
+  // if ((_params.flags & 1) || _params.bufferCount != 1) {
+  auto count = _params.bufferCount;
+  buffers.reserve(count);
+  for (uint32_t i = 0; i < count; ++i) {
+    IpmiBufferInfo _buffer;
+    ORBIS_RET_ON_ERROR(uread(_buffer, _params.buffers + i));
+
+    auto &bufferData = buffers.emplace_back();
+    bufferData.resize(_buffer.size);
+    ORBIS_RET_ON_ERROR(ureadRaw(bufferData.data(), _buffer.data, _buffer.size));
+  }
+  // }
+
+  std::lock_guard lock(session->mutex);
+
+  std::uint32_t clientTid;
+  {
+    std::lock_guard serverLock(session->server->mutex);
+    clientTid = session->server->tidToClientTid.at(thread->tid);
+  }
+
+  ORBIS_LOG_ERROR(__FUNCTION__, session->client->name, _params.errorCode);
+
+  if (_params.errorCode != 0) {
+    ORBIS_LOG_ERROR(__FUNCTION__, session->client->name, _params.errorCode);
+    thread->where();
+  }
+
+  session->syncResponses.push_front({
+      .errorCode = _params.errorCode,
+      .callerTid = clientTid,
+      .data = std::move(buffers),
+  });
+
+  session->responseCv.notify_all(session->mutex);
+  return uwrite(result, 0u);
+}
+orbis::SysResult orbis::sysIpmiClientInvokeAsyncMethod(Thread *thread,
+                                                       ptr<uint> result,
+                                                       uint kid,
+                                                       ptr<void> params,
+                                                       uint64_t paramsSz) {
+  struct IpmiAsyncCallParams {
+    uint32_t method;
+    uint32_t evfIndex;
+    uint64_t evfValue;
+    uint32_t numInData;
+    uint32_t padding1;
+    ptr<IpmiDataInfo> pInData;
+    ptr<sint> pResult;
+    uint32_t flags;
+  };
+
+  static_assert(sizeof(IpmiAsyncCallParams) == 0x30);
+
+  if (paramsSz != sizeof(IpmiAsyncCallParams)) {
+    return ErrorCode::INVAL;
+  }
+
+  auto client = g_context.ipmiMap.get(kid).cast<IpmiClient>();
+
+  if (client == nullptr) {
+    return ErrorCode::INVAL;
+  }
+
+  IpmiAsyncCallParams _params;
+  ORBIS_RET_ON_ERROR(uread(_params, (ptr<IpmiAsyncCallParams>)params));
+
+  if (_params.flags > 1) {
+    return ErrorCode::INVAL;
+  }
+
+  std::lock_guard clientLock(client->mutex);
+  auto session = client->session;
+
+  if (session == nullptr) {
+    return ErrorCode::INVAL;
+  }
+
+  std::lock_guard sessionLock(session->mutex);
+  auto server = session->server;
+
+  if (server == nullptr) {
+    return ErrorCode::INVAL;
+  }
+
+  {
+    std::lock_guard serverLock(server->mutex);
+
+    std::size_t inSize = 0;
+    for (auto &data : std::span(_params.pInData, _params.numInData)) {
+      inSize += data.size;
+    }
+
+    auto size = sizeof(IpmiAsyncMessageHeader) + inSize +
+                _params.numInData * sizeof(uint32_t);
+    kvector<std::byte> message(size);
+    auto msg = new (message.data()) IpmiAsyncMessageHeader;
+    msg->sessionImpl = session->sessionImpl;
+    msg->pid = thread->tproc->pid;
+    msg->methodId = _params.method;
+    msg->numInData = _params.numInData;
+
+    auto bufLoc = std::bit_cast<char *>(msg + 1);
+
+    for (auto &data : std::span(_params.pInData, _params.numInData)) {
+      *std::bit_cast<uint32_t *>(bufLoc) = data.size;
+      bufLoc += sizeof(uint32_t);
+      ORBIS_RET_ON_ERROR(ureadRaw(bufLoc, data.data, data.size));
+      bufLoc += data.size;
+    }
+
+    uint type = 0x43;
+
+    if ((_params.flags & 1) == 0) {
+      type |= 0x10;
+    }
+
+    server->packets.push_back(
+        {{.type = type, .clientKid = kid}, 0, session, std::move(message)});
+    server->receiveCv.notify_one(server->mutex);
+  }
+
+  if (_params.evfIndex != -1 && _params.evfValue != 0) {
+    client->eventFlags[_params.evfIndex].set(_params.evfValue);
+  }
+
+  ORBIS_RET_ON_ERROR(uwrite(_params.pResult, 0));
+  return uwrite(result, 0u);
+}
+
+orbis::SysResult orbis::sysImpiSessionRespondAsync(Thread *thread,
+                                                   ptr<uint> result, uint kid,
+                                                   ptr<void> params,
+                                                   uint64_t paramsSz) {
+  struct IpmiAsyncRespondParams {
+    uint method;
+    uint pid;
+    sint result;
+    uint32_t numOutData;
+    ptr<IpmiDataInfo> pOutData;
+    uint32_t unk2; // == 1
+  };
+
+  static_assert(sizeof(IpmiAsyncRespondParams) == 0x20);
+
+  if (paramsSz != sizeof(IpmiAsyncRespondParams)) {
+    return ErrorCode::INVAL;
+  }
+
+  auto session = g_context.ipmiMap.get(kid).cast<IpmiSession>();
+
+  if (session == nullptr) {
+    return ErrorCode::INVAL;
+  }
+
+  auto client = session->client;
+
+  if (client == nullptr) {
+    return ErrorCode::INVAL;
+  }
+
+  IpmiAsyncRespondParams _params;
+  ORBIS_RET_ON_ERROR(uread(_params, (ptr<IpmiAsyncRespondParams>)params));
+
+  kvector<kvector<std::byte>> outData;
+  outData.reserve(_params.numOutData);
+  for (auto data : std::span(_params.pOutData, _params.numOutData)) {
+    auto &elem = outData.emplace_back();
+    elem.resize(data.size);
+    ORBIS_RET_ON_ERROR(ureadRaw(elem.data(), data.data, data.size));
+  }
+
+  {
+    std::lock_guard clientLock(client->mutex);
+    client->asyncResponses.push_back({
+        .methodId = _params.method,
+        .errorCode = _params.result,
+        .data = std::move(outData),
+    });
+  }
+
+  client->asyncResponseCv.notify_all(client->mutex);
+  return uwrite(result, 0u);
+}
+
+orbis::SysResult orbis::sysIpmiClientTryGetResult(Thread *thread,
+                                                  ptr<uint> result, uint kid,
+                                                  ptr<void> params,
+                                                  uint64_t paramsSz) {
+  struct IpmiTryGetResultParams {
+    uint32_t method;
+    uint32_t unk;
+    ptr<sint> pResult;
+    uint32_t numOutData;
+    uint32_t padding;
+    ptr<IpmiBufferInfo> pOutData;
+    uint64_t padding2;
+  };
+
+  static_assert(sizeof(IpmiTryGetResultParams) == 0x28);
+
+  if (paramsSz != sizeof(IpmiTryGetResultParams)) {
+    return ErrorCode::INVAL;
+  }
+
+  IpmiTryGetResultParams _params;
+  ORBIS_RET_ON_ERROR(uread(_params, (ptr<IpmiTryGetResultParams>)params));
+
+  auto client = g_context.ipmiMap.get(kid).cast<IpmiClient>();
+
+  if (client == nullptr) {
+    return ErrorCode::INVAL;
+  }
+
+  while (true) {
+    std::lock_guard clientLock(client->mutex);
+
+    for (auto it = client->asyncResponses.begin();
+         it != client->asyncResponses.end(); ++it) {
+      if (it->methodId != _params.method) {
+        continue;
+      }
+
+      auto response = std::move(*it);
+      client->asyncResponses.erase(it);
+
+      ORBIS_RET_ON_ERROR(uwrite(_params.pResult, it->errorCode));
+
+      if (response.data.size() != _params.numOutData) {
+        ORBIS_LOG_ERROR(__FUNCTION__, "responses count mismatch",
+                        response.data.size(), _params.numOutData);
+      }
+
+      for (std::size_t i = 0; i < response.data.size(); ++i) {
+        if (response.data.size() > _params.numOutData) {
+          ORBIS_LOG_ERROR(__FUNCTION__, "too many responses",
+                          response.data.size(), _params.numOutData);
+          break;
+        }
+
+        IpmiBufferInfo _outData;
+        ORBIS_RET_ON_ERROR(uread(_outData, _params.pOutData + i));
+
+        auto &data = response.data[i];
+
+        if (_outData.capacity < data.size()) {
+          ORBIS_LOG_ERROR(__FUNCTION__, "too big response", _outData.capacity,
+                          data.size());
+          continue;
+        }
+
+        _outData.size = data.size();
+        ORBIS_RET_ON_ERROR(uwriteRaw(_outData.data, data.data(), data.size()));
+        ORBIS_RET_ON_ERROR(uwrite(_params.pOutData + i, _outData));
+      }
+
+      return uwrite(result, 0u);
+    }
+
+    orbis::scoped_unblock unblock;
+    client->asyncResponseCv.wait(client->mutex);
+  }
+
+  // return uwrite(result, 0x80020000 + static_cast<int>(ErrorCode::AGAIN));
+}
+
+orbis::SysResult orbis::sysIpmiClientGetMessage(Thread *thread,
+                                                ptr<uint> result, uint kid,
+                                                ptr<void> params,
+                                                uint64_t paramsSz) {
+  struct SceIpmiClientGetArgs {
+    uint32_t queueIndex;
+    uint32_t padding;
+    ptr<std::byte> message;
+    ptr<uint64_t> pSize;
+    uint64_t maxSize;
+    ptr<uint> pTimeout;
+  };
+
+  static_assert(sizeof(SceIpmiClientGetArgs) == 0x28);
+
+  if (paramsSz != sizeof(SceIpmiClientGetArgs)) {
+    return ErrorCode::INVAL;
+  }
+
+  auto client = g_context.ipmiMap.get(kid).cast<IpmiClient>();
+
+  if (client == nullptr) {
+    return ErrorCode::INVAL;
+  }
+
+  SceIpmiClientGetArgs _params;
+  ORBIS_RET_ON_ERROR(uread(_params, ptr<SceIpmiClientGetArgs>(params)));
+
+  std::lock_guard lock(client->mutex);
+
+  if (_params.queueIndex >= client->messageQueues.size()) {
+    return ErrorCode::INVAL;
+  }
+
+  auto &queue = client->messageQueues[_params.queueIndex];
+
+  using clock = std::chrono::high_resolution_clock;
+
+  clock::time_point timeoutPoint = clock::time_point::max();
+  if (_params.pTimeout != nullptr) {
+    std::uint32_t timeout{};
+    ORBIS_RET_ON_ERROR(uread(timeout, _params.pTimeout));
+    timeoutPoint = clock::now() + std::chrono::microseconds(timeout);
+  }
+
+  if (queue.messages.empty()) {
+    if (timeoutPoint != clock::time_point::max()) {
+      while (true) {
+        auto now = clock::now();
+        if (now >= timeoutPoint) {
+          ORBIS_RET_ON_ERROR(uwrite(_params.pTimeout, 0u));
+          return uwrite<uint>(
+              result, 0x80020000 + static_cast<int>(ErrorCode::TIMEDOUT));
+        }
+
+        auto waitTime = std::chrono::duration_cast<std::chrono::microseconds>(
+            timeoutPoint - now);
+
+        {
+          orbis::scoped_unblock unblock;
+          queue.messageCv.wait(client->mutex, waitTime.count());
+        }
+
+        if (!queue.messages.empty()) {
+          now = clock::now();
+
+          if (now >= timeoutPoint) {
+            ORBIS_RET_ON_ERROR(uwrite(_params.pTimeout, 0u));
+          } else {
+            std::uint32_t restTime =
+                std::chrono::duration_cast<std::chrono::microseconds>(
+                    timeoutPoint - now)
+                    .count();
+            ORBIS_RET_ON_ERROR(uwrite(_params.pTimeout, restTime));
+          }
+
+          break;
+        }
+      }
+    } else {
+      while (queue.messages.empty()) {
+        orbis::scoped_unblock unblock;
+        queue.messageCv.wait(client->mutex);
+      }
+    }
+  }
+
+  auto &message = queue.messages.front();
+
+  if (_params.maxSize < message.size()) {
+    ORBIS_LOG_ERROR(__FUNCTION__, "too small buffer");
+    return uwrite<uint>(result,
+                        0x80020000 + static_cast<int>(ErrorCode::INVAL));
+  }
+
+  ORBIS_RET_ON_ERROR(uwrite(_params.pSize, message.size()));
+  ORBIS_RET_ON_ERROR(
+      uwriteRaw(_params.message, message.data(), message.size()));
+  queue.messages.pop_front();
+  return uwrite<uint>(result, 0);
+}
+
+orbis::SysResult orbis::sysIpmiClientTryGetMessage(Thread *thread,
+                                                   ptr<uint> result, uint kid,
+                                                   ptr<void> params,
+                                                   uint64_t paramsSz) {
+  struct SceIpmiClientTryGetArgs {
+    uint32_t queueIndex;
+    uint32_t padding;
+    ptr<std::byte> message;
+    ptr<uint64_t> pSize;
+    uint64_t maxSize;
+  };
+
+  static_assert(sizeof(SceIpmiClientTryGetArgs) == 0x20);
+
+  if (paramsSz != sizeof(SceIpmiClientTryGetArgs)) {
+    return ErrorCode::INVAL;
+  }
+
+  auto client = g_context.ipmiMap.get(kid).cast<IpmiClient>();
+
+  if (client == nullptr) {
+    return ErrorCode::INVAL;
+  }
+
+  SceIpmiClientTryGetArgs _params;
+  ORBIS_RET_ON_ERROR(uread(_params, ptr<SceIpmiClientTryGetArgs>(params)));
+
+  std::lock_guard lock(client->mutex);
+
+  if (_params.queueIndex >= client->messageQueues.size()) {
+    return ErrorCode::INVAL;
+  }
+
+  auto &queue = client->messageQueues[_params.queueIndex];
+
+  if (queue.messages.empty()) {
+    return uwrite<uint>(result,
+                        0x80020000 + static_cast<int>(ErrorCode::AGAIN));
+  }
+
+  auto &message = queue.messages.front();
+
+  if (_params.maxSize < message.size()) {
+    ORBIS_LOG_ERROR(__FUNCTION__, "too small buffer");
+    return uwrite<uint>(result,
+                        0x80020000 + static_cast<int>(ErrorCode::INVAL));
+  }
+
+  ORBIS_RET_ON_ERROR(uwrite(_params.pSize, message.size()));
+  ORBIS_RET_ON_ERROR(
+      uwriteRaw(_params.message, message.data(), message.size()));
+  queue.messages.pop_front();
+  return uwrite<uint>(result, 0);
+}
+
+orbis::SysResult orbis::sysIpmiSessionTrySendMessage(Thread *thread,
+                                                     ptr<uint> result, uint kid,
+                                                     ptr<void> params,
+                                                     uint64_t paramsSz) {
+  struct SceIpmiClientTrySendArgs {
+    uint32_t queueIndex;
+    uint32_t padding;
+    ptr<std::byte> message;
+    uint64_t size;
+  };
+
+  static_assert(sizeof(SceIpmiClientTrySendArgs) == 0x18);
+
+  if (paramsSz != sizeof(SceIpmiClientTrySendArgs)) {
+    return ErrorCode::INVAL;
+  }
+
+  auto session = g_context.ipmiMap.get(kid).cast<IpmiSession>();
+
+  if (session == nullptr) {
+    return ErrorCode::INVAL;
+  }
+
+  SceIpmiClientTrySendArgs _params;
+  ORBIS_RET_ON_ERROR(uread(_params, ptr<SceIpmiClientTrySendArgs>(params)));
+
+  std::lock_guard lock(session->mutex);
+
+  if (session->client == nullptr) {
+    return ErrorCode::INVAL;
+  }
+
+  auto client = session->client;
+  std::lock_guard lockClient(client->mutex);
+
+  if (_params.queueIndex >= client->messageQueues.size()) {
+    return ErrorCode::INVAL;
+  }
+
+  auto &queue = client->messageQueues[_params.queueIndex];
+
+  auto &message = queue.messages.emplace_back();
+  message.resize(_params.size);
+  ORBIS_RET_ON_ERROR(ureadRaw(message.data(), _params.message, _params.size));
+  queue.messageCv.notify_all(client->mutex);
+  return uwrite<uint>(result, 0);
+}
+
+orbis::SysResult orbis::sysIpmiClientDisconnect(Thread *thread,
+                                                ptr<uint> result, uint kid,
+                                                ptr<void> params,
+                                                uint64_t paramsSz) {
+  struct SceIpmiClientDisconnectArgs {
+    ptr<sint> status;
+  };
+
+  if (paramsSz != sizeof(SceIpmiClientDisconnectArgs)) {
+    return ErrorCode::INVAL;
+  }
+
+  auto client = g_context.ipmiMap.get(kid).cast<IpmiClient>();
+
+  if (client == nullptr) {
+    return ErrorCode::INVAL;
+  }
+
+  SceIpmiClientDisconnectArgs _params;
+  ORBIS_RET_ON_ERROR(uread(_params, ptr<SceIpmiClientDisconnectArgs>(params)));
+
+  ORBIS_LOG_ERROR(__FUNCTION__, client->name, _params.status);
+  ORBIS_RET_ON_ERROR(uwrite(_params.status, 0));
+  return uwrite<uint>(result, 0);
+}
+
+orbis::SysResult orbis::sysIpmiSessionGetClientPid(Thread *thread,
+                                                   ptr<uint> result, uint kid,
+                                                   ptr<void> params,
+                                                   uint64_t paramsSz) {
+  struct IpmiGetClientPidParams {
+    ptr<uint32_t> pid;
+  };
+
+  if (paramsSz != sizeof(IpmiGetClientPidParams)) {
+    return ErrorCode::INVAL;
+  }
+
+  auto session = g_context.ipmiMap.get(kid).cast<IpmiSession>();
+
+  if (session == nullptr) {
+    return ErrorCode::INVAL;
+  }
+
+  IpmiGetClientPidParams _params;
+  ORBIS_RET_ON_ERROR(uread(_params, ptr<IpmiGetClientPidParams>(params)));
+  ORBIS_RET_ON_ERROR(
+      uwrite<uint32_t>(_params.pid, session->client->process->pid));
+  return uwrite<uint>(result, 0);
+}
+
+orbis::SysResult
+orbis::sysIpmiClientInvokeSyncMethod(Thread *thread, ptr<uint> result, uint kid,
+                                     ptr<void> params, uint64_t paramsSz) {
+  if (paramsSz != sizeof(IpmiSyncCallParams)) {
+    return ErrorCode::INVAL;
+  }
+
+  IpmiSyncCallParams _params;
+  ORBIS_RET_ON_ERROR(uread(_params, (ptr<IpmiSyncCallParams>)params));
+
+  if (_params.flags > 1) {
+    return ErrorCode::INVAL;
+  }
+
+  auto client = g_context.ipmiMap.get(kid).cast<IpmiClient>();
+
+  if (client == nullptr) {
+    return ErrorCode::INVAL;
+  }
+
+  auto session = client->session;
+
+  if (session == nullptr) {
+    return ErrorCode::INVAL;
+  }
+
+  std::lock_guard sessionLock(session->mutex);
+  auto server = session->server;
+
+  if (server == nullptr) {
+    return ErrorCode::INVAL;
+  }
+
+  {
+    std::lock_guard serverLock(server->mutex);
+
+    std::size_t inSize = 0;
+    for (auto &data : std::span(_params.pInData, _params.numInData)) {
+      inSize += data.size;
+    }
+
+    auto headerSize = sizeof(IpmiSyncMessageHeader) + inSize +
+                      _params.numInData * sizeof(uint32_t);
+    auto size = headerSize + _params.numOutData * sizeof(uint);
+
+    kvector<std::byte> message(size);
+    auto msg = new (message.data()) IpmiSyncMessageHeader;
+    msg->sessionImpl = session->sessionImpl;
+    msg->pid = thread->tproc->pid;
+    msg->methodId = _params.method;
+    msg->numInData = _params.numInData;
+    msg->numOutData = _params.numOutData;
+
+    auto bufLoc = std::bit_cast<char *>(msg + 1);
+
+    for (auto &data : std::span(_params.pInData, _params.numInData)) {
+      *std::bit_cast<uint32_t *>(bufLoc) = data.size;
+      bufLoc += sizeof(uint32_t);
+      ORBIS_RET_ON_ERROR(ureadRaw(bufLoc, data.data, data.size));
+      bufLoc += data.size;
+    }
+
+    for (auto &data : std::span(_params.pOutData, _params.numOutData)) {
+      *std::bit_cast<uint32_t *>(bufLoc) = data.capacity;
+      bufLoc += sizeof(uint32_t);
+    }
+
+    uint type = 0x41;
+
+    if ((_params.flags & 1) == 0) {
+      type |= 0x10;
+    }
+
+    if (server->pid == thread->tproc->pid) {
+      type |= 0x8000;
+    }
+
+    server->packets.push_back(
+        {{.inputSize = headerSize, .type = type, .clientKid = kid},
+         thread->tid,
+         session,
+         std::move(message)});
+    server->receiveCv.notify_one(server->mutex);
+  }
+
+  IpmiSession::SyncResponse response;
+
+  while (true) {
+    {
+      orbis::scoped_unblock unblock;
+      session->responseCv.wait(session->mutex);
+    }
+
+    bool found = false;
+    for (auto it = session->syncResponses.begin();
+         it != session->syncResponses.end(); ++it) {
+      if (it->callerTid != thread->tid) {
+        continue;
+      }
+
+      response = std::move(*it);
+      session->syncResponses.erase(it);
+      found = true;
+      break;
+    }
+    if (found) {
+      break;
+    }
+  }
+
+  ORBIS_RET_ON_ERROR(uwrite(_params.pResult, response.errorCode));
+
+  if (response.data.size() != _params.numOutData) {
+    ORBIS_LOG_ERROR(__FUNCTION__, "responses amount mismatch",
+                    response.data.size(), _params.numOutData);
+  }
+
+  for (std::size_t i = 0; i < response.data.size(); ++i) {
+    if (response.data.size() > _params.numOutData) {
+      ORBIS_LOG_ERROR(__FUNCTION__, "too many responses", response.data.size(),
+                      _params.numOutData);
+      break;
+    }
+
+    IpmiBufferInfo _outData;
+    ORBIS_RET_ON_ERROR(uread(_outData, _params.pOutData + i));
+
+    auto &data = response.data[i];
+
+    if (_outData.capacity < data.size()) {
+      ORBIS_LOG_ERROR(__FUNCTION__, "too big response", _outData.capacity,
+                      data.size());
+      continue;
+    }
+
+    // ORBIS_LOG_ERROR(__FUNCTION__, server->name, i, _outData.data,
+    // _outData.capacity,
+    //                 data.size());
+
+    _outData.size = data.size();
+    ORBIS_RET_ON_ERROR(uwriteRaw(_outData.data, data.data(), data.size()));
+    ORBIS_RET_ON_ERROR(uwrite(_params.pOutData + i, _outData));
+  }
+
+  return uwrite<uint>(result, 0);
+}
+
+orbis::SysResult orbis::sysIpmiClientConnect(Thread *thread, ptr<uint> result,
+                                             uint kid, ptr<void> params,
+                                             uint64_t paramsSz) {
+  if (paramsSz != sizeof(IpmiClientConnectParams)) {
+    return ErrorCode::INVAL;
+  }
+
+  auto client = g_context.ipmiMap.get(kid).cast<IpmiClient>();
+
+  if (client == nullptr) {
+    return ErrorCode::INVAL;
+  }
+
+  if (client->session != nullptr) {
+    return ErrorCode::EXIST;
+  }
+
+  IpmiClientConnectParams _params;
+  ORBIS_RET_ON_ERROR(uread(_params, ptr<IpmiClientConnectParams>(params)));
+
+  auto server = g_context.findIpmiServer(client->name);
+
+  if (server == nullptr) {
+    return SysResult::notAnError(ErrorCode::NOENT);
+  }
+
+  std::lock_guard clientLock(client->mutex);
+
+  decltype(server->connectionRequests)::iterator requestIt;
+
+  {
+    std::lock_guard serverLock(server->mutex);
+
+    for (auto &connReq : server->connectionRequests) {
+      if (connReq.client == client) {
+        return ErrorCode::EXIST;
+      }
+    }
+
+    server->connectionRequests.push_front({
+        .client = client,
+        .clientTid = thread->tid,
+        .clientPid = thread->tproc->pid,
+    });
+
+    requestIt = server->connectionRequests.begin();
+
+    struct QueueStats {
+      uint maxOutstanding;
+      uint unk;
+      ulong inDataSizeHardLimit;
+      ulong outDataSizeHardLimit;
+    };
+
+    struct ConnectMessageHeader {
+      uint32_t clientPid;
+      uint32_t clientKid;
+      QueueStats sync;
+      QueueStats async;
+      uint numEventFlag;
+      uint unk1;
+      uint numMsgQueue;
+      uint unk2;
+      ulong msgQueueSize[32];
+      ulong memorySize;
+    };
+
+    static_assert(sizeof(ConnectMessageHeader) == 0x150);
+
+    kvector<std::byte> message{
+        sizeof(ConnectMessageHeader) + sizeof(uint) +
+        std::max<std::size_t>(_params.userDataLen, 0x10)};
+    auto header = new (message.data()) ConnectMessageHeader{};
+    header->clientPid = thread->tproc->pid;
+    header->clientKid = kid;
+
+    header->sync.maxOutstanding = 1;
+    header->sync.inDataSizeHardLimit = 0x10000;
+    header->sync.outDataSizeHardLimit = 0x10000;
+    header->async.maxOutstanding = 8;
+    header->async.inDataSizeHardLimit = 0x10000;
+    header->async.outDataSizeHardLimit = 0x10000;
+
+    header->numEventFlag = client->eventFlags.size();
+    header->numMsgQueue = client->messageQueues.size();
+
+    for (auto &size : header->msgQueueSize) {
+      size = 0x10000;
+    }
+
+    if (_params.userDataLen != 0) {
+      auto bufLoc = std::bit_cast<char *>(header + 1);
+      *std::bit_cast<uint *>(bufLoc) = _params.userDataLen;
+      ORBIS_RET_ON_ERROR(ureadRaw(bufLoc + sizeof(uint), _params.userData,
+                                  _params.userDataLen));
+    }
+
+    server->packets.push_back({{
+                                   .inputSize = static_cast<ulong>(thread->tid),
+                                   .type = 1,
+                                   .clientKid = kid,
+                               },
+                               0,
+                               nullptr,
+                               std::move(message)});
+    server->receiveCv.notify_one(server->mutex);
+  }
+
+  while (client->session == nullptr && !client->connectionStatus) {
+    orbis::scoped_unblock unblock;
+    client->sessionCv.wait(client->mutex);
+  }
+
+  while (!client->connectionStatus) {
+    orbis::scoped_unblock unblock;
+    client->connectCv.wait(client->mutex);
+  }
+
+  ORBIS_RET_ON_ERROR(uwrite(_params.status, *client->connectionStatus));
+
+  {
+    std::lock_guard serverLock(server->mutex);
+    server->connectionRequests.erase(requestIt);
+  }
+
+  return uwrite(result, 0u);
+}
+
+orbis::SysResult orbis::sysIpmiSessionGetClientAppId(Thread *thread,
+                                                     ptr<uint> result, uint kid,
+                                                     ptr<void> params,
+                                                     uint64_t paramsSz) {
+  struct IpmiGetUserDataParam {
+    ptr<uint> data;
+  };
+
+  if (paramsSz != sizeof(IpmiGetUserDataParam)) {
+    return ErrorCode::INVAL;
+  }
+
+  auto session = g_context.ipmiMap.get(kid).cast<IpmiSession>();
+
+  if (session == nullptr) {
+    return ErrorCode::INVAL;
+  }
+
+  IpmiGetUserDataParam _params;
+  ORBIS_RET_ON_ERROR(uread(_params, ptr<IpmiGetUserDataParam>(params)));
+  ORBIS_RET_ON_ERROR(
+      uwrite(_params.data, session->client->process->appInfo.appId));
+  return uwrite<uint>(result, 0);
+}
+
+orbis::SysResult orbis::sysIpmiSessionGetUserData(Thread *thread,
+                                                  ptr<uint> result, uint kid,
+                                                  ptr<void> params,
+                                                  uint64_t paramsSz) {
+  struct IpmiGetUserDataParam {
+    ptr<ptr<void>> data;
+  };
+
+  if (paramsSz != sizeof(IpmiGetUserDataParam)) {
+    return ErrorCode::INVAL;
+  }
+
+  auto session = g_context.ipmiMap.get(kid).cast<IpmiSession>();
+
+  if (session == nullptr) {
+    return ErrorCode::INVAL;
+  }
+
+  IpmiGetUserDataParam _params;
+  ORBIS_RET_ON_ERROR(uread(_params, ptr<IpmiGetUserDataParam>(params)));
+  ORBIS_RET_ON_ERROR(uwrite(_params.data, session->userData));
+  return uwrite<uint>(result, 0);
+}
+
+orbis::SysResult orbis::sysIpmiServerGetName(Thread *thread, ptr<uint> result,
+                                             uint kid, ptr<void> params,
+                                             uint64_t paramsSz) {
+  struct IpmiGetServerNameParams {
+    ptr<char> name;
+  };
+
+  if (paramsSz != sizeof(IpmiGetServerNameParams)) {
+    return ErrorCode::INVAL;
+  }
+
+  auto server = g_context.ipmiMap.get(kid).cast<IpmiServer>();
+
+  if (server == nullptr) {
+    return ErrorCode::INVAL;
+  }
+
+  IpmiGetServerNameParams _param;
+  ORBIS_RET_ON_ERROR(uread(_param, ptr<IpmiGetServerNameParams>(params)));
+  ORBIS_RET_ON_ERROR(
+      uwriteRaw(_param.name, server->name.c_str(), server->name.size() + 1));
+
+  return uwrite<uint>(result, 0);
+}
+
+orbis::SysResult orbis::sysIpmiClientGetName(Thread *thread, ptr<uint> result,
+                                             uint kid, ptr<void> params,
+                                             uint64_t paramsSz) {
+  struct IpmiGetClientNameParams {
+    ptr<char> name;
+  };
+
+  if (paramsSz != sizeof(IpmiGetClientNameParams)) {
+    return ErrorCode::INVAL;
+  }
+
+  auto client = g_context.ipmiMap.get(kid).cast<IpmiClient>();
+
+  if (client == nullptr) {
+    return ErrorCode::INVAL;
+  }
+
+  IpmiGetClientNameParams _param;
+  ORBIS_RET_ON_ERROR(uread(_param, ptr<IpmiGetClientNameParams>(params)));
+  ORBIS_RET_ON_ERROR(
+      uwriteRaw(_param.name, client->name.c_str(), client->name.size() + 1));
+
+  return uwrite<uint>(result, 0);
+}
+
+orbis::SysResult orbis::sysIpmiClientWaitEventFlag(Thread *thread,
+                                                   ptr<uint> result, uint kid,
+                                                   ptr<void> params,
+                                                   uint64_t paramsSz) {
+  struct IpmiWaitEventFlagParam {
+    uint32_t index;
+    uint32_t padding0;
+    uint64_t patternSet;
+    uint32_t mode;
+    uint32_t padding1;
+    ptr<uint64_t> pPatternSet;
+    ptr<uint32_t> pTimeout;
+  };
+
+  static_assert(sizeof(IpmiWaitEventFlagParam) == 0x28);
+
+  if (paramsSz != sizeof(IpmiWaitEventFlagParam)) {
+    return ErrorCode::INVAL;
+  }
+
+  IpmiWaitEventFlagParam _params;
+  ORBIS_RET_ON_ERROR(uread(_params, ptr<IpmiWaitEventFlagParam>(params)));
+
+  auto client = g_context.ipmiMap.get(kid).cast<IpmiClient>();
+
+  if (client == nullptr) {
+    return ErrorCode::INVAL;
+  }
+
+  if (client->eventFlags.size() <= _params.index) {
+    return ErrorCode::INVAL;
+  }
+
+  std::uint32_t resultTimeout{};
+
+  if (_params.pTimeout != nullptr) {
+    ORBIS_RET_ON_ERROR(uread(resultTimeout, _params.pTimeout));
+  }
+
+  auto &evf = client->eventFlags[_params.index];
+  ErrorCode waitResult;
+
+  {
+    orbis::scoped_unblock unblock;
+    waitResult = evf.wait(thread, _params.mode, _params.patternSet,
+                          _params.pTimeout != 0 ? &resultTimeout : nullptr);
+  }
+
+  if (_params.pPatternSet != nullptr) {
+    ORBIS_RET_ON_ERROR(uwrite(_params.pPatternSet, thread->evfResultPattern));
+  }
+
+  ORBIS_RET_ON_ERROR(uwrite(result, 0u));
+  if (_params.pTimeout != nullptr) {
+    ORBIS_RET_ON_ERROR(uwrite(_params.pTimeout, resultTimeout));
+  }
+  if (waitResult == ErrorCode::TIMEDOUT) {
+    return SysResult::notAnError(ErrorCode::TIMEDOUT);
+  }
+  return waitResult;
+}
+
+orbis::SysResult orbis::sysIpmiClientPollEventFlag(Thread *thread,
+                                                   ptr<uint> result, uint kid,
+                                                   ptr<void> params,
+                                                   uint64_t paramsSz) {
+  struct IpmiPollEventFlagParam {
+    uint32_t index;
+    uint32_t padding0;
+    uint64_t patternSet;
+    uint32_t mode;
+    uint32_t padding1;
+    ptr<uint64_t> pPatternSet;
+  };
+
+  static_assert(sizeof(IpmiPollEventFlagParam) == 0x20);
+
+  if (paramsSz != sizeof(IpmiPollEventFlagParam)) {
+    return ErrorCode::INVAL;
+  }
+
+  IpmiPollEventFlagParam _params;
+  ORBIS_RET_ON_ERROR(uread(_params, ptr<IpmiPollEventFlagParam>(params)));
+
+  auto client = g_context.ipmiMap.get(kid).cast<IpmiClient>();
+
+  if (client == nullptr) {
+    return ErrorCode::INVAL;
+  }
+
+  if (client->eventFlags.size() <= _params.index) {
+    return ErrorCode::INVAL;
+  }
+
+  uint64_t patternSet;
+  ORBIS_RET_ON_ERROR(uread(patternSet, _params.pPatternSet));
+  auto &evf = client->eventFlags[_params.index];
+  auto waitResult = evf.tryWait(thread, _params.mode, patternSet);
+
+  ORBIS_RET_ON_ERROR(uread(patternSet, _params.pPatternSet));
+  ORBIS_RET_ON_ERROR(uwrite(_params.pPatternSet, thread->evfResultPattern));
+  ORBIS_RET_ON_ERROR(uwrite(result, 0u));
+  return SysResult::notAnError(waitResult);
+}
+
+orbis::SysResult orbis::sysIpmiSessionSetEventFlag(Thread *thread,
+                                                   ptr<uint> result, uint kid,
+                                                   ptr<void> params,
+                                                   uint64_t paramsSz) {
+  struct IpmiSetEventFlagParam {
+    uint32_t index;
+    uint32_t padding;
+    uint64_t patternSet;
+  };
+
+  static_assert(sizeof(IpmiSetEventFlagParam) == 0x10);
+
+  if (paramsSz != sizeof(IpmiSetEventFlagParam)) {
+    return ErrorCode::INVAL;
+  }
+
+  IpmiSetEventFlagParam _params;
+  ORBIS_RET_ON_ERROR(uread(_params, ptr<IpmiSetEventFlagParam>(params)));
+
+  auto session = g_context.ipmiMap.get(kid).cast<IpmiSession>();
+
+  if (session == nullptr) {
+    return ErrorCode::INVAL;
+  }
+
+  auto client = session->client;
+  if (client == nullptr) {
+    return ErrorCode::INVAL;
+  }
+
+  if (client->eventFlags.size() <= _params.index) {
+    return ErrorCode::INVAL;
+  }
+
+  auto &evf = client->eventFlags[_params.index];
+  evf.set(_params.patternSet);
+  return uwrite<uint>(result, 0);
+}
diff --git a/rpcsx/AudioOut.hpp b/rpcsx/AudioOut.hpp
index 669c6dd32..1ecbbaf7f 100644
--- a/rpcsx/AudioOut.hpp
+++ b/rpcsx/AudioOut.hpp
@@ -4,7 +4,7 @@
 #include <cstdint>
 #include <mutex>
 #include <orbis/evf.hpp>
-#include <orbis/utils/Rc.hpp>
+#include <rx/Rc.hpp>
 #include <thread>
 #include <vector>
 
@@ -12,7 +12,7 @@ struct AudioOutChannelInfo {
   std::int32_t port{};
   std::int32_t idControl{};
   std::int32_t channel{};
-  orbis::Ref<orbis::EventFlag> evf;
+  rx::Ref<orbis::EventFlag> evf;
 };
 
 struct AudioOutParams {
@@ -38,7 +38,7 @@ struct AudioOutParams {
   std::uint32_t sampleLength{};
 };
 
-struct AudioOut : orbis::RcBase {
+struct AudioOut : rx::RcBase {
   std::mutex thrMtx;
   std::mutex soxMtx;
   std::vector<std::thread> threads;
diff --git a/rpcsx/audio/AudioDevice.hpp b/rpcsx/audio/AudioDevice.hpp
index fb3e90f18..b7d3090e6 100644
--- a/rpcsx/audio/AudioDevice.hpp
+++ b/rpcsx/audio/AudioDevice.hpp
@@ -1,7 +1,7 @@
 #pragma once
 
 #include "orbis-config.hpp"
-#include "orbis/utils/Rc.hpp"
+#include "rx/Rc.hpp"
 #include <cstdlib>
 #include <orbis/sys/sysproto.hpp>
 
@@ -18,7 +18,7 @@ enum class AudioFormat : std::uint32_t {
   S32_LE = 0x1000,
 };
 
-class AudioDevice : public orbis::RcBase {
+class AudioDevice : public rx::RcBase {
 protected:
   bool mWorking = false;
   AudioFormat mFormat{};
diff --git a/rpcsx/gpu/Device.hpp b/rpcsx/gpu/Device.hpp
index c7795f67c..da7c1b9d6 100644
--- a/rpcsx/gpu/Device.hpp
+++ b/rpcsx/gpu/Device.hpp
@@ -5,9 +5,9 @@
 #include "Pipe.hpp"
 #include "amdgpu/tiler_vulkan.hpp"
 #include "orbis/KernelAllocator.hpp"
-#include "orbis/utils/Rc.hpp"
-#include "rx/SharedMutex.hpp"
+#include "rx/Rc.hpp"
 #include "rx/MemoryTable.hpp"
+#include "rx/SharedMutex.hpp"
 #include "shader/SemanticInfo.hpp"
 #include "shader/SpvConverter.hpp"
 #include "shader/gcn.hpp"
@@ -63,7 +63,7 @@ struct RemoteMemory {
   }
 };
 
-struct Device : orbis::RcBase, DeviceContext {
+struct Device : rx::RcBase, DeviceContext {
   static constexpr auto kComputePipeCount = 8;
   static constexpr auto kGfxPipeCount = 2;
 
diff --git a/rpcsx/gpu/DeviceCtl.cpp b/rpcsx/gpu/DeviceCtl.cpp
index fb32477dc..e26a2f068 100644
--- a/rpcsx/gpu/DeviceCtl.cpp
+++ b/rpcsx/gpu/DeviceCtl.cpp
@@ -12,7 +12,7 @@
 using namespace amdgpu;
 
 DeviceCtl::DeviceCtl() noexcept = default;
-DeviceCtl::DeviceCtl(orbis::Ref<orbis::RcBase> device) noexcept
+DeviceCtl::DeviceCtl(rx::Ref<rx::RcBase> device) noexcept
     : mDevice(device.rawStaticCast<Device>()) {}
 DeviceCtl::DeviceCtl(DeviceCtl &&) noexcept = default;
 DeviceCtl::DeviceCtl(const DeviceCtl &) = default;
@@ -28,7 +28,7 @@ DeviceCtl DeviceCtl::createDevice() {
 }
 
 DeviceContext &DeviceCtl::getContext() { return *mDevice.get(); }
-orbis::Ref<orbis::RcBase> DeviceCtl::getOpaque() { return mDevice; }
+rx::Ref<rx::RcBase> DeviceCtl::getOpaque() { return mDevice; }
 
 void DeviceCtl::submitGfxCommand(int gfxPipe, int vmId,
                                  std::span<const std::uint32_t> command) {
diff --git a/rpcsx/gpu/DeviceCtl.hpp b/rpcsx/gpu/DeviceCtl.hpp
index 0bc41fbf1..bdd4e1c7f 100644
--- a/rpcsx/gpu/DeviceCtl.hpp
+++ b/rpcsx/gpu/DeviceCtl.hpp
@@ -2,7 +2,7 @@
 
 #include "DeviceContext.hpp"
 #include "orbis-config.hpp"
-#include "orbis/utils/Rc.hpp"
+#include "rx/Rc.hpp"
 #include <cstdint>
 #include <span>
 
@@ -10,11 +10,11 @@ namespace amdgpu {
 class Device;
 
 class DeviceCtl {
-  orbis::Ref<Device> mDevice;
+  rx::Ref<Device> mDevice;
 
 public:
   DeviceCtl() noexcept;
-  DeviceCtl(orbis::Ref<orbis::RcBase> device) noexcept;
+  DeviceCtl(rx::Ref<rx::RcBase> device) noexcept;
   DeviceCtl(DeviceCtl &&) noexcept;
   DeviceCtl(const DeviceCtl &);
   DeviceCtl &operator=(DeviceCtl &&) noexcept;
@@ -23,7 +23,7 @@ public:
 
   static DeviceCtl createDevice();
   DeviceContext &getContext();
-  orbis::Ref<orbis::RcBase> getOpaque();
+  rx::Ref<rx::RcBase> getOpaque();
 
   void submitGfxCommand(int gfxPipe, int vmId,
                         std::span<const std::uint32_t> command);
diff --git a/rpcsx/io-device.cpp b/rpcsx/io-device.cpp
index 9cad681db..e04d08dbe 100644
--- a/rpcsx/io-device.cpp
+++ b/rpcsx/io-device.cpp
@@ -704,7 +704,7 @@ IoDevice *createHostIoDevice(orbis::kstring hostPath,
   return orbis::knew<HostFsDevice>(std::move(hostPath), std::move(virtualPath));
 }
 
-orbis::Ref<orbis::File> wrapSocket(int hostFd, orbis::kstring name, int dom,
+rx::Ref<orbis::File> wrapSocket(int hostFd, orbis::kstring name, int dom,
                                    int type, int prot) {
   auto s = orbis::knew<SocketFile>();
   s->name = std::move(name);
@@ -716,7 +716,7 @@ orbis::Ref<orbis::File> wrapSocket(int hostFd, orbis::kstring name, int dom,
   return s;
 }
 
-orbis::ErrorCode createSocket(orbis::Ref<orbis::File> *file,
+orbis::ErrorCode createSocket(rx::Ref<orbis::File> *file,
                               orbis::kstring name, int dom, int type,
                               int prot) {
   // ORBIS_LOG_ERROR(__FUNCTION__, name, dom, type, prot);
@@ -771,7 +771,7 @@ toRealPath(const std::filesystem::path &inp) {
   return result;
 }
 
-orbis::ErrorCode HostFsDevice::open(orbis::Ref<orbis::File> *file,
+orbis::ErrorCode HostFsDevice::open(rx::Ref<orbis::File> *file,
                                     const char *path, std::uint32_t flags,
                                     std::uint32_t mode, orbis::Thread *thread) {
   auto realPath = hostPath + "/" + path;
@@ -938,7 +938,7 @@ orbis::ErrorCode HostFsDevice::rename(const char *from, const char *to,
   return convertErrorCode(ec);
 }
 
-orbis::File *createHostFile(int hostFd, orbis::Ref<IoDevice> device,
+orbis::File *createHostFile(int hostFd, rx::Ref<IoDevice> device,
                             bool alignTruncate) {
   auto newFile = orbis::knew<HostFile>();
   newFile->hostFd = hostFd;
@@ -951,7 +951,7 @@ orbis::File *createHostFile(int hostFd, orbis::Ref<IoDevice> device,
 struct FdWrapDevice : public IoDevice {
   int fd;
 
-  orbis::ErrorCode open(orbis::Ref<orbis::File> *file, const char *path,
+  orbis::ErrorCode open(rx::Ref<orbis::File> *file, const char *path,
                         std::uint32_t flags, std::uint32_t mode,
                         orbis::Thread *thread) override {
     *file = createHostFile(fd, this);
diff --git a/rpcsx/io-device.hpp b/rpcsx/io-device.hpp
index 5e8ca6f53..a8d0d9b58 100644
--- a/rpcsx/io-device.hpp
+++ b/rpcsx/io-device.hpp
@@ -2,7 +2,7 @@
 
 #include "orbis/KernelAllocator.hpp"
 #include "orbis/file.hpp"
-#include "orbis/utils/Rc.hpp"
+#include "rx/Rc.hpp"
 #include <cstdint>
 #include <system_error>
 
@@ -24,8 +24,8 @@ enum OpenFlags {
   kOpenFlagDirectory = 0x20000,
 };
 
-struct IoDevice : orbis::RcBase {
-  virtual orbis::ErrorCode open(orbis::Ref<orbis::File> *file, const char *path,
+struct IoDevice : rx::RcBase {
+  virtual orbis::ErrorCode open(rx::Ref<orbis::File> *file, const char *path,
                                 std::uint32_t flags, std::uint32_t mode,
                                 orbis::Thread *thread) = 0;
   virtual orbis::ErrorCode unlink(const char *path, bool recursive,
@@ -56,7 +56,7 @@ struct HostFsDevice : IoDevice {
 
   HostFsDevice(orbis::kstring path, orbis::kstring virtualPath)
       : hostPath(std::move(path)), virtualPath(std::move(virtualPath)) {}
-  orbis::ErrorCode open(orbis::Ref<orbis::File> *file, const char *path,
+  orbis::ErrorCode open(rx::Ref<orbis::File> *file, const char *path,
                         std::uint32_t flags, std::uint32_t mode,
                         orbis::Thread *thread) override;
   orbis::ErrorCode unlink(const char *path, bool recursive,
@@ -74,10 +74,10 @@ orbis::ErrorCode convertErrorCode(const std::error_code &code);
 orbis::ErrorCode convertErrno();
 IoDevice *createHostIoDevice(orbis::kstring hostPath,
                              orbis::kstring virtualPath);
-orbis::Ref<orbis::File> wrapSocket(int hostFd, orbis::kstring name, int dom,
+rx::Ref<orbis::File> wrapSocket(int hostFd, orbis::kstring name, int dom,
                                    int type, int prot);
-orbis::ErrorCode createSocket(orbis::Ref<orbis::File> *file,
+orbis::ErrorCode createSocket(rx::Ref<orbis::File> *file,
                               orbis::kstring name, int dom, int type, int prot);
-orbis::File *createHostFile(int hostFd, orbis::Ref<IoDevice> device,
+orbis::File *createHostFile(int hostFd, rx::Ref<IoDevice> device,
                             bool alignTruncate = false);
 IoDevice *createFdWrapDevice(int fd);
diff --git a/rpcsx/iodev/a53io.cpp b/rpcsx/iodev/a53io.cpp
index 06a7cab41..56d5ad124 100644
--- a/rpcsx/iodev/a53io.cpp
+++ b/rpcsx/iodev/a53io.cpp
@@ -27,7 +27,7 @@ static const orbis::FileOps fileOps = {
 };
 
 struct A53IoDevice : IoDevice {
-  orbis::ErrorCode open(orbis::Ref<orbis::File> *file, const char *path,
+  orbis::ErrorCode open(rx::Ref<orbis::File> *file, const char *path,
                         std::uint32_t flags, std::uint32_t mode,
                         orbis::Thread *thread) override {
     auto newFile = orbis::knew<A53IoFile>();
diff --git a/rpcsx/iodev/ajm.cpp b/rpcsx/iodev/ajm.cpp
index 41269ac23..5dd571829 100644
--- a/rpcsx/iodev/ajm.cpp
+++ b/rpcsx/iodev/ajm.cpp
@@ -47,7 +47,7 @@ struct AjmDevice : IoDevice {
   orbis::uint32_t instanceIds[AJM_CODEC_COUNT]{};
   orbis::uint32_t unimplementedInstanceId = 0;
   orbis::kmap<orbis::int32_t, Instance> instanceMap;
-  orbis::ErrorCode open(orbis::Ref<orbis::File> *file, const char *path,
+  orbis::ErrorCode open(rx::Ref<orbis::File> *file, const char *path,
                         std::uint32_t flags, std::uint32_t mode,
                         orbis::Thread *thread) override;
 };
@@ -778,7 +778,7 @@ static const orbis::FileOps fileOps = {
     .ioctl = ajm_ioctl,
 };
 
-orbis::ErrorCode AjmDevice::open(orbis::Ref<orbis::File> *file,
+orbis::ErrorCode AjmDevice::open(rx::Ref<orbis::File> *file,
                                  const char *path, std::uint32_t flags,
                                  std::uint32_t mode, orbis::Thread *thread) {
   auto newFile = orbis::knew<AjmFile>();
diff --git a/rpcsx/iodev/aout.cpp b/rpcsx/iodev/aout.cpp
index 179154c0c..d850e242c 100644
--- a/rpcsx/iodev/aout.cpp
+++ b/rpcsx/iodev/aout.cpp
@@ -7,7 +7,7 @@
 #include "orbis/thread/Thread.hpp"
 #include "orbis/uio.hpp"
 #include "orbis/utils/Logs.hpp"
-#include "orbis/utils/Rc.hpp"
+#include "rx/Rc.hpp"
 #include <bits/types/struct_iovec.h>
 // #include <rx/hexdump.hpp>
 
@@ -29,12 +29,12 @@ struct AoutFile : orbis::File {};
 
 struct AoutDevice : public IoDevice {
   std::int8_t id;
-  orbis::Ref<AudioDevice> audioDevice;
+  rx::Ref<AudioDevice> audioDevice;
 
   AoutDevice(std::int8_t id, AudioDevice *audioDevice)
       : id(id), audioDevice(audioDevice) {}
 
-  orbis::ErrorCode open(orbis::Ref<orbis::File> *file, const char *path,
+  orbis::ErrorCode open(rx::Ref<orbis::File> *file, const char *path,
                         std::uint32_t flags, std::uint32_t mode,
                         orbis::Thread *thread) override;
 };
@@ -192,7 +192,7 @@ static const orbis::FileOps fileOps = {
     .write = aout_write,
 };
 
-orbis::ErrorCode AoutDevice::open(orbis::Ref<orbis::File> *file,
+orbis::ErrorCode AoutDevice::open(rx::Ref<orbis::File> *file,
                                   const char *path, std::uint32_t flags,
                                   std::uint32_t mode, orbis::Thread *thread) {
   ORBIS_LOG_FATAL("aout device open", path, flags, mode);
diff --git a/rpcsx/iodev/av_control.cpp b/rpcsx/iodev/av_control.cpp
index fada50f86..f153ad605 100644
--- a/rpcsx/iodev/av_control.cpp
+++ b/rpcsx/iodev/av_control.cpp
@@ -35,7 +35,7 @@ static const orbis::FileOps fileOps = {
 };
 
 struct AVControlDevice : IoDevice {
-  orbis::ErrorCode open(orbis::Ref<orbis::File> *file, const char *path,
+  orbis::ErrorCode open(rx::Ref<orbis::File> *file, const char *path,
                         std::uint32_t flags, std::uint32_t mode,
                         orbis::Thread *thread) override {
     auto newFile = orbis::knew<AVControlFile>();
diff --git a/rpcsx/iodev/blockpool.cpp b/rpcsx/iodev/blockpool.cpp
index 44cbff1a3..3d5c76e1d 100644
--- a/rpcsx/iodev/blockpool.cpp
+++ b/rpcsx/iodev/blockpool.cpp
@@ -102,7 +102,7 @@ static const orbis::FileOps ops = {
     .mmap = blockpool_mmap,
 };
 
-orbis::ErrorCode BlockPoolDevice::open(orbis::Ref<orbis::File> *file,
+orbis::ErrorCode BlockPoolDevice::open(rx::Ref<orbis::File> *file,
                                        const char *path, std::uint32_t flags,
                                        std::uint32_t mode,
                                        orbis::Thread *thread) {
diff --git a/rpcsx/iodev/blockpool.hpp b/rpcsx/iodev/blockpool.hpp
index c10f2a111..f2ef7d3cd 100644
--- a/rpcsx/iodev/blockpool.hpp
+++ b/rpcsx/iodev/blockpool.hpp
@@ -3,16 +3,16 @@
 #include "io-device.hpp"
 #include "orbis/error/ErrorCode.hpp"
 #include "orbis/file.hpp"
-#include "orbis/utils/Rc.hpp"
-#include "rx/SharedMutex.hpp"
+#include "rx/Rc.hpp"
 #include "rx/MemoryTable.hpp"
+#include "rx/SharedMutex.hpp"
 #include <cstdint>
 
 struct BlockPoolDevice : public IoDevice {
   rx::shared_mutex mtx;
   rx::MemoryAreaTable<> pool;
 
-  orbis::ErrorCode open(orbis::Ref<orbis::File> *file, const char *path,
+  orbis::ErrorCode open(rx::Ref<orbis::File> *file, const char *path,
                         std::uint32_t flags, std::uint32_t mode,
                         orbis::Thread *thread) override;
   orbis::ErrorCode map(void **address, std::uint64_t len, std::int32_t prot,
diff --git a/rpcsx/iodev/bt.cpp b/rpcsx/iodev/bt.cpp
index 1428ab3fc..361bf31e7 100644
--- a/rpcsx/iodev/bt.cpp
+++ b/rpcsx/iodev/bt.cpp
@@ -17,7 +17,7 @@ static const orbis::FileOps fileOps = {
 };
 
 struct BtDevice : IoDevice {
-  orbis::ErrorCode open(orbis::Ref<orbis::File> *file, const char *path,
+  orbis::ErrorCode open(rx::Ref<orbis::File> *file, const char *path,
                         std::uint32_t flags, std::uint32_t mode,
                         orbis::Thread *thread) override {
     auto newFile = orbis::knew<BtFile>();
diff --git a/rpcsx/iodev/camera.cpp b/rpcsx/iodev/camera.cpp
index 4c6f2d503..15ed707c1 100644
--- a/rpcsx/iodev/camera.cpp
+++ b/rpcsx/iodev/camera.cpp
@@ -50,7 +50,7 @@ static const orbis::FileOps fileOps = {
 };
 
 struct CameraDevice : IoDevice {
-  orbis::ErrorCode open(orbis::Ref<orbis::File> *file, const char *path,
+  orbis::ErrorCode open(rx::Ref<orbis::File> *file, const char *path,
                         std::uint32_t flags, std::uint32_t mode,
                         orbis::Thread *thread) override {
     auto newFile = orbis::knew<CameraFile>();
diff --git a/rpcsx/iodev/cayman_reg.cpp b/rpcsx/iodev/cayman_reg.cpp
index 9b3b7f9fa..fe0eb0d6d 100644
--- a/rpcsx/iodev/cayman_reg.cpp
+++ b/rpcsx/iodev/cayman_reg.cpp
@@ -5,7 +5,7 @@
 #include "orbis/utils/Logs.hpp"
 
 struct CaymanRegDevice : IoDevice {
-  orbis::ErrorCode open(orbis::Ref<orbis::File> *file, const char *path,
+  orbis::ErrorCode open(rx::Ref<orbis::File> *file, const char *path,
                         std::uint32_t flags, std::uint32_t mode,
                         orbis::Thread *thread) override;
 };
@@ -22,7 +22,7 @@ static const orbis::FileOps fileOps = {
     .ioctl = cayman_reg_ioctl,
 };
 
-orbis::ErrorCode CaymanRegDevice::open(orbis::Ref<orbis::File> *file,
+orbis::ErrorCode CaymanRegDevice::open(rx::Ref<orbis::File> *file,
                                        const char *path, std::uint32_t flags,
                                        std::uint32_t mode,
                                        orbis::Thread *thread) {
diff --git a/rpcsx/iodev/cd.cpp b/rpcsx/iodev/cd.cpp
index ed6ed9392..946794c54 100644
--- a/rpcsx/iodev/cd.cpp
+++ b/rpcsx/iodev/cd.cpp
@@ -24,7 +24,7 @@ static const orbis::FileOps fileOps = {
 };
 
 struct CdDevice : IoDevice {
-  orbis::ErrorCode open(orbis::Ref<orbis::File> *file, const char *path,
+  orbis::ErrorCode open(rx::Ref<orbis::File> *file, const char *path,
                         std::uint32_t flags, std::uint32_t mode,
                         orbis::Thread *thread) override {
     auto newFile = orbis::knew<CdFile>();
diff --git a/rpcsx/iodev/console.cpp b/rpcsx/iodev/console.cpp
index 348dd4c2a..f71a4c3f0 100644
--- a/rpcsx/iodev/console.cpp
+++ b/rpcsx/iodev/console.cpp
@@ -16,7 +16,7 @@ struct ConsoleDevice : IoDevice {
   ConsoleDevice(int inputFd, int outputFd)
       : inputFd(inputFd), outputFd(outputFd) {}
 
-  orbis::ErrorCode open(orbis::Ref<orbis::File> *file, const char *path,
+  orbis::ErrorCode open(rx::Ref<orbis::File> *file, const char *path,
                         std::uint32_t flags, std::uint32_t mode,
                         orbis::Thread *thread) override;
 };
@@ -64,7 +64,7 @@ static const orbis::FileOps fileOps = {
     .write = console_write,
 };
 
-orbis::ErrorCode ConsoleDevice::open(orbis::Ref<orbis::File> *file,
+orbis::ErrorCode ConsoleDevice::open(rx::Ref<orbis::File> *file,
                                      const char *path, std::uint32_t flags,
                                      std::uint32_t mode,
                                      orbis::Thread *thread) {
diff --git a/rpcsx/iodev/dce.cpp b/rpcsx/iodev/dce.cpp
index 74c0959db..4ac167bc8 100644
--- a/rpcsx/iodev/dce.cpp
+++ b/rpcsx/iodev/dce.cpp
@@ -626,7 +626,7 @@ static void createGpu() {
   }
 }
 
-orbis::ErrorCode DceDevice::open(orbis::Ref<orbis::File> *file,
+orbis::ErrorCode DceDevice::open(rx::Ref<orbis::File> *file,
                                  const char *path, std::uint32_t flags,
                                  std::uint32_t mode, orbis::Thread *thread) {
   auto newFile = orbis::knew<DceFile>();
diff --git a/rpcsx/iodev/dce.hpp b/rpcsx/iodev/dce.hpp
index 5dbd5fee5..1c965b811 100644
--- a/rpcsx/iodev/dce.hpp
+++ b/rpcsx/iodev/dce.hpp
@@ -5,7 +5,7 @@
 #include "orbis/error/ErrorCode.hpp"
 #include "orbis/file.hpp"
 #include "orbis/thread/Process.hpp"
-#include "orbis/utils/Rc.hpp"
+#include "rx/Rc.hpp"
 #include "rx/SharedMutex.hpp"
 
 static constexpr auto kVmIdCount = 6;
@@ -16,7 +16,7 @@ struct DceDevice : IoDevice {
   std::uint32_t freeVmIds = (1 << (kVmIdCount + 1)) - 1;
   orbis::uint64_t dmemOffset = ~static_cast<std::uint64_t>(0);
 
-  orbis::ErrorCode open(orbis::Ref<orbis::File> *file, const char *path,
+  orbis::ErrorCode open(rx::Ref<orbis::File> *file, const char *path,
                         std::uint32_t flags, std::uint32_t mode,
                         orbis::Thread *thread) override;
 
diff --git a/rpcsx/iodev/devact.cpp b/rpcsx/iodev/devact.cpp
index 2b3850f13..203fe23ad 100644
--- a/rpcsx/iodev/devact.cpp
+++ b/rpcsx/iodev/devact.cpp
@@ -49,7 +49,7 @@ static const orbis::FileOps fileOps = {
 };
 
 struct DevActDevice : IoDevice {
-  orbis::ErrorCode open(orbis::Ref<orbis::File> *file, const char *path,
+  orbis::ErrorCode open(rx::Ref<orbis::File> *file, const char *path,
                         std::uint32_t flags, std::uint32_t mode,
                         orbis::Thread *thread) override {
     auto newFile = orbis::knew<DevActFile>();
diff --git a/rpcsx/iodev/devctl.cpp b/rpcsx/iodev/devctl.cpp
index 98d49c7a3..1f1f97afc 100644
--- a/rpcsx/iodev/devctl.cpp
+++ b/rpcsx/iodev/devctl.cpp
@@ -18,7 +18,7 @@ static const orbis::FileOps fileOps = {
 
 struct DevCtlDevice : IoDevice {
   orbis::kstring data;
-  orbis::ErrorCode open(orbis::Ref<orbis::File> *file, const char *path,
+  orbis::ErrorCode open(rx::Ref<orbis::File> *file, const char *path,
                         std::uint32_t flags, std::uint32_t mode,
                         orbis::Thread *thread) override {
     auto newFile = orbis::knew<DevCtlFile>();
diff --git a/rpcsx/iodev/devstat.cpp b/rpcsx/iodev/devstat.cpp
index aa60f9fd7..443971d2a 100644
--- a/rpcsx/iodev/devstat.cpp
+++ b/rpcsx/iodev/devstat.cpp
@@ -17,7 +17,7 @@ static const orbis::FileOps fileOps = {
 };
 
 struct DevStatDevice : IoDevice {
-  orbis::ErrorCode open(orbis::Ref<orbis::File> *file, const char *path,
+  orbis::ErrorCode open(rx::Ref<orbis::File> *file, const char *path,
                         std::uint32_t flags, std::uint32_t mode,
                         orbis::Thread *thread) override {
     auto newFile = orbis::knew<DevStatFile>();
diff --git a/rpcsx/iodev/dipsw.cpp b/rpcsx/iodev/dipsw.cpp
index 99f6b82a6..8f47531bd 100644
--- a/rpcsx/iodev/dipsw.cpp
+++ b/rpcsx/iodev/dipsw.cpp
@@ -61,7 +61,7 @@ static const orbis::FileOps ops = {
 };
 
 struct DipswDevice : public IoDevice {
-  orbis::ErrorCode open(orbis::Ref<orbis::File> *file, const char *path,
+  orbis::ErrorCode open(rx::Ref<orbis::File> *file, const char *path,
                         std::uint32_t flags, std::uint32_t mode,
                         orbis::Thread *thread) override {
     auto newFile = orbis::knew<DipswFile>();
diff --git a/rpcsx/iodev/dmem.cpp b/rpcsx/iodev/dmem.cpp
index 710224919..0cbc3b0cd 100644
--- a/rpcsx/iodev/dmem.cpp
+++ b/rpcsx/iodev/dmem.cpp
@@ -385,7 +385,7 @@ orbis::ErrorCode DmemDevice::queryMaxFreeChunkSize(std::uint64_t *start,
   return {};
 }
 
-orbis::ErrorCode DmemDevice::open(orbis::Ref<orbis::File> *file,
+orbis::ErrorCode DmemDevice::open(rx::Ref<orbis::File> *file,
                                   const char *path, std::uint32_t flags,
                                   std::uint32_t mode, orbis::Thread *thread) {
   auto newFile = orbis::knew<DmemFile>();
diff --git a/rpcsx/iodev/dmem.hpp b/rpcsx/iodev/dmem.hpp
index 6f4b0955d..aa95ead1d 100644
--- a/rpcsx/iodev/dmem.hpp
+++ b/rpcsx/iodev/dmem.hpp
@@ -4,7 +4,7 @@
 #include "orbis/KernelAllocator.hpp"
 #include "orbis/error/ErrorCode.hpp"
 #include "orbis/file.hpp"
-#include "orbis/utils/Rc.hpp"
+#include "rx/Rc.hpp"
 #include "rx/SharedMutex.hpp"
 #include <cstdint>
 #include <rx/MemoryTable.hpp>
@@ -38,7 +38,7 @@ struct DmemDevice : public IoDevice {
 
   orbis::ErrorCode release(std::uint64_t start, std::uint64_t size);
 
-  orbis::ErrorCode open(orbis::Ref<orbis::File> *file, const char *path,
+  orbis::ErrorCode open(rx::Ref<orbis::File> *file, const char *path,
                         std::uint32_t flags, std::uint32_t mode,
                         orbis::Thread *thread) override;
 
diff --git a/rpcsx/iodev/evlg.cpp b/rpcsx/iodev/evlg.cpp
index afad8c0e9..0f7e0302a 100644
--- a/rpcsx/iodev/evlg.cpp
+++ b/rpcsx/iodev/evlg.cpp
@@ -13,7 +13,7 @@ struct EvlgDevice : IoDevice {
 
   EvlgDevice(int outputFd) : outputFd(outputFd) {}
 
-  orbis::ErrorCode open(orbis::Ref<orbis::File> *file, const char *path,
+  orbis::ErrorCode open(rx::Ref<orbis::File> *file, const char *path,
                         std::uint32_t flags, std::uint32_t mode,
                         orbis::Thread *thread) override;
 };
@@ -42,7 +42,7 @@ static const orbis::FileOps fileOps = {
     .write = evlg_write,
 };
 
-orbis::ErrorCode EvlgDevice::open(orbis::Ref<orbis::File> *file,
+orbis::ErrorCode EvlgDevice::open(rx::Ref<orbis::File> *file,
                                   const char *path, std::uint32_t flags,
                                   std::uint32_t mode, orbis::Thread *thread) {
   auto newFile = orbis::knew<EvlgFile>();
diff --git a/rpcsx/iodev/gbase.cpp b/rpcsx/iodev/gbase.cpp
index f6697f18e..12a33d5d1 100644
--- a/rpcsx/iodev/gbase.cpp
+++ b/rpcsx/iodev/gbase.cpp
@@ -37,7 +37,7 @@ static const orbis::FileOps fileOps = {
 };
 
 struct GbaseDevice : IoDevice {
-  orbis::ErrorCode open(orbis::Ref<orbis::File> *file, const char *path,
+  orbis::ErrorCode open(rx::Ref<orbis::File> *file, const char *path,
                         std::uint32_t flags, std::uint32_t mode,
                         orbis::Thread *thread) override {
     auto newFile = orbis::knew<GbaseFile>();
diff --git a/rpcsx/iodev/gc.cpp b/rpcsx/iodev/gc.cpp
index c75900905..8c564c9aa 100644
--- a/rpcsx/iodev/gc.cpp
+++ b/rpcsx/iodev/gc.cpp
@@ -29,7 +29,7 @@ struct GcDevice : public IoDevice {
   orbis::kmap<orbis::pid_t, int> clients;
   orbis::kmap<std::uint64_t, ComputeQueue> computeQueues;
   void *submitArea = nullptr;
-  orbis::ErrorCode open(orbis::Ref<orbis::File> *file, const char *path,
+  orbis::ErrorCode open(rx::Ref<orbis::File> *file, const char *path,
                         std::uint32_t flags, std::uint32_t mode,
                         orbis::Thread *thread) override;
 
@@ -458,7 +458,7 @@ static const orbis::FileOps ops = {
     .mmap = gc_mmap,
 };
 
-orbis::ErrorCode GcDevice::open(orbis::Ref<orbis::File> *file, const char *path,
+orbis::ErrorCode GcDevice::open(rx::Ref<orbis::File> *file, const char *path,
                                 std::uint32_t flags, std::uint32_t mode,
                                 orbis::Thread *thread) {
   auto newFile = orbis::knew<GcFile>();
diff --git a/rpcsx/iodev/hdd.cpp b/rpcsx/iodev/hdd.cpp
index ea031e93a..3cf385abe 100644
--- a/rpcsx/iodev/hdd.cpp
+++ b/rpcsx/iodev/hdd.cpp
@@ -13,7 +13,7 @@ struct HddDevice : IoDevice {
   std::uint64_t size;
   HddDevice(std::uint64_t size) : size(size) {}
 
-  orbis::ErrorCode open(orbis::Ref<orbis::File> *fs, const char *path,
+  orbis::ErrorCode open(rx::Ref<orbis::File> *fs, const char *path,
                         std::uint32_t flags, std::uint32_t mode,
                         orbis::Thread *thread) override;
 };
@@ -135,7 +135,7 @@ static const orbis::FileOps fsOps = {
     .stat = hdd_stat,
 };
 
-orbis::ErrorCode HddDevice::open(orbis::Ref<orbis::File> *fs, const char *path,
+orbis::ErrorCode HddDevice::open(rx::Ref<orbis::File> *fs, const char *path,
                                  std::uint32_t flags, std::uint32_t mode,
                                  orbis::Thread *thread) {
   auto newFile = orbis::knew<HddFile>();
diff --git a/rpcsx/iodev/hdmi.cpp b/rpcsx/iodev/hdmi.cpp
index c874bd904..4196a790a 100644
--- a/rpcsx/iodev/hdmi.cpp
+++ b/rpcsx/iodev/hdmi.cpp
@@ -76,7 +76,7 @@ static const orbis::FileOps fileOps = {
 };
 
 struct HDMIDevice : IoDevice {
-  orbis::ErrorCode open(orbis::Ref<orbis::File> *file, const char *path,
+  orbis::ErrorCode open(rx::Ref<orbis::File> *file, const char *path,
                         std::uint32_t flags, std::uint32_t mode,
                         orbis::Thread *thread) override {
     auto newFile = orbis::knew<HDMIFile>();
diff --git a/rpcsx/iodev/hid.cpp b/rpcsx/iodev/hid.cpp
index 2a081b336..61b6121fd 100644
--- a/rpcsx/iodev/hid.cpp
+++ b/rpcsx/iodev/hid.cpp
@@ -8,7 +8,7 @@
 #include <chrono>
 
 struct HidDevice : public IoDevice {
-  orbis::ErrorCode open(orbis::Ref<orbis::File> *file, const char *path,
+  orbis::ErrorCode open(rx::Ref<orbis::File> *file, const char *path,
                         std::uint32_t flags, std::uint32_t mode,
                         orbis::Thread *thread) override;
 };
@@ -155,7 +155,7 @@ static const orbis::FileOps ops = {
     .ioctl = hid_ioctl,
 };
 
-orbis::ErrorCode HidDevice::open(orbis::Ref<orbis::File> *file,
+orbis::ErrorCode HidDevice::open(rx::Ref<orbis::File> *file,
                                  const char *path, std::uint32_t flags,
                                  std::uint32_t mode, orbis::Thread *thread) {
   auto newFile = orbis::knew<HidFile>();
diff --git a/rpcsx/iodev/hmd2_cmd.cpp b/rpcsx/iodev/hmd2_cmd.cpp
index a31db2a60..a2bd41164 100644
--- a/rpcsx/iodev/hmd2_cmd.cpp
+++ b/rpcsx/iodev/hmd2_cmd.cpp
@@ -3,7 +3,7 @@
 #include "orbis/utils/Logs.hpp"
 
 struct Hmd2CmdDevice : public IoDevice {
-  orbis::ErrorCode open(orbis::Ref<orbis::File> *file, const char *path,
+  orbis::ErrorCode open(rx::Ref<orbis::File> *file, const char *path,
                         std::uint32_t flags, std::uint32_t mode,
                         orbis::Thread *thread) override;
 };
@@ -19,7 +19,7 @@ static const orbis::FileOps ops = {
     .ioctl = hmd2_cmd_ioctl,
 };
 
-orbis::ErrorCode Hmd2CmdDevice::open(orbis::Ref<orbis::File> *file,
+orbis::ErrorCode Hmd2CmdDevice::open(rx::Ref<orbis::File> *file,
                                      const char *path, std::uint32_t flags,
                                      std::uint32_t mode,
                                      orbis::Thread *thread) {
diff --git a/rpcsx/iodev/hmd2_gaze.cpp b/rpcsx/iodev/hmd2_gaze.cpp
index 569488eb3..a3b1070f7 100644
--- a/rpcsx/iodev/hmd2_gaze.cpp
+++ b/rpcsx/iodev/hmd2_gaze.cpp
@@ -3,7 +3,7 @@
 #include "orbis/utils/Logs.hpp"
 
 struct Hmd2GazeDevice : public IoDevice {
-  orbis::ErrorCode open(orbis::Ref<orbis::File> *file, const char *path,
+  orbis::ErrorCode open(rx::Ref<orbis::File> *file, const char *path,
                         std::uint32_t flags, std::uint32_t mode,
                         orbis::Thread *thread) override;
 };
@@ -20,7 +20,7 @@ static const orbis::FileOps ops = {
     .ioctl = hmd2_gaze_ioctl,
 };
 
-orbis::ErrorCode Hmd2GazeDevice::open(orbis::Ref<orbis::File> *file,
+orbis::ErrorCode Hmd2GazeDevice::open(rx::Ref<orbis::File> *file,
                                       const char *path, std::uint32_t flags,
                                       std::uint32_t mode,
                                       orbis::Thread *thread) {
diff --git a/rpcsx/iodev/hmd2_gen_data.cpp b/rpcsx/iodev/hmd2_gen_data.cpp
index f05d04d1e..7542be55f 100644
--- a/rpcsx/iodev/hmd2_gen_data.cpp
+++ b/rpcsx/iodev/hmd2_gen_data.cpp
@@ -3,7 +3,7 @@
 #include "orbis/utils/Logs.hpp"
 
 struct Hmd2GenDataDevice : public IoDevice {
-  orbis::ErrorCode open(orbis::Ref<orbis::File> *file, const char *path,
+  orbis::ErrorCode open(rx::Ref<orbis::File> *file, const char *path,
                         std::uint32_t flags, std::uint32_t mode,
                         orbis::Thread *thread) override;
 };
@@ -20,7 +20,7 @@ static const orbis::FileOps ops = {
     .ioctl = hmd2_gen_data_ioctl,
 };
 
-orbis::ErrorCode Hmd2GenDataDevice::open(orbis::Ref<orbis::File> *file,
+orbis::ErrorCode Hmd2GenDataDevice::open(rx::Ref<orbis::File> *file,
                                          const char *path, std::uint32_t flags,
                                          std::uint32_t mode,
                                          orbis::Thread *thread) {
diff --git a/rpcsx/iodev/hmd2_imu.cpp b/rpcsx/iodev/hmd2_imu.cpp
index 2a3d581c5..d04f164ef 100644
--- a/rpcsx/iodev/hmd2_imu.cpp
+++ b/rpcsx/iodev/hmd2_imu.cpp
@@ -3,7 +3,7 @@
 #include "orbis/utils/Logs.hpp"
 
 struct Hmd2ImuDevice : public IoDevice {
-  orbis::ErrorCode open(orbis::Ref<orbis::File> *file, const char *path,
+  orbis::ErrorCode open(rx::Ref<orbis::File> *file, const char *path,
                         std::uint32_t flags, std::uint32_t mode,
                         orbis::Thread *thread) override;
 };
@@ -19,7 +19,7 @@ static const orbis::FileOps ops = {
     .ioctl = hmd2_imu_ioctl,
 };
 
-orbis::ErrorCode Hmd2ImuDevice::open(orbis::Ref<orbis::File> *file,
+orbis::ErrorCode Hmd2ImuDevice::open(rx::Ref<orbis::File> *file,
                                      const char *path, std::uint32_t flags,
                                      std::uint32_t mode,
                                      orbis::Thread *thread) {
diff --git a/rpcsx/iodev/hmd_3da.cpp b/rpcsx/iodev/hmd_3da.cpp
index 5136b463a..88ba9c660 100644
--- a/rpcsx/iodev/hmd_3da.cpp
+++ b/rpcsx/iodev/hmd_3da.cpp
@@ -4,7 +4,7 @@
 #include "orbis/utils/Logs.hpp"
 
 struct Hmd3daDevice : public IoDevice {
-  orbis::ErrorCode open(orbis::Ref<orbis::File> *file, const char *path,
+  orbis::ErrorCode open(rx::Ref<orbis::File> *file, const char *path,
                         std::uint32_t flags, std::uint32_t mode,
                         orbis::Thread *thread) override;
 };
@@ -22,7 +22,7 @@ static const orbis::FileOps ops = {
     .ioctl = hmd_3da_ioctl,
 };
 
-orbis::ErrorCode Hmd3daDevice::open(orbis::Ref<orbis::File> *file,
+orbis::ErrorCode Hmd3daDevice::open(rx::Ref<orbis::File> *file,
                                     const char *path, std::uint32_t flags,
                                     std::uint32_t mode, orbis::Thread *thread) {
   auto newFile = orbis::knew<Hmd3daFile>();
diff --git a/rpcsx/iodev/hmd_cmd.cpp b/rpcsx/iodev/hmd_cmd.cpp
index fffc61795..b59860f01 100644
--- a/rpcsx/iodev/hmd_cmd.cpp
+++ b/rpcsx/iodev/hmd_cmd.cpp
@@ -3,7 +3,7 @@
 #include "orbis/utils/Logs.hpp"
 
 struct HmdCmdDevice : public IoDevice {
-  orbis::ErrorCode open(orbis::Ref<orbis::File> *file, const char *path,
+  orbis::ErrorCode open(rx::Ref<orbis::File> *file, const char *path,
                         std::uint32_t flags, std::uint32_t mode,
                         orbis::Thread *thread) override;
 };
@@ -21,7 +21,7 @@ static const orbis::FileOps ops = {
     .ioctl = hmd_cmd_ioctl,
 };
 
-orbis::ErrorCode HmdCmdDevice::open(orbis::Ref<orbis::File> *file,
+orbis::ErrorCode HmdCmdDevice::open(rx::Ref<orbis::File> *file,
                                     const char *path, std::uint32_t flags,
                                     std::uint32_t mode, orbis::Thread *thread) {
   auto newFile = orbis::knew<HmdCmdFile>();
diff --git a/rpcsx/iodev/hmd_mmap.cpp b/rpcsx/iodev/hmd_mmap.cpp
index 4f0ff141f..464a0f4b6 100644
--- a/rpcsx/iodev/hmd_mmap.cpp
+++ b/rpcsx/iodev/hmd_mmap.cpp
@@ -4,7 +4,7 @@
 #include "vm.hpp"
 
 struct HmdMmapDevice : public IoDevice {
-  orbis::ErrorCode open(orbis::Ref<orbis::File> *file, const char *path,
+  orbis::ErrorCode open(rx::Ref<orbis::File> *file, const char *path,
                         std::uint32_t flags, std::uint32_t mode,
                         orbis::Thread *thread) override;
 };
@@ -38,7 +38,7 @@ static const orbis::FileOps ops = {
     .mmap = hmd_mmap_mmap,
 };
 
-orbis::ErrorCode HmdMmapDevice::open(orbis::Ref<orbis::File> *file,
+orbis::ErrorCode HmdMmapDevice::open(rx::Ref<orbis::File> *file,
                                      const char *path, std::uint32_t flags,
                                      std::uint32_t mode,
                                      orbis::Thread *thread) {
diff --git a/rpcsx/iodev/hmd_snsr.cpp b/rpcsx/iodev/hmd_snsr.cpp
index effaa2b9d..897448e80 100644
--- a/rpcsx/iodev/hmd_snsr.cpp
+++ b/rpcsx/iodev/hmd_snsr.cpp
@@ -4,7 +4,7 @@
 #include "orbis/utils/Logs.hpp"
 
 struct HmdSnsrDevice : public IoDevice {
-  orbis::ErrorCode open(orbis::Ref<orbis::File> *file, const char *path,
+  orbis::ErrorCode open(rx::Ref<orbis::File> *file, const char *path,
                         std::uint32_t flags, std::uint32_t mode,
                         orbis::Thread *thread) override;
 };
@@ -22,7 +22,7 @@ static const orbis::FileOps ops = {
     .ioctl = hmd_snsr_ioctl,
 };
 
-orbis::ErrorCode HmdSnsrDevice::open(orbis::Ref<orbis::File> *file,
+orbis::ErrorCode HmdSnsrDevice::open(rx::Ref<orbis::File> *file,
                                      const char *path, std::uint32_t flags,
                                      std::uint32_t mode,
                                      orbis::Thread *thread) {
diff --git a/rpcsx/iodev/icc_configuration.cpp b/rpcsx/iodev/icc_configuration.cpp
index 29a68cf52..923bc165e 100644
--- a/rpcsx/iodev/icc_configuration.cpp
+++ b/rpcsx/iodev/icc_configuration.cpp
@@ -19,7 +19,7 @@ static const orbis::FileOps fileOps = {
 };
 
 struct IccConfigurationDevice : IoDevice {
-  orbis::ErrorCode open(orbis::Ref<orbis::File> *file, const char *path,
+  orbis::ErrorCode open(rx::Ref<orbis::File> *file, const char *path,
                         std::uint32_t flags, std::uint32_t mode,
                         orbis::Thread *thread) override {
     auto newFile = orbis::knew<IccConfigurationFile>();
diff --git a/rpcsx/iodev/icc_power.cpp b/rpcsx/iodev/icc_power.cpp
index 7d3dbcb84..476032708 100644
--- a/rpcsx/iodev/icc_power.cpp
+++ b/rpcsx/iodev/icc_power.cpp
@@ -7,7 +7,7 @@
 struct IccPowerDevice : IoDevice {
   std::uint8_t bootphase = 0;
 
-  orbis::ErrorCode open(orbis::Ref<orbis::File> *file, const char *path,
+  orbis::ErrorCode open(rx::Ref<orbis::File> *file, const char *path,
                         std::uint32_t flags, std::uint32_t mode,
                         orbis::Thread *thread) override;
 };
@@ -57,7 +57,7 @@ static const orbis::FileOps fileOps = {
     .stat = icc_stat,
 };
 
-orbis::ErrorCode IccPowerDevice::open(orbis::Ref<orbis::File> *file,
+orbis::ErrorCode IccPowerDevice::open(rx::Ref<orbis::File> *file,
                                       const char *path, std::uint32_t flags,
                                       std::uint32_t mode,
                                       orbis::Thread *thread) {
diff --git a/rpcsx/iodev/lvdctl.cpp b/rpcsx/iodev/lvdctl.cpp
index ae680f1a8..ee2fcb90f 100644
--- a/rpcsx/iodev/lvdctl.cpp
+++ b/rpcsx/iodev/lvdctl.cpp
@@ -18,7 +18,7 @@ static const orbis::FileOps fileOps = {
 };
 
 struct LvdCtlDevice : IoDevice {
-  orbis::ErrorCode open(orbis::Ref<orbis::File> *file, const char *path,
+  orbis::ErrorCode open(rx::Ref<orbis::File> *file, const char *path,
                         std::uint32_t flags, std::uint32_t mode,
                         orbis::Thread *thread) override {
     auto newFile = orbis::knew<LvdCtlFile>();
diff --git a/rpcsx/iodev/mbus.cpp b/rpcsx/iodev/mbus.cpp
index 86a78c603..85ba02f49 100644
--- a/rpcsx/iodev/mbus.cpp
+++ b/rpcsx/iodev/mbus.cpp
@@ -52,7 +52,7 @@ void MBusDevice::emitEvent(const MBusEvent &event) {
   eventEmitter->emit(orbis::kEvFiltRead);
 }
 
-orbis::ErrorCode MBusDevice::open(orbis::Ref<orbis::File> *file,
+orbis::ErrorCode MBusDevice::open(rx::Ref<orbis::File> *file,
                                   const char *path, std::uint32_t flags,
                                   std::uint32_t mode, orbis::Thread *thread) {
   ORBIS_LOG_FATAL("mbus device open");
diff --git a/rpcsx/iodev/mbus.hpp b/rpcsx/iodev/mbus.hpp
index cfa7ef360..4e31db57e 100644
--- a/rpcsx/iodev/mbus.hpp
+++ b/rpcsx/iodev/mbus.hpp
@@ -9,10 +9,10 @@ struct MBusDevice : IoDevice {
   rx::shared_mutex mtx;
   rx::shared_cv cv;
   orbis::kdeque<MBusEvent> events;
-  orbis::Ref<orbis::EventEmitter> eventEmitter =
+  rx::Ref<orbis::EventEmitter> eventEmitter =
       orbis::knew<orbis::EventEmitter>();
 
-  orbis::ErrorCode open(orbis::Ref<orbis::File> *file, const char *path,
+  orbis::ErrorCode open(rx::Ref<orbis::File> *file, const char *path,
                         std::uint32_t flags, std::uint32_t mode,
                         orbis::Thread *thread) override;
 
diff --git a/rpcsx/iodev/mbus_av.cpp b/rpcsx/iodev/mbus_av.cpp
index 610b43ffd..d42275ab7 100644
--- a/rpcsx/iodev/mbus_av.cpp
+++ b/rpcsx/iodev/mbus_av.cpp
@@ -45,7 +45,7 @@ static const orbis::FileOps fileOps = {
     .read = mbus_av_read,
 };
 
-orbis::ErrorCode MBusAVDevice::open(orbis::Ref<orbis::File> *file,
+orbis::ErrorCode MBusAVDevice::open(rx::Ref<orbis::File> *file,
                                     const char *path, std::uint32_t flags,
                                     std::uint32_t mode, orbis::Thread *thread) {
   auto newFile = orbis::knew<MBusAVFile>();
diff --git a/rpcsx/iodev/mbus_av.hpp b/rpcsx/iodev/mbus_av.hpp
index 3211ebaf7..c7e0a5711 100644
--- a/rpcsx/iodev/mbus_av.hpp
+++ b/rpcsx/iodev/mbus_av.hpp
@@ -9,10 +9,10 @@ struct MBusAVDevice : IoDevice {
   rx::shared_mutex mtx;
   rx::shared_cv cv;
   orbis::kdeque<MBusEvent> events;
-  orbis::Ref<orbis::EventEmitter> eventEmitter =
+  rx::Ref<orbis::EventEmitter> eventEmitter =
       orbis::knew<orbis::EventEmitter>();
 
-  orbis::ErrorCode open(orbis::Ref<orbis::File> *file, const char *path,
+  orbis::ErrorCode open(rx::Ref<orbis::File> *file, const char *path,
                         std::uint32_t flags, std::uint32_t mode,
                         orbis::Thread *thread) override;
 
diff --git a/rpcsx/iodev/metadbg.cpp b/rpcsx/iodev/metadbg.cpp
index 5554e6f75..badf28502 100644
--- a/rpcsx/iodev/metadbg.cpp
+++ b/rpcsx/iodev/metadbg.cpp
@@ -27,7 +27,7 @@ static const orbis::FileOps fileOps = {
 };
 
 struct MetaDbgDevice : IoDevice {
-  orbis::ErrorCode open(orbis::Ref<orbis::File> *file, const char *path,
+  orbis::ErrorCode open(rx::Ref<orbis::File> *file, const char *path,
                         std::uint32_t flags, std::uint32_t mode,
                         orbis::Thread *thread) override {
     auto newFile = orbis::knew<MetaDbgFile>();
diff --git a/rpcsx/iodev/notification.cpp b/rpcsx/iodev/notification.cpp
index 0afaf9487..ed623578a 100644
--- a/rpcsx/iodev/notification.cpp
+++ b/rpcsx/iodev/notification.cpp
@@ -18,7 +18,7 @@ struct NotificationDevice : IoDevice {
   orbis::kvector<std::byte> data;
 
   NotificationDevice(int index) : index(index) {}
-  orbis::ErrorCode open(orbis::Ref<orbis::File> *file, const char *path,
+  orbis::ErrorCode open(rx::Ref<orbis::File> *file, const char *path,
                         std::uint32_t flags, std::uint32_t mode,
                         orbis::Thread *thread) override;
 };
@@ -90,7 +90,7 @@ static const orbis::FileOps fileOps = {
     .write = notification_write,
 };
 
-orbis::ErrorCode NotificationDevice::open(orbis::Ref<orbis::File> *file,
+orbis::ErrorCode NotificationDevice::open(rx::Ref<orbis::File> *file,
                                           const char *path, std::uint32_t flags,
                                           std::uint32_t mode,
                                           orbis::Thread *thread) {
diff --git a/rpcsx/iodev/npdrm.cpp b/rpcsx/iodev/npdrm.cpp
index 1f178e135..cfc899128 100644
--- a/rpcsx/iodev/npdrm.cpp
+++ b/rpcsx/iodev/npdrm.cpp
@@ -17,7 +17,7 @@ static const orbis::FileOps fileOps = {
 };
 
 struct NpdrmDevice : IoDevice {
-  orbis::ErrorCode open(orbis::Ref<orbis::File> *file, const char *path,
+  orbis::ErrorCode open(rx::Ref<orbis::File> *file, const char *path,
                         std::uint32_t flags, std::uint32_t mode,
                         orbis::Thread *thread) override {
     auto newFile = orbis::knew<NpdrmFile>();
diff --git a/rpcsx/iodev/nsid_ctl.cpp b/rpcsx/iodev/nsid_ctl.cpp
index 2ffb788bd..3c70e0a0d 100644
--- a/rpcsx/iodev/nsid_ctl.cpp
+++ b/rpcsx/iodev/nsid_ctl.cpp
@@ -35,7 +35,7 @@ static const orbis::FileOps fileOps = {
 };
 
 struct NsidCtlDevice : IoDevice {
-  orbis::ErrorCode open(orbis::Ref<orbis::File> *file, const char *path,
+  orbis::ErrorCode open(rx::Ref<orbis::File> *file, const char *path,
                         std::uint32_t flags, std::uint32_t mode,
                         orbis::Thread *thread) override {
     auto newFile = orbis::knew<NsidCtlFile>();
diff --git a/rpcsx/iodev/null.cpp b/rpcsx/iodev/null.cpp
index 66a327348..b0d6b7f3f 100644
--- a/rpcsx/iodev/null.cpp
+++ b/rpcsx/iodev/null.cpp
@@ -4,7 +4,7 @@
 #include <span>
 
 struct NullDevice : public IoDevice {
-  orbis::ErrorCode open(orbis::Ref<orbis::File> *file, const char *path,
+  orbis::ErrorCode open(rx::Ref<orbis::File> *file, const char *path,
                         std::uint32_t flags, std::uint32_t mode,
                         orbis::Thread *thread) override;
 };
@@ -22,7 +22,7 @@ static const orbis::FileOps ops = {
     .write = null_write,
 };
 
-orbis::ErrorCode NullDevice::open(orbis::Ref<orbis::File> *file,
+orbis::ErrorCode NullDevice::open(rx::Ref<orbis::File> *file,
                                   const char *path, std::uint32_t flags,
                                   std::uint32_t mode, orbis::Thread *thread) {
   auto newFile = orbis::knew<NullFile>();
diff --git a/rpcsx/iodev/rng.cpp b/rpcsx/iodev/rng.cpp
index 77dca67a8..16bf1d366 100644
--- a/rpcsx/iodev/rng.cpp
+++ b/rpcsx/iodev/rng.cpp
@@ -4,7 +4,7 @@
 #include "vm.hpp"
 
 struct RngDevice : public IoDevice {
-  orbis::ErrorCode open(orbis::Ref<orbis::File> *file, const char *path,
+  orbis::ErrorCode open(rx::Ref<orbis::File> *file, const char *path,
                         std::uint32_t flags, std::uint32_t mode,
                         orbis::Thread *thread) override;
 };
@@ -38,7 +38,7 @@ static const orbis::FileOps ops = {
     .mmap = rng_mmap,
 };
 
-orbis::ErrorCode RngDevice::open(orbis::Ref<orbis::File> *file,
+orbis::ErrorCode RngDevice::open(rx::Ref<orbis::File> *file,
                                  const char *path, std::uint32_t flags,
                                  std::uint32_t mode, orbis::Thread *thread) {
   auto newFile = orbis::knew<RngFile>();
diff --git a/rpcsx/iodev/s3da.cpp b/rpcsx/iodev/s3da.cpp
index 5b14ae7ed..626fb1372 100644
--- a/rpcsx/iodev/s3da.cpp
+++ b/rpcsx/iodev/s3da.cpp
@@ -17,7 +17,7 @@ static const orbis::FileOps fileOps = {
 };
 
 struct S3DADevice : IoDevice {
-  orbis::ErrorCode open(orbis::Ref<orbis::File> *file, const char *path,
+  orbis::ErrorCode open(rx::Ref<orbis::File> *file, const char *path,
                         std::uint32_t flags, std::uint32_t mode,
                         orbis::Thread *thread) override {
     auto newFile = orbis::knew<S3DAFile>();
diff --git a/rpcsx/iodev/sbl_srv.cpp b/rpcsx/iodev/sbl_srv.cpp
index 7591264f1..4a346f1a2 100644
--- a/rpcsx/iodev/sbl_srv.cpp
+++ b/rpcsx/iodev/sbl_srv.cpp
@@ -11,7 +11,7 @@ struct SblSrvFile : public orbis::File {};
 
 struct SblSrvDevice : IoDevice {
   rx::shared_mutex mtx;
-  orbis::ErrorCode open(orbis::Ref<orbis::File> *file, const char *path,
+  orbis::ErrorCode open(rx::Ref<orbis::File> *file, const char *path,
                         std::uint32_t flags, std::uint32_t mode,
                         orbis::Thread *thread) override;
 };
@@ -43,7 +43,7 @@ static const orbis::FileOps ops = {
     .mmap = sbl_srv_mmap,
 };
 
-orbis::ErrorCode SblSrvDevice::open(orbis::Ref<orbis::File> *file,
+orbis::ErrorCode SblSrvDevice::open(rx::Ref<orbis::File> *file,
                                     const char *path, std::uint32_t flags,
                                     std::uint32_t mode, orbis::Thread *thread) {
   auto newFile = orbis::knew<SblSrvFile>();
diff --git a/rpcsx/iodev/scanin.cpp b/rpcsx/iodev/scanin.cpp
index b4525bf4d..812faf038 100644
--- a/rpcsx/iodev/scanin.cpp
+++ b/rpcsx/iodev/scanin.cpp
@@ -19,7 +19,7 @@ static const orbis::FileOps fileOps = {
 };
 
 struct ScaninDevice : IoDevice {
-  orbis::ErrorCode open(orbis::Ref<orbis::File> *file, const char *path,
+  orbis::ErrorCode open(rx::Ref<orbis::File> *file, const char *path,
                         std::uint32_t flags, std::uint32_t mode,
                         orbis::Thread *thread) override {
     auto newFile = orbis::knew<ScaninFile>();
diff --git a/rpcsx/iodev/shm.cpp b/rpcsx/iodev/shm.cpp
index ba02cfa34..c60c847a4 100644
--- a/rpcsx/iodev/shm.cpp
+++ b/rpcsx/iodev/shm.cpp
@@ -10,14 +10,14 @@
 #include <sys/mman.h>
 
 struct ShmDevice : IoDevice {
-  orbis::ErrorCode open(orbis::Ref<orbis::File> *file, const char *path,
+  orbis::ErrorCode open(rx::Ref<orbis::File> *file, const char *path,
                         std::uint32_t flags, std::uint32_t mode,
                         orbis::Thread *thread) override;
   orbis::ErrorCode unlink(const char *path, bool recursive,
                           orbis::Thread *thread) override;
 };
 
-orbis::ErrorCode ShmDevice::open(orbis::Ref<orbis::File> *file,
+orbis::ErrorCode ShmDevice::open(rx::Ref<orbis::File> *file,
                                  const char *path, std::uint32_t flags,
                                  std::uint32_t mode, orbis::Thread *thread) {
   ORBIS_LOG_WARNING("shm_open", path, flags, mode);
diff --git a/rpcsx/iodev/srtc.cpp b/rpcsx/iodev/srtc.cpp
index 771b410a9..1eb67a382 100644
--- a/rpcsx/iodev/srtc.cpp
+++ b/rpcsx/iodev/srtc.cpp
@@ -18,7 +18,7 @@ static const orbis::FileOps fileOps = {
 };
 
 struct SrtcDevice : IoDevice {
-  orbis::ErrorCode open(orbis::Ref<orbis::File> *file, const char *path,
+  orbis::ErrorCode open(rx::Ref<orbis::File> *file, const char *path,
                         std::uint32_t flags, std::uint32_t mode,
                         orbis::Thread *thread) override {
     auto newFile = orbis::knew<SrtcFile>();
diff --git a/rpcsx/iodev/sshot.cpp b/rpcsx/iodev/sshot.cpp
index 735dde6c5..7e2cb7067 100644
--- a/rpcsx/iodev/sshot.cpp
+++ b/rpcsx/iodev/sshot.cpp
@@ -19,7 +19,7 @@ static const orbis::FileOps fileOps = {
 };
 
 struct ScreenShotDevice : IoDevice {
-  orbis::ErrorCode open(orbis::Ref<orbis::File> *file, const char *path,
+  orbis::ErrorCode open(rx::Ref<orbis::File> *file, const char *path,
                         std::uint32_t flags, std::uint32_t mode,
                         orbis::Thread *thread) override {
     auto newFile = orbis::knew<ScreenShotFile>();
diff --git a/rpcsx/iodev/urandom.cpp b/rpcsx/iodev/urandom.cpp
index d191693cb..dc79e1f62 100644
--- a/rpcsx/iodev/urandom.cpp
+++ b/rpcsx/iodev/urandom.cpp
@@ -5,7 +5,7 @@
 #include <span>
 
 struct UrandomDevice : public IoDevice {
-  orbis::ErrorCode open(orbis::Ref<orbis::File> *file, const char *path,
+  orbis::ErrorCode open(rx::Ref<orbis::File> *file, const char *path,
                         std::uint32_t flags, std::uint32_t mode,
                         orbis::Thread *thread) override;
 };
@@ -25,7 +25,7 @@ static const orbis::FileOps ops = {
     .read = urandom_read,
 };
 
-orbis::ErrorCode UrandomDevice::open(orbis::Ref<orbis::File> *file,
+orbis::ErrorCode UrandomDevice::open(rx::Ref<orbis::File> *file,
                                      const char *path, std::uint32_t flags,
                                      std::uint32_t mode,
                                      orbis::Thread *thread) {
diff --git a/rpcsx/iodev/uvd.cpp b/rpcsx/iodev/uvd.cpp
index 749ed7acd..2c32a8e39 100644
--- a/rpcsx/iodev/uvd.cpp
+++ b/rpcsx/iodev/uvd.cpp
@@ -17,7 +17,7 @@ static const orbis::FileOps fileOps = {
 };
 
 struct UVDDevice : IoDevice {
-  orbis::ErrorCode open(orbis::Ref<orbis::File> *file, const char *path,
+  orbis::ErrorCode open(rx::Ref<orbis::File> *file, const char *path,
                         std::uint32_t flags, std::uint32_t mode,
                         orbis::Thread *thread) override {
     auto newFile = orbis::knew<UVDFile>();
diff --git a/rpcsx/iodev/vce.cpp b/rpcsx/iodev/vce.cpp
index cbeb74268..fc2a52cb6 100644
--- a/rpcsx/iodev/vce.cpp
+++ b/rpcsx/iodev/vce.cpp
@@ -30,7 +30,7 @@ static const orbis::FileOps fileOps = {
 };
 
 struct VCEDevice : IoDevice {
-  orbis::ErrorCode open(orbis::Ref<orbis::File> *file, const char *path,
+  orbis::ErrorCode open(rx::Ref<orbis::File> *file, const char *path,
                         std::uint32_t flags, std::uint32_t mode,
                         orbis::Thread *thread) override {
     auto newFile = orbis::knew<VCEFile>();
diff --git a/rpcsx/iodev/xpt.cpp b/rpcsx/iodev/xpt.cpp
index 7adda60c0..05b86a703 100644
--- a/rpcsx/iodev/xpt.cpp
+++ b/rpcsx/iodev/xpt.cpp
@@ -23,7 +23,7 @@ static const orbis::FileOps fileOps = {
 };
 
 struct XptDevice : IoDevice {
-  orbis::ErrorCode open(orbis::Ref<orbis::File> *file, const char *path,
+  orbis::ErrorCode open(rx::Ref<orbis::File> *file, const char *path,
                         std::uint32_t flags, std::uint32_t mode,
                         orbis::Thread *thread) override {
     auto newFile = orbis::knew<XptFile>();
diff --git a/rpcsx/iodev/zero.cpp b/rpcsx/iodev/zero.cpp
index c25076c75..b091d2551 100644
--- a/rpcsx/iodev/zero.cpp
+++ b/rpcsx/iodev/zero.cpp
@@ -5,7 +5,7 @@
 #include <span>
 
 struct ZeroDevice : public IoDevice {
-  orbis::ErrorCode open(orbis::Ref<orbis::File> *file, const char *path,
+  orbis::ErrorCode open(rx::Ref<orbis::File> *file, const char *path,
                         std::uint32_t flags, std::uint32_t mode,
                         orbis::Thread *thread) override;
 };
@@ -25,7 +25,7 @@ static const orbis::FileOps ops = {
     .read = zero_read,
 };
 
-orbis::ErrorCode ZeroDevice::open(orbis::Ref<orbis::File> *file,
+orbis::ErrorCode ZeroDevice::open(rx::Ref<orbis::File> *file,
                                   const char *path, std::uint32_t flags,
                                   std::uint32_t mode, orbis::Thread *thread) {
   auto newFile = orbis::knew<ZeroFile>();
diff --git a/rpcsx/ipmi.cpp b/rpcsx/ipmi.cpp
index 5a92b8dd4..3bc2401fa 100644
--- a/rpcsx/ipmi.cpp
+++ b/rpcsx/ipmi.cpp
@@ -118,7 +118,7 @@ orbis::sint ipmi::IpmiClient::sendSyncMessageRaw(
 
 ipmi::IpmiClient ipmi::createIpmiClient(orbis::Thread *thread,
                                         const char *name) {
-  orbis::Ref<orbis::IpmiClient> client;
+  rx::Ref<orbis::IpmiClient> client;
   GuestAlloc config = orbis::IpmiCreateClientConfig{
       .size = sizeof(orbis::IpmiCreateClientConfig),
   };
@@ -178,7 +178,7 @@ orbis::EventFlag *ipmi::createEventFlag(std::string_view name, uint32_t attrs,
 
 void ipmi::createShm(const char *name, uint32_t flags, uint32_t mode,
                      uint64_t size) {
-  orbis::Ref<orbis::File> shm;
+  rx::Ref<orbis::File> shm;
   auto shmDevice = orbis::g_context.shmDevice.staticCast<IoDevice>();
   shmDevice->open(&shm, name, flags, mode, nullptr);
   shm->ops->truncate(shm.get(), size, nullptr);
@@ -299,7 +299,7 @@ ipmi::IpmiServer::handle(orbis::IpmiSession *session,
 ipmi::IpmiServer &ipmi::createIpmiServer(orbis::Process *process,
                                          const char *name) {
   orbis::IpmiCreateServerConfig config{};
-  orbis::Ref<orbis::IpmiServer> serverImpl;
+  rx::Ref<orbis::IpmiServer> serverImpl;
   orbis::ipmiCreateServer(process, nullptr, name, config, serverImpl);
   auto server = std::make_shared<ipmi::IpmiServer>();
   server->serverImpl = serverImpl;
@@ -428,7 +428,7 @@ struct SceSysAudioSystemPortAndThreadArgs {
 };
 
 void ipmi::createAudioSystemObjects(orbis::Process *process) {
-  auto audioOut = orbis::Ref<AudioOut>(orbis::knew<AudioOut>());
+  auto audioOut = rx::Ref<AudioOut>(orbis::knew<AudioOut>());
 
   createIpmiServer(process, "SceSysAudioSystemIpc")
       .addSyncMethod<SceSysAudioSystemThreadArgs>(
diff --git a/rpcsx/ipmi.hpp b/rpcsx/ipmi.hpp
index 5637e7a3e..c66b5e8b3 100644
--- a/rpcsx/ipmi.hpp
+++ b/rpcsx/ipmi.hpp
@@ -10,7 +10,7 @@ template <typename T> std::vector<std::byte> toBytes(const T &value) {
 }
 
 struct IpmiClient {
-  orbis::Ref<orbis::IpmiClient> clientImpl;
+  rx::Ref<orbis::IpmiClient> clientImpl;
   orbis::uint kid;
   orbis::Thread *thread;
 
@@ -44,7 +44,7 @@ struct IpmiClient {
 };
 
 struct IpmiServer {
-  orbis::Ref<orbis::IpmiServer> serverImpl;
+  rx::Ref<orbis::IpmiServer> serverImpl;
 
   std::unordered_map<std::uint32_t,
                      std::function<orbis::ErrorCode(
diff --git a/rpcsx/linker.cpp b/rpcsx/linker.cpp
index e9b8144bf..22705fdfd 100644
--- a/rpcsx/linker.cpp
+++ b/rpcsx/linker.cpp
@@ -16,8 +16,6 @@
 #include <sys/mman.h>
 #include <unordered_map>
 
-using orbis::utils::Ref;
-
 std::uint64_t monoPimpAddress;
 
 static std::vector<std::byte> unself(const std::byte *image, std::size_t size) {
@@ -361,9 +359,9 @@ void rx::linker::override(std::string originalModuleName,
       std::move(replacedModulePath);
 }
 
-Ref<orbis::Module> rx::linker::loadModule(std::span<std::byte> image,
-                                          orbis::Process *process) {
-  Ref<orbis::Module> result{orbis::knew<orbis::Module>()};
+rx::Ref<orbis::Module> rx::linker::loadModule(std::span<std::byte> image,
+                                              orbis::Process *process) {
+  rx::Ref<orbis::Module> result{orbis::knew<orbis::Module>()};
 
   Elf64_Ehdr header;
   std::memcpy(&header, image.data(), sizeof(Elf64_Ehdr));
@@ -973,9 +971,9 @@ Ref<orbis::Module> rx::linker::loadModule(std::span<std::byte> image,
   return result;
 }
 
-static Ref<orbis::Module> loadModuleFileImpl(std::string_view path,
-                                             orbis::Thread *thread) {
-  orbis::Ref<orbis::File> instance;
+static rx::Ref<orbis::Module> loadModuleFileImpl(std::string_view path,
+                                                 orbis::Thread *thread) {
+  rx::Ref<orbis::File> instance;
   if (vfs::open(path, kOpenFlagReadOnly, 0, &instance, thread).isError()) {
     return {};
   }
@@ -1029,8 +1027,8 @@ static Ref<orbis::Module> loadModuleFileImpl(std::string_view path,
   return rx::linker::loadModule(image, thread->tproc);
 }
 
-Ref<orbis::Module> rx::linker::loadModuleFile(std::string_view path,
-                                              orbis::Thread *thread) {
+rx::Ref<orbis::Module> rx::linker::loadModuleFile(std::string_view path,
+                                                  orbis::Thread *thread) {
   if (auto result = loadModuleFileImpl(path, thread)) {
     return result;
   }
diff --git a/rpcsx/linker.hpp b/rpcsx/linker.hpp
index 3b4e3f988..22d48cfe4 100644
--- a/rpcsx/linker.hpp
+++ b/rpcsx/linker.hpp
@@ -1,7 +1,7 @@
 #pragma once
 
 #include "orbis/module/Module.hpp"
-#include "orbis/utils/Rc.hpp"
+#include "rx/Rc.hpp"
 #include <cstddef>
 #include <filesystem>
 #include <optional>
@@ -75,8 +75,8 @@ enum OrbisElfType_t {
 
 void override(std::string originalModuleName,
               std::filesystem::path replacedModulePath);
-orbis::Ref<orbis::Module> loadModule(std::span<std::byte> image,
-                                     orbis::Process *process);
-orbis::Ref<orbis::Module> loadModuleFile(std::string_view path,
-                                         orbis::Thread *thread);
+rx::Ref<orbis::Module> loadModule(std::span<std::byte> image,
+                                  orbis::Process *process);
+rx::Ref<orbis::Module> loadModuleFile(std::string_view path,
+                                      orbis::Thread *thread);
 } // namespace rx::linker
diff --git a/rpcsx/main.cpp b/rpcsx/main.cpp
index c95b98047..fec2f65a3 100644
--- a/rpcsx/main.cpp
+++ b/rpcsx/main.cpp
@@ -19,7 +19,7 @@
 #include "vm.hpp"
 #include "xbyak/xbyak.h"
 #include <optional>
-#include <orbis/utils/Rc.hpp>
+#include <rx/Rc.hpp>
 #include <rx/Version.hpp>
 #include <rx/align.hpp>
 #include <rx/hexdump.hpp>
@@ -519,9 +519,9 @@ static void guestInitDev() {
 }
 
 static void guestInitFd(orbis::Thread *mainThread) {
-  orbis::Ref<orbis::File> stdinFile;
-  orbis::Ref<orbis::File> stdoutFile;
-  orbis::Ref<orbis::File> stderrFile;
+  rx::Ref<orbis::File> stdinFile;
+  rx::Ref<orbis::File> stdoutFile;
+  rx::Ref<orbis::File> stderrFile;
   rx::procOpsTable.open(mainThread, "/dev/stdin", 0, 0, &stdinFile);
   rx::procOpsTable.open(mainThread, "/dev/stdout", 0, 0, &stdoutFile);
   rx::procOpsTable.open(mainThread, "/dev/stderr", 0, 0, &stderrFile);
@@ -551,7 +551,7 @@ struct ExecEnv {
 };
 
 int guestExec(orbis::Thread *mainThread, ExecEnv execEnv,
-              orbis::utils::Ref<orbis::Module> executableModule,
+              rx::Ref<orbis::Module> executableModule,
               std::span<std::string> argv, std::span<std::string> envp) {
   const auto stackEndAddress = 0x7'ffff'c000ull;
   const auto stackSize = 0x40000 * 32;
@@ -657,7 +657,7 @@ struct ProcessParam {
 };
 
 ExecEnv guestCreateExecEnv(orbis::Thread *mainThread,
-                           const orbis::Ref<orbis::Module> &executableModule,
+                           const rx::Ref<orbis::Module> &executableModule,
                            bool isSystem) {
   std::uint64_t interpBase = 0;
   std::uint64_t entryPoint = executableModule->entryPoint;
@@ -760,7 +760,7 @@ ExecEnv guestCreateExecEnv(orbis::Thread *mainThread,
 }
 
 int guestExec(orbis::Thread *mainThread,
-              orbis::utils::Ref<orbis::Module> executableModule,
+              rx::Ref<orbis::Module> executableModule,
               std::span<std::string> argv, std::span<std::string> envp) {
   auto execEnv = guestCreateExecEnv(mainThread, executableModule, true);
   return guestExec(mainThread, execEnv, std::move(executableModule), argv,
@@ -858,14 +858,14 @@ static orbis::SysResult launchDaemon(orbis::Thread *thread, std::string path,
 
   guestInitFd(newThread);
 
-  orbis::Ref<orbis::File> socket;
+  rx::Ref<orbis::File> socket;
   createSocket(&socket, "", 1, 1, 0);
   process->fileDescriptors.insert(socket);
 
   ORBIS_LOG_ERROR(__FUNCTION__, path);
 
   {
-    orbis::Ref<orbis::File> file;
+    rx::Ref<orbis::File> file;
     auto result = vfs::open(path, kOpenFlagReadOnly, 0, &file, thread);
     if (result.isError()) {
       return result;
diff --git a/rpcsx/ops.cpp b/rpcsx/ops.cpp
index 0628a882c..e78f4c1fb 100644
--- a/rpcsx/ops.cpp
+++ b/rpcsx/ops.cpp
@@ -14,7 +14,7 @@
 #include "orbis/uio.hpp"
 #include "orbis/umtx.hpp"
 #include "orbis/utils/Logs.hpp"
-#include "orbis/utils/Rc.hpp"
+#include "rx/Rc.hpp"
 #include "orbis/vm.hpp"
 #include "rx/watchdog.hpp"
 #include "thread.hpp"
@@ -43,11 +43,11 @@ extern bool allowMonoDebug;
 extern "C" void __register_frame(const void *);
 void setupSigHandlers();
 int guestExec(orbis::Thread *mainThread,
-              orbis::utils::Ref<orbis::Module> executableModule,
+              rx::Ref<orbis::Module> executableModule,
               std::span<std::string> argv, std::span<std::string> envp);
 
 namespace {
-static std::pair<SysResult, Ref<Module>>
+static std::pair<SysResult, rx::Ref<Module>>
 loadPrx(orbis::Thread *thread, std::string_view name, bool relocate,
         std::map<std::string, Module *, std::less<>> &loadedObjects,
         std::map<std::string, Module *, std::less<>> &loadedModules,
@@ -130,7 +130,7 @@ loadPrx(orbis::Thread *thread, std::string_view name, bool relocate,
   return {{}, module};
 }
 
-static std::pair<SysResult, Ref<Module>>
+static std::pair<SysResult, rx::Ref<Module>>
 loadPrx(orbis::Thread *thread, std::string_view path, bool relocate) {
   std::map<std::string, Module *, std::less<>> loadedObjects;
   std::map<std::string, Module *, std::less<>> loadedModules;
@@ -296,13 +296,13 @@ query_memory_protection(orbis::Thread *thread, orbis::ptr<void> address,
 
 orbis::SysResult open(orbis::Thread *thread, orbis::ptr<const char> path,
                       orbis::sint flags, orbis::sint mode,
-                      orbis::Ref<orbis::File> *file) {
+                      rx::Ref<orbis::File> *file) {
   return vfs::open(getAbsolutePath(path, thread), flags, mode, file, thread);
 }
 
 orbis::SysResult shm_open(orbis::Thread *thread, const char *path,
                           orbis::sint flags, orbis::sint mode,
-                          orbis::Ref<orbis::File> *file) {
+                          rx::Ref<orbis::File> *file) {
   auto dev = static_cast<IoDevice *>(orbis::g_context.shmDevice.get());
   return dev->open(file, path, flags, mode, thread);
 }
@@ -325,7 +325,7 @@ orbis::SysResult rename(Thread *thread, ptr<const char> from,
 }
 
 orbis::SysResult blockpool_open(orbis::Thread *thread,
-                                orbis::Ref<orbis::File> *file) {
+                                rx::Ref<orbis::File> *file) {
   auto dev = static_cast<IoDevice *>(orbis::g_context.blockpoolDevice.get());
   return dev->open(file, nullptr, 0, 0, thread);
 }
@@ -353,13 +353,13 @@ orbis::SysResult blockpool_unmap(orbis::Thread *thread, orbis::caddr_t addr,
 
 orbis::SysResult socket(orbis::Thread *thread, orbis::ptr<const char> name,
                         orbis::sint domain, orbis::sint type,
-                        orbis::sint protocol, Ref<File> *file) {
+                        orbis::sint protocol, rx::Ref<File> *file) {
   return createSocket(file, name ? name : "", domain, type, protocol);
 }
 
 orbis::SysResult socketPair(orbis::Thread *thread, orbis::sint domain,
                             orbis::sint type, orbis::sint protocol,
-                            Ref<File> *a, Ref<File> *b) {
+                            rx::Ref<File> *a, rx::Ref<File> *b) {
 
   if (domain == 1 && type == 1 && protocol == 0) {
     int fds[2];
@@ -479,7 +479,7 @@ orbis::SysResult dynlib_load_prx(orbis::Thread *thread,
   auto path = getAbsolutePath(_name, thread);
 
   {
-    orbis::Ref<orbis::File> file;
+    rx::Ref<orbis::File> file;
     if (auto result = vfs::open(path, 0, 0, &file, thread); result.isError()) {
       return result;
     }
@@ -571,7 +571,7 @@ SysResult thr_new(orbis::Thread *thread, orbis::ptr<thr_param> param,
     ORBIS_LOG_NOTICE("  rtp: ", _rtp.type, _rtp.prio);
   }
   childThread->handle =
-      std::thread{[=, childThread = Ref<Thread>(childThread)] {
+      std::thread{[=, childThread = rx::Ref<Thread>(childThread)] {
         static_cast<void>(
             uwrite(_param.child_tid, slong(childThread->tid))); // TODO: verify
         auto context = new ucontext_t{};
@@ -893,7 +893,7 @@ SysResult execve(Thread *thread, ptr<char> fname, ptr<ptr<char>> argv,
   //     }
   // }
   {
-    orbis::Ref<File> file;
+    rx::Ref<File> file;
     auto result = vfs::open(path, kOpenFlagReadOnly, 0, &file, thread);
     if (result.isError()) {
       return result;
diff --git a/rpcsx/vfs.cpp b/rpcsx/vfs.cpp
index 54e80e964..ad72128cf 100644
--- a/rpcsx/vfs.cpp
+++ b/rpcsx/vfs.cpp
@@ -19,9 +19,9 @@ static orbis::FileOps devfs_ops = {
 };
 
 struct DevFs : IoDevice {
-  std::map<std::string, orbis::Ref<IoDevice>, std::less<>> devices;
+  std::map<std::string, rx::Ref<IoDevice>, std::less<>> devices;
 
-  orbis::ErrorCode open(orbis::Ref<orbis::File> *file, const char *path,
+  orbis::ErrorCode open(rx::Ref<orbis::File> *file, const char *path,
                         std::uint32_t flags, std::uint32_t mode,
                         orbis::Thread *thread) override {
     if (path[0] == '\0') {
@@ -51,7 +51,7 @@ struct DevFs : IoDevice {
 };
 
 struct ProcFs : IoDevice {
-  orbis::ErrorCode open(orbis::Ref<orbis::File> *file, const char *path,
+  orbis::ErrorCode open(rx::Ref<orbis::File> *file, const char *path,
                         std::uint32_t flags, std::uint32_t mode,
                         orbis::Thread *thread) override {
     std::fprintf(stderr, "procfs access: %s\n", path);
@@ -60,8 +60,8 @@ struct ProcFs : IoDevice {
 };
 
 static rx::shared_mutex gMountMtx;
-static std::map<std::string, orbis::Ref<IoDevice>, std::greater<>> gMountsMap;
-static orbis::Ref<DevFs> gDevFs;
+static std::map<std::string, rx::Ref<IoDevice>, std::greater<>> gMountsMap;
+static rx::Ref<DevFs> gDevFs;
 
 void vfs::fork() {
   std::lock_guard lock(gMountMtx);
@@ -98,11 +98,11 @@ void vfs::addDevice(std::string name, IoDevice *device) {
   gDevFs->devices[std::move(name)] = device;
 }
 
-std::pair<orbis::Ref<IoDevice>, std::string>
+std::pair<rx::Ref<IoDevice>, std::string>
 vfs::get(const std::filesystem::path &guestPath) {
   std::string normalPath = std::filesystem::path(guestPath).lexically_normal();
   std::string_view path = normalPath;
-  orbis::Ref<IoDevice> device;
+  rx::Ref<IoDevice> device;
 
   std::lock_guard lock(gMountMtx);
 
@@ -159,7 +159,7 @@ orbis::SysResult vfs::mount(const std::filesystem::path &guestPath,
 }
 
 orbis::SysResult vfs::open(std::string_view path, int flags, int mode,
-                           orbis::Ref<orbis::File> *file,
+                           rx::Ref<orbis::File> *file,
                            orbis::Thread *thread) {
   auto [device, devPath] = get(path);
   if (device == nullptr) {
@@ -175,7 +175,7 @@ bool vfs::exists(std::string_view path, orbis::Thread *thread) {
     return false;
   }
 
-  orbis::Ref<orbis::File> file;
+  rx::Ref<orbis::File> file;
   if (device->open(&file, devPath.c_str(), 0, 0, thread) !=
       orbis::ErrorCode{}) {
     return false;
diff --git a/rpcsx/vfs.hpp b/rpcsx/vfs.hpp
index b1f23954a..9aa145874 100644
--- a/rpcsx/vfs.hpp
+++ b/rpcsx/vfs.hpp
@@ -2,7 +2,7 @@
 
 #include "orbis/error/SysResult.hpp"
 #include "orbis/file.hpp"
-#include "orbis/utils/Rc.hpp"
+#include "rx/Rc.hpp"
 #include <filesystem>
 
 struct IoDevice;
@@ -12,11 +12,11 @@ void fork();
 void initialize();
 void deinitialize();
 void addDevice(std::string name, IoDevice *device);
-std::pair<orbis::Ref<IoDevice>, std::string>
+std::pair<rx::Ref<IoDevice>, std::string>
 get(const std::filesystem::path &guestPath);
 orbis::SysResult mount(const std::filesystem::path &guestPath, IoDevice *dev);
 orbis::SysResult open(std::string_view path, int flags, int mode,
-                      orbis::Ref<orbis::File> *file, orbis::Thread *thread);
+                      rx::Ref<orbis::File> *file, orbis::Thread *thread);
 bool exists(std::string_view path, orbis::Thread *thread);
 orbis::SysResult mkdir(std::string_view path, int mode, orbis::Thread *thread);
 orbis::SysResult rmdir(std::string_view path, orbis::Thread *thread);
diff --git a/rpcsx/vm.cpp b/rpcsx/vm.cpp
index 2eb7d8fed..5ce577008 100644
--- a/rpcsx/vm.cpp
+++ b/rpcsx/vm.cpp
@@ -7,7 +7,7 @@
 #include "orbis/thread/Process.hpp"
 #include "orbis/thread/Thread.hpp"
 #include "orbis/utils/Logs.hpp"
-#include "orbis/utils/Rc.hpp"
+#include "rx/Rc.hpp"
 #include "rx/format.hpp"
 #include "rx/print.hpp"
 #include "rx/watchdog.hpp"
@@ -649,7 +649,7 @@ struct Block {
 static Block gBlocks[kBlockCount];
 
 struct MapInfo {
-  orbis::Ref<IoDevice> device;
+  rx::Ref<IoDevice> device;
   std::uint64_t offset;
   std::uint32_t flags;
   char name[32];
diff --git a/kernel/orbis/include/orbis/utils/BitSet.hpp b/rx/include/rx/BitSet.hpp
similarity index 97%
rename from kernel/orbis/include/orbis/utils/BitSet.hpp
rename to rx/include/rx/BitSet.hpp
index e1fa4ad0f..fa867dc31 100644
--- a/kernel/orbis/include/orbis/utils/BitSet.hpp
+++ b/rx/include/rx/BitSet.hpp
@@ -3,8 +3,7 @@
 #include <cstddef>
 #include <cstdint>
 
-namespace orbis {
-inline namespace utils {
+namespace rx {
 template <std::size_t Count> struct BitSet {
   using chunk_type = std::uint64_t;
   static constexpr auto BitsPerChunk = sizeof(chunk_type) * 8;
@@ -128,5 +127,4 @@ template <std::size_t Count> struct BitSet {
   [[nodiscard]] constexpr iterator begin() const { return iterator(this); }
   [[nodiscard]] constexpr iterator_end end() const { return {}; }
 };
-} // namespace utils
-} // namespace orbis
+} // namespace rx
diff --git a/kernel/orbis/include/orbis/utils/IdMap.hpp b/rx/include/rx/IdMap.hpp
similarity index 96%
rename from kernel/orbis/include/orbis/utils/IdMap.hpp
rename to rx/include/rx/IdMap.hpp
index 59dcdb3ee..3797efda4 100644
--- a/kernel/orbis/include/orbis/utils/IdMap.hpp
+++ b/rx/include/rx/IdMap.hpp
@@ -2,7 +2,7 @@
 
 #include "BitSet.hpp"
 #include "Rc.hpp"
-#include "rx/SharedMutex.hpp"
+#include "SharedMutex.hpp"
 
 #include <algorithm>
 #include <bit>
@@ -10,8 +10,7 @@
 #include <cstdint>
 #include <type_traits>
 
-namespace orbis {
-inline namespace utils {
+namespace rx {
 template <WithRc T, typename IdT = int, std::size_t MaxId = 4096,
           std::size_t MinId = 0>
   requires(MaxId > MinId)
@@ -178,7 +177,7 @@ public:
     return result;
   }
 
-  IdT insert(const Ref<T> &ref) { return insert(ref.get()); }
+  IdT insert(const rx::Ref<T> &ref) { return insert(ref.get()); }
 
   IdT insert(Ref<T> &&ref) {
     auto object = ref.release();
@@ -200,9 +199,9 @@ public:
     return false;
   }
 
-  bool insert(IdT id, const Ref<T> &ref) { return insert(id, ref.get()); }
+  bool insert(IdT id, const rx::Ref<T> &ref) { return insert(id, ref.get()); }
 
-  bool insert(IdT id, Ref<T> &&ref) {
+  bool insert(IdT id, rx::Ref<T> &&ref) {
     auto object = ref.release();
 
     if (!insert_impl(id, object)) {
@@ -213,7 +212,7 @@ public:
     return true;
   }
 
-  Ref<T> get(IdT id) const {
+  rx::Ref<T> get(IdT id) const {
     const auto rawId = static_cast<std::size_t>(id) - MinId;
 
     if (rawId >= MaxId - MinId) {
@@ -404,5 +403,4 @@ struct OwningIdMap {
     }
   }
 };
-} // namespace utils
-} // namespace orbis
+} // namespace rx
diff --git a/kernel/orbis/include/orbis/utils/LinkedNode.hpp b/rx/include/rx/LinkedNode.hpp
similarity index 89%
rename from kernel/orbis/include/orbis/utils/LinkedNode.hpp
rename to rx/include/rx/LinkedNode.hpp
index f2c005f4b..19f01b4e9 100644
--- a/kernel/orbis/include/orbis/utils/LinkedNode.hpp
+++ b/rx/include/rx/LinkedNode.hpp
@@ -1,7 +1,6 @@
 #pragma once
 
-namespace orbis {
-inline namespace utils {
+namespace rx {
 template <typename T> struct LinkedNode final {
   T object;
   LinkedNode *next = nullptr;
@@ -44,5 +43,4 @@ template <typename T> struct LinkedNode final {
     return result;
   }
 };
-} // namespace utils
-} // namespace orbis
+} // namespace rx
diff --git a/kernel/orbis/include/orbis/utils/Rc.hpp b/rx/include/rx/Rc.hpp
similarity index 83%
rename from kernel/orbis/include/orbis/utils/Rc.hpp
rename to rx/include/rx/Rc.hpp
index 346346458..3c791efd9 100644
--- a/kernel/orbis/include/orbis/utils/Rc.hpp
+++ b/rx/include/rx/Rc.hpp
@@ -2,24 +2,16 @@
 
 #include <atomic>
 #include <cassert>
-#include <cstdlib>
 #include <type_traits>
 #include <utility>
 
-namespace orbis {
-// template <typename T, typename... Args> T *knew(Args &&...args);
-inline namespace utils {
-void kfree(void *ptr, std::size_t size);
-
+namespace rx {
 struct RcBase {
   std::atomic<unsigned> references{0};
-  unsigned _total_size = 0; // Set by knew/kcreate
 
   virtual ~RcBase() = default;
 
   void incRef() {
-    if (!_total_size)
-      std::abort();
     if (references.fetch_add(1, std::memory_order::relaxed) > 4096) {
       assert(!"too many references");
     }
@@ -28,9 +20,7 @@ struct RcBase {
   // returns true if object was destroyed
   bool decRef() {
     if (references.fetch_sub(1, std::memory_order::relaxed) == 1) {
-      auto size = _total_size;
-      this->~RcBase();
-      orbis::utils::kfree(this, size);
+      delete this;
       return true;
     }
 
@@ -141,11 +131,4 @@ public:
 };
 
 template <typename T> Ref(T *) -> Ref<T>;
-
-// template <WithRc T, typename... ArgsT>
-//   requires(std::is_constructible_v<T, ArgsT...>)
-// Ref<T> kcreate(ArgsT &&...args) {
-//   return Ref<T>(knew<T>(std::forward<ArgsT>(args)...));
-// }
-} // namespace utils
-} // namespace orbis
+} // namespace rx
diff --git a/rx/src/SharedCV.cpp b/rx/src/SharedCV.cpp
index 781b4cc42..90f3d3c12 100644
--- a/rx/src/SharedCV.cpp
+++ b/rx/src/SharedCV.cpp
@@ -155,4 +155,4 @@ void shared_cv::impl_wake(shared_mutex &mutex, int _count) noexcept {
   mutex.unlock();
 #endif
 }
-} // namespace orbis::utils
+} // namespace rx