128 files changed, 1120 insertions, 1160 deletions

diff --git a/src/core/hle/ipc_helpers.h b/src/core/hle/ipc_helpers.h
index 3c4e45fcd..004bb2005 100644
--- a/src/core/hle/ipc_helpers.h
+++ b/src/core/hle/ipc_helpers.h
@@ -19,7 +19,7 @@
 
 namespace IPC {
 
-constexpr ResultCode ERR_REMOTE_PROCESS_DEAD{ErrorModule::HIPC, 301};
+constexpr Result ERR_REMOTE_PROCESS_DEAD{ErrorModule::HIPC, 301};
 
 class RequestHelperBase {
 protected:
@@ -176,7 +176,7 @@ public:
     void PushImpl(float value);
     void PushImpl(double value);
     void PushImpl(bool value);
-    void PushImpl(ResultCode value);
+    void PushImpl(Result value);
 
     template <typename T>
     void Push(T value) {
@@ -251,7 +251,7 @@ void ResponseBuilder::PushRaw(const T& value) {
     index += (sizeof(T) + 3) / 4; // round up to word length
 }
 
-inline void ResponseBuilder::PushImpl(ResultCode value) {
+inline void ResponseBuilder::PushImpl(Result value) {
     // Result codes are actually 64-bit in the IPC buffer, but only the high part is discarded.
     Push(value.raw);
     Push<u32>(0);
@@ -481,8 +481,8 @@ inline bool RequestParser::Pop() {
 }
 
 template <>
-inline ResultCode RequestParser::Pop() {
-    return ResultCode{Pop<u32>()};
+inline Result RequestParser::Pop() {
+    return Result{Pop<u32>()};
 }
 
 template <typename T>
diff --git a/src/core/hle/kernel/hle_ipc.cpp b/src/core/hle/kernel/hle_ipc.cpp
index 4650d25b0..45135a07f 100644
--- a/src/core/hle/kernel/hle_ipc.cpp
+++ b/src/core/hle/kernel/hle_ipc.cpp
@@ -188,8 +188,8 @@ void HLERequestContext::ParseCommandBuffer(const KHandleTable& handle_table, u32
     rp.Skip(1, false); // The command is actually an u64, but we don't use the high part.
 }
 
-ResultCode HLERequestContext::PopulateFromIncomingCommandBuffer(const KHandleTable& handle_table,
-                                                                u32_le* src_cmdbuf) {
+Result HLERequestContext::PopulateFromIncomingCommandBuffer(const KHandleTable& handle_table,
+                                                            u32_le* src_cmdbuf) {
     ParseCommandBuffer(handle_table, src_cmdbuf, true);
 
     if (command_header->IsCloseCommand()) {
@@ -202,7 +202,7 @@ ResultCode HLERequestContext::PopulateFromIncomingCommandBuffer(const KHandleTab
     return ResultSuccess;
 }
 
-ResultCode HLERequestContext::WriteToOutgoingCommandBuffer(KThread& requesting_thread) {
+Result HLERequestContext::WriteToOutgoingCommandBuffer(KThread& requesting_thread) {
     auto current_offset = handles_offset;
     auto& owner_process = *requesting_thread.GetOwnerProcess();
     auto& handle_table = owner_process.GetHandleTable();
diff --git a/src/core/hle/kernel/hle_ipc.h b/src/core/hle/kernel/hle_ipc.h
index 0ddc8df9e..d3abeee85 100644
--- a/src/core/hle/kernel/hle_ipc.h
+++ b/src/core/hle/kernel/hle_ipc.h
@@ -18,7 +18,7 @@
 #include "core/hle/ipc.h"
 #include "core/hle/kernel/svc_common.h"
 
-union ResultCode;
+union Result;
 
 namespace Core::Memory {
 class Memory;
@@ -71,10 +71,10 @@ public:
      * it should be used to differentiate which client (As in ClientSession) we're answering to.
      * TODO(Subv): Use a wrapper structure to hold all the information relevant to
      * this request (ServerSession, Originator thread, Translated command buffer, etc).
-     * @returns ResultCode the result code of the translate operation.
+     * @returns Result the result code of the translate operation.
      */
-    virtual ResultCode HandleSyncRequest(Kernel::KServerSession& session,
-                                         Kernel::HLERequestContext& context) = 0;
+    virtual Result HandleSyncRequest(Kernel::KServerSession& session,
+                                     Kernel::HLERequestContext& context) = 0;
 
     /**
      * Signals that a client has just connected to this HLE handler and keeps the
@@ -212,11 +212,10 @@ public:
     }
 
     /// Populates this context with data from the requesting process/thread.
-    ResultCode PopulateFromIncomingCommandBuffer(const KHandleTable& handle_table,
-                                                 u32_le* src_cmdbuf);
+    Result PopulateFromIncomingCommandBuffer(const KHandleTable& handle_table, u32_le* src_cmdbuf);
 
     /// Writes data from this context back to the requesting process/thread.
-    ResultCode WriteToOutgoingCommandBuffer(KThread& requesting_thread);
+    Result WriteToOutgoingCommandBuffer(KThread& requesting_thread);
 
     u32_le GetHipcCommand() const {
         return command;
diff --git a/src/core/hle/kernel/k_address_arbiter.cpp b/src/core/hle/kernel/k_address_arbiter.cpp
index 5fa67bae1..f85b11557 100644
--- a/src/core/hle/kernel/k_address_arbiter.cpp
+++ b/src/core/hle/kernel/k_address_arbiter.cpp
@@ -90,8 +90,7 @@ public:
     explicit ThreadQueueImplForKAddressArbiter(KernelCore& kernel_, KAddressArbiter::ThreadTree* t)
         : KThreadQueue(kernel_), m_tree(t) {}
 
-    void CancelWait(KThread* waiting_thread, ResultCode wait_result,
-                    bool cancel_timer_task) override {
+    void CancelWait(KThread* waiting_thread, Result wait_result, bool cancel_timer_task) override {
         // If the thread is waiting on an address arbiter, remove it from the tree.
         if (waiting_thread->IsWaitingForAddressArbiter()) {
             m_tree->erase(m_tree->iterator_to(*waiting_thread));
@@ -108,7 +107,7 @@ private:
 
 } // namespace
 
-ResultCode KAddressArbiter::Signal(VAddr addr, s32 count) {
+Result KAddressArbiter::Signal(VAddr addr, s32 count) {
     // Perform signaling.
     s32 num_waiters{};
     {
@@ -131,7 +130,7 @@ ResultCode KAddressArbiter::Signal(VAddr addr, s32 count) {
     return ResultSuccess;
 }
 
-ResultCode KAddressArbiter::SignalAndIncrementIfEqual(VAddr addr, s32 value, s32 count) {
+Result KAddressArbiter::SignalAndIncrementIfEqual(VAddr addr, s32 value, s32 count) {
     // Perform signaling.
     s32 num_waiters{};
     {
@@ -164,7 +163,7 @@ ResultCode KAddressArbiter::SignalAndIncrementIfEqual(VAddr addr, s32 value, s32
     return ResultSuccess;
 }
 
-ResultCode KAddressArbiter::SignalAndModifyByWaitingCountIfEqual(VAddr addr, s32 value, s32 count) {
+Result KAddressArbiter::SignalAndModifyByWaitingCountIfEqual(VAddr addr, s32 value, s32 count) {
     // Perform signaling.
     s32 num_waiters{};
     {
@@ -232,7 +231,7 @@ ResultCode KAddressArbiter::SignalAndModifyByWaitingCountIfEqual(VAddr addr, s32
     return ResultSuccess;
 }
 
-ResultCode KAddressArbiter::WaitIfLessThan(VAddr addr, s32 value, bool decrement, s64 timeout) {
+Result KAddressArbiter::WaitIfLessThan(VAddr addr, s32 value, bool decrement, s64 timeout) {
     // Prepare to wait.
     KThread* cur_thread = GetCurrentThreadPointer(kernel);
     ThreadQueueImplForKAddressArbiter wait_queue(kernel, std::addressof(thread_tree));
@@ -285,7 +284,7 @@ ResultCode KAddressArbiter::WaitIfLessThan(VAddr addr, s32 value, bool decrement
     return cur_thread->GetWaitResult();
 }
 
-ResultCode KAddressArbiter::WaitIfEqual(VAddr addr, s32 value, s64 timeout) {
+Result KAddressArbiter::WaitIfEqual(VAddr addr, s32 value, s64 timeout) {
     // Prepare to wait.
     KThread* cur_thread = GetCurrentThreadPointer(kernel);
     ThreadQueueImplForKAddressArbiter wait_queue(kernel, std::addressof(thread_tree));
diff --git a/src/core/hle/kernel/k_address_arbiter.h b/src/core/hle/kernel/k_address_arbiter.h
index 5fa19d386..e4085ae22 100644
--- a/src/core/hle/kernel/k_address_arbiter.h
+++ b/src/core/hle/kernel/k_address_arbiter.h
@@ -8,7 +8,7 @@
 #include "core/hle/kernel/k_condition_variable.h"
 #include "core/hle/kernel/svc_types.h"
 
-union ResultCode;
+union Result;
 
 namespace Core {
 class System;
@@ -25,8 +25,7 @@ public:
     explicit KAddressArbiter(Core::System& system_);
     ~KAddressArbiter();
 
-    [[nodiscard]] ResultCode SignalToAddress(VAddr addr, Svc::SignalType type, s32 value,
-                                             s32 count) {
+    [[nodiscard]] Result SignalToAddress(VAddr addr, Svc::SignalType type, s32 value, s32 count) {
         switch (type) {
         case Svc::SignalType::Signal:
             return Signal(addr, count);
@@ -39,8 +38,8 @@ public:
         return ResultUnknown;
     }
 
-    [[nodiscard]] ResultCode WaitForAddress(VAddr addr, Svc::ArbitrationType type, s32 value,
-                                            s64 timeout) {
+    [[nodiscard]] Result WaitForAddress(VAddr addr, Svc::ArbitrationType type, s32 value,
+                                        s64 timeout) {
         switch (type) {
         case Svc::ArbitrationType::WaitIfLessThan:
             return WaitIfLessThan(addr, value, false, timeout);
@@ -54,11 +53,11 @@ public:
     }
 
 private:
-    [[nodiscard]] ResultCode Signal(VAddr addr, s32 count);
-    [[nodiscard]] ResultCode SignalAndIncrementIfEqual(VAddr addr, s32 value, s32 count);
-    [[nodiscard]] ResultCode SignalAndModifyByWaitingCountIfEqual(VAddr addr, s32 value, s32 count);
-    [[nodiscard]] ResultCode WaitIfLessThan(VAddr addr, s32 value, bool decrement, s64 timeout);
-    [[nodiscard]] ResultCode WaitIfEqual(VAddr addr, s32 value, s64 timeout);
+    [[nodiscard]] Result Signal(VAddr addr, s32 count);
+    [[nodiscard]] Result SignalAndIncrementIfEqual(VAddr addr, s32 value, s32 count);
+    [[nodiscard]] Result SignalAndModifyByWaitingCountIfEqual(VAddr addr, s32 value, s32 count);
+    [[nodiscard]] Result WaitIfLessThan(VAddr addr, s32 value, bool decrement, s64 timeout);
+    [[nodiscard]] Result WaitIfEqual(VAddr addr, s32 value, s64 timeout);
 
     ThreadTree thread_tree;
 
diff --git a/src/core/hle/kernel/k_client_port.cpp b/src/core/hle/kernel/k_client_port.cpp
index ef168fe87..d63e77d15 100644
--- a/src/core/hle/kernel/k_client_port.cpp
+++ b/src/core/hle/kernel/k_client_port.cpp
@@ -59,8 +59,8 @@ bool KClientPort::IsSignaled() const {
     return num_sessions < max_sessions;
 }
 
-ResultCode KClientPort::CreateSession(KClientSession** out,
-                                      std::shared_ptr<SessionRequestManager> session_manager) {
+Result KClientPort::CreateSession(KClientSession** out,
+                                  std::shared_ptr<SessionRequestManager> session_manager) {
     // Reserve a new session from the resource limit.
     KScopedResourceReservation session_reservation(kernel.CurrentProcess()->GetResourceLimit(),
                                                    LimitableResource::Sessions);
diff --git a/src/core/hle/kernel/k_client_port.h b/src/core/hle/kernel/k_client_port.h
index 54bb05e20..ef8583efc 100644
--- a/src/core/hle/kernel/k_client_port.h
+++ b/src/core/hle/kernel/k_client_port.h
@@ -53,8 +53,8 @@ public:
     void Destroy() override;
     bool IsSignaled() const override;
 
-    ResultCode CreateSession(KClientSession** out,
-                             std::shared_ptr<SessionRequestManager> session_manager = nullptr);
+    Result CreateSession(KClientSession** out,
+                         std::shared_ptr<SessionRequestManager> session_manager = nullptr);
 
 private:
     std::atomic<s32> num_sessions{};
diff --git a/src/core/hle/kernel/k_client_session.cpp b/src/core/hle/kernel/k_client_session.cpp
index 731af079c..b2a887b14 100644
--- a/src/core/hle/kernel/k_client_session.cpp
+++ b/src/core/hle/kernel/k_client_session.cpp
@@ -21,8 +21,8 @@ void KClientSession::Destroy() {
 
 void KClientSession::OnServerClosed() {}
 
-ResultCode KClientSession::SendSyncRequest(KThread* thread, Core::Memory::Memory& memory,
-                                           Core::Timing::CoreTiming& core_timing) {
+Result KClientSession::SendSyncRequest(KThread* thread, Core::Memory::Memory& memory,
+                                       Core::Timing::CoreTiming& core_timing) {
     // Signal the server session that new data is available
     return parent->GetServerSession().HandleSyncRequest(thread, memory, core_timing);
 }
diff --git a/src/core/hle/kernel/k_client_session.h b/src/core/hle/kernel/k_client_session.h
index 7a7ec8450..0c750d756 100644
--- a/src/core/hle/kernel/k_client_session.h
+++ b/src/core/hle/kernel/k_client_session.h
@@ -9,7 +9,7 @@
 #include "core/hle/kernel/slab_helpers.h"
 #include "core/hle/result.h"
 
-union ResultCode;
+union Result;
 
 namespace Core::Memory {
 class Memory;
@@ -46,8 +46,8 @@ public:
         return parent;
     }
 
-    ResultCode SendSyncRequest(KThread* thread, Core::Memory::Memory& memory,
-                               Core::Timing::CoreTiming& core_timing);
+    Result SendSyncRequest(KThread* thread, Core::Memory::Memory& memory,
+                           Core::Timing::CoreTiming& core_timing);
 
     void OnServerClosed();
 
diff --git a/src/core/hle/kernel/k_code_memory.cpp b/src/core/hle/kernel/k_code_memory.cpp
index 4ae40ec8e..da57ceb21 100644
--- a/src/core/hle/kernel/k_code_memory.cpp
+++ b/src/core/hle/kernel/k_code_memory.cpp
@@ -7,7 +7,7 @@
 #include "core/hle/kernel/k_code_memory.h"
 #include "core/hle/kernel/k_light_lock.h"
 #include "core/hle/kernel/k_memory_block.h"
-#include "core/hle/kernel/k_page_linked_list.h"
+#include "core/hle/kernel/k_page_group.h"
 #include "core/hle/kernel/k_page_table.h"
 #include "core/hle/kernel/k_process.h"
 #include "core/hle/kernel/slab_helpers.h"
@@ -19,7 +19,7 @@ namespace Kernel {
 KCodeMemory::KCodeMemory(KernelCore& kernel_)
     : KAutoObjectWithSlabHeapAndContainer{kernel_}, m_lock(kernel_) {}
 
-ResultCode KCodeMemory::Initialize(Core::DeviceMemory& device_memory, VAddr addr, size_t size) {
+Result KCodeMemory::Initialize(Core::DeviceMemory& device_memory, VAddr addr, size_t size) {
     // Set members.
     m_owner = kernel.CurrentProcess();
 
@@ -62,7 +62,7 @@ void KCodeMemory::Finalize() {
     m_owner->Close();
 }
 
-ResultCode KCodeMemory::Map(VAddr address, size_t size) {
+Result KCodeMemory::Map(VAddr address, size_t size) {
     // Validate the size.
     R_UNLESS(m_page_group.GetNumPages() == Common::DivideUp(size, PageSize), ResultInvalidSize);
 
@@ -82,7 +82,7 @@ ResultCode KCodeMemory::Map(VAddr address, size_t size) {
     return ResultSuccess;
 }
 
-ResultCode KCodeMemory::Unmap(VAddr address, size_t size) {
+Result KCodeMemory::Unmap(VAddr address, size_t size) {
     // Validate the size.
     R_UNLESS(m_page_group.GetNumPages() == Common::DivideUp(size, PageSize), ResultInvalidSize);
 
@@ -99,7 +99,7 @@ ResultCode KCodeMemory::Unmap(VAddr address, size_t size) {
     return ResultSuccess;
 }
 
-ResultCode KCodeMemory::MapToOwner(VAddr address, size_t size, Svc::MemoryPermission perm) {
+Result KCodeMemory::MapToOwner(VAddr address, size_t size, Svc::MemoryPermission perm) {
     // Validate the size.
     R_UNLESS(m_page_group.GetNumPages() == Common::DivideUp(size, PageSize), ResultInvalidSize);
 
@@ -133,7 +133,7 @@ ResultCode KCodeMemory::MapToOwner(VAddr address, size_t size, Svc::MemoryPermis
     return ResultSuccess;
 }
 
-ResultCode KCodeMemory::UnmapFromOwner(VAddr address, size_t size) {
+Result KCodeMemory::UnmapFromOwner(VAddr address, size_t size) {
     // Validate the size.
     R_UNLESS(m_page_group.GetNumPages() == Common::DivideUp(size, PageSize), ResultInvalidSize);
 
diff --git a/src/core/hle/kernel/k_code_memory.h b/src/core/hle/kernel/k_code_memory.h
index ab06b6f29..2410f74a3 100644
--- a/src/core/hle/kernel/k_code_memory.h
+++ b/src/core/hle/kernel/k_code_memory.h
@@ -7,7 +7,7 @@
 #include "core/device_memory.h"
 #include "core/hle/kernel/k_auto_object.h"
 #include "core/hle/kernel/k_light_lock.h"
-#include "core/hle/kernel/k_page_linked_list.h"
+#include "core/hle/kernel/k_page_group.h"
 #include "core/hle/kernel/k_process.h"
 #include "core/hle/kernel/slab_helpers.h"
 #include "core/hle/kernel/svc_types.h"
@@ -29,13 +29,13 @@ class KCodeMemory final
 public:
     explicit KCodeMemory(KernelCore& kernel_);
 
-    ResultCode Initialize(Core::DeviceMemory& device_memory, VAddr address, size_t size);
+    Result Initialize(Core::DeviceMemory& device_memory, VAddr address, size_t size);
     void Finalize();
 
-    ResultCode Map(VAddr address, size_t size);
-    ResultCode Unmap(VAddr address, size_t size);
-    ResultCode MapToOwner(VAddr address, size_t size, Svc::MemoryPermission perm);
-    ResultCode UnmapFromOwner(VAddr address, size_t size);
+    Result Map(VAddr address, size_t size);
+    Result Unmap(VAddr address, size_t size);
+    Result MapToOwner(VAddr address, size_t size, Svc::MemoryPermission perm);
+    Result UnmapFromOwner(VAddr address, size_t size);
 
     bool IsInitialized() const {
         return m_is_initialized;
@@ -53,7 +53,7 @@ public:
     }
 
 private:
-    KPageLinkedList m_page_group{};
+    KPageGroup m_page_group{};
     KProcess* m_owner{};
     VAddr m_address{};
     KLightLock m_lock;
diff --git a/src/core/hle/kernel/k_condition_variable.cpp b/src/core/hle/kernel/k_condition_variable.cpp
index a8b5411e3..124149697 100644
--- a/src/core/hle/kernel/k_condition_variable.cpp
+++ b/src/core/hle/kernel/k_condition_variable.cpp
@@ -61,8 +61,7 @@ public:
     explicit ThreadQueueImplForKConditionVariableWaitForAddress(KernelCore& kernel_)
         : KThreadQueue(kernel_) {}
 
-    void CancelWait(KThread* waiting_thread, ResultCode wait_result,
-                    bool cancel_timer_task) override {
+    void CancelWait(KThread* waiting_thread, Result wait_result, bool cancel_timer_task) override {
         // Remove the thread as a waiter from its owner.
         waiting_thread->GetLockOwner()->RemoveWaiter(waiting_thread);
 
@@ -80,8 +79,7 @@ public:
         KernelCore& kernel_, KConditionVariable::ThreadTree* t)
         : KThreadQueue(kernel_), m_tree(t) {}
 
-    void CancelWait(KThread* waiting_thread, ResultCode wait_result,
-                    bool cancel_timer_task) override {
+    void CancelWait(KThread* waiting_thread, Result wait_result, bool cancel_timer_task) override {
         // Remove the thread as a waiter from its owner.
         if (KThread* owner = waiting_thread->GetLockOwner(); owner != nullptr) {
             owner->RemoveWaiter(waiting_thread);
@@ -105,7 +103,7 @@ KConditionVariable::KConditionVariable(Core::System& system_)
 
 KConditionVariable::~KConditionVariable() = default;
 
-ResultCode KConditionVariable::SignalToAddress(VAddr addr) {
+Result KConditionVariable::SignalToAddress(VAddr addr) {
     KThread* owner_thread = GetCurrentThreadPointer(kernel);
 
     // Signal the address.
@@ -126,7 +124,7 @@ ResultCode KConditionVariable::SignalToAddress(VAddr addr) {
             }
 
             // Write the value to userspace.
-            ResultCode result{ResultSuccess};
+            Result result{ResultSuccess};
             if (WriteToUser(system, addr, std::addressof(next_value))) [[likely]] {
                 result = ResultSuccess;
             } else {
@@ -146,7 +144,7 @@ ResultCode KConditionVariable::SignalToAddress(VAddr addr) {
     }
 }
 
-ResultCode KConditionVariable::WaitForAddress(Handle handle, VAddr addr, u32 value) {
+Result KConditionVariable::WaitForAddress(Handle handle, VAddr addr, u32 value) {
     KThread* cur_thread = GetCurrentThreadPointer(kernel);
     ThreadQueueImplForKConditionVariableWaitForAddress wait_queue(kernel);
 
@@ -261,7 +259,7 @@ void KConditionVariable::Signal(u64 cv_key, s32 count) {
     }
 }
 
-ResultCode KConditionVariable::Wait(VAddr addr, u64 key, u32 value, s64 timeout) {
+Result KConditionVariable::Wait(VAddr addr, u64 key, u32 value, s64 timeout) {
     // Prepare to wait.
     KThread* cur_thread = GetCurrentThreadPointer(kernel);
     ThreadQueueImplForKConditionVariableWaitConditionVariable wait_queue(
diff --git a/src/core/hle/kernel/k_condition_variable.h b/src/core/hle/kernel/k_condition_variable.h
index 7bc749d98..fad4ed011 100644
--- a/src/core/hle/kernel/k_condition_variable.h
+++ b/src/core/hle/kernel/k_condition_variable.h
@@ -25,12 +25,12 @@ public:
     ~KConditionVariable();
 
     // Arbitration
-    [[nodiscard]] ResultCode SignalToAddress(VAddr addr);
-    [[nodiscard]] ResultCode WaitForAddress(Handle handle, VAddr addr, u32 value);
+    [[nodiscard]] Result SignalToAddress(VAddr addr);
+    [[nodiscard]] Result WaitForAddress(Handle handle, VAddr addr, u32 value);
 
     // Condition variable
     void Signal(u64 cv_key, s32 count);
-    [[nodiscard]] ResultCode Wait(VAddr addr, u64 key, u32 value, s64 timeout);
+    [[nodiscard]] Result Wait(VAddr addr, u64 key, u32 value, s64 timeout);
 
 private:
     void SignalImpl(KThread* thread);
diff --git a/src/core/hle/kernel/k_handle_table.cpp b/src/core/hle/kernel/k_handle_table.cpp
index c453927ad..e830ca46e 100644
--- a/src/core/hle/kernel/k_handle_table.cpp
+++ b/src/core/hle/kernel/k_handle_table.cpp
@@ -8,7 +8,7 @@ namespace Kernel {
 KHandleTable::KHandleTable(KernelCore& kernel_) : kernel{kernel_} {}
 KHandleTable::~KHandleTable() = default;
 
-ResultCode KHandleTable::Finalize() {
+Result KHandleTable::Finalize() {
     // Get the table and clear our record of it.
     u16 saved_table_size = 0;
     {
@@ -62,7 +62,7 @@ bool KHandleTable::Remove(Handle handle) {
     return true;
 }
 
-ResultCode KHandleTable::Add(Handle* out_handle, KAutoObject* obj) {
+Result KHandleTable::Add(Handle* out_handle, KAutoObject* obj) {
     KScopedDisableDispatch dd(kernel);
     KScopedSpinLock lk(m_lock);
 
@@ -85,7 +85,7 @@ ResultCode KHandleTable::Add(Handle* out_handle, KAutoObject* obj) {
     return ResultSuccess;
 }
 
-ResultCode KHandleTable::Reserve(Handle* out_handle) {
+Result KHandleTable::Reserve(Handle* out_handle) {
     KScopedDisableDispatch dd(kernel);
     KScopedSpinLock lk(m_lock);
 
diff --git a/src/core/hle/kernel/k_handle_table.h b/src/core/hle/kernel/k_handle_table.h
index befdb2ec9..0864a737c 100644
--- a/src/core/hle/kernel/k_handle_table.h
+++ b/src/core/hle/kernel/k_handle_table.h
@@ -30,7 +30,7 @@ public:
     explicit KHandleTable(KernelCore& kernel_);
     ~KHandleTable();
 
-    ResultCode Initialize(s32 size) {
+    Result Initialize(s32 size) {
         R_UNLESS(size <= static_cast<s32>(MaxTableSize), ResultOutOfMemory);
 
         // Initialize all fields.
@@ -60,7 +60,7 @@ public:
         return m_max_count;
     }
 
-    ResultCode Finalize();
+    Result Finalize();
     bool Remove(Handle handle);
 
     template <typename T = KAutoObject>
@@ -100,10 +100,10 @@ public:
         return this->template GetObjectWithoutPseudoHandle<T>(handle);
     }
 
-    ResultCode Reserve(Handle* out_handle);
+    Result Reserve(Handle* out_handle);
     void Unreserve(Handle handle);
 
-    ResultCode Add(Handle* out_handle, KAutoObject* obj);
+    Result Add(Handle* out_handle, KAutoObject* obj);
     void Register(Handle handle, KAutoObject* obj);
 
     template <typename T>
diff --git a/src/core/hle/kernel/k_light_condition_variable.cpp b/src/core/hle/kernel/k_light_condition_variable.cpp
index a40f35f45..cade99cfd 100644
--- a/src/core/hle/kernel/k_light_condition_variable.cpp
+++ b/src/core/hle/kernel/k_light_condition_variable.cpp
@@ -17,8 +17,7 @@ public:
                                               bool term)
         : KThreadQueue(kernel_), m_wait_list(wl), m_allow_terminating_thread(term) {}
 
-    void CancelWait(KThread* waiting_thread, ResultCode wait_result,
-                    bool cancel_timer_task) override {
+    void CancelWait(KThread* waiting_thread, Result wait_result, bool cancel_timer_task) override {
         // Only process waits if we're allowed to.
         if (ResultTerminationRequested == wait_result && m_allow_terminating_thread) {
             return;
diff --git a/src/core/hle/kernel/k_light_lock.cpp b/src/core/hle/kernel/k_light_lock.cpp
index 0225734b4..43185320d 100644
--- a/src/core/hle/kernel/k_light_lock.cpp
+++ b/src/core/hle/kernel/k_light_lock.cpp
@@ -15,8 +15,7 @@ class ThreadQueueImplForKLightLock final : public KThreadQueue {
 public:
     explicit ThreadQueueImplForKLightLock(KernelCore& kernel_) : KThreadQueue(kernel_) {}
 
-    void CancelWait(KThread* waiting_thread, ResultCode wait_result,
-                    bool cancel_timer_task) override {
+    void CancelWait(KThread* waiting_thread, Result wait_result, bool cancel_timer_task) override {
         // Remove the thread as a waiter from its owner.
         if (KThread* owner = waiting_thread->GetLockOwner(); owner != nullptr) {
             owner->RemoveWaiter(waiting_thread);
diff --git a/src/core/hle/kernel/k_memory_manager.cpp b/src/core/hle/kernel/k_memory_manager.cpp
index 58e540f31..5b0a9963a 100644
--- a/src/core/hle/kernel/k_memory_manager.cpp
+++ b/src/core/hle/kernel/k_memory_manager.cpp
@@ -11,7 +11,7 @@
 #include "core/device_memory.h"
 #include "core/hle/kernel/initial_process.h"
 #include "core/hle/kernel/k_memory_manager.h"
-#include "core/hle/kernel/k_page_linked_list.h"
+#include "core/hle/kernel/k_page_group.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/svc_results.h"
 
@@ -208,8 +208,8 @@ PAddr KMemoryManager::AllocateAndOpenContinuous(size_t num_pages, size_t align_p
     return allocated_block;
 }
 
-ResultCode KMemoryManager::AllocatePageGroupImpl(KPageLinkedList* out, size_t num_pages, Pool pool,
-                                                 Direction dir, bool random) {
+Result KMemoryManager::AllocatePageGroupImpl(KPageGroup* out, size_t num_pages, Pool pool,
+                                             Direction dir, bool random) {
     // Choose a heap based on our page size request.
     const s32 heap_index = KPageHeap::GetBlockIndex(num_pages);
     R_UNLESS(0 <= heap_index, ResultOutOfMemory);
@@ -257,7 +257,7 @@ ResultCode KMemoryManager::AllocatePageGroupImpl(KPageLinkedList* out, size_t nu
     return ResultSuccess;
 }
 
-ResultCode KMemoryManager::AllocateAndOpen(KPageLinkedList* out, size_t num_pages, u32 option) {
+Result KMemoryManager::AllocateAndOpen(KPageGroup* out, size_t num_pages, u32 option) {
     ASSERT(out != nullptr);
     ASSERT(out->GetNumPages() == 0);
 
@@ -293,8 +293,8 @@ ResultCode KMemoryManager::AllocateAndOpen(KPageLinkedList* out, size_t num_page
     return ResultSuccess;
 }
 
-ResultCode KMemoryManager::AllocateAndOpenForProcess(KPageLinkedList* out, size_t num_pages,
-                                                     u32 option, u64 process_id, u8 fill_pattern) {
+Result KMemoryManager::AllocateAndOpenForProcess(KPageGroup* out, size_t num_pages, u32 option,
+                                                 u64 process_id, u8 fill_pattern) {
     ASSERT(out != nullptr);
     ASSERT(out->GetNumPages() == 0);
 
@@ -370,12 +370,12 @@ void KMemoryManager::Close(PAddr address, size_t num_pages) {
     }
 }
 
-void KMemoryManager::Close(const KPageLinkedList& pg) {
+void KMemoryManager::Close(const KPageGroup& pg) {
     for (const auto& node : pg.Nodes()) {
         Close(node.GetAddress(), node.GetNumPages());
     }
 }
-void KMemoryManager::Open(const KPageLinkedList& pg) {
+void KMemoryManager::Open(const KPageGroup& pg) {
     for (const auto& node : pg.Nodes()) {
         Open(node.GetAddress(), node.GetNumPages());
     }
diff --git a/src/core/hle/kernel/k_memory_manager.h b/src/core/hle/kernel/k_memory_manager.h
index c7923cb82..dcb9b6348 100644
--- a/src/core/hle/kernel/k_memory_manager.h
+++ b/src/core/hle/kernel/k_memory_manager.h
@@ -19,7 +19,7 @@ class System;
 
 namespace Kernel {
 
-class KPageLinkedList;
+class KPageGroup;
 
 class KMemoryManager final {
 public:
@@ -65,17 +65,17 @@ public:
     }
 
     PAddr AllocateAndOpenContinuous(size_t num_pages, size_t align_pages, u32 option);
-    ResultCode AllocateAndOpen(KPageLinkedList* out, size_t num_pages, u32 option);
-    ResultCode AllocateAndOpenForProcess(KPageLinkedList* out, size_t num_pages, u32 option,
-                                         u64 process_id, u8 fill_pattern);
+    Result AllocateAndOpen(KPageGroup* out, size_t num_pages, u32 option);
+    Result AllocateAndOpenForProcess(KPageGroup* out, size_t num_pages, u32 option, u64 process_id,
+                                     u8 fill_pattern);
 
     static constexpr size_t MaxManagerCount = 10;
 
     void Close(PAddr address, size_t num_pages);
-    void Close(const KPageLinkedList& pg);
+    void Close(const KPageGroup& pg);
 
     void Open(PAddr address, size_t num_pages);
-    void Open(const KPageLinkedList& pg);
+    void Open(const KPageGroup& pg);
 
 public:
     static size_t CalculateManagementOverheadSize(size_t region_size) {
@@ -262,8 +262,8 @@ private:
         }
     }
 
-    ResultCode AllocatePageGroupImpl(KPageLinkedList* out, size_t num_pages, Pool pool,
-                                     Direction dir, bool random);
+    Result AllocatePageGroupImpl(KPageGroup* out, size_t num_pages, Pool pool, Direction dir,
+                                 bool random);
 
 private:
     Core::System& system;
diff --git a/src/core/hle/kernel/k_page_linked_list.h b/src/core/hle/kernel/k_page_group.h
index 1f79c8330..968753992 100644
--- a/src/core/hle/kernel/k_page_linked_list.h
+++ b/src/core/hle/kernel/k_page_group.h
@@ -12,7 +12,7 @@
 
 namespace Kernel {
 
-class KPageLinkedList final {
+class KPageGroup final {
 public:
     class Node final {
     public:
@@ -36,8 +36,8 @@ public:
     };
 
 public:
-    KPageLinkedList() = default;
-    KPageLinkedList(u64 address, u64 num_pages) {
+    KPageGroup() = default;
+    KPageGroup(u64 address, u64 num_pages) {
         ASSERT(AddBlock(address, num_pages).IsSuccess());
     }
 
@@ -57,7 +57,7 @@ public:
         return num_pages;
     }
 
-    bool IsEqual(KPageLinkedList& other) const {
+    bool IsEqual(KPageGroup& other) const {
         auto this_node = nodes.begin();
         auto other_node = other.nodes.begin();
         while (this_node != nodes.end() && other_node != other.nodes.end()) {
@@ -72,7 +72,7 @@ public:
         return this_node == nodes.end() && other_node == other.nodes.end();
     }
 
-    ResultCode AddBlock(u64 address, u64 num_pages) {
+    Result AddBlock(u64 address, u64 num_pages) {
         if (!num_pages) {
             return ResultSuccess;
         }
diff --git a/src/core/hle/kernel/k_page_table.cpp b/src/core/hle/kernel/k_page_table.cpp
index 39b89da53..d975de844 100644
--- a/src/core/hle/kernel/k_page_table.cpp
+++ b/src/core/hle/kernel/k_page_table.cpp
@@ -9,7 +9,7 @@
 #include "core/hle/kernel/k_address_space_info.h"
 #include "core/hle/kernel/k_memory_block.h"
 #include "core/hle/kernel/k_memory_block_manager.h"
-#include "core/hle/kernel/k_page_linked_list.h"
+#include "core/hle/kernel/k_page_group.h"
 #include "core/hle/kernel/k_page_table.h"
 #include "core/hle/kernel/k_process.h"
 #include "core/hle/kernel/k_resource_limit.h"
@@ -47,9 +47,9 @@ KPageTable::KPageTable(Core::System& system_)
 
 KPageTable::~KPageTable() = default;
 
-ResultCode KPageTable::InitializeForProcess(FileSys::ProgramAddressSpaceType as_type,
-                                            bool enable_aslr, VAddr code_addr,
-                                            std::size_t code_size, KMemoryManager::Pool pool) {
+Result KPageTable::InitializeForProcess(FileSys::ProgramAddressSpaceType as_type, bool enable_aslr,
+                                        VAddr code_addr, std::size_t code_size,
+                                        KMemoryManager::Pool pool) {
 
     const auto GetSpaceStart = [this](KAddressSpaceInfo::Type type) {
         return KAddressSpaceInfo::GetAddressSpaceStart(address_space_width, type);
@@ -257,8 +257,8 @@ ResultCode KPageTable::InitializeForProcess(FileSys::ProgramAddressSpaceType as_
     return InitializeMemoryLayout(start, end);
 }
 
-ResultCode KPageTable::MapProcessCode(VAddr addr, std::size_t num_pages, KMemoryState state,
-                                      KMemoryPermission perm) {
+Result KPageTable::MapProcessCode(VAddr addr, std::size_t num_pages, KMemoryState state,
+                                  KMemoryPermission perm) {
     const u64 size{num_pages * PageSize};
 
     // Validate the mapping request.
@@ -271,7 +271,7 @@ ResultCode KPageTable::MapProcessCode(VAddr addr, std::size_t num_pages, KMemory
     R_TRY(this->CheckMemoryState(addr, size, KMemoryState::All, KMemoryState::Free,
                                  KMemoryPermission::None, KMemoryPermission::None,
                                  KMemoryAttribute::None, KMemoryAttribute::None));
-    KPageLinkedList pg;
+    KPageGroup pg;
     R_TRY(system.Kernel().MemoryManager().AllocateAndOpen(
         &pg, num_pages,
         KMemoryManager::EncodeOption(KMemoryManager::Pool::Application, allocation_option)));
@@ -283,7 +283,7 @@ ResultCode KPageTable::MapProcessCode(VAddr addr, std::size_t num_pages, KMemory
     return ResultSuccess;
 }
 
-ResultCode KPageTable::MapCodeMemory(VAddr dst_address, VAddr src_address, std::size_t size) {
+Result KPageTable::MapCodeMemory(VAddr dst_address, VAddr src_address, std::size_t size) {
     // Validate the mapping request.
     R_UNLESS(this->CanContain(dst_address, size, KMemoryState::AliasCode),
              ResultInvalidMemoryRegion);
@@ -313,7 +313,7 @@ ResultCode KPageTable::MapCodeMemory(VAddr dst_address, VAddr src_address, std::
         const std::size_t num_pages = size / PageSize;
 
         // Create page groups for the memory being mapped.
-        KPageLinkedList pg;
+        KPageGroup pg;
         AddRegionToPages(src_address, num_pages, pg);
 
         // Reprotect the source as kernel-read/not mapped.
@@ -344,8 +344,8 @@ ResultCode KPageTable::MapCodeMemory(VAddr dst_address, VAddr src_address, std::
     return ResultSuccess;
 }
 
-ResultCode KPageTable::UnmapCodeMemory(VAddr dst_address, VAddr src_address, std::size_t size,
-                                       ICacheInvalidationStrategy icache_invalidation_strategy) {
+Result KPageTable::UnmapCodeMemory(VAddr dst_address, VAddr src_address, std::size_t size,
+                                   ICacheInvalidationStrategy icache_invalidation_strategy) {
     // Validate the mapping request.
     R_UNLESS(this->CanContain(dst_address, size, KMemoryState::AliasCode),
              ResultInvalidMemoryRegion);
@@ -489,7 +489,7 @@ VAddr KPageTable::FindFreeArea(VAddr region_start, std::size_t region_num_pages,
     return address;
 }
 
-ResultCode KPageTable::MakePageGroup(KPageLinkedList& pg, VAddr addr, size_t num_pages) {
+Result KPageTable::MakePageGroup(KPageGroup& pg, VAddr addr, size_t num_pages) {
     ASSERT(this->IsLockedByCurrentThread());
 
     const size_t size = num_pages * PageSize;
@@ -541,7 +541,7 @@ ResultCode KPageTable::MakePageGroup(KPageLinkedList& pg, VAddr addr, size_t num
     return ResultSuccess;
 }
 
-bool KPageTable::IsValidPageGroup(const KPageLinkedList& pg_ll, VAddr addr, size_t num_pages) {
+bool KPageTable::IsValidPageGroup(const KPageGroup& pg_ll, VAddr addr, size_t num_pages) {
     ASSERT(this->IsLockedByCurrentThread());
 
     const size_t size = num_pages * PageSize;
@@ -630,8 +630,8 @@ bool KPageTable::IsValidPageGroup(const KPageLinkedList& pg_ll, VAddr addr, size
     return cur_block_address == cur_addr && cur_block_pages == (cur_size / PageSize);
 }
 
-ResultCode KPageTable::UnmapProcessMemory(VAddr dst_addr, std::size_t size,
-                                          KPageTable& src_page_table, VAddr src_addr) {
+Result KPageTable::UnmapProcessMemory(VAddr dst_addr, std::size_t size, KPageTable& src_page_table,
+                                      VAddr src_addr) {
     KScopedLightLock lk(general_lock);
 
     const std::size_t num_pages{size / PageSize};
@@ -660,7 +660,7 @@ ResultCode KPageTable::UnmapProcessMemory(VAddr dst_addr, std::size_t size,
     return ResultSuccess;
 }
 
-ResultCode KPageTable::MapPhysicalMemory(VAddr address, std::size_t size) {
+Result KPageTable::MapPhysicalMemory(VAddr address, std::size_t size) {
     // Lock the physical memory lock.
     KScopedLightLock map_phys_mem_lk(map_physical_memory_lock);
 
@@ -721,7 +721,7 @@ ResultCode KPageTable::MapPhysicalMemory(VAddr address, std::size_t size) {
             R_UNLESS(memory_reservation.Succeeded(), ResultLimitReached);
 
             // Allocate pages for the new memory.
-            KPageLinkedList pg;
+            KPageGroup pg;
             R_TRY(system.Kernel().MemoryManager().AllocateAndOpenForProcess(
                 &pg, (size - mapped_size) / PageSize,
                 KMemoryManager::EncodeOption(memory_pool, allocation_option), 0, 0));
@@ -903,7 +903,7 @@ ResultCode KPageTable::MapPhysicalMemory(VAddr address, std::size_t size) {
     }
 }
 
-ResultCode KPageTable::UnmapPhysicalMemory(VAddr address, std::size_t size) {
+Result KPageTable::UnmapPhysicalMemory(VAddr address, std::size_t size) {
     // Lock the physical memory lock.
     KScopedLightLock map_phys_mem_lk(map_physical_memory_lock);
 
@@ -972,7 +972,7 @@ ResultCode KPageTable::UnmapPhysicalMemory(VAddr address, std::size_t size) {
     }
 
     // Make a page group for the unmap region.
-    KPageLinkedList pg;
+    KPageGroup pg;
     {
         auto& impl = this->PageTableImpl();
 
@@ -1134,7 +1134,7 @@ ResultCode KPageTable::UnmapPhysicalMemory(VAddr address, std::size_t size) {
     return ResultSuccess;
 }
 
-ResultCode KPageTable::MapMemory(VAddr dst_addr, VAddr src_addr, std::size_t size) {
+Result KPageTable::MapMemory(VAddr dst_addr, VAddr src_addr, std::size_t size) {
     KScopedLightLock lk(general_lock);
 
     KMemoryState src_state{};
@@ -1147,7 +1147,7 @@ ResultCode KPageTable::MapMemory(VAddr dst_addr, VAddr src_addr, std::size_t siz
         return ResultInvalidCurrentMemory;
     }
 
-    KPageLinkedList page_linked_list;
+    KPageGroup page_linked_list;
     const std::size_t num_pages{size / PageSize};
 
     AddRegionToPages(src_addr, num_pages, page_linked_list);
@@ -1173,7 +1173,7 @@ ResultCode KPageTable::MapMemory(VAddr dst_addr, VAddr src_addr, std::size_t siz
     return ResultSuccess;
 }
 
-ResultCode KPageTable::UnmapMemory(VAddr dst_addr, VAddr src_addr, std::size_t size) {
+Result KPageTable::UnmapMemory(VAddr dst_addr, VAddr src_addr, std::size_t size) {
     KScopedLightLock lk(general_lock);
 
     KMemoryState src_state{};
@@ -1188,8 +1188,8 @@ ResultCode KPageTable::UnmapMemory(VAddr dst_addr, VAddr src_addr, std::size_t s
                                   KMemoryPermission::None, KMemoryAttribute::Mask,
                                   KMemoryAttribute::None, KMemoryAttribute::IpcAndDeviceMapped));
 
-    KPageLinkedList src_pages;
-    KPageLinkedList dst_pages;
+    KPageGroup src_pages;
+    KPageGroup dst_pages;
     const std::size_t num_pages{size / PageSize};
 
     AddRegionToPages(src_addr, num_pages, src_pages);
@@ -1215,8 +1215,8 @@ ResultCode KPageTable::UnmapMemory(VAddr dst_addr, VAddr src_addr, std::size_t s
     return ResultSuccess;
 }
 
-ResultCode KPageTable::MapPages(VAddr addr, const KPageLinkedList& page_linked_list,
-                                KMemoryPermission perm) {
+Result KPageTable::MapPages(VAddr addr, const KPageGroup& page_linked_list,
+                            KMemoryPermission perm) {
     ASSERT(this->IsLockedByCurrentThread());
 
     VAddr cur_addr{addr};
@@ -1239,8 +1239,8 @@ ResultCode KPageTable::MapPages(VAddr addr, const KPageLinkedList& page_linked_l
     return ResultSuccess;
 }
 
-ResultCode KPageTable::MapPages(VAddr address, KPageLinkedList& page_linked_list,
-                                KMemoryState state, KMemoryPermission perm) {
+Result KPageTable::MapPages(VAddr address, KPageGroup& page_linked_list, KMemoryState state,
+                            KMemoryPermission perm) {
     // Check that the map is in range.
     const std::size_t num_pages{page_linked_list.GetNumPages()};
     const std::size_t size{num_pages * PageSize};
@@ -1263,10 +1263,10 @@ ResultCode KPageTable::MapPages(VAddr address, KPageLinkedList& page_linked_list
     return ResultSuccess;
 }
 
-ResultCode KPageTable::MapPages(VAddr* out_addr, std::size_t num_pages, std::size_t alignment,
-                                PAddr phys_addr, bool is_pa_valid, VAddr region_start,
-                                std::size_t region_num_pages, KMemoryState state,
-                                KMemoryPermission perm) {
+Result KPageTable::MapPages(VAddr* out_addr, std::size_t num_pages, std::size_t alignment,
+                            PAddr phys_addr, bool is_pa_valid, VAddr region_start,
+                            std::size_t region_num_pages, KMemoryState state,
+                            KMemoryPermission perm) {
     ASSERT(Common::IsAligned(alignment, PageSize) && alignment >= PageSize);
 
     // Ensure this is a valid map request.
@@ -1303,7 +1303,7 @@ ResultCode KPageTable::MapPages(VAddr* out_addr, std::size_t num_pages, std::siz
     return ResultSuccess;
 }
 
-ResultCode KPageTable::UnmapPages(VAddr addr, const KPageLinkedList& page_linked_list) {
+Result KPageTable::UnmapPages(VAddr addr, const KPageGroup& page_linked_list) {
     ASSERT(this->IsLockedByCurrentThread());
 
     VAddr cur_addr{addr};
@@ -1321,8 +1321,7 @@ ResultCode KPageTable::UnmapPages(VAddr addr, const KPageLinkedList& page_linked
     return ResultSuccess;
 }
 
-ResultCode KPageTable::UnmapPages(VAddr addr, KPageLinkedList& page_linked_list,
-                                  KMemoryState state) {
+Result KPageTable::UnmapPages(VAddr addr, KPageGroup& page_linked_list, KMemoryState state) {
     // Check that the unmap is in range.
     const std::size_t num_pages{page_linked_list.GetNumPages()};
     const std::size_t size{num_pages * PageSize};
@@ -1345,7 +1344,7 @@ ResultCode KPageTable::UnmapPages(VAddr addr, KPageLinkedList& page_linked_list,
     return ResultSuccess;
 }
 
-ResultCode KPageTable::UnmapPages(VAddr address, std::size_t num_pages, KMemoryState state) {
+Result KPageTable::UnmapPages(VAddr address, std::size_t num_pages, KMemoryState state) {
     // Check that the unmap is in range.
     const std::size_t size = num_pages * PageSize;
     R_UNLESS(this->Contains(address, size), ResultInvalidCurrentMemory);
@@ -1369,10 +1368,10 @@ ResultCode KPageTable::UnmapPages(VAddr address, std::size_t num_pages, KMemoryS
     return ResultSuccess;
 }
 
-ResultCode KPageTable::MakeAndOpenPageGroup(KPageLinkedList* out, VAddr address, size_t num_pages,
-                                            KMemoryState state_mask, KMemoryState state,
-                                            KMemoryPermission perm_mask, KMemoryPermission perm,
-                                            KMemoryAttribute attr_mask, KMemoryAttribute attr) {
+Result KPageTable::MakeAndOpenPageGroup(KPageGroup* out, VAddr address, size_t num_pages,
+                                        KMemoryState state_mask, KMemoryState state,
+                                        KMemoryPermission perm_mask, KMemoryPermission perm,
+                                        KMemoryAttribute attr_mask, KMemoryAttribute attr) {
     // Ensure that the page group isn't null.
     ASSERT(out != nullptr);
 
@@ -1394,8 +1393,8 @@ ResultCode KPageTable::MakeAndOpenPageGroup(KPageLinkedList* out, VAddr address,
     return ResultSuccess;
 }
 
-ResultCode KPageTable::SetProcessMemoryPermission(VAddr addr, std::size_t size,
-                                                  Svc::MemoryPermission svc_perm) {
+Result KPageTable::SetProcessMemoryPermission(VAddr addr, std::size_t size,
+                                              Svc::MemoryPermission svc_perm) {
     const size_t num_pages = size / PageSize;
 
     // Lock the table.
@@ -1467,7 +1466,7 @@ KMemoryInfo KPageTable::QueryInfo(VAddr addr) {
     return QueryInfoImpl(addr);
 }
 
-ResultCode KPageTable::ReserveTransferMemory(VAddr addr, std::size_t size, KMemoryPermission perm) {
+Result KPageTable::ReserveTransferMemory(VAddr addr, std::size_t size, KMemoryPermission perm) {
     KScopedLightLock lk(general_lock);
 
     KMemoryState state{};
@@ -1485,7 +1484,7 @@ ResultCode KPageTable::ReserveTransferMemory(VAddr addr, std::size_t size, KMemo
     return ResultSuccess;
 }
 
-ResultCode KPageTable::ResetTransferMemory(VAddr addr, std::size_t size) {
+Result KPageTable::ResetTransferMemory(VAddr addr, std::size_t size) {
     KScopedLightLock lk(general_lock);
 
     KMemoryState state{};
@@ -1500,8 +1499,8 @@ ResultCode KPageTable::ResetTransferMemory(VAddr addr, std::size_t size) {
     return ResultSuccess;
 }
 
-ResultCode KPageTable::SetMemoryPermission(VAddr addr, std::size_t size,
-                                           Svc::MemoryPermission svc_perm) {
+Result KPageTable::SetMemoryPermission(VAddr addr, std::size_t size,
+                                       Svc::MemoryPermission svc_perm) {
     const size_t num_pages = size / PageSize;
 
     // Lock the table.
@@ -1528,7 +1527,7 @@ ResultCode KPageTable::SetMemoryPermission(VAddr addr, std::size_t size,
     return ResultSuccess;
 }
 
-ResultCode KPageTable::SetMemoryAttribute(VAddr addr, std::size_t size, u32 mask, u32 attr) {
+Result KPageTable::SetMemoryAttribute(VAddr addr, std::size_t size, u32 mask, u32 attr) {
     const size_t num_pages = size / PageSize;
     ASSERT((static_cast<KMemoryAttribute>(mask) | KMemoryAttribute::SetMask) ==
            KMemoryAttribute::SetMask);
@@ -1563,7 +1562,7 @@ ResultCode KPageTable::SetMemoryAttribute(VAddr addr, std::size_t size, u32 mask
     return ResultSuccess;
 }
 
-ResultCode KPageTable::SetMaxHeapSize(std::size_t size) {
+Result KPageTable::SetMaxHeapSize(std::size_t size) {
     // Lock the table.
     KScopedLightLock lk(general_lock);
 
@@ -1575,7 +1574,7 @@ ResultCode KPageTable::SetMaxHeapSize(std::size_t size) {
     return ResultSuccess;
 }
 
-ResultCode KPageTable::SetHeapSize(VAddr* out, std::size_t size) {
+Result KPageTable::SetHeapSize(VAddr* out, std::size_t size) {
     // Lock the physical memory mutex.
     KScopedLightLock map_phys_mem_lk(map_physical_memory_lock);
 
@@ -1642,7 +1641,7 @@ ResultCode KPageTable::SetHeapSize(VAddr* out, std::size_t size) {
     R_UNLESS(memory_reservation.Succeeded(), ResultLimitReached);
 
     // Allocate pages for the heap extension.
-    KPageLinkedList pg;
+    KPageGroup pg;
     R_TRY(system.Kernel().MemoryManager().AllocateAndOpen(
         &pg, allocation_size / PageSize,
         KMemoryManager::EncodeOption(memory_pool, allocation_option)));
@@ -1717,7 +1716,7 @@ ResultVal<VAddr> KPageTable::AllocateAndMapMemory(std::size_t needed_num_pages,
     if (is_map_only) {
         R_TRY(Operate(addr, needed_num_pages, perm, OperationType::Map, map_addr));
     } else {
-        KPageLinkedList page_group;
+        KPageGroup page_group;
         R_TRY(system.Kernel().MemoryManager().AllocateAndOpenForProcess(
             &page_group, needed_num_pages,
             KMemoryManager::EncodeOption(memory_pool, allocation_option), 0, 0));
@@ -1729,11 +1728,11 @@ ResultVal<VAddr> KPageTable::AllocateAndMapMemory(std::size_t needed_num_pages,
     return addr;
 }
 
-ResultCode KPageTable::LockForDeviceAddressSpace(VAddr addr, std::size_t size) {
+Result KPageTable::LockForDeviceAddressSpace(VAddr addr, std::size_t size) {
     KScopedLightLock lk(general_lock);
 
     KMemoryPermission perm{};
-    if (const ResultCode result{CheckMemoryState(
+    if (const Result result{CheckMemoryState(
             nullptr, &perm, nullptr, nullptr, addr, size, KMemoryState::FlagCanChangeAttribute,
             KMemoryState::FlagCanChangeAttribute, KMemoryPermission::None, KMemoryPermission::None,
             KMemoryAttribute::LockedAndIpcLocked, KMemoryAttribute::None,
@@ -1752,11 +1751,11 @@ ResultCode KPageTable::LockForDeviceAddressSpace(VAddr addr, std::size_t size) {
     return ResultSuccess;
 }
 
-ResultCode KPageTable::UnlockForDeviceAddressSpace(VAddr addr, std::size_t size) {
+Result KPageTable::UnlockForDeviceAddressSpace(VAddr addr, std::size_t size) {
     KScopedLightLock lk(general_lock);
 
     KMemoryPermission perm{};
-    if (const ResultCode result{CheckMemoryState(
+    if (const Result result{CheckMemoryState(
             nullptr, &perm, nullptr, nullptr, addr, size, KMemoryState::FlagCanChangeAttribute,
             KMemoryState::FlagCanChangeAttribute, KMemoryPermission::None, KMemoryPermission::None,
             KMemoryAttribute::LockedAndIpcLocked, KMemoryAttribute::None,
@@ -1775,7 +1774,7 @@ ResultCode KPageTable::UnlockForDeviceAddressSpace(VAddr addr, std::size_t size)
     return ResultSuccess;
 }
 
-ResultCode KPageTable::LockForCodeMemory(KPageLinkedList* out, VAddr addr, std::size_t size) {
+Result KPageTable::LockForCodeMemory(KPageGroup* out, VAddr addr, std::size_t size) {
     return this->LockMemoryAndOpen(
         out, nullptr, addr, size, KMemoryState::FlagCanCodeMemory, KMemoryState::FlagCanCodeMemory,
         KMemoryPermission::All, KMemoryPermission::UserReadWrite, KMemoryAttribute::All,
@@ -1785,15 +1784,14 @@ ResultCode KPageTable::LockForCodeMemory(KPageLinkedList* out, VAddr addr, std::
         KMemoryAttribute::Locked);
 }
 
-ResultCode KPageTable::UnlockForCodeMemory(VAddr addr, std::size_t size,
-                                           const KPageLinkedList& pg) {
+Result KPageTable::UnlockForCodeMemory(VAddr addr, std::size_t size, const KPageGroup& pg) {
     return this->UnlockMemory(
         addr, size, KMemoryState::FlagCanCodeMemory, KMemoryState::FlagCanCodeMemory,
         KMemoryPermission::None, KMemoryPermission::None, KMemoryAttribute::All,
         KMemoryAttribute::Locked, KMemoryPermission::UserReadWrite, KMemoryAttribute::Locked, &pg);
 }
 
-ResultCode KPageTable::InitializeMemoryLayout(VAddr start, VAddr end) {
+Result KPageTable::InitializeMemoryLayout(VAddr start, VAddr end) {
     block_manager = std::make_unique<KMemoryBlockManager>(start, end);
 
     return ResultSuccess;
@@ -1818,7 +1816,7 @@ bool KPageTable::IsRegionContiguous(VAddr addr, u64 size) const {
 }
 
 void KPageTable::AddRegionToPages(VAddr start, std::size_t num_pages,
-                                  KPageLinkedList& page_linked_list) {
+                                  KPageGroup& page_linked_list) {
     VAddr addr{start};
     while (addr < start + (num_pages * PageSize)) {
         const PAddr paddr{GetPhysicalAddr(addr)};
@@ -1837,8 +1835,8 @@ VAddr KPageTable::AllocateVirtualMemory(VAddr start, std::size_t region_num_page
                                        IsKernel() ? 1 : 4);
 }
 
-ResultCode KPageTable::Operate(VAddr addr, std::size_t num_pages, const KPageLinkedList& page_group,
-                               OperationType operation) {
+Result KPageTable::Operate(VAddr addr, std::size_t num_pages, const KPageGroup& page_group,
+                           OperationType operation) {
     ASSERT(this->IsLockedByCurrentThread());
 
     ASSERT(Common::IsAligned(addr, PageSize));
@@ -1862,8 +1860,8 @@ ResultCode KPageTable::Operate(VAddr addr, std::size_t num_pages, const KPageLin
     return ResultSuccess;
 }
 
-ResultCode KPageTable::Operate(VAddr addr, std::size_t num_pages, KMemoryPermission perm,
-                               OperationType operation, PAddr map_addr) {
+Result KPageTable::Operate(VAddr addr, std::size_t num_pages, KMemoryPermission perm,
+                           OperationType operation, PAddr map_addr) {
     ASSERT(this->IsLockedByCurrentThread());
 
     ASSERT(num_pages > 0);
@@ -2005,10 +2003,10 @@ bool KPageTable::CanContain(VAddr addr, std::size_t size, KMemoryState state) co
     }
 }
 
-ResultCode KPageTable::CheckMemoryState(const KMemoryInfo& info, KMemoryState state_mask,
-                                        KMemoryState state, KMemoryPermission perm_mask,
-                                        KMemoryPermission perm, KMemoryAttribute attr_mask,
-                                        KMemoryAttribute attr) const {
+Result KPageTable::CheckMemoryState(const KMemoryInfo& info, KMemoryState state_mask,
+                                    KMemoryState state, KMemoryPermission perm_mask,
+                                    KMemoryPermission perm, KMemoryAttribute attr_mask,
+                                    KMemoryAttribute attr) const {
     // Validate the states match expectation.
     R_UNLESS((info.state & state_mask) == state, ResultInvalidCurrentMemory);
     R_UNLESS((info.perm & perm_mask) == perm, ResultInvalidCurrentMemory);
@@ -2017,12 +2015,11 @@ ResultCode KPageTable::CheckMemoryState(const KMemoryInfo& info, KMemoryState st
     return ResultSuccess;
 }
 
-ResultCode KPageTable::CheckMemoryStateContiguous(std::size_t* out_blocks_needed, VAddr addr,
-                                                  std::size_t size, KMemoryState state_mask,
-                                                  KMemoryState state, KMemoryPermission perm_mask,
-                                                  KMemoryPermission perm,
-                                                  KMemoryAttribute attr_mask,
-                                                  KMemoryAttribute attr) const {
+Result KPageTable::CheckMemoryStateContiguous(std::size_t* out_blocks_needed, VAddr addr,
+                                              std::size_t size, KMemoryState state_mask,
+                                              KMemoryState state, KMemoryPermission perm_mask,
+                                              KMemoryPermission perm, KMemoryAttribute attr_mask,
+                                              KMemoryAttribute attr) const {
     ASSERT(this->IsLockedByCurrentThread());
 
     // Get information about the first block.
@@ -2060,12 +2057,12 @@ ResultCode KPageTable::CheckMemoryStateContiguous(std::size_t* out_blocks_needed
     return ResultSuccess;
 }
 
-ResultCode KPageTable::CheckMemoryState(KMemoryState* out_state, KMemoryPermission* out_perm,
-                                        KMemoryAttribute* out_attr, std::size_t* out_blocks_needed,
-                                        VAddr addr, std::size_t size, KMemoryState state_mask,
-                                        KMemoryState state, KMemoryPermission perm_mask,
-                                        KMemoryPermission perm, KMemoryAttribute attr_mask,
-                                        KMemoryAttribute attr, KMemoryAttribute ignore_attr) const {
+Result KPageTable::CheckMemoryState(KMemoryState* out_state, KMemoryPermission* out_perm,
+                                    KMemoryAttribute* out_attr, std::size_t* out_blocks_needed,
+                                    VAddr addr, std::size_t size, KMemoryState state_mask,
+                                    KMemoryState state, KMemoryPermission perm_mask,
+                                    KMemoryPermission perm, KMemoryAttribute attr_mask,
+                                    KMemoryAttribute attr, KMemoryAttribute ignore_attr) const {
     ASSERT(this->IsLockedByCurrentThread());
 
     // Get information about the first block.
@@ -2122,11 +2119,11 @@ ResultCode KPageTable::CheckMemoryState(KMemoryState* out_state, KMemoryPermissi
     return ResultSuccess;
 }
 
-ResultCode KPageTable::LockMemoryAndOpen(KPageLinkedList* out_pg, PAddr* out_paddr, VAddr addr,
-                                         size_t size, KMemoryState state_mask, KMemoryState state,
-                                         KMemoryPermission perm_mask, KMemoryPermission perm,
-                                         KMemoryAttribute attr_mask, KMemoryAttribute attr,
-                                         KMemoryPermission new_perm, KMemoryAttribute lock_attr) {
+Result KPageTable::LockMemoryAndOpen(KPageGroup* out_pg, PAddr* out_paddr, VAddr addr, size_t size,
+                                     KMemoryState state_mask, KMemoryState state,
+                                     KMemoryPermission perm_mask, KMemoryPermission perm,
+                                     KMemoryAttribute attr_mask, KMemoryAttribute attr,
+                                     KMemoryPermission new_perm, KMemoryAttribute lock_attr) {
     // Validate basic preconditions.
     ASSERT((lock_attr & attr) == KMemoryAttribute::None);
     ASSERT((lock_attr & (KMemoryAttribute::IpcLocked | KMemoryAttribute::DeviceShared)) ==
@@ -2180,11 +2177,11 @@ ResultCode KPageTable::LockMemoryAndOpen(KPageLinkedList* out_pg, PAddr* out_pad
     return ResultSuccess;
 }
 
-ResultCode KPageTable::UnlockMemory(VAddr addr, size_t size, KMemoryState state_mask,
-                                    KMemoryState state, KMemoryPermission perm_mask,
-                                    KMemoryPermission perm, KMemoryAttribute attr_mask,
-                                    KMemoryAttribute attr, KMemoryPermission new_perm,
-                                    KMemoryAttribute lock_attr, const KPageLinkedList* pg) {
+Result KPageTable::UnlockMemory(VAddr addr, size_t size, KMemoryState state_mask,
+                                KMemoryState state, KMemoryPermission perm_mask,
+                                KMemoryPermission perm, KMemoryAttribute attr_mask,
+                                KMemoryAttribute attr, KMemoryPermission new_perm,
+                                KMemoryAttribute lock_attr, const KPageGroup* pg) {
     // Validate basic preconditions.
     ASSERT((attr_mask & lock_attr) == lock_attr);
     ASSERT((attr & lock_attr) == lock_attr);
diff --git a/src/core/hle/kernel/k_page_table.h b/src/core/hle/kernel/k_page_table.h
index 6312eb682..25774f232 100644
--- a/src/core/hle/kernel/k_page_table.h
+++ b/src/core/hle/kernel/k_page_table.h
@@ -33,51 +33,49 @@ public:
     explicit KPageTable(Core::System& system_);
     ~KPageTable();
 
-    ResultCode InitializeForProcess(FileSys::ProgramAddressSpaceType as_type, bool enable_aslr,
-                                    VAddr code_addr, std::size_t code_size,
-                                    KMemoryManager::Pool pool);
-    ResultCode MapProcessCode(VAddr addr, std::size_t pages_count, KMemoryState state,
-                              KMemoryPermission perm);
-    ResultCode MapCodeMemory(VAddr dst_address, VAddr src_address, std::size_t size);
-    ResultCode UnmapCodeMemory(VAddr dst_address, VAddr src_address, std::size_t size,
-                               ICacheInvalidationStrategy icache_invalidation_strategy);
-    ResultCode UnmapProcessMemory(VAddr dst_addr, std::size_t size, KPageTable& src_page_table,
-                                  VAddr src_addr);
-    ResultCode MapPhysicalMemory(VAddr addr, std::size_t size);
-    ResultCode UnmapPhysicalMemory(VAddr addr, std::size_t size);
-    ResultCode MapMemory(VAddr dst_addr, VAddr src_addr, std::size_t size);
-    ResultCode UnmapMemory(VAddr dst_addr, VAddr src_addr, std::size_t size);
-    ResultCode MapPages(VAddr addr, KPageLinkedList& page_linked_list, KMemoryState state,
-                        KMemoryPermission perm);
-    ResultCode MapPages(VAddr* out_addr, std::size_t num_pages, std::size_t alignment,
-                        PAddr phys_addr, KMemoryState state, KMemoryPermission perm) {
+    Result InitializeForProcess(FileSys::ProgramAddressSpaceType as_type, bool enable_aslr,
+                                VAddr code_addr, std::size_t code_size, KMemoryManager::Pool pool);
+    Result MapProcessCode(VAddr addr, std::size_t pages_count, KMemoryState state,
+                          KMemoryPermission perm);
+    Result MapCodeMemory(VAddr dst_address, VAddr src_address, std::size_t size);
+    Result UnmapCodeMemory(VAddr dst_address, VAddr src_address, std::size_t size,
+                           ICacheInvalidationStrategy icache_invalidation_strategy);
+    Result UnmapProcessMemory(VAddr dst_addr, std::size_t size, KPageTable& src_page_table,
+                              VAddr src_addr);
+    Result MapPhysicalMemory(VAddr addr, std::size_t size);
+    Result UnmapPhysicalMemory(VAddr addr, std::size_t size);
+    Result MapMemory(VAddr dst_addr, VAddr src_addr, std::size_t size);
+    Result UnmapMemory(VAddr dst_addr, VAddr src_addr, std::size_t size);
+    Result MapPages(VAddr addr, KPageGroup& page_linked_list, KMemoryState state,
+                    KMemoryPermission perm);
+    Result MapPages(VAddr* out_addr, std::size_t num_pages, std::size_t alignment, PAddr phys_addr,
+                    KMemoryState state, KMemoryPermission perm) {
         return this->MapPages(out_addr, num_pages, alignment, phys_addr, true,
                               this->GetRegionAddress(state), this->GetRegionSize(state) / PageSize,
                               state, perm);
     }
-    ResultCode UnmapPages(VAddr addr, KPageLinkedList& page_linked_list, KMemoryState state);
-    ResultCode UnmapPages(VAddr address, std::size_t num_pages, KMemoryState state);
-    ResultCode SetProcessMemoryPermission(VAddr addr, std::size_t size,
-                                          Svc::MemoryPermission svc_perm);
+    Result UnmapPages(VAddr addr, KPageGroup& page_linked_list, KMemoryState state);
+    Result UnmapPages(VAddr address, std::size_t num_pages, KMemoryState state);
+    Result SetProcessMemoryPermission(VAddr addr, std::size_t size, Svc::MemoryPermission svc_perm);
     KMemoryInfo QueryInfo(VAddr addr);
-    ResultCode ReserveTransferMemory(VAddr addr, std::size_t size, KMemoryPermission perm);
-    ResultCode ResetTransferMemory(VAddr addr, std::size_t size);
-    ResultCode SetMemoryPermission(VAddr addr, std::size_t size, Svc::MemoryPermission perm);
-    ResultCode SetMemoryAttribute(VAddr addr, std::size_t size, u32 mask, u32 attr);
-    ResultCode SetMaxHeapSize(std::size_t size);
-    ResultCode SetHeapSize(VAddr* out, std::size_t size);
+    Result ReserveTransferMemory(VAddr addr, std::size_t size, KMemoryPermission perm);
+    Result ResetTransferMemory(VAddr addr, std::size_t size);
+    Result SetMemoryPermission(VAddr addr, std::size_t size, Svc::MemoryPermission perm);
+    Result SetMemoryAttribute(VAddr addr, std::size_t size, u32 mask, u32 attr);
+    Result SetMaxHeapSize(std::size_t size);
+    Result SetHeapSize(VAddr* out, std::size_t size);
     ResultVal<VAddr> AllocateAndMapMemory(std::size_t needed_num_pages, std::size_t align,
                                           bool is_map_only, VAddr region_start,
                                           std::size_t region_num_pages, KMemoryState state,
                                           KMemoryPermission perm, PAddr map_addr = 0);
-    ResultCode LockForDeviceAddressSpace(VAddr addr, std::size_t size);
-    ResultCode UnlockForDeviceAddressSpace(VAddr addr, std::size_t size);
-    ResultCode LockForCodeMemory(KPageLinkedList* out, VAddr addr, std::size_t size);
-    ResultCode UnlockForCodeMemory(VAddr addr, std::size_t size, const KPageLinkedList& pg);
-    ResultCode MakeAndOpenPageGroup(KPageLinkedList* out, VAddr address, size_t num_pages,
-                                    KMemoryState state_mask, KMemoryState state,
-                                    KMemoryPermission perm_mask, KMemoryPermission perm,
-                                    KMemoryAttribute attr_mask, KMemoryAttribute attr);
+    Result LockForDeviceAddressSpace(VAddr addr, std::size_t size);
+    Result UnlockForDeviceAddressSpace(VAddr addr, std::size_t size);
+    Result LockForCodeMemory(KPageGroup* out, VAddr addr, std::size_t size);
+    Result UnlockForCodeMemory(VAddr addr, std::size_t size, const KPageGroup& pg);
+    Result MakeAndOpenPageGroup(KPageGroup* out, VAddr address, size_t num_pages,
+                                KMemoryState state_mask, KMemoryState state,
+                                KMemoryPermission perm_mask, KMemoryPermission perm,
+                                KMemoryAttribute attr_mask, KMemoryAttribute attr);
 
     Common::PageTable& PageTableImpl() {
         return page_table_impl;
@@ -102,83 +100,78 @@ private:
                                                                 KMemoryAttribute::IpcLocked |
                                                                 KMemoryAttribute::DeviceShared;
 
-    ResultCode InitializeMemoryLayout(VAddr start, VAddr end);
-    ResultCode MapPages(VAddr addr, const KPageLinkedList& page_linked_list,
-                        KMemoryPermission perm);
-    ResultCode MapPages(VAddr* out_addr, std::size_t num_pages, std::size_t alignment,
-                        PAddr phys_addr, bool is_pa_valid, VAddr region_start,
-                        std::size_t region_num_pages, KMemoryState state, KMemoryPermission perm);
-    ResultCode UnmapPages(VAddr addr, const KPageLinkedList& page_linked_list);
+    Result InitializeMemoryLayout(VAddr start, VAddr end);
+    Result MapPages(VAddr addr, const KPageGroup& page_linked_list, KMemoryPermission perm);
+    Result MapPages(VAddr* out_addr, std::size_t num_pages, std::size_t alignment, PAddr phys_addr,
+                    bool is_pa_valid, VAddr region_start, std::size_t region_num_pages,
+                    KMemoryState state, KMemoryPermission perm);
+    Result UnmapPages(VAddr addr, const KPageGroup& page_linked_list);
     bool IsRegionMapped(VAddr address, u64 size);
     bool IsRegionContiguous(VAddr addr, u64 size) const;
-    void AddRegionToPages(VAddr start, std::size_t num_pages, KPageLinkedList& page_linked_list);
+    void AddRegionToPages(VAddr start, std::size_t num_pages, KPageGroup& page_linked_list);
     KMemoryInfo QueryInfoImpl(VAddr addr);
     VAddr AllocateVirtualMemory(VAddr start, std::size_t region_num_pages, u64 needed_num_pages,
                                 std::size_t align);
-    ResultCode Operate(VAddr addr, std::size_t num_pages, const KPageLinkedList& page_group,
-                       OperationType operation);
-    ResultCode Operate(VAddr addr, std::size_t num_pages, KMemoryPermission perm,
-                       OperationType operation, PAddr map_addr = 0);
+    Result Operate(VAddr addr, std::size_t num_pages, const KPageGroup& page_group,
+                   OperationType operation);
+    Result Operate(VAddr addr, std::size_t num_pages, KMemoryPermission perm,
+                   OperationType operation, PAddr map_addr = 0);
     VAddr GetRegionAddress(KMemoryState state) const;
     std::size_t GetRegionSize(KMemoryState state) const;
 
     VAddr FindFreeArea(VAddr region_start, std::size_t region_num_pages, std::size_t num_pages,
                        std::size_t alignment, std::size_t offset, std::size_t guard_pages);
 
-    ResultCode CheckMemoryStateContiguous(std::size_t* out_blocks_needed, VAddr addr,
-                                          std::size_t size, KMemoryState state_mask,
-                                          KMemoryState state, KMemoryPermission perm_mask,
-                                          KMemoryPermission perm, KMemoryAttribute attr_mask,
-                                          KMemoryAttribute attr) const;
-    ResultCode CheckMemoryStateContiguous(VAddr addr, std::size_t size, KMemoryState state_mask,
-                                          KMemoryState state, KMemoryPermission perm_mask,
-                                          KMemoryPermission perm, KMemoryAttribute attr_mask,
-                                          KMemoryAttribute attr) const {
+    Result CheckMemoryStateContiguous(std::size_t* out_blocks_needed, VAddr addr, std::size_t size,
+                                      KMemoryState state_mask, KMemoryState state,
+                                      KMemoryPermission perm_mask, KMemoryPermission perm,
+                                      KMemoryAttribute attr_mask, KMemoryAttribute attr) const;
+    Result CheckMemoryStateContiguous(VAddr addr, std::size_t size, KMemoryState state_mask,
+                                      KMemoryState state, KMemoryPermission perm_mask,
+                                      KMemoryPermission perm, KMemoryAttribute attr_mask,
+                                      KMemoryAttribute attr) const {
         return this->CheckMemoryStateContiguous(nullptr, addr, size, state_mask, state, perm_mask,
                                                 perm, attr_mask, attr);
     }
 
-    ResultCode CheckMemoryState(const KMemoryInfo& info, KMemoryState state_mask,
-                                KMemoryState state, KMemoryPermission perm_mask,
-                                KMemoryPermission perm, KMemoryAttribute attr_mask,
-                                KMemoryAttribute attr) const;
-    ResultCode CheckMemoryState(KMemoryState* out_state, KMemoryPermission* out_perm,
-                                KMemoryAttribute* out_attr, std::size_t* out_blocks_needed,
-                                VAddr addr, std::size_t size, KMemoryState state_mask,
-                                KMemoryState state, KMemoryPermission perm_mask,
-                                KMemoryPermission perm, KMemoryAttribute attr_mask,
-                                KMemoryAttribute attr,
-                                KMemoryAttribute ignore_attr = DefaultMemoryIgnoreAttr) const;
-    ResultCode CheckMemoryState(std::size_t* out_blocks_needed, VAddr addr, std::size_t size,
-                                KMemoryState state_mask, KMemoryState state,
-                                KMemoryPermission perm_mask, KMemoryPermission perm,
-                                KMemoryAttribute attr_mask, KMemoryAttribute attr,
-                                KMemoryAttribute ignore_attr = DefaultMemoryIgnoreAttr) const {
+    Result CheckMemoryState(const KMemoryInfo& info, KMemoryState state_mask, KMemoryState state,
+                            KMemoryPermission perm_mask, KMemoryPermission perm,
+                            KMemoryAttribute attr_mask, KMemoryAttribute attr) const;
+    Result CheckMemoryState(KMemoryState* out_state, KMemoryPermission* out_perm,
+                            KMemoryAttribute* out_attr, std::size_t* out_blocks_needed, VAddr addr,
+                            std::size_t size, KMemoryState state_mask, KMemoryState state,
+                            KMemoryPermission perm_mask, KMemoryPermission perm,
+                            KMemoryAttribute attr_mask, KMemoryAttribute attr,
+                            KMemoryAttribute ignore_attr = DefaultMemoryIgnoreAttr) const;
+    Result CheckMemoryState(std::size_t* out_blocks_needed, VAddr addr, std::size_t size,
+                            KMemoryState state_mask, KMemoryState state,
+                            KMemoryPermission perm_mask, KMemoryPermission perm,
+                            KMemoryAttribute attr_mask, KMemoryAttribute attr,
+                            KMemoryAttribute ignore_attr = DefaultMemoryIgnoreAttr) const {
         return CheckMemoryState(nullptr, nullptr, nullptr, out_blocks_needed, addr, size,
                                 state_mask, state, perm_mask, perm, attr_mask, attr, ignore_attr);
     }
-    ResultCode CheckMemoryState(VAddr addr, std::size_t size, KMemoryState state_mask,
-                                KMemoryState state, KMemoryPermission perm_mask,
-                                KMemoryPermission perm, KMemoryAttribute attr_mask,
-                                KMemoryAttribute attr,
-                                KMemoryAttribute ignore_attr = DefaultMemoryIgnoreAttr) const {
+    Result CheckMemoryState(VAddr addr, std::size_t size, KMemoryState state_mask,
+                            KMemoryState state, KMemoryPermission perm_mask, KMemoryPermission perm,
+                            KMemoryAttribute attr_mask, KMemoryAttribute attr,
+                            KMemoryAttribute ignore_attr = DefaultMemoryIgnoreAttr) const {
         return this->CheckMemoryState(nullptr, addr, size, state_mask, state, perm_mask, perm,
                                       attr_mask, attr, ignore_attr);
     }
 
-    ResultCode LockMemoryAndOpen(KPageLinkedList* out_pg, PAddr* out_paddr, VAddr addr, size_t size,
-                                 KMemoryState state_mask, KMemoryState state,
-                                 KMemoryPermission perm_mask, KMemoryPermission perm,
-                                 KMemoryAttribute attr_mask, KMemoryAttribute attr,
-                                 KMemoryPermission new_perm, KMemoryAttribute lock_attr);
-    ResultCode UnlockMemory(VAddr addr, size_t size, KMemoryState state_mask, KMemoryState state,
-                            KMemoryPermission perm_mask, KMemoryPermission perm,
-                            KMemoryAttribute attr_mask, KMemoryAttribute attr,
-                            KMemoryPermission new_perm, KMemoryAttribute lock_attr,
-                            const KPageLinkedList* pg);
+    Result LockMemoryAndOpen(KPageGroup* out_pg, PAddr* out_paddr, VAddr addr, size_t size,
+                             KMemoryState state_mask, KMemoryState state,
+                             KMemoryPermission perm_mask, KMemoryPermission perm,
+                             KMemoryAttribute attr_mask, KMemoryAttribute attr,
+                             KMemoryPermission new_perm, KMemoryAttribute lock_attr);
+    Result UnlockMemory(VAddr addr, size_t size, KMemoryState state_mask, KMemoryState state,
+                        KMemoryPermission perm_mask, KMemoryPermission perm,
+                        KMemoryAttribute attr_mask, KMemoryAttribute attr,
+                        KMemoryPermission new_perm, KMemoryAttribute lock_attr,
+                        const KPageGroup* pg);
 
-    ResultCode MakePageGroup(KPageLinkedList& pg, VAddr addr, size_t num_pages);
-    bool IsValidPageGroup(const KPageLinkedList& pg, VAddr addr, size_t num_pages);
+    Result MakePageGroup(KPageGroup& pg, VAddr addr, size_t num_pages);
+    bool IsValidPageGroup(const KPageGroup& pg, VAddr addr, size_t num_pages);
 
     bool IsLockedByCurrentThread() const {
         return general_lock.IsLockedByCurrentThread();
diff --git a/src/core/hle/kernel/k_port.cpp b/src/core/hle/kernel/k_port.cpp
index 51c2cd1ef..7a5a9dc2a 100644
--- a/src/core/hle/kernel/k_port.cpp
+++ b/src/core/hle/kernel/k_port.cpp
@@ -50,7 +50,7 @@ bool KPort::IsServerClosed() const {
     return state == State::ServerClosed;
 }
 
-ResultCode KPort::EnqueueSession(KServerSession* session) {
+Result KPort::EnqueueSession(KServerSession* session) {
     KScopedSchedulerLock sl{kernel};
 
     R_UNLESS(state == State::Normal, ResultPortClosed);
diff --git a/src/core/hle/kernel/k_port.h b/src/core/hle/kernel/k_port.h
index 1bfecf8c3..0cfc16dab 100644
--- a/src/core/hle/kernel/k_port.h
+++ b/src/core/hle/kernel/k_port.h
@@ -34,7 +34,7 @@ public:
 
     bool IsServerClosed() const;
 
-    ResultCode EnqueueSession(KServerSession* session);
+    Result EnqueueSession(KServerSession* session);
 
     KClientPort& GetClientPort() {
         return client;
diff --git a/src/core/hle/kernel/k_process.cpp b/src/core/hle/kernel/k_process.cpp
index b477c6e55..183c693e3 100644
--- a/src/core/hle/kernel/k_process.cpp
+++ b/src/core/hle/kernel/k_process.cpp
@@ -67,8 +67,8 @@ void SetupMainThread(Core::System& system, KProcess& owner_process, u32 priority
 }
 } // Anonymous namespace
 
-ResultCode KProcess::Initialize(KProcess* process, Core::System& system, std::string process_name,
-                                ProcessType type, KResourceLimit* res_limit) {
+Result KProcess::Initialize(KProcess* process, Core::System& system, std::string process_name,
+                            ProcessType type, KResourceLimit* res_limit) {
     auto& kernel = system.Kernel();
 
     process->name = std::move(process_name);
@@ -219,8 +219,8 @@ void KProcess::UnpinThread(KThread* thread) {
     KScheduler::SetSchedulerUpdateNeeded(kernel);
 }
 
-ResultCode KProcess::AddSharedMemory(KSharedMemory* shmem, [[maybe_unused]] VAddr address,
-                                     [[maybe_unused]] size_t size) {
+Result KProcess::AddSharedMemory(KSharedMemory* shmem, [[maybe_unused]] VAddr address,
+                                 [[maybe_unused]] size_t size) {
     // Lock ourselves, to prevent concurrent access.
     KScopedLightLock lk(state_lock);
 
@@ -284,7 +284,7 @@ void KProcess::UnregisterThread(KThread* thread) {
     thread_list.remove(thread);
 }
 
-ResultCode KProcess::Reset() {
+Result KProcess::Reset() {
     // Lock the process and the scheduler.
     KScopedLightLock lk(state_lock);
     KScopedSchedulerLock sl{kernel};
@@ -298,7 +298,7 @@ ResultCode KProcess::Reset() {
     return ResultSuccess;
 }
 
-ResultCode KProcess::SetActivity(ProcessActivity activity) {
+Result KProcess::SetActivity(ProcessActivity activity) {
     // Lock ourselves and the scheduler.
     KScopedLightLock lk{state_lock};
     KScopedLightLock list_lk{list_lock};
@@ -342,8 +342,7 @@ ResultCode KProcess::SetActivity(ProcessActivity activity) {
     return ResultSuccess;
 }
 
-ResultCode KProcess::LoadFromMetadata(const FileSys::ProgramMetadata& metadata,
-                                      std::size_t code_size) {
+Result KProcess::LoadFromMetadata(const FileSys::ProgramMetadata& metadata, std::size_t code_size) {
     program_id = metadata.GetTitleID();
     ideal_core = metadata.GetMainThreadCore();
     is_64bit_process = metadata.Is64BitProgram();
@@ -358,24 +357,24 @@ ResultCode KProcess::LoadFromMetadata(const FileSys::ProgramMetadata& metadata,
         return ResultLimitReached;
     }
     // Initialize proces address space
-    if (const ResultCode result{
-            page_table->InitializeForProcess(metadata.GetAddressSpaceType(), false, 0x8000000,
-                                             code_size, KMemoryManager::Pool::Application)};
+    if (const Result result{page_table->InitializeForProcess(metadata.GetAddressSpaceType(), false,
+                                                             0x8000000, code_size,
+                                                             KMemoryManager::Pool::Application)};
         result.IsError()) {
         return result;
     }
 
     // Map process code region
-    if (const ResultCode result{page_table->MapProcessCode(page_table->GetCodeRegionStart(),
-                                                           code_size / PageSize, KMemoryState::Code,
-                                                           KMemoryPermission::None)};
+    if (const Result result{page_table->MapProcessCode(page_table->GetCodeRegionStart(),
+                                                       code_size / PageSize, KMemoryState::Code,
+                                                       KMemoryPermission::None)};
         result.IsError()) {
         return result;
     }
 
     // Initialize process capabilities
     const auto& caps{metadata.GetKernelCapabilities()};
-    if (const ResultCode result{
+    if (const Result result{
             capabilities.InitializeForUserProcess(caps.data(), caps.size(), *page_table)};
         result.IsError()) {
         return result;
@@ -482,7 +481,7 @@ void KProcess::Finalize() {
     KAutoObjectWithSlabHeapAndContainer<KProcess, KWorkerTask>::Finalize();
 }
 
-ResultCode KProcess::CreateThreadLocalRegion(VAddr* out) {
+Result KProcess::CreateThreadLocalRegion(VAddr* out) {
     KThreadLocalPage* tlp = nullptr;
     VAddr tlr = 0;
 
@@ -533,7 +532,7 @@ ResultCode KProcess::CreateThreadLocalRegion(VAddr* out) {
     return ResultSuccess;
 }
 
-ResultCode KProcess::DeleteThreadLocalRegion(VAddr addr) {
+Result KProcess::DeleteThreadLocalRegion(VAddr addr) {
     KThreadLocalPage* page_to_free = nullptr;
 
     // Release the region.
@@ -664,7 +663,7 @@ void KProcess::ChangeStatus(ProcessStatus new_status) {
     NotifyAvailable();
 }
 
-ResultCode KProcess::AllocateMainThreadStack(std::size_t stack_size) {
+Result KProcess::AllocateMainThreadStack(std::size_t stack_size) {
     ASSERT(stack_size);
 
     // The kernel always ensures that the given stack size is page aligned.
diff --git a/src/core/hle/kernel/k_process.h b/src/core/hle/kernel/k_process.h
index c2086e5ba..5e3e22ad8 100644
--- a/src/core/hle/kernel/k_process.h
+++ b/src/core/hle/kernel/k_process.h
@@ -110,8 +110,8 @@ public:
 
     static constexpr std::size_t RANDOM_ENTROPY_SIZE = 4;
 
-    static ResultCode Initialize(KProcess* process, Core::System& system, std::string process_name,
-                                 ProcessType type, KResourceLimit* res_limit);
+    static Result Initialize(KProcess* process, Core::System& system, std::string process_name,
+                             ProcessType type, KResourceLimit* res_limit);
 
     /// Gets a reference to the process' page table.
     KPageTable& PageTable() {
@@ -133,11 +133,11 @@ public:
         return handle_table;
     }
 
-    ResultCode SignalToAddress(VAddr address) {
+    Result SignalToAddress(VAddr address) {
         return condition_var.SignalToAddress(address);
     }
 
-    ResultCode WaitForAddress(Handle handle, VAddr address, u32 tag) {
+    Result WaitForAddress(Handle handle, VAddr address, u32 tag) {
         return condition_var.WaitForAddress(handle, address, tag);
     }
 
@@ -145,17 +145,16 @@ public:
         return condition_var.Signal(cv_key, count);
     }
 
-    ResultCode WaitConditionVariable(VAddr address, u64 cv_key, u32 tag, s64 ns) {
+    Result WaitConditionVariable(VAddr address, u64 cv_key, u32 tag, s64 ns) {
         return condition_var.Wait(address, cv_key, tag, ns);
     }
 
-    ResultCode SignalAddressArbiter(VAddr address, Svc::SignalType signal_type, s32 value,
-                                    s32 count) {
+    Result SignalAddressArbiter(VAddr address, Svc::SignalType signal_type, s32 value, s32 count) {
         return address_arbiter.SignalToAddress(address, signal_type, value, count);
     }
 
-    ResultCode WaitAddressArbiter(VAddr address, Svc::ArbitrationType arb_type, s32 value,
-                                  s64 timeout) {
+    Result WaitAddressArbiter(VAddr address, Svc::ArbitrationType arb_type, s32 value,
+                              s64 timeout) {
         return address_arbiter.WaitForAddress(address, arb_type, value, timeout);
     }
 
@@ -322,7 +321,7 @@ public:
     /// @pre The process must be in a signaled state. If this is called on a
     ///      process instance that is not signaled, ERR_INVALID_STATE will be
     ///      returned.
-    ResultCode Reset();
+    Result Reset();
 
     /**
      * Loads process-specifics configuration info with metadata provided
@@ -333,7 +332,7 @@ public:
      * @returns ResultSuccess if all relevant metadata was able to be
      *          loaded and parsed. Otherwise, an error code is returned.
      */
-    ResultCode LoadFromMetadata(const FileSys::ProgramMetadata& metadata, std::size_t code_size);
+    Result LoadFromMetadata(const FileSys::ProgramMetadata& metadata, std::size_t code_size);
 
     /**
      * Starts the main application thread for this process.
@@ -367,7 +366,7 @@ public:
 
     void DoWorkerTaskImpl();
 
-    ResultCode SetActivity(ProcessActivity activity);
+    Result SetActivity(ProcessActivity activity);
 
     void PinCurrentThread(s32 core_id);
     void UnpinCurrentThread(s32 core_id);
@@ -377,17 +376,17 @@ public:
         return state_lock;
     }
 
-    ResultCode AddSharedMemory(KSharedMemory* shmem, VAddr address, size_t size);
+    Result AddSharedMemory(KSharedMemory* shmem, VAddr address, size_t size);
     void RemoveSharedMemory(KSharedMemory* shmem, VAddr address, size_t size);
 
     ///////////////////////////////////////////////////////////////////////////////////////////////
     // Thread-local storage management
 
     // Marks the next available region as used and returns the address of the slot.
-    [[nodiscard]] ResultCode CreateThreadLocalRegion(VAddr* out);
+    [[nodiscard]] Result CreateThreadLocalRegion(VAddr* out);
 
     // Frees a used TLS slot identified by the given address
-    ResultCode DeleteThreadLocalRegion(VAddr addr);
+    Result DeleteThreadLocalRegion(VAddr addr);
 
     ///////////////////////////////////////////////////////////////////////////////////////////////
     // Debug watchpoint management
@@ -423,7 +422,7 @@ private:
     void ChangeStatus(ProcessStatus new_status);
 
     /// Allocates the main thread stack for the process, given the stack size in bytes.
-    ResultCode AllocateMainThreadStack(std::size_t stack_size);
+    Result AllocateMainThreadStack(std::size_t stack_size);
 
     /// Memory manager for this process
     std::unique_ptr<KPageTable> page_table;
diff --git a/src/core/hle/kernel/k_readable_event.cpp b/src/core/hle/kernel/k_readable_event.cpp
index dddba554d..94c5464fe 100644
--- a/src/core/hle/kernel/k_readable_event.cpp
+++ b/src/core/hle/kernel/k_readable_event.cpp
@@ -27,7 +27,7 @@ void KReadableEvent::Destroy() {
     }
 }
 
-ResultCode KReadableEvent::Signal() {
+Result KReadableEvent::Signal() {
     KScopedSchedulerLock lk{kernel};
 
     if (!is_signaled) {
@@ -38,13 +38,13 @@ ResultCode KReadableEvent::Signal() {
     return ResultSuccess;
 }
 
-ResultCode KReadableEvent::Clear() {
+Result KReadableEvent::Clear() {
     Reset();
 
     return ResultSuccess;
 }
 
-ResultCode KReadableEvent::Reset() {
+Result KReadableEvent::Reset() {
     KScopedSchedulerLock lk{kernel};
 
     if (!is_signaled) {
diff --git a/src/core/hle/kernel/k_readable_event.h b/src/core/hle/kernel/k_readable_event.h
index 5065c7cc0..18dcad289 100644
--- a/src/core/hle/kernel/k_readable_event.h
+++ b/src/core/hle/kernel/k_readable_event.h
@@ -33,9 +33,9 @@ public:
     bool IsSignaled() const override;
     void Destroy() override;
 
-    ResultCode Signal();
-    ResultCode Clear();
-    ResultCode Reset();
+    Result Signal();
+    Result Clear();
+    Result Reset();
 
 private:
     bool is_signaled{};
diff --git a/src/core/hle/kernel/k_resource_limit.cpp b/src/core/hle/kernel/k_resource_limit.cpp
index 3e0ecffdb..010dcf99e 100644
--- a/src/core/hle/kernel/k_resource_limit.cpp
+++ b/src/core/hle/kernel/k_resource_limit.cpp
@@ -73,7 +73,7 @@ s64 KResourceLimit::GetFreeValue(LimitableResource which) const {
     return value;
 }
 
-ResultCode KResourceLimit::SetLimitValue(LimitableResource which, s64 value) {
+Result KResourceLimit::SetLimitValue(LimitableResource which, s64 value) {
     const auto index = static_cast<std::size_t>(which);
     KScopedLightLock lk(lock);
     R_UNLESS(current_values[index] <= value, ResultInvalidState);
diff --git a/src/core/hle/kernel/k_resource_limit.h b/src/core/hle/kernel/k_resource_limit.h
index 43bf74b8d..65c98c979 100644
--- a/src/core/hle/kernel/k_resource_limit.h
+++ b/src/core/hle/kernel/k_resource_limit.h
@@ -8,7 +8,7 @@
 #include "core/hle/kernel/k_light_condition_variable.h"
 #include "core/hle/kernel/k_light_lock.h"
 
-union ResultCode;
+union Result;
 
 namespace Core::Timing {
 class CoreTiming;
@@ -46,7 +46,7 @@ public:
     s64 GetPeakValue(LimitableResource which) const;
     s64 GetFreeValue(LimitableResource which) const;
 
-    ResultCode SetLimitValue(LimitableResource which, s64 value);
+    Result SetLimitValue(LimitableResource which, s64 value);
 
     bool Reserve(LimitableResource which, s64 value);
     bool Reserve(LimitableResource which, s64 value, s64 timeout);
diff --git a/src/core/hle/kernel/k_server_session.cpp b/src/core/hle/kernel/k_server_session.cpp
index 60f8ed470..802c646a6 100644
--- a/src/core/hle/kernel/k_server_session.cpp
+++ b/src/core/hle/kernel/k_server_session.cpp
@@ -79,7 +79,7 @@ std::size_t KServerSession::NumDomainRequestHandlers() const {
     return manager->DomainHandlerCount();
 }
 
-ResultCode KServerSession::HandleDomainSyncRequest(Kernel::HLERequestContext& context) {
+Result KServerSession::HandleDomainSyncRequest(Kernel::HLERequestContext& context) {
     if (!context.HasDomainMessageHeader()) {
         return ResultSuccess;
     }
@@ -123,7 +123,7 @@ ResultCode KServerSession::HandleDomainSyncRequest(Kernel::HLERequestContext& co
     return ResultSuccess;
 }
 
-ResultCode KServerSession::QueueSyncRequest(KThread* thread, Core::Memory::Memory& memory) {
+Result KServerSession::QueueSyncRequest(KThread* thread, Core::Memory::Memory& memory) {
     u32* cmd_buf{reinterpret_cast<u32*>(memory.GetPointer(thread->GetTLSAddress()))};
     auto context = std::make_shared<HLERequestContext>(kernel, memory, this, thread);
 
@@ -143,8 +143,8 @@ ResultCode KServerSession::QueueSyncRequest(KThread* thread, Core::Memory::Memor
     return ResultSuccess;
 }
 
-ResultCode KServerSession::CompleteSyncRequest(HLERequestContext& context) {
-    ResultCode result = ResultSuccess;
+Result KServerSession::CompleteSyncRequest(HLERequestContext& context) {
+    Result result = ResultSuccess;
 
     // If the session has been converted to a domain, handle the domain request
     if (manager->HasSessionRequestHandler(context)) {
@@ -173,8 +173,8 @@ ResultCode KServerSession::CompleteSyncRequest(HLERequestContext& context) {
     return result;
 }
 
-ResultCode KServerSession::HandleSyncRequest(KThread* thread, Core::Memory::Memory& memory,
-                                             Core::Timing::CoreTiming& core_timing) {
+Result KServerSession::HandleSyncRequest(KThread* thread, Core::Memory::Memory& memory,
+                                         Core::Timing::CoreTiming& core_timing) {
     return QueueSyncRequest(thread, memory);
 }
 
diff --git a/src/core/hle/kernel/k_server_session.h b/src/core/hle/kernel/k_server_session.h
index b628a843f..6d0821945 100644
--- a/src/core/hle/kernel/k_server_session.h
+++ b/src/core/hle/kernel/k_server_session.h
@@ -73,10 +73,10 @@ public:
      * @param memory      Memory context to handle the sync request under.
      * @param core_timing Core timing context to schedule the request event under.
      *
-     * @returns ResultCode from the operation.
+     * @returns Result from the operation.
      */
-    ResultCode HandleSyncRequest(KThread* thread, Core::Memory::Memory& memory,
-                                 Core::Timing::CoreTiming& core_timing);
+    Result HandleSyncRequest(KThread* thread, Core::Memory::Memory& memory,
+                             Core::Timing::CoreTiming& core_timing);
 
     /// Adds a new domain request handler to the collection of request handlers within
     /// this ServerSession instance.
@@ -103,14 +103,14 @@ public:
 
 private:
     /// Queues a sync request from the emulated application.
-    ResultCode QueueSyncRequest(KThread* thread, Core::Memory::Memory& memory);
+    Result QueueSyncRequest(KThread* thread, Core::Memory::Memory& memory);
 
     /// Completes a sync request from the emulated application.
-    ResultCode CompleteSyncRequest(HLERequestContext& context);
+    Result CompleteSyncRequest(HLERequestContext& context);
 
     /// Handles a SyncRequest to a domain, forwarding the request to the proper object or closing an
     /// object handle.
-    ResultCode HandleDomainSyncRequest(Kernel::HLERequestContext& context);
+    Result HandleDomainSyncRequest(Kernel::HLERequestContext& context);
 
     /// This session's HLE request handlers
     std::shared_ptr<SessionRequestManager> manager;
diff --git a/src/core/hle/kernel/k_shared_memory.cpp b/src/core/hle/kernel/k_shared_memory.cpp
index 51d7538ca..b77735736 100644
--- a/src/core/hle/kernel/k_shared_memory.cpp
+++ b/src/core/hle/kernel/k_shared_memory.cpp
@@ -18,12 +18,10 @@ KSharedMemory::~KSharedMemory() {
     kernel.GetSystemResourceLimit()->Release(LimitableResource::PhysicalMemory, size);
 }
 
-ResultCode KSharedMemory::Initialize(Core::DeviceMemory& device_memory_, KProcess* owner_process_,
-                                     KPageLinkedList&& page_list_,
-                                     Svc::MemoryPermission owner_permission_,
-                                     Svc::MemoryPermission user_permission_,
-                                     PAddr physical_address_, std::size_t size_,
-                                     std::string name_) {
+Result KSharedMemory::Initialize(Core::DeviceMemory& device_memory_, KProcess* owner_process_,
+                                 KPageGroup&& page_list_, Svc::MemoryPermission owner_permission_,
+                                 Svc::MemoryPermission user_permission_, PAddr physical_address_,
+                                 std::size_t size_, std::string name_) {
     // Set members.
     owner_process = owner_process_;
     device_memory = &device_memory_;
@@ -67,8 +65,8 @@ void KSharedMemory::Finalize() {
     KAutoObjectWithSlabHeapAndContainer<KSharedMemory, KAutoObjectWithList>::Finalize();
 }
 
-ResultCode KSharedMemory::Map(KProcess& target_process, VAddr address, std::size_t map_size,
-                              Svc::MemoryPermission permissions) {
+Result KSharedMemory::Map(KProcess& target_process, VAddr address, std::size_t map_size,
+                          Svc::MemoryPermission permissions) {
     const u64 page_count{(map_size + PageSize - 1) / PageSize};
 
     if (page_list.GetNumPages() != page_count) {
@@ -86,7 +84,7 @@ ResultCode KSharedMemory::Map(KProcess& target_process, VAddr address, std::size
                                                ConvertToKMemoryPermission(permissions));
 }
 
-ResultCode KSharedMemory::Unmap(KProcess& target_process, VAddr address, std::size_t unmap_size) {
+Result KSharedMemory::Unmap(KProcess& target_process, VAddr address, std::size_t unmap_size) {
     const u64 page_count{(unmap_size + PageSize - 1) / PageSize};
 
     if (page_list.GetNumPages() != page_count) {
diff --git a/src/core/hle/kernel/k_shared_memory.h b/src/core/hle/kernel/k_shared_memory.h
index 81de36136..2c1db0e70 100644
--- a/src/core/hle/kernel/k_shared_memory.h
+++ b/src/core/hle/kernel/k_shared_memory.h
@@ -9,7 +9,7 @@
 #include "common/common_types.h"
 #include "core/device_memory.h"
 #include "core/hle/kernel/k_memory_block.h"
-#include "core/hle/kernel/k_page_linked_list.h"
+#include "core/hle/kernel/k_page_group.h"
 #include "core/hle/kernel/k_process.h"
 #include "core/hle/kernel/slab_helpers.h"
 #include "core/hle/result.h"
@@ -26,10 +26,10 @@ public:
     explicit KSharedMemory(KernelCore& kernel_);
     ~KSharedMemory() override;
 
-    ResultCode Initialize(Core::DeviceMemory& device_memory_, KProcess* owner_process_,
-                          KPageLinkedList&& page_list_, Svc::MemoryPermission owner_permission_,
-                          Svc::MemoryPermission user_permission_, PAddr physical_address_,
-                          std::size_t size_, std::string name_);
+    Result Initialize(Core::DeviceMemory& device_memory_, KProcess* owner_process_,
+                      KPageGroup&& page_list_, Svc::MemoryPermission owner_permission_,
+                      Svc::MemoryPermission user_permission_, PAddr physical_address_,
+                      std::size_t size_, std::string name_);
 
     /**
      * Maps a shared memory block to an address in the target process' address space
@@ -38,8 +38,8 @@ public:
      * @param map_size Size of the shared memory block to map
      * @param permissions Memory block map permissions (specified by SVC field)
      */
-    ResultCode Map(KProcess& target_process, VAddr address, std::size_t map_size,
-                   Svc::MemoryPermission permissions);
+    Result Map(KProcess& target_process, VAddr address, std::size_t map_size,
+               Svc::MemoryPermission permissions);
 
     /**
      * Unmaps a shared memory block from an address in the target process' address space
@@ -47,7 +47,7 @@ public:
      * @param address Address in system memory to unmap shared memory block
      * @param unmap_size Size of the shared memory block to unmap
      */
-    ResultCode Unmap(KProcess& target_process, VAddr address, std::size_t unmap_size);
+    Result Unmap(KProcess& target_process, VAddr address, std::size_t unmap_size);
 
     /**
      * Gets a pointer to the shared memory block
@@ -77,7 +77,7 @@ public:
 private:
     Core::DeviceMemory* device_memory;
     KProcess* owner_process{};
-    KPageLinkedList page_list;
+    KPageGroup page_list;
     Svc::MemoryPermission owner_permission{};
     Svc::MemoryPermission user_permission{};
     PAddr physical_address{};
diff --git a/src/core/hle/kernel/k_synchronization_object.cpp b/src/core/hle/kernel/k_synchronization_object.cpp
index 8554144d5..802dca046 100644
--- a/src/core/hle/kernel/k_synchronization_object.cpp
+++ b/src/core/hle/kernel/k_synchronization_object.cpp
@@ -22,7 +22,7 @@ public:
         : KThreadQueueWithoutEndWait(kernel_), m_objects(o), m_nodes(n), m_count(c) {}
 
     void NotifyAvailable(KThread* waiting_thread, KSynchronizationObject* signaled_object,
-                         ResultCode wait_result) override {
+                         Result wait_result) override {
         // Determine the sync index, and unlink all nodes.
         s32 sync_index = -1;
         for (auto i = 0; i < m_count; ++i) {
@@ -45,8 +45,7 @@ public:
         KThreadQueue::EndWait(waiting_thread, wait_result);
     }
 
-    void CancelWait(KThread* waiting_thread, ResultCode wait_result,
-                    bool cancel_timer_task) override {
+    void CancelWait(KThread* waiting_thread, Result wait_result, bool cancel_timer_task) override {
         // Remove all nodes from our list.
         for (auto i = 0; i < m_count; ++i) {
             m_objects[i]->UnlinkNode(std::addressof(m_nodes[i]));
@@ -72,9 +71,9 @@ void KSynchronizationObject::Finalize() {
     KAutoObject::Finalize();
 }
 
-ResultCode KSynchronizationObject::Wait(KernelCore& kernel_ctx, s32* out_index,
-                                        KSynchronizationObject** objects, const s32 num_objects,
-                                        s64 timeout) {
+Result KSynchronizationObject::Wait(KernelCore& kernel_ctx, s32* out_index,
+                                    KSynchronizationObject** objects, const s32 num_objects,
+                                    s64 timeout) {
     // Allocate space on stack for thread nodes.
     std::vector<ThreadListNode> thread_nodes(num_objects);
 
@@ -148,7 +147,7 @@ KSynchronizationObject::KSynchronizationObject(KernelCore& kernel_)
 
 KSynchronizationObject::~KSynchronizationObject() = default;
 
-void KSynchronizationObject::NotifyAvailable(ResultCode result) {
+void KSynchronizationObject::NotifyAvailable(Result result) {
     KScopedSchedulerLock sl(kernel);
 
     // If we're not signaled, we've nothing to notify.
diff --git a/src/core/hle/kernel/k_synchronization_object.h b/src/core/hle/kernel/k_synchronization_object.h
index d7540d6c7..8d8122ab7 100644
--- a/src/core/hle/kernel/k_synchronization_object.h
+++ b/src/core/hle/kernel/k_synchronization_object.h
@@ -24,9 +24,9 @@ public:
         KThread* thread{};
     };
 
-    [[nodiscard]] static ResultCode Wait(KernelCore& kernel, s32* out_index,
-                                         KSynchronizationObject** objects, const s32 num_objects,
-                                         s64 timeout);
+    [[nodiscard]] static Result Wait(KernelCore& kernel, s32* out_index,
+                                     KSynchronizationObject** objects, const s32 num_objects,
+                                     s64 timeout);
 
     void Finalize() override;
 
@@ -72,7 +72,7 @@ protected:
 
     virtual void OnFinalizeSynchronizationObject() {}
 
-    void NotifyAvailable(ResultCode result);
+    void NotifyAvailable(Result result);
     void NotifyAvailable() {
         return this->NotifyAvailable(ResultSuccess);
     }
diff --git a/src/core/hle/kernel/k_thread.cpp b/src/core/hle/kernel/k_thread.cpp
index fa5352847..8d7faa662 100644
--- a/src/core/hle/kernel/k_thread.cpp
+++ b/src/core/hle/kernel/k_thread.cpp
@@ -80,8 +80,7 @@ public:
     explicit ThreadQueueImplForKThreadSetProperty(KernelCore& kernel_, KThread::WaiterList* wl)
         : KThreadQueue(kernel_), m_wait_list(wl) {}
 
-    void CancelWait(KThread* waiting_thread, ResultCode wait_result,
-                    bool cancel_timer_task) override {
+    void CancelWait(KThread* waiting_thread, Result wait_result, bool cancel_timer_task) override {
         // Remove the thread from the wait list.
         m_wait_list->erase(m_wait_list->iterator_to(*waiting_thread));
 
@@ -99,8 +98,8 @@ KThread::KThread(KernelCore& kernel_)
     : KAutoObjectWithSlabHeapAndContainer{kernel_}, activity_pause_lock{kernel_} {}
 KThread::~KThread() = default;
 
-ResultCode KThread::Initialize(KThreadFunction func, uintptr_t arg, VAddr user_stack_top, s32 prio,
-                               s32 virt_core, KProcess* owner, ThreadType type) {
+Result KThread::Initialize(KThreadFunction func, uintptr_t arg, VAddr user_stack_top, s32 prio,
+                           s32 virt_core, KProcess* owner, ThreadType type) {
     // Assert parameters are valid.
     ASSERT((type == ThreadType::Main) || (type == ThreadType::Dummy) ||
            (Svc::HighestThreadPriority <= prio && prio <= Svc::LowestThreadPriority));
@@ -245,10 +244,10 @@ ResultCode KThread::Initialize(KThreadFunction func, uintptr_t arg, VAddr user_s
     return ResultSuccess;
 }
 
-ResultCode KThread::InitializeThread(KThread* thread, KThreadFunction func, uintptr_t arg,
-                                     VAddr user_stack_top, s32 prio, s32 core, KProcess* owner,
-                                     ThreadType type, std::function<void(void*)>&& init_func,
-                                     void* init_func_parameter) {
+Result KThread::InitializeThread(KThread* thread, KThreadFunction func, uintptr_t arg,
+                                 VAddr user_stack_top, s32 prio, s32 core, KProcess* owner,
+                                 ThreadType type, std::function<void(void*)>&& init_func,
+                                 void* init_func_parameter) {
     // Initialize the thread.
     R_TRY(thread->Initialize(func, arg, user_stack_top, prio, core, owner, type));
 
@@ -260,27 +259,26 @@ ResultCode KThread::InitializeThread(KThread* thread, KThreadFunction func, uint
     return ResultSuccess;
 }
 
-ResultCode KThread::InitializeDummyThread(KThread* thread) {
+Result KThread::InitializeDummyThread(KThread* thread) {
     return thread->Initialize({}, {}, {}, DummyThreadPriority, 3, {}, ThreadType::Dummy);
 }
 
-ResultCode KThread::InitializeIdleThread(Core::System& system, KThread* thread, s32 virt_core) {
+Result KThread::InitializeIdleThread(Core::System& system, KThread* thread, s32 virt_core) {
     return InitializeThread(thread, {}, {}, {}, IdleThreadPriority, virt_core, {}, ThreadType::Main,
                             Core::CpuManager::GetIdleThreadStartFunc(),
                             system.GetCpuManager().GetStartFuncParameter());
 }
 
-ResultCode KThread::InitializeHighPriorityThread(Core::System& system, KThread* thread,
-                                                 KThreadFunction func, uintptr_t arg,
-                                                 s32 virt_core) {
+Result KThread::InitializeHighPriorityThread(Core::System& system, KThread* thread,
+                                             KThreadFunction func, uintptr_t arg, s32 virt_core) {
     return InitializeThread(thread, func, arg, {}, {}, virt_core, nullptr, ThreadType::HighPriority,
                             Core::CpuManager::GetShutdownThreadStartFunc(),
                             system.GetCpuManager().GetStartFuncParameter());
 }
 
-ResultCode KThread::InitializeUserThread(Core::System& system, KThread* thread,
-                                         KThreadFunction func, uintptr_t arg, VAddr user_stack_top,
-                                         s32 prio, s32 virt_core, KProcess* owner) {
+Result KThread::InitializeUserThread(Core::System& system, KThread* thread, KThreadFunction func,
+                                     uintptr_t arg, VAddr user_stack_top, s32 prio, s32 virt_core,
+                                     KProcess* owner) {
     system.Kernel().GlobalSchedulerContext().AddThread(thread);
     return InitializeThread(thread, func, arg, user_stack_top, prio, virt_core, owner,
                             ThreadType::User, Core::CpuManager::GetGuestThreadStartFunc(),
@@ -523,7 +521,7 @@ void KThread::ClearInterruptFlag() {
     memory.Write16(tls_address + offsetof(ThreadLocalRegion, interrupt_flag), 0);
 }
 
-ResultCode KThread::GetCoreMask(s32* out_ideal_core, u64* out_affinity_mask) {
+Result KThread::GetCoreMask(s32* out_ideal_core, u64* out_affinity_mask) {
     KScopedSchedulerLock sl{kernel};
 
     // Get the virtual mask.
@@ -533,7 +531,7 @@ ResultCode KThread::GetCoreMask(s32* out_ideal_core, u64* out_affinity_mask) {
     return ResultSuccess;
 }
 
-ResultCode KThread::GetPhysicalCoreMask(s32* out_ideal_core, u64* out_affinity_mask) {
+Result KThread::GetPhysicalCoreMask(s32* out_ideal_core, u64* out_affinity_mask) {
     KScopedSchedulerLock sl{kernel};
     ASSERT(num_core_migration_disables >= 0);
 
@@ -549,7 +547,7 @@ ResultCode KThread::GetPhysicalCoreMask(s32* out_ideal_core, u64* out_affinity_m
     return ResultSuccess;
 }
 
-ResultCode KThread::SetCoreMask(s32 core_id_, u64 v_affinity_mask) {
+Result KThread::SetCoreMask(s32 core_id_, u64 v_affinity_mask) {
     ASSERT(parent != nullptr);
     ASSERT(v_affinity_mask != 0);
     KScopedLightLock lk(activity_pause_lock);
@@ -761,7 +759,7 @@ void KThread::WaitUntilSuspended() {
     }
 }
 
-ResultCode KThread::SetActivity(Svc::ThreadActivity activity) {
+Result KThread::SetActivity(Svc::ThreadActivity activity) {
     // Lock ourselves.
     KScopedLightLock lk(activity_pause_lock);
 
@@ -834,7 +832,7 @@ ResultCode KThread::SetActivity(Svc::ThreadActivity activity) {
     return ResultSuccess;
 }
 
-ResultCode KThread::GetThreadContext3(std::vector<u8>& out) {
+Result KThread::GetThreadContext3(std::vector<u8>& out) {
     // Lock ourselves.
     KScopedLightLock lk{activity_pause_lock};
 
@@ -999,7 +997,7 @@ KThread* KThread::RemoveWaiterByKey(s32* out_num_waiters, VAddr key) {
     return next_lock_owner;
 }
 
-ResultCode KThread::Run() {
+Result KThread::Run() {
     while (true) {
         KScopedSchedulerLock lk{kernel};
 
@@ -1060,7 +1058,7 @@ void KThread::Exit() {
     }
 }
 
-ResultCode KThread::Sleep(s64 timeout) {
+Result KThread::Sleep(s64 timeout) {
     ASSERT(!kernel.GlobalSchedulerContext().IsLocked());
     ASSERT(this == GetCurrentThreadPointer(kernel));
     ASSERT(timeout > 0);
@@ -1116,7 +1114,7 @@ void KThread::BeginWait(KThreadQueue* queue) {
     wait_queue = queue;
 }
 
-void KThread::NotifyAvailable(KSynchronizationObject* signaled_object, ResultCode wait_result_) {
+void KThread::NotifyAvailable(KSynchronizationObject* signaled_object, Result wait_result_) {
     // Lock the scheduler.
     KScopedSchedulerLock sl(kernel);
 
@@ -1126,7 +1124,7 @@ void KThread::NotifyAvailable(KSynchronizationObject* signaled_object, ResultCod
     }
 }
 
-void KThread::EndWait(ResultCode wait_result_) {
+void KThread::EndWait(Result wait_result_) {
     // Lock the scheduler.
     KScopedSchedulerLock sl(kernel);
 
@@ -1145,7 +1143,7 @@ void KThread::EndWait(ResultCode wait_result_) {
     }
 }
 
-void KThread::CancelWait(ResultCode wait_result_, bool cancel_timer_task) {
+void KThread::CancelWait(Result wait_result_, bool cancel_timer_task) {
     // Lock the scheduler.
     KScopedSchedulerLock sl(kernel);
 
diff --git a/src/core/hle/kernel/k_thread.h b/src/core/hle/kernel/k_thread.h
index c6ca37f56..94c4cd1c8 100644
--- a/src/core/hle/kernel/k_thread.h
+++ b/src/core/hle/kernel/k_thread.h
@@ -176,7 +176,7 @@ public:
 
     void SetBasePriority(s32 value);
 
-    [[nodiscard]] ResultCode Run();
+    [[nodiscard]] Result Run();
 
     void Exit();
 
@@ -218,11 +218,11 @@ public:
         return synced_index;
     }
 
-    constexpr void SetWaitResult(ResultCode wait_res) {
+    constexpr void SetWaitResult(Result wait_res) {
         wait_result = wait_res;
     }
 
-    [[nodiscard]] constexpr ResultCode GetWaitResult() const {
+    [[nodiscard]] constexpr Result GetWaitResult() const {
         return wait_result;
     }
 
@@ -345,15 +345,15 @@ public:
         return physical_affinity_mask;
     }
 
-    [[nodiscard]] ResultCode GetCoreMask(s32* out_ideal_core, u64* out_affinity_mask);
+    [[nodiscard]] Result GetCoreMask(s32* out_ideal_core, u64* out_affinity_mask);
 
-    [[nodiscard]] ResultCode GetPhysicalCoreMask(s32* out_ideal_core, u64* out_affinity_mask);
+    [[nodiscard]] Result GetPhysicalCoreMask(s32* out_ideal_core, u64* out_affinity_mask);
 
-    [[nodiscard]] ResultCode SetCoreMask(s32 cpu_core_id, u64 v_affinity_mask);
+    [[nodiscard]] Result SetCoreMask(s32 cpu_core_id, u64 v_affinity_mask);
 
-    [[nodiscard]] ResultCode SetActivity(Svc::ThreadActivity activity);
+    [[nodiscard]] Result SetActivity(Svc::ThreadActivity activity);
 
-    [[nodiscard]] ResultCode Sleep(s64 timeout);
+    [[nodiscard]] Result Sleep(s64 timeout);
 
     [[nodiscard]] s64 GetYieldScheduleCount() const {
         return schedule_count;
@@ -411,20 +411,19 @@ public:
 
     static void PostDestroy(uintptr_t arg);
 
-    [[nodiscard]] static ResultCode InitializeDummyThread(KThread* thread);
+    [[nodiscard]] static Result InitializeDummyThread(KThread* thread);
 
-    [[nodiscard]] static ResultCode InitializeIdleThread(Core::System& system, KThread* thread,
-                                                         s32 virt_core);
+    [[nodiscard]] static Result InitializeIdleThread(Core::System& system, KThread* thread,
+                                                     s32 virt_core);
 
-    [[nodiscard]] static ResultCode InitializeHighPriorityThread(Core::System& system,
-                                                                 KThread* thread,
-                                                                 KThreadFunction func,
-                                                                 uintptr_t arg, s32 virt_core);
+    [[nodiscard]] static Result InitializeHighPriorityThread(Core::System& system, KThread* thread,
+                                                             KThreadFunction func, uintptr_t arg,
+                                                             s32 virt_core);
 
-    [[nodiscard]] static ResultCode InitializeUserThread(Core::System& system, KThread* thread,
-                                                         KThreadFunction func, uintptr_t arg,
-                                                         VAddr user_stack_top, s32 prio,
-                                                         s32 virt_core, KProcess* owner);
+    [[nodiscard]] static Result InitializeUserThread(Core::System& system, KThread* thread,
+                                                     KThreadFunction func, uintptr_t arg,
+                                                     VAddr user_stack_top, s32 prio, s32 virt_core,
+                                                     KProcess* owner);
 
 public:
     struct StackParameters {
@@ -610,7 +609,7 @@ public:
 
     void RemoveWaiter(KThread* thread);
 
-    [[nodiscard]] ResultCode GetThreadContext3(std::vector<u8>& out);
+    [[nodiscard]] Result GetThreadContext3(std::vector<u8>& out);
 
     [[nodiscard]] KThread* RemoveWaiterByKey(s32* out_num_waiters, VAddr key);
 
@@ -636,9 +635,9 @@ public:
     }
 
     void BeginWait(KThreadQueue* queue);
-    void NotifyAvailable(KSynchronizationObject* signaled_object, ResultCode wait_result_);
-    void EndWait(ResultCode wait_result_);
-    void CancelWait(ResultCode wait_result_, bool cancel_timer_task);
+    void NotifyAvailable(KSynchronizationObject* signaled_object, Result wait_result_);
+    void EndWait(Result wait_result_);
+    void CancelWait(Result wait_result_, bool cancel_timer_task);
 
     [[nodiscard]] bool HasWaiters() const {
         return !waiter_list.empty();
@@ -724,14 +723,14 @@ private:
 
     void FinishTermination();
 
-    [[nodiscard]] ResultCode Initialize(KThreadFunction func, uintptr_t arg, VAddr user_stack_top,
-                                        s32 prio, s32 virt_core, KProcess* owner, ThreadType type);
+    [[nodiscard]] Result Initialize(KThreadFunction func, uintptr_t arg, VAddr user_stack_top,
+                                    s32 prio, s32 virt_core, KProcess* owner, ThreadType type);
 
-    [[nodiscard]] static ResultCode InitializeThread(KThread* thread, KThreadFunction func,
-                                                     uintptr_t arg, VAddr user_stack_top, s32 prio,
-                                                     s32 core, KProcess* owner, ThreadType type,
-                                                     std::function<void(void*)>&& init_func,
-                                                     void* init_func_parameter);
+    [[nodiscard]] static Result InitializeThread(KThread* thread, KThreadFunction func,
+                                                 uintptr_t arg, VAddr user_stack_top, s32 prio,
+                                                 s32 core, KProcess* owner, ThreadType type,
+                                                 std::function<void(void*)>&& init_func,
+                                                 void* init_func_parameter);
 
     static void RestorePriority(KernelCore& kernel_ctx, KThread* thread);
 
@@ -768,7 +767,7 @@ private:
     u32 suspend_request_flags{};
     u32 suspend_allowed_flags{};
     s32 synced_index{};
-    ResultCode wait_result{ResultSuccess};
+    Result wait_result{ResultSuccess};
     s32 base_priority{};
     s32 physical_ideal_core_id{};
     s32 virtual_ideal_core_id{};
diff --git a/src/core/hle/kernel/k_thread_local_page.cpp b/src/core/hle/kernel/k_thread_local_page.cpp
index fbdc40b3a..563560114 100644
--- a/src/core/hle/kernel/k_thread_local_page.cpp
+++ b/src/core/hle/kernel/k_thread_local_page.cpp
@@ -13,7 +13,7 @@
 
 namespace Kernel {
 
-ResultCode KThreadLocalPage::Initialize(KernelCore& kernel, KProcess* process) {
+Result KThreadLocalPage::Initialize(KernelCore& kernel, KProcess* process) {
     // Set that this process owns us.
     m_owner = process;
     m_kernel = &kernel;
@@ -35,7 +35,7 @@ ResultCode KThreadLocalPage::Initialize(KernelCore& kernel, KProcess* process) {
     return ResultSuccess;
 }
 
-ResultCode KThreadLocalPage::Finalize() {
+Result KThreadLocalPage::Finalize() {
     // Get the physical address of the page.
     const PAddr phys_addr = m_owner->PageTable().GetPhysicalAddr(m_virt_addr);
     ASSERT(phys_addr);
diff --git a/src/core/hle/kernel/k_thread_local_page.h b/src/core/hle/kernel/k_thread_local_page.h
index a4fe43ee5..0a7f22680 100644
--- a/src/core/hle/kernel/k_thread_local_page.h
+++ b/src/core/hle/kernel/k_thread_local_page.h
@@ -34,8 +34,8 @@ public:
         return m_virt_addr;
     }
 
-    ResultCode Initialize(KernelCore& kernel, KProcess* process);
-    ResultCode Finalize();
+    Result Initialize(KernelCore& kernel, KProcess* process);
+    Result Finalize();
 
     VAddr Reserve();
     void Release(VAddr addr);
diff --git a/src/core/hle/kernel/k_thread_queue.cpp b/src/core/hle/kernel/k_thread_queue.cpp
index 1c338904a..9f4e081ba 100644
--- a/src/core/hle/kernel/k_thread_queue.cpp
+++ b/src/core/hle/kernel/k_thread_queue.cpp
@@ -9,9 +9,9 @@ namespace Kernel {
 
 void KThreadQueue::NotifyAvailable([[maybe_unused]] KThread* waiting_thread,
                                    [[maybe_unused]] KSynchronizationObject* signaled_object,
-                                   [[maybe_unused]] ResultCode wait_result) {}
+                                   [[maybe_unused]] Result wait_result) {}
 
-void KThreadQueue::EndWait(KThread* waiting_thread, ResultCode wait_result) {
+void KThreadQueue::EndWait(KThread* waiting_thread, Result wait_result) {
     // Set the thread's wait result.
     waiting_thread->SetWaitResult(wait_result);
 
@@ -25,8 +25,7 @@ void KThreadQueue::EndWait(KThread* waiting_thread, ResultCode wait_result) {
     kernel.TimeManager().UnscheduleTimeEvent(waiting_thread);
 }
 
-void KThreadQueue::CancelWait(KThread* waiting_thread, ResultCode wait_result,
-                              bool cancel_timer_task) {
+void KThreadQueue::CancelWait(KThread* waiting_thread, Result wait_result, bool cancel_timer_task) {
     // Set the thread's wait result.
     waiting_thread->SetWaitResult(wait_result);
 
@@ -43,6 +42,6 @@ void KThreadQueue::CancelWait(KThread* waiting_thread, ResultCode wait_result,
 }
 
 void KThreadQueueWithoutEndWait::EndWait([[maybe_unused]] KThread* waiting_thread,
-                                         [[maybe_unused]] ResultCode wait_result) {}
+                                         [[maybe_unused]] Result wait_result) {}
 
 } // namespace Kernel
diff --git a/src/core/hle/kernel/k_thread_queue.h b/src/core/hle/kernel/k_thread_queue.h
index 4a7dbdd47..8d76ece81 100644
--- a/src/core/hle/kernel/k_thread_queue.h
+++ b/src/core/hle/kernel/k_thread_queue.h
@@ -14,10 +14,9 @@ public:
     virtual ~KThreadQueue() = default;
 
     virtual void NotifyAvailable(KThread* waiting_thread, KSynchronizationObject* signaled_object,
-                                 ResultCode wait_result);
-    virtual void EndWait(KThread* waiting_thread, ResultCode wait_result);
-    virtual void CancelWait(KThread* waiting_thread, ResultCode wait_result,
-                            bool cancel_timer_task);
+                                 Result wait_result);
+    virtual void EndWait(KThread* waiting_thread, Result wait_result);
+    virtual void CancelWait(KThread* waiting_thread, Result wait_result, bool cancel_timer_task);
 
 private:
     KernelCore& kernel;
@@ -28,7 +27,7 @@ class KThreadQueueWithoutEndWait : public KThreadQueue {
 public:
     explicit KThreadQueueWithoutEndWait(KernelCore& kernel_) : KThreadQueue(kernel_) {}
 
-    void EndWait(KThread* waiting_thread, ResultCode wait_result) override final;
+    void EndWait(KThread* waiting_thread, Result wait_result) override final;
 };
 
 } // namespace Kernel
diff --git a/src/core/hle/kernel/k_transfer_memory.cpp b/src/core/hle/kernel/k_transfer_memory.cpp
index 1ed4b0f6f..b0320eb73 100644
--- a/src/core/hle/kernel/k_transfer_memory.cpp
+++ b/src/core/hle/kernel/k_transfer_memory.cpp
@@ -13,8 +13,8 @@ KTransferMemory::KTransferMemory(KernelCore& kernel_)
 
 KTransferMemory::~KTransferMemory() = default;
 
-ResultCode KTransferMemory::Initialize(VAddr address_, std::size_t size_,
-                                       Svc::MemoryPermission owner_perm_) {
+Result KTransferMemory::Initialize(VAddr address_, std::size_t size_,
+                                   Svc::MemoryPermission owner_perm_) {
     // Set members.
     owner = kernel.CurrentProcess();
 
diff --git a/src/core/hle/kernel/k_transfer_memory.h b/src/core/hle/kernel/k_transfer_memory.h
index 9ad80ba30..85d508ee7 100644
--- a/src/core/hle/kernel/k_transfer_memory.h
+++ b/src/core/hle/kernel/k_transfer_memory.h
@@ -7,7 +7,7 @@
 #include "core/hle/kernel/svc_types.h"
 #include "core/hle/result.h"
 
-union ResultCode;
+union Result;
 
 namespace Core::Memory {
 class Memory;
@@ -26,7 +26,7 @@ public:
     explicit KTransferMemory(KernelCore& kernel_);
     ~KTransferMemory() override;
 
-    ResultCode Initialize(VAddr address_, std::size_t size_, Svc::MemoryPermission owner_perm_);
+    Result Initialize(VAddr address_, std::size_t size_, Svc::MemoryPermission owner_perm_);
 
     void Finalize() override;
 
diff --git a/src/core/hle/kernel/k_writable_event.cpp b/src/core/hle/kernel/k_writable_event.cpp
index 26c8489ad..ff88c5acd 100644
--- a/src/core/hle/kernel/k_writable_event.cpp
+++ b/src/core/hle/kernel/k_writable_event.cpp
@@ -18,11 +18,11 @@ void KWritableEvent::Initialize(KEvent* parent_event_, std::string&& name_) {
     parent->GetReadableEvent().Open();
 }
 
-ResultCode KWritableEvent::Signal() {
+Result KWritableEvent::Signal() {
     return parent->GetReadableEvent().Signal();
 }
 
-ResultCode KWritableEvent::Clear() {
+Result KWritableEvent::Clear() {
     return parent->GetReadableEvent().Clear();
 }
 
diff --git a/src/core/hle/kernel/k_writable_event.h b/src/core/hle/kernel/k_writable_event.h
index e289e80c4..3fd0c7d0a 100644
--- a/src/core/hle/kernel/k_writable_event.h
+++ b/src/core/hle/kernel/k_writable_event.h
@@ -25,8 +25,8 @@ public:
     static void PostDestroy([[maybe_unused]] uintptr_t arg) {}
 
     void Initialize(KEvent* parent_, std::string&& name_);
-    ResultCode Signal();
-    ResultCode Clear();
+    Result Signal();
+    Result Clear();
 
     KEvent* GetParent() const {
         return parent;
diff --git a/src/core/hle/kernel/process_capability.cpp b/src/core/hle/kernel/process_capability.cpp
index 54872626e..773319ad8 100644
--- a/src/core/hle/kernel/process_capability.cpp
+++ b/src/core/hle/kernel/process_capability.cpp
@@ -68,9 +68,9 @@ u32 GetFlagBitOffset(CapabilityType type) {
 
 } // Anonymous namespace
 
-ResultCode ProcessCapabilities::InitializeForKernelProcess(const u32* capabilities,
-                                                           std::size_t num_capabilities,
-                                                           KPageTable& page_table) {
+Result ProcessCapabilities::InitializeForKernelProcess(const u32* capabilities,
+                                                       std::size_t num_capabilities,
+                                                       KPageTable& page_table) {
     Clear();
 
     // Allow all cores and priorities.
@@ -81,9 +81,9 @@ ResultCode ProcessCapabilities::InitializeForKernelProcess(const u32* capabiliti
     return ParseCapabilities(capabilities, num_capabilities, page_table);
 }
 
-ResultCode ProcessCapabilities::InitializeForUserProcess(const u32* capabilities,
-                                                         std::size_t num_capabilities,
-                                                         KPageTable& page_table) {
+Result ProcessCapabilities::InitializeForUserProcess(const u32* capabilities,
+                                                     std::size_t num_capabilities,
+                                                     KPageTable& page_table) {
     Clear();
 
     return ParseCapabilities(capabilities, num_capabilities, page_table);
@@ -107,9 +107,8 @@ void ProcessCapabilities::InitializeForMetadatalessProcess() {
     can_force_debug = true;
 }
 
-ResultCode ProcessCapabilities::ParseCapabilities(const u32* capabilities,
-                                                  std::size_t num_capabilities,
-                                                  KPageTable& page_table) {
+Result ProcessCapabilities::ParseCapabilities(const u32* capabilities, std::size_t num_capabilities,
+                                              KPageTable& page_table) {
     u32 set_flags = 0;
     u32 set_svc_bits = 0;
 
@@ -155,8 +154,8 @@ ResultCode ProcessCapabilities::ParseCapabilities(const u32* capabilities,
     return ResultSuccess;
 }
 
-ResultCode ProcessCapabilities::ParseSingleFlagCapability(u32& set_flags, u32& set_svc_bits,
-                                                          u32 flag, KPageTable& page_table) {
+Result ProcessCapabilities::ParseSingleFlagCapability(u32& set_flags, u32& set_svc_bits, u32 flag,
+                                                      KPageTable& page_table) {
     const auto type = GetCapabilityType(flag);
 
     if (type == CapabilityType::Unset) {
@@ -224,7 +223,7 @@ void ProcessCapabilities::Clear() {
     can_force_debug = false;
 }
 
-ResultCode ProcessCapabilities::HandlePriorityCoreNumFlags(u32 flags) {
+Result ProcessCapabilities::HandlePriorityCoreNumFlags(u32 flags) {
     if (priority_mask != 0 || core_mask != 0) {
         LOG_ERROR(Kernel, "Core or priority mask are not zero! priority_mask={}, core_mask={}",
                   priority_mask, core_mask);
@@ -266,7 +265,7 @@ ResultCode ProcessCapabilities::HandlePriorityCoreNumFlags(u32 flags) {
     return ResultSuccess;
 }
 
-ResultCode ProcessCapabilities::HandleSyscallFlags(u32& set_svc_bits, u32 flags) {
+Result ProcessCapabilities::HandleSyscallFlags(u32& set_svc_bits, u32 flags) {
     const u32 index = flags >> 29;
     const u32 svc_bit = 1U << index;
 
@@ -290,23 +289,23 @@ ResultCode ProcessCapabilities::HandleSyscallFlags(u32& set_svc_bits, u32 flags)
     return ResultSuccess;
 }
 
-ResultCode ProcessCapabilities::HandleMapPhysicalFlags(u32 flags, u32 size_flags,
-                                                       KPageTable& page_table) {
+Result ProcessCapabilities::HandleMapPhysicalFlags(u32 flags, u32 size_flags,
+                                                   KPageTable& page_table) {
     // TODO(Lioncache): Implement once the memory manager can handle this.
     return ResultSuccess;
 }
 
-ResultCode ProcessCapabilities::HandleMapIOFlags(u32 flags, KPageTable& page_table) {
+Result ProcessCapabilities::HandleMapIOFlags(u32 flags, KPageTable& page_table) {
     // TODO(Lioncache): Implement once the memory manager can handle this.
     return ResultSuccess;
 }
 
-ResultCode ProcessCapabilities::HandleMapRegionFlags(u32 flags, KPageTable& page_table) {
+Result ProcessCapabilities::HandleMapRegionFlags(u32 flags, KPageTable& page_table) {
     // TODO(Lioncache): Implement once the memory manager can handle this.
     return ResultSuccess;
 }
 
-ResultCode ProcessCapabilities::HandleInterruptFlags(u32 flags) {
+Result ProcessCapabilities::HandleInterruptFlags(u32 flags) {
     constexpr u32 interrupt_ignore_value = 0x3FF;
     const u32 interrupt0 = (flags >> 12) & 0x3FF;
     const u32 interrupt1 = (flags >> 22) & 0x3FF;
@@ -333,7 +332,7 @@ ResultCode ProcessCapabilities::HandleInterruptFlags(u32 flags) {
     return ResultSuccess;
 }
 
-ResultCode ProcessCapabilities::HandleProgramTypeFlags(u32 flags) {
+Result ProcessCapabilities::HandleProgramTypeFlags(u32 flags) {
     const u32 reserved = flags >> 17;
     if (reserved != 0) {
         LOG_ERROR(Kernel, "Reserved value is non-zero! reserved={}", reserved);
@@ -344,7 +343,7 @@ ResultCode ProcessCapabilities::HandleProgramTypeFlags(u32 flags) {
     return ResultSuccess;
 }
 
-ResultCode ProcessCapabilities::HandleKernelVersionFlags(u32 flags) {
+Result ProcessCapabilities::HandleKernelVersionFlags(u32 flags) {
     // Yes, the internal member variable is checked in the actual kernel here.
     // This might look odd for options that are only allowed to be initialized
     // just once, however the kernel has a separate initialization function for
@@ -364,7 +363,7 @@ ResultCode ProcessCapabilities::HandleKernelVersionFlags(u32 flags) {
     return ResultSuccess;
 }
 
-ResultCode ProcessCapabilities::HandleHandleTableFlags(u32 flags) {
+Result ProcessCapabilities::HandleHandleTableFlags(u32 flags) {
     const u32 reserved = flags >> 26;
     if (reserved != 0) {
         LOG_ERROR(Kernel, "Reserved value is non-zero! reserved={}", reserved);
@@ -375,7 +374,7 @@ ResultCode ProcessCapabilities::HandleHandleTableFlags(u32 flags) {
     return ResultSuccess;
 }
 
-ResultCode ProcessCapabilities::HandleDebugFlags(u32 flags) {
+Result ProcessCapabilities::HandleDebugFlags(u32 flags) {
     const u32 reserved = flags >> 19;
     if (reserved != 0) {
         LOG_ERROR(Kernel, "Reserved value is non-zero! reserved={}", reserved);
diff --git a/src/core/hle/kernel/process_capability.h b/src/core/hle/kernel/process_capability.h
index 7f3a2339d..ff05dc5ff 100644
--- a/src/core/hle/kernel/process_capability.h
+++ b/src/core/hle/kernel/process_capability.h
@@ -7,7 +7,7 @@
 
 #include "common/common_types.h"
 
-union ResultCode;
+union Result;
 
 namespace Kernel {
 
@@ -86,8 +86,8 @@ public:
     /// @returns ResultSuccess if this capabilities instance was able to be initialized,
     ///          otherwise, an error code upon failure.
     ///
-    ResultCode InitializeForKernelProcess(const u32* capabilities, std::size_t num_capabilities,
-                                          KPageTable& page_table);
+    Result InitializeForKernelProcess(const u32* capabilities, std::size_t num_capabilities,
+                                      KPageTable& page_table);
 
     /// Initializes this process capabilities instance for a userland process.
     ///
@@ -99,8 +99,8 @@ public:
     /// @returns ResultSuccess if this capabilities instance was able to be initialized,
     ///          otherwise, an error code upon failure.
     ///
-    ResultCode InitializeForUserProcess(const u32* capabilities, std::size_t num_capabilities,
-                                        KPageTable& page_table);
+    Result InitializeForUserProcess(const u32* capabilities, std::size_t num_capabilities,
+                                    KPageTable& page_table);
 
     /// Initializes this process capabilities instance for a process that does not
     /// have any metadata to parse.
@@ -185,8 +185,8 @@ private:
     ///
     /// @return ResultSuccess if no errors occur, otherwise an error code.
     ///
-    ResultCode ParseCapabilities(const u32* capabilities, std::size_t num_capabilities,
-                                 KPageTable& page_table);
+    Result ParseCapabilities(const u32* capabilities, std::size_t num_capabilities,
+                             KPageTable& page_table);
 
     /// Attempts to parse a capability descriptor that is only represented by a
     /// single flag set.
@@ -200,8 +200,8 @@ private:
     ///
     /// @return ResultSuccess if no errors occurred, otherwise an error code.
     ///
-    ResultCode ParseSingleFlagCapability(u32& set_flags, u32& set_svc_bits, u32 flag,
-                                         KPageTable& page_table);
+    Result ParseSingleFlagCapability(u32& set_flags, u32& set_svc_bits, u32 flag,
+                                     KPageTable& page_table);
 
     /// Clears the internal state of this process capability instance. Necessary,
     /// to have a sane starting point due to us allowing running executables without
@@ -219,34 +219,34 @@ private:
     void Clear();
 
     /// Handles flags related to the priority and core number capability flags.
-    ResultCode HandlePriorityCoreNumFlags(u32 flags);
+    Result HandlePriorityCoreNumFlags(u32 flags);
 
     /// Handles flags related to determining the allowable SVC mask.
-    ResultCode HandleSyscallFlags(u32& set_svc_bits, u32 flags);
+    Result HandleSyscallFlags(u32& set_svc_bits, u32 flags);
 
     /// Handles flags related to mapping physical memory pages.
-    ResultCode HandleMapPhysicalFlags(u32 flags, u32 size_flags, KPageTable& page_table);
+    Result HandleMapPhysicalFlags(u32 flags, u32 size_flags, KPageTable& page_table);
 
     /// Handles flags related to mapping IO pages.
-    ResultCode HandleMapIOFlags(u32 flags, KPageTable& page_table);
+    Result HandleMapIOFlags(u32 flags, KPageTable& page_table);
 
     /// Handles flags related to mapping physical memory regions.
-    ResultCode HandleMapRegionFlags(u32 flags, KPageTable& page_table);
+    Result HandleMapRegionFlags(u32 flags, KPageTable& page_table);
 
     /// Handles flags related to the interrupt capability flags.
-    ResultCode HandleInterruptFlags(u32 flags);
+    Result HandleInterruptFlags(u32 flags);
 
     /// Handles flags related to the program type.
-    ResultCode HandleProgramTypeFlags(u32 flags);
+    Result HandleProgramTypeFlags(u32 flags);
 
     /// Handles flags related to the handle table size.
-    ResultCode HandleHandleTableFlags(u32 flags);
+    Result HandleHandleTableFlags(u32 flags);
 
     /// Handles flags related to the kernel version capability flags.
-    ResultCode HandleKernelVersionFlags(u32 flags);
+    Result HandleKernelVersionFlags(u32 flags);
 
     /// Handles flags related to debug-specific capabilities.
-    ResultCode HandleDebugFlags(u32 flags);
+    Result HandleDebugFlags(u32 flags);
 
     SyscallCapabilities svc_capabilities;
     InterruptCapabilities interrupt_capabilities;
diff --git a/src/core/hle/kernel/svc.cpp b/src/core/hle/kernel/svc.cpp
index 71ed17790..8655506b0 100644
--- a/src/core/hle/kernel/svc.cpp
+++ b/src/core/hle/kernel/svc.cpp
@@ -58,8 +58,8 @@ constexpr bool IsValidAddressRange(VAddr address, u64 size) {
 // Helper function that performs the common sanity checks for svcMapMemory
 // and svcUnmapMemory. This is doable, as both functions perform their sanitizing
 // in the same order.
-ResultCode MapUnmapMemorySanityChecks(const KPageTable& manager, VAddr dst_addr, VAddr src_addr,
-                                      u64 size) {
+Result MapUnmapMemorySanityChecks(const KPageTable& manager, VAddr dst_addr, VAddr src_addr,
+                                  u64 size) {
     if (!Common::Is4KBAligned(dst_addr)) {
         LOG_ERROR(Kernel_SVC, "Destination address is not aligned to 4KB, 0x{:016X}", dst_addr);
         return ResultInvalidAddress;
@@ -135,7 +135,7 @@ enum class ResourceLimitValueType {
 } // Anonymous namespace
 
 /// Set the process heap to a given Size. It can both extend and shrink the heap.
-static ResultCode SetHeapSize(Core::System& system, VAddr* out_address, u64 size) {
+static Result SetHeapSize(Core::System& system, VAddr* out_address, u64 size) {
     LOG_TRACE(Kernel_SVC, "called, heap_size=0x{:X}", size);
 
     // Validate size.
@@ -148,9 +148,9 @@ static ResultCode SetHeapSize(Core::System& system, VAddr* out_address, u64 size
     return ResultSuccess;
 }
 
-static ResultCode SetHeapSize32(Core::System& system, u32* heap_addr, u32 heap_size) {
+static Result SetHeapSize32(Core::System& system, u32* heap_addr, u32 heap_size) {
     VAddr temp_heap_addr{};
-    const ResultCode result{SetHeapSize(system, &temp_heap_addr, heap_size)};
+    const Result result{SetHeapSize(system, &temp_heap_addr, heap_size)};
     *heap_addr = static_cast<u32>(temp_heap_addr);
     return result;
 }
@@ -166,8 +166,8 @@ constexpr bool IsValidSetMemoryPermission(MemoryPermission perm) {
     }
 }
 
-static ResultCode SetMemoryPermission(Core::System& system, VAddr address, u64 size,
-                                      MemoryPermission perm) {
+static Result SetMemoryPermission(Core::System& system, VAddr address, u64 size,
+                                  MemoryPermission perm) {
     LOG_DEBUG(Kernel_SVC, "called, address=0x{:016X}, size=0x{:X}, perm=0x{:08X", address, size,
               perm);
 
@@ -188,8 +188,8 @@ static ResultCode SetMemoryPermission(Core::System& system, VAddr address, u64 s
     return page_table.SetMemoryPermission(address, size, perm);
 }
 
-static ResultCode SetMemoryAttribute(Core::System& system, VAddr address, u64 size, u32 mask,
-                                     u32 attr) {
+static Result SetMemoryAttribute(Core::System& system, VAddr address, u64 size, u32 mask,
+                                 u32 attr) {
     LOG_DEBUG(Kernel_SVC,
               "called, address=0x{:016X}, size=0x{:X}, mask=0x{:08X}, attribute=0x{:08X}", address,
               size, mask, attr);
@@ -213,19 +213,19 @@ static ResultCode SetMemoryAttribute(Core::System& system, VAddr address, u64 si
     return page_table.SetMemoryAttribute(address, size, mask, attr);
 }
 
-static ResultCode SetMemoryAttribute32(Core::System& system, u32 address, u32 size, u32 mask,
-                                       u32 attr) {
+static Result SetMemoryAttribute32(Core::System& system, u32 address, u32 size, u32 mask,
+                                   u32 attr) {
     return SetMemoryAttribute(system, address, size, mask, attr);
 }
 
 /// Maps a memory range into a different range.
-static ResultCode MapMemory(Core::System& system, VAddr dst_addr, VAddr src_addr, u64 size) {
+static Result MapMemory(Core::System& system, VAddr dst_addr, VAddr src_addr, u64 size) {
     LOG_TRACE(Kernel_SVC, "called, dst_addr=0x{:X}, src_addr=0x{:X}, size=0x{:X}", dst_addr,
               src_addr, size);
 
     auto& page_table{system.Kernel().CurrentProcess()->PageTable()};
 
-    if (const ResultCode result{MapUnmapMemorySanityChecks(page_table, dst_addr, src_addr, size)};
+    if (const Result result{MapUnmapMemorySanityChecks(page_table, dst_addr, src_addr, size)};
         result.IsError()) {
         return result;
     }
@@ -233,18 +233,18 @@ static ResultCode MapMemory(Core::System& system, VAddr dst_addr, VAddr src_addr
     return page_table.MapMemory(dst_addr, src_addr, size);
 }
 
-static ResultCode MapMemory32(Core::System& system, u32 dst_addr, u32 src_addr, u32 size) {
+static Result MapMemory32(Core::System& system, u32 dst_addr, u32 src_addr, u32 size) {
     return MapMemory(system, dst_addr, src_addr, size);
 }
 
 /// Unmaps a region that was previously mapped with svcMapMemory
-static ResultCode UnmapMemory(Core::System& system, VAddr dst_addr, VAddr src_addr, u64 size) {
+static Result UnmapMemory(Core::System& system, VAddr dst_addr, VAddr src_addr, u64 size) {
     LOG_TRACE(Kernel_SVC, "called, dst_addr=0x{:X}, src_addr=0x{:X}, size=0x{:X}", dst_addr,
               src_addr, size);
 
     auto& page_table{system.Kernel().CurrentProcess()->PageTable()};
 
-    if (const ResultCode result{MapUnmapMemorySanityChecks(page_table, dst_addr, src_addr, size)};
+    if (const Result result{MapUnmapMemorySanityChecks(page_table, dst_addr, src_addr, size)};
         result.IsError()) {
         return result;
     }
@@ -252,12 +252,12 @@ static ResultCode UnmapMemory(Core::System& system, VAddr dst_addr, VAddr src_ad
     return page_table.UnmapMemory(dst_addr, src_addr, size);
 }
 
-static ResultCode UnmapMemory32(Core::System& system, u32 dst_addr, u32 src_addr, u32 size) {
+static Result UnmapMemory32(Core::System& system, u32 dst_addr, u32 src_addr, u32 size) {
     return UnmapMemory(system, dst_addr, src_addr, size);
 }
 
 /// Connect to an OS service given the port name, returns the handle to the port to out
-static ResultCode ConnectToNamedPort(Core::System& system, Handle* out, VAddr port_name_address) {
+static Result ConnectToNamedPort(Core::System& system, Handle* out, VAddr port_name_address) {
     auto& memory = system.Memory();
     if (!memory.IsValidVirtualAddress(port_name_address)) {
         LOG_ERROR(Kernel_SVC,
@@ -307,14 +307,14 @@ static ResultCode ConnectToNamedPort(Core::System& system, Handle* out, VAddr po
     return ResultSuccess;
 }
 
-static ResultCode ConnectToNamedPort32(Core::System& system, Handle* out_handle,
-                                       u32 port_name_address) {
+static Result ConnectToNamedPort32(Core::System& system, Handle* out_handle,
+                                   u32 port_name_address) {
 
     return ConnectToNamedPort(system, out_handle, port_name_address);
 }
 
 /// Makes a blocking IPC call to an OS service.
-static ResultCode SendSyncRequest(Core::System& system, Handle handle) {
+static Result SendSyncRequest(Core::System& system, Handle handle) {
     auto& kernel = system.Kernel();
 
     // Create the wait queue.
@@ -339,12 +339,12 @@ static ResultCode SendSyncRequest(Core::System& system, Handle handle) {
     return GetCurrentThread(kernel).GetWaitResult();
 }
 
-static ResultCode SendSyncRequest32(Core::System& system, Handle handle) {
+static Result SendSyncRequest32(Core::System& system, Handle handle) {
     return SendSyncRequest(system, handle);
 }
 
 /// Get the ID for the specified thread.
-static ResultCode GetThreadId(Core::System& system, u64* out_thread_id, Handle thread_handle) {
+static Result GetThreadId(Core::System& system, u64* out_thread_id, Handle thread_handle) {
     // Get the thread from its handle.
     KScopedAutoObject thread =
         system.Kernel().CurrentProcess()->GetHandleTable().GetObject<KThread>(thread_handle);
@@ -355,10 +355,10 @@ static ResultCode GetThreadId(Core::System& system, u64* out_thread_id, Handle t
     return ResultSuccess;
 }
 
-static ResultCode GetThreadId32(Core::System& system, u32* out_thread_id_low,
-                                u32* out_thread_id_high, Handle thread_handle) {
+static Result GetThreadId32(Core::System& system, u32* out_thread_id_low, u32* out_thread_id_high,
+                            Handle thread_handle) {
     u64 out_thread_id{};
-    const ResultCode result{GetThreadId(system, &out_thread_id, thread_handle)};
+    const Result result{GetThreadId(system, &out_thread_id, thread_handle)};
 
     *out_thread_id_low = static_cast<u32>(out_thread_id >> 32);
     *out_thread_id_high = static_cast<u32>(out_thread_id & std::numeric_limits<u32>::max());
@@ -367,7 +367,7 @@ static ResultCode GetThreadId32(Core::System& system, u32* out_thread_id_low,
 }
 
 /// Gets the ID of the specified process or a specified thread's owning process.
-static ResultCode GetProcessId(Core::System& system, u64* out_process_id, Handle handle) {
+static Result GetProcessId(Core::System& system, u64* out_process_id, Handle handle) {
     LOG_DEBUG(Kernel_SVC, "called handle=0x{:08X}", handle);
 
     // Get the object from the handle table.
@@ -398,8 +398,8 @@ static ResultCode GetProcessId(Core::System& system, u64* out_process_id, Handle
     return ResultSuccess;
 }
 
-static ResultCode GetProcessId32(Core::System& system, u32* out_process_id_low,
-                                 u32* out_process_id_high, Handle handle) {
+static Result GetProcessId32(Core::System& system, u32* out_process_id_low,
+                             u32* out_process_id_high, Handle handle) {
     u64 out_process_id{};
     const auto result = GetProcessId(system, &out_process_id, handle);
     *out_process_id_low = static_cast<u32>(out_process_id);
@@ -408,8 +408,8 @@ static ResultCode GetProcessId32(Core::System& system, u32* out_process_id_low,
 }
 
 /// Wait for the given handles to synchronize, timeout after the specified nanoseconds
-static ResultCode WaitSynchronization(Core::System& system, s32* index, VAddr handles_address,
-                                      s32 num_handles, s64 nano_seconds) {
+static Result WaitSynchronization(Core::System& system, s32* index, VAddr handles_address,
+                                  s32 num_handles, s64 nano_seconds) {
     LOG_TRACE(Kernel_SVC, "called handles_address=0x{:X}, num_handles={}, nano_seconds={}",
               handles_address, num_handles, nano_seconds);
 
@@ -444,14 +444,14 @@ static ResultCode WaitSynchronization(Core::System& system, s32* index, VAddr ha
                                         nano_seconds);
 }
 
-static ResultCode WaitSynchronization32(Core::System& system, u32 timeout_low, u32 handles_address,
-                                        s32 num_handles, u32 timeout_high, s32* index) {
+static Result WaitSynchronization32(Core::System& system, u32 timeout_low, u32 handles_address,
+                                    s32 num_handles, u32 timeout_high, s32* index) {
     const s64 nano_seconds{(static_cast<s64>(timeout_high) << 32) | static_cast<s64>(timeout_low)};
     return WaitSynchronization(system, index, handles_address, num_handles, nano_seconds);
 }
 
 /// Resumes a thread waiting on WaitSynchronization
-static ResultCode CancelSynchronization(Core::System& system, Handle handle) {
+static Result CancelSynchronization(Core::System& system, Handle handle) {
     LOG_TRACE(Kernel_SVC, "called handle=0x{:X}", handle);
 
     // Get the thread from its handle.
@@ -464,13 +464,12 @@ static ResultCode CancelSynchronization(Core::System& system, Handle handle) {
     return ResultSuccess;
 }
 
-static ResultCode CancelSynchronization32(Core::System& system, Handle handle) {
+static Result CancelSynchronization32(Core::System& system, Handle handle) {
     return CancelSynchronization(system, handle);
 }
 
 /// Attempts to locks a mutex
-static ResultCode ArbitrateLock(Core::System& system, Handle thread_handle, VAddr address,
-                                u32 tag) {
+static Result ArbitrateLock(Core::System& system, Handle thread_handle, VAddr address, u32 tag) {
     LOG_TRACE(Kernel_SVC, "called thread_handle=0x{:08X}, address=0x{:X}, tag=0x{:08X}",
               thread_handle, address, tag);
 
@@ -488,13 +487,12 @@ static ResultCode ArbitrateLock(Core::System& system, Handle thread_handle, VAdd
     return system.Kernel().CurrentProcess()->WaitForAddress(thread_handle, address, tag);
 }
 
-static ResultCode ArbitrateLock32(Core::System& system, Handle thread_handle, u32 address,
-                                  u32 tag) {
+static Result ArbitrateLock32(Core::System& system, Handle thread_handle, u32 address, u32 tag) {
     return ArbitrateLock(system, thread_handle, address, tag);
 }
 
 /// Unlock a mutex
-static ResultCode ArbitrateUnlock(Core::System& system, VAddr address) {
+static Result ArbitrateUnlock(Core::System& system, VAddr address) {
     LOG_TRACE(Kernel_SVC, "called address=0x{:X}", address);
 
     // Validate the input address.
@@ -512,7 +510,7 @@ static ResultCode ArbitrateUnlock(Core::System& system, VAddr address) {
     return system.Kernel().CurrentProcess()->SignalToAddress(address);
 }
 
-static ResultCode ArbitrateUnlock32(Core::System& system, u32 address) {
+static Result ArbitrateUnlock32(Core::System& system, u32 address) {
     return ArbitrateUnlock(system, address);
 }
 
@@ -655,8 +653,8 @@ static void OutputDebugString32(Core::System& system, u32 address, u32 len) {
 }
 
 /// Gets system/memory information for the current process
-static ResultCode GetInfo(Core::System& system, u64* result, u64 info_id, Handle handle,
-                          u64 info_sub_id) {
+static Result GetInfo(Core::System& system, u64* result, u64 info_id, Handle handle,
+                      u64 info_sub_id) {
     LOG_TRACE(Kernel_SVC, "called info_id=0x{:X}, info_sub_id=0x{:X}, handle=0x{:08X}", info_id,
               info_sub_id, handle);
 
@@ -943,12 +941,12 @@ static ResultCode GetInfo(Core::System& system, u64* result, u64 info_id, Handle
     }
 }
 
-static ResultCode GetInfo32(Core::System& system, u32* result_low, u32* result_high, u32 sub_id_low,
-                            u32 info_id, u32 handle, u32 sub_id_high) {
+static Result GetInfo32(Core::System& system, u32* result_low, u32* result_high, u32 sub_id_low,
+                        u32 info_id, u32 handle, u32 sub_id_high) {
     const u64 sub_id{u64{sub_id_low} | (u64{sub_id_high} << 32)};
     u64 res_value{};
 
-    const ResultCode result{GetInfo(system, &res_value, info_id, handle, sub_id)};
+    const Result result{GetInfo(system, &res_value, info_id, handle, sub_id)};
     *result_high = static_cast<u32>(res_value >> 32);
     *result_low = static_cast<u32>(res_value & std::numeric_limits<u32>::max());
 
@@ -956,7 +954,7 @@ static ResultCode GetInfo32(Core::System& system, u32* result_low, u32* result_h
 }
 
 /// Maps memory at a desired address
-static ResultCode MapPhysicalMemory(Core::System& system, VAddr addr, u64 size) {
+static Result MapPhysicalMemory(Core::System& system, VAddr addr, u64 size) {
     LOG_DEBUG(Kernel_SVC, "called, addr=0x{:016X}, size=0x{:X}", addr, size);
 
     if (!Common::Is4KBAligned(addr)) {
@@ -1004,12 +1002,12 @@ static ResultCode MapPhysicalMemory(Core::System& system, VAddr addr, u64 size)
     return page_table.MapPhysicalMemory(addr, size);
 }
 
-static ResultCode MapPhysicalMemory32(Core::System& system, u32 addr, u32 size) {
+static Result MapPhysicalMemory32(Core::System& system, u32 addr, u32 size) {
     return MapPhysicalMemory(system, addr, size);
 }
 
 /// Unmaps memory previously mapped via MapPhysicalMemory
-static ResultCode UnmapPhysicalMemory(Core::System& system, VAddr addr, u64 size) {
+static Result UnmapPhysicalMemory(Core::System& system, VAddr addr, u64 size) {
     LOG_DEBUG(Kernel_SVC, "called, addr=0x{:016X}, size=0x{:X}", addr, size);
 
     if (!Common::Is4KBAligned(addr)) {
@@ -1057,13 +1055,13 @@ static ResultCode UnmapPhysicalMemory(Core::System& system, VAddr addr, u64 size
     return page_table.UnmapPhysicalMemory(addr, size);
 }
 
-static ResultCode UnmapPhysicalMemory32(Core::System& system, u32 addr, u32 size) {
+static Result UnmapPhysicalMemory32(Core::System& system, u32 addr, u32 size) {
     return UnmapPhysicalMemory(system, addr, size);
 }
 
 /// Sets the thread activity
-static ResultCode SetThreadActivity(Core::System& system, Handle thread_handle,
-                                    ThreadActivity thread_activity) {
+static Result SetThreadActivity(Core::System& system, Handle thread_handle,
+                                ThreadActivity thread_activity) {
     LOG_DEBUG(Kernel_SVC, "called, handle=0x{:08X}, activity=0x{:08X}", thread_handle,
               thread_activity);
 
@@ -1088,13 +1086,13 @@ static ResultCode SetThreadActivity(Core::System& system, Handle thread_handle,
     return ResultSuccess;
 }
 
-static ResultCode SetThreadActivity32(Core::System& system, Handle thread_handle,
-                                      Svc::ThreadActivity thread_activity) {
+static Result SetThreadActivity32(Core::System& system, Handle thread_handle,
+                                  Svc::ThreadActivity thread_activity) {
     return SetThreadActivity(system, thread_handle, thread_activity);
 }
 
 /// Gets the thread context
-static ResultCode GetThreadContext(Core::System& system, VAddr out_context, Handle thread_handle) {
+static Result GetThreadContext(Core::System& system, VAddr out_context, Handle thread_handle) {
     LOG_DEBUG(Kernel_SVC, "called, out_context=0x{:08X}, thread_handle=0x{:X}", out_context,
               thread_handle);
 
@@ -1151,12 +1149,12 @@ static ResultCode GetThreadContext(Core::System& system, VAddr out_context, Hand
     return ResultSuccess;
 }
 
-static ResultCode GetThreadContext32(Core::System& system, u32 out_context, Handle thread_handle) {
+static Result GetThreadContext32(Core::System& system, u32 out_context, Handle thread_handle) {
     return GetThreadContext(system, out_context, thread_handle);
 }
 
 /// Gets the priority for the specified thread
-static ResultCode GetThreadPriority(Core::System& system, u32* out_priority, Handle handle) {
+static Result GetThreadPriority(Core::System& system, u32* out_priority, Handle handle) {
     LOG_TRACE(Kernel_SVC, "called");
 
     // Get the thread from its handle.
@@ -1169,12 +1167,12 @@ static ResultCode GetThreadPriority(Core::System& system, u32* out_priority, Han
     return ResultSuccess;
 }
 
-static ResultCode GetThreadPriority32(Core::System& system, u32* out_priority, Handle handle) {
+static Result GetThreadPriority32(Core::System& system, u32* out_priority, Handle handle) {
     return GetThreadPriority(system, out_priority, handle);
 }
 
 /// Sets the priority for the specified thread
-static ResultCode SetThreadPriority(Core::System& system, Handle thread_handle, u32 priority) {
+static Result SetThreadPriority(Core::System& system, Handle thread_handle, u32 priority) {
     // Get the current process.
     KProcess& process = *system.Kernel().CurrentProcess();
 
@@ -1192,7 +1190,7 @@ static ResultCode SetThreadPriority(Core::System& system, Handle thread_handle,
     return ResultSuccess;
 }
 
-static ResultCode SetThreadPriority32(Core::System& system, Handle thread_handle, u32 priority) {
+static Result SetThreadPriority32(Core::System& system, Handle thread_handle, u32 priority) {
     return SetThreadPriority(system, thread_handle, priority);
 }
 
@@ -1252,8 +1250,8 @@ constexpr bool IsValidUnmapFromOwnerCodeMemoryPermission(Svc::MemoryPermission p
 
 } // Anonymous namespace
 
-static ResultCode MapSharedMemory(Core::System& system, Handle shmem_handle, VAddr address,
-                                  u64 size, Svc::MemoryPermission map_perm) {
+static Result MapSharedMemory(Core::System& system, Handle shmem_handle, VAddr address, u64 size,
+                              Svc::MemoryPermission map_perm) {
     LOG_TRACE(Kernel_SVC,
               "called, shared_memory_handle=0x{:X}, addr=0x{:X}, size=0x{:X}, permissions=0x{:08X}",
               shmem_handle, address, size, map_perm);
@@ -1293,13 +1291,13 @@ static ResultCode MapSharedMemory(Core::System& system, Handle shmem_handle, VAd
     return ResultSuccess;
 }
 
-static ResultCode MapSharedMemory32(Core::System& system, Handle shmem_handle, u32 address,
-                                    u32 size, Svc::MemoryPermission map_perm) {
+static Result MapSharedMemory32(Core::System& system, Handle shmem_handle, u32 address, u32 size,
+                                Svc::MemoryPermission map_perm) {
     return MapSharedMemory(system, shmem_handle, address, size, map_perm);
 }
 
-static ResultCode UnmapSharedMemory(Core::System& system, Handle shmem_handle, VAddr address,
-                                    u64 size) {
+static Result UnmapSharedMemory(Core::System& system, Handle shmem_handle, VAddr address,
+                                u64 size) {
     // Validate the address/size.
     R_UNLESS(Common::IsAligned(address, PageSize), ResultInvalidAddress);
     R_UNLESS(Common::IsAligned(size, PageSize), ResultInvalidSize);
@@ -1326,13 +1324,13 @@ static ResultCode UnmapSharedMemory(Core::System& system, Handle shmem_handle, V
     return ResultSuccess;
 }
 
-static ResultCode UnmapSharedMemory32(Core::System& system, Handle shmem_handle, u32 address,
-                                      u32 size) {
+static Result UnmapSharedMemory32(Core::System& system, Handle shmem_handle, u32 address,
+                                  u32 size) {
     return UnmapSharedMemory(system, shmem_handle, address, size);
 }
 
-static ResultCode SetProcessMemoryPermission(Core::System& system, Handle process_handle,
-                                             VAddr address, u64 size, Svc::MemoryPermission perm) {
+static Result SetProcessMemoryPermission(Core::System& system, Handle process_handle, VAddr address,
+                                         u64 size, Svc::MemoryPermission perm) {
     LOG_TRACE(Kernel_SVC,
               "called, process_handle=0x{:X}, addr=0x{:X}, size=0x{:X}, permissions=0x{:08X}",
               process_handle, address, size, perm);
@@ -1361,8 +1359,8 @@ static ResultCode SetProcessMemoryPermission(Core::System& system, Handle proces
     return page_table.SetProcessMemoryPermission(address, size, perm);
 }
 
-static ResultCode MapProcessMemory(Core::System& system, VAddr dst_address, Handle process_handle,
-                                   VAddr src_address, u64 size) {
+static Result MapProcessMemory(Core::System& system, VAddr dst_address, Handle process_handle,
+                               VAddr src_address, u64 size) {
     LOG_TRACE(Kernel_SVC,
               "called, dst_address=0x{:X}, process_handle=0x{:X}, src_address=0x{:X}, size=0x{:X}",
               dst_address, process_handle, src_address, size);
@@ -1391,7 +1389,7 @@ static ResultCode MapProcessMemory(Core::System& system, VAddr dst_address, Hand
              ResultInvalidMemoryRegion);
 
     // Create a new page group.
-    KPageLinkedList pg;
+    KPageGroup pg;
     R_TRY(src_pt.MakeAndOpenPageGroup(
         std::addressof(pg), src_address, size / PageSize, KMemoryState::FlagCanMapProcess,
         KMemoryState::FlagCanMapProcess, KMemoryPermission::None, KMemoryPermission::None,
@@ -1404,8 +1402,8 @@ static ResultCode MapProcessMemory(Core::System& system, VAddr dst_address, Hand
     return ResultSuccess;
 }
 
-static ResultCode UnmapProcessMemory(Core::System& system, VAddr dst_address, Handle process_handle,
-                                     VAddr src_address, u64 size) {
+static Result UnmapProcessMemory(Core::System& system, VAddr dst_address, Handle process_handle,
+                                 VAddr src_address, u64 size) {
     LOG_TRACE(Kernel_SVC,
               "called, dst_address=0x{:X}, process_handle=0x{:X}, src_address=0x{:X}, size=0x{:X}",
               dst_address, process_handle, src_address, size);
@@ -1439,7 +1437,7 @@ static ResultCode UnmapProcessMemory(Core::System& system, VAddr dst_address, Ha
     return ResultSuccess;
 }
 
-static ResultCode CreateCodeMemory(Core::System& system, Handle* out, VAddr address, size_t size) {
+static Result CreateCodeMemory(Core::System& system, Handle* out, VAddr address, size_t size) {
     LOG_TRACE(Kernel_SVC, "called, address=0x{:X}, size=0x{:X}", address, size);
 
     // Get kernel instance.
@@ -1474,12 +1472,12 @@ static ResultCode CreateCodeMemory(Core::System& system, Handle* out, VAddr addr
     return ResultSuccess;
 }
 
-static ResultCode CreateCodeMemory32(Core::System& system, Handle* out, u32 address, u32 size) {
+static Result CreateCodeMemory32(Core::System& system, Handle* out, u32 address, u32 size) {
     return CreateCodeMemory(system, out, address, size);
 }
 
-static ResultCode ControlCodeMemory(Core::System& system, Handle code_memory_handle, u32 operation,
-                                    VAddr address, size_t size, Svc::MemoryPermission perm) {
+static Result ControlCodeMemory(Core::System& system, Handle code_memory_handle, u32 operation,
+                                VAddr address, size_t size, Svc::MemoryPermission perm) {
 
     LOG_TRACE(Kernel_SVC,
               "called, code_memory_handle=0x{:X}, operation=0x{:X}, address=0x{:X}, size=0x{:X}, "
@@ -1557,15 +1555,13 @@ static ResultCode ControlCodeMemory(Core::System& system, Handle code_memory_han
     return ResultSuccess;
 }
 
-static ResultCode ControlCodeMemory32(Core::System& system, Handle code_memory_handle,
-                                      u32 operation, u64 address, u64 size,
-                                      Svc::MemoryPermission perm) {
+static Result ControlCodeMemory32(Core::System& system, Handle code_memory_handle, u32 operation,
+                                  u64 address, u64 size, Svc::MemoryPermission perm) {
     return ControlCodeMemory(system, code_memory_handle, operation, address, size, perm);
 }
 
-static ResultCode QueryProcessMemory(Core::System& system, VAddr memory_info_address,
-                                     VAddr page_info_address, Handle process_handle,
-                                     VAddr address) {
+static Result QueryProcessMemory(Core::System& system, VAddr memory_info_address,
+                                 VAddr page_info_address, Handle process_handle, VAddr address) {
     LOG_TRACE(Kernel_SVC, "called process=0x{:08X} address={:X}", process_handle, address);
     const auto& handle_table = system.Kernel().CurrentProcess()->GetHandleTable();
     KScopedAutoObject process = handle_table.GetObject<KProcess>(process_handle);
@@ -1593,8 +1589,8 @@ static ResultCode QueryProcessMemory(Core::System& system, VAddr memory_info_add
     return ResultSuccess;
 }
 
-static ResultCode QueryMemory(Core::System& system, VAddr memory_info_address,
-                              VAddr page_info_address, VAddr query_address) {
+static Result QueryMemory(Core::System& system, VAddr memory_info_address, VAddr page_info_address,
+                          VAddr query_address) {
     LOG_TRACE(Kernel_SVC,
               "called, memory_info_address=0x{:016X}, page_info_address=0x{:016X}, "
               "query_address=0x{:016X}",
@@ -1604,13 +1600,13 @@ static ResultCode QueryMemory(Core::System& system, VAddr memory_info_address,
                               query_address);
 }
 
-static ResultCode QueryMemory32(Core::System& system, u32 memory_info_address,
-                                u32 page_info_address, u32 query_address) {
+static Result QueryMemory32(Core::System& system, u32 memory_info_address, u32 page_info_address,
+                            u32 query_address) {
     return QueryMemory(system, memory_info_address, page_info_address, query_address);
 }
 
-static ResultCode MapProcessCodeMemory(Core::System& system, Handle process_handle, u64 dst_address,
-                                       u64 src_address, u64 size) {
+static Result MapProcessCodeMemory(Core::System& system, Handle process_handle, u64 dst_address,
+                                   u64 src_address, u64 size) {
     LOG_DEBUG(Kernel_SVC,
               "called. process_handle=0x{:08X}, dst_address=0x{:016X}, "
               "src_address=0x{:016X}, size=0x{:016X}",
@@ -1677,8 +1673,8 @@ static ResultCode MapProcessCodeMemory(Core::System& system, Handle process_hand
     return page_table.MapCodeMemory(dst_address, src_address, size);
 }
 
-static ResultCode UnmapProcessCodeMemory(Core::System& system, Handle process_handle,
-                                         u64 dst_address, u64 src_address, u64 size) {
+static Result UnmapProcessCodeMemory(Core::System& system, Handle process_handle, u64 dst_address,
+                                     u64 src_address, u64 size) {
     LOG_DEBUG(Kernel_SVC,
               "called. process_handle=0x{:08X}, dst_address=0x{:016X}, src_address=0x{:016X}, "
               "size=0x{:016X}",
@@ -1770,8 +1766,8 @@ constexpr bool IsValidVirtualCoreId(int32_t core_id) {
 } // Anonymous namespace
 
 /// Creates a new thread
-static ResultCode CreateThread(Core::System& system, Handle* out_handle, VAddr entry_point, u64 arg,
-                               VAddr stack_bottom, u32 priority, s32 core_id) {
+static Result CreateThread(Core::System& system, Handle* out_handle, VAddr entry_point, u64 arg,
+                           VAddr stack_bottom, u32 priority, s32 core_id) {
     LOG_DEBUG(Kernel_SVC,
               "called entry_point=0x{:08X}, arg=0x{:08X}, stack_bottom=0x{:08X}, "
               "priority=0x{:08X}, core_id=0x{:08X}",
@@ -1842,13 +1838,13 @@ static ResultCode CreateThread(Core::System& system, Handle* out_handle, VAddr e
     return ResultSuccess;
 }
 
-static ResultCode CreateThread32(Core::System& system, Handle* out_handle, u32 priority,
-                                 u32 entry_point, u32 arg, u32 stack_top, s32 processor_id) {
+static Result CreateThread32(Core::System& system, Handle* out_handle, u32 priority,
+                             u32 entry_point, u32 arg, u32 stack_top, s32 processor_id) {
     return CreateThread(system, out_handle, entry_point, arg, stack_top, priority, processor_id);
 }
 
 /// Starts the thread for the provided handle
-static ResultCode StartThread(Core::System& system, Handle thread_handle) {
+static Result StartThread(Core::System& system, Handle thread_handle) {
     LOG_DEBUG(Kernel_SVC, "called thread=0x{:08X}", thread_handle);
 
     // Get the thread from its handle.
@@ -1866,7 +1862,7 @@ static ResultCode StartThread(Core::System& system, Handle thread_handle) {
     return ResultSuccess;
 }
 
-static ResultCode StartThread32(Core::System& system, Handle thread_handle) {
+static Result StartThread32(Core::System& system, Handle thread_handle) {
     return StartThread(system, thread_handle);
 }
 
@@ -1917,8 +1913,8 @@ static void SleepThread32(Core::System& system, u32 nanoseconds_low, u32 nanosec
 }
 
 /// Wait process wide key atomic
-static ResultCode WaitProcessWideKeyAtomic(Core::System& system, VAddr address, VAddr cv_key,
-                                           u32 tag, s64 timeout_ns) {
+static Result WaitProcessWideKeyAtomic(Core::System& system, VAddr address, VAddr cv_key, u32 tag,
+                                       s64 timeout_ns) {
     LOG_TRACE(Kernel_SVC, "called address={:X}, cv_key={:X}, tag=0x{:08X}, timeout_ns={}", address,
               cv_key, tag, timeout_ns);
 
@@ -1953,8 +1949,8 @@ static ResultCode WaitProcessWideKeyAtomic(Core::System& system, VAddr address,
         address, Common::AlignDown(cv_key, sizeof(u32)), tag, timeout);
 }
 
-static ResultCode WaitProcessWideKeyAtomic32(Core::System& system, u32 address, u32 cv_key, u32 tag,
-                                             u32 timeout_ns_low, u32 timeout_ns_high) {
+static Result WaitProcessWideKeyAtomic32(Core::System& system, u32 address, u32 cv_key, u32 tag,
+                                         u32 timeout_ns_low, u32 timeout_ns_high) {
     const auto timeout_ns = static_cast<s64>(timeout_ns_low | (u64{timeout_ns_high} << 32));
     return WaitProcessWideKeyAtomic(system, address, cv_key, tag, timeout_ns);
 }
@@ -1999,8 +1995,8 @@ constexpr bool IsValidArbitrationType(Svc::ArbitrationType type) {
 } // namespace
 
 // Wait for an address (via Address Arbiter)
-static ResultCode WaitForAddress(Core::System& system, VAddr address, Svc::ArbitrationType arb_type,
-                                 s32 value, s64 timeout_ns) {
+static Result WaitForAddress(Core::System& system, VAddr address, Svc::ArbitrationType arb_type,
+                             s32 value, s64 timeout_ns) {
     LOG_TRACE(Kernel_SVC, "called, address=0x{:X}, arb_type=0x{:X}, value=0x{:X}, timeout_ns={}",
               address, arb_type, value, timeout_ns);
 
@@ -2037,15 +2033,15 @@ static ResultCode WaitForAddress(Core::System& system, VAddr address, Svc::Arbit
     return system.Kernel().CurrentProcess()->WaitAddressArbiter(address, arb_type, value, timeout);
 }
 
-static ResultCode WaitForAddress32(Core::System& system, u32 address, Svc::ArbitrationType arb_type,
-                                   s32 value, u32 timeout_ns_low, u32 timeout_ns_high) {
+static Result WaitForAddress32(Core::System& system, u32 address, Svc::ArbitrationType arb_type,
+                               s32 value, u32 timeout_ns_low, u32 timeout_ns_high) {
     const auto timeout = static_cast<s64>(timeout_ns_low | (u64{timeout_ns_high} << 32));
     return WaitForAddress(system, address, arb_type, value, timeout);
 }
 
 // Signals to an address (via Address Arbiter)
-static ResultCode SignalToAddress(Core::System& system, VAddr address, Svc::SignalType signal_type,
-                                  s32 value, s32 count) {
+static Result SignalToAddress(Core::System& system, VAddr address, Svc::SignalType signal_type,
+                              s32 value, s32 count) {
     LOG_TRACE(Kernel_SVC, "called, address=0x{:X}, signal_type=0x{:X}, value=0x{:X}, count=0x{:X}",
               address, signal_type, value, count);
 
@@ -2086,8 +2082,8 @@ static void SynchronizePreemptionState(Core::System& system) {
     }
 }
 
-static ResultCode SignalToAddress32(Core::System& system, u32 address, Svc::SignalType signal_type,
-                                    s32 value, s32 count) {
+static Result SignalToAddress32(Core::System& system, u32 address, Svc::SignalType signal_type,
+                                s32 value, s32 count) {
     return SignalToAddress(system, address, signal_type, value, count);
 }
 
@@ -2125,7 +2121,7 @@ static void GetSystemTick32(Core::System& system, u32* time_low, u32* time_high)
 }
 
 /// Close a handle
-static ResultCode CloseHandle(Core::System& system, Handle handle) {
+static Result CloseHandle(Core::System& system, Handle handle) {
     LOG_TRACE(Kernel_SVC, "Closing handle 0x{:08X}", handle);
 
     // Remove the handle.
@@ -2135,12 +2131,12 @@ static ResultCode CloseHandle(Core::System& system, Handle handle) {
     return ResultSuccess;
 }
 
-static ResultCode CloseHandle32(Core::System& system, Handle handle) {
+static Result CloseHandle32(Core::System& system, Handle handle) {
     return CloseHandle(system, handle);
 }
 
 /// Clears the signaled state of an event or process.
-static ResultCode ResetSignal(Core::System& system, Handle handle) {
+static Result ResetSignal(Core::System& system, Handle handle) {
     LOG_DEBUG(Kernel_SVC, "called handle 0x{:08X}", handle);
 
     // Get the current handle table.
@@ -2167,7 +2163,7 @@ static ResultCode ResetSignal(Core::System& system, Handle handle) {
     return ResultInvalidHandle;
 }
 
-static ResultCode ResetSignal32(Core::System& system, Handle handle) {
+static Result ResetSignal32(Core::System& system, Handle handle) {
     return ResetSignal(system, handle);
 }
 
@@ -2187,8 +2183,8 @@ constexpr bool IsValidTransferMemoryPermission(MemoryPermission perm) {
 } // Anonymous namespace
 
 /// Creates a TransferMemory object
-static ResultCode CreateTransferMemory(Core::System& system, Handle* out, VAddr address, u64 size,
-                                       MemoryPermission map_perm) {
+static Result CreateTransferMemory(Core::System& system, Handle* out, VAddr address, u64 size,
+                                   MemoryPermission map_perm) {
     auto& kernel = system.Kernel();
 
     // Validate the size.
@@ -2234,13 +2230,13 @@ static ResultCode CreateTransferMemory(Core::System& system, Handle* out, VAddr
     return ResultSuccess;
 }
 
-static ResultCode CreateTransferMemory32(Core::System& system, Handle* out, u32 address, u32 size,
-                                         MemoryPermission map_perm) {
+static Result CreateTransferMemory32(Core::System& system, Handle* out, u32 address, u32 size,
+                                     MemoryPermission map_perm) {
     return CreateTransferMemory(system, out, address, size, map_perm);
 }
 
-static ResultCode GetThreadCoreMask(Core::System& system, Handle thread_handle, s32* out_core_id,
-                                    u64* out_affinity_mask) {
+static Result GetThreadCoreMask(Core::System& system, Handle thread_handle, s32* out_core_id,
+                                u64* out_affinity_mask) {
     LOG_TRACE(Kernel_SVC, "called, handle=0x{:08X}", thread_handle);
 
     // Get the thread from its handle.
@@ -2254,8 +2250,8 @@ static ResultCode GetThreadCoreMask(Core::System& system, Handle thread_handle,
     return ResultSuccess;
 }
 
-static ResultCode GetThreadCoreMask32(Core::System& system, Handle thread_handle, s32* out_core_id,
-                                      u32* out_affinity_mask_low, u32* out_affinity_mask_high) {
+static Result GetThreadCoreMask32(Core::System& system, Handle thread_handle, s32* out_core_id,
+                                  u32* out_affinity_mask_low, u32* out_affinity_mask_high) {
     u64 out_affinity_mask{};
     const auto result = GetThreadCoreMask(system, thread_handle, out_core_id, &out_affinity_mask);
     *out_affinity_mask_high = static_cast<u32>(out_affinity_mask >> 32);
@@ -2263,8 +2259,8 @@ static ResultCode GetThreadCoreMask32(Core::System& system, Handle thread_handle
     return result;
 }
 
-static ResultCode SetThreadCoreMask(Core::System& system, Handle thread_handle, s32 core_id,
-                                    u64 affinity_mask) {
+static Result SetThreadCoreMask(Core::System& system, Handle thread_handle, s32 core_id,
+                                u64 affinity_mask) {
     // Determine the core id/affinity mask.
     if (core_id == IdealCoreUseProcessValue) {
         core_id = system.Kernel().CurrentProcess()->GetIdealCoreId();
@@ -2295,13 +2291,13 @@ static ResultCode SetThreadCoreMask(Core::System& system, Handle thread_handle,
     return ResultSuccess;
 }
 
-static ResultCode SetThreadCoreMask32(Core::System& system, Handle thread_handle, s32 core_id,
-                                      u32 affinity_mask_low, u32 affinity_mask_high) {
+static Result SetThreadCoreMask32(Core::System& system, Handle thread_handle, s32 core_id,
+                                  u32 affinity_mask_low, u32 affinity_mask_high) {
     const auto affinity_mask = u64{affinity_mask_low} | (u64{affinity_mask_high} << 32);
     return SetThreadCoreMask(system, thread_handle, core_id, affinity_mask);
 }
 
-static ResultCode SignalEvent(Core::System& system, Handle event_handle) {
+static Result SignalEvent(Core::System& system, Handle event_handle) {
     LOG_DEBUG(Kernel_SVC, "called, event_handle=0x{:08X}", event_handle);
 
     // Get the current handle table.
@@ -2314,11 +2310,11 @@ static ResultCode SignalEvent(Core::System& system, Handle event_handle) {
     return writable_event->Signal();
 }
 
-static ResultCode SignalEvent32(Core::System& system, Handle event_handle) {
+static Result SignalEvent32(Core::System& system, Handle event_handle) {
     return SignalEvent(system, event_handle);
 }
 
-static ResultCode ClearEvent(Core::System& system, Handle event_handle) {
+static Result ClearEvent(Core::System& system, Handle event_handle) {
     LOG_TRACE(Kernel_SVC, "called, event_handle=0x{:08X}", event_handle);
 
     // Get the current handle table.
@@ -2345,11 +2341,11 @@ static ResultCode ClearEvent(Core::System& system, Handle event_handle) {
     return ResultInvalidHandle;
 }
 
-static ResultCode ClearEvent32(Core::System& system, Handle event_handle) {
+static Result ClearEvent32(Core::System& system, Handle event_handle) {
     return ClearEvent(system, event_handle);
 }
 
-static ResultCode CreateEvent(Core::System& system, Handle* out_write, Handle* out_read) {
+static Result CreateEvent(Core::System& system, Handle* out_write, Handle* out_read) {
     LOG_DEBUG(Kernel_SVC, "called");
 
     // Get the kernel reference and handle table.
@@ -2394,11 +2390,11 @@ static ResultCode CreateEvent(Core::System& system, Handle* out_write, Handle* o
     return ResultSuccess;
 }
 
-static ResultCode CreateEvent32(Core::System& system, Handle* out_write, Handle* out_read) {
+static Result CreateEvent32(Core::System& system, Handle* out_write, Handle* out_read) {
     return CreateEvent(system, out_write, out_read);
 }
 
-static ResultCode GetProcessInfo(Core::System& system, u64* out, Handle process_handle, u32 type) {
+static Result GetProcessInfo(Core::System& system, u64* out, Handle process_handle, u32 type) {
     LOG_DEBUG(Kernel_SVC, "called, handle=0x{:08X}, type=0x{:X}", process_handle, type);
 
     // This function currently only allows retrieving a process' status.
@@ -2424,7 +2420,7 @@ static ResultCode GetProcessInfo(Core::System& system, u64* out, Handle process_
     return ResultSuccess;
 }
 
-static ResultCode CreateResourceLimit(Core::System& system, Handle* out_handle) {
+static Result CreateResourceLimit(Core::System& system, Handle* out_handle) {
     LOG_DEBUG(Kernel_SVC, "called");
 
     // Create a new resource limit.
@@ -2447,9 +2443,8 @@ static ResultCode CreateResourceLimit(Core::System& system, Handle* out_handle)
     return ResultSuccess;
 }
 
-static ResultCode GetResourceLimitLimitValue(Core::System& system, u64* out_limit_value,
-                                             Handle resource_limit_handle,
-                                             LimitableResource which) {
+static Result GetResourceLimitLimitValue(Core::System& system, u64* out_limit_value,
+                                         Handle resource_limit_handle, LimitableResource which) {
     LOG_DEBUG(Kernel_SVC, "called, resource_limit_handle={:08X}, which={}", resource_limit_handle,
               which);
 
@@ -2468,9 +2463,8 @@ static ResultCode GetResourceLimitLimitValue(Core::System& system, u64* out_limi
     return ResultSuccess;
 }
 
-static ResultCode GetResourceLimitCurrentValue(Core::System& system, u64* out_current_value,
-                                               Handle resource_limit_handle,
-                                               LimitableResource which) {
+static Result GetResourceLimitCurrentValue(Core::System& system, u64* out_current_value,
+                                           Handle resource_limit_handle, LimitableResource which) {
     LOG_DEBUG(Kernel_SVC, "called, resource_limit_handle={:08X}, which={}", resource_limit_handle,
               which);
 
@@ -2489,8 +2483,8 @@ static ResultCode GetResourceLimitCurrentValue(Core::System& system, u64* out_cu
     return ResultSuccess;
 }
 
-static ResultCode SetResourceLimitLimitValue(Core::System& system, Handle resource_limit_handle,
-                                             LimitableResource which, u64 limit_value) {
+static Result SetResourceLimitLimitValue(Core::System& system, Handle resource_limit_handle,
+                                         LimitableResource which, u64 limit_value) {
     LOG_DEBUG(Kernel_SVC, "called, resource_limit_handle={:08X}, which={}, limit_value={}",
               resource_limit_handle, which, limit_value);
 
@@ -2509,8 +2503,8 @@ static ResultCode SetResourceLimitLimitValue(Core::System& system, Handle resour
     return ResultSuccess;
 }
 
-static ResultCode GetProcessList(Core::System& system, u32* out_num_processes,
-                                 VAddr out_process_ids, u32 out_process_ids_size) {
+static Result GetProcessList(Core::System& system, u32* out_num_processes, VAddr out_process_ids,
+                             u32 out_process_ids_size) {
     LOG_DEBUG(Kernel_SVC, "called. out_process_ids=0x{:016X}, out_process_ids_size={}",
               out_process_ids, out_process_ids_size);
 
@@ -2546,8 +2540,8 @@ static ResultCode GetProcessList(Core::System& system, u32* out_num_processes,
     return ResultSuccess;
 }
 
-static ResultCode GetThreadList(Core::System& system, u32* out_num_threads, VAddr out_thread_ids,
-                                u32 out_thread_ids_size, Handle debug_handle) {
+static Result GetThreadList(Core::System& system, u32* out_num_threads, VAddr out_thread_ids,
+                            u32 out_thread_ids_size, Handle debug_handle) {
     // TODO: Handle this case when debug events are supported.
     UNIMPLEMENTED_IF(debug_handle != InvalidHandle);
 
@@ -2586,9 +2580,9 @@ static ResultCode GetThreadList(Core::System& system, u32* out_num_threads, VAdd
     return ResultSuccess;
 }
 
-static ResultCode FlushProcessDataCache32([[maybe_unused]] Core::System& system,
-                                          [[maybe_unused]] Handle handle,
-                                          [[maybe_unused]] u32 address, [[maybe_unused]] u32 size) {
+static Result FlushProcessDataCache32([[maybe_unused]] Core::System& system,
+                                      [[maybe_unused]] Handle handle, [[maybe_unused]] u32 address,
+                                      [[maybe_unused]] u32 size) {
     // Note(Blinkhawk): For emulation purposes of the data cache this is mostly a no-op,
     // as all emulation is done in the same cache level in host architecture, thus data cache
     // does not need flushing.
diff --git a/src/core/hle/kernel/svc_results.h b/src/core/hle/kernel/svc_results.h
index fab12d070..f27cade33 100644
--- a/src/core/hle/kernel/svc_results.h
+++ b/src/core/hle/kernel/svc_results.h
@@ -9,34 +9,34 @@ namespace Kernel {
 
 // Confirmed Switch kernel error codes
 
-constexpr ResultCode ResultOutOfSessions{ErrorModule::Kernel, 7};
-constexpr ResultCode ResultInvalidArgument{ErrorModule::Kernel, 14};
-constexpr ResultCode ResultNoSynchronizationObject{ErrorModule::Kernel, 57};
-constexpr ResultCode ResultTerminationRequested{ErrorModule::Kernel, 59};
-constexpr ResultCode ResultInvalidSize{ErrorModule::Kernel, 101};
-constexpr ResultCode ResultInvalidAddress{ErrorModule::Kernel, 102};
-constexpr ResultCode ResultOutOfResource{ErrorModule::Kernel, 103};
-constexpr ResultCode ResultOutOfMemory{ErrorModule::Kernel, 104};
-constexpr ResultCode ResultOutOfHandles{ErrorModule::Kernel, 105};
-constexpr ResultCode ResultInvalidCurrentMemory{ErrorModule::Kernel, 106};
-constexpr ResultCode ResultInvalidNewMemoryPermission{ErrorModule::Kernel, 108};
-constexpr ResultCode ResultInvalidMemoryRegion{ErrorModule::Kernel, 110};
-constexpr ResultCode ResultInvalidPriority{ErrorModule::Kernel, 112};
-constexpr ResultCode ResultInvalidCoreId{ErrorModule::Kernel, 113};
-constexpr ResultCode ResultInvalidHandle{ErrorModule::Kernel, 114};
-constexpr ResultCode ResultInvalidPointer{ErrorModule::Kernel, 115};
-constexpr ResultCode ResultInvalidCombination{ErrorModule::Kernel, 116};
-constexpr ResultCode ResultTimedOut{ErrorModule::Kernel, 117};
-constexpr ResultCode ResultCancelled{ErrorModule::Kernel, 118};
-constexpr ResultCode ResultOutOfRange{ErrorModule::Kernel, 119};
-constexpr ResultCode ResultInvalidEnumValue{ErrorModule::Kernel, 120};
-constexpr ResultCode ResultNotFound{ErrorModule::Kernel, 121};
-constexpr ResultCode ResultBusy{ErrorModule::Kernel, 122};
-constexpr ResultCode ResultSessionClosed{ErrorModule::Kernel, 123};
-constexpr ResultCode ResultInvalidState{ErrorModule::Kernel, 125};
-constexpr ResultCode ResultReservedUsed{ErrorModule::Kernel, 126};
-constexpr ResultCode ResultPortClosed{ErrorModule::Kernel, 131};
-constexpr ResultCode ResultLimitReached{ErrorModule::Kernel, 132};
-constexpr ResultCode ResultInvalidId{ErrorModule::Kernel, 519};
+constexpr Result ResultOutOfSessions{ErrorModule::Kernel, 7};
+constexpr Result ResultInvalidArgument{ErrorModule::Kernel, 14};
+constexpr Result ResultNoSynchronizationObject{ErrorModule::Kernel, 57};
+constexpr Result ResultTerminationRequested{ErrorModule::Kernel, 59};
+constexpr Result ResultInvalidSize{ErrorModule::Kernel, 101};
+constexpr Result ResultInvalidAddress{ErrorModule::Kernel, 102};
+constexpr Result ResultOutOfResource{ErrorModule::Kernel, 103};
+constexpr Result ResultOutOfMemory{ErrorModule::Kernel, 104};
+constexpr Result ResultOutOfHandles{ErrorModule::Kernel, 105};
+constexpr Result ResultInvalidCurrentMemory{ErrorModule::Kernel, 106};
+constexpr Result ResultInvalidNewMemoryPermission{ErrorModule::Kernel, 108};
+constexpr Result ResultInvalidMemoryRegion{ErrorModule::Kernel, 110};
+constexpr Result ResultInvalidPriority{ErrorModule::Kernel, 112};
+constexpr Result ResultInvalidCoreId{ErrorModule::Kernel, 113};
+constexpr Result ResultInvalidHandle{ErrorModule::Kernel, 114};
+constexpr Result ResultInvalidPointer{ErrorModule::Kernel, 115};
+constexpr Result ResultInvalidCombination{ErrorModule::Kernel, 116};
+constexpr Result ResultTimedOut{ErrorModule::Kernel, 117};
+constexpr Result ResultCancelled{ErrorModule::Kernel, 118};
+constexpr Result ResultOutOfRange{ErrorModule::Kernel, 119};
+constexpr Result ResultInvalidEnumValue{ErrorModule::Kernel, 120};
+constexpr Result ResultNotFound{ErrorModule::Kernel, 121};
+constexpr Result ResultBusy{ErrorModule::Kernel, 122};
+constexpr Result ResultSessionClosed{ErrorModule::Kernel, 123};
+constexpr Result ResultInvalidState{ErrorModule::Kernel, 125};
+constexpr Result ResultReservedUsed{ErrorModule::Kernel, 126};
+constexpr Result ResultPortClosed{ErrorModule::Kernel, 131};
+constexpr Result ResultLimitReached{ErrorModule::Kernel, 132};
+constexpr Result ResultInvalidId{ErrorModule::Kernel, 519};
 
 } // namespace Kernel
diff --git a/src/core/hle/kernel/svc_wrap.h b/src/core/hle/kernel/svc_wrap.h
index 2271bb80c..4bc49087e 100644
--- a/src/core/hle/kernel/svc_wrap.h
+++ b/src/core/hle/kernel/svc_wrap.h
@@ -33,24 +33,24 @@ static inline void FuncReturn32(Core::System& system, u32 result) {
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
-// Function wrappers that return type ResultCode
+// Function wrappers that return type Result
 
-template <ResultCode func(Core::System&, u64)>
+template <Result func(Core::System&, u64)>
 void SvcWrap64(Core::System& system) {
     FuncReturn(system, func(system, Param(system, 0)).raw);
 }
 
-template <ResultCode func(Core::System&, u64, u64)>
+template <Result func(Core::System&, u64, u64)>
 void SvcWrap64(Core::System& system) {
     FuncReturn(system, func(system, Param(system, 0), Param(system, 1)).raw);
 }
 
-template <ResultCode func(Core::System&, u32)>
+template <Result func(Core::System&, u32)>
 void SvcWrap64(Core::System& system) {
     FuncReturn(system, func(system, static_cast<u32>(Param(system, 0))).raw);
 }
 
-template <ResultCode func(Core::System&, u32, u32)>
+template <Result func(Core::System&, u32, u32)>
 void SvcWrap64(Core::System& system) {
     FuncReturn(
         system,
@@ -58,14 +58,14 @@ void SvcWrap64(Core::System& system) {
 }
 
 // Used by SetThreadActivity
-template <ResultCode func(Core::System&, Handle, Svc::ThreadActivity)>
+template <Result func(Core::System&, Handle, Svc::ThreadActivity)>
 void SvcWrap64(Core::System& system) {
     FuncReturn(system, func(system, static_cast<u32>(Param(system, 0)),
                             static_cast<Svc::ThreadActivity>(Param(system, 1)))
                            .raw);
 }
 
-template <ResultCode func(Core::System&, u32, u64, u64, u64)>
+template <Result func(Core::System&, u32, u64, u64, u64)>
 void SvcWrap64(Core::System& system) {
     FuncReturn(system, func(system, static_cast<u32>(Param(system, 0)), Param(system, 1),
                             Param(system, 2), Param(system, 3))
@@ -73,7 +73,7 @@ void SvcWrap64(Core::System& system) {
 }
 
 // Used by MapProcessMemory and UnmapProcessMemory
-template <ResultCode func(Core::System&, u64, u32, u64, u64)>
+template <Result func(Core::System&, u64, u32, u64, u64)>
 void SvcWrap64(Core::System& system) {
     FuncReturn(system, func(system, Param(system, 0), static_cast<u32>(Param(system, 1)),
                             Param(system, 2), Param(system, 3))
@@ -81,7 +81,7 @@ void SvcWrap64(Core::System& system) {
 }
 
 // Used by ControlCodeMemory
-template <ResultCode func(Core::System&, Handle, u32, u64, u64, Svc::MemoryPermission)>
+template <Result func(Core::System&, Handle, u32, u64, u64, Svc::MemoryPermission)>
 void SvcWrap64(Core::System& system) {
     FuncReturn(system, func(system, static_cast<Handle>(Param(system, 0)),
                             static_cast<u32>(Param(system, 1)), Param(system, 2), Param(system, 3),
@@ -89,7 +89,7 @@ void SvcWrap64(Core::System& system) {
                            .raw);
 }
 
-template <ResultCode func(Core::System&, u32*)>
+template <Result func(Core::System&, u32*)>
 void SvcWrap64(Core::System& system) {
     u32 param = 0;
     const u32 retval = func(system, &param).raw;
@@ -97,7 +97,7 @@ void SvcWrap64(Core::System& system) {
     FuncReturn(system, retval);
 }
 
-template <ResultCode func(Core::System&, u32*, u32)>
+template <Result func(Core::System&, u32*, u32)>
 void SvcWrap64(Core::System& system) {
     u32 param_1 = 0;
     const u32 retval = func(system, &param_1, static_cast<u32>(Param(system, 1))).raw;
@@ -105,7 +105,7 @@ void SvcWrap64(Core::System& system) {
     FuncReturn(system, retval);
 }
 
-template <ResultCode func(Core::System&, u32*, u32*)>
+template <Result func(Core::System&, u32*, u32*)>
 void SvcWrap64(Core::System& system) {
     u32 param_1 = 0;
     u32 param_2 = 0;
@@ -118,7 +118,7 @@ void SvcWrap64(Core::System& system) {
     FuncReturn(system, retval);
 }
 
-template <ResultCode func(Core::System&, u32*, u64)>
+template <Result func(Core::System&, u32*, u64)>
 void SvcWrap64(Core::System& system) {
     u32 param_1 = 0;
     const u32 retval = func(system, &param_1, Param(system, 1)).raw;
@@ -126,7 +126,7 @@ void SvcWrap64(Core::System& system) {
     FuncReturn(system, retval);
 }
 
-template <ResultCode func(Core::System&, u32*, u64, u32)>
+template <Result func(Core::System&, u32*, u64, u32)>
 void SvcWrap64(Core::System& system) {
     u32 param_1 = 0;
     const u32 retval =
@@ -136,7 +136,7 @@ void SvcWrap64(Core::System& system) {
     FuncReturn(system, retval);
 }
 
-template <ResultCode func(Core::System&, u64*, u32)>
+template <Result func(Core::System&, u64*, u32)>
 void SvcWrap64(Core::System& system) {
     u64 param_1 = 0;
     const u32 retval = func(system, &param_1, static_cast<u32>(Param(system, 1))).raw;
@@ -145,12 +145,12 @@ void SvcWrap64(Core::System& system) {
     FuncReturn(system, retval);
 }
 
-template <ResultCode func(Core::System&, u64, u32)>
+template <Result func(Core::System&, u64, u32)>
 void SvcWrap64(Core::System& system) {
     FuncReturn(system, func(system, Param(system, 0), static_cast<u32>(Param(system, 1))).raw);
 }
 
-template <ResultCode func(Core::System&, u64*, u64)>
+template <Result func(Core::System&, u64*, u64)>
 void SvcWrap64(Core::System& system) {
     u64 param_1 = 0;
     const u32 retval = func(system, &param_1, Param(system, 1)).raw;
@@ -159,7 +159,7 @@ void SvcWrap64(Core::System& system) {
     FuncReturn(system, retval);
 }
 
-template <ResultCode func(Core::System&, u64*, u32, u32)>
+template <Result func(Core::System&, u64*, u32, u32)>
 void SvcWrap64(Core::System& system) {
     u64 param_1 = 0;
     const u32 retval = func(system, &param_1, static_cast<u32>(Param(system, 1)),
@@ -171,7 +171,7 @@ void SvcWrap64(Core::System& system) {
 }
 
 // Used by GetResourceLimitLimitValue.
-template <ResultCode func(Core::System&, u64*, Handle, LimitableResource)>
+template <Result func(Core::System&, u64*, Handle, LimitableResource)>
 void SvcWrap64(Core::System& system) {
     u64 param_1 = 0;
     const u32 retval = func(system, &param_1, static_cast<Handle>(Param(system, 1)),
@@ -182,13 +182,13 @@ void SvcWrap64(Core::System& system) {
     FuncReturn(system, retval);
 }
 
-template <ResultCode func(Core::System&, u32, u64)>
+template <Result func(Core::System&, u32, u64)>
 void SvcWrap64(Core::System& system) {
     FuncReturn(system, func(system, static_cast<u32>(Param(system, 0)), Param(system, 1)).raw);
 }
 
 // Used by SetResourceLimitLimitValue
-template <ResultCode func(Core::System&, Handle, LimitableResource, u64)>
+template <Result func(Core::System&, Handle, LimitableResource, u64)>
 void SvcWrap64(Core::System& system) {
     FuncReturn(system, func(system, static_cast<Handle>(Param(system, 0)),
                             static_cast<LimitableResource>(Param(system, 1)), Param(system, 2))
@@ -196,7 +196,7 @@ void SvcWrap64(Core::System& system) {
 }
 
 // Used by SetThreadCoreMask
-template <ResultCode func(Core::System&, Handle, s32, u64)>
+template <Result func(Core::System&, Handle, s32, u64)>
 void SvcWrap64(Core::System& system) {
     FuncReturn(system, func(system, static_cast<u32>(Param(system, 0)),
                             static_cast<s32>(Param(system, 1)), Param(system, 2))
@@ -204,44 +204,44 @@ void SvcWrap64(Core::System& system) {
 }
 
 // Used by GetThreadCoreMask
-template <ResultCode func(Core::System&, Handle, s32*, u64*)>
+template <Result func(Core::System&, Handle, s32*, u64*)>
 void SvcWrap64(Core::System& system) {
     s32 param_1 = 0;
     u64 param_2 = 0;
-    const ResultCode retval = func(system, static_cast<u32>(Param(system, 2)), &param_1, &param_2);
+    const Result retval = func(system, static_cast<u32>(Param(system, 2)), &param_1, &param_2);
 
     system.CurrentArmInterface().SetReg(1, param_1);
     system.CurrentArmInterface().SetReg(2, param_2);
     FuncReturn(system, retval.raw);
 }
 
-template <ResultCode func(Core::System&, u64, u64, u32, u32)>
+template <Result func(Core::System&, u64, u64, u32, u32)>
 void SvcWrap64(Core::System& system) {
     FuncReturn(system, func(system, Param(system, 0), Param(system, 1),
                             static_cast<u32>(Param(system, 2)), static_cast<u32>(Param(system, 3)))
                            .raw);
 }
 
-template <ResultCode func(Core::System&, u64, u64, u32, u64)>
+template <Result func(Core::System&, u64, u64, u32, u64)>
 void SvcWrap64(Core::System& system) {
     FuncReturn(system, func(system, Param(system, 0), Param(system, 1),
                             static_cast<u32>(Param(system, 2)), Param(system, 3))
                            .raw);
 }
 
-template <ResultCode func(Core::System&, u32, u64, u32)>
+template <Result func(Core::System&, u32, u64, u32)>
 void SvcWrap64(Core::System& system) {
     FuncReturn(system, func(system, static_cast<u32>(Param(system, 0)), Param(system, 1),
                             static_cast<u32>(Param(system, 2)))
                            .raw);
 }
 
-template <ResultCode func(Core::System&, u64, u64, u64)>
+template <Result func(Core::System&, u64, u64, u64)>
 void SvcWrap64(Core::System& system) {
     FuncReturn(system, func(system, Param(system, 0), Param(system, 1), Param(system, 2)).raw);
 }
 
-template <ResultCode func(Core::System&, u64, u64, u32)>
+template <Result func(Core::System&, u64, u64, u32)>
 void SvcWrap64(Core::System& system) {
     FuncReturn(
         system,
@@ -249,7 +249,7 @@ void SvcWrap64(Core::System& system) {
 }
 
 // Used by SetMemoryPermission
-template <ResultCode func(Core::System&, u64, u64, Svc::MemoryPermission)>
+template <Result func(Core::System&, u64, u64, Svc::MemoryPermission)>
 void SvcWrap64(Core::System& system) {
     FuncReturn(system, func(system, Param(system, 0), Param(system, 1),
                             static_cast<Svc::MemoryPermission>(Param(system, 2)))
@@ -257,14 +257,14 @@ void SvcWrap64(Core::System& system) {
 }
 
 // Used by MapSharedMemory
-template <ResultCode func(Core::System&, Handle, u64, u64, Svc::MemoryPermission)>
+template <Result func(Core::System&, Handle, u64, u64, Svc::MemoryPermission)>
 void SvcWrap64(Core::System& system) {
     FuncReturn(system, func(system, static_cast<Handle>(Param(system, 0)), Param(system, 1),
                             Param(system, 2), static_cast<Svc::MemoryPermission>(Param(system, 3)))
                            .raw);
 }
 
-template <ResultCode func(Core::System&, u32, u64, u64)>
+template <Result func(Core::System&, u32, u64, u64)>
 void SvcWrap64(Core::System& system) {
     FuncReturn(
         system,
@@ -272,7 +272,7 @@ void SvcWrap64(Core::System& system) {
 }
 
 // Used by WaitSynchronization
-template <ResultCode func(Core::System&, s32*, u64, s32, s64)>
+template <Result func(Core::System&, s32*, u64, s32, s64)>
 void SvcWrap64(Core::System& system) {
     s32 param_1 = 0;
     const u32 retval = func(system, &param_1, Param(system, 1), static_cast<s32>(Param(system, 2)),
@@ -283,7 +283,7 @@ void SvcWrap64(Core::System& system) {
     FuncReturn(system, retval);
 }
 
-template <ResultCode func(Core::System&, u64, u64, u32, s64)>
+template <Result func(Core::System&, u64, u64, u32, s64)>
 void SvcWrap64(Core::System& system) {
     FuncReturn(system, func(system, Param(system, 0), Param(system, 1),
                             static_cast<u32>(Param(system, 2)), static_cast<s64>(Param(system, 3)))
@@ -291,7 +291,7 @@ void SvcWrap64(Core::System& system) {
 }
 
 // Used by GetInfo
-template <ResultCode func(Core::System&, u64*, u64, Handle, u64)>
+template <Result func(Core::System&, u64*, u64, Handle, u64)>
 void SvcWrap64(Core::System& system) {
     u64 param_1 = 0;
     const u32 retval = func(system, &param_1, Param(system, 1),
@@ -302,7 +302,7 @@ void SvcWrap64(Core::System& system) {
     FuncReturn(system, retval);
 }
 
-template <ResultCode func(Core::System&, u32*, u64, u64, u64, u32, s32)>
+template <Result func(Core::System&, u32*, u64, u64, u64, u32, s32)>
 void SvcWrap64(Core::System& system) {
     u32 param_1 = 0;
     const u32 retval = func(system, &param_1, Param(system, 1), Param(system, 2), Param(system, 3),
@@ -314,7 +314,7 @@ void SvcWrap64(Core::System& system) {
 }
 
 // Used by CreateTransferMemory
-template <ResultCode func(Core::System&, Handle*, u64, u64, Svc::MemoryPermission)>
+template <Result func(Core::System&, Handle*, u64, u64, Svc::MemoryPermission)>
 void SvcWrap64(Core::System& system) {
     u32 param_1 = 0;
     const u32 retval = func(system, &param_1, Param(system, 1), Param(system, 2),
@@ -326,7 +326,7 @@ void SvcWrap64(Core::System& system) {
 }
 
 // Used by CreateCodeMemory
-template <ResultCode func(Core::System&, Handle*, u64, u64)>
+template <Result func(Core::System&, Handle*, u64, u64)>
 void SvcWrap64(Core::System& system) {
     u32 param_1 = 0;
     const u32 retval = func(system, &param_1, Param(system, 1), Param(system, 2)).raw;
@@ -335,7 +335,7 @@ void SvcWrap64(Core::System& system) {
     FuncReturn(system, retval);
 }
 
-template <ResultCode func(Core::System&, Handle*, u64, u32, u32)>
+template <Result func(Core::System&, Handle*, u64, u32, u32)>
 void SvcWrap64(Core::System& system) {
     u32 param_1 = 0;
     const u32 retval = func(system, &param_1, Param(system, 1), static_cast<u32>(Param(system, 2)),
@@ -347,7 +347,7 @@ void SvcWrap64(Core::System& system) {
 }
 
 // Used by WaitForAddress
-template <ResultCode func(Core::System&, u64, Svc::ArbitrationType, s32, s64)>
+template <Result func(Core::System&, u64, Svc::ArbitrationType, s32, s64)>
 void SvcWrap64(Core::System& system) {
     FuncReturn(system,
                func(system, Param(system, 0), static_cast<Svc::ArbitrationType>(Param(system, 1)),
@@ -356,7 +356,7 @@ void SvcWrap64(Core::System& system) {
 }
 
 // Used by SignalToAddress
-template <ResultCode func(Core::System&, u64, Svc::SignalType, s32, s32)>
+template <Result func(Core::System&, u64, Svc::SignalType, s32, s32)>
 void SvcWrap64(Core::System& system) {
     FuncReturn(system,
                func(system, Param(system, 0), static_cast<Svc::SignalType>(Param(system, 1)),
@@ -425,7 +425,7 @@ void SvcWrap64(Core::System& system) {
 }
 
 // Used by QueryMemory32, ArbitrateLock32
-template <ResultCode func(Core::System&, u32, u32, u32)>
+template <Result func(Core::System&, u32, u32, u32)>
 void SvcWrap32(Core::System& system) {
     FuncReturn32(system,
                  func(system, Param32(system, 0), Param32(system, 1), Param32(system, 2)).raw);
@@ -456,7 +456,7 @@ void SvcWrap32(Core::System& system) {
 }
 
 // Used by CreateThread32
-template <ResultCode func(Core::System&, Handle*, u32, u32, u32, u32, s32)>
+template <Result func(Core::System&, Handle*, u32, u32, u32, u32, s32)>
 void SvcWrap32(Core::System& system) {
     Handle param_1 = 0;
 
@@ -469,7 +469,7 @@ void SvcWrap32(Core::System& system) {
 }
 
 // Used by GetInfo32
-template <ResultCode func(Core::System&, u32*, u32*, u32, u32, u32, u32)>
+template <Result func(Core::System&, u32*, u32*, u32, u32, u32, u32)>
 void SvcWrap32(Core::System& system) {
     u32 param_1 = 0;
     u32 param_2 = 0;
@@ -484,7 +484,7 @@ void SvcWrap32(Core::System& system) {
 }
 
 // Used by GetThreadPriority32, ConnectToNamedPort32
-template <ResultCode func(Core::System&, u32*, u32)>
+template <Result func(Core::System&, u32*, u32)>
 void SvcWrap32(Core::System& system) {
     u32 param_1 = 0;
     const u32 retval = func(system, &param_1, Param32(system, 1)).raw;
@@ -493,7 +493,7 @@ void SvcWrap32(Core::System& system) {
 }
 
 // Used by GetThreadId32
-template <ResultCode func(Core::System&, u32*, u32*, u32)>
+template <Result func(Core::System&, u32*, u32*, u32)>
 void SvcWrap32(Core::System& system) {
     u32 param_1 = 0;
     u32 param_2 = 0;
@@ -516,7 +516,7 @@ void SvcWrap32(Core::System& system) {
 }
 
 // Used by CreateEvent32
-template <ResultCode func(Core::System&, Handle*, Handle*)>
+template <Result func(Core::System&, Handle*, Handle*)>
 void SvcWrap32(Core::System& system) {
     Handle param_1 = 0;
     Handle param_2 = 0;
@@ -528,7 +528,7 @@ void SvcWrap32(Core::System& system) {
 }
 
 // Used by GetThreadId32
-template <ResultCode func(Core::System&, Handle, u32*, u32*, u32*)>
+template <Result func(Core::System&, Handle, u32*, u32*, u32*)>
 void SvcWrap32(Core::System& system) {
     u32 param_1 = 0;
     u32 param_2 = 0;
@@ -542,7 +542,7 @@ void SvcWrap32(Core::System& system) {
 }
 
 // Used by GetThreadCoreMask32
-template <ResultCode func(Core::System&, Handle, s32*, u32*, u32*)>
+template <Result func(Core::System&, Handle, s32*, u32*, u32*)>
 void SvcWrap32(Core::System& system) {
     s32 param_1 = 0;
     u32 param_2 = 0;
@@ -562,7 +562,7 @@ void SvcWrap32(Core::System& system) {
 }
 
 // Used by SetThreadActivity32
-template <ResultCode func(Core::System&, Handle, Svc::ThreadActivity)>
+template <Result func(Core::System&, Handle, Svc::ThreadActivity)>
 void SvcWrap32(Core::System& system) {
     const u32 retval = func(system, static_cast<Handle>(Param(system, 0)),
                             static_cast<Svc::ThreadActivity>(Param(system, 1)))
@@ -571,7 +571,7 @@ void SvcWrap32(Core::System& system) {
 }
 
 // Used by SetThreadPriority32
-template <ResultCode func(Core::System&, Handle, u32)>
+template <Result func(Core::System&, Handle, u32)>
 void SvcWrap32(Core::System& system) {
     const u32 retval =
         func(system, static_cast<Handle>(Param(system, 0)), static_cast<u32>(Param(system, 1))).raw;
@@ -579,7 +579,7 @@ void SvcWrap32(Core::System& system) {
 }
 
 // Used by SetMemoryAttribute32
-template <ResultCode func(Core::System&, Handle, u32, u32, u32)>
+template <Result func(Core::System&, Handle, u32, u32, u32)>
 void SvcWrap32(Core::System& system) {
     const u32 retval =
         func(system, static_cast<Handle>(Param(system, 0)), static_cast<u32>(Param(system, 1)),
@@ -589,7 +589,7 @@ void SvcWrap32(Core::System& system) {
 }
 
 // Used by MapSharedMemory32
-template <ResultCode func(Core::System&, Handle, u32, u32, Svc::MemoryPermission)>
+template <Result func(Core::System&, Handle, u32, u32, Svc::MemoryPermission)>
 void SvcWrap32(Core::System& system) {
     const u32 retval = func(system, static_cast<Handle>(Param(system, 0)),
                             static_cast<u32>(Param(system, 1)), static_cast<u32>(Param(system, 2)),
@@ -599,7 +599,7 @@ void SvcWrap32(Core::System& system) {
 }
 
 // Used by SetThreadCoreMask32
-template <ResultCode func(Core::System&, Handle, s32, u32, u32)>
+template <Result func(Core::System&, Handle, s32, u32, u32)>
 void SvcWrap32(Core::System& system) {
     const u32 retval =
         func(system, static_cast<Handle>(Param(system, 0)), static_cast<s32>(Param(system, 1)),
@@ -609,7 +609,7 @@ void SvcWrap32(Core::System& system) {
 }
 
 // Used by WaitProcessWideKeyAtomic32
-template <ResultCode func(Core::System&, u32, u32, Handle, u32, u32)>
+template <Result func(Core::System&, u32, u32, Handle, u32, u32)>
 void SvcWrap32(Core::System& system) {
     const u32 retval =
         func(system, static_cast<u32>(Param(system, 0)), static_cast<u32>(Param(system, 1)),
@@ -620,7 +620,7 @@ void SvcWrap32(Core::System& system) {
 }
 
 // Used by WaitForAddress32
-template <ResultCode func(Core::System&, u32, Svc::ArbitrationType, s32, u32, u32)>
+template <Result func(Core::System&, u32, Svc::ArbitrationType, s32, u32, u32)>
 void SvcWrap32(Core::System& system) {
     const u32 retval = func(system, static_cast<u32>(Param(system, 0)),
                             static_cast<Svc::ArbitrationType>(Param(system, 1)),
@@ -631,7 +631,7 @@ void SvcWrap32(Core::System& system) {
 }
 
 // Used by SignalToAddress32
-template <ResultCode func(Core::System&, u32, Svc::SignalType, s32, s32)>
+template <Result func(Core::System&, u32, Svc::SignalType, s32, s32)>
 void SvcWrap32(Core::System& system) {
     const u32 retval = func(system, static_cast<u32>(Param(system, 0)),
                             static_cast<Svc::SignalType>(Param(system, 1)),
@@ -641,13 +641,13 @@ void SvcWrap32(Core::System& system) {
 }
 
 // Used by SendSyncRequest32, ArbitrateUnlock32
-template <ResultCode func(Core::System&, u32)>
+template <Result func(Core::System&, u32)>
 void SvcWrap32(Core::System& system) {
     FuncReturn(system, func(system, static_cast<u32>(Param(system, 0))).raw);
 }
 
 // Used by CreateTransferMemory32
-template <ResultCode func(Core::System&, Handle*, u32, u32, Svc::MemoryPermission)>
+template <Result func(Core::System&, Handle*, u32, u32, Svc::MemoryPermission)>
 void SvcWrap32(Core::System& system) {
     Handle handle = 0;
     const u32 retval = func(system, &handle, Param32(system, 1), Param32(system, 2),
@@ -658,7 +658,7 @@ void SvcWrap32(Core::System& system) {
 }
 
 // Used by WaitSynchronization32
-template <ResultCode func(Core::System&, u32, u32, s32, u32, s32*)>
+template <Result func(Core::System&, u32, u32, s32, u32, s32*)>
 void SvcWrap32(Core::System& system) {
     s32 param_1 = 0;
     const u32 retval = func(system, Param32(system, 0), Param32(system, 1), Param32(system, 2),
@@ -669,7 +669,7 @@ void SvcWrap32(Core::System& system) {
 }
 
 // Used by CreateCodeMemory32
-template <ResultCode func(Core::System&, Handle*, u32, u32)>
+template <Result func(Core::System&, Handle*, u32, u32)>
 void SvcWrap32(Core::System& system) {
     Handle handle = 0;
 
@@ -680,7 +680,7 @@ void SvcWrap32(Core::System& system) {
 }
 
 // Used by ControlCodeMemory32
-template <ResultCode func(Core::System&, Handle, u32, u64, u64, Svc::MemoryPermission)>
+template <Result func(Core::System&, Handle, u32, u64, u64, Svc::MemoryPermission)>
 void SvcWrap32(Core::System& system) {
     const u32 retval =
         func(system, Param32(system, 0), Param32(system, 1), Param(system, 2), Param(system, 4),
diff --git a/src/core/hle/result.h b/src/core/hle/result.h
index 569dd9f38..aa9e5b89d 100644
--- a/src/core/hle/result.h
+++ b/src/core/hle/result.h
@@ -112,15 +112,15 @@ enum class ErrorModule : u32 {
 };
 
 /// Encapsulates a Horizon OS error code, allowing it to be separated into its constituent fields.
-union ResultCode {
+union Result {
     u32 raw;
 
     BitField<0, 9, ErrorModule> module;
     BitField<9, 13, u32> description;
 
-    constexpr explicit ResultCode(u32 raw_) : raw(raw_) {}
+    constexpr explicit Result(u32 raw_) : raw(raw_) {}
 
-    constexpr ResultCode(ErrorModule module_, u32 description_)
+    constexpr Result(ErrorModule module_, u32 description_)
         : raw(module.FormatValue(module_) | description.FormatValue(description_)) {}
 
     [[nodiscard]] constexpr bool IsSuccess() const {
@@ -132,18 +132,18 @@ union ResultCode {
     }
 };
 
-[[nodiscard]] constexpr bool operator==(const ResultCode& a, const ResultCode& b) {
+[[nodiscard]] constexpr bool operator==(const Result& a, const Result& b) {
     return a.raw == b.raw;
 }
 
-[[nodiscard]] constexpr bool operator!=(const ResultCode& a, const ResultCode& b) {
+[[nodiscard]] constexpr bool operator!=(const Result& a, const Result& b) {
     return !operator==(a, b);
 }
 
 // Convenience functions for creating some common kinds of errors:
 
-/// The default success `ResultCode`.
-constexpr ResultCode ResultSuccess(0);
+/// The default success `Result`.
+constexpr Result ResultSuccess(0);
 
 /**
  * Placeholder result code used for unknown error codes.
@@ -151,24 +151,24 @@ constexpr ResultCode ResultSuccess(0);
  * @note This should only be used when a particular error code
  *       is not known yet.
  */
-constexpr ResultCode ResultUnknown(UINT32_MAX);
+constexpr Result ResultUnknown(UINT32_MAX);
 
 /**
  * A ResultRange defines an inclusive range of error descriptions within an error module.
- * This can be used to check whether the description of a given ResultCode falls within the range.
- * The conversion function returns a ResultCode with its description set to description_start.
+ * This can be used to check whether the description of a given Result falls within the range.
+ * The conversion function returns a Result with its description set to description_start.
  *
  * An example of how it could be used:
  * \code
  * constexpr ResultRange ResultCommonError{ErrorModule::Common, 0, 9999};
  *
- * ResultCode Example(int value) {
- *     const ResultCode result = OtherExample(value);
+ * Result Example(int value) {
+ *     const Result result = OtherExample(value);
  *
  *     // This will only evaluate to true if result.module is ErrorModule::Common and
  *     // result.description is in between 0 and 9999 inclusive.
  *     if (ResultCommonError.Includes(result)) {
- *         // This returns ResultCode{ErrorModule::Common, 0};
+ *         // This returns Result{ErrorModule::Common, 0};
  *         return ResultCommonError;
  *     }
  *
@@ -181,22 +181,22 @@ public:
     consteval ResultRange(ErrorModule module, u32 description_start, u32 description_end_)
         : code{module, description_start}, description_end{description_end_} {}
 
-    [[nodiscard]] constexpr operator ResultCode() const {
+    [[nodiscard]] constexpr operator Result() const {
         return code;
     }
 
-    [[nodiscard]] constexpr bool Includes(ResultCode other) const {
+    [[nodiscard]] constexpr bool Includes(Result other) const {
         return code.module == other.module && code.description <= other.description &&
                other.description <= description_end;
     }
 
 private:
-    ResultCode code;
+    Result code;
     u32 description_end;
 };
 
 /**
- * This is an optional value type. It holds a `ResultCode` and, if that code is ResultSuccess, it
+ * This is an optional value type. It holds a `Result` and, if that code is ResultSuccess, it
  * also holds a result of type `T`. If the code is an error code (not ResultSuccess), then trying
  * to access the inner value with operator* is undefined behavior and will assert with Unwrap().
  * Users of this class must be cognizant to check the status of the ResultVal with operator bool(),
@@ -207,7 +207,7 @@ private:
  * ResultVal<int> Frobnicate(float strength) {
  *     if (strength < 0.f || strength > 1.0f) {
  *         // Can't frobnicate too weakly or too strongly
- *         return ResultCode{ErrorModule::Common, 1};
+ *         return Result{ErrorModule::Common, 1};
  *     } else {
  *         // Frobnicated! Give caller a cookie
  *         return 42;
@@ -230,7 +230,7 @@ class ResultVal {
 public:
     constexpr ResultVal() : expected{} {}
 
-    constexpr ResultVal(ResultCode code) : expected{Common::Unexpected(code)} {}
+    constexpr ResultVal(Result code) : expected{Common::Unexpected(code)} {}
 
     constexpr ResultVal(ResultRange range) : expected{Common::Unexpected(range)} {}
 
@@ -252,7 +252,7 @@ public:
         return expected.has_value();
     }
 
-    [[nodiscard]] constexpr ResultCode Code() const {
+    [[nodiscard]] constexpr Result Code() const {
         return expected.has_value() ? ResultSuccess : expected.error();
     }
 
@@ -320,7 +320,7 @@ public:
 
 private:
     // TODO (Morph): Replace this with C++23 std::expected.
-    Common::Expected<T, ResultCode> expected;
+    Common::Expected<T, Result> expected;
 };
 
 /**
@@ -337,7 +337,7 @@ private:
     target = std::move(*CONCAT2(check_result_L, __LINE__))
 
 /**
- * Analogous to CASCADE_RESULT, but for a bare ResultCode. The code will be propagated if
+ * Analogous to CASCADE_RESULT, but for a bare Result. The code will be propagated if
  * non-success, or discarded otherwise.
  */
 #define CASCADE_CODE(source)                                                                       \
diff --git a/src/core/hle/service/acc/acc.cpp b/src/core/hle/service/acc/acc.cpp
index 88b74cbb0..b726ac27a 100644
--- a/src/core/hle/service/acc/acc.cpp
+++ b/src/core/hle/service/acc/acc.cpp
@@ -28,11 +28,11 @@
 
 namespace Service::Account {
 
-constexpr ResultCode ERR_INVALID_USER_ID{ErrorModule::Account, 20};
-constexpr ResultCode ERR_INVALID_APPLICATION_ID{ErrorModule::Account, 22};
-constexpr ResultCode ERR_INVALID_BUFFER{ErrorModule::Account, 30};
-constexpr ResultCode ERR_INVALID_BUFFER_SIZE{ErrorModule::Account, 31};
-constexpr ResultCode ERR_FAILED_SAVE_DATA{ErrorModule::Account, 100};
+constexpr Result ERR_INVALID_USER_ID{ErrorModule::Account, 20};
+constexpr Result ERR_INVALID_APPLICATION_ID{ErrorModule::Account, 22};
+constexpr Result ERR_INVALID_BUFFER{ErrorModule::Account, 30};
+constexpr Result ERR_INVALID_BUFFER_SIZE{ErrorModule::Account, 31};
+constexpr Result ERR_FAILED_SAVE_DATA{ErrorModule::Account, 100};
 
 // Thumbnails are hard coded to be at least this size
 constexpr std::size_t THUMBNAIL_SIZE = 0x24000;
@@ -505,7 +505,7 @@ protected:
 
     void Cancel() override {}
 
-    ResultCode GetResult() const override {
+    Result GetResult() const override {
         return ResultSuccess;
     }
 };
@@ -747,7 +747,7 @@ void Module::Interface::InitializeApplicationInfoRestricted(Kernel::HLERequestCo
     rb.Push(InitializeApplicationInfoBase());
 }
 
-ResultCode Module::Interface::InitializeApplicationInfoBase() {
+Result Module::Interface::InitializeApplicationInfoBase() {
     if (application_info) {
         LOG_ERROR(Service_ACC, "Application already initialized");
         return ERR_ACCOUNTINFO_ALREADY_INITIALIZED;
diff --git a/src/core/hle/service/acc/acc.h b/src/core/hle/service/acc/acc.h
index fff447fc3..1621e7c0a 100644
--- a/src/core/hle/service/acc/acc.h
+++ b/src/core/hle/service/acc/acc.h
@@ -41,7 +41,7 @@ public:
         void StoreSaveDataThumbnailSystem(Kernel::HLERequestContext& ctx);
 
     private:
-        ResultCode InitializeApplicationInfoBase();
+        Result InitializeApplicationInfoBase();
         void StoreSaveDataThumbnail(Kernel::HLERequestContext& ctx, const Common::UUID& uuid,
                                     const u64 tid);
 
diff --git a/src/core/hle/service/acc/async_context.h b/src/core/hle/service/acc/async_context.h
index e4929f7f0..26332d241 100644
--- a/src/core/hle/service/acc/async_context.h
+++ b/src/core/hle/service/acc/async_context.h
@@ -26,7 +26,7 @@ public:
 protected:
     virtual bool IsComplete() const = 0;
     virtual void Cancel() = 0;
-    virtual ResultCode GetResult() const = 0;
+    virtual Result GetResult() const = 0;
 
     void MarkComplete();
 
diff --git a/src/core/hle/service/acc/errors.h b/src/core/hle/service/acc/errors.h
index eafb75713..e9c16b951 100644
--- a/src/core/hle/service/acc/errors.h
+++ b/src/core/hle/service/acc/errors.h
@@ -7,7 +7,7 @@
 
 namespace Service::Account {
 
-constexpr ResultCode ERR_ACCOUNTINFO_BAD_APPLICATION{ErrorModule::Account, 22};
-constexpr ResultCode ERR_ACCOUNTINFO_ALREADY_INITIALIZED{ErrorModule::Account, 41};
+constexpr Result ERR_ACCOUNTINFO_BAD_APPLICATION{ErrorModule::Account, 22};
+constexpr Result ERR_ACCOUNTINFO_ALREADY_INITIALIZED{ErrorModule::Account, 41};
 
 } // namespace Service::Account
diff --git a/src/core/hle/service/acc/profile_manager.cpp b/src/core/hle/service/acc/profile_manager.cpp
index 0ef298180..8118ead33 100644
--- a/src/core/hle/service/acc/profile_manager.cpp
+++ b/src/core/hle/service/acc/profile_manager.cpp
@@ -33,9 +33,9 @@ struct ProfileDataRaw {
 static_assert(sizeof(ProfileDataRaw) == 0x650, "ProfileDataRaw has incorrect size.");
 
 // TODO(ogniK): Get actual error codes
-constexpr ResultCode ERROR_TOO_MANY_USERS(ErrorModule::Account, u32(-1));
-constexpr ResultCode ERROR_USER_ALREADY_EXISTS(ErrorModule::Account, u32(-2));
-constexpr ResultCode ERROR_ARGUMENT_IS_NULL(ErrorModule::Account, 20);
+constexpr Result ERROR_TOO_MANY_USERS(ErrorModule::Account, u32(-1));
+constexpr Result ERROR_USER_ALREADY_EXISTS(ErrorModule::Account, u32(-2));
+constexpr Result ERROR_ARGUMENT_IS_NULL(ErrorModule::Account, 20);
 
 constexpr char ACC_SAVE_AVATORS_BASE_PATH[] = "system/save/8000000000000010/su/avators";
 
@@ -87,7 +87,7 @@ bool ProfileManager::RemoveProfileAtIndex(std::size_t index) {
 }
 
 /// Helper function to register a user to the system
-ResultCode ProfileManager::AddUser(const ProfileInfo& user) {
+Result ProfileManager::AddUser(const ProfileInfo& user) {
     if (!AddToProfiles(user)) {
         return ERROR_TOO_MANY_USERS;
     }
@@ -96,7 +96,7 @@ ResultCode ProfileManager::AddUser(const ProfileInfo& user) {
 
 /// Create a new user on the system. If the uuid of the user already exists, the user is not
 /// created.
-ResultCode ProfileManager::CreateNewUser(UUID uuid, const ProfileUsername& username) {
+Result ProfileManager::CreateNewUser(UUID uuid, const ProfileUsername& username) {
     if (user_count == MAX_USERS) {
         return ERROR_TOO_MANY_USERS;
     }
@@ -123,7 +123,7 @@ ResultCode ProfileManager::CreateNewUser(UUID uuid, const ProfileUsername& usern
 /// Creates a new user on the system. This function allows a much simpler method of registration
 /// specifically by allowing an std::string for the username. This is required specifically since
 /// we're loading a string straight from the config
-ResultCode ProfileManager::CreateNewUser(UUID uuid, const std::string& username) {
+Result ProfileManager::CreateNewUser(UUID uuid, const std::string& username) {
     ProfileUsername username_output{};
 
     if (username.size() > username_output.size()) {
diff --git a/src/core/hle/service/acc/profile_manager.h b/src/core/hle/service/acc/profile_manager.h
index 955dbd3d6..9940957f1 100644
--- a/src/core/hle/service/acc/profile_manager.h
+++ b/src/core/hle/service/acc/profile_manager.h
@@ -64,9 +64,9 @@ public:
     ProfileManager();
     ~ProfileManager();
 
-    ResultCode AddUser(const ProfileInfo& user);
-    ResultCode CreateNewUser(Common::UUID uuid, const ProfileUsername& username);
-    ResultCode CreateNewUser(Common::UUID uuid, const std::string& username);
+    Result AddUser(const ProfileInfo& user);
+    Result CreateNewUser(Common::UUID uuid, const ProfileUsername& username);
+    Result CreateNewUser(Common::UUID uuid, const std::string& username);
     std::optional<Common::UUID> GetUser(std::size_t index) const;
     std::optional<std::size_t> GetUserIndex(const Common::UUID& uuid) const;
     std::optional<std::size_t> GetUserIndex(const ProfileInfo& user) const;
diff --git a/src/core/hle/service/am/am.cpp b/src/core/hle/service/am/am.cpp
index c4a93e524..d35644e73 100644
--- a/src/core/hle/service/am/am.cpp
+++ b/src/core/hle/service/am/am.cpp
@@ -40,9 +40,9 @@
 
 namespace Service::AM {
 
-constexpr ResultCode ERR_NO_DATA_IN_CHANNEL{ErrorModule::AM, 2};
-constexpr ResultCode ERR_NO_MESSAGES{ErrorModule::AM, 3};
-constexpr ResultCode ERR_SIZE_OUT_OF_BOUNDS{ErrorModule::AM, 503};
+constexpr Result ERR_NO_DATA_IN_CHANNEL{ErrorModule::AM, 2};
+constexpr Result ERR_NO_MESSAGES{ErrorModule::AM, 3};
+constexpr Result ERR_SIZE_OUT_OF_BOUNDS{ErrorModule::AM, 503};
 
 enum class LaunchParameterKind : u32 {
     ApplicationSpecific = 1,
@@ -365,7 +365,7 @@ void ISelfController::LeaveFatalSection(Kernel::HLERequestContext& ctx) {
     // Entry and exit of fatal sections must be balanced.
     if (num_fatal_sections_entered == 0) {
         IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ResultCode{ErrorModule::AM, 512});
+        rb.Push(Result{ErrorModule::AM, 512});
         return;
     }
 
diff --git a/src/core/hle/service/am/applets/applet_controller.cpp b/src/core/hle/service/am/applets/applet_controller.cpp
index 0a5603d18..b418031de 100644
--- a/src/core/hle/service/am/applets/applet_controller.cpp
+++ b/src/core/hle/service/am/applets/applet_controller.cpp
@@ -20,9 +20,9 @@
 namespace Service::AM::Applets {
 
 // This error code (0x183ACA) is thrown when the applet fails to initialize.
-[[maybe_unused]] constexpr ResultCode ERR_CONTROLLER_APPLET_3101{ErrorModule::HID, 3101};
+[[maybe_unused]] constexpr Result ERR_CONTROLLER_APPLET_3101{ErrorModule::HID, 3101};
 // This error code (0x183CCA) is thrown when the u32 result in ControllerSupportResultInfo is 2.
-[[maybe_unused]] constexpr ResultCode ERR_CONTROLLER_APPLET_3102{ErrorModule::HID, 3102};
+[[maybe_unused]] constexpr Result ERR_CONTROLLER_APPLET_3102{ErrorModule::HID, 3102};
 
 static Core::Frontend::ControllerParameters ConvertToFrontendParameters(
     ControllerSupportArgPrivate private_arg, ControllerSupportArgHeader header, bool enable_text,
@@ -173,7 +173,7 @@ bool Controller::TransactionComplete() const {
     return complete;
 }
 
-ResultCode Controller::GetStatus() const {
+Result Controller::GetStatus() const {
     return status;
 }
 
diff --git a/src/core/hle/service/am/applets/applet_controller.h b/src/core/hle/service/am/applets/applet_controller.h
index e1a34853d..1f9adec65 100644
--- a/src/core/hle/service/am/applets/applet_controller.h
+++ b/src/core/hle/service/am/applets/applet_controller.h
@@ -126,7 +126,7 @@ public:
     void Initialize() override;
 
     bool TransactionComplete() const override;
-    ResultCode GetStatus() const override;
+    Result GetStatus() const override;
     void ExecuteInteractive() override;
     void Execute() override;
 
@@ -143,7 +143,7 @@ private:
     ControllerUpdateFirmwareArg controller_update_arg;
     ControllerKeyRemappingArg controller_key_remapping_arg;
     bool complete{false};
-    ResultCode status{ResultSuccess};
+    Result status{ResultSuccess};
     bool is_single_mode{false};
     std::vector<u8> out_data;
 };
diff --git a/src/core/hle/service/am/applets/applet_error.cpp b/src/core/hle/service/am/applets/applet_error.cpp
index 0b87c60b9..fcf34bf7e 100644
--- a/src/core/hle/service/am/applets/applet_error.cpp
+++ b/src/core/hle/service/am/applets/applet_error.cpp
@@ -25,15 +25,15 @@ struct ErrorCode {
         };
     }
 
-    static constexpr ErrorCode FromResultCode(ResultCode result) {
+    static constexpr ErrorCode FromResult(Result result) {
         return {
             .error_category{2000 + static_cast<u32>(result.module.Value())},
             .error_number{result.description.Value()},
         };
     }
 
-    constexpr ResultCode ToResultCode() const {
-        return ResultCode{static_cast<ErrorModule>(error_category - 2000), error_number};
+    constexpr Result ToResult() const {
+        return Result{static_cast<ErrorModule>(error_category - 2000), error_number};
     }
 };
 static_assert(sizeof(ErrorCode) == 0x8, "ErrorCode has incorrect size.");
@@ -97,8 +97,8 @@ void CopyArgumentData(const std::vector<u8>& data, T& variable) {
     std::memcpy(&variable, data.data(), sizeof(T));
 }
 
-ResultCode Decode64BitError(u64 error) {
-    return ErrorCode::FromU64(error).ToResultCode();
+Result Decode64BitError(u64 error) {
+    return ErrorCode::FromU64(error).ToResult();
 }
 
 } // Anonymous namespace
@@ -127,16 +127,16 @@ void Error::Initialize() {
         if (args->error.use_64bit_error_code) {
             error_code = Decode64BitError(args->error.error_code_64);
         } else {
-            error_code = ResultCode(args->error.error_code_32);
+            error_code = Result(args->error.error_code_32);
         }
         break;
     case ErrorAppletMode::ShowSystemError:
         CopyArgumentData(data, args->system_error);
-        error_code = ResultCode(Decode64BitError(args->system_error.error_code_64));
+        error_code = Result(Decode64BitError(args->system_error.error_code_64));
         break;
     case ErrorAppletMode::ShowApplicationError:
         CopyArgumentData(data, args->application_error);
-        error_code = ResultCode(args->application_error.error_code);
+        error_code = Result(args->application_error.error_code);
         break;
     case ErrorAppletMode::ShowErrorRecord:
         CopyArgumentData(data, args->error_record);
@@ -151,7 +151,7 @@ bool Error::TransactionComplete() const {
     return complete;
 }
 
-ResultCode Error::GetStatus() const {
+Result Error::GetStatus() const {
     return ResultSuccess;
 }
 
diff --git a/src/core/hle/service/am/applets/applet_error.h b/src/core/hle/service/am/applets/applet_error.h
index 43487f647..d78d6f1d1 100644
--- a/src/core/hle/service/am/applets/applet_error.h
+++ b/src/core/hle/service/am/applets/applet_error.h
@@ -31,7 +31,7 @@ public:
     void Initialize() override;
 
     bool TransactionComplete() const override;
-    ResultCode GetStatus() const override;
+    Result GetStatus() const override;
     void ExecuteInteractive() override;
     void Execute() override;
 
@@ -41,7 +41,7 @@ private:
     union ErrorArguments;
 
     const Core::Frontend::ErrorApplet& frontend;
-    ResultCode error_code = ResultSuccess;
+    Result error_code = ResultSuccess;
     ErrorAppletMode mode = ErrorAppletMode::ShowError;
     std::unique_ptr<ErrorArguments> args;
 
diff --git a/src/core/hle/service/am/applets/applet_general_backend.cpp b/src/core/hle/service/am/applets/applet_general_backend.cpp
index 41c002ef2..c34ef08b3 100644
--- a/src/core/hle/service/am/applets/applet_general_backend.cpp
+++ b/src/core/hle/service/am/applets/applet_general_backend.cpp
@@ -13,7 +13,7 @@
 
 namespace Service::AM::Applets {
 
-constexpr ResultCode ERROR_INVALID_PIN{ErrorModule::PCTL, 221};
+constexpr Result ERROR_INVALID_PIN{ErrorModule::PCTL, 221};
 
 static void LogCurrentStorage(AppletDataBroker& broker, std::string_view prefix) {
     std::shared_ptr<IStorage> storage = broker.PopNormalDataToApplet();
@@ -71,7 +71,7 @@ bool Auth::TransactionComplete() const {
     return complete;
 }
 
-ResultCode Auth::GetStatus() const {
+Result Auth::GetStatus() const {
     return successful ? ResultSuccess : ERROR_INVALID_PIN;
 }
 
@@ -136,7 +136,7 @@ void Auth::AuthFinished(bool is_successful) {
     successful = is_successful;
 
     struct Return {
-        ResultCode result_code;
+        Result result_code;
     };
     static_assert(sizeof(Return) == 0x4, "Return (AuthApplet) has incorrect size.");
 
@@ -170,7 +170,7 @@ bool PhotoViewer::TransactionComplete() const {
     return complete;
 }
 
-ResultCode PhotoViewer::GetStatus() const {
+Result PhotoViewer::GetStatus() const {
     return ResultSuccess;
 }
 
@@ -223,7 +223,7 @@ bool StubApplet::TransactionComplete() const {
     return true;
 }
 
-ResultCode StubApplet::GetStatus() const {
+Result StubApplet::GetStatus() const {
     LOG_WARNING(Service_AM, "called (STUBBED)");
     return ResultSuccess;
 }
diff --git a/src/core/hle/service/am/applets/applet_general_backend.h b/src/core/hle/service/am/applets/applet_general_backend.h
index e647d0f41..a9f2535a2 100644
--- a/src/core/hle/service/am/applets/applet_general_backend.h
+++ b/src/core/hle/service/am/applets/applet_general_backend.h
@@ -25,7 +25,7 @@ public:
 
     void Initialize() override;
     bool TransactionComplete() const override;
-    ResultCode GetStatus() const override;
+    Result GetStatus() const override;
     void ExecuteInteractive() override;
     void Execute() override;
 
@@ -56,7 +56,7 @@ public:
 
     void Initialize() override;
     bool TransactionComplete() const override;
-    ResultCode GetStatus() const override;
+    Result GetStatus() const override;
     void ExecuteInteractive() override;
     void Execute() override;
 
@@ -77,7 +77,7 @@ public:
     void Initialize() override;
 
     bool TransactionComplete() const override;
-    ResultCode GetStatus() const override;
+    Result GetStatus() const override;
     void ExecuteInteractive() override;
     void Execute() override;
 
diff --git a/src/core/hle/service/am/applets/applet_mii_edit.cpp b/src/core/hle/service/am/applets/applet_mii_edit.cpp
index 8d847c3f6..ae80ef506 100644
--- a/src/core/hle/service/am/applets/applet_mii_edit.cpp
+++ b/src/core/hle/service/am/applets/applet_mii_edit.cpp
@@ -62,7 +62,7 @@ bool MiiEdit::TransactionComplete() const {
     return is_complete;
 }
 
-ResultCode MiiEdit::GetStatus() const {
+Result MiiEdit::GetStatus() const {
     return ResultSuccess;
 }
 
diff --git a/src/core/hle/service/am/applets/applet_mii_edit.h b/src/core/hle/service/am/applets/applet_mii_edit.h
index 900754e57..d18dd3cf5 100644
--- a/src/core/hle/service/am/applets/applet_mii_edit.h
+++ b/src/core/hle/service/am/applets/applet_mii_edit.h
@@ -22,7 +22,7 @@ public:
     void Initialize() override;
 
     bool TransactionComplete() const override;
-    ResultCode GetStatus() const override;
+    Result GetStatus() const override;
     void ExecuteInteractive() override;
     void Execute() override;
 
diff --git a/src/core/hle/service/am/applets/applet_profile_select.cpp b/src/core/hle/service/am/applets/applet_profile_select.cpp
index 02049fd9f..c738db028 100644
--- a/src/core/hle/service/am/applets/applet_profile_select.cpp
+++ b/src/core/hle/service/am/applets/applet_profile_select.cpp
@@ -12,7 +12,7 @@
 
 namespace Service::AM::Applets {
 
-constexpr ResultCode ERR_USER_CANCELLED_SELECTION{ErrorModule::Account, 1};
+constexpr Result ERR_USER_CANCELLED_SELECTION{ErrorModule::Account, 1};
 
 ProfileSelect::ProfileSelect(Core::System& system_, LibraryAppletMode applet_mode_,
                              const Core::Frontend::ProfileSelectApplet& frontend_)
@@ -39,7 +39,7 @@ bool ProfileSelect::TransactionComplete() const {
     return complete;
 }
 
-ResultCode ProfileSelect::GetStatus() const {
+Result ProfileSelect::GetStatus() const {
     return status;
 }
 
diff --git a/src/core/hle/service/am/applets/applet_profile_select.h b/src/core/hle/service/am/applets/applet_profile_select.h
index 3a6e50eaa..b77f1d205 100644
--- a/src/core/hle/service/am/applets/applet_profile_select.h
+++ b/src/core/hle/service/am/applets/applet_profile_select.h
@@ -39,7 +39,7 @@ public:
     void Initialize() override;
 
     bool TransactionComplete() const override;
-    ResultCode GetStatus() const override;
+    Result GetStatus() const override;
     void ExecuteInteractive() override;
     void Execute() override;
 
@@ -50,7 +50,7 @@ private:
 
     UserSelectionConfig config;
     bool complete = false;
-    ResultCode status = ResultSuccess;
+    Result status = ResultSuccess;
     std::vector<u8> final_data;
     Core::System& system;
 };
diff --git a/src/core/hle/service/am/applets/applet_software_keyboard.cpp b/src/core/hle/service/am/applets/applet_software_keyboard.cpp
index 4116fbaa7..faa092957 100644
--- a/src/core/hle/service/am/applets/applet_software_keyboard.cpp
+++ b/src/core/hle/service/am/applets/applet_software_keyboard.cpp
@@ -80,7 +80,7 @@ bool SoftwareKeyboard::TransactionComplete() const {
     return complete;
 }
 
-ResultCode SoftwareKeyboard::GetStatus() const {
+Result SoftwareKeyboard::GetStatus() const {
     return status;
 }
 
diff --git a/src/core/hle/service/am/applets/applet_software_keyboard.h b/src/core/hle/service/am/applets/applet_software_keyboard.h
index c36806a72..b01b31c98 100644
--- a/src/core/hle/service/am/applets/applet_software_keyboard.h
+++ b/src/core/hle/service/am/applets/applet_software_keyboard.h
@@ -28,7 +28,7 @@ public:
     void Initialize() override;
 
     bool TransactionComplete() const override;
-    ResultCode GetStatus() const override;
+    Result GetStatus() const override;
     void ExecuteInteractive() override;
     void Execute() override;
 
@@ -180,7 +180,7 @@ private:
     bool is_background{false};
 
     bool complete{false};
-    ResultCode status{ResultSuccess};
+    Result status{ResultSuccess};
 };
 
 } // namespace Service::AM::Applets
diff --git a/src/core/hle/service/am/applets/applet_web_browser.cpp b/src/core/hle/service/am/applets/applet_web_browser.cpp
index 7b3f77a51..4b804b78c 100644
--- a/src/core/hle/service/am/applets/applet_web_browser.cpp
+++ b/src/core/hle/service/am/applets/applet_web_browser.cpp
@@ -288,7 +288,7 @@ bool WebBrowser::TransactionComplete() const {
     return complete;
 }
 
-ResultCode WebBrowser::GetStatus() const {
+Result WebBrowser::GetStatus() const {
     return status;
 }
 
diff --git a/src/core/hle/service/am/applets/applet_web_browser.h b/src/core/hle/service/am/applets/applet_web_browser.h
index 6b602769b..fd727fac8 100644
--- a/src/core/hle/service/am/applets/applet_web_browser.h
+++ b/src/core/hle/service/am/applets/applet_web_browser.h
@@ -32,7 +32,7 @@ public:
     void Initialize() override;
 
     bool TransactionComplete() const override;
-    ResultCode GetStatus() const override;
+    Result GetStatus() const override;
     void ExecuteInteractive() override;
     void Execute() override;
 
@@ -66,7 +66,7 @@ private:
     const Core::Frontend::WebBrowserApplet& frontend;
 
     bool complete{false};
-    ResultCode status{ResultSuccess};
+    Result status{ResultSuccess};
 
     WebAppletVersion web_applet_version{};
     WebArgHeader web_arg_header{};
diff --git a/src/core/hle/service/am/applets/applets.h b/src/core/hle/service/am/applets/applets.h
index 2861fed0e..e78a57657 100644
--- a/src/core/hle/service/am/applets/applets.h
+++ b/src/core/hle/service/am/applets/applets.h
@@ -9,7 +9,7 @@
 #include "common/swap.h"
 #include "core/hle/service/kernel_helpers.h"
 
-union ResultCode;
+union Result;
 
 namespace Core {
 class System;
@@ -138,7 +138,7 @@ public:
     virtual void Initialize();
 
     virtual bool TransactionComplete() const = 0;
-    virtual ResultCode GetStatus() const = 0;
+    virtual Result GetStatus() const = 0;
     virtual void ExecuteInteractive() = 0;
     virtual void Execute() = 0;
 
diff --git a/src/core/hle/service/audio/errors.h b/src/core/hle/service/audio/errors.h
index 542fec899..ac6c514af 100644
--- a/src/core/hle/service/audio/errors.h
+++ b/src/core/hle/service/audio/errors.h
@@ -7,8 +7,8 @@
 
 namespace Service::Audio {
 
-constexpr ResultCode ERR_OPERATION_FAILED{ErrorModule::Audio, 2};
-constexpr ResultCode ERR_BUFFER_COUNT_EXCEEDED{ErrorModule::Audio, 8};
-constexpr ResultCode ERR_NOT_SUPPORTED{ErrorModule::Audio, 513};
+constexpr Result ERR_OPERATION_FAILED{ErrorModule::Audio, 2};
+constexpr Result ERR_BUFFER_COUNT_EXCEEDED{ErrorModule::Audio, 8};
+constexpr Result ERR_NOT_SUPPORTED{ErrorModule::Audio, 513};
 
 } // namespace Service::Audio
diff --git a/src/core/hle/service/bcat/backend/backend.cpp b/src/core/hle/service/bcat/backend/backend.cpp
index 7e6d16230..cd0b405ff 100644
--- a/src/core/hle/service/bcat/backend/backend.cpp
+++ b/src/core/hle/service/bcat/backend/backend.cpp
@@ -74,7 +74,7 @@ void ProgressServiceBackend::CommitDirectory(std::string_view dir_name) {
     SignalUpdate();
 }
 
-void ProgressServiceBackend::FinishDownload(ResultCode result) {
+void ProgressServiceBackend::FinishDownload(Result result) {
     impl.total_downloaded_bytes = impl.total_bytes;
     impl.status = DeliveryCacheProgressImpl::Status::Done;
     impl.result = result;
diff --git a/src/core/hle/service/bcat/backend/backend.h b/src/core/hle/service/bcat/backend/backend.h
index 7e8026c75..205ed0702 100644
--- a/src/core/hle/service/bcat/backend/backend.h
+++ b/src/core/hle/service/bcat/backend/backend.h
@@ -49,7 +49,7 @@ struct DeliveryCacheProgressImpl {
     };
 
     Status status;
-    ResultCode result = ResultSuccess;
+    Result result = ResultSuccess;
     DirectoryName current_directory;
     FileName current_file;
     s64 current_downloaded_bytes; ///< Bytes downloaded on current file.
@@ -90,7 +90,7 @@ public:
     void CommitDirectory(std::string_view dir_name);
 
     // Notifies the application that the operation completed with result code result.
-    void FinishDownload(ResultCode result);
+    void FinishDownload(Result result);
 
 private:
     explicit ProgressServiceBackend(Core::System& system, std::string_view event_name);
diff --git a/src/core/hle/service/bcat/bcat_module.cpp b/src/core/hle/service/bcat/bcat_module.cpp
index 076fd79e7..d928e37fb 100644
--- a/src/core/hle/service/bcat/bcat_module.cpp
+++ b/src/core/hle/service/bcat/bcat_module.cpp
@@ -18,15 +18,15 @@
 
 namespace Service::BCAT {
 
-constexpr ResultCode ERROR_INVALID_ARGUMENT{ErrorModule::BCAT, 1};
-constexpr ResultCode ERROR_FAILED_OPEN_ENTITY{ErrorModule::BCAT, 2};
-constexpr ResultCode ERROR_ENTITY_ALREADY_OPEN{ErrorModule::BCAT, 6};
-constexpr ResultCode ERROR_NO_OPEN_ENTITY{ErrorModule::BCAT, 7};
+constexpr Result ERROR_INVALID_ARGUMENT{ErrorModule::BCAT, 1};
+constexpr Result ERROR_FAILED_OPEN_ENTITY{ErrorModule::BCAT, 2};
+constexpr Result ERROR_ENTITY_ALREADY_OPEN{ErrorModule::BCAT, 6};
+constexpr Result ERROR_NO_OPEN_ENTITY{ErrorModule::BCAT, 7};
 
 // The command to clear the delivery cache just calls fs IFileSystem DeleteFile on all of the files
 // and if any of them have a non-zero result it just forwards that result. This is the FS error code
 // for permission denied, which is the closest approximation of this scenario.
-constexpr ResultCode ERROR_FAILED_CLEAR_CACHE{ErrorModule::FS, 6400};
+constexpr Result ERROR_FAILED_CLEAR_CACHE{ErrorModule::FS, 6400};
 
 using BCATDigest = std::array<u8, 0x10>;
 
diff --git a/src/core/hle/service/es/es.cpp b/src/core/hle/service/es/es.cpp
index cbe9d5f7c..ff9b0427c 100644
--- a/src/core/hle/service/es/es.cpp
+++ b/src/core/hle/service/es/es.cpp
@@ -8,8 +8,8 @@
 
 namespace Service::ES {
 
-constexpr ResultCode ERROR_INVALID_ARGUMENT{ErrorModule::ETicket, 2};
-constexpr ResultCode ERROR_INVALID_RIGHTS_ID{ErrorModule::ETicket, 3};
+constexpr Result ERROR_INVALID_ARGUMENT{ErrorModule::ETicket, 2};
+constexpr Result ERROR_INVALID_RIGHTS_ID{ErrorModule::ETicket, 3};
 
 class ETicket final : public ServiceFramework<ETicket> {
 public:
diff --git a/src/core/hle/service/fatal/fatal.cpp b/src/core/hle/service/fatal/fatal.cpp
index a99c90479..27675615b 100644
--- a/src/core/hle/service/fatal/fatal.cpp
+++ b/src/core/hle/service/fatal/fatal.cpp
@@ -62,8 +62,7 @@ enum class FatalType : u32 {
     ErrorScreen = 2,
 };
 
-static void GenerateErrorReport(Core::System& system, ResultCode error_code,
-                                const FatalInfo& info) {
+static void GenerateErrorReport(Core::System& system, Result error_code, const FatalInfo& info) {
     const auto title_id = system.GetCurrentProcessProgramID();
     std::string crash_report = fmt::format(
         "Yuzu {}-{} crash report\n"
@@ -106,7 +105,7 @@ static void GenerateErrorReport(Core::System& system, ResultCode error_code,
         info.backtrace_size, info.ArchAsString(), info.unk10);
 }
 
-static void ThrowFatalError(Core::System& system, ResultCode error_code, FatalType fatal_type,
+static void ThrowFatalError(Core::System& system, Result error_code, FatalType fatal_type,
                             const FatalInfo& info) {
     LOG_ERROR(Service_Fatal, "Threw fatal error type {} with error code 0x{:X}", fatal_type,
               error_code.raw);
@@ -129,7 +128,7 @@ static void ThrowFatalError(Core::System& system, ResultCode error_code, FatalTy
 void Module::Interface::ThrowFatal(Kernel::HLERequestContext& ctx) {
     LOG_ERROR(Service_Fatal, "called");
     IPC::RequestParser rp{ctx};
-    const auto error_code = rp.Pop<ResultCode>();
+    const auto error_code = rp.Pop<Result>();
 
     ThrowFatalError(system, error_code, FatalType::ErrorScreen, {});
     IPC::ResponseBuilder rb{ctx, 2};
@@ -139,7 +138,7 @@ void Module::Interface::ThrowFatal(Kernel::HLERequestContext& ctx) {
 void Module::Interface::ThrowFatalWithPolicy(Kernel::HLERequestContext& ctx) {
     LOG_ERROR(Service_Fatal, "called");
     IPC::RequestParser rp(ctx);
-    const auto error_code = rp.Pop<ResultCode>();
+    const auto error_code = rp.Pop<Result>();
     const auto fatal_type = rp.PopEnum<FatalType>();
 
     ThrowFatalError(system, error_code, fatal_type,
@@ -151,7 +150,7 @@ void Module::Interface::ThrowFatalWithPolicy(Kernel::HLERequestContext& ctx) {
 void Module::Interface::ThrowFatalWithCpuContext(Kernel::HLERequestContext& ctx) {
     LOG_ERROR(Service_Fatal, "called");
     IPC::RequestParser rp(ctx);
-    const auto error_code = rp.Pop<ResultCode>();
+    const auto error_code = rp.Pop<Result>();
     const auto fatal_type = rp.PopEnum<FatalType>();
     const auto fatal_info = ctx.ReadBuffer();
     FatalInfo info{};
diff --git a/src/core/hle/service/filesystem/filesystem.cpp b/src/core/hle/service/filesystem/filesystem.cpp
index f8e7519ca..11c604a0f 100644
--- a/src/core/hle/service/filesystem/filesystem.cpp
+++ b/src/core/hle/service/filesystem/filesystem.cpp
@@ -49,7 +49,7 @@ std::string VfsDirectoryServiceWrapper::GetName() const {
     return backing->GetName();
 }
 
-ResultCode VfsDirectoryServiceWrapper::CreateFile(const std::string& path_, u64 size) const {
+Result VfsDirectoryServiceWrapper::CreateFile(const std::string& path_, u64 size) const {
     std::string path(Common::FS::SanitizePath(path_));
     auto dir = GetDirectoryRelativeWrapped(backing, Common::FS::GetParentPath(path));
     if (dir == nullptr) {
@@ -73,7 +73,7 @@ ResultCode VfsDirectoryServiceWrapper::CreateFile(const std::string& path_, u64
     return ResultSuccess;
 }
 
-ResultCode VfsDirectoryServiceWrapper::DeleteFile(const std::string& path_) const {
+Result VfsDirectoryServiceWrapper::DeleteFile(const std::string& path_) const {
     std::string path(Common::FS::SanitizePath(path_));
     if (path.empty()) {
         // TODO(DarkLordZach): Why do games call this and what should it do? Works as is but...
@@ -92,7 +92,7 @@ ResultCode VfsDirectoryServiceWrapper::DeleteFile(const std::string& path_) cons
     return ResultSuccess;
 }
 
-ResultCode VfsDirectoryServiceWrapper::CreateDirectory(const std::string& path_) const {
+Result VfsDirectoryServiceWrapper::CreateDirectory(const std::string& path_) const {
     std::string path(Common::FS::SanitizePath(path_));
 
     // NOTE: This is inaccurate behavior. CreateDirectory is not recursive.
@@ -116,7 +116,7 @@ ResultCode VfsDirectoryServiceWrapper::CreateDirectory(const std::string& path_)
     return ResultSuccess;
 }
 
-ResultCode VfsDirectoryServiceWrapper::DeleteDirectory(const std::string& path_) const {
+Result VfsDirectoryServiceWrapper::DeleteDirectory(const std::string& path_) const {
     std::string path(Common::FS::SanitizePath(path_));
     auto dir = GetDirectoryRelativeWrapped(backing, Common::FS::GetParentPath(path));
     if (!dir->DeleteSubdirectory(Common::FS::GetFilename(path))) {
@@ -126,7 +126,7 @@ ResultCode VfsDirectoryServiceWrapper::DeleteDirectory(const std::string& path_)
     return ResultSuccess;
 }
 
-ResultCode VfsDirectoryServiceWrapper::DeleteDirectoryRecursively(const std::string& path_) const {
+Result VfsDirectoryServiceWrapper::DeleteDirectoryRecursively(const std::string& path_) const {
     std::string path(Common::FS::SanitizePath(path_));
     auto dir = GetDirectoryRelativeWrapped(backing, Common::FS::GetParentPath(path));
     if (!dir->DeleteSubdirectoryRecursive(Common::FS::GetFilename(path))) {
@@ -136,7 +136,7 @@ ResultCode VfsDirectoryServiceWrapper::DeleteDirectoryRecursively(const std::str
     return ResultSuccess;
 }
 
-ResultCode VfsDirectoryServiceWrapper::CleanDirectoryRecursively(const std::string& path) const {
+Result VfsDirectoryServiceWrapper::CleanDirectoryRecursively(const std::string& path) const {
     const std::string sanitized_path(Common::FS::SanitizePath(path));
     auto dir = GetDirectoryRelativeWrapped(backing, Common::FS::GetParentPath(sanitized_path));
 
@@ -148,8 +148,8 @@ ResultCode VfsDirectoryServiceWrapper::CleanDirectoryRecursively(const std::stri
     return ResultSuccess;
 }
 
-ResultCode VfsDirectoryServiceWrapper::RenameFile(const std::string& src_path_,
-                                                  const std::string& dest_path_) const {
+Result VfsDirectoryServiceWrapper::RenameFile(const std::string& src_path_,
+                                              const std::string& dest_path_) const {
     std::string src_path(Common::FS::SanitizePath(src_path_));
     std::string dest_path(Common::FS::SanitizePath(dest_path_));
     auto src = backing->GetFileRelative(src_path);
@@ -183,8 +183,8 @@ ResultCode VfsDirectoryServiceWrapper::RenameFile(const std::string& src_path_,
     return ResultSuccess;
 }
 
-ResultCode VfsDirectoryServiceWrapper::RenameDirectory(const std::string& src_path_,
-                                                       const std::string& dest_path_) const {
+Result VfsDirectoryServiceWrapper::RenameDirectory(const std::string& src_path_,
+                                                   const std::string& dest_path_) const {
     std::string src_path(Common::FS::SanitizePath(src_path_));
     std::string dest_path(Common::FS::SanitizePath(dest_path_));
     auto src = GetDirectoryRelativeWrapped(backing, src_path);
@@ -273,28 +273,27 @@ FileSystemController::FileSystemController(Core::System& system_) : system{syste
 
 FileSystemController::~FileSystemController() = default;
 
-ResultCode FileSystemController::RegisterRomFS(std::unique_ptr<FileSys::RomFSFactory>&& factory) {
+Result FileSystemController::RegisterRomFS(std::unique_ptr<FileSys::RomFSFactory>&& factory) {
     romfs_factory = std::move(factory);
     LOG_DEBUG(Service_FS, "Registered RomFS");
     return ResultSuccess;
 }
 
-ResultCode FileSystemController::RegisterSaveData(
-    std::unique_ptr<FileSys::SaveDataFactory>&& factory) {
+Result FileSystemController::RegisterSaveData(std::unique_ptr<FileSys::SaveDataFactory>&& factory) {
     ASSERT_MSG(save_data_factory == nullptr, "Tried to register a second save data");
     save_data_factory = std::move(factory);
     LOG_DEBUG(Service_FS, "Registered save data");
     return ResultSuccess;
 }
 
-ResultCode FileSystemController::RegisterSDMC(std::unique_ptr<FileSys::SDMCFactory>&& factory) {
+Result FileSystemController::RegisterSDMC(std::unique_ptr<FileSys::SDMCFactory>&& factory) {
     ASSERT_MSG(sdmc_factory == nullptr, "Tried to register a second SDMC");
     sdmc_factory = std::move(factory);
     LOG_DEBUG(Service_FS, "Registered SDMC");
     return ResultSuccess;
 }
 
-ResultCode FileSystemController::RegisterBIS(std::unique_ptr<FileSys::BISFactory>&& factory) {
+Result FileSystemController::RegisterBIS(std::unique_ptr<FileSys::BISFactory>&& factory) {
     ASSERT_MSG(bis_factory == nullptr, "Tried to register a second BIS");
     bis_factory = std::move(factory);
     LOG_DEBUG(Service_FS, "Registered BIS");
diff --git a/src/core/hle/service/filesystem/filesystem.h b/src/core/hle/service/filesystem/filesystem.h
index 8dd2652fe..5b27de9fa 100644
--- a/src/core/hle/service/filesystem/filesystem.h
+++ b/src/core/hle/service/filesystem/filesystem.h
@@ -58,10 +58,10 @@ public:
     explicit FileSystemController(Core::System& system_);
     ~FileSystemController();
 
-    ResultCode RegisterRomFS(std::unique_ptr<FileSys::RomFSFactory>&& factory);
-    ResultCode RegisterSaveData(std::unique_ptr<FileSys::SaveDataFactory>&& factory);
-    ResultCode RegisterSDMC(std::unique_ptr<FileSys::SDMCFactory>&& factory);
-    ResultCode RegisterBIS(std::unique_ptr<FileSys::BISFactory>&& factory);
+    Result RegisterRomFS(std::unique_ptr<FileSys::RomFSFactory>&& factory);
+    Result RegisterSaveData(std::unique_ptr<FileSys::SaveDataFactory>&& factory);
+    Result RegisterSDMC(std::unique_ptr<FileSys::SDMCFactory>&& factory);
+    Result RegisterBIS(std::unique_ptr<FileSys::BISFactory>&& factory);
 
     void SetPackedUpdate(FileSys::VirtualFile update_raw);
     ResultVal<FileSys::VirtualFile> OpenRomFSCurrentProcess() const;
@@ -141,7 +141,7 @@ private:
 
 void InstallInterfaces(Core::System& system);
 
-// A class that wraps a VfsDirectory with methods that return ResultVal and ResultCode instead of
+// A class that wraps a VfsDirectory with methods that return ResultVal and Result instead of
 // pointers and booleans. This makes using a VfsDirectory with switch services much easier and
 // avoids repetitive code.
 class VfsDirectoryServiceWrapper {
@@ -160,35 +160,35 @@ public:
      * @param size The size of the new file, filled with zeroes
      * @return Result of the operation
      */
-    ResultCode CreateFile(const std::string& path, u64 size) const;
+    Result CreateFile(const std::string& path, u64 size) const;
 
     /**
      * Delete a file specified by its path
      * @param path Path relative to the archive
      * @return Result of the operation
      */
-    ResultCode DeleteFile(const std::string& path) const;
+    Result DeleteFile(const std::string& path) const;
 
     /**
      * Create a directory specified by its path
      * @param path Path relative to the archive
      * @return Result of the operation
      */
-    ResultCode CreateDirectory(const std::string& path) const;
+    Result CreateDirectory(const std::string& path) const;
 
     /**
      * Delete a directory specified by its path
      * @param path Path relative to the archive
      * @return Result of the operation
      */
-    ResultCode DeleteDirectory(const std::string& path) const;
+    Result DeleteDirectory(const std::string& path) const;
 
     /**
      * Delete a directory specified by its path and anything under it
      * @param path Path relative to the archive
      * @return Result of the operation
      */
-    ResultCode DeleteDirectoryRecursively(const std::string& path) const;
+    Result DeleteDirectoryRecursively(const std::string& path) const;
 
     /**
      * Cleans the specified directory. This is similar to DeleteDirectoryRecursively,
@@ -200,7 +200,7 @@ public:
      *
      * @return Result of the operation.
      */
-    ResultCode CleanDirectoryRecursively(const std::string& path) const;
+    Result CleanDirectoryRecursively(const std::string& path) const;
 
     /**
      * Rename a File specified by its path
@@ -208,7 +208,7 @@ public:
      * @param dest_path Destination path relative to the archive
      * @return Result of the operation
      */
-    ResultCode RenameFile(const std::string& src_path, const std::string& dest_path) const;
+    Result RenameFile(const std::string& src_path, const std::string& dest_path) const;
 
     /**
      * Rename a Directory specified by its path
@@ -216,7 +216,7 @@ public:
      * @param dest_path Destination path relative to the archive
      * @return Result of the operation
      */
-    ResultCode RenameDirectory(const std::string& src_path, const std::string& dest_path) const;
+    Result RenameDirectory(const std::string& src_path, const std::string& dest_path) const;
 
     /**
      * Open a file specified by its path, using the specified mode
diff --git a/src/core/hle/service/friend/errors.h b/src/core/hle/service/friend/errors.h
index bc9fe0aca..ff525d865 100644
--- a/src/core/hle/service/friend/errors.h
+++ b/src/core/hle/service/friend/errors.h
@@ -7,5 +7,5 @@
 
 namespace Service::Friend {
 
-constexpr ResultCode ERR_NO_NOTIFICATIONS{ErrorModule::Account, 15};
+constexpr Result ERR_NO_NOTIFICATIONS{ErrorModule::Account, 15};
 }
diff --git a/src/core/hle/service/glue/arp.cpp b/src/core/hle/service/glue/arp.cpp
index fec7787ab..49b6d45fe 100644
--- a/src/core/hle/service/glue/arp.cpp
+++ b/src/core/hle/service/glue/arp.cpp
@@ -153,7 +153,7 @@ class IRegistrar final : public ServiceFramework<IRegistrar> {
     friend class ARP_W;
 
 public:
-    using IssuerFn = std::function<ResultCode(u64, ApplicationLaunchProperty, std::vector<u8>)>;
+    using IssuerFn = std::function<Result(u64, ApplicationLaunchProperty, std::vector<u8>)>;
 
     explicit IRegistrar(Core::System& system_, IssuerFn&& issuer)
         : ServiceFramework{system_, "IRegistrar"}, issue_process_id{std::move(issuer)} {
diff --git a/src/core/hle/service/glue/errors.h b/src/core/hle/service/glue/errors.h
index aefbe1f3e..d4ce7f44e 100644
--- a/src/core/hle/service/glue/errors.h
+++ b/src/core/hle/service/glue/errors.h
@@ -7,9 +7,9 @@
 
 namespace Service::Glue {
 
-constexpr ResultCode ERR_INVALID_RESOURCE{ErrorModule::ARP, 30};
-constexpr ResultCode ERR_INVALID_PROCESS_ID{ErrorModule::ARP, 31};
-constexpr ResultCode ERR_INVALID_ACCESS{ErrorModule::ARP, 42};
-constexpr ResultCode ERR_NOT_REGISTERED{ErrorModule::ARP, 102};
+constexpr Result ERR_INVALID_RESOURCE{ErrorModule::ARP, 30};
+constexpr Result ERR_INVALID_PROCESS_ID{ErrorModule::ARP, 31};
+constexpr Result ERR_INVALID_ACCESS{ErrorModule::ARP, 42};
+constexpr Result ERR_NOT_REGISTERED{ErrorModule::ARP, 102};
 
 } // namespace Service::Glue
diff --git a/src/core/hle/service/glue/glue_manager.cpp b/src/core/hle/service/glue/glue_manager.cpp
index f1655b33e..8a654cdca 100644
--- a/src/core/hle/service/glue/glue_manager.cpp
+++ b/src/core/hle/service/glue/glue_manager.cpp
@@ -41,8 +41,8 @@ ResultVal<std::vector<u8>> ARPManager::GetControlProperty(u64 title_id) const {
     return iter->second.control;
 }
 
-ResultCode ARPManager::Register(u64 title_id, ApplicationLaunchProperty launch,
-                                std::vector<u8> control) {
+Result ARPManager::Register(u64 title_id, ApplicationLaunchProperty launch,
+                            std::vector<u8> control) {
     if (title_id == 0) {
         return ERR_INVALID_PROCESS_ID;
     }
@@ -56,7 +56,7 @@ ResultCode ARPManager::Register(u64 title_id, ApplicationLaunchProperty launch,
     return ResultSuccess;
 }
 
-ResultCode ARPManager::Unregister(u64 title_id) {
+Result ARPManager::Unregister(u64 title_id) {
     if (title_id == 0) {
         return ERR_INVALID_PROCESS_ID;
     }
diff --git a/src/core/hle/service/glue/glue_manager.h b/src/core/hle/service/glue/glue_manager.h
index 6246fd2ff..cd0b092ac 100644
--- a/src/core/hle/service/glue/glue_manager.h
+++ b/src/core/hle/service/glue/glue_manager.h
@@ -42,12 +42,12 @@ public:
     // Adds a new entry to the internal database with the provided parameters, returning
     // ERR_INVALID_ACCESS if attempting to re-register a title ID without an intermediate Unregister
     // step, and ERR_INVALID_PROCESS_ID if the title ID is 0.
-    ResultCode Register(u64 title_id, ApplicationLaunchProperty launch, std::vector<u8> control);
+    Result Register(u64 title_id, ApplicationLaunchProperty launch, std::vector<u8> control);
 
     // Removes the registration for the provided title ID from the database, returning
     // ERR_NOT_REGISTERED if it doesn't exist in the database and ERR_INVALID_PROCESS_ID if the
     // title ID is 0.
-    ResultCode Unregister(u64 title_id);
+    Result Unregister(u64 title_id);
 
     // Removes all entries from the database, always succeeds. Should only be used when resetting
     // system state.
diff --git a/src/core/hle/service/hid/controllers/npad.cpp b/src/core/hle/service/hid/controllers/npad.cpp
index ac5c38cc6..c08b0a5dc 100644
--- a/src/core/hle/service/hid/controllers/npad.cpp
+++ b/src/core/hle/service/hid/controllers/npad.cpp
@@ -56,7 +56,7 @@ bool Controller_NPad::IsDeviceHandleValid(const Core::HID::VibrationDeviceHandle
     return npad_id && npad_type && device_index;
 }
 
-ResultCode Controller_NPad::VerifyValidSixAxisSensorHandle(
+Result Controller_NPad::VerifyValidSixAxisSensorHandle(
     const Core::HID::SixAxisSensorHandle& device_handle) {
     const auto npad_id = IsNpadIdValid(static_cast<Core::HID::NpadIdType>(device_handle.npad_id));
     if (!npad_id) {
@@ -720,9 +720,9 @@ Controller_NPad::NpadCommunicationMode Controller_NPad::GetNpadCommunicationMode
     return communication_mode;
 }
 
-ResultCode Controller_NPad::SetNpadMode(Core::HID::NpadIdType npad_id,
-                                        NpadJoyDeviceType npad_device_type,
-                                        NpadJoyAssignmentMode assignment_mode) {
+Result Controller_NPad::SetNpadMode(Core::HID::NpadIdType npad_id,
+                                    NpadJoyDeviceType npad_device_type,
+                                    NpadJoyAssignmentMode assignment_mode) {
     if (!IsNpadIdValid(npad_id)) {
         LOG_ERROR(Service_HID, "Invalid NpadIdType npad_id:{}", npad_id);
         return InvalidNpadId;
@@ -984,7 +984,7 @@ void Controller_NPad::UpdateControllerAt(Core::HID::NpadStyleIndex type,
     InitNewlyAddedController(npad_id);
 }
 
-ResultCode Controller_NPad::DisconnectNpad(Core::HID::NpadIdType npad_id) {
+Result Controller_NPad::DisconnectNpad(Core::HID::NpadIdType npad_id) {
     if (!IsNpadIdValid(npad_id)) {
         LOG_ERROR(Service_HID, "Invalid NpadIdType npad_id:{}", npad_id);
         return InvalidNpadId;
@@ -1032,7 +1032,7 @@ ResultCode Controller_NPad::DisconnectNpad(Core::HID::NpadIdType npad_id) {
     WriteEmptyEntry(shared_memory);
     return ResultSuccess;
 }
-ResultCode Controller_NPad::SetGyroscopeZeroDriftMode(
+Result Controller_NPad::SetGyroscopeZeroDriftMode(
     const Core::HID::SixAxisSensorHandle& sixaxis_handle, GyroscopeZeroDriftMode drift_mode) {
     const auto is_valid = VerifyValidSixAxisSensorHandle(sixaxis_handle);
     if (is_valid.IsError()) {
@@ -1046,7 +1046,7 @@ ResultCode Controller_NPad::SetGyroscopeZeroDriftMode(
     return ResultSuccess;
 }
 
-ResultCode Controller_NPad::GetGyroscopeZeroDriftMode(
+Result Controller_NPad::GetGyroscopeZeroDriftMode(
     const Core::HID::SixAxisSensorHandle& sixaxis_handle,
     GyroscopeZeroDriftMode& drift_mode) const {
     const auto is_valid = VerifyValidSixAxisSensorHandle(sixaxis_handle);
@@ -1061,8 +1061,8 @@ ResultCode Controller_NPad::GetGyroscopeZeroDriftMode(
     return ResultSuccess;
 }
 
-ResultCode Controller_NPad::IsSixAxisSensorAtRest(
-    const Core::HID::SixAxisSensorHandle& sixaxis_handle, bool& is_at_rest) const {
+Result Controller_NPad::IsSixAxisSensorAtRest(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
+                                              bool& is_at_rest) const {
     const auto is_valid = VerifyValidSixAxisSensorHandle(sixaxis_handle);
     if (is_valid.IsError()) {
         LOG_ERROR(Service_HID, "Invalid handle, error_code={}", is_valid.raw);
@@ -1074,7 +1074,7 @@ ResultCode Controller_NPad::IsSixAxisSensorAtRest(
     return ResultSuccess;
 }
 
-ResultCode Controller_NPad::IsFirmwareUpdateAvailableForSixAxisSensor(
+Result Controller_NPad::IsFirmwareUpdateAvailableForSixAxisSensor(
     const Core::HID::SixAxisSensorHandle& sixaxis_handle, bool& is_firmware_available) const {
     const auto is_valid = VerifyValidSixAxisSensorHandle(sixaxis_handle);
     if (is_valid.IsError()) {
@@ -1087,7 +1087,7 @@ ResultCode Controller_NPad::IsFirmwareUpdateAvailableForSixAxisSensor(
     return ResultSuccess;
 }
 
-ResultCode Controller_NPad::EnableSixAxisSensorUnalteredPassthrough(
+Result Controller_NPad::EnableSixAxisSensorUnalteredPassthrough(
     const Core::HID::SixAxisSensorHandle& sixaxis_handle, bool is_enabled) {
     const auto is_valid = VerifyValidSixAxisSensorHandle(sixaxis_handle);
     if (is_valid.IsError()) {
@@ -1100,7 +1100,7 @@ ResultCode Controller_NPad::EnableSixAxisSensorUnalteredPassthrough(
     return ResultSuccess;
 }
 
-ResultCode Controller_NPad::IsSixAxisSensorUnalteredPassthroughEnabled(
+Result Controller_NPad::IsSixAxisSensorUnalteredPassthroughEnabled(
     const Core::HID::SixAxisSensorHandle& sixaxis_handle, bool& is_enabled) const {
     const auto is_valid = VerifyValidSixAxisSensorHandle(sixaxis_handle);
     if (is_valid.IsError()) {
@@ -1113,7 +1113,7 @@ ResultCode Controller_NPad::IsSixAxisSensorUnalteredPassthroughEnabled(
     return ResultSuccess;
 }
 
-ResultCode Controller_NPad::LoadSixAxisSensorCalibrationParameter(
+Result Controller_NPad::LoadSixAxisSensorCalibrationParameter(
     const Core::HID::SixAxisSensorHandle& sixaxis_handle,
     Core::HID::SixAxisSensorCalibrationParameter& calibration) const {
     const auto is_valid = VerifyValidSixAxisSensorHandle(sixaxis_handle);
@@ -1128,7 +1128,7 @@ ResultCode Controller_NPad::LoadSixAxisSensorCalibrationParameter(
     return ResultSuccess;
 }
 
-ResultCode Controller_NPad::GetSixAxisSensorIcInformation(
+Result Controller_NPad::GetSixAxisSensorIcInformation(
     const Core::HID::SixAxisSensorHandle& sixaxis_handle,
     Core::HID::SixAxisSensorIcInformation& ic_information) const {
     const auto is_valid = VerifyValidSixAxisSensorHandle(sixaxis_handle);
@@ -1143,7 +1143,7 @@ ResultCode Controller_NPad::GetSixAxisSensorIcInformation(
     return ResultSuccess;
 }
 
-ResultCode Controller_NPad::ResetIsSixAxisSensorDeviceNewlyAssigned(
+Result Controller_NPad::ResetIsSixAxisSensorDeviceNewlyAssigned(
     const Core::HID::SixAxisSensorHandle& sixaxis_handle) {
     const auto is_valid = VerifyValidSixAxisSensorHandle(sixaxis_handle);
     if (is_valid.IsError()) {
@@ -1157,8 +1157,8 @@ ResultCode Controller_NPad::ResetIsSixAxisSensorDeviceNewlyAssigned(
     return ResultSuccess;
 }
 
-ResultCode Controller_NPad::SetSixAxisEnabled(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
-                                              bool sixaxis_status) {
+Result Controller_NPad::SetSixAxisEnabled(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
+                                          bool sixaxis_status) {
     const auto is_valid = VerifyValidSixAxisSensorHandle(sixaxis_handle);
     if (is_valid.IsError()) {
         LOG_ERROR(Service_HID, "Invalid handle, error_code={}", is_valid.raw);
@@ -1170,7 +1170,7 @@ ResultCode Controller_NPad::SetSixAxisEnabled(const Core::HID::SixAxisSensorHand
     return ResultSuccess;
 }
 
-ResultCode Controller_NPad::IsSixAxisSensorFusionEnabled(
+Result Controller_NPad::IsSixAxisSensorFusionEnabled(
     const Core::HID::SixAxisSensorHandle& sixaxis_handle, bool& is_fusion_enabled) const {
     const auto is_valid = VerifyValidSixAxisSensorHandle(sixaxis_handle);
     if (is_valid.IsError()) {
@@ -1183,7 +1183,7 @@ ResultCode Controller_NPad::IsSixAxisSensorFusionEnabled(
 
     return ResultSuccess;
 }
-ResultCode Controller_NPad::SetSixAxisFusionEnabled(
+Result Controller_NPad::SetSixAxisFusionEnabled(
     const Core::HID::SixAxisSensorHandle& sixaxis_handle, bool is_fusion_enabled) {
     const auto is_valid = VerifyValidSixAxisSensorHandle(sixaxis_handle);
     if (is_valid.IsError()) {
@@ -1197,7 +1197,7 @@ ResultCode Controller_NPad::SetSixAxisFusionEnabled(
     return ResultSuccess;
 }
 
-ResultCode Controller_NPad::SetSixAxisFusionParameters(
+Result Controller_NPad::SetSixAxisFusionParameters(
     const Core::HID::SixAxisSensorHandle& sixaxis_handle,
     Core::HID::SixAxisSensorFusionParameters sixaxis_fusion_parameters) {
     const auto is_valid = VerifyValidSixAxisSensorHandle(sixaxis_handle);
@@ -1217,7 +1217,7 @@ ResultCode Controller_NPad::SetSixAxisFusionParameters(
     return ResultSuccess;
 }
 
-ResultCode Controller_NPad::GetSixAxisFusionParameters(
+Result Controller_NPad::GetSixAxisFusionParameters(
     const Core::HID::SixAxisSensorHandle& sixaxis_handle,
     Core::HID::SixAxisSensorFusionParameters& parameters) const {
     const auto is_valid = VerifyValidSixAxisSensorHandle(sixaxis_handle);
@@ -1232,8 +1232,8 @@ ResultCode Controller_NPad::GetSixAxisFusionParameters(
     return ResultSuccess;
 }
 
-ResultCode Controller_NPad::MergeSingleJoyAsDualJoy(Core::HID::NpadIdType npad_id_1,
-                                                    Core::HID::NpadIdType npad_id_2) {
+Result Controller_NPad::MergeSingleJoyAsDualJoy(Core::HID::NpadIdType npad_id_1,
+                                                Core::HID::NpadIdType npad_id_2) {
     if (!IsNpadIdValid(npad_id_1) || !IsNpadIdValid(npad_id_2)) {
         LOG_ERROR(Service_HID, "Invalid NpadIdType npad_id_1:{}, npad_id_2:{}", npad_id_1,
                   npad_id_2);
@@ -1304,8 +1304,8 @@ void Controller_NPad::StopLRAssignmentMode() {
     is_in_lr_assignment_mode = false;
 }
 
-ResultCode Controller_NPad::SwapNpadAssignment(Core::HID::NpadIdType npad_id_1,
-                                               Core::HID::NpadIdType npad_id_2) {
+Result Controller_NPad::SwapNpadAssignment(Core::HID::NpadIdType npad_id_1,
+                                           Core::HID::NpadIdType npad_id_2) {
     if (!IsNpadIdValid(npad_id_1) || !IsNpadIdValid(npad_id_2)) {
         LOG_ERROR(Service_HID, "Invalid NpadIdType npad_id_1:{}, npad_id_2:{}", npad_id_1,
                   npad_id_2);
@@ -1336,8 +1336,8 @@ ResultCode Controller_NPad::SwapNpadAssignment(Core::HID::NpadIdType npad_id_1,
     return ResultSuccess;
 }
 
-ResultCode Controller_NPad::GetLedPattern(Core::HID::NpadIdType npad_id,
-                                          Core::HID::LedPattern& pattern) const {
+Result Controller_NPad::GetLedPattern(Core::HID::NpadIdType npad_id,
+                                      Core::HID::LedPattern& pattern) const {
     if (!IsNpadIdValid(npad_id)) {
         LOG_ERROR(Service_HID, "Invalid NpadIdType npad_id:{}", npad_id);
         return InvalidNpadId;
@@ -1347,8 +1347,8 @@ ResultCode Controller_NPad::GetLedPattern(Core::HID::NpadIdType npad_id,
     return ResultSuccess;
 }
 
-ResultCode Controller_NPad::IsUnintendedHomeButtonInputProtectionEnabled(
-    Core::HID::NpadIdType npad_id, bool& is_valid) const {
+Result Controller_NPad::IsUnintendedHomeButtonInputProtectionEnabled(Core::HID::NpadIdType npad_id,
+                                                                     bool& is_valid) const {
     if (!IsNpadIdValid(npad_id)) {
         LOG_ERROR(Service_HID, "Invalid NpadIdType npad_id:{}", npad_id);
         return InvalidNpadId;
@@ -1358,7 +1358,7 @@ ResultCode Controller_NPad::IsUnintendedHomeButtonInputProtectionEnabled(
     return ResultSuccess;
 }
 
-ResultCode Controller_NPad::SetUnintendedHomeButtonInputProtectionEnabled(
+Result Controller_NPad::SetUnintendedHomeButtonInputProtectionEnabled(
     bool is_protection_enabled, Core::HID::NpadIdType npad_id) {
     if (!IsNpadIdValid(npad_id)) {
         LOG_ERROR(Service_HID, "Invalid NpadIdType npad_id:{}", npad_id);
diff --git a/src/core/hle/service/hid/controllers/npad.h b/src/core/hle/service/hid/controllers/npad.h
index 0b662b7f8..8b54724ed 100644
--- a/src/core/hle/service/hid/controllers/npad.h
+++ b/src/core/hle/service/hid/controllers/npad.h
@@ -29,7 +29,7 @@ namespace Service::KernelHelpers {
 class ServiceContext;
 } // namespace Service::KernelHelpers
 
-union ResultCode;
+union Result;
 
 namespace Service::HID {
 
@@ -107,8 +107,8 @@ public:
     void SetNpadCommunicationMode(NpadCommunicationMode communication_mode_);
     NpadCommunicationMode GetNpadCommunicationMode() const;
 
-    ResultCode SetNpadMode(Core::HID::NpadIdType npad_id, NpadJoyDeviceType npad_device_type,
-                           NpadJoyAssignmentMode assignment_mode);
+    Result SetNpadMode(Core::HID::NpadIdType npad_id, NpadJoyDeviceType npad_device_type,
+                       NpadJoyAssignmentMode assignment_mode);
 
     bool VibrateControllerAtIndex(Core::HID::NpadIdType npad_id, std::size_t device_index,
                                   const Core::HID::VibrationValue& vibration_value);
@@ -141,56 +141,55 @@ public:
     void UpdateControllerAt(Core::HID::NpadStyleIndex controller, Core::HID::NpadIdType npad_id,
                             bool connected);
 
-    ResultCode DisconnectNpad(Core::HID::NpadIdType npad_id);
+    Result DisconnectNpad(Core::HID::NpadIdType npad_id);
 
-    ResultCode SetGyroscopeZeroDriftMode(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
-                                         GyroscopeZeroDriftMode drift_mode);
-    ResultCode GetGyroscopeZeroDriftMode(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
-                                         GyroscopeZeroDriftMode& drift_mode) const;
-    ResultCode IsSixAxisSensorAtRest(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
-                                     bool& is_at_rest) const;
-    ResultCode IsFirmwareUpdateAvailableForSixAxisSensor(
+    Result SetGyroscopeZeroDriftMode(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
+                                     GyroscopeZeroDriftMode drift_mode);
+    Result GetGyroscopeZeroDriftMode(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
+                                     GyroscopeZeroDriftMode& drift_mode) const;
+    Result IsSixAxisSensorAtRest(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
+                                 bool& is_at_rest) const;
+    Result IsFirmwareUpdateAvailableForSixAxisSensor(
         const Core::HID::SixAxisSensorHandle& sixaxis_handle, bool& is_firmware_available) const;
-    ResultCode EnableSixAxisSensorUnalteredPassthrough(
+    Result EnableSixAxisSensorUnalteredPassthrough(
         const Core::HID::SixAxisSensorHandle& sixaxis_handle, bool is_enabled);
-    ResultCode IsSixAxisSensorUnalteredPassthroughEnabled(
+    Result IsSixAxisSensorUnalteredPassthroughEnabled(
         const Core::HID::SixAxisSensorHandle& sixaxis_handle, bool& is_enabled) const;
-    ResultCode LoadSixAxisSensorCalibrationParameter(
+    Result LoadSixAxisSensorCalibrationParameter(
         const Core::HID::SixAxisSensorHandle& sixaxis_handle,
         Core::HID::SixAxisSensorCalibrationParameter& calibration) const;
-    ResultCode GetSixAxisSensorIcInformation(
+    Result GetSixAxisSensorIcInformation(
         const Core::HID::SixAxisSensorHandle& sixaxis_handle,
         Core::HID::SixAxisSensorIcInformation& ic_information) const;
-    ResultCode ResetIsSixAxisSensorDeviceNewlyAssigned(
+    Result ResetIsSixAxisSensorDeviceNewlyAssigned(
         const Core::HID::SixAxisSensorHandle& sixaxis_handle);
-    ResultCode SetSixAxisEnabled(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
-                                 bool sixaxis_status);
-    ResultCode IsSixAxisSensorFusionEnabled(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
-                                            bool& is_fusion_enabled) const;
-    ResultCode SetSixAxisFusionEnabled(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
-                                       bool is_fusion_enabled);
-    ResultCode SetSixAxisFusionParameters(
+    Result SetSixAxisEnabled(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
+                             bool sixaxis_status);
+    Result IsSixAxisSensorFusionEnabled(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
+                                        bool& is_fusion_enabled) const;
+    Result SetSixAxisFusionEnabled(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
+                                   bool is_fusion_enabled);
+    Result SetSixAxisFusionParameters(
         const Core::HID::SixAxisSensorHandle& sixaxis_handle,
         Core::HID::SixAxisSensorFusionParameters sixaxis_fusion_parameters);
-    ResultCode GetSixAxisFusionParameters(
-        const Core::HID::SixAxisSensorHandle& sixaxis_handle,
-        Core::HID::SixAxisSensorFusionParameters& parameters) const;
-    ResultCode GetLedPattern(Core::HID::NpadIdType npad_id, Core::HID::LedPattern& pattern) const;
-    ResultCode IsUnintendedHomeButtonInputProtectionEnabled(Core::HID::NpadIdType npad_id,
-                                                            bool& is_enabled) const;
-    ResultCode SetUnintendedHomeButtonInputProtectionEnabled(bool is_protection_enabled,
-                                                             Core::HID::NpadIdType npad_id);
+    Result GetSixAxisFusionParameters(const Core::HID::SixAxisSensorHandle& sixaxis_handle,
+                                      Core::HID::SixAxisSensorFusionParameters& parameters) const;
+    Result GetLedPattern(Core::HID::NpadIdType npad_id, Core::HID::LedPattern& pattern) const;
+    Result IsUnintendedHomeButtonInputProtectionEnabled(Core::HID::NpadIdType npad_id,
+                                                        bool& is_enabled) const;
+    Result SetUnintendedHomeButtonInputProtectionEnabled(bool is_protection_enabled,
+                                                         Core::HID::NpadIdType npad_id);
     void SetAnalogStickUseCenterClamp(bool use_center_clamp);
     void ClearAllConnectedControllers();
     void DisconnectAllConnectedControllers();
     void ConnectAllDisconnectedControllers();
     void ClearAllControllers();
 
-    ResultCode MergeSingleJoyAsDualJoy(Core::HID::NpadIdType npad_id_1,
-                                       Core::HID::NpadIdType npad_id_2);
+    Result MergeSingleJoyAsDualJoy(Core::HID::NpadIdType npad_id_1,
+                                   Core::HID::NpadIdType npad_id_2);
     void StartLRAssignmentMode();
     void StopLRAssignmentMode();
-    ResultCode SwapNpadAssignment(Core::HID::NpadIdType npad_id_1, Core::HID::NpadIdType npad_id_2);
+    Result SwapNpadAssignment(Core::HID::NpadIdType npad_id_1, Core::HID::NpadIdType npad_id_2);
 
     // Logical OR for all buttons presses on all controllers
     // Specifically for cheat engine and other features.
@@ -198,7 +197,7 @@ public:
 
     static bool IsNpadIdValid(Core::HID::NpadIdType npad_id);
     static bool IsDeviceHandleValid(const Core::HID::VibrationDeviceHandle& device_handle);
-    static ResultCode VerifyValidSixAxisSensorHandle(
+    static Result VerifyValidSixAxisSensorHandle(
         const Core::HID::SixAxisSensorHandle& device_handle);
 
 private:
diff --git a/src/core/hle/service/hid/errors.h b/src/core/hle/service/hid/errors.h
index 6c8ad04af..615c23b84 100644
--- a/src/core/hle/service/hid/errors.h
+++ b/src/core/hle/service/hid/errors.h
@@ -7,12 +7,12 @@
 
 namespace Service::HID {
 
-constexpr ResultCode NpadInvalidHandle{ErrorModule::HID, 100};
-constexpr ResultCode NpadDeviceIndexOutOfRange{ErrorModule::HID, 107};
-constexpr ResultCode InvalidSixAxisFusionRange{ErrorModule::HID, 423};
-constexpr ResultCode NpadIsDualJoycon{ErrorModule::HID, 601};
-constexpr ResultCode NpadIsSameType{ErrorModule::HID, 602};
-constexpr ResultCode InvalidNpadId{ErrorModule::HID, 709};
-constexpr ResultCode NpadNotConnected{ErrorModule::HID, 710};
+constexpr Result NpadInvalidHandle{ErrorModule::HID, 100};
+constexpr Result NpadDeviceIndexOutOfRange{ErrorModule::HID, 107};
+constexpr Result InvalidSixAxisFusionRange{ErrorModule::HID, 423};
+constexpr Result NpadIsDualJoycon{ErrorModule::HID, 601};
+constexpr Result NpadIsSameType{ErrorModule::HID, 602};
+constexpr Result InvalidNpadId{ErrorModule::HID, 709};
+constexpr Result NpadNotConnected{ErrorModule::HID, 710};
 
 } // namespace Service::HID
diff --git a/src/core/hle/service/hid/hidbus.h b/src/core/hle/service/hid/hidbus.h
index 6b3015a0f..8c687f678 100644
--- a/src/core/hle/service/hid/hidbus.h
+++ b/src/core/hle/service/hid/hidbus.h
@@ -71,7 +71,7 @@ private:
     struct HidbusStatusManagerEntry {
         u8 is_connected{};
         INSERT_PADDING_BYTES(0x3);
-        ResultCode is_connected_result{0};
+        Result is_connected_result{0};
         u8 is_enabled{};
         u8 is_in_focus{};
         u8 is_polling_mode{};
diff --git a/src/core/hle/service/hid/hidbus/hidbus_base.h b/src/core/hle/service/hid/hidbus/hidbus_base.h
index 01c52051b..d3960f506 100644
--- a/src/core/hle/service/hid/hidbus/hidbus_base.h
+++ b/src/core/hle/service/hid/hidbus/hidbus_base.h
@@ -26,7 +26,7 @@ enum class JoyPollingMode : u32 {
 };
 
 struct DataAccessorHeader {
-    ResultCode result{ResultUnknown};
+    Result result{ResultUnknown};
     INSERT_PADDING_WORDS(0x1);
     std::array<u8, 0x18> unused{};
     u64 latest_entry{};
diff --git a/src/core/hle/service/ldn/errors.h b/src/core/hle/service/ldn/errors.h
index fb86b9402..972a74806 100644
--- a/src/core/hle/service/ldn/errors.h
+++ b/src/core/hle/service/ldn/errors.h
@@ -7,6 +7,6 @@
 
 namespace Service::LDN {
 
-constexpr ResultCode ERROR_DISABLED{ErrorModule::LDN, 22};
+constexpr Result ERROR_DISABLED{ErrorModule::LDN, 22};
 
 } // namespace Service::LDN
diff --git a/src/core/hle/service/ldr/ldr.cpp b/src/core/hle/service/ldr/ldr.cpp
index 72e4902cb..becd6d1b9 100644
--- a/src/core/hle/service/ldr/ldr.cpp
+++ b/src/core/hle/service/ldr/ldr.cpp
@@ -20,20 +20,20 @@
 
 namespace Service::LDR {
 
-constexpr ResultCode ERROR_INSUFFICIENT_ADDRESS_SPACE{ErrorModule::RO, 2};
-
-[[maybe_unused]] constexpr ResultCode ERROR_INVALID_MEMORY_STATE{ErrorModule::Loader, 51};
-constexpr ResultCode ERROR_INVALID_NRO{ErrorModule::Loader, 52};
-constexpr ResultCode ERROR_INVALID_NRR{ErrorModule::Loader, 53};
-constexpr ResultCode ERROR_MISSING_NRR_HASH{ErrorModule::Loader, 54};
-constexpr ResultCode ERROR_MAXIMUM_NRO{ErrorModule::Loader, 55};
-constexpr ResultCode ERROR_MAXIMUM_NRR{ErrorModule::Loader, 56};
-constexpr ResultCode ERROR_ALREADY_LOADED{ErrorModule::Loader, 57};
-constexpr ResultCode ERROR_INVALID_ALIGNMENT{ErrorModule::Loader, 81};
-constexpr ResultCode ERROR_INVALID_SIZE{ErrorModule::Loader, 82};
-constexpr ResultCode ERROR_INVALID_NRO_ADDRESS{ErrorModule::Loader, 84};
-[[maybe_unused]] constexpr ResultCode ERROR_INVALID_NRR_ADDRESS{ErrorModule::Loader, 85};
-constexpr ResultCode ERROR_NOT_INITIALIZED{ErrorModule::Loader, 87};
+constexpr Result ERROR_INSUFFICIENT_ADDRESS_SPACE{ErrorModule::RO, 2};
+
+[[maybe_unused]] constexpr Result ERROR_INVALID_MEMORY_STATE{ErrorModule::Loader, 51};
+constexpr Result ERROR_INVALID_NRO{ErrorModule::Loader, 52};
+constexpr Result ERROR_INVALID_NRR{ErrorModule::Loader, 53};
+constexpr Result ERROR_MISSING_NRR_HASH{ErrorModule::Loader, 54};
+constexpr Result ERROR_MAXIMUM_NRO{ErrorModule::Loader, 55};
+constexpr Result ERROR_MAXIMUM_NRR{ErrorModule::Loader, 56};
+constexpr Result ERROR_ALREADY_LOADED{ErrorModule::Loader, 57};
+constexpr Result ERROR_INVALID_ALIGNMENT{ErrorModule::Loader, 81};
+constexpr Result ERROR_INVALID_SIZE{ErrorModule::Loader, 82};
+constexpr Result ERROR_INVALID_NRO_ADDRESS{ErrorModule::Loader, 84};
+[[maybe_unused]] constexpr Result ERROR_INVALID_NRR_ADDRESS{ErrorModule::Loader, 85};
+constexpr Result ERROR_NOT_INITIALIZED{ErrorModule::Loader, 87};
 
 constexpr std::size_t MAXIMUM_LOADED_RO{0x40};
 constexpr std::size_t MAXIMUM_MAP_RETRIES{0x200};
@@ -307,7 +307,7 @@ public:
         return (start + size + padding_size) <= (end_info.GetAddress() + end_info.GetSize());
     }
 
-    ResultCode GetAvailableMapRegion(Kernel::KPageTable& page_table, u64 size, VAddr& out_addr) {
+    Result GetAvailableMapRegion(Kernel::KPageTable& page_table, u64 size, VAddr& out_addr) {
         size = Common::AlignUp(size, Kernel::PageSize);
         size += page_table.GetNumGuardPages() * Kernel::PageSize * 4;
 
@@ -364,7 +364,7 @@ public:
         for (std::size_t retry = 0; retry < MAXIMUM_MAP_RETRIES; retry++) {
             R_TRY(GetAvailableMapRegion(page_table, size, addr));
 
-            const ResultCode result{page_table.MapCodeMemory(addr, base_addr, size)};
+            const Result result{page_table.MapCodeMemory(addr, base_addr, size)};
             if (result == Kernel::ResultInvalidCurrentMemory) {
                 continue;
             }
@@ -397,8 +397,7 @@ public:
                         Kernel::KPageTable::ICacheInvalidationStrategy::InvalidateRange);
                 });
 
-                const ResultCode result{
-                    page_table.MapCodeMemory(addr + nro_size, bss_addr, bss_size)};
+                const Result result{page_table.MapCodeMemory(addr + nro_size, bss_addr, bss_size)};
 
                 if (result == Kernel::ResultInvalidCurrentMemory) {
                     continue;
@@ -419,8 +418,8 @@ public:
         return ERROR_INSUFFICIENT_ADDRESS_SPACE;
     }
 
-    ResultCode LoadNro(Kernel::KProcess* process, const NROHeader& nro_header, VAddr nro_addr,
-                       VAddr start) const {
+    Result LoadNro(Kernel::KProcess* process, const NROHeader& nro_header, VAddr nro_addr,
+                   VAddr start) const {
         const VAddr text_start{start + nro_header.segment_headers[TEXT_INDEX].memory_offset};
         const VAddr ro_start{start + nro_header.segment_headers[RO_INDEX].memory_offset};
         const VAddr data_start{start + nro_header.segment_headers[DATA_INDEX].memory_offset};
@@ -569,7 +568,7 @@ public:
         rb.Push(*map_result);
     }
 
-    ResultCode UnmapNro(const NROInfo& info) {
+    Result UnmapNro(const NROInfo& info) {
         // Each region must be unmapped separately to validate memory state
         auto& page_table{system.CurrentProcess()->PageTable()};
 
diff --git a/src/core/hle/service/mii/mii.cpp b/src/core/hle/service/mii/mii.cpp
index 41755bf0b..efb569993 100644
--- a/src/core/hle/service/mii/mii.cpp
+++ b/src/core/hle/service/mii/mii.cpp
@@ -12,7 +12,7 @@
 
 namespace Service::Mii {
 
-constexpr ResultCode ERROR_INVALID_ARGUMENT{ErrorModule::Mii, 1};
+constexpr Result ERROR_INVALID_ARGUMENT{ErrorModule::Mii, 1};
 
 class IDatabaseService final : public ServiceFramework<IDatabaseService> {
 public:
diff --git a/src/core/hle/service/mii/mii_manager.cpp b/src/core/hle/service/mii/mii_manager.cpp
index 08300a1a6..544c92a00 100644
--- a/src/core/hle/service/mii/mii_manager.cpp
+++ b/src/core/hle/service/mii/mii_manager.cpp
@@ -16,7 +16,7 @@ namespace Service::Mii {
 
 namespace {
 
-constexpr ResultCode ERROR_CANNOT_FIND_ENTRY{ErrorModule::Mii, 4};
+constexpr Result ERROR_CANNOT_FIND_ENTRY{ErrorModule::Mii, 4};
 
 constexpr std::size_t BaseMiiCount{2};
 constexpr std::size_t DefaultMiiCount{RawData::DefaultMii.size()};
@@ -441,7 +441,7 @@ ResultVal<std::vector<MiiInfoElement>> MiiManager::GetDefault(SourceFlag source_
     return result;
 }
 
-ResultCode MiiManager::GetIndex([[maybe_unused]] const MiiInfo& info, u32& index) {
+Result MiiManager::GetIndex([[maybe_unused]] const MiiInfo& info, u32& index) {
     constexpr u32 INVALID_INDEX{0xFFFFFFFF};
 
     index = INVALID_INDEX;
diff --git a/src/core/hle/service/mii/mii_manager.h b/src/core/hle/service/mii/mii_manager.h
index db217b9a5..6a286bd96 100644
--- a/src/core/hle/service/mii/mii_manager.h
+++ b/src/core/hle/service/mii/mii_manager.h
@@ -23,7 +23,7 @@ public:
     MiiInfo BuildRandom(Age age, Gender gender, Race race);
     MiiInfo BuildDefault(std::size_t index);
     ResultVal<std::vector<MiiInfoElement>> GetDefault(SourceFlag source_flag);
-    ResultCode GetIndex(const MiiInfo& info, u32& index);
+    Result GetIndex(const MiiInfo& info, u32& index);
 
 private:
     const Common::UUID user_id{};
diff --git a/src/core/hle/service/nfp/nfp.cpp b/src/core/hle/service/nfp/nfp.cpp
index 74891da57..6c5b41dd1 100644
--- a/src/core/hle/service/nfp/nfp.cpp
+++ b/src/core/hle/service/nfp/nfp.cpp
@@ -17,10 +17,10 @@
 
 namespace Service::NFP {
 namespace ErrCodes {
-constexpr ResultCode DeviceNotFound(ErrorModule::NFP, 64);
-constexpr ResultCode WrongDeviceState(ErrorModule::NFP, 73);
-constexpr ResultCode ApplicationAreaIsNotInitialized(ErrorModule::NFP, 128);
-constexpr ResultCode ApplicationAreaExist(ErrorModule::NFP, 168);
+constexpr Result DeviceNotFound(ErrorModule::NFP, 64);
+constexpr Result WrongDeviceState(ErrorModule::NFP, 73);
+constexpr Result ApplicationAreaIsNotInitialized(ErrorModule::NFP, 128);
+constexpr Result ApplicationAreaExist(ErrorModule::NFP, 168);
 } // namespace ErrCodes
 
 constexpr u32 ApplicationAreaSize = 0xD8;
@@ -585,7 +585,7 @@ void Module::Interface::Finalize() {
     application_area_data.clear();
 }
 
-ResultCode Module::Interface::StartDetection(s32 protocol_) {
+Result Module::Interface::StartDetection(s32 protocol_) {
     auto npad_device = system.HIDCore().GetEmulatedController(npad_id);
 
     // TODO(german77): Add callback for when nfc data is available
@@ -601,7 +601,7 @@ ResultCode Module::Interface::StartDetection(s32 protocol_) {
     return ErrCodes::WrongDeviceState;
 }
 
-ResultCode Module::Interface::StopDetection() {
+Result Module::Interface::StopDetection() {
     auto npad_device = system.HIDCore().GetEmulatedController(npad_id);
     npad_device->SetPollingMode(Common::Input::PollingMode::Active);
 
@@ -618,7 +618,7 @@ ResultCode Module::Interface::StopDetection() {
     return ErrCodes::WrongDeviceState;
 }
 
-ResultCode Module::Interface::Mount() {
+Result Module::Interface::Mount() {
     if (device_state == DeviceState::TagFound) {
         device_state = DeviceState::TagMounted;
         return ResultSuccess;
@@ -628,7 +628,7 @@ ResultCode Module::Interface::Mount() {
     return ErrCodes::WrongDeviceState;
 }
 
-ResultCode Module::Interface::Unmount() {
+Result Module::Interface::Unmount() {
     if (device_state == DeviceState::TagMounted) {
         is_application_area_initialized = false;
         application_area_id = 0;
@@ -641,7 +641,7 @@ ResultCode Module::Interface::Unmount() {
     return ErrCodes::WrongDeviceState;
 }
 
-ResultCode Module::Interface::GetTagInfo(TagInfo& tag_info) const {
+Result Module::Interface::GetTagInfo(TagInfo& tag_info) const {
     if (device_state == DeviceState::TagFound || device_state == DeviceState::TagMounted) {
         tag_info = {
             .uuid = tag_data.uuid,
@@ -656,7 +656,7 @@ ResultCode Module::Interface::GetTagInfo(TagInfo& tag_info) const {
     return ErrCodes::WrongDeviceState;
 }
 
-ResultCode Module::Interface::GetCommonInfo(CommonInfo& common_info) const {
+Result Module::Interface::GetCommonInfo(CommonInfo& common_info) const {
     if (device_state != DeviceState::TagMounted) {
         LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);
         return ErrCodes::WrongDeviceState;
@@ -674,7 +674,7 @@ ResultCode Module::Interface::GetCommonInfo(CommonInfo& common_info) const {
     return ResultSuccess;
 }
 
-ResultCode Module::Interface::GetModelInfo(ModelInfo& model_info) const {
+Result Module::Interface::GetModelInfo(ModelInfo& model_info) const {
     if (device_state != DeviceState::TagMounted) {
         LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);
         return ErrCodes::WrongDeviceState;
@@ -684,7 +684,7 @@ ResultCode Module::Interface::GetModelInfo(ModelInfo& model_info) const {
     return ResultSuccess;
 }
 
-ResultCode Module::Interface::GetRegisterInfo(RegisterInfo& register_info) const {
+Result Module::Interface::GetRegisterInfo(RegisterInfo& register_info) const {
     if (device_state != DeviceState::TagMounted) {
         LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);
         return ErrCodes::WrongDeviceState;
@@ -704,7 +704,7 @@ ResultCode Module::Interface::GetRegisterInfo(RegisterInfo& register_info) const
     return ResultSuccess;
 }
 
-ResultCode Module::Interface::OpenApplicationArea(u32 access_id) {
+Result Module::Interface::OpenApplicationArea(u32 access_id) {
     if (device_state != DeviceState::TagMounted) {
         LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);
         return ErrCodes::WrongDeviceState;
@@ -721,7 +721,7 @@ ResultCode Module::Interface::OpenApplicationArea(u32 access_id) {
     return ResultSuccess;
 }
 
-ResultCode Module::Interface::GetApplicationArea(std::vector<u8>& data) const {
+Result Module::Interface::GetApplicationArea(std::vector<u8>& data) const {
     if (device_state != DeviceState::TagMounted) {
         LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);
         return ErrCodes::WrongDeviceState;
@@ -736,7 +736,7 @@ ResultCode Module::Interface::GetApplicationArea(std::vector<u8>& data) const {
     return ResultSuccess;
 }
 
-ResultCode Module::Interface::SetApplicationArea(const std::vector<u8>& data) {
+Result Module::Interface::SetApplicationArea(const std::vector<u8>& data) {
     if (device_state != DeviceState::TagMounted) {
         LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);
         return ErrCodes::WrongDeviceState;
@@ -750,7 +750,7 @@ ResultCode Module::Interface::SetApplicationArea(const std::vector<u8>& data) {
     return ResultSuccess;
 }
 
-ResultCode Module::Interface::CreateApplicationArea(u32 access_id, const std::vector<u8>& data) {
+Result Module::Interface::CreateApplicationArea(u32 access_id, const std::vector<u8>& data) {
     if (device_state != DeviceState::TagMounted) {
         LOG_ERROR(Service_NFP, "Wrong device state {}", device_state);
         return ErrCodes::WrongDeviceState;
diff --git a/src/core/hle/service/nfp/nfp.h b/src/core/hle/service/nfp/nfp.h
index d307c6a35..0fc808781 100644
--- a/src/core/hle/service/nfp/nfp.h
+++ b/src/core/hle/service/nfp/nfp.h
@@ -178,20 +178,20 @@ public:
         void Initialize();
         void Finalize();
 
-        ResultCode StartDetection(s32 protocol_);
-        ResultCode StopDetection();
-        ResultCode Mount();
-        ResultCode Unmount();
-
-        ResultCode GetTagInfo(TagInfo& tag_info) const;
-        ResultCode GetCommonInfo(CommonInfo& common_info) const;
-        ResultCode GetModelInfo(ModelInfo& model_info) const;
-        ResultCode GetRegisterInfo(RegisterInfo& register_info) const;
-
-        ResultCode OpenApplicationArea(u32 access_id);
-        ResultCode GetApplicationArea(std::vector<u8>& data) const;
-        ResultCode SetApplicationArea(const std::vector<u8>& data);
-        ResultCode CreateApplicationArea(u32 access_id, const std::vector<u8>& data);
+        Result StartDetection(s32 protocol_);
+        Result StopDetection();
+        Result Mount();
+        Result Unmount();
+
+        Result GetTagInfo(TagInfo& tag_info) const;
+        Result GetCommonInfo(CommonInfo& common_info) const;
+        Result GetModelInfo(ModelInfo& model_info) const;
+        Result GetRegisterInfo(RegisterInfo& register_info) const;
+
+        Result OpenApplicationArea(u32 access_id);
+        Result GetApplicationArea(std::vector<u8>& data) const;
+        Result SetApplicationArea(const std::vector<u8>& data);
+        Result CreateApplicationArea(u32 access_id, const std::vector<u8>& data);
 
         u64 GetHandle() const;
         DeviceState GetCurrentState() const;
diff --git a/src/core/hle/service/ns/errors.h b/src/core/hle/service/ns/errors.h
index 3c50c66e0..8a7621798 100644
--- a/src/core/hle/service/ns/errors.h
+++ b/src/core/hle/service/ns/errors.h
@@ -7,5 +7,5 @@
 
 namespace Service::NS {
 
-constexpr ResultCode ERR_APPLICATION_LANGUAGE_NOT_FOUND{ErrorModule::NS, 300};
+constexpr Result ERR_APPLICATION_LANGUAGE_NOT_FOUND{ErrorModule::NS, 300};
 }
\ No newline at end of file
diff --git a/src/core/hle/service/pctl/pctl_module.cpp b/src/core/hle/service/pctl/pctl_module.cpp
index 8d5729003..2a123b42d 100644
--- a/src/core/hle/service/pctl/pctl_module.cpp
+++ b/src/core/hle/service/pctl/pctl_module.cpp
@@ -13,10 +13,10 @@ namespace Service::PCTL {
 
 namespace Error {
 
-constexpr ResultCode ResultNoFreeCommunication{ErrorModule::PCTL, 101};
-constexpr ResultCode ResultStereoVisionRestricted{ErrorModule::PCTL, 104};
-constexpr ResultCode ResultNoCapability{ErrorModule::PCTL, 131};
-constexpr ResultCode ResultNoRestrictionEnabled{ErrorModule::PCTL, 181};
+constexpr Result ResultNoFreeCommunication{ErrorModule::PCTL, 101};
+constexpr Result ResultStereoVisionRestricted{ErrorModule::PCTL, 104};
+constexpr Result ResultNoCapability{ErrorModule::PCTL, 131};
+constexpr Result ResultNoRestrictionEnabled{ErrorModule::PCTL, 181};
 
 } // namespace Error
 
diff --git a/src/core/hle/service/pm/pm.cpp b/src/core/hle/service/pm/pm.cpp
index a8e2a5cbd..b10e86c8f 100644
--- a/src/core/hle/service/pm/pm.cpp
+++ b/src/core/hle/service/pm/pm.cpp
@@ -12,12 +12,12 @@ namespace Service::PM {
 
 namespace {
 
-constexpr ResultCode ResultProcessNotFound{ErrorModule::PM, 1};
-[[maybe_unused]] constexpr ResultCode ResultAlreadyStarted{ErrorModule::PM, 2};
-[[maybe_unused]] constexpr ResultCode ResultNotTerminated{ErrorModule::PM, 3};
-[[maybe_unused]] constexpr ResultCode ResultDebugHookInUse{ErrorModule::PM, 4};
-[[maybe_unused]] constexpr ResultCode ResultApplicationRunning{ErrorModule::PM, 5};
-[[maybe_unused]] constexpr ResultCode ResultInvalidSize{ErrorModule::PM, 6};
+constexpr Result ResultProcessNotFound{ErrorModule::PM, 1};
+[[maybe_unused]] constexpr Result ResultAlreadyStarted{ErrorModule::PM, 2};
+[[maybe_unused]] constexpr Result ResultNotTerminated{ErrorModule::PM, 3};
+[[maybe_unused]] constexpr Result ResultDebugHookInUse{ErrorModule::PM, 4};
+[[maybe_unused]] constexpr Result ResultApplicationRunning{ErrorModule::PM, 5};
+[[maybe_unused]] constexpr Result ResultInvalidSize{ErrorModule::PM, 6};
 
 constexpr u64 NO_PROCESS_FOUND_PID{0};
 
diff --git a/src/core/hle/service/service.cpp b/src/core/hle/service/service.cpp
index 574272b0c..318009e4f 100644
--- a/src/core/hle/service/service.cpp
+++ b/src/core/hle/service/service.cpp
@@ -190,8 +190,8 @@ void ServiceFrameworkBase::InvokeRequestTipc(Kernel::HLERequestContext& ctx) {
     handler_invoker(this, info->handler_callback, ctx);
 }
 
-ResultCode ServiceFrameworkBase::HandleSyncRequest(Kernel::KServerSession& session,
-                                                   Kernel::HLERequestContext& ctx) {
+Result ServiceFrameworkBase::HandleSyncRequest(Kernel::KServerSession& session,
+                                               Kernel::HLERequestContext& ctx) {
     const auto guard = LockService();
 
     switch (ctx.GetCommandType()) {
diff --git a/src/core/hle/service/service.h b/src/core/hle/service/service.h
index f23e0cd64..5bf197c51 100644
--- a/src/core/hle/service/service.h
+++ b/src/core/hle/service/service.h
@@ -79,8 +79,8 @@ public:
     Kernel::KClientPort& CreatePort();
 
     /// Handles a synchronization request for the service.
-    ResultCode HandleSyncRequest(Kernel::KServerSession& session,
-                                 Kernel::HLERequestContext& context) override;
+    Result HandleSyncRequest(Kernel::KServerSession& session,
+                             Kernel::HLERequestContext& context) override;
 
 protected:
     /// Member-function pointer type of SyncRequest handlers.
diff --git a/src/core/hle/service/set/set.cpp b/src/core/hle/service/set/set.cpp
index 2839cffcf..f761c2da4 100644
--- a/src/core/hle/service/set/set.cpp
+++ b/src/core/hle/service/set/set.cpp
@@ -74,7 +74,7 @@ constexpr std::array<std::pair<LanguageCode, KeyboardLayout>, 18> language_to_la
 constexpr std::size_t PRE_4_0_0_MAX_ENTRIES = 0xF;
 constexpr std::size_t POST_4_0_0_MAX_ENTRIES = 0x40;
 
-constexpr ResultCode ERR_INVALID_LANGUAGE{ErrorModule::Settings, 625};
+constexpr Result ERR_INVALID_LANGUAGE{ErrorModule::Settings, 625};
 
 void PushResponseLanguageCode(Kernel::HLERequestContext& ctx, std::size_t num_language_codes) {
     IPC::ResponseBuilder rb{ctx, 3};
diff --git a/src/core/hle/service/set/set_sys.cpp b/src/core/hle/service/set/set_sys.cpp
index 87c6f7f85..2a0b812c1 100644
--- a/src/core/hle/service/set/set_sys.cpp
+++ b/src/core/hle/service/set/set_sys.cpp
@@ -32,7 +32,7 @@ void GetFirmwareVersionImpl(Kernel::HLERequestContext& ctx, GetFirmwareVersionTy
     // consistence (currently reports as 5.1.0-0.0)
     const auto archive = FileSys::SystemArchive::SystemVersion();
 
-    const auto early_exit_failure = [&ctx](std::string_view desc, ResultCode code) {
+    const auto early_exit_failure = [&ctx](std::string_view desc, Result code) {
         LOG_ERROR(Service_SET, "General failure while attempting to resolve firmware version ({}).",
                   desc);
         IPC::ResponseBuilder rb{ctx, 2};
diff --git a/src/core/hle/service/sm/sm.cpp b/src/core/hle/service/sm/sm.cpp
index 925608875..246c94623 100644
--- a/src/core/hle/service/sm/sm.cpp
+++ b/src/core/hle/service/sm/sm.cpp
@@ -17,10 +17,10 @@
 
 namespace Service::SM {
 
-constexpr ResultCode ERR_NOT_INITIALIZED(ErrorModule::SM, 2);
-constexpr ResultCode ERR_ALREADY_REGISTERED(ErrorModule::SM, 4);
-constexpr ResultCode ERR_INVALID_NAME(ErrorModule::SM, 6);
-constexpr ResultCode ERR_SERVICE_NOT_REGISTERED(ErrorModule::SM, 7);
+constexpr Result ERR_NOT_INITIALIZED(ErrorModule::SM, 2);
+constexpr Result ERR_ALREADY_REGISTERED(ErrorModule::SM, 4);
+constexpr Result ERR_INVALID_NAME(ErrorModule::SM, 6);
+constexpr Result ERR_SERVICE_NOT_REGISTERED(ErrorModule::SM, 7);
 
 ServiceManager::ServiceManager(Kernel::KernelCore& kernel_) : kernel{kernel_} {}
 ServiceManager::~ServiceManager() = default;
@@ -29,7 +29,7 @@ void ServiceManager::InvokeControlRequest(Kernel::HLERequestContext& context) {
     controller_interface->InvokeRequest(context);
 }
 
-static ResultCode ValidateServiceName(const std::string& name) {
+static Result ValidateServiceName(const std::string& name) {
     if (name.empty() || name.size() > 8) {
         LOG_ERROR(Service_SM, "Invalid service name! service={}", name);
         return ERR_INVALID_NAME;
@@ -43,8 +43,8 @@ Kernel::KClientPort& ServiceManager::InterfaceFactory(ServiceManager& self, Core
     return self.sm_interface->CreatePort();
 }
 
-ResultCode ServiceManager::RegisterService(std::string name, u32 max_sessions,
-                                           Kernel::SessionRequestHandlerPtr handler) {
+Result ServiceManager::RegisterService(std::string name, u32 max_sessions,
+                                       Kernel::SessionRequestHandlerPtr handler) {
 
     CASCADE_CODE(ValidateServiceName(name));
 
@@ -58,7 +58,7 @@ ResultCode ServiceManager::RegisterService(std::string name, u32 max_sessions,
     return ResultSuccess;
 }
 
-ResultCode ServiceManager::UnregisterService(const std::string& name) {
+Result ServiceManager::UnregisterService(const std::string& name) {
     CASCADE_CODE(ValidateServiceName(name));
 
     const auto iter = registered_services.find(name);
@@ -94,7 +94,7 @@ ResultVal<Kernel::KPort*> ServiceManager::GetServicePort(const std::string& name
  *  Inputs:
  *      0: 0x00000000
  *  Outputs:
- *      0: ResultCode
+ *      0: Result
  */
 void SM::Initialize(Kernel::HLERequestContext& ctx) {
     LOG_DEBUG(Service_SM, "called");
diff --git a/src/core/hle/service/sm/sm.h b/src/core/hle/service/sm/sm.h
index 43d445e97..878decc6f 100644
--- a/src/core/hle/service/sm/sm.h
+++ b/src/core/hle/service/sm/sm.h
@@ -55,9 +55,9 @@ public:
     explicit ServiceManager(Kernel::KernelCore& kernel_);
     ~ServiceManager();
 
-    ResultCode RegisterService(std::string name, u32 max_sessions,
-                               Kernel::SessionRequestHandlerPtr handler);
-    ResultCode UnregisterService(const std::string& name);
+    Result RegisterService(std::string name, u32 max_sessions,
+                           Kernel::SessionRequestHandlerPtr handler);
+    Result UnregisterService(const std::string& name);
     ResultVal<Kernel::KPort*> GetServicePort(const std::string& name);
 
     template <Common::DerivedFrom<Kernel::SessionRequestHandler> T>
diff --git a/src/core/hle/service/sm/sm_controller.cpp b/src/core/hle/service/sm/sm_controller.cpp
index a4ed4193e..2a4bd64ab 100644
--- a/src/core/hle/service/sm/sm_controller.cpp
+++ b/src/core/hle/service/sm/sm_controller.cpp
@@ -33,7 +33,7 @@ void Controller::CloneCurrentObject(Kernel::HLERequestContext& ctx) {
 
     // Create a session.
     Kernel::KClientSession* session{};
-    const ResultCode result = parent_port.CreateSession(std::addressof(session), session_manager);
+    const Result result = parent_port.CreateSession(std::addressof(session), session_manager);
     if (result.IsError()) {
         LOG_CRITICAL(Service, "CreateSession failed with error 0x{:08X}", result.raw);
         IPC::ResponseBuilder rb{ctx, 2};
diff --git a/src/core/hle/service/spl/spl_results.h b/src/core/hle/service/spl/spl_results.h
index 17ef655a9..dd7ba11f3 100644
--- a/src/core/hle/service/spl/spl_results.h
+++ b/src/core/hle/service/spl/spl_results.h
@@ -8,23 +8,23 @@
 namespace Service::SPL {
 
 // Description 0 - 99
-constexpr ResultCode ResultSecureMonitorError{ErrorModule::SPL, 0};
-constexpr ResultCode ResultSecureMonitorNotImplemented{ErrorModule::SPL, 1};
-constexpr ResultCode ResultSecureMonitorInvalidArgument{ErrorModule::SPL, 2};
-constexpr ResultCode ResultSecureMonitorBusy{ErrorModule::SPL, 3};
-constexpr ResultCode ResultSecureMonitorNoAsyncOperation{ErrorModule::SPL, 4};
-constexpr ResultCode ResultSecureMonitorInvalidAsyncOperation{ErrorModule::SPL, 5};
-constexpr ResultCode ResultSecureMonitorNotPermitted{ErrorModule::SPL, 6};
-constexpr ResultCode ResultSecureMonitorNotInitialized{ErrorModule::SPL, 7};
+constexpr Result ResultSecureMonitorError{ErrorModule::SPL, 0};
+constexpr Result ResultSecureMonitorNotImplemented{ErrorModule::SPL, 1};
+constexpr Result ResultSecureMonitorInvalidArgument{ErrorModule::SPL, 2};
+constexpr Result ResultSecureMonitorBusy{ErrorModule::SPL, 3};
+constexpr Result ResultSecureMonitorNoAsyncOperation{ErrorModule::SPL, 4};
+constexpr Result ResultSecureMonitorInvalidAsyncOperation{ErrorModule::SPL, 5};
+constexpr Result ResultSecureMonitorNotPermitted{ErrorModule::SPL, 6};
+constexpr Result ResultSecureMonitorNotInitialized{ErrorModule::SPL, 7};
 
-constexpr ResultCode ResultInvalidSize{ErrorModule::SPL, 100};
-constexpr ResultCode ResultUnknownSecureMonitorError{ErrorModule::SPL, 101};
-constexpr ResultCode ResultDecryptionFailed{ErrorModule::SPL, 102};
+constexpr Result ResultInvalidSize{ErrorModule::SPL, 100};
+constexpr Result ResultUnknownSecureMonitorError{ErrorModule::SPL, 101};
+constexpr Result ResultDecryptionFailed{ErrorModule::SPL, 102};
 
-constexpr ResultCode ResultOutOfKeySlots{ErrorModule::SPL, 104};
-constexpr ResultCode ResultInvalidKeySlot{ErrorModule::SPL, 105};
-constexpr ResultCode ResultBootReasonAlreadySet{ErrorModule::SPL, 106};
-constexpr ResultCode ResultBootReasonNotSet{ErrorModule::SPL, 107};
-constexpr ResultCode ResultInvalidArgument{ErrorModule::SPL, 108};
+constexpr Result ResultOutOfKeySlots{ErrorModule::SPL, 104};
+constexpr Result ResultInvalidKeySlot{ErrorModule::SPL, 105};
+constexpr Result ResultBootReasonAlreadySet{ErrorModule::SPL, 106};
+constexpr Result ResultBootReasonNotSet{ErrorModule::SPL, 107};
+constexpr Result ResultInvalidArgument{ErrorModule::SPL, 108};
 
 } // namespace Service::SPL
diff --git a/src/core/hle/service/time/clock_types.h b/src/core/hle/service/time/clock_types.h
index d0af06d94..ef070f32f 100644
--- a/src/core/hle/service/time/clock_types.h
+++ b/src/core/hle/service/time/clock_types.h
@@ -22,7 +22,7 @@ struct SteadyClockTimePoint {
     s64 time_point;
     Common::UUID clock_source_id;
 
-    ResultCode GetSpanBetween(SteadyClockTimePoint other, s64& span) const {
+    Result GetSpanBetween(SteadyClockTimePoint other, s64& span) const {
         span = 0;
 
         if (clock_source_id != other.clock_source_id) {
@@ -92,9 +92,9 @@ struct ClockSnapshot {
     TimeType type;
     INSERT_PADDING_BYTES_NOINIT(0x2);
 
-    static ResultCode GetCurrentTime(s64& current_time,
-                                     const SteadyClockTimePoint& steady_clock_time_point,
-                                     const SystemClockContext& context) {
+    static Result GetCurrentTime(s64& current_time,
+                                 const SteadyClockTimePoint& steady_clock_time_point,
+                                 const SystemClockContext& context) {
         if (steady_clock_time_point.clock_source_id != context.steady_time_point.clock_source_id) {
             current_time = 0;
             return ERROR_TIME_MISMATCH;
diff --git a/src/core/hle/service/time/errors.h b/src/core/hle/service/time/errors.h
index 592921f6b..6655d30e1 100644
--- a/src/core/hle/service/time/errors.h
+++ b/src/core/hle/service/time/errors.h
@@ -7,15 +7,15 @@
 
 namespace Service::Time {
 
-constexpr ResultCode ERROR_PERMISSION_DENIED{ErrorModule::Time, 1};
-constexpr ResultCode ERROR_TIME_MISMATCH{ErrorModule::Time, 102};
-constexpr ResultCode ERROR_UNINITIALIZED_CLOCK{ErrorModule::Time, 103};
-constexpr ResultCode ERROR_TIME_NOT_FOUND{ErrorModule::Time, 200};
-constexpr ResultCode ERROR_OVERFLOW{ErrorModule::Time, 201};
-constexpr ResultCode ERROR_LOCATION_NAME_TOO_LONG{ErrorModule::Time, 801};
-constexpr ResultCode ERROR_OUT_OF_RANGE{ErrorModule::Time, 902};
-constexpr ResultCode ERROR_TIME_ZONE_CONVERSION_FAILED{ErrorModule::Time, 903};
-constexpr ResultCode ERROR_TIME_ZONE_NOT_FOUND{ErrorModule::Time, 989};
-constexpr ResultCode ERROR_NOT_IMPLEMENTED{ErrorModule::Time, 990};
+constexpr Result ERROR_PERMISSION_DENIED{ErrorModule::Time, 1};
+constexpr Result ERROR_TIME_MISMATCH{ErrorModule::Time, 102};
+constexpr Result ERROR_UNINITIALIZED_CLOCK{ErrorModule::Time, 103};
+constexpr Result ERROR_TIME_NOT_FOUND{ErrorModule::Time, 200};
+constexpr Result ERROR_OVERFLOW{ErrorModule::Time, 201};
+constexpr Result ERROR_LOCATION_NAME_TOO_LONG{ErrorModule::Time, 801};
+constexpr Result ERROR_OUT_OF_RANGE{ErrorModule::Time, 902};
+constexpr Result ERROR_TIME_ZONE_CONVERSION_FAILED{ErrorModule::Time, 903};
+constexpr Result ERROR_TIME_ZONE_NOT_FOUND{ErrorModule::Time, 989};
+constexpr Result ERROR_NOT_IMPLEMENTED{ErrorModule::Time, 990};
 
 } // namespace Service::Time
diff --git a/src/core/hle/service/time/local_system_clock_context_writer.h b/src/core/hle/service/time/local_system_clock_context_writer.h
index 0977806b3..1639ef2b9 100644
--- a/src/core/hle/service/time/local_system_clock_context_writer.h
+++ b/src/core/hle/service/time/local_system_clock_context_writer.h
@@ -14,7 +14,7 @@ public:
         : SystemClockContextUpdateCallback{}, shared_memory{shared_memory_} {}
 
 protected:
-    ResultCode Update() override {
+    Result Update() override {
         shared_memory.UpdateLocalSystemClockContext(context);
         return ResultSuccess;
     }
diff --git a/src/core/hle/service/time/network_system_clock_context_writer.h b/src/core/hle/service/time/network_system_clock_context_writer.h
index 975089af8..655e4c06d 100644
--- a/src/core/hle/service/time/network_system_clock_context_writer.h
+++ b/src/core/hle/service/time/network_system_clock_context_writer.h
@@ -15,7 +15,7 @@ public:
         : SystemClockContextUpdateCallback{}, shared_memory{shared_memory_} {}
 
 protected:
-    ResultCode Update() override {
+    Result Update() override {
         shared_memory.UpdateNetworkSystemClockContext(context);
         return ResultSuccess;
     }
diff --git a/src/core/hle/service/time/standard_user_system_clock_core.cpp b/src/core/hle/service/time/standard_user_system_clock_core.cpp
index 508091dc2..b033757ed 100644
--- a/src/core/hle/service/time/standard_user_system_clock_core.cpp
+++ b/src/core/hle/service/time/standard_user_system_clock_core.cpp
@@ -27,9 +27,9 @@ StandardUserSystemClockCore::~StandardUserSystemClockCore() {
     service_context.CloseEvent(auto_correction_event);
 }
 
-ResultCode StandardUserSystemClockCore::SetAutomaticCorrectionEnabled(Core::System& system,
-                                                                      bool value) {
-    if (const ResultCode result{ApplyAutomaticCorrection(system, value)}; result != ResultSuccess) {
+Result StandardUserSystemClockCore::SetAutomaticCorrectionEnabled(Core::System& system,
+                                                                  bool value) {
+    if (const Result result{ApplyAutomaticCorrection(system, value)}; result != ResultSuccess) {
         return result;
     }
 
@@ -38,27 +38,27 @@ ResultCode StandardUserSystemClockCore::SetAutomaticCorrectionEnabled(Core::Syst
     return ResultSuccess;
 }
 
-ResultCode StandardUserSystemClockCore::GetClockContext(Core::System& system,
-                                                        SystemClockContext& ctx) const {
-    if (const ResultCode result{ApplyAutomaticCorrection(system, false)}; result != ResultSuccess) {
+Result StandardUserSystemClockCore::GetClockContext(Core::System& system,
+                                                    SystemClockContext& ctx) const {
+    if (const Result result{ApplyAutomaticCorrection(system, false)}; result != ResultSuccess) {
         return result;
     }
 
     return local_system_clock_core.GetClockContext(system, ctx);
 }
 
-ResultCode StandardUserSystemClockCore::Flush(const SystemClockContext&) {
+Result StandardUserSystemClockCore::Flush(const SystemClockContext&) {
     UNIMPLEMENTED();
     return ERROR_NOT_IMPLEMENTED;
 }
 
-ResultCode StandardUserSystemClockCore::SetClockContext(const SystemClockContext&) {
+Result StandardUserSystemClockCore::SetClockContext(const SystemClockContext&) {
     UNIMPLEMENTED();
     return ERROR_NOT_IMPLEMENTED;
 }
 
-ResultCode StandardUserSystemClockCore::ApplyAutomaticCorrection(Core::System& system,
-                                                                 bool value) const {
+Result StandardUserSystemClockCore::ApplyAutomaticCorrection(Core::System& system,
+                                                             bool value) const {
     if (auto_correction_enabled == value) {
         return ResultSuccess;
     }
@@ -68,7 +68,7 @@ ResultCode StandardUserSystemClockCore::ApplyAutomaticCorrection(Core::System& s
     }
 
     SystemClockContext ctx{};
-    if (const ResultCode result{network_system_clock_core.GetClockContext(system, ctx)};
+    if (const Result result{network_system_clock_core.GetClockContext(system, ctx)};
         result != ResultSuccess) {
         return result;
     }
diff --git a/src/core/hle/service/time/standard_user_system_clock_core.h b/src/core/hle/service/time/standard_user_system_clock_core.h
index 22df23b29..ee6e29487 100644
--- a/src/core/hle/service/time/standard_user_system_clock_core.h
+++ b/src/core/hle/service/time/standard_user_system_clock_core.h
@@ -28,9 +28,9 @@ public:
 
     ~StandardUserSystemClockCore() override;
 
-    ResultCode SetAutomaticCorrectionEnabled(Core::System& system, bool value);
+    Result SetAutomaticCorrectionEnabled(Core::System& system, bool value);
 
-    ResultCode GetClockContext(Core::System& system, SystemClockContext& ctx) const override;
+    Result GetClockContext(Core::System& system, SystemClockContext& ctx) const override;
 
     bool IsAutomaticCorrectionEnabled() const {
         return auto_correction_enabled;
@@ -41,11 +41,11 @@ public:
     }
 
 protected:
-    ResultCode Flush(const SystemClockContext&) override;
+    Result Flush(const SystemClockContext&) override;
 
-    ResultCode SetClockContext(const SystemClockContext&) override;
+    Result SetClockContext(const SystemClockContext&) override;
 
-    ResultCode ApplyAutomaticCorrection(Core::System& system, bool value) const;
+    Result ApplyAutomaticCorrection(Core::System& system, bool value) const;
 
     const SteadyClockTimePoint& GetAutomaticCorrectionUpdatedTime() const {
         return auto_correction_time;
diff --git a/src/core/hle/service/time/system_clock_context_update_callback.cpp b/src/core/hle/service/time/system_clock_context_update_callback.cpp
index 37c140c6f..a649bed3a 100644
--- a/src/core/hle/service/time/system_clock_context_update_callback.cpp
+++ b/src/core/hle/service/time/system_clock_context_update_callback.cpp
@@ -30,8 +30,8 @@ void SystemClockContextUpdateCallback::BroadcastOperationEvent() {
     }
 }
 
-ResultCode SystemClockContextUpdateCallback::Update(const SystemClockContext& value) {
-    ResultCode result{ResultSuccess};
+Result SystemClockContextUpdateCallback::Update(const SystemClockContext& value) {
+    Result result{ResultSuccess};
 
     if (NeedUpdate(value)) {
         context = value;
@@ -47,7 +47,7 @@ ResultCode SystemClockContextUpdateCallback::Update(const SystemClockContext& va
     return result;
 }
 
-ResultCode SystemClockContextUpdateCallback::Update() {
+Result SystemClockContextUpdateCallback::Update() {
     return ResultSuccess;
 }
 
diff --git a/src/core/hle/service/time/system_clock_context_update_callback.h b/src/core/hle/service/time/system_clock_context_update_callback.h
index bee90e329..9c6caf196 100644
--- a/src/core/hle/service/time/system_clock_context_update_callback.h
+++ b/src/core/hle/service/time/system_clock_context_update_callback.h
@@ -28,10 +28,10 @@ public:
 
     void BroadcastOperationEvent();
 
-    ResultCode Update(const SystemClockContext& value);
+    Result Update(const SystemClockContext& value);
 
 protected:
-    virtual ResultCode Update();
+    virtual Result Update();
 
     SystemClockContext context{};
 
diff --git a/src/core/hle/service/time/system_clock_core.cpp b/src/core/hle/service/time/system_clock_core.cpp
index cb132239c..da078241f 100644
--- a/src/core/hle/service/time/system_clock_core.cpp
+++ b/src/core/hle/service/time/system_clock_core.cpp
@@ -14,13 +14,13 @@ SystemClockCore::SystemClockCore(SteadyClockCore& steady_clock_core_)
 
 SystemClockCore::~SystemClockCore() = default;
 
-ResultCode SystemClockCore::GetCurrentTime(Core::System& system, s64& posix_time) const {
+Result SystemClockCore::GetCurrentTime(Core::System& system, s64& posix_time) const {
     posix_time = 0;
 
     const SteadyClockTimePoint current_time_point{steady_clock_core.GetCurrentTimePoint(system)};
 
     SystemClockContext clock_context{};
-    if (const ResultCode result{GetClockContext(system, clock_context)}; result != ResultSuccess) {
+    if (const Result result{GetClockContext(system, clock_context)}; result != ResultSuccess) {
         return result;
     }
 
@@ -33,26 +33,26 @@ ResultCode SystemClockCore::GetCurrentTime(Core::System& system, s64& posix_time
     return ResultSuccess;
 }
 
-ResultCode SystemClockCore::SetCurrentTime(Core::System& system, s64 posix_time) {
+Result SystemClockCore::SetCurrentTime(Core::System& system, s64 posix_time) {
     const SteadyClockTimePoint current_time_point{steady_clock_core.GetCurrentTimePoint(system)};
     const SystemClockContext clock_context{posix_time - current_time_point.time_point,
                                            current_time_point};
 
-    if (const ResultCode result{SetClockContext(clock_context)}; result != ResultSuccess) {
+    if (const Result result{SetClockContext(clock_context)}; result != ResultSuccess) {
         return result;
     }
     return Flush(clock_context);
 }
 
-ResultCode SystemClockCore::Flush(const SystemClockContext& clock_context) {
+Result SystemClockCore::Flush(const SystemClockContext& clock_context) {
     if (!system_clock_context_update_callback) {
         return ResultSuccess;
     }
     return system_clock_context_update_callback->Update(clock_context);
 }
 
-ResultCode SystemClockCore::SetSystemClockContext(const SystemClockContext& clock_context) {
-    if (const ResultCode result{SetClockContext(clock_context)}; result != ResultSuccess) {
+Result SystemClockCore::SetSystemClockContext(const SystemClockContext& clock_context) {
+    if (const Result result{SetClockContext(clock_context)}; result != ResultSuccess) {
         return result;
     }
     return Flush(clock_context);
diff --git a/src/core/hle/service/time/system_clock_core.h b/src/core/hle/service/time/system_clock_core.h
index 76d82f976..8cb34126f 100644
--- a/src/core/hle/service/time/system_clock_core.h
+++ b/src/core/hle/service/time/system_clock_core.h
@@ -29,28 +29,28 @@ public:
         return steady_clock_core;
     }
 
-    ResultCode GetCurrentTime(Core::System& system, s64& posix_time) const;
+    Result GetCurrentTime(Core::System& system, s64& posix_time) const;
 
-    ResultCode SetCurrentTime(Core::System& system, s64 posix_time);
+    Result SetCurrentTime(Core::System& system, s64 posix_time);
 
-    virtual ResultCode GetClockContext([[maybe_unused]] Core::System& system,
-                                       SystemClockContext& value) const {
+    virtual Result GetClockContext([[maybe_unused]] Core::System& system,
+                                   SystemClockContext& value) const {
         value = context;
         return ResultSuccess;
     }
 
-    virtual ResultCode SetClockContext(const SystemClockContext& value) {
+    virtual Result SetClockContext(const SystemClockContext& value) {
         context = value;
         return ResultSuccess;
     }
 
-    virtual ResultCode Flush(const SystemClockContext& clock_context);
+    virtual Result Flush(const SystemClockContext& clock_context);
 
     void SetUpdateCallbackInstance(std::shared_ptr<SystemClockContextUpdateCallback> callback) {
         system_clock_context_update_callback = std::move(callback);
     }
 
-    ResultCode SetSystemClockContext(const SystemClockContext& context);
+    Result SetSystemClockContext(const SystemClockContext& context);
 
     bool IsInitialized() const {
         return is_initialized;
diff --git a/src/core/hle/service/time/time.cpp b/src/core/hle/service/time/time.cpp
index 095fa021c..f77cdbb43 100644
--- a/src/core/hle/service/time/time.cpp
+++ b/src/core/hle/service/time/time.cpp
@@ -43,8 +43,7 @@ private:
         }
 
         s64 posix_time{};
-        if (const ResultCode result{clock_core.GetCurrentTime(system, posix_time)};
-            result.IsError()) {
+        if (const Result result{clock_core.GetCurrentTime(system, posix_time)}; result.IsError()) {
             IPC::ResponseBuilder rb{ctx, 2};
             rb.Push(result);
             return;
@@ -65,7 +64,7 @@ private:
         }
 
         Clock::SystemClockContext system_clock_context{};
-        if (const ResultCode result{clock_core.GetClockContext(system, system_clock_context)};
+        if (const Result result{clock_core.GetClockContext(system, system_clock_context)};
             result.IsError()) {
             IPC::ResponseBuilder rb{ctx, 2};
             rb.Push(result);
@@ -116,7 +115,7 @@ private:
     Clock::SteadyClockCore& clock_core;
 };
 
-ResultCode Module::Interface::GetClockSnapshotFromSystemClockContextInternal(
+Result Module::Interface::GetClockSnapshotFromSystemClockContextInternal(
     Kernel::KThread* thread, Clock::SystemClockContext user_context,
     Clock::SystemClockContext network_context, Clock::TimeType type,
     Clock::ClockSnapshot& clock_snapshot) {
@@ -129,7 +128,7 @@ ResultCode Module::Interface::GetClockSnapshotFromSystemClockContextInternal(
         time_manager.GetStandardUserSystemClockCore().IsAutomaticCorrectionEnabled();
     clock_snapshot.type = type;
 
-    if (const ResultCode result{
+    if (const Result result{
             time_manager.GetTimeZoneContentManager().GetTimeZoneManager().GetDeviceLocationName(
                 clock_snapshot.location_name)};
         result != ResultSuccess) {
@@ -138,7 +137,7 @@ ResultCode Module::Interface::GetClockSnapshotFromSystemClockContextInternal(
 
     clock_snapshot.user_context = user_context;
 
-    if (const ResultCode result{Clock::ClockSnapshot::GetCurrentTime(
+    if (const Result result{Clock::ClockSnapshot::GetCurrentTime(
             clock_snapshot.user_time, clock_snapshot.steady_clock_time_point,
             clock_snapshot.user_context)};
         result != ResultSuccess) {
@@ -146,7 +145,7 @@ ResultCode Module::Interface::GetClockSnapshotFromSystemClockContextInternal(
     }
 
     TimeZone::CalendarInfo userCalendarInfo{};
-    if (const ResultCode result{
+    if (const Result result{
             time_manager.GetTimeZoneContentManager().GetTimeZoneManager().ToCalendarTimeWithMyRules(
                 clock_snapshot.user_time, userCalendarInfo)};
         result != ResultSuccess) {
@@ -165,7 +164,7 @@ ResultCode Module::Interface::GetClockSnapshotFromSystemClockContextInternal(
     }
 
     TimeZone::CalendarInfo networkCalendarInfo{};
-    if (const ResultCode result{
+    if (const Result result{
             time_manager.GetTimeZoneContentManager().GetTimeZoneManager().ToCalendarTimeWithMyRules(
                 clock_snapshot.network_time, networkCalendarInfo)};
         result != ResultSuccess) {
@@ -262,7 +261,7 @@ void Module::Interface::GetClockSnapshot(Kernel::HLERequestContext& ctx) {
     LOG_DEBUG(Service_Time, "called, type={}", type);
 
     Clock::SystemClockContext user_context{};
-    if (const ResultCode result{
+    if (const Result result{
             system.GetTimeManager().GetStandardUserSystemClockCore().GetClockContext(system,
                                                                                      user_context)};
         result.IsError()) {
@@ -272,7 +271,7 @@ void Module::Interface::GetClockSnapshot(Kernel::HLERequestContext& ctx) {
     }
 
     Clock::SystemClockContext network_context{};
-    if (const ResultCode result{
+    if (const Result result{
             system.GetTimeManager().GetStandardNetworkSystemClockCore().GetClockContext(
                 system, network_context)};
         result.IsError()) {
@@ -282,7 +281,7 @@ void Module::Interface::GetClockSnapshot(Kernel::HLERequestContext& ctx) {
     }
 
     Clock::ClockSnapshot clock_snapshot{};
-    if (const ResultCode result{GetClockSnapshotFromSystemClockContextInternal(
+    if (const Result result{GetClockSnapshotFromSystemClockContextInternal(
             &ctx.GetThread(), user_context, network_context, type, clock_snapshot)};
         result.IsError()) {
         IPC::ResponseBuilder rb{ctx, 2};
@@ -308,7 +307,7 @@ void Module::Interface::GetClockSnapshotFromSystemClockContext(Kernel::HLEReques
     LOG_DEBUG(Service_Time, "called, type={}", type);
 
     Clock::ClockSnapshot clock_snapshot{};
-    if (const ResultCode result{GetClockSnapshotFromSystemClockContextInternal(
+    if (const Result result{GetClockSnapshotFromSystemClockContextInternal(
             &ctx.GetThread(), user_context, network_context, type, clock_snapshot)};
         result != ResultSuccess) {
         IPC::ResponseBuilder rb{ctx, 2};
@@ -365,7 +364,7 @@ void Module::Interface::CalculateSpanBetween(Kernel::HLERequestContext& ctx) {
     Clock::TimeSpanType time_span_type{};
     s64 span{};
 
-    if (const ResultCode result{snapshot_a.steady_clock_time_point.GetSpanBetween(
+    if (const Result result{snapshot_a.steady_clock_time_point.GetSpanBetween(
             snapshot_b.steady_clock_time_point, span)};
         result != ResultSuccess) {
         if (snapshot_a.network_time && snapshot_b.network_time) {
diff --git a/src/core/hle/service/time/time.h b/src/core/hle/service/time/time.h
index 017f20a23..76a46cfc7 100644
--- a/src/core/hle/service/time/time.h
+++ b/src/core/hle/service/time/time.h
@@ -36,7 +36,7 @@ public:
         void GetSharedMemoryNativeHandle(Kernel::HLERequestContext& ctx);
 
     private:
-        ResultCode GetClockSnapshotFromSystemClockContextInternal(
+        Result GetClockSnapshotFromSystemClockContextInternal(
             Kernel::KThread* thread, Clock::SystemClockContext user_context,
             Clock::SystemClockContext network_context, Clock::TimeType type,
             Clock::ClockSnapshot& cloc_snapshot);
diff --git a/src/core/hle/service/time/time_zone_content_manager.cpp b/src/core/hle/service/time/time_zone_content_manager.cpp
index 80818eb70..afbfe9715 100644
--- a/src/core/hle/service/time/time_zone_content_manager.cpp
+++ b/src/core/hle/service/time/time_zone_content_manager.cpp
@@ -90,10 +90,10 @@ void TimeZoneContentManager::Initialize(TimeManager& time_manager) {
     }
 }
 
-ResultCode TimeZoneContentManager::LoadTimeZoneRule(TimeZoneRule& rules,
-                                                    const std::string& location_name) const {
+Result TimeZoneContentManager::LoadTimeZoneRule(TimeZoneRule& rules,
+                                                const std::string& location_name) const {
     FileSys::VirtualFile vfs_file;
-    if (const ResultCode result{GetTimeZoneInfoFile(location_name, vfs_file)};
+    if (const Result result{GetTimeZoneInfoFile(location_name, vfs_file)};
         result != ResultSuccess) {
         return result;
     }
@@ -106,8 +106,8 @@ bool TimeZoneContentManager::IsLocationNameValid(const std::string& location_nam
            location_name_cache.end();
 }
 
-ResultCode TimeZoneContentManager::GetTimeZoneInfoFile(const std::string& location_name,
-                                                       FileSys::VirtualFile& vfs_file) const {
+Result TimeZoneContentManager::GetTimeZoneInfoFile(const std::string& location_name,
+                                                   FileSys::VirtualFile& vfs_file) const {
     if (!IsLocationNameValid(location_name)) {
         return ERROR_TIME_NOT_FOUND;
     }
diff --git a/src/core/hle/service/time/time_zone_content_manager.h b/src/core/hle/service/time/time_zone_content_manager.h
index c6c94bcc0..3d94b6428 100644
--- a/src/core/hle/service/time/time_zone_content_manager.h
+++ b/src/core/hle/service/time/time_zone_content_manager.h
@@ -32,12 +32,12 @@ public:
         return time_zone_manager;
     }
 
-    ResultCode LoadTimeZoneRule(TimeZoneRule& rules, const std::string& location_name) const;
+    Result LoadTimeZoneRule(TimeZoneRule& rules, const std::string& location_name) const;
 
 private:
     bool IsLocationNameValid(const std::string& location_name) const;
-    ResultCode GetTimeZoneInfoFile(const std::string& location_name,
-                                   FileSys::VirtualFile& vfs_file) const;
+    Result GetTimeZoneInfoFile(const std::string& location_name,
+                               FileSys::VirtualFile& vfs_file) const;
 
     Core::System& system;
     TimeZoneManager time_zone_manager;
diff --git a/src/core/hle/service/time/time_zone_manager.cpp b/src/core/hle/service/time/time_zone_manager.cpp
index fee05ec7a..2aa675df9 100644
--- a/src/core/hle/service/time/time_zone_manager.cpp
+++ b/src/core/hle/service/time/time_zone_manager.cpp
@@ -666,8 +666,8 @@ static bool ParseTimeZoneBinary(TimeZoneRule& time_zone_rule, FileSys::VirtualFi
     return true;
 }
 
-static ResultCode CreateCalendarTime(s64 time, int gmt_offset, CalendarTimeInternal& calendar_time,
-                                     CalendarAdditionalInfo& calendar_additional_info) {
+static Result CreateCalendarTime(s64 time, int gmt_offset, CalendarTimeInternal& calendar_time,
+                                 CalendarAdditionalInfo& calendar_additional_info) {
     s64 year{epoch_year};
     s64 time_days{time / seconds_per_day};
     s64 remaining_seconds{time % seconds_per_day};
@@ -741,9 +741,9 @@ static ResultCode CreateCalendarTime(s64 time, int gmt_offset, CalendarTimeInter
     return ResultSuccess;
 }
 
-static ResultCode ToCalendarTimeInternal(const TimeZoneRule& rules, s64 time,
-                                         CalendarTimeInternal& calendar_time,
-                                         CalendarAdditionalInfo& calendar_additional_info) {
+static Result ToCalendarTimeInternal(const TimeZoneRule& rules, s64 time,
+                                     CalendarTimeInternal& calendar_time,
+                                     CalendarAdditionalInfo& calendar_additional_info) {
     if ((rules.go_ahead && time < rules.ats[0]) ||
         (rules.go_back && time > rules.ats[rules.time_count - 1])) {
         s64 seconds{};
@@ -766,7 +766,7 @@ static ResultCode ToCalendarTimeInternal(const TimeZoneRule& rules, s64 time,
         if (new_time < rules.ats[0] && new_time > rules.ats[rules.time_count - 1]) {
             return ERROR_TIME_NOT_FOUND;
         }
-        if (const ResultCode result{
+        if (const Result result{
                 ToCalendarTimeInternal(rules, new_time, calendar_time, calendar_additional_info)};
             result != ResultSuccess) {
             return result;
@@ -797,8 +797,8 @@ static ResultCode ToCalendarTimeInternal(const TimeZoneRule& rules, s64 time,
         tti_index = rules.types[low - 1];
     }
 
-    if (const ResultCode result{CreateCalendarTime(time, rules.ttis[tti_index].gmt_offset,
-                                                   calendar_time, calendar_additional_info)};
+    if (const Result result{CreateCalendarTime(time, rules.ttis[tti_index].gmt_offset,
+                                               calendar_time, calendar_additional_info)};
         result != ResultSuccess) {
         return result;
     }
@@ -811,9 +811,9 @@ static ResultCode ToCalendarTimeInternal(const TimeZoneRule& rules, s64 time,
     return ResultSuccess;
 }
 
-static ResultCode ToCalendarTimeImpl(const TimeZoneRule& rules, s64 time, CalendarInfo& calendar) {
+static Result ToCalendarTimeImpl(const TimeZoneRule& rules, s64 time, CalendarInfo& calendar) {
     CalendarTimeInternal calendar_time{};
-    const ResultCode result{
+    const Result result{
         ToCalendarTimeInternal(rules, time, calendar_time, calendar.additional_info)};
     calendar.time.year = static_cast<s16>(calendar_time.year);
 
@@ -830,13 +830,13 @@ static ResultCode ToCalendarTimeImpl(const TimeZoneRule& rules, s64 time, Calend
 TimeZoneManager::TimeZoneManager() = default;
 TimeZoneManager::~TimeZoneManager() = default;
 
-ResultCode TimeZoneManager::ToCalendarTime(const TimeZoneRule& rules, s64 time,
-                                           CalendarInfo& calendar) const {
+Result TimeZoneManager::ToCalendarTime(const TimeZoneRule& rules, s64 time,
+                                       CalendarInfo& calendar) const {
     return ToCalendarTimeImpl(rules, time, calendar);
 }
 
-ResultCode TimeZoneManager::SetDeviceLocationNameWithTimeZoneRule(const std::string& location_name,
-                                                                  FileSys::VirtualFile& vfs_file) {
+Result TimeZoneManager::SetDeviceLocationNameWithTimeZoneRule(const std::string& location_name,
+                                                              FileSys::VirtualFile& vfs_file) {
     TimeZoneRule rule{};
     if (ParseTimeZoneBinary(rule, vfs_file)) {
         device_location_name = location_name;
@@ -846,12 +846,12 @@ ResultCode TimeZoneManager::SetDeviceLocationNameWithTimeZoneRule(const std::str
     return ERROR_TIME_ZONE_CONVERSION_FAILED;
 }
 
-ResultCode TimeZoneManager::SetUpdatedTime(const Clock::SteadyClockTimePoint& value) {
+Result TimeZoneManager::SetUpdatedTime(const Clock::SteadyClockTimePoint& value) {
     time_zone_update_time_point = value;
     return ResultSuccess;
 }
 
-ResultCode TimeZoneManager::ToCalendarTimeWithMyRules(s64 time, CalendarInfo& calendar) const {
+Result TimeZoneManager::ToCalendarTimeWithMyRules(s64 time, CalendarInfo& calendar) const {
     if (is_initialized) {
         return ToCalendarTime(time_zone_rule, time, calendar);
     } else {
@@ -859,16 +859,16 @@ ResultCode TimeZoneManager::ToCalendarTimeWithMyRules(s64 time, CalendarInfo& ca
     }
 }
 
-ResultCode TimeZoneManager::ParseTimeZoneRuleBinary(TimeZoneRule& rules,
-                                                    FileSys::VirtualFile& vfs_file) const {
+Result TimeZoneManager::ParseTimeZoneRuleBinary(TimeZoneRule& rules,
+                                                FileSys::VirtualFile& vfs_file) const {
     if (!ParseTimeZoneBinary(rules, vfs_file)) {
         return ERROR_TIME_ZONE_CONVERSION_FAILED;
     }
     return ResultSuccess;
 }
 
-ResultCode TimeZoneManager::ToPosixTime(const TimeZoneRule& rules,
-                                        const CalendarTime& calendar_time, s64& posix_time) const {
+Result TimeZoneManager::ToPosixTime(const TimeZoneRule& rules, const CalendarTime& calendar_time,
+                                    s64& posix_time) const {
     posix_time = 0;
 
     CalendarTimeInternal internal_time{
@@ -1020,8 +1020,8 @@ ResultCode TimeZoneManager::ToPosixTime(const TimeZoneRule& rules,
     return ResultSuccess;
 }
 
-ResultCode TimeZoneManager::ToPosixTimeWithMyRule(const CalendarTime& calendar_time,
-                                                  s64& posix_time) const {
+Result TimeZoneManager::ToPosixTimeWithMyRule(const CalendarTime& calendar_time,
+                                              s64& posix_time) const {
     if (is_initialized) {
         return ToPosixTime(time_zone_rule, calendar_time, posix_time);
     }
@@ -1029,7 +1029,7 @@ ResultCode TimeZoneManager::ToPosixTimeWithMyRule(const CalendarTime& calendar_t
     return ERROR_UNINITIALIZED_CLOCK;
 }
 
-ResultCode TimeZoneManager::GetDeviceLocationName(LocationName& value) const {
+Result TimeZoneManager::GetDeviceLocationName(LocationName& value) const {
     if (!is_initialized) {
         return ERROR_UNINITIALIZED_CLOCK;
     }
diff --git a/src/core/hle/service/time/time_zone_manager.h b/src/core/hle/service/time/time_zone_manager.h
index 8c1b19f81..5ebd4035e 100644
--- a/src/core/hle/service/time/time_zone_manager.h
+++ b/src/core/hle/service/time/time_zone_manager.h
@@ -29,16 +29,16 @@ public:
         is_initialized = true;
     }
 
-    ResultCode SetDeviceLocationNameWithTimeZoneRule(const std::string& location_name,
-                                                     FileSys::VirtualFile& vfs_file);
-    ResultCode SetUpdatedTime(const Clock::SteadyClockTimePoint& value);
-    ResultCode GetDeviceLocationName(TimeZone::LocationName& value) const;
-    ResultCode ToCalendarTime(const TimeZoneRule& rules, s64 time, CalendarInfo& calendar) const;
-    ResultCode ToCalendarTimeWithMyRules(s64 time, CalendarInfo& calendar) const;
-    ResultCode ParseTimeZoneRuleBinary(TimeZoneRule& rules, FileSys::VirtualFile& vfs_file) const;
-    ResultCode ToPosixTime(const TimeZoneRule& rules, const CalendarTime& calendar_time,
-                           s64& posix_time) const;
-    ResultCode ToPosixTimeWithMyRule(const CalendarTime& calendar_time, s64& posix_time) const;
+    Result SetDeviceLocationNameWithTimeZoneRule(const std::string& location_name,
+                                                 FileSys::VirtualFile& vfs_file);
+    Result SetUpdatedTime(const Clock::SteadyClockTimePoint& value);
+    Result GetDeviceLocationName(TimeZone::LocationName& value) const;
+    Result ToCalendarTime(const TimeZoneRule& rules, s64 time, CalendarInfo& calendar) const;
+    Result ToCalendarTimeWithMyRules(s64 time, CalendarInfo& calendar) const;
+    Result ParseTimeZoneRuleBinary(TimeZoneRule& rules, FileSys::VirtualFile& vfs_file) const;
+    Result ToPosixTime(const TimeZoneRule& rules, const CalendarTime& calendar_time,
+                       s64& posix_time) const;
+    Result ToPosixTimeWithMyRule(const CalendarTime& calendar_time, s64& posix_time) const;
 
 private:
     bool is_initialized{};
diff --git a/src/core/hle/service/time/time_zone_service.cpp b/src/core/hle/service/time/time_zone_service.cpp
index cbf0ef6fa..961040bfc 100644
--- a/src/core/hle/service/time/time_zone_service.cpp
+++ b/src/core/hle/service/time/time_zone_service.cpp
@@ -32,7 +32,7 @@ void ITimeZoneService::GetDeviceLocationName(Kernel::HLERequestContext& ctx) {
     LOG_DEBUG(Service_Time, "called");
 
     TimeZone::LocationName location_name{};
-    if (const ResultCode result{
+    if (const Result result{
             time_zone_content_manager.GetTimeZoneManager().GetDeviceLocationName(location_name)};
         result != ResultSuccess) {
         IPC::ResponseBuilder rb{ctx, 2};
@@ -61,7 +61,7 @@ void ITimeZoneService::LoadTimeZoneRule(Kernel::HLERequestContext& ctx) {
     LOG_DEBUG(Service_Time, "called, location_name={}", location_name);
 
     TimeZone::TimeZoneRule time_zone_rule{};
-    if (const ResultCode result{
+    if (const Result result{
             time_zone_content_manager.LoadTimeZoneRule(time_zone_rule, location_name)};
         result != ResultSuccess) {
         IPC::ResponseBuilder rb{ctx, 2};
@@ -88,7 +88,7 @@ void ITimeZoneService::ToCalendarTime(Kernel::HLERequestContext& ctx) {
     std::memcpy(&time_zone_rule, buffer.data(), buffer.size());
 
     TimeZone::CalendarInfo calendar_info{};
-    if (const ResultCode result{time_zone_content_manager.GetTimeZoneManager().ToCalendarTime(
+    if (const Result result{time_zone_content_manager.GetTimeZoneManager().ToCalendarTime(
             time_zone_rule, posix_time, calendar_info)};
         result != ResultSuccess) {
         IPC::ResponseBuilder rb{ctx, 2};
@@ -108,7 +108,7 @@ void ITimeZoneService::ToCalendarTimeWithMyRule(Kernel::HLERequestContext& ctx)
     LOG_DEBUG(Service_Time, "called, posix_time=0x{:016X}", posix_time);
 
     TimeZone::CalendarInfo calendar_info{};
-    if (const ResultCode result{
+    if (const Result result{
             time_zone_content_manager.GetTimeZoneManager().ToCalendarTimeWithMyRules(
                 posix_time, calendar_info)};
         result != ResultSuccess) {
@@ -131,7 +131,7 @@ void ITimeZoneService::ToPosixTime(Kernel::HLERequestContext& ctx) {
     std::memcpy(&time_zone_rule, ctx.ReadBuffer().data(), sizeof(TimeZone::TimeZoneRule));
 
     s64 posix_time{};
-    if (const ResultCode result{time_zone_content_manager.GetTimeZoneManager().ToPosixTime(
+    if (const Result result{time_zone_content_manager.GetTimeZoneManager().ToPosixTime(
             time_zone_rule, calendar_time, posix_time)};
         result != ResultSuccess) {
         IPC::ResponseBuilder rb{ctx, 2};
@@ -154,9 +154,8 @@ void ITimeZoneService::ToPosixTimeWithMyRule(Kernel::HLERequestContext& ctx) {
     const auto calendar_time{rp.PopRaw<TimeZone::CalendarTime>()};
 
     s64 posix_time{};
-    if (const ResultCode result{
-            time_zone_content_manager.GetTimeZoneManager().ToPosixTimeWithMyRule(calendar_time,
-                                                                                 posix_time)};
+    if (const Result result{time_zone_content_manager.GetTimeZoneManager().ToPosixTimeWithMyRule(
+            calendar_time, posix_time)};
         result != ResultSuccess) {
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(result);
diff --git a/src/core/hle/service/vi/vi.cpp b/src/core/hle/service/vi/vi.cpp
index a7b53d7dc..546879648 100644
--- a/src/core/hle/service/vi/vi.cpp
+++ b/src/core/hle/service/vi/vi.cpp
@@ -34,10 +34,10 @@
 
 namespace Service::VI {
 
-constexpr ResultCode ERR_OPERATION_FAILED{ErrorModule::VI, 1};
-constexpr ResultCode ERR_PERMISSION_DENIED{ErrorModule::VI, 5};
-constexpr ResultCode ERR_UNSUPPORTED{ErrorModule::VI, 6};
-constexpr ResultCode ERR_NOT_FOUND{ErrorModule::VI, 7};
+constexpr Result ERR_OPERATION_FAILED{ErrorModule::VI, 1};
+constexpr Result ERR_PERMISSION_DENIED{ErrorModule::VI, 5};
+constexpr Result ERR_UNSUPPORTED{ErrorModule::VI, 6};
+constexpr Result ERR_NOT_FOUND{ErrorModule::VI, 7};
 
 struct DisplayInfo {
     /// The name of this particular display.