106 files changed, 2992 insertions, 485 deletions

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index a88551fbc..f69d00a2b 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -13,3 +13,6 @@ endif()
 if (ENABLE_QT)
     add_subdirectory(yuzu)
 endif()
+if (ENABLE_WEB_SERVICE)
+    add_subdirectory(web_service)
+endif()
diff --git a/src/common/CMakeLists.txt b/src/common/CMakeLists.txt
index 6a3f1fe08..d0e506689 100644
--- a/src/common/CMakeLists.txt
+++ b/src/common/CMakeLists.txt
@@ -29,7 +29,7 @@ if ($ENV{CI})
       if (BUILD_VERSION)
         # This leaves a trailing space on the last word, but we actually want that
         # because of how it's styled in the title bar.
-        set(BUILD_FULLNAME "${REPO_NAME} #${BUILD_VERSION} ")
+        set(BUILD_FULLNAME "${REPO_NAME} ${BUILD_VERSION} ")
       else()
         set(BUILD_FULLNAME "")
       endif()
@@ -41,6 +41,8 @@ configure_file("${CMAKE_CURRENT_SOURCE_DIR}/scm_rev.cpp.in" "${CMAKE_CURRENT_SOU
 add_library(common STATIC
     alignment.h
     assert.h
+    detached_tasks.cpp
+    detached_tasks.h
     bit_field.h
     bit_set.h
     cityhash.cpp
@@ -87,6 +89,7 @@ add_library(common STATIC
     timer.cpp
     timer.h
     vector_math.h
+    web_result.h
 )
 
 if(ARCHITECTURE_x86_64)
diff --git a/src/common/detached_tasks.cpp b/src/common/detached_tasks.cpp
new file mode 100644
index 000000000..a347d9e02
--- /dev/null
+++ b/src/common/detached_tasks.cpp
@@ -0,0 +1,41 @@
+// Copyright 2018 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <thread>
+#include "common/assert.h"
+#include "common/detached_tasks.h"
+
+namespace Common {
+
+DetachedTasks* DetachedTasks::instance = nullptr;
+
+DetachedTasks::DetachedTasks() {
+    ASSERT(instance == nullptr);
+    instance = this;
+}
+
+void DetachedTasks::WaitForAllTasks() {
+    std::unique_lock<std::mutex> lock(mutex);
+    cv.wait(lock, [this]() { return count == 0; });
+}
+
+DetachedTasks::~DetachedTasks() {
+    std::unique_lock<std::mutex> lock(mutex);
+    ASSERT(count == 0);
+    instance = nullptr;
+}
+
+void DetachedTasks::AddTask(std::function<void()> task) {
+    std::unique_lock<std::mutex> lock(instance->mutex);
+    ++instance->count;
+    std::thread([task{std::move(task)}]() {
+        task();
+        std::unique_lock<std::mutex> lock(instance->mutex);
+        --instance->count;
+        std::notify_all_at_thread_exit(instance->cv, std::move(lock));
+    })
+        .detach();
+}
+
+} // namespace Common
diff --git a/src/common/detached_tasks.h b/src/common/detached_tasks.h
new file mode 100644
index 000000000..5dd8fc27b
--- /dev/null
+++ b/src/common/detached_tasks.h
@@ -0,0 +1,40 @@
+// Copyright 2018 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <condition_variable>
+#include <functional>
+
+namespace Common {
+
+/**
+ * A background manager which ensures that all detached task is finished before program exits.
+ *
+ * Some tasks, telemetry submission for example, prefer executing asynchronously and don't care
+ * about the result. These tasks are suitable for std::thread::detach(). However, this is unsafe if
+ * the task is launched just before the program exits (which is a common case for telemetry), so we
+ * need to block on these tasks on program exit.
+ *
+ * To make detached task safe, a single DetachedTasks object should be placed in the main(), and
+ * call WaitForAllTasks() after all program execution but before global/static variable destruction.
+ * Any potentially unsafe detached task should be executed via DetachedTasks::AddTask.
+ */
+class DetachedTasks {
+public:
+    DetachedTasks();
+    ~DetachedTasks();
+    void WaitForAllTasks();
+
+    static void AddTask(std::function<void()> task);
+
+private:
+    static DetachedTasks* instance;
+
+    std::condition_variable cv;
+    std::mutex mutex;
+    int count = 0;
+};
+
+} // namespace Common
diff --git a/src/common/logging/text_formatter.cpp b/src/common/logging/text_formatter.cpp
index 05437c137..6a0605c63 100644
--- a/src/common/logging/text_formatter.cpp
+++ b/src/common/logging/text_formatter.cpp
@@ -31,7 +31,7 @@ std::string FormatLogMessage(const Entry& entry) {
 }
 
 void PrintMessage(const Entry& entry) {
-    auto str = FormatLogMessage(entry) + '\n';
+    const auto str = FormatLogMessage(entry).append(1, '\n');
     fputs(str.c_str(), stderr);
 }
 
diff --git a/src/common/param_package.cpp b/src/common/param_package.cpp
index 9526ca0c6..b916b4866 100644
--- a/src/common/param_package.cpp
+++ b/src/common/param_package.cpp
@@ -20,7 +20,15 @@ constexpr char KEY_VALUE_SEPARATOR_ESCAPE[] = "$0";
 constexpr char PARAM_SEPARATOR_ESCAPE[] = "$1";
 constexpr char ESCAPE_CHARACTER_ESCAPE[] = "$2";
 
+/// A placeholder for empty param packages to avoid empty strings
+/// (they may be recognized as "not set" by some frontend libraries like qt)
+constexpr char EMPTY_PLACEHOLDER[] = "[empty]";
+
 ParamPackage::ParamPackage(const std::string& serialized) {
+    if (serialized == EMPTY_PLACEHOLDER) {
+        return;
+    }
+
     std::vector<std::string> pairs;
     Common::SplitString(serialized, PARAM_SEPARATOR, pairs);
 
@@ -46,7 +54,7 @@ ParamPackage::ParamPackage(std::initializer_list<DataType::value_type> list) : d
 
 std::string ParamPackage::Serialize() const {
     if (data.empty())
-        return "";
+        return EMPTY_PLACEHOLDER;
 
     std::string result;
 
@@ -120,4 +128,12 @@ bool ParamPackage::Has(const std::string& key) const {
     return data.find(key) != data.end();
 }
 
+void ParamPackage::Erase(const std::string& key) {
+    data.erase(key);
+}
+
+void ParamPackage::Clear() {
+    data.clear();
+}
+
 } // namespace Common
diff --git a/src/common/param_package.h b/src/common/param_package.h
index 7842cd4ef..6a0a9b656 100644
--- a/src/common/param_package.h
+++ b/src/common/param_package.h
@@ -32,6 +32,8 @@ public:
     void Set(const std::string& key, int value);
     void Set(const std::string& key, float value);
     bool Has(const std::string& key) const;
+    void Erase(const std::string& key);
+    void Clear();
 
 private:
     DataType data;
diff --git a/src/common/web_result.h b/src/common/web_result.h
new file mode 100644
index 000000000..969926674
--- /dev/null
+++ b/src/common/web_result.h
@@ -0,0 +1,24 @@
+// Copyright 2018 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <string>
+
+namespace Common {
+struct WebResult {
+    enum class Code : u32 {
+        Success,
+        InvalidURL,
+        CredentialsMissing,
+        LibError,
+        HttpError,
+        WrongContent,
+        NoWebservice,
+    };
+    Code result_code;
+    std::string result_string;
+    std::string returned_data;
+};
+} // namespace Common
diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt
index a98dbb9ab..e4a676e91 100644
--- a/src/core/CMakeLists.txt
+++ b/src/core/CMakeLists.txt
@@ -396,6 +396,10 @@ create_target_directory_groups(core)
 
 target_link_libraries(core PUBLIC common PRIVATE audio_core video_core)
 target_link_libraries(core PUBLIC Boost::boost PRIVATE fmt lz4_static mbedtls opus unicorn open_source_archives)
+if (ENABLE_WEB_SERVICE)
+    add_definitions(-DENABLE_WEB_SERVICE)
+    target_link_libraries(core PUBLIC json-headers web_service)
+endif()
 
 if (ARCHITECTURE_x86_64)
     target_sources(core PRIVATE
diff --git a/src/core/arm/dynarmic/arm_dynarmic.cpp b/src/core/arm/dynarmic/arm_dynarmic.cpp
index 05cc84458..7e978cf7a 100644
--- a/src/core/arm/dynarmic/arm_dynarmic.cpp
+++ b/src/core/arm/dynarmic/arm_dynarmic.cpp
@@ -86,7 +86,7 @@ public:
                 parent.jit->HaltExecution();
                 parent.SetPC(pc);
                 Kernel::Thread* thread = Kernel::GetCurrentThread();
-                parent.SaveContext(thread->context);
+                parent.SaveContext(thread->GetContext());
                 GDBStub::Break();
                 GDBStub::SendTrap(thread, 5);
                 return;
diff --git a/src/core/arm/unicorn/arm_unicorn.cpp b/src/core/arm/unicorn/arm_unicorn.cpp
index e218a0b15..ded4dd359 100644
--- a/src/core/arm/unicorn/arm_unicorn.cpp
+++ b/src/core/arm/unicorn/arm_unicorn.cpp
@@ -195,7 +195,7 @@ void ARM_Unicorn::ExecuteInstructions(int num_instructions) {
             uc_reg_write(uc, UC_ARM64_REG_PC, &last_bkpt.address);
         }
         Kernel::Thread* thread = Kernel::GetCurrentThread();
-        SaveContext(thread->context);
+        SaveContext(thread->GetContext());
         if (last_bkpt_hit || GDBStub::GetCpuStepFlag()) {
             last_bkpt_hit = false;
             GDBStub::Break();
diff --git a/src/core/file_sys/patch_manager.cpp b/src/core/file_sys/patch_manager.cpp
index ab2e5e43d..7b31a57a4 100644
--- a/src/core/file_sys/patch_manager.cpp
+++ b/src/core/file_sys/patch_manager.cpp
@@ -204,8 +204,8 @@ static void ApplyLayeredFS(VirtualFile& romfs, u64 title_id, ContentRecordType t
     romfs = std::move(packed);
 }
 
-VirtualFile PatchManager::PatchRomFS(VirtualFile romfs, u64 ivfc_offset,
-                                     ContentRecordType type) const {
+VirtualFile PatchManager::PatchRomFS(VirtualFile romfs, u64 ivfc_offset, ContentRecordType type,
+                                     VirtualFile update_raw) const {
     LOG_INFO(Loader, "Patching RomFS for title_id={:016X}, type={:02X}", title_id,
              static_cast<u8>(type));
 
@@ -225,6 +225,13 @@ VirtualFile PatchManager::PatchRomFS(VirtualFile romfs, u64 ivfc_offset,
                      FormatTitleVersion(installed->GetEntryVersion(update_tid).get_value_or(0)));
             romfs = new_nca->GetRomFS();
         }
+    } else if (update_raw != nullptr) {
+        const auto new_nca = std::make_shared<NCA>(update_raw, romfs, ivfc_offset);
+        if (new_nca->GetStatus() == Loader::ResultStatus::Success &&
+            new_nca->GetRomFS() != nullptr) {
+            LOG_INFO(Loader, "    RomFS: Update (PACKED) applied successfully");
+            romfs = new_nca->GetRomFS();
+        }
     }
 
     // LayeredFS
@@ -244,7 +251,8 @@ static bool IsDirValidAndNonEmpty(const VirtualDir& dir) {
     return dir != nullptr && (!dir->GetFiles().empty() || !dir->GetSubdirectories().empty());
 }
 
-std::map<std::string, std::string, std::less<>> PatchManager::GetPatchVersionNames() const {
+std::map<std::string, std::string, std::less<>> PatchManager::GetPatchVersionNames(
+    VirtualFile update_raw) const {
     std::map<std::string, std::string, std::less<>> out;
     const auto installed = Service::FileSystem::GetUnionContents();
 
@@ -265,6 +273,8 @@ std::map<std::string, std::string, std::less<>> PatchManager::GetPatchVersionNam
                     "Update",
                     FormatTitleVersion(meta_ver.get(), TitleVersionFormat::ThreeElements));
             }
+        } else if (update_raw != nullptr) {
+            out.insert_or_assign("Update", "PACKED");
         }
     }
 
diff --git a/src/core/file_sys/patch_manager.h b/src/core/file_sys/patch_manager.h
index 66fdba148..eb6fc4607 100644
--- a/src/core/file_sys/patch_manager.h
+++ b/src/core/file_sys/patch_manager.h
@@ -47,11 +47,13 @@ public:
     // - Game Updates
     // - LayeredFS
     VirtualFile PatchRomFS(VirtualFile base, u64 ivfc_offset,
-                           ContentRecordType type = ContentRecordType::Program) const;
+                           ContentRecordType type = ContentRecordType::Program,
+                           VirtualFile update_raw = nullptr) const;
 
     // Returns a vector of pairs between patch names and patch versions.
     // i.e. Update 3.2.2 will return {"Update", "3.2.2"}
-    std::map<std::string, std::string, std::less<>> GetPatchVersionNames() const;
+    std::map<std::string, std::string, std::less<>> GetPatchVersionNames(
+        VirtualFile update_raw = nullptr) const;
 
     // Given title_id of the program, attempts to get the control data of the update and parse it,
     // falling back to the base control data.
diff --git a/src/core/file_sys/romfs_factory.cpp b/src/core/file_sys/romfs_factory.cpp
index 4994c2532..0b645b106 100644
--- a/src/core/file_sys/romfs_factory.cpp
+++ b/src/core/file_sys/romfs_factory.cpp
@@ -30,12 +30,17 @@ RomFSFactory::RomFSFactory(Loader::AppLoader& app_loader) {
 
 RomFSFactory::~RomFSFactory() = default;
 
+void RomFSFactory::SetPackedUpdate(VirtualFile update_raw) {
+    this->update_raw = std::move(update_raw);
+}
+
 ResultVal<VirtualFile> RomFSFactory::OpenCurrentProcess() {
     if (!updatable)
         return MakeResult<VirtualFile>(file);
 
     const PatchManager patch_manager(Core::CurrentProcess()->GetTitleID());
-    return MakeResult<VirtualFile>(patch_manager.PatchRomFS(file, ivfc_offset));
+    return MakeResult<VirtualFile>(
+        patch_manager.PatchRomFS(file, ivfc_offset, ContentRecordType::Program, update_raw));
 }
 
 ResultVal<VirtualFile> RomFSFactory::Open(u64 title_id, StorageId storage, ContentRecordType type) {
diff --git a/src/core/file_sys/romfs_factory.h b/src/core/file_sys/romfs_factory.h
index 2cace8180..7724c0b23 100644
--- a/src/core/file_sys/romfs_factory.h
+++ b/src/core/file_sys/romfs_factory.h
@@ -32,11 +32,13 @@ public:
     explicit RomFSFactory(Loader::AppLoader& app_loader);
     ~RomFSFactory();
 
+    void SetPackedUpdate(VirtualFile update_raw);
     ResultVal<VirtualFile> OpenCurrentProcess();
     ResultVal<VirtualFile> Open(u64 title_id, StorageId storage, ContentRecordType type);
 
 private:
     VirtualFile file;
+    VirtualFile update_raw;
     bool updatable;
     u64 ivfc_offset;
 };
diff --git a/src/core/file_sys/submission_package.cpp b/src/core/file_sys/submission_package.cpp
index 09bf077cd..ab5dc900c 100644
--- a/src/core/file_sys/submission_package.cpp
+++ b/src/core/file_sys/submission_package.cpp
@@ -259,8 +259,11 @@ void NSP::ReadNCAs(const std::vector<VirtualFile>& files) {
                 auto next_nca = std::make_shared<NCA>(next_file);
                 if (next_nca->GetType() == NCAContentType::Program)
                     program_status[cnmt.GetTitleID()] = next_nca->GetStatus();
-                if (next_nca->GetStatus() == Loader::ResultStatus::Success)
+                if (next_nca->GetStatus() == Loader::ResultStatus::Success ||
+                    (next_nca->GetStatus() == Loader::ResultStatus::ErrorMissingBKTRBaseRomFS &&
+                     (cnmt.GetTitleID() & 0x800) != 0)) {
                     ncas_title[rec.type] = std::move(next_nca);
+                }
             }
 
             break;
diff --git a/src/core/gdbstub/gdbstub.cpp b/src/core/gdbstub/gdbstub.cpp
index 5bc947010..e961ef121 100644
--- a/src/core/gdbstub/gdbstub.cpp
+++ b/src/core/gdbstub/gdbstub.cpp
@@ -209,7 +209,7 @@ static Kernel::Thread* FindThreadById(int id) {
     for (u32 core = 0; core < Core::NUM_CPU_CORES; core++) {
         const auto& threads = Core::System::GetInstance().Scheduler(core)->GetThreadList();
         for (auto& thread : threads) {
-            if (thread->GetThreadId() == static_cast<u32>(id)) {
+            if (thread->GetThreadID() == static_cast<u32>(id)) {
                 current_core = core;
                 return thread.get();
             }
@@ -223,16 +223,18 @@ static u64 RegRead(std::size_t id, Kernel::Thread* thread = nullptr) {
         return 0;
     }
 
+    const auto& thread_context = thread->GetContext();
+
     if (id < SP_REGISTER) {
-        return thread->context.cpu_registers[id];
+        return thread_context.cpu_registers[id];
     } else if (id == SP_REGISTER) {
-        return thread->context.sp;
+        return thread_context.sp;
     } else if (id == PC_REGISTER) {
-        return thread->context.pc;
+        return thread_context.pc;
     } else if (id == PSTATE_REGISTER) {
-        return thread->context.pstate;
+        return thread_context.pstate;
     } else if (id > PSTATE_REGISTER && id < FPCR_REGISTER) {
-        return thread->context.vector_registers[id - UC_ARM64_REG_Q0][0];
+        return thread_context.vector_registers[id - UC_ARM64_REG_Q0][0];
     } else {
         return 0;
     }
@@ -243,16 +245,18 @@ static void RegWrite(std::size_t id, u64 val, Kernel::Thread* thread = nullptr)
         return;
     }
 
+    auto& thread_context = thread->GetContext();
+
     if (id < SP_REGISTER) {
-        thread->context.cpu_registers[id] = val;
+        thread_context.cpu_registers[id] = val;
     } else if (id == SP_REGISTER) {
-        thread->context.sp = val;
+        thread_context.sp = val;
     } else if (id == PC_REGISTER) {
-        thread->context.pc = val;
+        thread_context.pc = val;
     } else if (id == PSTATE_REGISTER) {
-        thread->context.pstate = static_cast<u32>(val);
+        thread_context.pstate = static_cast<u32>(val);
     } else if (id > PSTATE_REGISTER && id < FPCR_REGISTER) {
-        thread->context.vector_registers[id - (PSTATE_REGISTER + 1)][0] = val;
+        thread_context.vector_registers[id - (PSTATE_REGISTER + 1)][0] = val;
     }
 }
 
@@ -595,7 +599,7 @@ static void HandleQuery() {
         for (u32 core = 0; core < Core::NUM_CPU_CORES; core++) {
             const auto& threads = Core::System::GetInstance().Scheduler(core)->GetThreadList();
             for (const auto& thread : threads) {
-                val += fmt::format("{:x}", thread->GetThreadId());
+                val += fmt::format("{:x}", thread->GetThreadID());
                 val += ",";
             }
         }
@@ -612,7 +616,7 @@ static void HandleQuery() {
             for (const auto& thread : threads) {
                 buffer +=
                     fmt::format(R"*(<thread id="{:x}" core="{:d}" name="Thread {:x}"></thread>)*",
-                                thread->GetThreadId(), core, thread->GetThreadId());
+                                thread->GetThreadID(), core, thread->GetThreadID());
             }
         }
         buffer += "</threads>";
@@ -693,7 +697,7 @@ static void SendSignal(Kernel::Thread* thread, u32 signal, bool full = true) {
     }
 
     if (thread) {
-        buffer += fmt::format(";thread:{:x};", thread->GetThreadId());
+        buffer += fmt::format(";thread:{:x};", thread->GetThreadID());
     }
 
     SendReply(buffer.c_str());
@@ -857,7 +861,9 @@ static void WriteRegister() {
     }
 
     // Update Unicorn context skipping scheduler, no running threads at this point
-    Core::System::GetInstance().ArmInterface(current_core).LoadContext(current_thread->context);
+    Core::System::GetInstance()
+        .ArmInterface(current_core)
+        .LoadContext(current_thread->GetContext());
 
     SendReply("OK");
 }
@@ -886,7 +892,9 @@ static void WriteRegisters() {
     }
 
     // Update Unicorn context skipping scheduler, no running threads at this point
-    Core::System::GetInstance().ArmInterface(current_core).LoadContext(current_thread->context);
+    Core::System::GetInstance()
+        .ArmInterface(current_core)
+        .LoadContext(current_thread->GetContext());
 
     SendReply("OK");
 }
@@ -960,7 +968,9 @@ static void Step() {
     if (command_length > 1) {
         RegWrite(PC_REGISTER, GdbHexToLong(command_buffer + 1), current_thread);
         // Update Unicorn context skipping scheduler, no running threads at this point
-        Core::System::GetInstance().ArmInterface(current_core).LoadContext(current_thread->context);
+        Core::System::GetInstance()
+            .ArmInterface(current_core)
+            .LoadContext(current_thread->GetContext());
     }
     step_loop = true;
     halt_loop = true;
diff --git a/src/core/hle/kernel/address_arbiter.cpp b/src/core/hle/kernel/address_arbiter.cpp
index 93577591f..ebf193930 100644
--- a/src/core/hle/kernel/address_arbiter.cpp
+++ b/src/core/hle/kernel/address_arbiter.cpp
@@ -23,13 +23,13 @@ namespace AddressArbiter {
 // Performs actual address waiting logic.
 static ResultCode WaitForAddress(VAddr address, s64 timeout) {
     SharedPtr<Thread> current_thread = GetCurrentThread();
-    current_thread->arb_wait_address = address;
-    current_thread->status = ThreadStatus::WaitArb;
-    current_thread->wakeup_callback = nullptr;
+    current_thread->SetArbiterWaitAddress(address);
+    current_thread->SetStatus(ThreadStatus::WaitArb);
+    current_thread->InvalidateWakeupCallback();
 
     current_thread->WakeAfterDelay(timeout);
 
-    Core::System::GetInstance().CpuCore(current_thread->processor_id).PrepareReschedule();
+    Core::System::GetInstance().CpuCore(current_thread->GetProcessorID()).PrepareReschedule();
     return RESULT_TIMEOUT;
 }
 
@@ -39,10 +39,10 @@ static std::vector<SharedPtr<Thread>> GetThreadsWaitingOnAddress(VAddr address)
                                            std::vector<SharedPtr<Thread>>& waiting_threads,
                                            VAddr arb_addr) {
         const auto& scheduler = Core::System::GetInstance().Scheduler(core_index);
-        auto& thread_list = scheduler->GetThreadList();
+        const auto& thread_list = scheduler->GetThreadList();
 
-        for (auto& thread : thread_list) {
-            if (thread->arb_wait_address == arb_addr)
+        for (const auto& thread : thread_list) {
+            if (thread->GetArbiterWaitAddress() == arb_addr)
                 waiting_threads.push_back(thread);
         }
     };
@@ -57,7 +57,7 @@ static std::vector<SharedPtr<Thread>> GetThreadsWaitingOnAddress(VAddr address)
     // Sort them by priority, such that the highest priority ones come first.
     std::sort(threads.begin(), threads.end(),
               [](const SharedPtr<Thread>& lhs, const SharedPtr<Thread>& rhs) {
-                  return lhs->current_priority < rhs->current_priority;
+                  return lhs->GetPriority() < rhs->GetPriority();
               });
 
     return threads;
@@ -73,9 +73,9 @@ static void WakeThreads(std::vector<SharedPtr<Thread>>& waiting_threads, s32 num
 
     // Signal the waiting threads.
     for (std::size_t i = 0; i < last; i++) {
-        ASSERT(waiting_threads[i]->status == ThreadStatus::WaitArb);
+        ASSERT(waiting_threads[i]->GetStatus() == ThreadStatus::WaitArb);
         waiting_threads[i]->SetWaitSynchronizationResult(RESULT_SUCCESS);
-        waiting_threads[i]->arb_wait_address = 0;
+        waiting_threads[i]->SetArbiterWaitAddress(0);
         waiting_threads[i]->ResumeFromWait();
     }
 }
diff --git a/src/core/hle/kernel/client_port.cpp b/src/core/hle/kernel/client_port.cpp
index 873d6c516..d4c91d529 100644
--- a/src/core/hle/kernel/client_port.cpp
+++ b/src/core/hle/kernel/client_port.cpp
@@ -17,6 +17,10 @@ namespace Kernel {
 ClientPort::ClientPort(KernelCore& kernel) : Object{kernel} {}
 ClientPort::~ClientPort() = default;
 
+SharedPtr<ServerPort> ClientPort::GetServerPort() const {
+    return server_port;
+}
+
 ResultVal<SharedPtr<ClientSession>> ClientPort::Connect() {
     // Note: Threads do not wait for the server endpoint to call
     // AcceptSession before returning from this call.
diff --git a/src/core/hle/kernel/client_port.h b/src/core/hle/kernel/client_port.h
index f3dfebbb1..6cd607206 100644
--- a/src/core/hle/kernel/client_port.h
+++ b/src/core/hle/kernel/client_port.h
@@ -30,6 +30,8 @@ public:
         return HANDLE_TYPE;
     }
 
+    SharedPtr<ServerPort> GetServerPort() const;
+
     /**
      * Creates a new Session pair, adds the created ServerSession to the associated ServerPort's
      * list of pending sessions, and signals the ServerPort, causing any threads
diff --git a/src/core/hle/kernel/hle_ipc.cpp b/src/core/hle/kernel/hle_ipc.cpp
index 72fb9d250..edad5f1b1 100644
--- a/src/core/hle/kernel/hle_ipc.cpp
+++ b/src/core/hle/kernel/hle_ipc.cpp
@@ -42,14 +42,14 @@ SharedPtr<Event> HLERequestContext::SleepClientThread(SharedPtr<Thread> thread,
                                                       Kernel::SharedPtr<Kernel::Event> event) {
 
     // Put the client thread to sleep until the wait event is signaled or the timeout expires.
-    thread->wakeup_callback = [context = *this, callback](
+    thread->SetWakeupCallback([context = *this, callback](
                                   ThreadWakeupReason reason, SharedPtr<Thread> thread,
                                   SharedPtr<WaitObject> object, std::size_t index) mutable -> bool {
-        ASSERT(thread->status == ThreadStatus::WaitHLEEvent);
+        ASSERT(thread->GetStatus() == ThreadStatus::WaitHLEEvent);
         callback(thread, context, reason);
         context.WriteToOutgoingCommandBuffer(*thread);
         return true;
-    };
+    });
 
     if (!event) {
         // Create event if not provided
@@ -59,8 +59,8 @@ SharedPtr<Event> HLERequestContext::SleepClientThread(SharedPtr<Thread> thread,
     }
 
     event->Clear();
-    thread->status = ThreadStatus::WaitHLEEvent;
-    thread->wait_objects = {event};
+    thread->SetStatus(ThreadStatus::WaitHLEEvent);
+    thread->SetWaitObjects({event});
     event->AddWaitingThread(thread);
 
     if (timeout > 0) {
@@ -209,7 +209,7 @@ ResultCode HLERequestContext::PopulateFromIncomingCommandBuffer(u32_le* src_cmdb
 
 ResultCode HLERequestContext::WriteToOutgoingCommandBuffer(const Thread& thread) {
     std::array<u32, IPC::COMMAND_BUFFER_LENGTH> dst_cmdbuf;
-    Memory::ReadBlock(*thread.owner_process, thread.GetTLSAddress(), dst_cmdbuf.data(),
+    Memory::ReadBlock(*thread.GetOwnerProcess(), thread.GetTLSAddress(), dst_cmdbuf.data(),
                       dst_cmdbuf.size() * sizeof(u32));
 
     // The header was already built in the internal command buffer. Attempt to parse it to verify
@@ -268,7 +268,7 @@ ResultCode HLERequestContext::WriteToOutgoingCommandBuffer(const Thread& thread)
     }
 
     // Copy the translated command buffer back into the thread's command buffer area.
-    Memory::WriteBlock(*thread.owner_process, thread.GetTLSAddress(), dst_cmdbuf.data(),
+    Memory::WriteBlock(*thread.GetOwnerProcess(), thread.GetTLSAddress(), dst_cmdbuf.data(),
                        dst_cmdbuf.size() * sizeof(u32));
 
     return RESULT_SUCCESS;
diff --git a/src/core/hle/kernel/kernel.cpp b/src/core/hle/kernel/kernel.cpp
index 3e0800a71..98eb74298 100644
--- a/src/core/hle/kernel/kernel.cpp
+++ b/src/core/hle/kernel/kernel.cpp
@@ -46,40 +46,40 @@ static void ThreadWakeupCallback(u64 thread_handle, [[maybe_unused]] int cycles_
 
     bool resume = true;
 
-    if (thread->status == ThreadStatus::WaitSynchAny ||
-        thread->status == ThreadStatus::WaitSynchAll ||
-        thread->status == ThreadStatus::WaitHLEEvent) {
+    if (thread->GetStatus() == ThreadStatus::WaitSynchAny ||
+        thread->GetStatus() == ThreadStatus::WaitSynchAll ||
+        thread->GetStatus() == ThreadStatus::WaitHLEEvent) {
         // Remove the thread from each of its waiting objects' waitlists
-        for (auto& object : thread->wait_objects) {
+        for (const auto& object : thread->GetWaitObjects()) {
             object->RemoveWaitingThread(thread.get());
         }
-        thread->wait_objects.clear();
+        thread->ClearWaitObjects();
 
         // Invoke the wakeup callback before clearing the wait objects
-        if (thread->wakeup_callback) {
-            resume = thread->wakeup_callback(ThreadWakeupReason::Timeout, thread, nullptr, 0);
+        if (thread->HasWakeupCallback()) {
+            resume = thread->InvokeWakeupCallback(ThreadWakeupReason::Timeout, thread, nullptr, 0);
         }
     }
 
-    if (thread->mutex_wait_address != 0 || thread->condvar_wait_address != 0 ||
-        thread->wait_handle) {
-        ASSERT(thread->status == ThreadStatus::WaitMutex);
-        thread->mutex_wait_address = 0;
-        thread->condvar_wait_address = 0;
-        thread->wait_handle = 0;
+    if (thread->GetMutexWaitAddress() != 0 || thread->GetCondVarWaitAddress() != 0 ||
+        thread->GetWaitHandle() != 0) {
+        ASSERT(thread->GetStatus() == ThreadStatus::WaitMutex);
+        thread->SetMutexWaitAddress(0);
+        thread->SetCondVarWaitAddress(0);
+        thread->SetWaitHandle(0);
 
-        auto lock_owner = thread->lock_owner;
+        auto* const lock_owner = thread->GetLockOwner();
         // Threads waking up by timeout from WaitProcessWideKey do not perform priority inheritance
         // and don't have a lock owner unless SignalProcessWideKey was called first and the thread
         // wasn't awakened due to the mutex already being acquired.
-        if (lock_owner) {
+        if (lock_owner != nullptr) {
             lock_owner->RemoveMutexWaiter(thread);
         }
     }
 
-    if (thread->arb_wait_address != 0) {
-        ASSERT(thread->status == ThreadStatus::WaitArb);
-        thread->arb_wait_address = 0;
+    if (thread->GetArbiterWaitAddress() != 0) {
+        ASSERT(thread->GetStatus() == ThreadStatus::WaitArb);
+        thread->SetArbiterWaitAddress(0);
     }
 
     if (resume) {
diff --git a/src/core/hle/kernel/mutex.cpp b/src/core/hle/kernel/mutex.cpp
index 81675eac5..dd541ffcc 100644
--- a/src/core/hle/kernel/mutex.cpp
+++ b/src/core/hle/kernel/mutex.cpp
@@ -28,11 +28,11 @@ static std::pair<SharedPtr<Thread>, u32> GetHighestPriorityMutexWaitingThread(
     SharedPtr<Thread> highest_priority_thread;
     u32 num_waiters = 0;
 
-    for (auto& thread : current_thread->wait_mutex_threads) {
-        if (thread->mutex_wait_address != mutex_addr)
+    for (const auto& thread : current_thread->GetMutexWaitingThreads()) {
+        if (thread->GetMutexWaitAddress() != mutex_addr)
             continue;
 
-        ASSERT(thread->status == ThreadStatus::WaitMutex);
+        ASSERT(thread->GetStatus() == ThreadStatus::WaitMutex);
 
         ++num_waiters;
         if (highest_priority_thread == nullptr ||
@@ -47,12 +47,12 @@ static std::pair<SharedPtr<Thread>, u32> GetHighestPriorityMutexWaitingThread(
 /// Update the mutex owner field of all threads waiting on the mutex to point to the new owner.
 static void TransferMutexOwnership(VAddr mutex_addr, SharedPtr<Thread> current_thread,
                                    SharedPtr<Thread> new_owner) {
-    auto threads = current_thread->wait_mutex_threads;
-    for (auto& thread : threads) {
-        if (thread->mutex_wait_address != mutex_addr)
+    const auto threads = current_thread->GetMutexWaitingThreads();
+    for (const auto& thread : threads) {
+        if (thread->GetMutexWaitAddress() != mutex_addr)
             continue;
 
-        ASSERT(thread->lock_owner == current_thread);
+        ASSERT(thread->GetLockOwner() == current_thread);
         current_thread->RemoveMutexWaiter(thread);
         if (new_owner != thread)
             new_owner->AddMutexWaiter(thread);
@@ -84,11 +84,11 @@ ResultCode Mutex::TryAcquire(HandleTable& handle_table, VAddr address, Handle ho
         return ERR_INVALID_HANDLE;
 
     // Wait until the mutex is released
-    GetCurrentThread()->mutex_wait_address = address;
-    GetCurrentThread()->wait_handle = requesting_thread_handle;
+    GetCurrentThread()->SetMutexWaitAddress(address);
+    GetCurrentThread()->SetWaitHandle(requesting_thread_handle);
 
-    GetCurrentThread()->status = ThreadStatus::WaitMutex;
-    GetCurrentThread()->wakeup_callback = nullptr;
+    GetCurrentThread()->SetStatus(ThreadStatus::WaitMutex);
+    GetCurrentThread()->InvalidateWakeupCallback();
 
     // Update the lock holder thread's priority to prevent priority inversion.
     holding_thread->AddMutexWaiter(GetCurrentThread());
@@ -115,7 +115,7 @@ ResultCode Mutex::Release(VAddr address) {
     // Transfer the ownership of the mutex from the previous owner to the new one.
     TransferMutexOwnership(address, GetCurrentThread(), thread);
 
-    u32 mutex_value = thread->wait_handle;
+    u32 mutex_value = thread->GetWaitHandle();
 
     if (num_waiters >= 2) {
         // Notify the guest that there are still some threads waiting for the mutex
@@ -125,13 +125,13 @@ ResultCode Mutex::Release(VAddr address) {
     // Grant the mutex to the next waiting thread and resume it.
     Memory::Write32(address, mutex_value);
 
-    ASSERT(thread->status == ThreadStatus::WaitMutex);
+    ASSERT(thread->GetStatus() == ThreadStatus::WaitMutex);
     thread->ResumeFromWait();
 
-    thread->lock_owner = nullptr;
-    thread->condvar_wait_address = 0;
-    thread->mutex_wait_address = 0;
-    thread->wait_handle = 0;
+    thread->SetLockOwner(nullptr);
+    thread->SetCondVarWaitAddress(0);
+    thread->SetMutexWaitAddress(0);
+    thread->SetWaitHandle(0);
 
     return RESULT_SUCCESS;
 }
diff --git a/src/core/hle/kernel/process.cpp b/src/core/hle/kernel/process.cpp
index dc9fc8470..fb0027a71 100644
--- a/src/core/hle/kernel/process.cpp
+++ b/src/core/hle/kernel/process.cpp
@@ -144,15 +144,15 @@ void Process::PrepareForTermination() {
 
     const auto stop_threads = [this](const std::vector<SharedPtr<Thread>>& thread_list) {
         for (auto& thread : thread_list) {
-            if (thread->owner_process != this)
+            if (thread->GetOwnerProcess() != this)
                 continue;
 
             if (thread == GetCurrentThread())
                 continue;
 
             // TODO(Subv): When are the other running/ready threads terminated?
-            ASSERT_MSG(thread->status == ThreadStatus::WaitSynchAny ||
-                           thread->status == ThreadStatus::WaitSynchAll,
+            ASSERT_MSG(thread->GetStatus() == ThreadStatus::WaitSynchAny ||
+                           thread->GetStatus() == ThreadStatus::WaitSynchAll,
                        "Exiting processes with non-waiting threads is currently unimplemented");
 
             thread->Stop();
diff --git a/src/core/hle/kernel/scheduler.cpp b/src/core/hle/kernel/scheduler.cpp
index 1e82cfffb..cfd6e1bad 100644
--- a/src/core/hle/kernel/scheduler.cpp
+++ b/src/core/hle/kernel/scheduler.cpp
@@ -38,10 +38,10 @@ Thread* Scheduler::PopNextReadyThread() {
     Thread* next = nullptr;
     Thread* thread = GetCurrentThread();
 
-    if (thread && thread->status == ThreadStatus::Running) {
+    if (thread && thread->GetStatus() == ThreadStatus::Running) {
         // We have to do better than the current thread.
         // This call returns null when that's not possible.
-        next = ready_queue.pop_first_better(thread->current_priority);
+        next = ready_queue.pop_first_better(thread->GetPriority());
         if (!next) {
             // Otherwise just keep going with the current thread
             next = thread;
@@ -58,22 +58,21 @@ void Scheduler::SwitchContext(Thread* new_thread) {
 
     // Save context for previous thread
     if (previous_thread) {
-        previous_thread->last_running_ticks = CoreTiming::GetTicks();
-        cpu_core.SaveContext(previous_thread->context);
+        cpu_core.SaveContext(previous_thread->GetContext());
         // Save the TPIDR_EL0 system register in case it was modified.
-        previous_thread->tpidr_el0 = cpu_core.GetTPIDR_EL0();
+        previous_thread->SetTPIDR_EL0(cpu_core.GetTPIDR_EL0());
 
-        if (previous_thread->status == ThreadStatus::Running) {
+        if (previous_thread->GetStatus() == ThreadStatus::Running) {
             // This is only the case when a reschedule is triggered without the current thread
             // yielding execution (i.e. an event triggered, system core time-sliced, etc)
-            ready_queue.push_front(previous_thread->current_priority, previous_thread);
-            previous_thread->status = ThreadStatus::Ready;
+            ready_queue.push_front(previous_thread->GetPriority(), previous_thread);
+            previous_thread->SetStatus(ThreadStatus::Ready);
         }
     }
 
     // Load context of new thread
     if (new_thread) {
-        ASSERT_MSG(new_thread->status == ThreadStatus::Ready,
+        ASSERT_MSG(new_thread->GetStatus() == ThreadStatus::Ready,
                    "Thread must be ready to become running.");
 
         // Cancel any outstanding wakeup events for this thread
@@ -83,15 +82,16 @@ void Scheduler::SwitchContext(Thread* new_thread) {
 
         current_thread = new_thread;
 
-        ready_queue.remove(new_thread->current_priority, new_thread);
-        new_thread->status = ThreadStatus::Running;
+        ready_queue.remove(new_thread->GetPriority(), new_thread);
+        new_thread->SetStatus(ThreadStatus::Running);
 
-        if (previous_process != current_thread->owner_process) {
-            Core::CurrentProcess() = current_thread->owner_process;
+        const auto thread_owner_process = current_thread->GetOwnerProcess();
+        if (previous_process != thread_owner_process) {
+            Core::CurrentProcess() = thread_owner_process;
             SetCurrentPageTable(&Core::CurrentProcess()->VMManager().page_table);
         }
 
-        cpu_core.LoadContext(new_thread->context);
+        cpu_core.LoadContext(new_thread->GetContext());
         cpu_core.SetTlsAddress(new_thread->GetTLSAddress());
         cpu_core.SetTPIDR_EL0(new_thread->GetTPIDR_EL0());
         cpu_core.ClearExclusiveState();
@@ -136,14 +136,14 @@ void Scheduler::RemoveThread(Thread* thread) {
 void Scheduler::ScheduleThread(Thread* thread, u32 priority) {
     std::lock_guard<std::mutex> lock(scheduler_mutex);
 
-    ASSERT(thread->status == ThreadStatus::Ready);
+    ASSERT(thread->GetStatus() == ThreadStatus::Ready);
     ready_queue.push_back(priority, thread);
 }
 
 void Scheduler::UnscheduleThread(Thread* thread, u32 priority) {
     std::lock_guard<std::mutex> lock(scheduler_mutex);
 
-    ASSERT(thread->status == ThreadStatus::Ready);
+    ASSERT(thread->GetStatus() == ThreadStatus::Ready);
     ready_queue.remove(priority, thread);
 }
 
@@ -151,8 +151,8 @@ void Scheduler::SetThreadPriority(Thread* thread, u32 priority) {
     std::lock_guard<std::mutex> lock(scheduler_mutex);
 
     // If thread was ready, adjust queues
-    if (thread->status == ThreadStatus::Ready)
-        ready_queue.move(thread, thread->current_priority, priority);
+    if (thread->GetStatus() == ThreadStatus::Ready)
+        ready_queue.move(thread, thread->GetPriority(), priority);
     else
         ready_queue.prepare(priority);
 }
diff --git a/src/core/hle/kernel/server_port.h b/src/core/hle/kernel/server_port.h
index 62fb51349..e52f8245f 100644
--- a/src/core/hle/kernel/server_port.h
+++ b/src/core/hle/kernel/server_port.h
@@ -11,6 +11,7 @@
 #include "common/common_types.h"
 #include "core/hle/kernel/object.h"
 #include "core/hle/kernel/wait_object.h"
+#include "core/hle/result.h"
 
 namespace Kernel {
 
diff --git a/src/core/hle/kernel/server_session.cpp b/src/core/hle/kernel/server_session.cpp
index aba0cab96..1ece691c7 100644
--- a/src/core/hle/kernel/server_session.cpp
+++ b/src/core/hle/kernel/server_session.cpp
@@ -120,10 +120,10 @@ ResultCode ServerSession::HandleSyncRequest(SharedPtr<Thread> thread) {
         result = hle_handler->HandleSyncRequest(context);
     }
 
-    if (thread->status == ThreadStatus::Running) {
+    if (thread->GetStatus() == ThreadStatus::Running) {
         // Put the thread to sleep until the server replies, it will be awoken in
         // svcReplyAndReceive for LLE servers.
-        thread->status = ThreadStatus::WaitIPC;
+        thread->SetStatus(ThreadStatus::WaitIPC);
 
         if (hle_handler != nullptr) {
             // For HLE services, we put the request threads to sleep for a short duration to
diff --git a/src/core/hle/kernel/svc.cpp b/src/core/hle/kernel/svc.cpp
index 1cdaa740a..6c4af7e47 100644
--- a/src/core/hle/kernel/svc.cpp
+++ b/src/core/hle/kernel/svc.cpp
@@ -156,7 +156,7 @@ static ResultCode GetThreadId(u32* thread_id, Handle thread_handle) {
         return ERR_INVALID_HANDLE;
     }
 
-    *thread_id = thread->GetThreadId();
+    *thread_id = thread->GetThreadID();
     return RESULT_SUCCESS;
 }
 
@@ -177,7 +177,7 @@ static ResultCode GetProcessId(u32* process_id, Handle process_handle) {
 /// Default thread wakeup callback for WaitSynchronization
 static bool DefaultThreadWakeupCallback(ThreadWakeupReason reason, SharedPtr<Thread> thread,
                                         SharedPtr<WaitObject> object, std::size_t index) {
-    ASSERT(thread->status == ThreadStatus::WaitSynchAny);
+    ASSERT(thread->GetStatus() == ThreadStatus::WaitSynchAny);
 
     if (reason == ThreadWakeupReason::Timeout) {
         thread->SetWaitSynchronizationResult(RESULT_TIMEOUT);
@@ -204,10 +204,10 @@ static ResultCode WaitSynchronization(Handle* index, VAddr handles_address, u64
     if (handle_count > MaxHandles)
         return ResultCode(ErrorModule::Kernel, ErrCodes::TooLarge);
 
-    auto thread = GetCurrentThread();
+    auto* const thread = GetCurrentThread();
 
-    using ObjectPtr = SharedPtr<WaitObject>;
-    std::vector<ObjectPtr> objects(handle_count);
+    using ObjectPtr = Thread::ThreadWaitObjects::value_type;
+    Thread::ThreadWaitObjects objects(handle_count);
     auto& kernel = Core::System::GetInstance().Kernel();
 
     for (u64 i = 0; i < handle_count; ++i) {
@@ -244,14 +244,14 @@ static ResultCode WaitSynchronization(Handle* index, VAddr handles_address, u64
     for (auto& object : objects)
         object->AddWaitingThread(thread);
 
-    thread->wait_objects = std::move(objects);
-    thread->status = ThreadStatus::WaitSynchAny;
+    thread->SetWaitObjects(std::move(objects));
+    thread->SetStatus(ThreadStatus::WaitSynchAny);
 
     // Create an event to wake the thread up after the specified nanosecond delay has passed
     thread->WakeAfterDelay(nano_seconds);
-    thread->wakeup_callback = DefaultThreadWakeupCallback;
+    thread->SetWakeupCallback(DefaultThreadWakeupCallback);
 
-    Core::System::GetInstance().CpuCore(thread->processor_id).PrepareReschedule();
+    Core::System::GetInstance().CpuCore(thread->GetProcessorID()).PrepareReschedule();
 
     return RESULT_TIMEOUT;
 }
@@ -266,7 +266,7 @@ static ResultCode CancelSynchronization(Handle thread_handle) {
         return ERR_INVALID_HANDLE;
     }
 
-    ASSERT(thread->status == ThreadStatus::WaitSynchAny);
+    ASSERT(thread->GetStatus() == ThreadStatus::WaitSynchAny);
     thread->SetWaitSynchronizationResult(
         ResultCode(ErrorModule::Kernel, ErrCodes::SynchronizationCanceled));
     thread->ResumeFromWait();
@@ -425,7 +425,7 @@ static ResultCode GetThreadContext(VAddr thread_context, Handle handle) {
     }
 
     const auto current_process = Core::CurrentProcess();
-    if (thread->owner_process != current_process) {
+    if (thread->GetOwnerProcess() != current_process) {
         return ERR_INVALID_HANDLE;
     }
 
@@ -433,7 +433,7 @@ static ResultCode GetThreadContext(VAddr thread_context, Handle handle) {
         return ERR_ALREADY_REGISTERED;
     }
 
-    Core::ARM_Interface::ThreadContext ctx = thread->context;
+    Core::ARM_Interface::ThreadContext ctx = thread->GetContext();
     // Mask away mode bits, interrupt bits, IL bit, and other reserved bits.
     ctx.pstate &= 0xFF0FFE20;
 
@@ -479,14 +479,14 @@ static ResultCode SetThreadPriority(Handle handle, u32 priority) {
 
     thread->SetPriority(priority);
 
-    Core::System::GetInstance().CpuCore(thread->processor_id).PrepareReschedule();
+    Core::System::GetInstance().CpuCore(thread->GetProcessorID()).PrepareReschedule();
     return RESULT_SUCCESS;
 }
 
 /// Get which CPU core is executing the current thread
 static u32 GetCurrentProcessorNumber() {
     LOG_TRACE(Kernel_SVC, "called");
-    return GetCurrentThread()->processor_id;
+    return GetCurrentThread()->GetProcessorID();
 }
 
 static ResultCode MapSharedMemory(Handle shared_memory_handle, VAddr addr, u64 size,
@@ -622,10 +622,14 @@ static ResultCode CreateThread(Handle* out_handle, VAddr entry_point, u64 arg, V
     CASCADE_RESULT(SharedPtr<Thread> thread,
                    Thread::Create(kernel, name, entry_point, priority, arg, processor_id, stack_top,
                                   Core::CurrentProcess()));
-    CASCADE_RESULT(thread->guest_handle, kernel.HandleTable().Create(thread));
-    *out_handle = thread->guest_handle;
+    const auto new_guest_handle = kernel.HandleTable().Create(thread);
+    if (new_guest_handle.Failed()) {
+        return new_guest_handle.Code();
+    }
+    thread->SetGuestHandle(*new_guest_handle);
+    *out_handle = *new_guest_handle;
 
-    Core::System::GetInstance().CpuCore(thread->processor_id).PrepareReschedule();
+    Core::System::GetInstance().CpuCore(thread->GetProcessorID()).PrepareReschedule();
 
     LOG_TRACE(Kernel_SVC,
               "called entrypoint=0x{:08X} ({}), arg=0x{:08X}, stacktop=0x{:08X}, "
@@ -645,10 +649,10 @@ static ResultCode StartThread(Handle thread_handle) {
         return ERR_INVALID_HANDLE;
     }
 
-    ASSERT(thread->status == ThreadStatus::Dormant);
+    ASSERT(thread->GetStatus() == ThreadStatus::Dormant);
 
     thread->ResumeFromWait();
-    Core::System::GetInstance().CpuCore(thread->processor_id).PrepareReschedule();
+    Core::System::GetInstance().CpuCore(thread->GetProcessorID()).PrepareReschedule();
 
     return RESULT_SUCCESS;
 }
@@ -694,17 +698,17 @@ static ResultCode WaitProcessWideKeyAtomic(VAddr mutex_addr, VAddr condition_var
     CASCADE_CODE(Mutex::Release(mutex_addr));
 
     SharedPtr<Thread> current_thread = GetCurrentThread();
-    current_thread->condvar_wait_address = condition_variable_addr;
-    current_thread->mutex_wait_address = mutex_addr;
-    current_thread->wait_handle = thread_handle;
-    current_thread->status = ThreadStatus::WaitMutex;
-    current_thread->wakeup_callback = nullptr;
+    current_thread->SetCondVarWaitAddress(condition_variable_addr);
+    current_thread->SetMutexWaitAddress(mutex_addr);
+    current_thread->SetWaitHandle(thread_handle);
+    current_thread->SetStatus(ThreadStatus::WaitMutex);
+    current_thread->InvalidateWakeupCallback();
 
     current_thread->WakeAfterDelay(nano_seconds);
 
     // Note: Deliberately don't attempt to inherit the lock owner's priority.
 
-    Core::System::GetInstance().CpuCore(current_thread->processor_id).PrepareReschedule();
+    Core::System::GetInstance().CpuCore(current_thread->GetProcessorID()).PrepareReschedule();
     return RESULT_SUCCESS;
 }
 
@@ -713,14 +717,14 @@ static ResultCode SignalProcessWideKey(VAddr condition_variable_addr, s32 target
     LOG_TRACE(Kernel_SVC, "called, condition_variable_addr=0x{:X}, target=0x{:08X}",
               condition_variable_addr, target);
 
-    auto RetrieveWaitingThreads = [](std::size_t core_index,
-                                     std::vector<SharedPtr<Thread>>& waiting_threads,
-                                     VAddr condvar_addr) {
+    const auto RetrieveWaitingThreads = [](std::size_t core_index,
+                                           std::vector<SharedPtr<Thread>>& waiting_threads,
+                                           VAddr condvar_addr) {
         const auto& scheduler = Core::System::GetInstance().Scheduler(core_index);
-        auto& thread_list = scheduler->GetThreadList();
+        const auto& thread_list = scheduler->GetThreadList();
 
-        for (auto& thread : thread_list) {
-            if (thread->condvar_wait_address == condvar_addr)
+        for (const auto& thread : thread_list) {
+            if (thread->GetCondVarWaitAddress() == condvar_addr)
                 waiting_threads.push_back(thread);
         }
     };
@@ -734,7 +738,7 @@ static ResultCode SignalProcessWideKey(VAddr condition_variable_addr, s32 target
     // Sort them by priority, such that the highest priority ones come first.
     std::sort(waiting_threads.begin(), waiting_threads.end(),
               [](const SharedPtr<Thread>& lhs, const SharedPtr<Thread>& rhs) {
-                  return lhs->current_priority < rhs->current_priority;
+                  return lhs->GetPriority() < rhs->GetPriority();
               });
 
     // Only process up to 'target' threads, unless 'target' is -1, in which case process
@@ -750,7 +754,7 @@ static ResultCode SignalProcessWideKey(VAddr condition_variable_addr, s32 target
     for (std::size_t index = 0; index < last; ++index) {
         auto& thread = waiting_threads[index];
 
-        ASSERT(thread->condvar_wait_address == condition_variable_addr);
+        ASSERT(thread->GetCondVarWaitAddress() == condition_variable_addr);
 
         std::size_t current_core = Core::System::GetInstance().CurrentCoreIndex();
 
@@ -759,42 +763,43 @@ static ResultCode SignalProcessWideKey(VAddr condition_variable_addr, s32 target
         // Atomically read the value of the mutex.
         u32 mutex_val = 0;
         do {
-            monitor.SetExclusive(current_core, thread->mutex_wait_address);
+            monitor.SetExclusive(current_core, thread->GetMutexWaitAddress());
 
             // If the mutex is not yet acquired, acquire it.
-            mutex_val = Memory::Read32(thread->mutex_wait_address);
+            mutex_val = Memory::Read32(thread->GetMutexWaitAddress());
 
             if (mutex_val != 0) {
                 monitor.ClearExclusive();
                 break;
             }
-        } while (!monitor.ExclusiveWrite32(current_core, thread->mutex_wait_address,
-                                           thread->wait_handle));
+        } while (!monitor.ExclusiveWrite32(current_core, thread->GetMutexWaitAddress(),
+                                           thread->GetWaitHandle()));
 
         if (mutex_val == 0) {
             // We were able to acquire the mutex, resume this thread.
-            ASSERT(thread->status == ThreadStatus::WaitMutex);
+            ASSERT(thread->GetStatus() == ThreadStatus::WaitMutex);
             thread->ResumeFromWait();
 
-            auto lock_owner = thread->lock_owner;
-            if (lock_owner)
+            auto* const lock_owner = thread->GetLockOwner();
+            if (lock_owner != nullptr) {
                 lock_owner->RemoveMutexWaiter(thread);
+            }
 
-            thread->lock_owner = nullptr;
-            thread->mutex_wait_address = 0;
-            thread->condvar_wait_address = 0;
-            thread->wait_handle = 0;
+            thread->SetLockOwner(nullptr);
+            thread->SetMutexWaitAddress(0);
+            thread->SetCondVarWaitAddress(0);
+            thread->SetWaitHandle(0);
         } else {
             // Atomically signal that the mutex now has a waiting thread.
             do {
-                monitor.SetExclusive(current_core, thread->mutex_wait_address);
+                monitor.SetExclusive(current_core, thread->GetMutexWaitAddress());
 
                 // Ensure that the mutex value is still what we expect.
-                u32 value = Memory::Read32(thread->mutex_wait_address);
+                u32 value = Memory::Read32(thread->GetMutexWaitAddress());
                 // TODO(Subv): When this happens, the kernel just clears the exclusive state and
                 // retries the initial read for this thread.
                 ASSERT_MSG(mutex_val == value, "Unhandled synchronization primitive case");
-            } while (!monitor.ExclusiveWrite32(current_core, thread->mutex_wait_address,
+            } while (!monitor.ExclusiveWrite32(current_core, thread->GetMutexWaitAddress(),
                                                mutex_val | Mutex::MutexHasWaitersFlag));
 
             // The mutex is already owned by some other thread, make this thread wait on it.
@@ -802,12 +807,12 @@ static ResultCode SignalProcessWideKey(VAddr condition_variable_addr, s32 target
             Handle owner_handle = static_cast<Handle>(mutex_val & Mutex::MutexOwnerMask);
             auto owner = kernel.HandleTable().Get<Thread>(owner_handle);
             ASSERT(owner);
-            ASSERT(thread->status == ThreadStatus::WaitMutex);
-            thread->wakeup_callback = nullptr;
+            ASSERT(thread->GetStatus() == ThreadStatus::WaitMutex);
+            thread->InvalidateWakeupCallback();
 
             owner->AddMutexWaiter(thread);
 
-            Core::System::GetInstance().CpuCore(thread->processor_id).PrepareReschedule();
+            Core::System::GetInstance().CpuCore(thread->GetProcessorID()).PrepareReschedule();
         }
     }
 
@@ -913,8 +918,8 @@ static ResultCode GetThreadCoreMask(Handle thread_handle, u32* core, u64* mask)
         return ERR_INVALID_HANDLE;
     }
 
-    *core = thread->ideal_core;
-    *mask = thread->affinity_mask;
+    *core = thread->GetIdealCore();
+    *mask = thread->GetAffinityMask();
 
     return RESULT_SUCCESS;
 }
@@ -930,11 +935,13 @@ static ResultCode SetThreadCoreMask(Handle thread_handle, u32 core, u64 mask) {
     }
 
     if (core == static_cast<u32>(THREADPROCESSORID_DEFAULT)) {
-        ASSERT(thread->owner_process->GetDefaultProcessorID() !=
-               static_cast<u8>(THREADPROCESSORID_DEFAULT));
+        const u8 default_processor_id = thread->GetOwnerProcess()->GetDefaultProcessorID();
+
+        ASSERT(default_processor_id != static_cast<u8>(THREADPROCESSORID_DEFAULT));
+
         // Set the target CPU to the one specified in the process' exheader.
-        core = thread->owner_process->GetDefaultProcessorID();
-        mask = 1ull << core;
+        core = default_processor_id;
+        mask = 1ULL << core;
     }
 
     if (mask == 0) {
@@ -945,7 +952,7 @@ static ResultCode SetThreadCoreMask(Handle thread_handle, u32 core, u64 mask) {
     static constexpr u32 OnlyChangeMask = static_cast<u32>(-3);
 
     if (core == OnlyChangeMask) {
-        core = thread->ideal_core;
+        core = thread->GetIdealCore();
     } else if (core >= Core::NUM_CPU_CORES && core != static_cast<u32>(-1)) {
         return ResultCode(ErrorModule::Kernel, ErrCodes::InvalidProcessorId);
     }
diff --git a/src/core/hle/kernel/thread.cpp b/src/core/hle/kernel/thread.cpp
index b5c16cfbb..8e514cf9a 100644
--- a/src/core/hle/kernel/thread.cpp
+++ b/src/core/hle/kernel/thread.cpp
@@ -70,7 +70,7 @@ void Thread::Stop() {
 
 void WaitCurrentThread_Sleep() {
     Thread* thread = GetCurrentThread();
-    thread->status = ThreadStatus::WaitSleep;
+    thread->SetStatus(ThreadStatus::WaitSleep);
 }
 
 void ExitCurrentThread() {
@@ -169,7 +169,7 @@ void Thread::ResumeFromWait() {
     next_scheduler->ScheduleThread(this, current_priority);
 
     // Change thread's scheduler
-    scheduler = next_scheduler;
+    scheduler = next_scheduler.get();
 
     Core::System::GetInstance().CpuCore(processor_id).PrepareReschedule();
 }
@@ -233,7 +233,7 @@ ResultVal<SharedPtr<Thread>> Thread::Create(KernelCore& kernel, std::string name
     thread->name = std::move(name);
     thread->callback_handle = kernel.ThreadWakeupCallbackHandleTable().Create(thread).Unwrap();
     thread->owner_process = owner_process;
-    thread->scheduler = Core::System::GetInstance().Scheduler(processor_id);
+    thread->scheduler = Core::System::GetInstance().Scheduler(processor_id).get();
     thread->scheduler->AddThread(thread, priority);
     thread->tls_address = thread->owner_process->MarkNextAvailableTLSSlotAsUsed(*thread);
 
@@ -269,9 +269,9 @@ SharedPtr<Thread> SetupMainThread(KernelCore& kernel, VAddr entry_point, u32 pri
     SharedPtr<Thread> thread = std::move(thread_res).Unwrap();
 
     // Register 1 must be a handle to the main thread
-    thread->guest_handle = kernel.HandleTable().Create(thread).Unwrap();
-
-    thread->context.cpu_registers[1] = thread->guest_handle;
+    const Handle guest_handle = kernel.HandleTable().Create(thread).Unwrap();
+    thread->SetGuestHandle(guest_handle);
+    thread->GetContext().cpu_registers[1] = guest_handle;
 
     // Threads by default are dormant, wake up the main thread so it runs when the scheduler fires
     thread->ResumeFromWait();
@@ -299,6 +299,18 @@ VAddr Thread::GetCommandBufferAddress() const {
     return GetTLSAddress() + CommandHeaderOffset;
 }
 
+void Thread::SetStatus(ThreadStatus new_status) {
+    if (new_status == status) {
+        return;
+    }
+
+    if (status == ThreadStatus::Running) {
+        last_running_ticks = CoreTiming::GetTicks();
+    }
+
+    status = new_status;
+}
+
 void Thread::AddMutexWaiter(SharedPtr<Thread> thread) {
     if (thread->lock_owner == this) {
         // If the thread is already waiting for this thread to release the mutex, ensure that the
@@ -388,11 +400,23 @@ void Thread::ChangeCore(u32 core, u64 mask) {
     next_scheduler->ScheduleThread(this, current_priority);
 
     // Change thread's scheduler
-    scheduler = next_scheduler;
+    scheduler = next_scheduler.get();
 
     Core::System::GetInstance().CpuCore(processor_id).PrepareReschedule();
 }
 
+bool Thread::AllWaitObjectsReady() {
+    return std::none_of(
+        wait_objects.begin(), wait_objects.end(),
+        [this](const SharedPtr<WaitObject>& object) { return object->ShouldWait(this); });
+}
+
+bool Thread::InvokeWakeupCallback(ThreadWakeupReason reason, SharedPtr<Thread> thread,
+                                  SharedPtr<WaitObject> object, std::size_t index) {
+    ASSERT(wakeup_callback);
+    return wakeup_callback(reason, std::move(thread), std::move(object), index);
+}
+
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 /**
diff --git a/src/core/hle/kernel/thread.h b/src/core/hle/kernel/thread.h
index 4250144c3..c6ffbd28c 100644
--- a/src/core/hle/kernel/thread.h
+++ b/src/core/hle/kernel/thread.h
@@ -65,6 +65,15 @@ public:
     using TLSMemory = std::vector<u8>;
     using TLSMemoryPtr = std::shared_ptr<TLSMemory>;
 
+    using MutexWaitingThreads = std::vector<SharedPtr<Thread>>;
+
+    using ThreadContext = Core::ARM_Interface::ThreadContext;
+
+    using ThreadWaitObjects = std::vector<SharedPtr<WaitObject>>;
+
+    using WakeupCallback = std::function<bool(ThreadWakeupReason reason, SharedPtr<Thread> thread,
+                                              SharedPtr<WaitObject> object, std::size_t index)>;
+
     /**
      * Creates and returns a new thread. The new thread is immediately scheduled
      * @param kernel The kernel instance this thread will be created under.
@@ -106,6 +115,14 @@ public:
     }
 
     /**
+     * Gets the thread's nominal priority.
+     * @return The current thread's nominal priority.
+     */
+    u32 GetNominalPriority() const {
+        return nominal_priority;
+    }
+
+    /**
      * Sets the thread's current priority
      * @param priority The new priority
      */
@@ -133,7 +150,7 @@ public:
      * Gets the thread's thread ID
      * @return The thread's ID
      */
-    u32 GetThreadId() const {
+    u32 GetThreadID() const {
         return thread_id;
     }
 
@@ -203,6 +220,11 @@ public:
         return tpidr_el0;
     }
 
+    /// Sets the value of the TPIDR_EL0 Read/Write system register for this thread.
+    void SetTPIDR_EL0(u64 value) {
+        tpidr_el0 = value;
+    }
+
     /*
      * Returns the address of the current thread's command buffer, located in the TLS.
      * @returns VAddr of the thread's command buffer.
@@ -218,69 +240,193 @@ public:
         return status == ThreadStatus::WaitSynchAll;
     }
 
-    Core::ARM_Interface::ThreadContext context;
+    ThreadContext& GetContext() {
+        return context;
+    }
+
+    const ThreadContext& GetContext() const {
+        return context;
+    }
+
+    ThreadStatus GetStatus() const {
+        return status;
+    }
+
+    void SetStatus(ThreadStatus new_status);
+
+    u64 GetLastRunningTicks() const {
+        return last_running_ticks;
+    }
+
+    s32 GetProcessorID() const {
+        return processor_id;
+    }
+
+    SharedPtr<Process>& GetOwnerProcess() {
+        return owner_process;
+    }
+
+    const SharedPtr<Process>& GetOwnerProcess() const {
+        return owner_process;
+    }
+
+    const ThreadWaitObjects& GetWaitObjects() const {
+        return wait_objects;
+    }
+
+    void SetWaitObjects(ThreadWaitObjects objects) {
+        wait_objects = std::move(objects);
+    }
+
+    void ClearWaitObjects() {
+        wait_objects.clear();
+    }
+
+    /// Determines whether all the objects this thread is waiting on are ready.
+    bool AllWaitObjectsReady();
+
+    const MutexWaitingThreads& GetMutexWaitingThreads() const {
+        return wait_mutex_threads;
+    }
+
+    Thread* GetLockOwner() const {
+        return lock_owner.get();
+    }
+
+    void SetLockOwner(SharedPtr<Thread> owner) {
+        lock_owner = std::move(owner);
+    }
+
+    VAddr GetCondVarWaitAddress() const {
+        return condvar_wait_address;
+    }
+
+    void SetCondVarWaitAddress(VAddr address) {
+        condvar_wait_address = address;
+    }
+
+    VAddr GetMutexWaitAddress() const {
+        return mutex_wait_address;
+    }
 
-    u32 thread_id;
+    void SetMutexWaitAddress(VAddr address) {
+        mutex_wait_address = address;
+    }
 
-    ThreadStatus status;
-    VAddr entry_point;
-    VAddr stack_top;
+    Handle GetWaitHandle() const {
+        return wait_handle;
+    }
 
-    u32 nominal_priority; ///< Nominal thread priority, as set by the emulated application
-    u32 current_priority; ///< Current thread priority, can be temporarily changed
+    void SetWaitHandle(Handle handle) {
+        wait_handle = handle;
+    }
 
-    u64 last_running_ticks; ///< CPU tick when thread was last running
+    VAddr GetArbiterWaitAddress() const {
+        return arb_wait_address;
+    }
 
-    s32 processor_id;
+    void SetArbiterWaitAddress(VAddr address) {
+        arb_wait_address = address;
+    }
 
-    VAddr tls_address; ///< Virtual address of the Thread Local Storage of the thread
-    u64 tpidr_el0;     ///< TPIDR_EL0 read/write system register.
+    void SetGuestHandle(Handle handle) {
+        guest_handle = handle;
+    }
 
-    SharedPtr<Process> owner_process; ///< Process that owns this thread
+    bool HasWakeupCallback() const {
+        return wakeup_callback != nullptr;
+    }
+
+    void SetWakeupCallback(WakeupCallback callback) {
+        wakeup_callback = std::move(callback);
+    }
+
+    void InvalidateWakeupCallback() {
+        SetWakeupCallback(nullptr);
+    }
+
+    /**
+     * Invokes the thread's wakeup callback.
+     *
+     * @pre A valid wakeup callback has been set. Violating this precondition
+     *      will cause an assertion to trigger.
+     */
+    bool InvokeWakeupCallback(ThreadWakeupReason reason, SharedPtr<Thread> thread,
+                              SharedPtr<WaitObject> object, std::size_t index);
+
+    u32 GetIdealCore() const {
+        return ideal_core;
+    }
+
+    u64 GetAffinityMask() const {
+        return affinity_mask;
+    }
+
+private:
+    explicit Thread(KernelCore& kernel);
+    ~Thread() override;
+
+    Core::ARM_Interface::ThreadContext context{};
+
+    u32 thread_id = 0;
+
+    ThreadStatus status = ThreadStatus::Dormant;
+
+    VAddr entry_point = 0;
+    VAddr stack_top = 0;
+
+    u32 nominal_priority = 0; ///< Nominal thread priority, as set by the emulated application
+    u32 current_priority = 0; ///< Current thread priority, can be temporarily changed
+
+    u64 last_running_ticks = 0; ///< CPU tick when thread was last running
+
+    s32 processor_id = 0;
+
+    VAddr tls_address = 0; ///< Virtual address of the Thread Local Storage of the thread
+    u64 tpidr_el0 = 0;     ///< TPIDR_EL0 read/write system register.
+
+    /// Process that owns this thread
+    SharedPtr<Process> owner_process;
 
     /// Objects that the thread is waiting on, in the same order as they were
-    // passed to WaitSynchronization1/N.
-    std::vector<SharedPtr<WaitObject>> wait_objects;
+    /// passed to WaitSynchronization1/N.
+    ThreadWaitObjects wait_objects;
 
     /// List of threads that are waiting for a mutex that is held by this thread.
-    std::vector<SharedPtr<Thread>> wait_mutex_threads;
+    MutexWaitingThreads wait_mutex_threads;
 
     /// Thread that owns the lock that this thread is waiting for.
     SharedPtr<Thread> lock_owner;
 
-    // If waiting on a ConditionVariable, this is the ConditionVariable  address
-    VAddr condvar_wait_address;
-    VAddr mutex_wait_address; ///< If waiting on a Mutex, this is the mutex address
-    Handle wait_handle;       ///< The handle used to wait for the mutex.
+    /// If waiting on a ConditionVariable, this is the ConditionVariable address
+    VAddr condvar_wait_address = 0;
+    /// If waiting on a Mutex, this is the mutex address
+    VAddr mutex_wait_address = 0;
+    /// The handle used to wait for the mutex.
+    Handle wait_handle = 0;
 
-    // If waiting for an AddressArbiter, this is the address being waited on.
+    /// If waiting for an AddressArbiter, this is the address being waited on.
     VAddr arb_wait_address{0};
 
-    std::string name;
-
     /// Handle used by guest emulated application to access this thread
-    Handle guest_handle;
+    Handle guest_handle = 0;
 
     /// Handle used as userdata to reference this object when inserting into the CoreTiming queue.
-    Handle callback_handle;
+    Handle callback_handle = 0;
 
-    using WakeupCallback = bool(ThreadWakeupReason reason, SharedPtr<Thread> thread,
-                                SharedPtr<WaitObject> object, std::size_t index);
-    // Callback that will be invoked when the thread is resumed from a waiting state. If the thread
-    // was waiting via WaitSynchronizationN then the object will be the last object that became
-    // available. In case of a timeout, the object will be nullptr.
-    std::function<WakeupCallback> wakeup_callback;
+    /// Callback that will be invoked when the thread is resumed from a waiting state. If the thread
+    /// was waiting via WaitSynchronizationN then the object will be the last object that became
+    /// available. In case of a timeout, the object will be nullptr.
+    WakeupCallback wakeup_callback;
 
-    std::shared_ptr<Scheduler> scheduler;
+    Scheduler* scheduler = nullptr;
 
     u32 ideal_core{0xFFFFFFFF};
     u64 affinity_mask{0x1};
 
-private:
-    explicit Thread(KernelCore& kernel);
-    ~Thread() override;
-
     TLSMemoryPtr tls_memory = std::make_shared<TLSMemory>();
+
+    std::string name;
 };
 
 /**
diff --git a/src/core/hle/kernel/wait_object.cpp b/src/core/hle/kernel/wait_object.cpp
index b190ceb98..530ee6af7 100644
--- a/src/core/hle/kernel/wait_object.cpp
+++ b/src/core/hle/kernel/wait_object.cpp
@@ -35,13 +35,15 @@ SharedPtr<Thread> WaitObject::GetHighestPriorityReadyThread() {
     u32 candidate_priority = THREADPRIO_LOWEST + 1;
 
     for (const auto& thread : waiting_threads) {
+        const ThreadStatus thread_status = thread->GetStatus();
+
         // The list of waiting threads must not contain threads that are not waiting to be awakened.
-        ASSERT_MSG(thread->status == ThreadStatus::WaitSynchAny ||
-                       thread->status == ThreadStatus::WaitSynchAll ||
-                       thread->status == ThreadStatus::WaitHLEEvent,
+        ASSERT_MSG(thread_status == ThreadStatus::WaitSynchAny ||
+                       thread_status == ThreadStatus::WaitSynchAll ||
+                       thread_status == ThreadStatus::WaitHLEEvent,
                    "Inconsistent thread statuses in waiting_threads");
 
-        if (thread->current_priority >= candidate_priority)
+        if (thread->GetPriority() >= candidate_priority)
             continue;
 
         if (ShouldWait(thread.get()))
@@ -50,16 +52,13 @@ SharedPtr<Thread> WaitObject::GetHighestPriorityReadyThread() {
         // A thread is ready to run if it's either in ThreadStatus::WaitSynchAny or
         // in ThreadStatus::WaitSynchAll and the rest of the objects it is waiting on are ready.
         bool ready_to_run = true;
-        if (thread->status == ThreadStatus::WaitSynchAll) {
-            ready_to_run = std::none_of(thread->wait_objects.begin(), thread->wait_objects.end(),
-                                        [&thread](const SharedPtr<WaitObject>& object) {
-                                            return object->ShouldWait(thread.get());
-                                        });
+        if (thread_status == ThreadStatus::WaitSynchAll) {
+            ready_to_run = thread->AllWaitObjectsReady();
         }
 
         if (ready_to_run) {
             candidate = thread.get();
-            candidate_priority = thread->current_priority;
+            candidate_priority = thread->GetPriority();
         }
     }
 
@@ -75,24 +74,24 @@ void WaitObject::WakeupWaitingThread(SharedPtr<Thread> thread) {
     if (!thread->IsSleepingOnWaitAll()) {
         Acquire(thread.get());
     } else {
-        for (auto& object : thread->wait_objects) {
+        for (const auto& object : thread->GetWaitObjects()) {
             ASSERT(!object->ShouldWait(thread.get()));
             object->Acquire(thread.get());
         }
     }
 
-    std::size_t index = thread->GetWaitObjectIndex(this);
+    const std::size_t index = thread->GetWaitObjectIndex(this);
 
-    for (auto& object : thread->wait_objects)
+    for (const auto& object : thread->GetWaitObjects())
         object->RemoveWaitingThread(thread.get());
-    thread->wait_objects.clear();
+    thread->ClearWaitObjects();
 
     thread->CancelWakeupTimer();
 
     bool resume = true;
 
-    if (thread->wakeup_callback)
-        resume = thread->wakeup_callback(ThreadWakeupReason::Signal, thread, this, index);
+    if (thread->HasWakeupCallback())
+        resume = thread->InvokeWakeupCallback(ThreadWakeupReason::Signal, thread, this, index);
 
     if (resume)
         thread->ResumeFromWait();
diff --git a/src/core/hle/service/aoc/aoc_u.cpp b/src/core/hle/service/aoc/aoc_u.cpp
index 79580bcd9..0ecfb5af1 100644
--- a/src/core/hle/service/aoc/aoc_u.cpp
+++ b/src/core/hle/service/aoc/aoc_u.cpp
@@ -61,13 +61,13 @@ AOC_U::AOC_U() : ServiceFramework("aoc:u"), add_on_content(AccumulateAOCTitleIDs
 AOC_U::~AOC_U() = default;
 
 void AOC_U::CountAddOnContent(Kernel::HLERequestContext& ctx) {
-    IPC::ResponseBuilder rb{ctx, 4};
+    IPC::ResponseBuilder rb{ctx, 3};
     rb.Push(RESULT_SUCCESS);
 
     const auto current = Core::System::GetInstance().CurrentProcess()->GetTitleID();
-    rb.Push<u32>(std::count_if(add_on_content.begin(), add_on_content.end(), [&current](u64 tid) {
-        return (tid & DLC_BASE_TITLE_ID_MASK) == current;
-    }));
+    rb.Push<u32>(static_cast<u32>(
+        std::count_if(add_on_content.begin(), add_on_content.end(),
+                      [&current](u64 tid) { return (tid & DLC_BASE_TITLE_ID_MASK) == current; })));
 }
 
 void AOC_U::ListAddOnContent(Kernel::HLERequestContext& ctx) {
@@ -91,7 +91,7 @@ void AOC_U::ListAddOnContent(Kernel::HLERequestContext& ctx) {
         return;
     }
 
-    count = std::min<size_t>(out.size() - offset, count);
+    count = static_cast<u32>(std::min<size_t>(out.size() - offset, count));
     std::rotate(out.begin(), out.begin() + offset, out.end());
     out.resize(count);
 
diff --git a/src/core/hle/service/filesystem/filesystem.cpp b/src/core/hle/service/filesystem/filesystem.cpp
index aed2abb71..439e62d27 100644
--- a/src/core/hle/service/filesystem/filesystem.cpp
+++ b/src/core/hle/service/filesystem/filesystem.cpp
@@ -264,6 +264,15 @@ ResultCode RegisterBIS(std::unique_ptr<FileSys::BISFactory>&& factory) {
     return RESULT_SUCCESS;
 }
 
+void SetPackedUpdate(FileSys::VirtualFile update_raw) {
+    LOG_TRACE(Service_FS, "Setting packed update for romfs");
+
+    if (romfs_factory == nullptr)
+        return;
+
+    romfs_factory->SetPackedUpdate(std::move(update_raw));
+}
+
 ResultVal<FileSys::VirtualFile> OpenRomFSCurrentProcess() {
     LOG_TRACE(Service_FS, "Opening RomFS for current process");
 
diff --git a/src/core/hle/service/filesystem/filesystem.h b/src/core/hle/service/filesystem/filesystem.h
index 7039a2247..53b01bb01 100644
--- a/src/core/hle/service/filesystem/filesystem.h
+++ b/src/core/hle/service/filesystem/filesystem.h
@@ -39,6 +39,7 @@ ResultCode RegisterSaveData(std::unique_ptr<FileSys::SaveDataFactory>&& factory)
 ResultCode RegisterSDMC(std::unique_ptr<FileSys::SDMCFactory>&& factory);
 ResultCode RegisterBIS(std::unique_ptr<FileSys::BISFactory>&& factory);
 
+void SetPackedUpdate(FileSys::VirtualFile update_raw);
 ResultVal<FileSys::VirtualFile> OpenRomFSCurrentProcess();
 ResultVal<FileSys::VirtualFile> OpenRomFS(u64 title_id, FileSys::StorageId storage_id,
                                           FileSys::ContentRecordType type);
diff --git a/src/core/hle/service/nvdrv/devices/nvhost_as_gpu.cpp b/src/core/hle/service/nvdrv/devices/nvhost_as_gpu.cpp
index d8b8037a8..7555bbe7d 100644
--- a/src/core/hle/service/nvdrv/devices/nvhost_as_gpu.cpp
+++ b/src/core/hle/service/nvdrv/devices/nvhost_as_gpu.cpp
@@ -157,7 +157,12 @@ u32 nvhost_as_gpu::UnmapBuffer(const std::vector<u8>& input, std::vector<u8>& ou
     LOG_DEBUG(Service_NVDRV, "called, offset=0x{:X}", params.offset);
 
     const auto itr = buffer_mappings.find(params.offset);
-    ASSERT_MSG(itr != buffer_mappings.end(), "Tried to unmap invalid mapping");
+    if (itr == buffer_mappings.end()) {
+        LOG_WARNING(Service_NVDRV, "Tried to unmap an invalid offset 0x{:X}", params.offset);
+        // Hardware tests shows that unmapping an already unmapped buffer always returns successful
+        // and doesn't fail.
+        return 0;
+    }
 
     auto& system_instance = Core::System::GetInstance();
 
diff --git a/src/core/hle/service/sm/sm.h b/src/core/hle/service/sm/sm.h
index da2c51082..4f8145dda 100644
--- a/src/core/hle/service/sm/sm.h
+++ b/src/core/hle/service/sm/sm.h
@@ -6,9 +6,12 @@
 
 #include <memory>
 #include <string>
+#include <type_traits>
 #include <unordered_map>
 
+#include "core/hle/kernel/client_port.h"
 #include "core/hle/kernel/object.h"
+#include "core/hle/kernel/server_port.h"
 #include "core/hle/result.h"
 #include "core/hle/service/service.h"
 
@@ -48,6 +51,22 @@ public:
     ResultVal<Kernel::SharedPtr<Kernel::ClientPort>> GetServicePort(const std::string& name);
     ResultVal<Kernel::SharedPtr<Kernel::ClientSession>> ConnectToService(const std::string& name);
 
+    template <typename T>
+    std::shared_ptr<T> GetService(const std::string& service_name) const {
+        static_assert(std::is_base_of_v<Kernel::SessionRequestHandler, T>,
+                      "Not a base of ServiceFrameworkBase");
+        auto service = registered_services.find(service_name);
+        if (service == registered_services.end()) {
+            LOG_DEBUG(Service, "Can't find service: {}", service_name);
+            return nullptr;
+        }
+        auto port = service->second->GetServerPort();
+        if (port == nullptr) {
+            return nullptr;
+        }
+        return std::static_pointer_cast<T>(port->hle_handler);
+    }
+
     void InvokeControlRequest(Kernel::HLERequestContext& context);
 
 private:
diff --git a/src/core/loader/deconstructed_rom_directory.cpp b/src/core/loader/deconstructed_rom_directory.cpp
index 9a86e5824..951fd8257 100644
--- a/src/core/loader/deconstructed_rom_directory.cpp
+++ b/src/core/loader/deconstructed_rom_directory.cpp
@@ -3,6 +3,7 @@
 // Refer to the license.txt file included.
 
 #include <cinttypes>
+#include <cstring>
 #include "common/common_funcs.h"
 #include "common/file_util.h"
 #include "common/logging/log.h"
@@ -140,7 +141,8 @@ ResultStatus AppLoader_DeconstructedRomDirectory::Load(Kernel::Process& process)
         const FileSys::VirtualFile module_file = dir->GetFile(module);
         if (module_file != nullptr) {
             const VAddr load_addr = next_load_addr;
-            next_load_addr = AppLoader_NSO::LoadModule(module_file, load_addr, pm);
+            next_load_addr = AppLoader_NSO::LoadModule(module_file, load_addr,
+                                                       std::strcmp(module, "rtld") == 0, pm);
             LOG_DEBUG(Loader, "loaded module {} @ 0x{:X}", module, load_addr);
             // Register module with GDBStub
             GDBStub::RegisterModule(module, load_addr, next_load_addr - 1, false);
diff --git a/src/core/loader/loader.cpp b/src/core/loader/loader.cpp
index f2a183ba1..91659ec17 100644
--- a/src/core/loader/loader.cpp
+++ b/src/core/loader/loader.cpp
@@ -93,7 +93,7 @@ std::string GetFileTypeString(FileType type) {
     return "unknown";
 }
 
-constexpr std::array<const char*, 58> RESULT_MESSAGES{
+constexpr std::array<const char*, 59> RESULT_MESSAGES{
     "The operation completed successfully.",
     "The loader requested to load is already loaded.",
     "The operation is not implemented.",
@@ -152,6 +152,7 @@ constexpr std::array<const char*, 58> RESULT_MESSAGES{
     "The BKTR-type NCA has a bad Relocation bucket.",
     "The BKTR-type NCA has a bad Subsection bucket.",
     "The BKTR-type NCA is missing the base RomFS.",
+    "The NSP or XCI does not contain an update in addition to the base game.",
 };
 
 std::ostream& operator<<(std::ostream& os, ResultStatus status) {
diff --git a/src/core/loader/loader.h b/src/core/loader/loader.h
index 20e66109b..0e0333db5 100644
--- a/src/core/loader/loader.h
+++ b/src/core/loader/loader.h
@@ -114,6 +114,7 @@ enum class ResultStatus : u16 {
     ErrorBadRelocationBuckets,
     ErrorBadSubsectionBuckets,
     ErrorMissingBKTRBaseRomFS,
+    ErrorNoPackedUpdate,
 };
 
 std::ostream& operator<<(std::ostream& os, ResultStatus status);
@@ -196,10 +197,19 @@ public:
     /**
      * Get the RomFS of the application
      * Since the RomFS can be huge, we return a file reference instead of copying to a buffer
-     * @param dir The directory containing the RomFS
+     * @param file The directory containing the RomFS
      * @return ResultStatus result of function
      */
-    virtual ResultStatus ReadRomFS(FileSys::VirtualFile& dir) {
+    virtual ResultStatus ReadRomFS(FileSys::VirtualFile& file) {
+        return ResultStatus::ErrorNotImplemented;
+    }
+
+    /**
+     * Get the raw update of the application, should it come packed with one
+     * @param file The raw update NCA file (Program-type
+     * @return ResultStatus result of function
+     */
+    virtual ResultStatus ReadUpdateRaw(FileSys::VirtualFile& file) {
         return ResultStatus::ErrorNotImplemented;
     }
 
diff --git a/src/core/loader/nax.cpp b/src/core/loader/nax.cpp
index 073fb9d2f..42f4a777b 100644
--- a/src/core/loader/nax.cpp
+++ b/src/core/loader/nax.cpp
@@ -72,6 +72,10 @@ ResultStatus AppLoader_NAX::ReadRomFS(FileSys::VirtualFile& dir) {
     return nca_loader->ReadRomFS(dir);
 }
 
+u64 AppLoader_NAX::ReadRomFSIVFCOffset() const {
+    return nca_loader->ReadRomFSIVFCOffset();
+}
+
 ResultStatus AppLoader_NAX::ReadProgramId(u64& out_program_id) {
     return nca_loader->ReadProgramId(out_program_id);
 }
diff --git a/src/core/loader/nax.h b/src/core/loader/nax.h
index fc3c01876..b4d93bd01 100644
--- a/src/core/loader/nax.h
+++ b/src/core/loader/nax.h
@@ -36,6 +36,7 @@ public:
     ResultStatus Load(Kernel::Process& process) override;
 
     ResultStatus ReadRomFS(FileSys::VirtualFile& dir) override;
+    u64 ReadRomFSIVFCOffset() const override;
     ResultStatus ReadProgramId(u64& out_program_id) override;
 
 private:
diff --git a/src/core/loader/nro.cpp b/src/core/loader/nro.cpp
index c10f826a4..25dd3f04e 100644
--- a/src/core/loader/nro.cpp
+++ b/src/core/loader/nro.cpp
@@ -18,7 +18,9 @@
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/vm_manager.h"
 #include "core/loader/nro.h"
+#include "core/loader/nso.h"
 #include "core/memory.h"
+#include "core/settings.h"
 
 namespace Loader {
 
@@ -150,6 +152,19 @@ bool AppLoader_NRO::LoadNro(FileSys::VirtualFile file, VAddr load_base) {
         codeset->segments[i].size = PageAlignSize(nro_header.segments[i].size);
     }
 
+    if (!Settings::values.program_args.empty()) {
+        const auto arg_data = Settings::values.program_args;
+        codeset->DataSegment().size += NSO_ARGUMENT_DATA_ALLOCATION_SIZE;
+        NSOArgumentHeader args_header{
+            NSO_ARGUMENT_DATA_ALLOCATION_SIZE, static_cast<u32_le>(arg_data.size()), {}};
+        const auto end_offset = program_image.size();
+        program_image.resize(static_cast<u32>(program_image.size()) +
+                             NSO_ARGUMENT_DATA_ALLOCATION_SIZE);
+        std::memcpy(program_image.data() + end_offset, &args_header, sizeof(NSOArgumentHeader));
+        std::memcpy(program_image.data() + end_offset + sizeof(NSOArgumentHeader), arg_data.data(),
+                    arg_data.size());
+    }
+
     // Read MOD header
     ModHeader mod_header{};
     // Default .bss to NRO header bss size if MOD0 section doesn't exist
diff --git a/src/core/loader/nso.cpp b/src/core/loader/nso.cpp
index 2186b02af..28c6dd9b7 100644
--- a/src/core/loader/nso.cpp
+++ b/src/core/loader/nso.cpp
@@ -17,6 +17,7 @@
 #include "core/hle/kernel/vm_manager.h"
 #include "core/loader/nso.h"
 #include "core/memory.h"
+#include "core/settings.h"
 
 namespace Loader {
 
@@ -94,6 +95,7 @@ static constexpr u32 PageAlignSize(u32 size) {
 }
 
 VAddr AppLoader_NSO::LoadModule(FileSys::VirtualFile file, VAddr load_base,
+                                bool should_pass_arguments,
                                 boost::optional<FileSys::PatchManager> pm) {
     if (file == nullptr)
         return {};
@@ -125,6 +127,19 @@ VAddr AppLoader_NSO::LoadModule(FileSys::VirtualFile file, VAddr load_base,
         codeset->segments[i].size = PageAlignSize(static_cast<u32>(data.size()));
     }
 
+    if (should_pass_arguments && !Settings::values.program_args.empty()) {
+        const auto arg_data = Settings::values.program_args;
+        codeset->DataSegment().size += NSO_ARGUMENT_DATA_ALLOCATION_SIZE;
+        NSOArgumentHeader args_header{
+            NSO_ARGUMENT_DATA_ALLOCATION_SIZE, static_cast<u32_le>(arg_data.size()), {}};
+        const auto end_offset = program_image.size();
+        program_image.resize(static_cast<u32>(program_image.size()) +
+                             NSO_ARGUMENT_DATA_ALLOCATION_SIZE);
+        std::memcpy(program_image.data() + end_offset, &args_header, sizeof(NSOArgumentHeader));
+        std::memcpy(program_image.data() + end_offset + sizeof(NSOArgumentHeader), arg_data.data(),
+                    arg_data.size());
+    }
+
     // MOD header pointer is at .text offset + 4
     u32 module_offset;
     std::memcpy(&module_offset, program_image.data() + 4, sizeof(u32));
@@ -172,7 +187,7 @@ ResultStatus AppLoader_NSO::Load(Kernel::Process& process) {
 
     // Load module
     const VAddr base_address = process.VMManager().GetCodeRegionBaseAddress();
-    LoadModule(file, base_address);
+    LoadModule(file, base_address, true);
     LOG_DEBUG(Loader, "loaded module {} @ 0x{:X}", file->GetName(), base_address);
 
     process.Run(base_address, Kernel::THREADPRIO_DEFAULT, Memory::DEFAULT_STACK_SIZE);
diff --git a/src/core/loader/nso.h b/src/core/loader/nso.h
index 05353d4d9..70ab3b718 100644
--- a/src/core/loader/nso.h
+++ b/src/core/loader/nso.h
@@ -11,6 +11,15 @@
 
 namespace Loader {
 
+constexpr u64 NSO_ARGUMENT_DATA_ALLOCATION_SIZE = 0x9000;
+
+struct NSOArgumentHeader {
+    u32_le allocated_size;
+    u32_le actual_size;
+    INSERT_PADDING_BYTES(0x18);
+};
+static_assert(sizeof(NSOArgumentHeader) == 0x20, "NSOArgumentHeader has incorrect size.");
+
 /// Loads an NSO file
 class AppLoader_NSO final : public AppLoader, Linker {
 public:
@@ -27,7 +36,7 @@ public:
         return IdentifyType(file);
     }
 
-    static VAddr LoadModule(FileSys::VirtualFile file, VAddr load_base,
+    static VAddr LoadModule(FileSys::VirtualFile file, VAddr load_base, bool should_pass_arguments,
                             boost::optional<FileSys::PatchManager> pm = boost::none);
 
     ResultStatus Load(Kernel::Process& process) override;
diff --git a/src/core/loader/nsp.cpp b/src/core/loader/nsp.cpp
index b7ba77ef4..5534ce01c 100644
--- a/src/core/loader/nsp.cpp
+++ b/src/core/loader/nsp.cpp
@@ -10,8 +10,10 @@
 #include "core/file_sys/control_metadata.h"
 #include "core/file_sys/nca_metadata.h"
 #include "core/file_sys/patch_manager.h"
+#include "core/file_sys/registered_cache.h"
 #include "core/file_sys/submission_package.h"
 #include "core/hle/kernel/process.h"
+#include "core/hle/service/filesystem/filesystem.h"
 #include "core/loader/deconstructed_rom_directory.h"
 #include "core/loader/nca.h"
 #include "core/loader/nsp.h"
@@ -91,13 +93,39 @@ ResultStatus AppLoader_NSP::Load(Kernel::Process& process) {
     if (result != ResultStatus::Success)
         return result;
 
+    FileSys::VirtualFile update_raw;
+    if (ReadUpdateRaw(update_raw) == ResultStatus::Success && update_raw != nullptr)
+        Service::FileSystem::SetPackedUpdate(std::move(update_raw));
+
     is_loaded = true;
 
     return ResultStatus::Success;
 }
 
-ResultStatus AppLoader_NSP::ReadRomFS(FileSys::VirtualFile& dir) {
-    return secondary_loader->ReadRomFS(dir);
+ResultStatus AppLoader_NSP::ReadRomFS(FileSys::VirtualFile& file) {
+    return secondary_loader->ReadRomFS(file);
+}
+
+u64 AppLoader_NSP::ReadRomFSIVFCOffset() const {
+    return secondary_loader->ReadRomFSIVFCOffset();
+}
+
+ResultStatus AppLoader_NSP::ReadUpdateRaw(FileSys::VirtualFile& file) {
+    if (nsp->IsExtractedType())
+        return ResultStatus::ErrorNoPackedUpdate;
+
+    const auto read =
+        nsp->GetNCAFile(FileSys::GetUpdateTitleID(title_id), FileSys::ContentRecordType::Program);
+
+    if (read == nullptr)
+        return ResultStatus::ErrorNoPackedUpdate;
+    const auto nca_test = std::make_shared<FileSys::NCA>(read);
+
+    if (nca_test->GetStatus() != ResultStatus::ErrorMissingBKTRBaseRomFS)
+        return nca_test->GetStatus();
+
+    file = read;
+    return ResultStatus::Success;
 }
 
 ResultStatus AppLoader_NSP::ReadProgramId(u64& out_program_id) {
diff --git a/src/core/loader/nsp.h b/src/core/loader/nsp.h
index eac9b819a..b006594a6 100644
--- a/src/core/loader/nsp.h
+++ b/src/core/loader/nsp.h
@@ -37,7 +37,9 @@ public:
 
     ResultStatus Load(Kernel::Process& process) override;
 
-    ResultStatus ReadRomFS(FileSys::VirtualFile& dir) override;
+    ResultStatus ReadRomFS(FileSys::VirtualFile& file) override;
+    u64 ReadRomFSIVFCOffset() const override;
+    ResultStatus ReadUpdateRaw(FileSys::VirtualFile& file) override;
     ResultStatus ReadProgramId(u64& out_program_id) override;
     ResultStatus ReadIcon(std::vector<u8>& buffer) override;
     ResultStatus ReadTitle(std::string& title) override;
diff --git a/src/core/loader/xci.cpp b/src/core/loader/xci.cpp
index eda67a8c8..ee5452eb9 100644
--- a/src/core/loader/xci.cpp
+++ b/src/core/loader/xci.cpp
@@ -9,7 +9,11 @@
 #include "core/file_sys/content_archive.h"
 #include "core/file_sys/control_metadata.h"
 #include "core/file_sys/patch_manager.h"
+#include "core/file_sys/registered_cache.h"
+#include "core/file_sys/romfs.h"
+#include "core/file_sys/submission_package.h"
 #include "core/hle/kernel/process.h"
+#include "core/hle/service/filesystem/filesystem.h"
 #include "core/loader/nca.h"
 #include "core/loader/xci.h"
 
@@ -63,13 +67,41 @@ ResultStatus AppLoader_XCI::Load(Kernel::Process& process) {
     if (result != ResultStatus::Success)
         return result;
 
+    FileSys::VirtualFile update_raw;
+    if (ReadUpdateRaw(update_raw) == ResultStatus::Success && update_raw != nullptr)
+        Service::FileSystem::SetPackedUpdate(std::move(update_raw));
+
     is_loaded = true;
 
     return ResultStatus::Success;
 }
 
-ResultStatus AppLoader_XCI::ReadRomFS(FileSys::VirtualFile& dir) {
-    return nca_loader->ReadRomFS(dir);
+ResultStatus AppLoader_XCI::ReadRomFS(FileSys::VirtualFile& file) {
+    return nca_loader->ReadRomFS(file);
+}
+
+u64 AppLoader_XCI::ReadRomFSIVFCOffset() const {
+    return nca_loader->ReadRomFSIVFCOffset();
+}
+
+ResultStatus AppLoader_XCI::ReadUpdateRaw(FileSys::VirtualFile& file) {
+    u64 program_id{};
+    nca_loader->ReadProgramId(program_id);
+    if (program_id == 0)
+        return ResultStatus::ErrorXCIMissingProgramNCA;
+
+    const auto read = xci->GetSecurePartitionNSP()->GetNCAFile(
+        FileSys::GetUpdateTitleID(program_id), FileSys::ContentRecordType::Program);
+
+    if (read == nullptr)
+        return ResultStatus::ErrorNoPackedUpdate;
+    const auto nca_test = std::make_shared<FileSys::NCA>(read);
+
+    if (nca_test->GetStatus() != ResultStatus::ErrorMissingBKTRBaseRomFS)
+        return nca_test->GetStatus();
+
+    file = read;
+    return ResultStatus::Success;
 }
 
 ResultStatus AppLoader_XCI::ReadProgramId(u64& out_program_id) {
diff --git a/src/core/loader/xci.h b/src/core/loader/xci.h
index 17e47b658..770ed1437 100644
--- a/src/core/loader/xci.h
+++ b/src/core/loader/xci.h
@@ -37,7 +37,9 @@ public:
 
     ResultStatus Load(Kernel::Process& process) override;
 
-    ResultStatus ReadRomFS(FileSys::VirtualFile& dir) override;
+    ResultStatus ReadRomFS(FileSys::VirtualFile& file) override;
+    u64 ReadRomFSIVFCOffset() const override;
+    ResultStatus ReadUpdateRaw(FileSys::VirtualFile& file) override;
     ResultStatus ReadProgramId(u64& out_program_id) override;
     ResultStatus ReadIcon(std::vector<u8>& buffer) override;
     ResultStatus ReadTitle(std::string& title) override;
diff --git a/src/core/settings.h b/src/core/settings.h
index 0318d019c..83b9a04c8 100644
--- a/src/core/settings.h
+++ b/src/core/settings.h
@@ -155,6 +155,13 @@ struct Values {
     // Debugging
     bool use_gdbstub;
     u16 gdbstub_port;
+    std::string program_args;
+
+    // WebService
+    bool enable_telemetry;
+    std::string web_api_url;
+    std::string yuzu_username;
+    std::string yuzu_token;
 } extern values;
 
 void Apply();
diff --git a/src/core/telemetry_session.cpp b/src/core/telemetry_session.cpp
index b0df154ca..f29fff1e7 100644
--- a/src/core/telemetry_session.cpp
+++ b/src/core/telemetry_session.cpp
@@ -6,6 +6,8 @@
 #include "common/common_types.h"
 #include "common/file_util.h"
 
+#include <mbedtls/ctr_drbg.h>
+#include <mbedtls/entropy.h>
 #include "core/core.h"
 #include "core/file_sys/control_metadata.h"
 #include "core/file_sys/patch_manager.h"
@@ -13,10 +15,31 @@
 #include "core/settings.h"
 #include "core/telemetry_session.h"
 
+#ifdef ENABLE_WEB_SERVICE
+#include "web_service/telemetry_json.h"
+#include "web_service/verify_login.h"
+#endif
+
 namespace Core {
 
 static u64 GenerateTelemetryId() {
     u64 telemetry_id{};
+
+    mbedtls_entropy_context entropy;
+    mbedtls_entropy_init(&entropy);
+    mbedtls_ctr_drbg_context ctr_drbg;
+    std::string personalization = "yuzu Telemetry ID";
+
+    mbedtls_ctr_drbg_init(&ctr_drbg);
+    ASSERT(mbedtls_ctr_drbg_seed(&ctr_drbg, mbedtls_entropy_func, &entropy,
+                                 reinterpret_cast<const unsigned char*>(personalization.c_str()),
+                                 personalization.size()) == 0);
+    ASSERT(mbedtls_ctr_drbg_random(&ctr_drbg, reinterpret_cast<unsigned char*>(&telemetry_id),
+                                   sizeof(u64)) == 0);
+
+    mbedtls_ctr_drbg_free(&ctr_drbg);
+    mbedtls_entropy_free(&entropy);
+
     return telemetry_id;
 }
 
@@ -25,14 +48,21 @@ u64 GetTelemetryId() {
     const std::string filename{FileUtil::GetUserPath(FileUtil::UserPath::ConfigDir) +
                                "telemetry_id"};
 
-    if (FileUtil::Exists(filename)) {
+    bool generate_new_id = !FileUtil::Exists(filename);
+    if (!generate_new_id) {
         FileUtil::IOFile file(filename, "rb");
         if (!file.IsOpen()) {
             LOG_ERROR(Core, "failed to open telemetry_id: {}", filename);
             return {};
         }
         file.ReadBytes(&telemetry_id, sizeof(u64));
-    } else {
+        if (telemetry_id == 0) {
+            LOG_ERROR(Frontend, "telemetry_id is 0. Generating a new one.", telemetry_id);
+            generate_new_id = true;
+        }
+    }
+
+    if (generate_new_id) {
         FileUtil::IOFile file(filename, "wb");
         if (!file.IsOpen()) {
             LOG_ERROR(Core, "failed to open telemetry_id: {}", filename);
@@ -59,23 +89,20 @@ u64 RegenerateTelemetryId() {
     return new_telemetry_id;
 }
 
-std::future<bool> VerifyLogin(std::string username, std::string token, std::function<void()> func) {
+bool VerifyLogin(const std::string& username, const std::string& token) {
 #ifdef ENABLE_WEB_SERVICE
-    return WebService::VerifyLogin(username, token, Settings::values.verify_endpoint_url, func);
+    return WebService::VerifyLogin(Settings::values.web_api_url, username, token);
 #else
-    return std::async(std::launch::async, [func{std::move(func)}]() {
-        func();
-        return false;
-    });
+    return false;
 #endif
 }
 
 TelemetrySession::TelemetrySession() {
 #ifdef ENABLE_WEB_SERVICE
     if (Settings::values.enable_telemetry) {
-        backend = std::make_unique<WebService::TelemetryJson>(
-            Settings::values.telemetry_endpoint_url, Settings::values.yuzu_username,
-            Settings::values.yuzu_token);
+        backend = std::make_unique<WebService::TelemetryJson>(Settings::values.web_api_url,
+                                                              Settings::values.yuzu_username,
+                                                              Settings::values.yuzu_token);
     } else {
         backend = std::make_unique<Telemetry::NullVisitor>();
     }
@@ -94,7 +121,8 @@ TelemetrySession::TelemetrySession() {
     u64 program_id{};
     const Loader::ResultStatus res{System::GetInstance().GetAppLoader().ReadProgramId(program_id)};
     if (res == Loader::ResultStatus::Success) {
-        AddField(Telemetry::FieldType::Session, "ProgramId", program_id);
+        const std::string formatted_program_id{fmt::format("{:016X}", program_id)};
+        AddField(Telemetry::FieldType::Session, "ProgramId", formatted_program_id);
 
         std::string name;
         System::GetInstance().GetAppLoader().ReadTitle(name);
diff --git a/src/core/telemetry_session.h b/src/core/telemetry_session.h
index dbc4f8bd4..cec271df0 100644
--- a/src/core/telemetry_session.h
+++ b/src/core/telemetry_session.h
@@ -4,7 +4,6 @@
 
 #pragma once
 
-#include <future>
 #include <memory>
 #include "common/telemetry.h"
 
@@ -31,6 +30,8 @@ public:
         field_collection.AddField(type, name, std::move(value));
     }
 
+    static void FinalizeAsyncJob();
+
 private:
     Telemetry::FieldCollection field_collection; ///< Tracks all added fields for the session
     std::unique_ptr<Telemetry::VisitorInterface> backend; ///< Backend interface that logs fields
@@ -55,6 +56,6 @@ u64 RegenerateTelemetryId();
  * @param func A function that gets exectued when the verification is finished
  * @returns Future with bool indicating whether the verification succeeded
  */
-std::future<bool> VerifyLogin(std::string username, std::string token, std::function<void()> func);
+bool VerifyLogin(const std::string& username, const std::string& token);
 
 } // namespace Core
diff --git a/src/video_core/CMakeLists.txt b/src/video_core/CMakeLists.txt
index f5ae57039..09ecc5bad 100644
--- a/src/video_core/CMakeLists.txt
+++ b/src/video_core/CMakeLists.txt
@@ -27,6 +27,8 @@ add_library(video_core STATIC
     renderer_base.h
     renderer_opengl/gl_buffer_cache.cpp
     renderer_opengl/gl_buffer_cache.h
+    renderer_opengl/gl_primitive_assembler.cpp
+    renderer_opengl/gl_primitive_assembler.h
     renderer_opengl/gl_rasterizer.cpp
     renderer_opengl/gl_rasterizer.h
     renderer_opengl/gl_rasterizer_cache.cpp
diff --git a/src/video_core/engines/fermi_2d.cpp b/src/video_core/engines/fermi_2d.cpp
index ea1555c5d..912e785b9 100644
--- a/src/video_core/engines/fermi_2d.cpp
+++ b/src/video_core/engines/fermi_2d.cpp
@@ -4,11 +4,13 @@
 
 #include "core/memory.h"
 #include "video_core/engines/fermi_2d.h"
+#include "video_core/rasterizer_interface.h"
 #include "video_core/textures/decoders.h"
 
 namespace Tegra::Engines {
 
-Fermi2D::Fermi2D(MemoryManager& memory_manager) : memory_manager(memory_manager) {}
+Fermi2D::Fermi2D(VideoCore::RasterizerInterface& rasterizer, MemoryManager& memory_manager)
+    : memory_manager(memory_manager), rasterizer{rasterizer} {}
 
 void Fermi2D::WriteReg(u32 method, u32 value) {
     ASSERT_MSG(method < Regs::NUM_REGS,
@@ -44,27 +46,31 @@ void Fermi2D::HandleSurfaceCopy() {
     u32 src_bytes_per_pixel = RenderTargetBytesPerPixel(regs.src.format);
     u32 dst_bytes_per_pixel = RenderTargetBytesPerPixel(regs.dst.format);
 
-    if (regs.src.linear == regs.dst.linear) {
-        // If the input layout and the output layout are the same, just perform a raw copy.
-        ASSERT(regs.src.BlockHeight() == regs.dst.BlockHeight());
-        Memory::CopyBlock(dest_cpu, source_cpu,
-                          src_bytes_per_pixel * regs.dst.width * regs.dst.height);
-        return;
-    }
-
-    u8* src_buffer = Memory::GetPointer(source_cpu);
-    u8* dst_buffer = Memory::GetPointer(dest_cpu);
-
-    if (!regs.src.linear && regs.dst.linear) {
-        // If the input is tiled and the output is linear, deswizzle the input and copy it over.
-        Texture::CopySwizzledData(regs.src.width, regs.src.height, src_bytes_per_pixel,
-                                  dst_bytes_per_pixel, src_buffer, dst_buffer, true,
-                                  regs.src.BlockHeight());
-    } else {
-        // If the input is linear and the output is tiled, swizzle the input and copy it over.
-        Texture::CopySwizzledData(regs.src.width, regs.src.height, src_bytes_per_pixel,
-                                  dst_bytes_per_pixel, dst_buffer, src_buffer, false,
-                                  regs.dst.BlockHeight());
+    if (!rasterizer.AccelerateSurfaceCopy(regs.src, regs.dst)) {
+        // TODO(bunnei): The below implementation currently will not get hit, as
+        // AccelerateSurfaceCopy tries to always copy and will always return success. This should be
+        // changed once we properly support flushing.
+
+        if (regs.src.linear == regs.dst.linear) {
+            // If the input layout and the output layout are the same, just perform a raw copy.
+            ASSERT(regs.src.BlockHeight() == regs.dst.BlockHeight());
+            Memory::CopyBlock(dest_cpu, source_cpu,
+                              src_bytes_per_pixel * regs.dst.width * regs.dst.height);
+            return;
+        }
+        u8* src_buffer = Memory::GetPointer(source_cpu);
+        u8* dst_buffer = Memory::GetPointer(dest_cpu);
+        if (!regs.src.linear && regs.dst.linear) {
+            // If the input is tiled and the output is linear, deswizzle the input and copy it over.
+            Texture::CopySwizzledData(regs.src.width, regs.src.height, src_bytes_per_pixel,
+                                      dst_bytes_per_pixel, src_buffer, dst_buffer, true,
+                                      regs.src.BlockHeight());
+        } else {
+            // If the input is linear and the output is tiled, swizzle the input and copy it over.
+            Texture::CopySwizzledData(regs.src.width, regs.src.height, src_bytes_per_pixel,
+                                      dst_bytes_per_pixel, dst_buffer, src_buffer, false,
+                                      regs.dst.BlockHeight());
+        }
     }
 }
 
diff --git a/src/video_core/engines/fermi_2d.h b/src/video_core/engines/fermi_2d.h
index 021b83eaa..81d15c62a 100644
--- a/src/video_core/engines/fermi_2d.h
+++ b/src/video_core/engines/fermi_2d.h
@@ -12,6 +12,10 @@
 #include "video_core/gpu.h"
 #include "video_core/memory_manager.h"
 
+namespace VideoCore {
+class RasterizerInterface;
+}
+
 namespace Tegra::Engines {
 
 #define FERMI2D_REG_INDEX(field_name)                                                              \
@@ -19,7 +23,7 @@ namespace Tegra::Engines {
 
 class Fermi2D final {
 public:
-    explicit Fermi2D(MemoryManager& memory_manager);
+    explicit Fermi2D(VideoCore::RasterizerInterface& rasterizer, MemoryManager& memory_manager);
     ~Fermi2D() = default;
 
     /// Write the value to the register identified by method.
@@ -94,6 +98,8 @@ public:
     MemoryManager& memory_manager;
 
 private:
+    VideoCore::RasterizerInterface& rasterizer;
+
     /// Performs the copy from the source surface to the destination surface as configured in the
     /// registers.
     void HandleSurfaceCopy();
diff --git a/src/video_core/engines/maxwell_3d.h b/src/video_core/engines/maxwell_3d.h
index 9f5581045..4290da33f 100644
--- a/src/video_core/engines/maxwell_3d.h
+++ b/src/video_core/engines/maxwell_3d.h
@@ -744,6 +744,12 @@ public:
                         return static_cast<GPUVAddr>((static_cast<GPUVAddr>(end_addr_high) << 32) |
                                                      end_addr_low);
                     }
+
+                    /// Adjust the index buffer offset so it points to the first desired index.
+                    GPUVAddr IndexStart() const {
+                        return StartAddress() + static_cast<size_t>(first) *
+                                                    static_cast<size_t>(FormatSizeInBytes());
+                    }
                 } index_array;
 
                 INSERT_PADDING_WORDS(0x7);
diff --git a/src/video_core/gpu.cpp b/src/video_core/gpu.cpp
index baa8b63b7..9ba7e3533 100644
--- a/src/video_core/gpu.cpp
+++ b/src/video_core/gpu.cpp
@@ -25,7 +25,7 @@ u32 FramebufferConfig::BytesPerPixel(PixelFormat format) {
 GPU::GPU(VideoCore::RasterizerInterface& rasterizer) {
     memory_manager = std::make_unique<Tegra::MemoryManager>();
     maxwell_3d = std::make_unique<Engines::Maxwell3D>(rasterizer, *memory_manager);
-    fermi_2d = std::make_unique<Engines::Fermi2D>(*memory_manager);
+    fermi_2d = std::make_unique<Engines::Fermi2D>(rasterizer, *memory_manager);
     maxwell_compute = std::make_unique<Engines::MaxwellCompute>();
     maxwell_dma = std::make_unique<Engines::MaxwellDMA>(*memory_manager);
     kepler_memory = std::make_unique<Engines::KeplerMemory>(*memory_manager);
diff --git a/src/video_core/rasterizer_interface.h b/src/video_core/rasterizer_interface.h
index cd819d69f..06fc59dbe 100644
--- a/src/video_core/rasterizer_interface.h
+++ b/src/video_core/rasterizer_interface.h
@@ -5,6 +5,7 @@
 #pragma once
 
 #include "common/common_types.h"
+#include "video_core/engines/fermi_2d.h"
 #include "video_core/gpu.h"
 #include "video_core/memory_manager.h"
 
@@ -33,13 +34,9 @@ public:
     /// and invalidated
     virtual void FlushAndInvalidateRegion(VAddr addr, u64 size) = 0;
 
-    /// Attempt to use a faster method to perform a display transfer with is_texture_copy = 0
-    virtual bool AccelerateDisplayTransfer(const void* config) {
-        return false;
-    }
-
-    /// Attempt to use a faster method to perform a display transfer with is_texture_copy = 1
-    virtual bool AccelerateTextureCopy(const void* config) {
+    /// Attempt to use a faster method to perform a surface copy
+    virtual bool AccelerateSurfaceCopy(const Tegra::Engines::Fermi2D::Regs::Surface& src,
+                                       const Tegra::Engines::Fermi2D::Regs::Surface& dst) {
         return false;
     }
 
diff --git a/src/video_core/renderer_opengl/gl_buffer_cache.cpp b/src/video_core/renderer_opengl/gl_buffer_cache.cpp
index 578aca789..c142095c5 100644
--- a/src/video_core/renderer_opengl/gl_buffer_cache.cpp
+++ b/src/video_core/renderer_opengl/gl_buffer_cache.cpp
@@ -34,7 +34,7 @@ GLintptr OGLBufferCache::UploadMemory(Tegra::GPUVAddr gpu_addr, std::size_t size
     }
 
     AlignBuffer(alignment);
-    GLintptr uploaded_offset = buffer_offset;
+    const GLintptr uploaded_offset = buffer_offset;
 
     Memory::ReadBlock(*cpu_addr, buffer_ptr, size);
 
@@ -57,13 +57,23 @@ GLintptr OGLBufferCache::UploadHostMemory(const void* raw_pointer, std::size_t s
                                           std::size_t alignment) {
     AlignBuffer(alignment);
     std::memcpy(buffer_ptr, raw_pointer, size);
-    GLintptr uploaded_offset = buffer_offset;
+    const GLintptr uploaded_offset = buffer_offset;
 
     buffer_ptr += size;
     buffer_offset += size;
     return uploaded_offset;
 }
 
+std::tuple<u8*, GLintptr> OGLBufferCache::ReserveMemory(std::size_t size, std::size_t alignment) {
+    AlignBuffer(alignment);
+    u8* const uploaded_ptr = buffer_ptr;
+    const GLintptr uploaded_offset = buffer_offset;
+
+    buffer_ptr += size;
+    buffer_offset += size;
+    return std::make_tuple(uploaded_ptr, uploaded_offset);
+}
+
 void OGLBufferCache::Map(std::size_t max_size) {
     bool invalidate;
     std::tie(buffer_ptr, buffer_offset_base, invalidate) =
@@ -74,6 +84,7 @@ void OGLBufferCache::Map(std::size_t max_size) {
         InvalidateAll();
     }
 }
+
 void OGLBufferCache::Unmap() {
     stream_buffer.Unmap(buffer_offset - buffer_offset_base);
 }
@@ -84,7 +95,7 @@ GLuint OGLBufferCache::GetHandle() const {
 
 void OGLBufferCache::AlignBuffer(std::size_t alignment) {
     // Align the offset, not the mapped pointer
-    GLintptr offset_aligned =
+    const GLintptr offset_aligned =
         static_cast<GLintptr>(Common::AlignUp(static_cast<std::size_t>(buffer_offset), alignment));
     buffer_ptr += offset_aligned - buffer_offset;
     buffer_offset = offset_aligned;
diff --git a/src/video_core/renderer_opengl/gl_buffer_cache.h b/src/video_core/renderer_opengl/gl_buffer_cache.h
index 6c18461f4..965976334 100644
--- a/src/video_core/renderer_opengl/gl_buffer_cache.h
+++ b/src/video_core/renderer_opengl/gl_buffer_cache.h
@@ -6,6 +6,7 @@
 
 #include <cstddef>
 #include <memory>
+#include <tuple>
 
 #include "common/common_types.h"
 #include "video_core/rasterizer_cache.h"
@@ -33,11 +34,17 @@ class OGLBufferCache final : public RasterizerCache<std::shared_ptr<CachedBuffer
 public:
     explicit OGLBufferCache(std::size_t size);
 
+    /// Uploads data from a guest GPU address. Returns host's buffer offset where it's been
+    /// allocated.
     GLintptr UploadMemory(Tegra::GPUVAddr gpu_addr, std::size_t size, std::size_t alignment = 4,
                           bool cache = true);
 
+    /// Uploads from a host memory. Returns host's buffer offset where it's been allocated.
     GLintptr UploadHostMemory(const void* raw_pointer, std::size_t size, std::size_t alignment = 4);
 
+    /// Reserves memory to be used by host's CPU. Returns mapped address and offset.
+    std::tuple<u8*, GLintptr> ReserveMemory(std::size_t size, std::size_t alignment = 4);
+
     void Map(std::size_t max_size);
     void Unmap();
 
diff --git a/src/video_core/renderer_opengl/gl_primitive_assembler.cpp b/src/video_core/renderer_opengl/gl_primitive_assembler.cpp
new file mode 100644
index 000000000..ee1d9601b
--- /dev/null
+++ b/src/video_core/renderer_opengl/gl_primitive_assembler.cpp
@@ -0,0 +1,64 @@
+// Copyright 2018 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <algorithm>
+#include <array>
+#include "common/assert.h"
+#include "common/common_types.h"
+#include "core/memory.h"
+#include "video_core/renderer_opengl/gl_buffer_cache.h"
+#include "video_core/renderer_opengl/gl_primitive_assembler.h"
+
+namespace OpenGL {
+
+constexpr u32 TRIANGLES_PER_QUAD = 6;
+constexpr std::array<u32, TRIANGLES_PER_QUAD> QUAD_MAP = {0, 1, 2, 0, 2, 3};
+
+PrimitiveAssembler::PrimitiveAssembler(OGLBufferCache& buffer_cache) : buffer_cache(buffer_cache) {}
+
+PrimitiveAssembler::~PrimitiveAssembler() = default;
+
+std::size_t PrimitiveAssembler::CalculateQuadSize(u32 count) const {
+    ASSERT_MSG(count % 4 == 0, "Quad count is expected to be a multiple of 4");
+    return (count / 4) * TRIANGLES_PER_QUAD * sizeof(GLuint);
+}
+
+GLintptr PrimitiveAssembler::MakeQuadArray(u32 first, u32 count) {
+    const std::size_t size{CalculateQuadSize(count)};
+    auto [dst_pointer, index_offset] = buffer_cache.ReserveMemory(size);
+
+    for (u32 primitive = 0; primitive < count / 4; ++primitive) {
+        for (u32 i = 0; i < TRIANGLES_PER_QUAD; ++i) {
+            const u32 index = first + primitive * 4 + QUAD_MAP[i];
+            std::memcpy(dst_pointer, &index, sizeof(index));
+            dst_pointer += sizeof(index);
+        }
+    }
+
+    return index_offset;
+}
+
+GLintptr PrimitiveAssembler::MakeQuadIndexed(Tegra::GPUVAddr gpu_addr, std::size_t index_size,
+                                             u32 count) {
+    const std::size_t map_size{CalculateQuadSize(count)};
+    auto [dst_pointer, index_offset] = buffer_cache.ReserveMemory(map_size);
+
+    auto& memory_manager = Core::System::GetInstance().GPU().MemoryManager();
+    const boost::optional<VAddr> cpu_addr{memory_manager.GpuToCpuAddress(gpu_addr)};
+    const u8* source{Memory::GetPointer(*cpu_addr)};
+
+    for (u32 primitive = 0; primitive < count / 4; ++primitive) {
+        for (std::size_t i = 0; i < TRIANGLES_PER_QUAD; ++i) {
+            const u32 index = primitive * 4 + QUAD_MAP[i];
+            const u8* src_offset = source + (index * index_size);
+
+            std::memcpy(dst_pointer, src_offset, index_size);
+            dst_pointer += index_size;
+        }
+    }
+
+    return index_offset;
+}
+
+} // namespace OpenGL
\ No newline at end of file
diff --git a/src/video_core/renderer_opengl/gl_primitive_assembler.h b/src/video_core/renderer_opengl/gl_primitive_assembler.h
new file mode 100644
index 000000000..a8cb88eb5
--- /dev/null
+++ b/src/video_core/renderer_opengl/gl_primitive_assembler.h
@@ -0,0 +1,33 @@
+// Copyright 2018 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <vector>
+#include <glad/glad.h>
+
+#include "common/common_types.h"
+#include "video_core/memory_manager.h"
+
+namespace OpenGL {
+
+class OGLBufferCache;
+
+class PrimitiveAssembler {
+public:
+    explicit PrimitiveAssembler(OGLBufferCache& buffer_cache);
+    ~PrimitiveAssembler();
+
+    /// Calculates the size required by MakeQuadArray and MakeQuadIndexed.
+    std::size_t CalculateQuadSize(u32 count) const;
+
+    GLintptr MakeQuadArray(u32 first, u32 count);
+
+    GLintptr MakeQuadIndexed(Tegra::GPUVAddr gpu_addr, std::size_t index_size, u32 count);
+
+private:
+    OGLBufferCache& buffer_cache;
+};
+
+} // namespace OpenGL
\ No newline at end of file
diff --git a/src/video_core/renderer_opengl/gl_rasterizer.cpp b/src/video_core/renderer_opengl/gl_rasterizer.cpp
index 587d9dffb..209bdf181 100644
--- a/src/video_core/renderer_opengl/gl_rasterizer.cpp
+++ b/src/video_core/renderer_opengl/gl_rasterizer.cpp
@@ -42,6 +42,41 @@ MICROPROFILE_DEFINE(OpenGL_Framebuffer, "OpenGL", "Framebuffer Setup", MP_RGB(12
 MICROPROFILE_DEFINE(OpenGL_Drawing, "OpenGL", "Drawing", MP_RGB(128, 128, 192));
 MICROPROFILE_DEFINE(OpenGL_Blits, "OpenGL", "Blits", MP_RGB(128, 128, 192));
 MICROPROFILE_DEFINE(OpenGL_CacheManagement, "OpenGL", "Cache Mgmt", MP_RGB(100, 255, 100));
+MICROPROFILE_DEFINE(OpenGL_PrimitiveAssembly, "OpenGL", "Prim Asmbl", MP_RGB(255, 100, 100));
+
+struct DrawParameters {
+    GLenum primitive_mode;
+    GLsizei count;
+    GLint current_instance;
+    bool use_indexed;
+
+    GLint vertex_first;
+
+    GLenum index_format;
+    GLint base_vertex;
+    GLintptr index_buffer_offset;
+
+    void DispatchDraw() const {
+        if (use_indexed) {
+            const auto index_buffer_ptr = reinterpret_cast<const void*>(index_buffer_offset);
+            if (current_instance > 0) {
+                glDrawElementsInstancedBaseVertexBaseInstance(primitive_mode, count, index_format,
+                                                              index_buffer_ptr, 1, base_vertex,
+                                                              current_instance);
+            } else {
+                glDrawElementsBaseVertex(primitive_mode, count, index_format, index_buffer_ptr,
+                                         base_vertex);
+            }
+        } else {
+            if (current_instance > 0) {
+                glDrawArraysInstancedBaseInstance(primitive_mode, vertex_first, count, 1,
+                                                  current_instance);
+            } else {
+                glDrawArrays(primitive_mode, vertex_first, count);
+            }
+        }
+    }
+};
 
 RasterizerOpenGL::RasterizerOpenGL(Core::Frontend::EmuWindow& window, ScreenInfo& info)
     : emu_window{window}, screen_info{info}, buffer_cache(STREAM_BUFFER_SIZE) {
@@ -172,6 +207,54 @@ void RasterizerOpenGL::SetupVertexArrays() {
     }
 }
 
+DrawParameters RasterizerOpenGL::SetupDraw() {
+    const auto& gpu = Core::System::GetInstance().GPU().Maxwell3D();
+    const auto& regs = gpu.regs;
+    const bool is_indexed = accelerate_draw == AccelDraw::Indexed;
+
+    DrawParameters params{};
+    params.current_instance = gpu.state.current_instance;
+
+    if (regs.draw.topology == Maxwell::PrimitiveTopology::Quads) {
+        MICROPROFILE_SCOPE(OpenGL_PrimitiveAssembly);
+
+        params.use_indexed = true;
+        params.primitive_mode = GL_TRIANGLES;
+
+        if (is_indexed) {
+            params.index_format = MaxwellToGL::IndexFormat(regs.index_array.format);
+            params.count = (regs.index_array.count / 4) * 6;
+            params.index_buffer_offset = primitive_assembler.MakeQuadIndexed(
+                regs.index_array.IndexStart(), regs.index_array.FormatSizeInBytes(),
+                regs.index_array.count);
+            params.base_vertex = static_cast<GLint>(regs.vb_element_base);
+        } else {
+            // MakeQuadArray always generates u32 indexes
+            params.index_format = GL_UNSIGNED_INT;
+            params.count = (regs.vertex_buffer.count / 4) * 6;
+            params.index_buffer_offset =
+                primitive_assembler.MakeQuadArray(regs.vertex_buffer.first, params.count);
+        }
+        return params;
+    }
+
+    params.use_indexed = is_indexed;
+    params.primitive_mode = MaxwellToGL::PrimitiveTopology(regs.draw.topology);
+
+    if (is_indexed) {
+        MICROPROFILE_SCOPE(OpenGL_Index);
+        params.index_format = MaxwellToGL::IndexFormat(regs.index_array.format);
+        params.count = regs.index_array.count;
+        params.index_buffer_offset =
+            buffer_cache.UploadMemory(regs.index_array.IndexStart(), CalculateIndexBufferSize());
+        params.base_vertex = static_cast<GLint>(regs.vb_element_base);
+    } else {
+        params.count = regs.vertex_buffer.count;
+        params.vertex_first = regs.vertex_buffer.first;
+    }
+    return params;
+}
+
 void RasterizerOpenGL::SetupShaders() {
     MICROPROFILE_SCOPE(OpenGL_Shader);
     const auto& gpu = Core::System::GetInstance().GPU().Maxwell3D();
@@ -256,6 +339,13 @@ std::size_t RasterizerOpenGL::CalculateVertexArraysSize() const {
     return size;
 }
 
+std::size_t RasterizerOpenGL::CalculateIndexBufferSize() const {
+    const auto& regs = Core::System::GetInstance().GPU().Maxwell3D().regs;
+
+    return static_cast<std::size_t>(regs.index_array.count) *
+           static_cast<std::size_t>(regs.index_array.FormatSizeInBytes());
+}
+
 bool RasterizerOpenGL::AccelerateDrawBatch(bool is_indexed) {
     accelerate_draw = is_indexed ? AccelDraw::Indexed : AccelDraw::Arrays;
     DrawArrays();
@@ -459,16 +549,23 @@ void RasterizerOpenGL::DrawArrays() {
 
     // Draw the vertex batch
     const bool is_indexed = accelerate_draw == AccelDraw::Indexed;
-    const u64 index_buffer_size{static_cast<u64>(regs.index_array.count) *
-                                static_cast<u64>(regs.index_array.FormatSizeInBytes())};
 
     state.draw.vertex_buffer = buffer_cache.GetHandle();
     state.Apply();
 
     std::size_t buffer_size = CalculateVertexArraysSize();
 
-    if (is_indexed) {
-        buffer_size = Common::AlignUp<std::size_t>(buffer_size, 4) + index_buffer_size;
+    // Add space for index buffer (keeping in mind non-core primitives)
+    switch (regs.draw.topology) {
+    case Maxwell::PrimitiveTopology::Quads:
+        buffer_size = Common::AlignUp<std::size_t>(buffer_size, 4) +
+                      primitive_assembler.CalculateQuadSize(regs.vertex_buffer.count);
+        break;
+    default:
+        if (is_indexed) {
+            buffer_size = Common::AlignUp<std::size_t>(buffer_size, 4) + CalculateIndexBufferSize();
+        }
+        break;
     }
 
     // Uniform space for the 5 shader stages
@@ -482,20 +579,7 @@ void RasterizerOpenGL::DrawArrays() {
     buffer_cache.Map(buffer_size);
 
     SetupVertexArrays();
-
-    // If indexed mode, copy the index buffer
-    GLintptr index_buffer_offset = 0;
-    if (is_indexed) {
-        MICROPROFILE_SCOPE(OpenGL_Index);
-
-        // Adjust the index buffer offset so it points to the first desired index.
-        auto index_start = regs.index_array.StartAddress();
-        index_start += static_cast<size_t>(regs.index_array.first) *
-                       static_cast<size_t>(regs.index_array.FormatSizeInBytes());
-
-        index_buffer_offset = buffer_cache.UploadMemory(index_start, index_buffer_size);
-    }
-
+    DrawParameters params = SetupDraw();
     SetupShaders();
 
     buffer_cache.Unmap();
@@ -503,31 +587,8 @@ void RasterizerOpenGL::DrawArrays() {
     shader_program_manager->ApplyTo(state);
     state.Apply();
 
-    const GLenum primitive_mode{MaxwellToGL::PrimitiveTopology(regs.draw.topology)};
-    if (is_indexed) {
-        const GLint base_vertex{static_cast<GLint>(regs.vb_element_base)};
-
-        if (gpu.state.current_instance > 0) {
-            glDrawElementsInstancedBaseVertexBaseInstance(
-                primitive_mode, regs.index_array.count,
-                MaxwellToGL::IndexFormat(regs.index_array.format),
-                reinterpret_cast<const void*>(index_buffer_offset), 1, base_vertex,
-                gpu.state.current_instance);
-        } else {
-            glDrawElementsBaseVertex(primitive_mode, regs.index_array.count,
-                                     MaxwellToGL::IndexFormat(regs.index_array.format),
-                                     reinterpret_cast<const void*>(index_buffer_offset),
-                                     base_vertex);
-        }
-    } else {
-        if (gpu.state.current_instance > 0) {
-            glDrawArraysInstancedBaseInstance(primitive_mode, regs.vertex_buffer.first,
-                                              regs.vertex_buffer.count, 1,
-                                              gpu.state.current_instance);
-        } else {
-            glDrawArrays(primitive_mode, regs.vertex_buffer.first, regs.vertex_buffer.count);
-        }
-    }
+    // Execute draw call
+    params.DispatchDraw();
 
     // Disable scissor test
     state.scissor.enabled = false;
@@ -556,14 +617,10 @@ void RasterizerOpenGL::FlushAndInvalidateRegion(VAddr addr, u64 size) {
     InvalidateRegion(addr, size);
 }
 
-bool RasterizerOpenGL::AccelerateDisplayTransfer(const void* config) {
+bool RasterizerOpenGL::AccelerateSurfaceCopy(const Tegra::Engines::Fermi2D::Regs::Surface& src,
+                                             const Tegra::Engines::Fermi2D::Regs::Surface& dst) {
     MICROPROFILE_SCOPE(OpenGL_Blits);
-    UNREACHABLE();
-    return true;
-}
-
-bool RasterizerOpenGL::AccelerateTextureCopy(const void* config) {
-    UNREACHABLE();
+    res_cache.FermiCopySurface(src, dst);
     return true;
 }
 
@@ -601,10 +658,13 @@ void RasterizerOpenGL::SamplerInfo::Create() {
     sampler.Create();
     mag_filter = min_filter = Tegra::Texture::TextureFilter::Linear;
     wrap_u = wrap_v = wrap_p = Tegra::Texture::WrapMode::Wrap;
+    uses_depth_compare = false;
+    depth_compare_func = Tegra::Texture::DepthCompareFunc::Never;
 
     // default is GL_LINEAR_MIPMAP_LINEAR
     glSamplerParameteri(sampler.handle, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
     // Other attributes have correct defaults
+    glSamplerParameteri(sampler.handle, GL_TEXTURE_COMPARE_FUNC, GL_NEVER);
 }
 
 void RasterizerOpenGL::SamplerInfo::SyncWithConfig(const Tegra::Texture::TSCEntry& config) {
@@ -632,6 +692,21 @@ void RasterizerOpenGL::SamplerInfo::SyncWithConfig(const Tegra::Texture::TSCEntr
         glSamplerParameteri(s, GL_TEXTURE_WRAP_R, MaxwellToGL::WrapMode(wrap_p));
     }
 
+    if (uses_depth_compare != (config.depth_compare_enabled == 1)) {
+        uses_depth_compare = (config.depth_compare_enabled == 1);
+        if (uses_depth_compare) {
+            glSamplerParameteri(s, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE);
+        } else {
+            glSamplerParameteri(s, GL_TEXTURE_COMPARE_MODE, GL_NONE);
+        }
+    }
+
+    if (depth_compare_func != config.depth_compare_func) {
+        depth_compare_func = config.depth_compare_func;
+        glSamplerParameteri(s, GL_TEXTURE_COMPARE_FUNC,
+                            MaxwellToGL::DepthCompareFunc(depth_compare_func));
+    }
+
     if (wrap_u == Tegra::Texture::WrapMode::Border || wrap_v == Tegra::Texture::WrapMode::Border ||
         wrap_p == Tegra::Texture::WrapMode::Border) {
         const GLvec4 new_border_color = {{config.border_color_r, config.border_color_g,
diff --git a/src/video_core/renderer_opengl/gl_rasterizer.h b/src/video_core/renderer_opengl/gl_rasterizer.h
index 4c8ecbd1c..0dab2018b 100644
--- a/src/video_core/renderer_opengl/gl_rasterizer.h
+++ b/src/video_core/renderer_opengl/gl_rasterizer.h
@@ -23,6 +23,7 @@
 #include "video_core/rasterizer_cache.h"
 #include "video_core/rasterizer_interface.h"
 #include "video_core/renderer_opengl/gl_buffer_cache.h"
+#include "video_core/renderer_opengl/gl_primitive_assembler.h"
 #include "video_core/renderer_opengl/gl_rasterizer_cache.h"
 #include "video_core/renderer_opengl/gl_resource_manager.h"
 #include "video_core/renderer_opengl/gl_shader_cache.h"
@@ -38,6 +39,7 @@ class EmuWindow;
 namespace OpenGL {
 
 struct ScreenInfo;
+struct DrawParameters;
 
 class RasterizerOpenGL : public VideoCore::RasterizerInterface {
 public:
@@ -50,8 +52,8 @@ public:
     void FlushRegion(VAddr addr, u64 size) override;
     void InvalidateRegion(VAddr addr, u64 size) override;
     void FlushAndInvalidateRegion(VAddr addr, u64 size) override;
-    bool AccelerateDisplayTransfer(const void* config) override;
-    bool AccelerateTextureCopy(const void* config) override;
+    bool AccelerateSurfaceCopy(const Tegra::Engines::Fermi2D::Regs::Surface& src,
+                               const Tegra::Engines::Fermi2D::Regs::Surface& dst) override;
     bool AccelerateFill(const void* config) override;
     bool AccelerateDisplay(const Tegra::FramebufferConfig& config, VAddr framebuffer_addr,
                            u32 pixel_stride) override;
@@ -94,6 +96,8 @@ private:
         Tegra::Texture::WrapMode wrap_u;
         Tegra::Texture::WrapMode wrap_v;
         Tegra::Texture::WrapMode wrap_p;
+        bool uses_depth_compare;
+        Tegra::Texture::DepthCompareFunc depth_compare_func;
         GLvec4 border_color;
     };
 
@@ -192,12 +196,17 @@ private:
     static constexpr std::size_t STREAM_BUFFER_SIZE = 128 * 1024 * 1024;
     OGLBufferCache buffer_cache;
     OGLFramebuffer framebuffer;
+    PrimitiveAssembler primitive_assembler{buffer_cache};
     GLint uniform_buffer_alignment;
 
     std::size_t CalculateVertexArraysSize() const;
 
+    std::size_t CalculateIndexBufferSize() const;
+
     void SetupVertexArrays();
 
+    DrawParameters SetupDraw();
+
     void SetupShaders();
 
     enum class AccelDraw { Disabled, Arrays, Indexed };
diff --git a/src/video_core/renderer_opengl/gl_rasterizer_cache.cpp b/src/video_core/renderer_opengl/gl_rasterizer_cache.cpp
index ce967c4d6..56ff83eff 100644
--- a/src/video_core/renderer_opengl/gl_rasterizer_cache.cpp
+++ b/src/video_core/renderer_opengl/gl_rasterizer_cache.cpp
@@ -143,6 +143,28 @@ static VAddr TryGetCpuAddr(Tegra::GPUVAddr gpu_addr) {
     return params;
 }
 
+/*static*/ SurfaceParams SurfaceParams::CreateForFermiCopySurface(
+    const Tegra::Engines::Fermi2D::Regs::Surface& config) {
+    SurfaceParams params{};
+    params.addr = TryGetCpuAddr(config.Address());
+    params.is_tiled = !config.linear;
+    params.block_height = params.is_tiled ? config.BlockHeight() : 0,
+    params.pixel_format = PixelFormatFromRenderTargetFormat(config.format);
+    params.component_type = ComponentTypeFromRenderTarget(config.format);
+    params.type = GetFormatType(params.pixel_format);
+    params.width = config.width;
+    params.height = config.height;
+    params.unaligned_height = config.height;
+    params.target = SurfaceTarget::Texture2D;
+    params.depth = 1;
+    params.size_in_bytes_total = params.SizeInBytesTotal();
+    params.size_in_bytes_2d = params.SizeInBytes2D();
+    params.max_mip_level = 0;
+    params.rt = {};
+
+    return params;
+}
+
 static constexpr std::array<FormatTuple, SurfaceParams::MaxPixelFormat> tex_format_tuples = {{
     {GL_RGBA8, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, ComponentType::UNorm, false}, // ABGR8U
     {GL_RGBA8, GL_RGBA, GL_BYTE, ComponentType::SNorm, false},                     // ABGR8S
@@ -559,6 +581,18 @@ static bool BlitSurface(const Surface& src_surface, const Surface& dst_surface,
     return true;
 }
 
+static void FastCopySurface(const Surface& src_surface, const Surface& dst_surface) {
+    const auto& src_params{src_surface->GetSurfaceParams()};
+    const auto& dst_params{dst_surface->GetSurfaceParams()};
+
+    const u32 width{std::min(src_params.width, dst_params.width)};
+    const u32 height{std::min(src_params.height, dst_params.height)};
+
+    glCopyImageSubData(src_surface->Texture().handle, SurfaceTargetToGL(src_params.target), 0, 0, 0,
+                       0, dst_surface->Texture().handle, SurfaceTargetToGL(dst_params.target), 0, 0,
+                       0, 0, width, height, 1);
+}
+
 static void CopySurface(const Surface& src_surface, const Surface& dst_surface,
                         GLuint copy_pbo_handle, GLenum src_attachment = 0,
                         GLenum dst_attachment = 0, std::size_t cubemap_face = 0) {
@@ -1033,6 +1067,26 @@ Surface RasterizerCacheOpenGL::GetUncachedSurface(const SurfaceParams& params) {
     return surface;
 }
 
+void RasterizerCacheOpenGL::FermiCopySurface(
+    const Tegra::Engines::Fermi2D::Regs::Surface& src_config,
+    const Tegra::Engines::Fermi2D::Regs::Surface& dst_config) {
+
+    const auto& src_params = SurfaceParams::CreateForFermiCopySurface(src_config);
+    const auto& dst_params = SurfaceParams::CreateForFermiCopySurface(dst_config);
+
+    ASSERT(src_params.width == dst_params.width);
+    ASSERT(src_params.height == dst_params.height);
+    ASSERT(src_params.pixel_format == dst_params.pixel_format);
+    ASSERT(src_params.block_height == dst_params.block_height);
+    ASSERT(src_params.is_tiled == dst_params.is_tiled);
+    ASSERT(src_params.depth == dst_params.depth);
+    ASSERT(src_params.depth == 1); // Currently, FastCopySurface only works with 2D surfaces
+    ASSERT(src_params.target == dst_params.target);
+    ASSERT(src_params.rt.index == dst_params.rt.index);
+
+    FastCopySurface(GetSurface(src_params, true), GetSurface(dst_params, false));
+}
+
 Surface RasterizerCacheOpenGL::RecreateSurface(const Surface& old_surface,
                                                const SurfaceParams& new_params) {
     // Verify surface is compatible for blitting
@@ -1041,6 +1095,15 @@ Surface RasterizerCacheOpenGL::RecreateSurface(const Surface& old_surface,
     // Get a new surface with the new parameters, and blit the previous surface to it
     Surface new_surface{GetUncachedSurface(new_params)};
 
+    // For compatible surfaces, we can just do fast glCopyImageSubData based copy
+    if (old_params.target == new_params.target && old_params.type == new_params.type &&
+        old_params.depth == new_params.depth && old_params.depth == 1 &&
+        SurfaceParams::GetFormatBpp(old_params.pixel_format) ==
+            SurfaceParams::GetFormatBpp(new_params.pixel_format)) {
+        FastCopySurface(old_surface, new_surface);
+        return new_surface;
+    }
+
     // If the format is the same, just do a framebuffer blit. This is significantly faster than
     // using PBOs. The is also likely less accurate, as textures will be converted rather than
     // reinterpreted. When use_accurate_framebuffers setting is enabled, perform a more accurate
diff --git a/src/video_core/renderer_opengl/gl_rasterizer_cache.h b/src/video_core/renderer_opengl/gl_rasterizer_cache.h
index 49025a3fe..0b4940b3c 100644
--- a/src/video_core/renderer_opengl/gl_rasterizer_cache.h
+++ b/src/video_core/renderer_opengl/gl_rasterizer_cache.h
@@ -13,6 +13,7 @@
 #include "common/common_types.h"
 #include "common/hash.h"
 #include "common/math_util.h"
+#include "video_core/engines/fermi_2d.h"
 #include "video_core/engines/maxwell_3d.h"
 #include "video_core/rasterizer_cache.h"
 #include "video_core/renderer_opengl/gl_resource_manager.h"
@@ -719,6 +720,10 @@ struct SurfaceParams {
                                               Tegra::GPUVAddr zeta_address,
                                               Tegra::DepthFormat format);
 
+    /// Creates SurfaceParams for a Fermi2D surface copy
+    static SurfaceParams CreateForFermiCopySurface(
+        const Tegra::Engines::Fermi2D::Regs::Surface& config);
+
     /// Checks if surfaces are compatible for caching
     bool IsCompatibleSurface(const SurfaceParams& other) const {
         return std::tie(pixel_format, type, width, height, target, depth) ==
@@ -837,6 +842,10 @@ public:
     /// Tries to find a framebuffer using on the provided CPU address
     Surface TryFindFramebufferSurface(VAddr addr) const;
 
+    /// Copies the contents of one surface to another
+    void FermiCopySurface(const Tegra::Engines::Fermi2D::Regs::Surface& src_config,
+                          const Tegra::Engines::Fermi2D::Regs::Surface& dst_config);
+
 private:
     void LoadSurface(const Surface& surface);
     Surface GetSurface(const SurfaceParams& params, bool preserve_contents = true);
diff --git a/src/video_core/renderer_opengl/gl_shader_decompiler.cpp b/src/video_core/renderer_opengl/gl_shader_decompiler.cpp
index 579a78702..7e57de78a 100644
--- a/src/video_core/renderer_opengl/gl_shader_decompiler.cpp
+++ b/src/video_core/renderer_opengl/gl_shader_decompiler.cpp
@@ -508,7 +508,7 @@ public:
     /// Returns the GLSL sampler used for the input shader sampler, and creates a new one if
     /// necessary.
     std::string AccessSampler(const Sampler& sampler, Tegra::Shader::TextureType type,
-                              bool is_array) {
+                              bool is_array, bool is_shadow) {
         const std::size_t offset = static_cast<std::size_t>(sampler.index.Value());
 
         // If this sampler has already been used, return the existing mapping.
@@ -517,13 +517,14 @@ public:
                          [&](const SamplerEntry& entry) { return entry.GetOffset() == offset; });
 
         if (itr != used_samplers.end()) {
-            ASSERT(itr->GetType() == type && itr->IsArray() == is_array);
+            ASSERT(itr->GetType() == type && itr->IsArray() == is_array &&
+                   itr->IsShadow() == is_shadow);
             return itr->GetName();
         }
 
         // Otherwise create a new mapping for this sampler
         const std::size_t next_index = used_samplers.size();
-        const SamplerEntry entry{stage, offset, next_index, type, is_array};
+        const SamplerEntry entry{stage, offset, next_index, type, is_array, is_shadow};
         used_samplers.emplace_back(entry);
         return entry.GetName();
     }
@@ -747,8 +748,9 @@ private:
     }
 
     /// Generates code representing a texture sampler.
-    std::string GetSampler(const Sampler& sampler, Tegra::Shader::TextureType type, bool is_array) {
-        return regs.AccessSampler(sampler, type, is_array);
+    std::string GetSampler(const Sampler& sampler, Tegra::Shader::TextureType type, bool is_array,
+                           bool is_shadow) {
+        return regs.AccessSampler(sampler, type, is_array, is_shadow);
     }
 
     /**
@@ -1002,6 +1004,24 @@ private:
         shader.AddLine('}');
     }
 
+    static u32 TextureCoordinates(Tegra::Shader::TextureType texture_type) {
+        switch (texture_type) {
+        case Tegra::Shader::TextureType::Texture1D: {
+            return 1;
+        }
+        case Tegra::Shader::TextureType::Texture2D: {
+            return 2;
+        }
+        case Tegra::Shader::TextureType::TextureCube: {
+            return 3;
+        }
+        default:
+            LOG_CRITICAL(HW_GPU, "Unhandled texture type {}", static_cast<u32>(texture_type));
+            UNREACHABLE();
+            return 0;
+        }
+    }
+
     /*
      * Emits code to push the input target address to the SSY address stack, incrementing the stack
      * top.
@@ -1896,24 +1916,35 @@ private:
                            "NODEP is not implemented");
                 ASSERT_MSG(!instr.tex.UsesMiscMode(Tegra::Shader::TextureMiscMode::AOFFI),
                            "AOFFI is not implemented");
-                ASSERT_MSG(!instr.tex.UsesMiscMode(Tegra::Shader::TextureMiscMode::DC),
-                           "DC is not implemented");
 
-                switch (texture_type) {
-                case Tegra::Shader::TextureType::Texture1D: {
+                const bool depth_compare =
+                    instr.tex.UsesMiscMode(Tegra::Shader::TextureMiscMode::DC);
+                u32 num_coordinates = TextureCoordinates(texture_type);
+                if (depth_compare)
+                    num_coordinates += 1;
+
+                switch (num_coordinates) {
+                case 1: {
                     const std::string x = regs.GetRegisterAsFloat(instr.gpr8);
                     coord = "float coords = " + x + ';';
                     break;
                 }
-                case Tegra::Shader::TextureType::Texture2D: {
+                case 2: {
                     const std::string x = regs.GetRegisterAsFloat(instr.gpr8);
                     const std::string y = regs.GetRegisterAsFloat(instr.gpr8.Value() + 1);
                     coord = "vec2 coords = vec2(" + x + ", " + y + ");";
                     break;
                 }
+                case 3: {
+                    const std::string x = regs.GetRegisterAsFloat(instr.gpr8);
+                    const std::string y = regs.GetRegisterAsFloat(instr.gpr8.Value() + 1);
+                    const std::string z = regs.GetRegisterAsFloat(instr.gpr20);
+                    coord = "vec3 coords = vec3(" + x + ", " + y + ", " + z + ");";
+                    break;
+                }
                 default:
-                    LOG_CRITICAL(HW_GPU, "Unhandled texture type {}",
-                                 static_cast<u32>(texture_type));
+                    LOG_CRITICAL(HW_GPU, "Unhandled coordinates number {}",
+                                 static_cast<u32>(num_coordinates));
                     UNREACHABLE();
 
                     // Fallback to interpreting as a 2D texture for now
@@ -1924,9 +1955,10 @@ private:
                 }
                 // TODO: make sure coordinates are always indexed to gpr8 and gpr20 is always bias
                 // or lod.
-                const std::string op_c = regs.GetRegisterAsFloat(instr.gpr20);
+                std::string op_c;
 
-                const std::string sampler = GetSampler(instr.sampler, texture_type, false);
+                const std::string sampler =
+                    GetSampler(instr.sampler, texture_type, false, depth_compare);
                 // Add an extra scope and declare the texture coords inside to prevent
                 // overwriting them in case they are used as outputs of the texs instruction.
 
@@ -1935,7 +1967,7 @@ private:
                 shader.AddLine(coord);
                 std::string texture;
 
-                switch (instr.tex.process_mode) {
+                switch (instr.tex.GetTextureProcessMode()) {
                 case Tegra::Shader::TextureProcessMode::None: {
                     texture = "texture(" + sampler + ", coords)";
                     break;
@@ -1946,12 +1978,22 @@ private:
                 }
                 case Tegra::Shader::TextureProcessMode::LB:
                 case Tegra::Shader::TextureProcessMode::LBA: {
+                    if (num_coordinates <= 2) {
+                        op_c = regs.GetRegisterAsFloat(instr.gpr20);
+                    } else {
+                        op_c = regs.GetRegisterAsFloat(instr.gpr20.Value() + 1);
+                    }
                     // TODO: Figure if A suffix changes the equation at all.
                     texture = "texture(" + sampler + ", coords, " + op_c + ')';
                     break;
                 }
                 case Tegra::Shader::TextureProcessMode::LL:
                 case Tegra::Shader::TextureProcessMode::LLA: {
+                    if (num_coordinates <= 2) {
+                        op_c = regs.GetRegisterAsFloat(instr.gpr20);
+                    } else {
+                        op_c = regs.GetRegisterAsFloat(instr.gpr20.Value() + 1);
+                    }
                     // TODO: Figure if A suffix changes the equation at all.
                     texture = "textureLod(" + sampler + ", coords, " + op_c + ')';
                     break;
@@ -1959,18 +2001,22 @@ private:
                 default: {
                     texture = "texture(" + sampler + ", coords)";
                     LOG_CRITICAL(HW_GPU, "Unhandled texture process mode {}",
-                                 static_cast<u32>(instr.tex.process_mode.Value()));
+                                 static_cast<u32>(instr.tex.GetTextureProcessMode()));
                     UNREACHABLE();
                 }
                 }
-                std::size_t dest_elem{};
-                for (std::size_t elem = 0; elem < 4; ++elem) {
-                    if (!instr.tex.IsComponentEnabled(elem)) {
-                        // Skip disabled components
-                        continue;
+                if (!depth_compare) {
+                    std::size_t dest_elem{};
+                    for (std::size_t elem = 0; elem < 4; ++elem) {
+                        if (!instr.tex.IsComponentEnabled(elem)) {
+                            // Skip disabled components
+                            continue;
+                        }
+                        regs.SetRegisterToFloat(instr.gpr0, elem, texture, 1, 4, false, dest_elem);
+                        ++dest_elem;
                     }
-                    regs.SetRegisterToFloat(instr.gpr0, elem, texture, 1, 4, false, dest_elem);
-                    ++dest_elem;
+                } else {
+                    regs.SetRegisterToFloat(instr.gpr0, 0, texture, 1, 1, false);
                 }
                 --shader.scope;
                 shader.AddLine("}");
@@ -1983,11 +2029,15 @@ private:
 
                 ASSERT_MSG(!instr.texs.UsesMiscMode(Tegra::Shader::TextureMiscMode::NODEP),
                            "NODEP is not implemented");
-                ASSERT_MSG(!instr.texs.UsesMiscMode(Tegra::Shader::TextureMiscMode::DC),
-                           "DC is not implemented");
 
-                switch (texture_type) {
-                case Tegra::Shader::TextureType::Texture2D: {
+                const bool depth_compare =
+                    instr.texs.UsesMiscMode(Tegra::Shader::TextureMiscMode::DC);
+                u32 num_coordinates = TextureCoordinates(texture_type);
+                if (depth_compare)
+                    num_coordinates += 1;
+
+                switch (num_coordinates) {
+                case 2: {
                     if (is_array) {
                         const std::string index = regs.GetRegisterAsInteger(instr.gpr8);
                         const std::string x = regs.GetRegisterAsFloat(instr.gpr8.Value() + 1);
@@ -2000,17 +2050,25 @@ private:
                     }
                     break;
                 }
-                case Tegra::Shader::TextureType::TextureCube: {
-                    ASSERT_MSG(!is_array, "Unimplemented");
-                    std::string x = regs.GetRegisterAsFloat(instr.gpr8);
-                    std::string y = regs.GetRegisterAsFloat(instr.gpr8.Value() + 1);
-                    std::string z = regs.GetRegisterAsFloat(instr.gpr20);
-                    coord = "vec3 coords = vec3(" + x + ", " + y + ", " + z + ");";
+                case 3: {
+                    if (is_array) {
+                        UNIMPLEMENTED_MSG("3-coordinate arrays not fully implemented");
+                        const std::string x = regs.GetRegisterAsFloat(instr.gpr8);
+                        const std::string y = regs.GetRegisterAsFloat(instr.gpr20);
+                        coord = "vec2 coords = vec2(" + x + ", " + y + ");";
+                        texture_type = Tegra::Shader::TextureType::Texture2D;
+                        is_array = false;
+                    } else {
+                        const std::string x = regs.GetRegisterAsFloat(instr.gpr8);
+                        const std::string y = regs.GetRegisterAsFloat(instr.gpr8.Value() + 1);
+                        const std::string z = regs.GetRegisterAsFloat(instr.gpr20);
+                        coord = "vec3 coords = vec3(" + x + ", " + y + ", " + z + ");";
+                    }
                     break;
                 }
                 default:
-                    LOG_CRITICAL(HW_GPU, "Unhandled texture type {}",
-                                 static_cast<u32>(texture_type));
+                    LOG_CRITICAL(HW_GPU, "Unhandled coordinates number {}",
+                                 static_cast<u32>(num_coordinates));
                     UNREACHABLE();
 
                     // Fallback to interpreting as a 2D texture for now
@@ -2020,9 +2078,35 @@ private:
                     texture_type = Tegra::Shader::TextureType::Texture2D;
                     is_array = false;
                 }
-                const std::string sampler = GetSampler(instr.sampler, texture_type, is_array);
-                const std::string texture = "texture(" + sampler + ", coords)";
-                WriteTexsInstruction(instr, coord, texture);
+                const std::string sampler =
+                    GetSampler(instr.sampler, texture_type, is_array, depth_compare);
+                std::string texture;
+                switch (instr.texs.GetTextureProcessMode()) {
+                case Tegra::Shader::TextureProcessMode::None: {
+                    texture = "texture(" + sampler + ", coords)";
+                    break;
+                }
+                case Tegra::Shader::TextureProcessMode::LZ: {
+                    texture = "textureLod(" + sampler + ", coords, 0.0)";
+                    break;
+                }
+                case Tegra::Shader::TextureProcessMode::LL: {
+                    const std::string op_c = regs.GetRegisterAsFloat(instr.gpr20.Value() + 1);
+                    texture = "textureLod(" + sampler + ", coords, " + op_c + ')';
+                    break;
+                }
+                default: {
+                    texture = "texture(" + sampler + ", coords)";
+                    LOG_CRITICAL(HW_GPU, "Unhandled texture process mode {}",
+                                 static_cast<u32>(instr.texs.GetTextureProcessMode()));
+                    UNREACHABLE();
+                }
+                }
+                if (!depth_compare) {
+                    WriteTexsInstruction(instr, coord, texture);
+                } else {
+                    WriteTexsInstruction(instr, coord, "vec4(" + texture + ')');
+                }
                 break;
             }
             case OpCode::Id::TLDS: {
@@ -2062,9 +2146,26 @@ private:
                                  static_cast<u32>(texture_type));
                     UNREACHABLE();
                 }
-
-                const std::string sampler = GetSampler(instr.sampler, texture_type, is_array);
-                const std::string texture = "texelFetch(" + sampler + ", coords, 0)";
+                const std::string sampler =
+                    GetSampler(instr.sampler, texture_type, is_array, false);
+                std::string texture = "texelFetch(" + sampler + ", coords, 0)";
+                const std::string op_c = regs.GetRegisterAsInteger(instr.gpr20.Value() + 1);
+                switch (instr.tlds.GetTextureProcessMode()) {
+                case Tegra::Shader::TextureProcessMode::LZ: {
+                    texture = "texelFetch(" + sampler + ", coords, 0)";
+                    break;
+                }
+                case Tegra::Shader::TextureProcessMode::LL: {
+                    texture = "texelFetch(" + sampler + ", coords, " + op_c + ')';
+                    break;
+                }
+                default: {
+                    texture = "texelFetch(" + sampler + ", coords, 0)";
+                    LOG_CRITICAL(HW_GPU, "Unhandled texture process mode {}",
+                                 static_cast<u32>(instr.tlds.GetTextureProcessMode()));
+                    UNREACHABLE();
+                }
+                }
                 WriteTexsInstruction(instr, coord, texture);
                 break;
             }
@@ -2077,28 +2178,43 @@ private:
                            "NODEP is not implemented");
                 ASSERT_MSG(!instr.tld4.UsesMiscMode(Tegra::Shader::TextureMiscMode::AOFFI),
                            "AOFFI is not implemented");
-                ASSERT_MSG(!instr.tld4.UsesMiscMode(Tegra::Shader::TextureMiscMode::DC),
-                           "DC is not implemented");
                 ASSERT_MSG(!instr.tld4.UsesMiscMode(Tegra::Shader::TextureMiscMode::NDV),
                            "NDV is not implemented");
                 ASSERT_MSG(!instr.tld4.UsesMiscMode(Tegra::Shader::TextureMiscMode::PTP),
                            "PTP is not implemented");
-
-                switch (instr.tld4.texture_type) {
-                case Tegra::Shader::TextureType::Texture2D: {
+                const bool depth_compare =
+                    instr.tld4.UsesMiscMode(Tegra::Shader::TextureMiscMode::DC);
+                auto texture_type = instr.tld4.texture_type.Value();
+                u32 num_coordinates = TextureCoordinates(texture_type);
+                if (depth_compare)
+                    num_coordinates += 1;
+
+                switch (num_coordinates) {
+                case 2: {
                     const std::string x = regs.GetRegisterAsFloat(instr.gpr8);
                     const std::string y = regs.GetRegisterAsFloat(instr.gpr8.Value() + 1);
                     coord = "vec2 coords = vec2(" + x + ", " + y + ");";
                     break;
                 }
+                case 3: {
+                    const std::string x = regs.GetRegisterAsFloat(instr.gpr8);
+                    const std::string y = regs.GetRegisterAsFloat(instr.gpr8.Value() + 1);
+                    const std::string z = regs.GetRegisterAsFloat(instr.gpr8.Value() + 2);
+                    coord = "vec3 coords = vec3(" + x + ", " + y + ", " + z + ");";
+                    break;
+                }
                 default:
-                    LOG_CRITICAL(HW_GPU, "Unhandled texture type {}",
-                                 static_cast<u32>(instr.tld4.texture_type.Value()));
+                    LOG_CRITICAL(HW_GPU, "Unhandled coordinates number {}",
+                                 static_cast<u32>(num_coordinates));
                     UNREACHABLE();
+                    const std::string x = regs.GetRegisterAsFloat(instr.gpr8);
+                    const std::string y = regs.GetRegisterAsFloat(instr.gpr8.Value() + 1);
+                    coord = "vec2 coords = vec2(" + x + ", " + y + ");";
+                    texture_type = Tegra::Shader::TextureType::Texture2D;
                 }
 
                 const std::string sampler =
-                    GetSampler(instr.sampler, instr.tld4.texture_type, false);
+                    GetSampler(instr.sampler, texture_type, false, depth_compare);
                 // Add an extra scope and declare the texture coords inside to prevent
                 // overwriting them in case they are used as outputs of the texs instruction.
                 shader.AddLine("{");
@@ -2106,15 +2222,18 @@ private:
                 shader.AddLine(coord);
                 const std::string texture = "textureGather(" + sampler + ", coords, " +
                                             std::to_string(instr.tld4.component) + ')';
-
-                std::size_t dest_elem{};
-                for (std::size_t elem = 0; elem < 4; ++elem) {
-                    if (!instr.tex.IsComponentEnabled(elem)) {
-                        // Skip disabled components
-                        continue;
+                if (!depth_compare) {
+                    std::size_t dest_elem{};
+                    for (std::size_t elem = 0; elem < 4; ++elem) {
+                        if (!instr.tex.IsComponentEnabled(elem)) {
+                            // Skip disabled components
+                            continue;
+                        }
+                        regs.SetRegisterToFloat(instr.gpr0, elem, texture, 1, 4, false, dest_elem);
+                        ++dest_elem;
                     }
-                    regs.SetRegisterToFloat(instr.gpr0, elem, texture, 1, 4, false, dest_elem);
-                    ++dest_elem;
+                } else {
+                    regs.SetRegisterToFloat(instr.gpr0, 0, texture, 1, 1, false);
                 }
                 --shader.scope;
                 shader.AddLine("}");
@@ -2125,18 +2244,30 @@ private:
                            "NODEP is not implemented");
                 ASSERT_MSG(!instr.tld4s.UsesMiscMode(Tegra::Shader::TextureMiscMode::AOFFI),
                            "AOFFI is not implemented");
-                ASSERT_MSG(!instr.tld4s.UsesMiscMode(Tegra::Shader::TextureMiscMode::DC),
-                           "DC is not implemented");
 
+                const bool depth_compare =
+                    instr.tld4s.UsesMiscMode(Tegra::Shader::TextureMiscMode::DC);
                 const std::string op_a = regs.GetRegisterAsFloat(instr.gpr8);
                 const std::string op_b = regs.GetRegisterAsFloat(instr.gpr20);
                 // TODO(Subv): Figure out how the sampler type is encoded in the TLD4S instruction.
-                const std::string sampler =
-                    GetSampler(instr.sampler, Tegra::Shader::TextureType::Texture2D, false);
-                const std::string coord = "vec2 coords = vec2(" + op_a + ", " + op_b + ");";
+                const std::string sampler = GetSampler(
+                    instr.sampler, Tegra::Shader::TextureType::Texture2D, false, depth_compare);
+                std::string coord;
+                if (!depth_compare) {
+                    coord = "vec2 coords = vec2(" + op_a + ", " + op_b + ");";
+                } else {
+                    // Note: TLD4S coordinate encoding works just like TEXS's
+                    const std::string op_c = regs.GetRegisterAsFloat(instr.gpr8.Value() + 1);
+                    coord = "vec3 coords = vec3(" + op_a + ", " + op_c + ", " + op_b + ");";
+                }
                 const std::string texture = "textureGather(" + sampler + ", coords, " +
                                             std::to_string(instr.tld4s.component) + ')';
-                WriteTexsInstruction(instr, coord, texture);
+
+                if (!depth_compare) {
+                    WriteTexsInstruction(instr, coord, texture);
+                } else {
+                    WriteTexsInstruction(instr, coord, "vec4(" + texture + ')');
+                }
                 break;
             }
             case OpCode::Id::TXQ: {
@@ -2147,7 +2278,7 @@ private:
                 // Sadly, not all texture instructions specify the type of texture their sampler
                 // uses. This must be fixed at a later instance.
                 const std::string sampler =
-                    GetSampler(instr.sampler, Tegra::Shader::TextureType::Texture2D, false);
+                    GetSampler(instr.sampler, Tegra::Shader::TextureType::Texture2D, false, false);
                 switch (instr.txq.query_type) {
                 case Tegra::Shader::TextureQueryType::Dimension: {
                     const std::string texture = "textureQueryLevels(" + sampler + ')';
@@ -2172,7 +2303,8 @@ private:
                 const std::string op_b = regs.GetRegisterAsFloat(instr.gpr8.Value() + 1);
                 const bool is_array = instr.tmml.array != 0;
                 auto texture_type = instr.tmml.texture_type.Value();
-                const std::string sampler = GetSampler(instr.sampler, texture_type, is_array);
+                const std::string sampler =
+                    GetSampler(instr.sampler, texture_type, is_array, false);
 
                 // TODO: add coordinates for different samplers once other texture types are
                 // implemented.
diff --git a/src/video_core/renderer_opengl/gl_shader_gen.h b/src/video_core/renderer_opengl/gl_shader_gen.h
index d53b93ad5..e56f39e78 100644
--- a/src/video_core/renderer_opengl/gl_shader_gen.h
+++ b/src/video_core/renderer_opengl/gl_shader_gen.h
@@ -75,8 +75,9 @@ class SamplerEntry {
 
 public:
     SamplerEntry(Maxwell::ShaderStage stage, std::size_t offset, std::size_t index,
-                 Tegra::Shader::TextureType type, bool is_array)
-        : offset(offset), stage(stage), sampler_index(index), type(type), is_array(is_array) {}
+                 Tegra::Shader::TextureType type, bool is_array, bool is_shadow)
+        : offset(offset), stage(stage), sampler_index(index), type(type), is_array(is_array),
+          is_shadow(is_shadow) {}
 
     std::size_t GetOffset() const {
         return offset;
@@ -117,6 +118,8 @@ public:
         }
         if (is_array)
             glsl_type += "Array";
+        if (is_shadow)
+            glsl_type += "Shadow";
         return glsl_type;
     }
 
@@ -128,6 +131,10 @@ public:
         return is_array;
     }
 
+    bool IsShadow() const {
+        return is_shadow;
+    }
+
     u32 GetHash() const {
         return (static_cast<u32>(stage) << 16) | static_cast<u32>(sampler_index);
     }
@@ -147,7 +154,8 @@ private:
     Maxwell::ShaderStage stage;      ///< Shader stage where this sampler was used.
     std::size_t sampler_index;       ///< Value used to index into the generated GLSL sampler array.
     Tegra::Shader::TextureType type; ///< The type used to sample this texture (Texture2D, etc)
-    bool is_array; ///< Whether the texture is being sampled as an array texture or not.
+    bool is_array;  ///< Whether the texture is being sampled as an array texture or not.
+    bool is_shadow; ///< Whether the texture is being sampled as a depth texture or not.
 };
 
 struct ShaderEntries {
diff --git a/src/video_core/renderer_opengl/maxwell_to_gl.h b/src/video_core/renderer_opengl/maxwell_to_gl.h
index 67273e164..3c3bcaae4 100644
--- a/src/video_core/renderer_opengl/maxwell_to_gl.h
+++ b/src/video_core/renderer_opengl/maxwell_to_gl.h
@@ -159,6 +159,31 @@ inline GLenum WrapMode(Tegra::Texture::WrapMode wrap_mode) {
     return {};
 }
 
+inline GLenum DepthCompareFunc(Tegra::Texture::DepthCompareFunc func) {
+    switch (func) {
+    case Tegra::Texture::DepthCompareFunc::Never:
+        return GL_NEVER;
+    case Tegra::Texture::DepthCompareFunc::Less:
+        return GL_LESS;
+    case Tegra::Texture::DepthCompareFunc::LessEqual:
+        return GL_LEQUAL;
+    case Tegra::Texture::DepthCompareFunc::Equal:
+        return GL_EQUAL;
+    case Tegra::Texture::DepthCompareFunc::NotEqual:
+        return GL_NOTEQUAL;
+    case Tegra::Texture::DepthCompareFunc::Greater:
+        return GL_GREATER;
+    case Tegra::Texture::DepthCompareFunc::GreaterEqual:
+        return GL_GEQUAL;
+    case Tegra::Texture::DepthCompareFunc::Always:
+        return GL_ALWAYS;
+    }
+    LOG_CRITICAL(Render_OpenGL, "Unimplemented texture depth compare function ={}",
+                 static_cast<u32>(func));
+    UNREACHABLE();
+    return {};
+}
+
 inline GLenum BlendEquation(Maxwell::Blend::Equation equation) {
     switch (equation) {
     case Maxwell::Blend::Equation::Add:
diff --git a/src/video_core/textures/texture.h b/src/video_core/textures/texture.h
index 14aea4838..8f31d825a 100644
--- a/src/video_core/textures/texture.h
+++ b/src/video_core/textures/texture.h
@@ -227,6 +227,17 @@ enum class WrapMode : u32 {
     MirrorOnceClampOGL = 7,
 };
 
+enum class DepthCompareFunc : u32 {
+    Never = 0,
+    Less = 1,
+    Equal = 2,
+    LessEqual = 3,
+    Greater = 4,
+    NotEqual = 5,
+    GreaterEqual = 6,
+    Always = 7,
+};
+
 enum class TextureFilter : u32 {
     Nearest = 1,
     Linear = 2,
@@ -244,7 +255,7 @@ struct TSCEntry {
         BitField<3, 3, WrapMode> wrap_v;
         BitField<6, 3, WrapMode> wrap_p;
         BitField<9, 1, u32> depth_compare_enabled;
-        BitField<10, 3, u32> depth_compare_func;
+        BitField<10, 3, DepthCompareFunc> depth_compare_func;
     };
     union {
         BitField<0, 2, TextureFilter> mag_filter;
diff --git a/src/web_service/CMakeLists.txt b/src/web_service/CMakeLists.txt
new file mode 100644
index 000000000..1c83e9c34
--- /dev/null
+++ b/src/web_service/CMakeLists.txt
@@ -0,0 +1,16 @@
+add_library(web_service STATIC
+    telemetry_json.cpp
+    telemetry_json.h
+    verify_login.cpp
+    verify_login.h
+    web_backend.cpp
+    web_backend.h
+)
+
+create_target_directory_groups(web_service)
+
+get_directory_property(OPENSSL_LIBS
+        DIRECTORY ${CMAKE_SOURCE_DIR}/externals/libressl
+        DEFINITION OPENSSL_LIBS)
+target_compile_definitions(web_service PUBLIC -DCPPHTTPLIB_OPENSSL_SUPPORT)
+target_link_libraries(web_service PRIVATE common json-headers ${OPENSSL_LIBS} httplib lurlparser)
diff --git a/src/web_service/telemetry_json.cpp b/src/web_service/telemetry_json.cpp
new file mode 100644
index 000000000..033ea1ea4
--- /dev/null
+++ b/src/web_service/telemetry_json.cpp
@@ -0,0 +1,99 @@
+// Copyright 2017 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <thread>
+#include "common/assert.h"
+#include "common/detached_tasks.h"
+#include "web_service/telemetry_json.h"
+#include "web_service/web_backend.h"
+
+namespace WebService {
+
+TelemetryJson::TelemetryJson(const std::string& host, const std::string& username,
+                             const std::string& token)
+    : host(std::move(host)), username(std::move(username)), token(std::move(token)) {}
+TelemetryJson::~TelemetryJson() = default;
+
+template <class T>
+void TelemetryJson::Serialize(Telemetry::FieldType type, const std::string& name, T value) {
+    sections[static_cast<u8>(type)][name] = value;
+}
+
+void TelemetryJson::SerializeSection(Telemetry::FieldType type, const std::string& name) {
+    TopSection()[name] = sections[static_cast<unsigned>(type)];
+}
+
+void TelemetryJson::Visit(const Telemetry::Field<bool>& field) {
+    Serialize(field.GetType(), field.GetName(), field.GetValue());
+}
+
+void TelemetryJson::Visit(const Telemetry::Field<double>& field) {
+    Serialize(field.GetType(), field.GetName(), field.GetValue());
+}
+
+void TelemetryJson::Visit(const Telemetry::Field<float>& field) {
+    Serialize(field.GetType(), field.GetName(), field.GetValue());
+}
+
+void TelemetryJson::Visit(const Telemetry::Field<u8>& field) {
+    Serialize(field.GetType(), field.GetName(), field.GetValue());
+}
+
+void TelemetryJson::Visit(const Telemetry::Field<u16>& field) {
+    Serialize(field.GetType(), field.GetName(), field.GetValue());
+}
+
+void TelemetryJson::Visit(const Telemetry::Field<u32>& field) {
+    Serialize(field.GetType(), field.GetName(), field.GetValue());
+}
+
+void TelemetryJson::Visit(const Telemetry::Field<u64>& field) {
+    Serialize(field.GetType(), field.GetName(), field.GetValue());
+}
+
+void TelemetryJson::Visit(const Telemetry::Field<s8>& field) {
+    Serialize(field.GetType(), field.GetName(), field.GetValue());
+}
+
+void TelemetryJson::Visit(const Telemetry::Field<s16>& field) {
+    Serialize(field.GetType(), field.GetName(), field.GetValue());
+}
+
+void TelemetryJson::Visit(const Telemetry::Field<s32>& field) {
+    Serialize(field.GetType(), field.GetName(), field.GetValue());
+}
+
+void TelemetryJson::Visit(const Telemetry::Field<s64>& field) {
+    Serialize(field.GetType(), field.GetName(), field.GetValue());
+}
+
+void TelemetryJson::Visit(const Telemetry::Field<std::string>& field) {
+    Serialize(field.GetType(), field.GetName(), field.GetValue());
+}
+
+void TelemetryJson::Visit(const Telemetry::Field<const char*>& field) {
+    Serialize(field.GetType(), field.GetName(), std::string(field.GetValue()));
+}
+
+void TelemetryJson::Visit(const Telemetry::Field<std::chrono::microseconds>& field) {
+    Serialize(field.GetType(), field.GetName(), field.GetValue().count());
+}
+
+void TelemetryJson::Complete() {
+    SerializeSection(Telemetry::FieldType::App, "App");
+    SerializeSection(Telemetry::FieldType::Session, "Session");
+    SerializeSection(Telemetry::FieldType::Performance, "Performance");
+    SerializeSection(Telemetry::FieldType::UserFeedback, "UserFeedback");
+    SerializeSection(Telemetry::FieldType::UserConfig, "UserConfig");
+    SerializeSection(Telemetry::FieldType::UserSystem, "UserSystem");
+
+    auto content = TopSection().dump();
+    // Send the telemetry async but don't handle the errors since they were written to the log
+    Common::DetachedTasks::AddTask(
+        [host{this->host}, username{this->username}, token{this->token}, content]() {
+            Client{host, username, token}.PostJson("/telemetry", content, true);
+        });
+}
+
+} // namespace WebService
diff --git a/src/web_service/telemetry_json.h b/src/web_service/telemetry_json.h
new file mode 100644
index 000000000..0fe6f9a3e
--- /dev/null
+++ b/src/web_service/telemetry_json.h
@@ -0,0 +1,58 @@
+// Copyright 2017 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <array>
+#include <string>
+#include <json.hpp>
+#include "common/telemetry.h"
+#include "common/web_result.h"
+
+namespace WebService {
+
+/**
+ * Implementation of VisitorInterface that serialized telemetry into JSON, and submits it to the
+ * yuzu web service
+ */
+class TelemetryJson : public Telemetry::VisitorInterface {
+public:
+    TelemetryJson(const std::string& host, const std::string& username, const std::string& token);
+    ~TelemetryJson();
+
+    void Visit(const Telemetry::Field<bool>& field) override;
+    void Visit(const Telemetry::Field<double>& field) override;
+    void Visit(const Telemetry::Field<float>& field) override;
+    void Visit(const Telemetry::Field<u8>& field) override;
+    void Visit(const Telemetry::Field<u16>& field) override;
+    void Visit(const Telemetry::Field<u32>& field) override;
+    void Visit(const Telemetry::Field<u64>& field) override;
+    void Visit(const Telemetry::Field<s8>& field) override;
+    void Visit(const Telemetry::Field<s16>& field) override;
+    void Visit(const Telemetry::Field<s32>& field) override;
+    void Visit(const Telemetry::Field<s64>& field) override;
+    void Visit(const Telemetry::Field<std::string>& field) override;
+    void Visit(const Telemetry::Field<const char*>& field) override;
+    void Visit(const Telemetry::Field<std::chrono::microseconds>& field) override;
+
+    void Complete() override;
+
+private:
+    nlohmann::json& TopSection() {
+        return sections[static_cast<u8>(Telemetry::FieldType::None)];
+    }
+
+    template <class T>
+    void Serialize(Telemetry::FieldType type, const std::string& name, T value);
+
+    void SerializeSection(Telemetry::FieldType type, const std::string& name);
+
+    nlohmann::json output;
+    std::array<nlohmann::json, 7> sections;
+    std::string host;
+    std::string username;
+    std::string token;
+};
+
+} // namespace WebService
diff --git a/src/web_service/verify_login.cpp b/src/web_service/verify_login.cpp
new file mode 100644
index 000000000..124aa3863
--- /dev/null
+++ b/src/web_service/verify_login.cpp
@@ -0,0 +1,27 @@
+// Copyright 2017 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <json.hpp>
+#include "web_service/verify_login.h"
+#include "web_service/web_backend.h"
+
+namespace WebService {
+
+bool VerifyLogin(const std::string& host, const std::string& username, const std::string& token) {
+    Client client(host, username, token);
+    auto reply = client.GetJson("/profile", false).returned_data;
+    if (reply.empty()) {
+        return false;
+    }
+    nlohmann::json json = nlohmann::json::parse(reply);
+    const auto iter = json.find("username");
+
+    if (iter == json.end()) {
+        return username.empty();
+    }
+
+    return username == *iter;
+}
+
+} // namespace WebService
diff --git a/src/web_service/verify_login.h b/src/web_service/verify_login.h
new file mode 100644
index 000000000..39db32dbb
--- /dev/null
+++ b/src/web_service/verify_login.h
@@ -0,0 +1,22 @@
+// Copyright 2017 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <functional>
+#include <future>
+#include <string>
+
+namespace WebService {
+
+/**
+ * Checks if username and token is valid
+ * @param host the web API URL
+ * @param username yuzu username to use for authentication.
+ * @param token yuzu token to use for authentication.
+ * @returns a bool indicating whether the verification succeeded
+ */
+bool VerifyLogin(const std::string& host, const std::string& username, const std::string& token);
+
+} // namespace WebService
diff --git a/src/web_service/web_backend.cpp b/src/web_service/web_backend.cpp
new file mode 100644
index 000000000..787b0fbcb
--- /dev/null
+++ b/src/web_service/web_backend.cpp
@@ -0,0 +1,149 @@
+// Copyright 2017 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <cstdlib>
+#include <string>
+#include <thread>
+#include <LUrlParser.h>
+#include "common/logging/log.h"
+#include "common/web_result.h"
+#include "core/settings.h"
+#include "web_service/web_backend.h"
+
+namespace WebService {
+
+constexpr std::array<const char, 1> API_VERSION{'1'};
+
+constexpr u32 HTTP_PORT = 80;
+constexpr u32 HTTPS_PORT = 443;
+
+constexpr u32 TIMEOUT_SECONDS = 30;
+
+Client::JWTCache Client::jwt_cache{};
+
+Client::Client(const std::string& host, const std::string& username, const std::string& token)
+    : host(host), username(username), token(token) {
+    std::lock_guard<std::mutex> lock(jwt_cache.mutex);
+    if (username == jwt_cache.username && token == jwt_cache.token) {
+        jwt = jwt_cache.jwt;
+    }
+}
+
+Common::WebResult Client::GenericJson(const std::string& method, const std::string& path,
+                                      const std::string& data, const std::string& jwt,
+                                      const std::string& username, const std::string& token) {
+    if (cli == nullptr) {
+        auto parsedUrl = LUrlParser::clParseURL::ParseURL(host);
+        int port;
+        if (parsedUrl.m_Scheme == "http") {
+            if (!parsedUrl.GetPort(&port)) {
+                port = HTTP_PORT;
+            }
+            cli =
+                std::make_unique<httplib::Client>(parsedUrl.m_Host.c_str(), port, TIMEOUT_SECONDS);
+        } else if (parsedUrl.m_Scheme == "https") {
+            if (!parsedUrl.GetPort(&port)) {
+                port = HTTPS_PORT;
+            }
+            cli = std::make_unique<httplib::SSLClient>(parsedUrl.m_Host.c_str(), port,
+                                                       TIMEOUT_SECONDS);
+        } else {
+            LOG_ERROR(WebService, "Bad URL scheme {}", parsedUrl.m_Scheme);
+            return Common::WebResult{Common::WebResult::Code::InvalidURL, "Bad URL scheme"};
+        }
+    }
+    if (cli == nullptr) {
+        LOG_ERROR(WebService, "Invalid URL {}", host + path);
+        return Common::WebResult{Common::WebResult::Code::InvalidURL, "Invalid URL"};
+    }
+
+    httplib::Headers params;
+    if (!jwt.empty()) {
+        params = {
+            {std::string("Authorization"), fmt::format("Bearer {}", jwt)},
+        };
+    } else if (!username.empty()) {
+        params = {
+            {std::string("x-username"), username},
+            {std::string("x-token"), token},
+        };
+    }
+
+    params.emplace(std::string("api-version"), std::string(API_VERSION.begin(), API_VERSION.end()));
+    if (method != "GET") {
+        params.emplace(std::string("Content-Type"), std::string("application/json"));
+    };
+
+    httplib::Request request;
+    request.method = method;
+    request.path = path;
+    request.headers = params;
+    request.body = data;
+
+    httplib::Response response;
+
+    if (!cli->send(request, response)) {
+        LOG_ERROR(WebService, "{} to {} returned null", method, host + path);
+        return Common::WebResult{Common::WebResult::Code::LibError, "Null response"};
+    }
+
+    if (response.status >= 400) {
+        LOG_ERROR(WebService, "{} to {} returned error status code: {}", method, host + path,
+                  response.status);
+        return Common::WebResult{Common::WebResult::Code::HttpError,
+                                 std::to_string(response.status)};
+    }
+
+    auto content_type = response.headers.find("content-type");
+
+    if (content_type == response.headers.end()) {
+        LOG_ERROR(WebService, "{} to {} returned no content", method, host + path);
+        return Common::WebResult{Common::WebResult::Code::WrongContent, ""};
+    }
+
+    if (content_type->second.find("application/json") == std::string::npos &&
+        content_type->second.find("text/html; charset=utf-8") == std::string::npos) {
+        LOG_ERROR(WebService, "{} to {} returned wrong content: {}", method, host + path,
+                  content_type->second);
+        return Common::WebResult{Common::WebResult::Code::WrongContent, "Wrong content"};
+    }
+    return Common::WebResult{Common::WebResult::Code::Success, "", response.body};
+}
+
+void Client::UpdateJWT() {
+    if (!username.empty() && !token.empty()) {
+        auto result = GenericJson("POST", "/jwt/internal", "", "", username, token);
+        if (result.result_code != Common::WebResult::Code::Success) {
+            LOG_ERROR(WebService, "UpdateJWT failed");
+        } else {
+            std::lock_guard<std::mutex> lock(jwt_cache.mutex);
+            jwt_cache.username = username;
+            jwt_cache.token = token;
+            jwt_cache.jwt = jwt = result.returned_data;
+        }
+    }
+}
+
+Common::WebResult Client::GenericJson(const std::string& method, const std::string& path,
+                                      const std::string& data, bool allow_anonymous) {
+    if (jwt.empty()) {
+        UpdateJWT();
+    }
+
+    if (jwt.empty() && !allow_anonymous) {
+        LOG_ERROR(WebService, "Credentials must be provided for authenticated requests");
+        return Common::WebResult{Common::WebResult::Code::CredentialsMissing, "Credentials needed"};
+    }
+
+    auto result = GenericJson(method, path, data, jwt);
+    if (result.result_string == "401") {
+        // Try again with new JWT
+        UpdateJWT();
+        result = GenericJson(method, path, data, jwt);
+    }
+
+    return result;
+}
+
+} // namespace WebService
diff --git a/src/web_service/web_backend.h b/src/web_service/web_backend.h
new file mode 100644
index 000000000..d75fbcc15
--- /dev/null
+++ b/src/web_service/web_backend.h
@@ -0,0 +1,92 @@
+// Copyright 2017 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <functional>
+#include <mutex>
+#include <string>
+#include <tuple>
+#include <httplib.h>
+#include "common/common_types.h"
+#include "common/web_result.h"
+
+namespace httplib {
+class Client;
+}
+
+namespace WebService {
+
+class Client {
+public:
+    Client(const std::string& host, const std::string& username, const std::string& token);
+
+    /**
+     * Posts JSON to the specified path.
+     * @param path the URL segment after the host address.
+     * @param data String of JSON data to use for the body of the POST request.
+     * @param allow_anonymous If true, allow anonymous unauthenticated requests.
+     * @return the result of the request.
+     */
+    Common::WebResult PostJson(const std::string& path, const std::string& data,
+                               bool allow_anonymous) {
+        return GenericJson("POST", path, data, allow_anonymous);
+    }
+
+    /**
+     * Gets JSON from the specified path.
+     * @param path the URL segment after the host address.
+     * @param allow_anonymous If true, allow anonymous unauthenticated requests.
+     * @return the result of the request.
+     */
+    Common::WebResult GetJson(const std::string& path, bool allow_anonymous) {
+        return GenericJson("GET", path, "", allow_anonymous);
+    }
+
+    /**
+     * Deletes JSON to the specified path.
+     * @param path the URL segment after the host address.
+     * @param data String of JSON data to use for the body of the DELETE request.
+     * @param allow_anonymous If true, allow anonymous unauthenticated requests.
+     * @return the result of the request.
+     */
+    Common::WebResult DeleteJson(const std::string& path, const std::string& data,
+                                 bool allow_anonymous) {
+        return GenericJson("DELETE", path, data, allow_anonymous);
+    }
+
+private:
+    /// A generic function handles POST, GET and DELETE request together
+    Common::WebResult GenericJson(const std::string& method, const std::string& path,
+                                  const std::string& data, bool allow_anonymous);
+
+    /**
+     * A generic function with explicit authentication method specified
+     * JWT is used if the jwt parameter is not empty
+     * username + token is used if jwt is empty but username and token are not empty
+     * anonymous if all of jwt, username and token are empty
+     */
+    Common::WebResult GenericJson(const std::string& method, const std::string& path,
+                                  const std::string& data, const std::string& jwt = "",
+                                  const std::string& username = "", const std::string& token = "");
+
+    // Retrieve a new JWT from given username and token
+    void UpdateJWT();
+
+    std::string host;
+    std::string username;
+    std::string token;
+    std::string jwt;
+    std::unique_ptr<httplib::Client> cli;
+
+    struct JWTCache {
+        std::mutex mutex;
+        std::string username;
+        std::string token;
+        std::string jwt;
+    };
+    static JWTCache jwt_cache;
+};
+
+} // namespace WebService
diff --git a/src/yuzu/CMakeLists.txt b/src/yuzu/CMakeLists.txt
index f48b69809..04464ad5e 100644
--- a/src/yuzu/CMakeLists.txt
+++ b/src/yuzu/CMakeLists.txt
@@ -29,6 +29,8 @@ add_executable(yuzu
     configuration/configure_input.h
     configuration/configure_system.cpp
     configuration/configure_system.h
+    configuration/configure_web.cpp
+    configuration/configure_web.h
     debugger/graphics/graphics_breakpoint_observer.cpp
     debugger/graphics/graphics_breakpoint_observer.h
     debugger/graphics/graphics_breakpoints.cpp
@@ -42,6 +44,7 @@ add_executable(yuzu
     debugger/profiler.h
     debugger/wait_tree.cpp
     debugger/wait_tree.h
+    discord.h
     game_list.cpp
     game_list.h
     game_list_p.h
@@ -57,6 +60,8 @@ add_executable(yuzu
     util/spinbox.h
     util/util.cpp
     util/util.h
+    compatdb.cpp
+    compatdb.h
     yuzu.rc
 )
 
@@ -70,8 +75,10 @@ set(UIS
     configuration/configure_graphics.ui
     configuration/configure_input.ui
     configuration/configure_system.ui
+    configuration/configure_web.ui
     hotkeys.ui
     main.ui
+    compatdb.ui
 )
 
 file(GLOB COMPAT_LIST
@@ -113,6 +120,19 @@ target_link_libraries(yuzu PRIVATE common core input_common video_core)
 target_link_libraries(yuzu PRIVATE Boost::boost glad Qt5::OpenGL Qt5::Widgets)
 target_link_libraries(yuzu PRIVATE ${PLATFORM_LIBRARIES} Threads::Threads)
 
+if (YUZU_ENABLE_COMPATIBILITY_REPORTING)
+    add_definitions(-DYUZU_ENABLE_COMPATIBILITY_REPORTING)
+endif()
+
+if (USE_DISCORD_PRESENCE)
+    target_sources(yuzu PUBLIC
+        discord_impl.cpp
+        discord_impl.h
+    )
+    target_link_libraries(yuzu PRIVATE discord-rpc)
+    target_compile_definitions(yuzu PRIVATE -DUSE_DISCORD_PRESENCE)
+endif()
+
 if(UNIX AND NOT APPLE)
     install(TARGETS yuzu RUNTIME DESTINATION "${CMAKE_INSTALL_PREFIX}/bin")
 endif()
diff --git a/src/yuzu/compatdb.cpp b/src/yuzu/compatdb.cpp
new file mode 100644
index 000000000..91e754274
--- /dev/null
+++ b/src/yuzu/compatdb.cpp
@@ -0,0 +1,65 @@
+// Copyright 2017 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <QButtonGroup>
+#include <QMessageBox>
+#include <QPushButton>
+#include "common/logging/log.h"
+#include "common/telemetry.h"
+#include "core/core.h"
+#include "core/telemetry_session.h"
+#include "ui_compatdb.h"
+#include "yuzu/compatdb.h"
+
+CompatDB::CompatDB(QWidget* parent)
+    : QWizard(parent, Qt::WindowTitleHint | Qt::WindowCloseButtonHint | Qt::WindowSystemMenuHint),
+      ui{std::make_unique<Ui::CompatDB>()} {
+    ui->setupUi(this);
+    connect(ui->radioButton_Perfect, &QRadioButton::clicked, this, &CompatDB::EnableNext);
+    connect(ui->radioButton_Great, &QRadioButton::clicked, this, &CompatDB::EnableNext);
+    connect(ui->radioButton_Okay, &QRadioButton::clicked, this, &CompatDB::EnableNext);
+    connect(ui->radioButton_Bad, &QRadioButton::clicked, this, &CompatDB::EnableNext);
+    connect(ui->radioButton_IntroMenu, &QRadioButton::clicked, this, &CompatDB::EnableNext);
+    connect(ui->radioButton_WontBoot, &QRadioButton::clicked, this, &CompatDB::EnableNext);
+    connect(button(NextButton), &QPushButton::clicked, this, &CompatDB::Submit);
+}
+
+CompatDB::~CompatDB() = default;
+
+enum class CompatDBPage {
+    Intro = 0,
+    Selection = 1,
+    Final = 2,
+};
+
+void CompatDB::Submit() {
+    QButtonGroup* compatibility = new QButtonGroup(this);
+    compatibility->addButton(ui->radioButton_Perfect, 0);
+    compatibility->addButton(ui->radioButton_Great, 1);
+    compatibility->addButton(ui->radioButton_Okay, 2);
+    compatibility->addButton(ui->radioButton_Bad, 3);
+    compatibility->addButton(ui->radioButton_IntroMenu, 4);
+    compatibility->addButton(ui->radioButton_WontBoot, 5);
+    switch ((static_cast<CompatDBPage>(currentId()))) {
+    case CompatDBPage::Selection:
+        if (compatibility->checkedId() == -1) {
+            button(NextButton)->setEnabled(false);
+        }
+        break;
+    case CompatDBPage::Final:
+        LOG_DEBUG(Frontend, "Compatibility Rating: {}", compatibility->checkedId());
+        Core::Telemetry().AddField(Telemetry::FieldType::UserFeedback, "Compatibility",
+                                   compatibility->checkedId());
+        // older versions of QT don't support the "NoCancelButtonOnLastPage" option, this is a
+        // workaround
+        button(QWizard::CancelButton)->setVisible(false);
+        break;
+    default:
+        LOG_ERROR(Frontend, "Unexpected page: {}", currentId());
+    }
+}
+
+void CompatDB::EnableNext() {
+    button(NextButton)->setEnabled(true);
+}
diff --git a/src/yuzu/compatdb.h b/src/yuzu/compatdb.h
new file mode 100644
index 000000000..ca0dd11d6
--- /dev/null
+++ b/src/yuzu/compatdb.h
@@ -0,0 +1,26 @@
+// Copyright 2017 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <memory>
+#include <QWizard>
+
+namespace Ui {
+class CompatDB;
+}
+
+class CompatDB : public QWizard {
+    Q_OBJECT
+
+public:
+    explicit CompatDB(QWidget* parent = nullptr);
+    ~CompatDB();
+
+private:
+    std::unique_ptr<Ui::CompatDB> ui;
+
+    void Submit();
+    void EnableNext();
+};
diff --git a/src/yuzu/compatdb.ui b/src/yuzu/compatdb.ui
new file mode 100644
index 000000000..fed402176
--- /dev/null
+++ b/src/yuzu/compatdb.ui
@@ -0,0 +1,215 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>CompatDB</class>
+ <widget class="QWizard" name="CompatDB">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>600</width>
+    <height>482</height>
+   </rect>
+  </property>
+  <property name="minimumSize">
+   <size>
+    <width>500</width>
+    <height>410</height>
+   </size>
+  </property>
+  <property name="windowTitle">
+   <string>Report Compatibility</string>
+  </property>
+  <property name="options">
+   <set>QWizard::DisabledBackButtonOnLastPage|QWizard::HelpButtonOnRight|QWizard::NoBackButtonOnStartPage</set>
+  </property>
+  <widget class="QWizardPage" name="wizard_Info">
+   <property name="title">
+    <string>Report Game Compatibility</string>
+   </property>
+   <attribute name="pageId">
+    <string notr="true">0</string>
+   </attribute>
+   <layout class="QVBoxLayout" name="verticalLayout">
+    <item>
+     <widget class="QLabel" name="lbl_Spiel">
+      <property name="text">
+       <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;&lt;span style=&quot; font-size:10pt;&quot;&gt;Should you choose to submit a test case to the &lt;/span&gt;&lt;a href=&quot;https://yuzu-emu.org/game/&quot;&gt;&lt;span style=&quot; font-size:10pt; text-decoration: underline; color:#0000ff;&quot;&gt;yuzu Compatibility List&lt;/span&gt;&lt;/a&gt;&lt;span style=&quot; font-size:10pt;&quot;&gt;, The following information will be collected and displayed on the site:&lt;/span&gt;&lt;/p&gt;&lt;ul style=&quot;margin-top: 0px; margin-bottom: 0px; margin-left: 0px; margin-right: 0px; -qt-list-indent: 1;&quot;&gt;&lt;li style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;Hardware Information (CPU / GPU / Operating System)&lt;/li&gt;&lt;li style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;Which version of yuzu you are running&lt;/li&gt;&lt;li style=&quot; margin-top:12px; margin-bottom:12px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;&quot;&gt;The connected yuzu account&lt;/li&gt;&lt;/ul&gt;&lt;/body&gt;&lt;/html&gt;</string>
+      </property>
+      <property name="wordWrap">
+       <bool>true</bool>
+      </property>
+      <property name="openExternalLinks">
+       <bool>true</bool>
+      </property>
+     </widget>
+    </item>
+    <item>
+     <spacer name="verticalSpacer_2">
+      <property name="orientation">
+       <enum>Qt::Vertical</enum>
+      </property>
+      <property name="sizeHint" stdset="0">
+       <size>
+        <width>20</width>
+        <height>0</height>
+       </size>
+      </property>
+     </spacer>
+    </item>
+   </layout>
+  </widget>
+  <widget class="QWizardPage" name="wizard_Report">
+   <property name="title">
+    <string>Report Game Compatibility</string>
+   </property>
+   <attribute name="pageId">
+    <string notr="true">1</string>
+   </attribute>
+   <layout class="QFormLayout" name="formLayout">
+    <item row="2" column="0">
+     <widget class="QRadioButton" name="radioButton_Perfect">
+      <property name="text">
+       <string>Perfect</string>
+      </property>
+     </widget>
+    </item>
+    <item row="2" column="1">
+     <widget class="QLabel" name="lbl_Perfect">
+      <property name="text">
+       <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Game functions flawlessly with no audio or graphical glitches.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+      </property>
+      <property name="wordWrap">
+       <bool>true</bool>
+      </property>
+     </widget>
+    </item>
+    <item row="4" column="0">
+     <widget class="QRadioButton" name="radioButton_Great">
+      <property name="text">
+       <string>Great </string>
+      </property>
+     </widget>
+    </item>
+    <item row="4" column="1">
+     <widget class="QLabel" name="lbl_Great">
+      <property name="text">
+       <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Game functions with minor graphical or audio glitches and is playable from start to finish. May require some workarounds.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+      </property>
+      <property name="wordWrap">
+       <bool>true</bool>
+      </property>
+     </widget>
+    </item>
+    <item row="5" column="0">
+     <widget class="QRadioButton" name="radioButton_Okay">
+      <property name="text">
+       <string>Okay</string>
+      </property>
+     </widget>
+    </item>
+    <item row="5" column="1">
+     <widget class="QLabel" name="lbl_Okay">
+      <property name="text">
+       <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Game functions with major graphical or audio glitches, but game is playable from start to finish with workarounds.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+      </property>
+      <property name="wordWrap">
+       <bool>true</bool>
+      </property>
+     </widget>
+    </item>
+    <item row="6" column="0">
+     <widget class="QRadioButton" name="radioButton_Bad">
+      <property name="text">
+       <string>Bad</string>
+      </property>
+     </widget>
+    </item>
+    <item row="6" column="1">
+     <widget class="QLabel" name="lbl_Bad">
+      <property name="text">
+       <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Game functions, but with major graphical or audio glitches. Unable to progress in specific areas due to glitches even with workarounds.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+      </property>
+      <property name="wordWrap">
+       <bool>true</bool>
+      </property>
+     </widget>
+    </item>
+    <item row="7" column="0">
+     <widget class="QRadioButton" name="radioButton_IntroMenu">
+      <property name="text">
+       <string>Intro/Menu</string>
+      </property>
+     </widget>
+    </item>
+    <item row="7" column="1">
+     <widget class="QLabel" name="lbl_IntroMenu">
+      <property name="text">
+       <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Game is completely unplayable due to major graphical or audio glitches. Unable to progress past the Start Screen.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+      </property>
+      <property name="wordWrap">
+       <bool>true</bool>
+      </property>
+     </widget>
+    </item>
+    <item row="8" column="0">
+     <widget class="QRadioButton" name="radioButton_WontBoot">
+      <property name="text">
+       <string>Won't Boot</string>
+      </property>
+      <property name="checkable">
+       <bool>true</bool>
+      </property>
+      <property name="checked">
+       <bool>false</bool>
+      </property>
+     </widget>
+    </item>
+    <item row="8" column="1">
+     <widget class="QLabel" name="lbl_WontBoot">
+      <property name="text">
+       <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;The game crashes when attempting to startup.&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+      </property>
+     </widget>
+    </item>
+    <item row="0" column="0" colspan="2">
+     <widget class="QLabel" name="lbl_Independent">
+      <property name="font">
+       <font>
+        <pointsize>10</pointsize>
+       </font>
+      </property>
+      <property name="text">
+       <string>&lt;html&gt;&lt;head/&gt;&lt;body&gt;&lt;p&gt;Independent of speed or performance, how well does this game play from start to finish on this version of yuzu?&lt;/p&gt;&lt;/body&gt;&lt;/html&gt;</string>
+      </property>
+      <property name="wordWrap">
+       <bool>true</bool>
+      </property>
+     </widget>
+    </item>
+    <item row="1" column="0" colspan="2">
+     <spacer name="verticalSpacer">
+      <property name="orientation">
+       <enum>Qt::Vertical</enum>
+      </property>
+      <property name="sizeHint" stdset="0">
+       <size>
+        <width>20</width>
+        <height>0</height>
+       </size>
+      </property>
+     </spacer>
+    </item>
+   </layout>
+  </widget>
+  <widget class="QWizardPage" name="wizard_ThankYou">
+   <property name="title">
+    <string>Thank you for your submission!</string>
+   </property>
+   <attribute name="pageId">
+    <string notr="true">2</string>
+   </attribute>
+  </widget>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>
diff --git a/src/yuzu/configuration/config.cpp b/src/yuzu/configuration/config.cpp
index d229225b4..7fec15991 100644
--- a/src/yuzu/configuration/config.cpp
+++ b/src/yuzu/configuration/config.cpp
@@ -134,10 +134,21 @@ void Config::ReadValues() {
     qt_config->beginGroup("Debugging");
     Settings::values.use_gdbstub = qt_config->value("use_gdbstub", false).toBool();
     Settings::values.gdbstub_port = qt_config->value("gdbstub_port", 24689).toInt();
+    Settings::values.program_args = qt_config->value("program_args", "").toString().toStdString();
+    qt_config->endGroup();
+
+    qt_config->beginGroup("WebService");
+    Settings::values.enable_telemetry = qt_config->value("enable_telemetry", true).toBool();
+    Settings::values.web_api_url =
+        qt_config->value("web_api_url", "https://api.yuzu-emu.org").toString().toStdString();
+    Settings::values.yuzu_username = qt_config->value("yuzu_username").toString().toStdString();
+    Settings::values.yuzu_token = qt_config->value("yuzu_token").toString().toStdString();
     qt_config->endGroup();
 
     qt_config->beginGroup("UI");
     UISettings::values.theme = qt_config->value("theme", UISettings::themes[0].second).toString();
+    UISettings::values.enable_discord_presence =
+        qt_config->value("enable_discord_presence", true).toBool();
 
     qt_config->beginGroup("UIGameList");
     UISettings::values.show_unknown = qt_config->value("show_unknown", true).toBool();
@@ -259,10 +270,19 @@ void Config::SaveValues() {
     qt_config->beginGroup("Debugging");
     qt_config->setValue("use_gdbstub", Settings::values.use_gdbstub);
     qt_config->setValue("gdbstub_port", Settings::values.gdbstub_port);
+    qt_config->setValue("program_args", QString::fromStdString(Settings::values.program_args));
+    qt_config->endGroup();
+
+    qt_config->beginGroup("WebService");
+    qt_config->setValue("enable_telemetry", Settings::values.enable_telemetry);
+    qt_config->setValue("web_api_url", QString::fromStdString(Settings::values.web_api_url));
+    qt_config->setValue("yuzu_username", QString::fromStdString(Settings::values.yuzu_username));
+    qt_config->setValue("yuzu_token", QString::fromStdString(Settings::values.yuzu_token));
     qt_config->endGroup();
 
     qt_config->beginGroup("UI");
     qt_config->setValue("theme", UISettings::values.theme);
+    qt_config->setValue("enable_discord_presence", UISettings::values.enable_discord_presence);
 
     qt_config->beginGroup("UIGameList");
     qt_config->setValue("show_unknown", UISettings::values.show_unknown);
diff --git a/src/yuzu/configuration/configure.ui b/src/yuzu/configuration/configure.ui
index 20f120134..9b297df28 100644
--- a/src/yuzu/configuration/configure.ui
+++ b/src/yuzu/configuration/configure.ui
@@ -54,6 +54,11 @@
        <string>Debug</string>
       </attribute>
      </widget>
+      <widget class="ConfigureWeb" name="webTab">
+        <attribute name="title">
+          <string>Web</string>
+        </attribute>
+      </widget>
     </widget>
    </item>
    <item>
@@ -108,6 +113,12 @@
    <header>configuration/configure_graphics.h</header>
    <container>1</container>
   </customwidget>
+   <customwidget>
+     <class>ConfigureWeb</class>
+     <extends>QWidget</extends>
+     <header>configuration/configure_web.h</header>
+     <container>1</container>
+   </customwidget>
  </customwidgets>
  <resources/>
  <connections>
diff --git a/src/yuzu/configuration/configure_debug.cpp b/src/yuzu/configuration/configure_debug.cpp
index 45d84f19a..9e765fc93 100644
--- a/src/yuzu/configuration/configure_debug.cpp
+++ b/src/yuzu/configuration/configure_debug.cpp
@@ -33,6 +33,7 @@ void ConfigureDebug::setConfiguration() {
     ui->toggle_console->setEnabled(!Core::System::GetInstance().IsPoweredOn());
     ui->toggle_console->setChecked(UISettings::values.show_console);
     ui->log_filter_edit->setText(QString::fromStdString(Settings::values.log_filter));
+    ui->homebrew_args_edit->setText(QString::fromStdString(Settings::values.program_args));
 }
 
 void ConfigureDebug::applyConfiguration() {
@@ -40,6 +41,7 @@ void ConfigureDebug::applyConfiguration() {
     Settings::values.gdbstub_port = ui->gdbport_spinbox->value();
     UISettings::values.show_console = ui->toggle_console->isChecked();
     Settings::values.log_filter = ui->log_filter_edit->text().toStdString();
+    Settings::values.program_args = ui->homebrew_args_edit->text().toStdString();
     Debugger::ToggleConsole();
     Log::Filter filter;
     filter.ParseFilterString(Settings::values.log_filter);
diff --git a/src/yuzu/configuration/configure_debug.ui b/src/yuzu/configuration/configure_debug.ui
index 5ae7276bd..ff4987604 100644
--- a/src/yuzu/configuration/configure_debug.ui
+++ b/src/yuzu/configuration/configure_debug.ui
@@ -107,6 +107,29 @@
     </widget>
    </item>
    <item>
+    <widget class="QGroupBox" name="groupBox_3">
+     <property name="title">
+      <string>Homebrew</string>
+     </property>
+     <layout class="QVBoxLayout" name="verticalLayout">
+      <item>
+       <layout class="QHBoxLayout" name="horizontalLayout">
+        <item>
+         <widget class="QLabel" name="label">
+          <property name="text">
+           <string>Arguments String</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QLineEdit" name="homebrew_args_edit"/>
+        </item>
+       </layout>
+      </item>
+     </layout>
+    </widget>
+   </item>
+   <item>
     <spacer name="verticalSpacer">
      <property name="orientation">
       <enum>Qt::Vertical</enum>
diff --git a/src/yuzu/configuration/configure_dialog.cpp b/src/yuzu/configuration/configure_dialog.cpp
index daa4cc0d9..3905423e9 100644
--- a/src/yuzu/configuration/configure_dialog.cpp
+++ b/src/yuzu/configuration/configure_dialog.cpp
@@ -27,5 +27,6 @@ void ConfigureDialog::applyConfiguration() {
     ui->graphicsTab->applyConfiguration();
     ui->audioTab->applyConfiguration();
     ui->debugTab->applyConfiguration();
+    ui->webTab->applyConfiguration();
     Settings::Apply();
 }
diff --git a/src/yuzu/configuration/configure_general.cpp b/src/yuzu/configuration/configure_general.cpp
index 9292d9a42..f5db9e55b 100644
--- a/src/yuzu/configuration/configure_general.cpp
+++ b/src/yuzu/configuration/configure_general.cpp
@@ -13,7 +13,7 @@ ConfigureGeneral::ConfigureGeneral(QWidget* parent)
 
     ui->setupUi(this);
 
-    for (auto theme : UISettings::themes) {
+    for (const auto& theme : UISettings::themes) {
         ui->theme_combobox->addItem(theme.first, theme.second);
     }
 
diff --git a/src/yuzu/configuration/configure_input.cpp b/src/yuzu/configuration/configure_input.cpp
index 473937ea9..94789c064 100644
--- a/src/yuzu/configuration/configure_input.cpp
+++ b/src/yuzu/configuration/configure_input.cpp
@@ -5,6 +5,7 @@
 #include <algorithm>
 #include <memory>
 #include <utility>
+#include <QMenu>
 #include <QMessageBox>
 #include <QTimer>
 #include "common/param_package.h"
@@ -128,28 +129,63 @@ ConfigureInput::ConfigureInput(QWidget* parent)
     analog_map_stick = {ui->buttonLStickAnalog, ui->buttonRStickAnalog};
 
     for (int button_id = 0; button_id < Settings::NativeButton::NumButtons; button_id++) {
-        if (button_map[button_id])
-            connect(button_map[button_id], &QPushButton::released, [=]() {
-                handleClick(
-                    button_map[button_id],
-                    [=](const Common::ParamPackage& params) { buttons_param[button_id] = params; },
-                    InputCommon::Polling::DeviceType::Button);
-            });
+        if (!button_map[button_id])
+            continue;
+        button_map[button_id]->setContextMenuPolicy(Qt::CustomContextMenu);
+        connect(button_map[button_id], &QPushButton::released, [=]() {
+            handleClick(
+                button_map[button_id],
+                [=](const Common::ParamPackage& params) { buttons_param[button_id] = params; },
+                InputCommon::Polling::DeviceType::Button);
+        });
+        connect(button_map[button_id], &QPushButton::customContextMenuRequested,
+                [=](const QPoint& menu_location) {
+                    QMenu context_menu;
+                    context_menu.addAction(tr("Clear"), [&] {
+                        buttons_param[button_id].Clear();
+                        button_map[button_id]->setText(tr("[not set]"));
+                    });
+                    context_menu.addAction(tr("Restore Default"), [&] {
+                        buttons_param[button_id] = Common::ParamPackage{
+                            InputCommon::GenerateKeyboardParam(Config::default_buttons[button_id])};
+                        button_map[button_id]->setText(ButtonToText(buttons_param[button_id]));
+                    });
+                    context_menu.exec(button_map[button_id]->mapToGlobal(menu_location));
+                });
     }
 
     for (int analog_id = 0; analog_id < Settings::NativeAnalog::NumAnalogs; analog_id++) {
         for (int sub_button_id = 0; sub_button_id < ANALOG_SUB_BUTTONS_NUM; sub_button_id++) {
-            if (analog_map_buttons[analog_id][sub_button_id] != nullptr) {
-                connect(analog_map_buttons[analog_id][sub_button_id], &QPushButton::released,
-                        [=]() {
-                            handleClick(analog_map_buttons[analog_id][sub_button_id],
-                                        [=](const Common::ParamPackage& params) {
-                                            SetAnalogButton(params, analogs_param[analog_id],
-                                                            analog_sub_buttons[sub_button_id]);
-                                        },
-                                        InputCommon::Polling::DeviceType::Button);
+            if (!analog_map_buttons[analog_id][sub_button_id])
+                continue;
+            analog_map_buttons[analog_id][sub_button_id]->setContextMenuPolicy(
+                Qt::CustomContextMenu);
+            connect(analog_map_buttons[analog_id][sub_button_id], &QPushButton::released, [=]() {
+                handleClick(analog_map_buttons[analog_id][sub_button_id],
+                            [=](const Common::ParamPackage& params) {
+                                SetAnalogButton(params, analogs_param[analog_id],
+                                                analog_sub_buttons[sub_button_id]);
+                            },
+                            InputCommon::Polling::DeviceType::Button);
+            });
+            connect(analog_map_buttons[analog_id][sub_button_id],
+                    &QPushButton::customContextMenuRequested, [=](const QPoint& menu_location) {
+                        QMenu context_menu;
+                        context_menu.addAction(tr("Clear"), [&] {
+                            analogs_param[analog_id].Erase(analog_sub_buttons[sub_button_id]);
+                            analog_map_buttons[analog_id][sub_button_id]->setText(tr("[not set]"));
                         });
-            }
+                        context_menu.addAction(tr("Restore Default"), [&] {
+                            Common::ParamPackage params{InputCommon::GenerateKeyboardParam(
+                                Config::default_analogs[analog_id][sub_button_id])};
+                            SetAnalogButton(params, analogs_param[analog_id],
+                                            analog_sub_buttons[sub_button_id]);
+                            analog_map_buttons[analog_id][sub_button_id]->setText(AnalogToText(
+                                analogs_param[analog_id], analog_sub_buttons[sub_button_id]));
+                        });
+                        context_menu.exec(analog_map_buttons[analog_id][sub_button_id]->mapToGlobal(
+                            menu_location));
+                    });
         }
         connect(analog_map_stick[analog_id], &QPushButton::released, [=]() {
             QMessageBox::information(this, tr("Information"),
@@ -162,6 +198,7 @@ ConfigureInput::ConfigureInput(QWidget* parent)
         });
     }
 
+    connect(ui->buttonClearAll, &QPushButton::released, [this] { ClearAll(); });
     connect(ui->buttonRestoreDefaults, &QPushButton::released, [this]() { restoreDefaults(); });
 
     timeout_timer->setSingleShot(true);
@@ -215,7 +252,21 @@ void ConfigureInput::restoreDefaults() {
         }
     }
     updateButtonLabels();
-    applyConfiguration();
+}
+
+void ConfigureInput::ClearAll() {
+    for (int button_id = 0; button_id < Settings::NativeButton::NumButtons; button_id++) {
+        if (button_map[button_id] && button_map[button_id]->isEnabled())
+            buttons_param[button_id].Clear();
+    }
+    for (int analog_id = 0; analog_id < Settings::NativeAnalog::NumAnalogs; analog_id++) {
+        for (int sub_button_id = 0; sub_button_id < ANALOG_SUB_BUTTONS_NUM; sub_button_id++) {
+            if (analog_map_buttons[analog_id][sub_button_id] &&
+                analog_map_buttons[analog_id][sub_button_id]->isEnabled())
+                analogs_param[analog_id].Erase(analog_sub_buttons[sub_button_id]);
+        }
+    }
+    updateButtonLabels();
 }
 
 void ConfigureInput::updateButtonLabels() {
diff --git a/src/yuzu/configuration/configure_input.h b/src/yuzu/configuration/configure_input.h
index a0bef86d5..d1198db81 100644
--- a/src/yuzu/configuration/configure_input.h
+++ b/src/yuzu/configuration/configure_input.h
@@ -72,6 +72,9 @@ private:
     void loadConfiguration();
     /// Restore all buttons to their default values.
     void restoreDefaults();
+    /// Clear all input configuration
+    void ClearAll();
+
     /// Update UI to reflect current configuration.
     void updateButtonLabels();
 
diff --git a/src/yuzu/configuration/configure_input.ui b/src/yuzu/configuration/configure_input.ui
index 8bfa5df62..8a019a693 100644
--- a/src/yuzu/configuration/configure_input.ui
+++ b/src/yuzu/configuration/configure_input.ui
@@ -695,6 +695,34 @@ Capture:</string>
       </spacer>
      </item>
      <item>
+      <widget class="QPushButton" name="buttonClearAll">
+       <property name="sizePolicy">
+        <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
+         <horstretch>0</horstretch>
+         <verstretch>0</verstretch>
+        </sizepolicy>
+       </property>
+       <property name="sizeIncrement">
+        <size>
+         <width>0</width>
+         <height>0</height>
+        </size>
+       </property>
+       <property name="baseSize">
+        <size>
+         <width>0</width>
+         <height>0</height>
+        </size>
+       </property>
+       <property name="layoutDirection">
+        <enum>Qt::LeftToRight</enum>
+       </property>
+       <property name="text">
+        <string>Clear All</string>
+       </property>
+      </widget>
+     </item>
+     <item>
       <widget class="QPushButton" name="buttonRestoreDefaults">
        <property name="sizePolicy">
         <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
diff --git a/src/yuzu/configuration/configure_web.cpp b/src/yuzu/configuration/configure_web.cpp
new file mode 100644
index 000000000..3c2ccb76f
--- /dev/null
+++ b/src/yuzu/configuration/configure_web.cpp
@@ -0,0 +1,119 @@
+// Copyright 2017 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <QIcon>
+#include <QMessageBox>
+#include <QtConcurrent/QtConcurrentRun>
+#include "core/settings.h"
+#include "core/telemetry_session.h"
+#include "ui_configure_web.h"
+#include "yuzu/configuration/configure_web.h"
+#include "yuzu/ui_settings.h"
+
+ConfigureWeb::ConfigureWeb(QWidget* parent)
+    : QWidget(parent), ui(std::make_unique<Ui::ConfigureWeb>()) {
+    ui->setupUi(this);
+    connect(ui->button_regenerate_telemetry_id, &QPushButton::clicked, this,
+            &ConfigureWeb::RefreshTelemetryID);
+    connect(ui->button_verify_login, &QPushButton::clicked, this, &ConfigureWeb::VerifyLogin);
+    connect(&verify_watcher, &QFutureWatcher<bool>::finished, this, &ConfigureWeb::OnLoginVerified);
+
+#ifndef USE_DISCORD_PRESENCE
+    ui->discord_group->setVisible(false);
+#endif
+    this->setConfiguration();
+}
+
+ConfigureWeb::~ConfigureWeb() = default;
+
+void ConfigureWeb::setConfiguration() {
+    ui->web_credentials_disclaimer->setWordWrap(true);
+    ui->telemetry_learn_more->setOpenExternalLinks(true);
+    ui->telemetry_learn_more->setText(
+        tr("<a href='https://yuzu-emu.org/help/feature/telemetry/'><span style=\"text-decoration: "
+           "underline; color:#039be5;\">Learn more</span></a>"));
+
+    ui->web_signup_link->setOpenExternalLinks(true);
+    ui->web_signup_link->setText(
+        tr("<a href='https://profile.yuzu-emu.org/'><span style=\"text-decoration: underline; "
+           "color:#039be5;\">Sign up</span></a>"));
+    ui->web_token_info_link->setOpenExternalLinks(true);
+    ui->web_token_info_link->setText(
+        tr("<a href='https://yuzu-emu.org/wiki/yuzu-web-service/'><span style=\"text-decoration: "
+           "underline; color:#039be5;\">What is my token?</span></a>"));
+
+    ui->toggle_telemetry->setChecked(Settings::values.enable_telemetry);
+    ui->edit_username->setText(QString::fromStdString(Settings::values.yuzu_username));
+    ui->edit_token->setText(QString::fromStdString(Settings::values.yuzu_token));
+    // Connect after setting the values, to avoid calling OnLoginChanged now
+    connect(ui->edit_token, &QLineEdit::textChanged, this, &ConfigureWeb::OnLoginChanged);
+    connect(ui->edit_username, &QLineEdit::textChanged, this, &ConfigureWeb::OnLoginChanged);
+    ui->label_telemetry_id->setText(
+        tr("Telemetry ID: 0x%1").arg(QString::number(Core::GetTelemetryId(), 16).toUpper()));
+    user_verified = true;
+
+    ui->toggle_discordrpc->setChecked(UISettings::values.enable_discord_presence);
+}
+
+void ConfigureWeb::applyConfiguration() {
+    Settings::values.enable_telemetry = ui->toggle_telemetry->isChecked();
+    UISettings::values.enable_discord_presence = ui->toggle_discordrpc->isChecked();
+    if (user_verified) {
+        Settings::values.yuzu_username = ui->edit_username->text().toStdString();
+        Settings::values.yuzu_token = ui->edit_token->text().toStdString();
+    } else {
+        QMessageBox::warning(this, tr("Username and token not verified"),
+                             tr("Username and token were not verified. The changes to your "
+                                "username and/or token have not been saved."));
+    }
+}
+
+void ConfigureWeb::RefreshTelemetryID() {
+    const u64 new_telemetry_id{Core::RegenerateTelemetryId()};
+    ui->label_telemetry_id->setText(
+        tr("Telemetry ID: 0x%1").arg(QString::number(new_telemetry_id, 16).toUpper()));
+}
+
+void ConfigureWeb::OnLoginChanged() {
+    if (ui->edit_username->text().isEmpty() && ui->edit_token->text().isEmpty()) {
+        user_verified = true;
+        ui->label_username_verified->setPixmap(QIcon::fromTheme("checked").pixmap(16));
+        ui->label_token_verified->setPixmap(QIcon::fromTheme("checked").pixmap(16));
+    } else {
+        user_verified = false;
+        ui->label_username_verified->setPixmap(QIcon::fromTheme("failed").pixmap(16));
+        ui->label_token_verified->setPixmap(QIcon::fromTheme("failed").pixmap(16));
+    }
+}
+
+void ConfigureWeb::VerifyLogin() {
+    ui->button_verify_login->setDisabled(true);
+    ui->button_verify_login->setText(tr("Verifying"));
+    verify_watcher.setFuture(
+        QtConcurrent::run([this, username = ui->edit_username->text().toStdString(),
+                           token = ui->edit_token->text().toStdString()]() {
+            return Core::VerifyLogin(username, token);
+        }));
+}
+
+void ConfigureWeb::OnLoginVerified() {
+    ui->button_verify_login->setEnabled(true);
+    ui->button_verify_login->setText(tr("Verify"));
+    if (verify_watcher.result()) {
+        user_verified = true;
+        ui->label_username_verified->setPixmap(QIcon::fromTheme("checked").pixmap(16));
+        ui->label_token_verified->setPixmap(QIcon::fromTheme("checked").pixmap(16));
+    } else {
+        ui->label_username_verified->setPixmap(QIcon::fromTheme("failed").pixmap(16));
+        ui->label_token_verified->setPixmap(QIcon::fromTheme("failed").pixmap(16));
+        QMessageBox::critical(
+            this, tr("Verification failed"),
+            tr("Verification failed. Check that you have entered your username and token "
+               "correctly, and that your internet connection is working."));
+    }
+}
+
+void ConfigureWeb::retranslateUi() {
+    ui->retranslateUi(this);
+}
diff --git a/src/yuzu/configuration/configure_web.h b/src/yuzu/configuration/configure_web.h
new file mode 100644
index 000000000..7741ab95d
--- /dev/null
+++ b/src/yuzu/configuration/configure_web.h
@@ -0,0 +1,38 @@
+// Copyright 2017 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <memory>
+#include <QFutureWatcher>
+#include <QWidget>
+
+namespace Ui {
+class ConfigureWeb;
+}
+
+class ConfigureWeb : public QWidget {
+    Q_OBJECT
+
+public:
+    explicit ConfigureWeb(QWidget* parent = nullptr);
+    ~ConfigureWeb();
+
+    void applyConfiguration();
+    void retranslateUi();
+
+public slots:
+    void RefreshTelemetryID();
+    void OnLoginChanged();
+    void VerifyLogin();
+    void OnLoginVerified();
+
+private:
+    void setConfiguration();
+
+    bool user_verified = true;
+    QFutureWatcher<bool> verify_watcher;
+
+    std::unique_ptr<Ui::ConfigureWeb> ui;
+};
diff --git a/src/yuzu/configuration/configure_web.ui b/src/yuzu/configuration/configure_web.ui
new file mode 100644
index 000000000..2f4b9dd73
--- /dev/null
+++ b/src/yuzu/configuration/configure_web.ui
@@ -0,0 +1,206 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>ConfigureWeb</class>
+ <widget class="QWidget" name="ConfigureWeb">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>926</width>
+    <height>561</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Form</string>
+  </property>
+  <layout class="QVBoxLayout" name="verticalLayout">
+   <item>
+    <layout class="QVBoxLayout" name="verticalLayout_3">
+     <item>
+      <widget class="QGroupBox" name="groupBoxWebConfig">
+       <property name="title">
+        <string>yuzu Web Service</string>
+       </property>
+       <layout class="QVBoxLayout" name="verticalLayoutYuzuWebService">
+        <item>
+         <widget class="QLabel" name="web_credentials_disclaimer">
+          <property name="text">
+           <string>By providing your username and token, you agree to allow yuzu to collect additional usage data, which may include user identifying information.</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <layout class="QGridLayout" name="gridLayoutYuzuUsername">
+          <item row="2" column="3">
+           <widget class="QPushButton" name="button_verify_login">
+            <property name="sizePolicy">
+             <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
+              <horstretch>0</horstretch>
+              <verstretch>0</verstretch>
+             </sizepolicy>
+            </property>
+            <property name="layoutDirection">
+             <enum>Qt::RightToLeft</enum>
+            </property>
+            <property name="text">
+             <string>Verify</string>
+            </property>
+           </widget>
+          </item>
+          <item row="2" column="0">
+           <widget class="QLabel" name="web_signup_link">
+            <property name="text">
+             <string>Sign up</string>
+            </property>
+           </widget>
+          </item>
+          <item row="0" column="1" colspan="3">
+           <widget class="QLineEdit" name="edit_username">
+            <property name="maxLength">
+             <number>36</number>
+            </property>
+           </widget>
+          </item>
+          <item row="1" column="0">
+           <widget class="QLabel" name="label_token">
+            <property name="text">
+             <string>Token: </string>
+            </property>
+           </widget>
+          </item>
+          <item row="1" column="4">
+           <widget class="QLabel" name="label_token_verified">
+           </widget>
+          </item>
+          <item row="0" column="0">
+           <widget class="QLabel" name="label_username">
+            <property name="text">
+             <string>Username: </string>
+            </property>
+           </widget>
+          </item>
+          <item row="0" column="4">
+           <widget class="QLabel" name="label_username_verified">
+           </widget>
+          </item>
+          <item row="1" column="1" colspan="3">
+           <widget class="QLineEdit" name="edit_token">
+            <property name="maxLength">
+             <number>36</number>
+            </property>
+            <property name="echoMode">
+             <enum>QLineEdit::Password</enum>
+            </property>
+           </widget>
+          </item>
+          <item row="2" column="1">
+           <widget class="QLabel" name="web_token_info_link">
+            <property name="text">
+             <string>What is my token?</string>
+            </property>
+           </widget>
+          </item>
+          <item row="2" column="2">
+           <spacer name="horizontalSpacer">
+            <property name="orientation">
+             <enum>Qt::Horizontal</enum>
+            </property>
+            <property name="sizeHint" stdset="0">
+             <size>
+              <width>40</width>
+              <height>20</height>
+             </size>
+            </property>
+           </spacer>
+          </item>
+         </layout>
+        </item>
+       </layout>
+      </widget>
+     </item>
+     <item>
+      <widget class="QGroupBox" name="groupBox">
+       <property name="title">
+        <string>Telemetry</string>
+       </property>
+       <layout class="QVBoxLayout" name="verticalLayout_2">
+        <item>
+         <widget class="QCheckBox" name="toggle_telemetry">
+          <property name="text">
+           <string>Share anonymous usage data with the yuzu team</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QLabel" name="telemetry_learn_more">
+          <property name="text">
+           <string>Learn more</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <layout class="QGridLayout" name="gridLayoutTelemetryId">
+          <item row="0" column="0">
+           <widget class="QLabel" name="label_telemetry_id">
+            <property name="text">
+             <string>Telemetry ID:</string>
+            </property>
+           </widget>
+          </item>
+          <item row="0" column="1">
+           <widget class="QPushButton" name="button_regenerate_telemetry_id">
+            <property name="sizePolicy">
+             <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
+              <horstretch>0</horstretch>
+              <verstretch>0</verstretch>
+             </sizepolicy>
+            </property>
+            <property name="layoutDirection">
+             <enum>Qt::RightToLeft</enum>
+            </property>
+            <property name="text">
+             <string>Regenerate</string>
+            </property>
+           </widget>
+          </item>
+         </layout>
+        </item>
+       </layout>
+      </widget>
+     </item>
+    </layout>
+   </item>
+   <item>
+     <widget class="QGroupBox" name="discord_group">
+      <property name="title">
+       <string>Discord Presence</string>
+      </property>
+      <layout class="QVBoxLayout" name="verticalLayout_21">
+       <item>
+        <widget class="QCheckBox" name="toggle_discordrpc">
+         <property name="text">
+          <string>Show Current Game in your Discord Status</string>
+         </property>
+        </widget>
+       </item>
+      </layout>
+     </widget>
+   </item>
+   <item>
+    <spacer name="verticalSpacer">
+     <property name="orientation">
+      <enum>Qt::Vertical</enum>
+     </property>
+     <property name="sizeHint" stdset="0">
+      <size>
+       <width>20</width>
+       <height>40</height>
+      </size>
+     </property>
+    </spacer>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>
diff --git a/src/yuzu/debugger/wait_tree.cpp b/src/yuzu/debugger/wait_tree.cpp
index a3b1fd357..4a09da685 100644
--- a/src/yuzu/debugger/wait_tree.cpp
+++ b/src/yuzu/debugger/wait_tree.cpp
@@ -119,7 +119,7 @@ std::vector<std::unique_ptr<WaitTreeItem>> WaitTreeCallstack::GetChildren() cons
     std::vector<std::unique_ptr<WaitTreeItem>> list;
 
     constexpr std::size_t BaseRegister = 29;
-    u64 base_pointer = thread.context.cpu_registers[BaseRegister];
+    u64 base_pointer = thread.GetContext().cpu_registers[BaseRegister];
 
     while (base_pointer != 0) {
         u64 lr = Memory::Read64(base_pointer + sizeof(u64));
@@ -213,7 +213,7 @@ WaitTreeThread::~WaitTreeThread() = default;
 QString WaitTreeThread::GetText() const {
     const auto& thread = static_cast<const Kernel::Thread&>(object);
     QString status;
-    switch (thread.status) {
+    switch (thread.GetStatus()) {
     case Kernel::ThreadStatus::Running:
         status = tr("running");
         break;
@@ -246,15 +246,17 @@ QString WaitTreeThread::GetText() const {
         status = tr("dead");
         break;
     }
-    QString pc_info = tr(" PC = 0x%1 LR = 0x%2")
-                          .arg(thread.context.pc, 8, 16, QLatin1Char('0'))
-                          .arg(thread.context.cpu_registers[30], 8, 16, QLatin1Char('0'));
+
+    const auto& context = thread.GetContext();
+    const QString pc_info = tr(" PC = 0x%1 LR = 0x%2")
+                                .arg(context.pc, 8, 16, QLatin1Char('0'))
+                                .arg(context.cpu_registers[30], 8, 16, QLatin1Char('0'));
     return WaitTreeWaitObject::GetText() + pc_info + " (" + status + ") ";
 }
 
 QColor WaitTreeThread::GetColor() const {
     const auto& thread = static_cast<const Kernel::Thread&>(object);
-    switch (thread.status) {
+    switch (thread.GetStatus()) {
     case Kernel::ThreadStatus::Running:
         return QColor(Qt::GlobalColor::darkGreen);
     case Kernel::ThreadStatus::Ready:
@@ -284,7 +286,7 @@ std::vector<std::unique_ptr<WaitTreeItem>> WaitTreeThread::GetChildren() const {
     const auto& thread = static_cast<const Kernel::Thread&>(object);
 
     QString processor;
-    switch (thread.processor_id) {
+    switch (thread.GetProcessorID()) {
     case Kernel::ThreadProcessorId::THREADPROCESSORID_DEFAULT:
         processor = tr("default");
         break;
@@ -292,32 +294,35 @@ std::vector<std::unique_ptr<WaitTreeItem>> WaitTreeThread::GetChildren() const {
     case Kernel::ThreadProcessorId::THREADPROCESSORID_1:
     case Kernel::ThreadProcessorId::THREADPROCESSORID_2:
     case Kernel::ThreadProcessorId::THREADPROCESSORID_3:
-        processor = tr("core %1").arg(thread.processor_id);
+        processor = tr("core %1").arg(thread.GetProcessorID());
         break;
     default:
-        processor = tr("Unknown processor %1").arg(thread.processor_id);
+        processor = tr("Unknown processor %1").arg(thread.GetProcessorID());
         break;
     }
 
     list.push_back(std::make_unique<WaitTreeText>(tr("processor = %1").arg(processor)));
-    list.push_back(std::make_unique<WaitTreeText>(tr("ideal core = %1").arg(thread.ideal_core)));
     list.push_back(
-        std::make_unique<WaitTreeText>(tr("affinity mask = %1").arg(thread.affinity_mask)));
-    list.push_back(std::make_unique<WaitTreeText>(tr("thread id = %1").arg(thread.GetThreadId())));
+        std::make_unique<WaitTreeText>(tr("ideal core = %1").arg(thread.GetIdealCore())));
+    list.push_back(
+        std::make_unique<WaitTreeText>(tr("affinity mask = %1").arg(thread.GetAffinityMask())));
+    list.push_back(std::make_unique<WaitTreeText>(tr("thread id = %1").arg(thread.GetThreadID())));
     list.push_back(std::make_unique<WaitTreeText>(tr("priority = %1(current) / %2(normal)")
-                                                      .arg(thread.current_priority)
-                                                      .arg(thread.nominal_priority)));
+                                                      .arg(thread.GetPriority())
+                                                      .arg(thread.GetNominalPriority())));
     list.push_back(std::make_unique<WaitTreeText>(
-        tr("last running ticks = %1").arg(thread.last_running_ticks)));
+        tr("last running ticks = %1").arg(thread.GetLastRunningTicks())));
 
-    if (thread.mutex_wait_address != 0)
-        list.push_back(std::make_unique<WaitTreeMutexInfo>(thread.mutex_wait_address));
-    else
+    const VAddr mutex_wait_address = thread.GetMutexWaitAddress();
+    if (mutex_wait_address != 0) {
+        list.push_back(std::make_unique<WaitTreeMutexInfo>(mutex_wait_address));
+    } else {
         list.push_back(std::make_unique<WaitTreeText>(tr("not waiting for mutex")));
+    }
 
-    if (thread.status == Kernel::ThreadStatus::WaitSynchAny ||
-        thread.status == Kernel::ThreadStatus::WaitSynchAll) {
-        list.push_back(std::make_unique<WaitTreeObjectList>(thread.wait_objects,
+    if (thread.GetStatus() == Kernel::ThreadStatus::WaitSynchAny ||
+        thread.GetStatus() == Kernel::ThreadStatus::WaitSynchAll) {
+        list.push_back(std::make_unique<WaitTreeObjectList>(thread.GetWaitObjects(),
                                                             thread.IsSleepingOnWaitAll()));
     }
 
diff --git a/src/yuzu/discord.h b/src/yuzu/discord.h
new file mode 100644
index 000000000..a867cc4d6
--- /dev/null
+++ b/src/yuzu/discord.h
@@ -0,0 +1,25 @@
+// Copyright 2018 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+namespace DiscordRPC {
+
+class DiscordInterface {
+public:
+    virtual ~DiscordInterface() = default;
+
+    virtual void Pause() = 0;
+    virtual void Update() = 0;
+};
+
+class NullImpl : public DiscordInterface {
+public:
+    ~NullImpl() = default;
+
+    void Pause() override {}
+    void Update() override {}
+};
+
+} // namespace DiscordRPC
diff --git a/src/yuzu/discord_impl.cpp b/src/yuzu/discord_impl.cpp
new file mode 100644
index 000000000..9d87a41eb
--- /dev/null
+++ b/src/yuzu/discord_impl.cpp
@@ -0,0 +1,52 @@
+// Copyright 2018 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <chrono>
+#include <string>
+#include <discord_rpc.h>
+#include "common/common_types.h"
+#include "core/core.h"
+#include "core/loader/loader.h"
+#include "yuzu/discord_impl.h"
+#include "yuzu/ui_settings.h"
+
+namespace DiscordRPC {
+
+DiscordImpl::DiscordImpl() {
+    DiscordEventHandlers handlers{};
+
+    // The number is the client ID for yuzu, it's used for images and the
+    // application name
+    Discord_Initialize("471872241299226636", &handlers, 1, nullptr);
+}
+
+DiscordImpl::~DiscordImpl() {
+    Discord_ClearPresence();
+    Discord_Shutdown();
+}
+
+void DiscordImpl::Pause() {
+    Discord_ClearPresence();
+}
+
+void DiscordImpl::Update() {
+    s64 start_time = std::chrono::duration_cast<std::chrono::seconds>(
+                         std::chrono::system_clock::now().time_since_epoch())
+                         .count();
+    std::string title;
+    if (Core::System::GetInstance().IsPoweredOn())
+        Core::System::GetInstance().GetAppLoader().ReadTitle(title);
+    DiscordRichPresence presence{};
+    presence.largeImageKey = "yuzu_logo";
+    presence.largeImageText = "yuzu is an emulator for the Nintendo Switch";
+    if (Core::System::GetInstance().IsPoweredOn()) {
+        presence.state = title.c_str();
+        presence.details = "Currently in game";
+    } else {
+        presence.details = "Not in game";
+    }
+    presence.startTimestamp = start_time;
+    Discord_UpdatePresence(&presence);
+}
+} // namespace DiscordRPC
diff --git a/src/yuzu/discord_impl.h b/src/yuzu/discord_impl.h
new file mode 100644
index 000000000..4bfda8cdf
--- /dev/null
+++ b/src/yuzu/discord_impl.h
@@ -0,0 +1,20 @@
+// Copyright 2018 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include "yuzu/discord.h"
+
+namespace DiscordRPC {
+
+class DiscordImpl : public DiscordInterface {
+public:
+    DiscordImpl();
+    ~DiscordImpl() override;
+
+    void Pause() override;
+    void Update() override;
+};
+
+} // namespace DiscordRPC
diff --git a/src/yuzu/game_list_worker.cpp b/src/yuzu/game_list_worker.cpp
index 1947bdb93..d2b3de683 100644
--- a/src/yuzu/game_list_worker.cpp
+++ b/src/yuzu/game_list_worker.cpp
@@ -57,16 +57,25 @@ QString FormatGameName(const std::string& physical_name) {
     return physical_name_as_qstring;
 }
 
-QString FormatPatchNameVersions(const FileSys::PatchManager& patch_manager, bool updatable = true) {
+QString FormatPatchNameVersions(const FileSys::PatchManager& patch_manager,
+                                Loader::AppLoader& loader, bool updatable = true) {
     QString out;
-    for (const auto& kv : patch_manager.GetPatchVersionNames()) {
+    FileSys::VirtualFile update_raw;
+    loader.ReadUpdateRaw(update_raw);
+    for (const auto& kv : patch_manager.GetPatchVersionNames(update_raw)) {
         if (!updatable && kv.first == "Update")
             continue;
 
         if (kv.second.empty()) {
             out.append(fmt::format("{}\n", kv.first).c_str());
         } else {
-            out.append(fmt::format("{} ({})\n", kv.first, kv.second).c_str());
+            auto ver = kv.second;
+
+            // Display container name for packed updates
+            if (ver == "PACKED" && kv.first == "Update")
+                ver = Loader::GetFileTypeString(loader.GetFileType());
+
+            out.append(fmt::format("{} ({})\n", kv.first, ver).c_str());
         }
     }
 
@@ -116,7 +125,7 @@ void GameListWorker::AddInstalledTitlesToGameList() {
                 QString::fromStdString(Loader::GetFileTypeString(loader->GetFileType())),
                 program_id),
             new GameListItemCompat(compatibility),
-            new GameListItem(FormatPatchNameVersions(patch)),
+            new GameListItem(FormatPatchNameVersions(patch, *loader)),
             new GameListItem(
                 QString::fromStdString(Loader::GetFileTypeString(loader->GetFileType()))),
             new GameListItemSize(file->GetSize()),
@@ -206,7 +215,8 @@ void GameListWorker::AddFstEntriesToGameList(const std::string& dir_path, unsign
                     QString::fromStdString(Loader::GetFileTypeString(loader->GetFileType())),
                     program_id),
                 new GameListItemCompat(compatibility),
-                new GameListItem(FormatPatchNameVersions(patch, loader->IsRomFSUpdatable())),
+                new GameListItem(
+                    FormatPatchNameVersions(patch, *loader, loader->IsRomFSUpdatable())),
                 new GameListItem(
                     QString::fromStdString(Loader::GetFileTypeString(loader->GetFileType()))),
                 new GameListItemSize(FileUtil::GetSize(physical_name)),
diff --git a/src/yuzu/main.cpp b/src/yuzu/main.cpp
index 27015d02c..e11833c5a 100644
--- a/src/yuzu/main.cpp
+++ b/src/yuzu/main.cpp
@@ -35,6 +35,7 @@ static FileSys::VirtualFile VfsDirectoryCreateFileWrapper(const FileSys::Virtual
 #include <QtWidgets>
 #include <fmt/format.h>
 #include "common/common_paths.h"
+#include "common/detached_tasks.h"
 #include "common/file_util.h"
 #include "common/logging/backend.h"
 #include "common/logging/filter.h"
@@ -65,6 +66,7 @@ static FileSys::VirtualFile VfsDirectoryCreateFileWrapper(const FileSys::Virtual
 #include "video_core/debug_utils/debug_utils.h"
 #include "yuzu/about_dialog.h"
 #include "yuzu/bootmanager.h"
+#include "yuzu/compatdb.h"
 #include "yuzu/compatibility_list.h"
 #include "yuzu/configuration/config.h"
 #include "yuzu/configuration/configure_dialog.h"
@@ -73,12 +75,17 @@ static FileSys::VirtualFile VfsDirectoryCreateFileWrapper(const FileSys::Virtual
 #include "yuzu/debugger/graphics/graphics_surface.h"
 #include "yuzu/debugger/profiler.h"
 #include "yuzu/debugger/wait_tree.h"
+#include "yuzu/discord.h"
 #include "yuzu/game_list.h"
 #include "yuzu/game_list_p.h"
 #include "yuzu/hotkeys.h"
 #include "yuzu/main.h"
 #include "yuzu/ui_settings.h"
 
+#ifdef USE_DISCORD_PRESENCE
+#include "yuzu/discord_impl.h"
+#endif
+
 #ifdef QT_STATICPLUGIN
 Q_IMPORT_PLUGIN(QWindowsIntegrationPlugin);
 #endif
@@ -102,23 +109,22 @@ enum class CalloutFlag : uint32_t {
     DRDDeprecation = 0x2,
 };
 
-static void ShowCalloutMessage(const QString& message, CalloutFlag flag) {
-    if (UISettings::values.callout_flags & static_cast<uint32_t>(flag)) {
+void GMainWindow::ShowTelemetryCallout() {
+    if (UISettings::values.callout_flags & static_cast<uint32_t>(CalloutFlag::Telemetry)) {
         return;
     }
 
-    UISettings::values.callout_flags |= static_cast<uint32_t>(flag);
-
-    QMessageBox msg;
-    msg.setText(message);
-    msg.setStandardButtons(QMessageBox::Ok);
-    msg.setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
-    msg.setStyleSheet("QLabel{min-width: 900px;}");
-    msg.exec();
+    UISettings::values.callout_flags |= static_cast<uint32_t>(CalloutFlag::Telemetry);
+    const QString telemetry_message =
+        tr("<a href='https://yuzu-emu.org/help/feature/telemetry/'>Anonymous "
+           "data is collected</a> to help improve yuzu. "
+           "<br/><br/>Would you like to share your usage data with us?");
+    if (QMessageBox::question(this, tr("Telemetry"), telemetry_message) != QMessageBox::Yes) {
+        Settings::values.enable_telemetry = false;
+        Settings::Apply();
+    }
 }
 
-void GMainWindow::ShowCallouts() {}
-
 const int GMainWindow::max_recent_files_item;
 
 static void InitializeLogging() {
@@ -145,6 +151,9 @@ GMainWindow::GMainWindow()
     default_theme_paths = QIcon::themeSearchPaths();
     UpdateUITheme();
 
+    SetDiscordEnabled(UISettings::values.enable_discord_presence);
+    discord_rpc->Update();
+
     InitializeWidgets();
     InitializeDebugWidgets();
     InitializeRecentFileMenuActions();
@@ -168,7 +177,7 @@ GMainWindow::GMainWindow()
     game_list->PopulateAsync(UISettings::values.gamedir, UISettings::values.gamedir_deepscan);
 
     // Show one-time "callout" messages to the user
-    ShowCallouts();
+    ShowTelemetryCallout();
 
     QStringList args = QApplication::arguments();
     if (args.length() >= 2) {
@@ -183,6 +192,9 @@ GMainWindow::~GMainWindow() {
 }
 
 void GMainWindow::InitializeWidgets() {
+#ifdef YUZU_ENABLE_COMPATIBILITY_REPORTING
+    ui.action_Report_Compatibility->setVisible(true);
+#endif
     render_window = new GRenderWindow(this, emu_thread.get());
     render_window->hide();
 
@@ -411,6 +423,8 @@ void GMainWindow::ConnectMenuEvents() {
     connect(ui.action_Start, &QAction::triggered, this, &GMainWindow::OnStartGame);
     connect(ui.action_Pause, &QAction::triggered, this, &GMainWindow::OnPauseGame);
     connect(ui.action_Stop, &QAction::triggered, this, &GMainWindow::OnStopGame);
+    connect(ui.action_Report_Compatibility, &QAction::triggered, this,
+            &GMainWindow::OnMenuReportCompatibility);
     connect(ui.action_Restart, &QAction::triggered, this, [this] { BootGame(QString(game_path)); });
     connect(ui.action_Configure, &QAction::triggered, this, &GMainWindow::OnConfigure);
 
@@ -471,6 +485,8 @@ QStringList GMainWindow::GetUnsupportedGLExtensions() {
         unsupported_ext.append("ARB_texture_storage");
     if (!GLAD_GL_ARB_multi_bind)
         unsupported_ext.append("ARB_multi_bind");
+    if (!GLAD_GL_ARB_copy_image)
+        unsupported_ext.append("ARB_copy_image");
 
     // Extensions required to support some texture formats.
     if (!GLAD_GL_EXT_texture_compression_s3tc)
@@ -647,6 +663,7 @@ void GMainWindow::BootGame(const QString& filename) {
 }
 
 void GMainWindow::ShutdownGame() {
+    discord_rpc->Pause();
     emu_thread->RequestStop();
 
     emit EmulationStopping();
@@ -655,6 +672,8 @@ void GMainWindow::ShutdownGame() {
     emu_thread->wait();
     emu_thread = nullptr;
 
+    discord_rpc->Update();
+
     // The emulation is stopped, so closing the window or not does not matter anymore
     disconnect(render_window, &GRenderWindow::Closed, this, &GMainWindow::OnStopGame);
 
@@ -664,6 +683,7 @@ void GMainWindow::ShutdownGame() {
     ui.action_Pause->setEnabled(false);
     ui.action_Stop->setEnabled(false);
     ui.action_Restart->setEnabled(false);
+    ui.action_Report_Compatibility->setEnabled(false);
     render_window->hide();
     game_list->show();
     game_list->setFilterFocus();
@@ -1147,6 +1167,9 @@ void GMainWindow::OnStartGame() {
     ui.action_Pause->setEnabled(true);
     ui.action_Stop->setEnabled(true);
     ui.action_Restart->setEnabled(true);
+    ui.action_Report_Compatibility->setEnabled(true);
+
+    discord_rpc->Update();
 }
 
 void GMainWindow::OnPauseGame() {
@@ -1161,6 +1184,20 @@ void GMainWindow::OnStopGame() {
     ShutdownGame();
 }
 
+void GMainWindow::OnMenuReportCompatibility() {
+    if (!Settings::values.yuzu_token.empty() && !Settings::values.yuzu_username.empty()) {
+        CompatDB compatdb{this};
+        compatdb.exec();
+    } else {
+        QMessageBox::critical(
+            this, tr("Missing yuzu Account"),
+            tr("In order to submit a game compatibility test case, you must link your yuzu "
+               "account.<br><br/>To link your yuzu account, go to Emulation &gt; Configuration "
+               "&gt; "
+               "Web."));
+    }
+}
+
 void GMainWindow::ToggleFullscreen() {
     if (!emulation_running) {
         return;
@@ -1224,11 +1261,14 @@ void GMainWindow::ToggleWindowMode() {
 void GMainWindow::OnConfigure() {
     ConfigureDialog configureDialog(this, hotkey_registry);
     auto old_theme = UISettings::values.theme;
+    const bool old_discord_presence = UISettings::values.enable_discord_presence;
     auto result = configureDialog.exec();
     if (result == QDialog::Accepted) {
         configureDialog.applyConfiguration();
         if (UISettings::values.theme != old_theme)
             UpdateUITheme();
+        if (UISettings::values.enable_discord_presence != old_discord_presence)
+            SetDiscordEnabled(UISettings::values.enable_discord_presence);
         game_list->PopulateAsync(UISettings::values.gamedir, UISettings::values.gamedir_deepscan);
         config->Save();
     }
@@ -1443,11 +1483,25 @@ void GMainWindow::UpdateUITheme() {
     emit UpdateThemedIcons();
 }
 
+void GMainWindow::SetDiscordEnabled(bool state) {
+#ifdef USE_DISCORD_PRESENCE
+    if (state) {
+        discord_rpc = std::make_unique<DiscordRPC::DiscordImpl>();
+    } else {
+        discord_rpc = std::make_unique<DiscordRPC::NullImpl>();
+    }
+#else
+    discord_rpc = std::make_unique<DiscordRPC::NullImpl>();
+#endif
+    discord_rpc->Update();
+}
+
 #ifdef main
 #undef main
 #endif
 
 int main(int argc, char* argv[]) {
+    Common::DetachedTasks detached_tasks;
     MicroProfileOnThreadCreate("Frontend");
     SCOPE_EXIT({ MicroProfileShutdown(); });
 
@@ -1465,5 +1519,7 @@ int main(int argc, char* argv[]) {
     GMainWindow main_window;
     // After settings have been loaded by GMainWindow, apply the filter
     main_window.show();
-    return app.exec();
+    int result = app.exec();
+    detached_tasks.WaitForAllTasks();
+    return result;
 }
diff --git a/src/yuzu/main.h b/src/yuzu/main.h
index 8ee9242b1..fe0e9a50a 100644
--- a/src/yuzu/main.h
+++ b/src/yuzu/main.h
@@ -41,6 +41,10 @@ enum class EmulatedDirectoryTarget {
     SDMC,
 };
 
+namespace DiscordRPC {
+class DiscordInterface;
+}
+
 class GMainWindow : public QMainWindow {
     Q_OBJECT
 
@@ -61,6 +65,8 @@ public:
     GMainWindow();
     ~GMainWindow() override;
 
+    std::unique_ptr<DiscordRPC::DiscordInterface> discord_rpc;
+
 signals:
 
     /**
@@ -99,7 +105,8 @@ private:
     void BootGame(const QString& filename);
     void ShutdownGame();
 
-    void ShowCallouts();
+    void ShowTelemetryCallout();
+    void SetDiscordEnabled(bool state);
 
     /**
      * Stores the filename in the recently loaded files list.
@@ -135,6 +142,7 @@ private slots:
     void OnStartGame();
     void OnPauseGame();
     void OnStopGame();
+    void OnMenuReportCompatibility();
     /// Called whenever a user selects a game in the game list widget.
     void OnGameListLoadFile(QString game_path);
     void OnGameListOpenFolder(u64 program_id, GameListOpenTarget target);
diff --git a/src/yuzu/main.ui b/src/yuzu/main.ui
index 3879d4813..cb1664b21 100644
--- a/src/yuzu/main.ui
+++ b/src/yuzu/main.ui
@@ -45,7 +45,7 @@
      <x>0</x>
      <y>0</y>
      <width>1081</width>
-     <height>19</height>
+     <height>21</height>
     </rect>
    </property>
    <widget class="QMenu" name="menu_File">
@@ -101,6 +101,8 @@
     <property name="title">
      <string>&amp;Help</string>
     </property>
+    <addaction name="action_Report_Compatibility"/>
+    <addaction name="separator"/>
     <addaction name="action_About"/>
    </widget>
    <addaction name="menu_File"/>
@@ -239,6 +241,18 @@
        <string>Restart</string>
      </property>
    </action>
+   <action name="action_Report_Compatibility">
+     <property name="enabled">
+       <bool>false</bool>
+     </property>
+     <property name="text">
+       <string>Report Compatibility</string>
+     </property>
+     <property name="visible">
+       <bool>false</bool>
+     </property>
+   </action>
   </widget>
  <resources/>
+ <connections/>
 </ui>
diff --git a/src/yuzu/ui_settings.cpp b/src/yuzu/ui_settings.cpp
index 120b34990..a314493fc 100644
--- a/src/yuzu/ui_settings.cpp
+++ b/src/yuzu/ui_settings.cpp
@@ -6,5 +6,11 @@
 
 namespace UISettings {
 
+const Themes themes{{
+    {"Default", "default"},
+    {"Dark", "qdarkstyle"},
+}};
+
 Values values = {};
-}
+
+} // namespace UISettings
diff --git a/src/yuzu/ui_settings.h b/src/yuzu/ui_settings.h
index 051494bc5..2e617d52a 100644
--- a/src/yuzu/ui_settings.h
+++ b/src/yuzu/ui_settings.h
@@ -15,9 +15,8 @@ namespace UISettings {
 using ContextualShortcut = std::pair<QString, int>;
 using Shortcut = std::pair<QString, ContextualShortcut>;
 
-static const std::array<std::pair<QString, QString>, 2> themes = {
-    {std::make_pair(QString("Default"), QString("default")),
-     std::make_pair(QString("Dark"), QString("qdarkstyle"))}};
+using Themes = std::array<std::pair<const char*, const char*>, 2>;
+extern const Themes themes;
 
 struct Values {
     QByteArray geometry;
@@ -39,6 +38,9 @@ struct Values {
     bool confirm_before_closing;
     bool first_start;
 
+    // Discord RPC
+    bool enable_discord_presence;
+
     QString roms_path;
     QString symbols_path;
     QString gamedir;
diff --git a/src/yuzu_cmd/config.cpp b/src/yuzu_cmd/config.cpp
index a478b0a56..2470f4640 100644
--- a/src/yuzu_cmd/config.cpp
+++ b/src/yuzu_cmd/config.cpp
@@ -138,6 +138,15 @@ void Config::ReadValues() {
     Settings::values.use_gdbstub = sdl2_config->GetBoolean("Debugging", "use_gdbstub", false);
     Settings::values.gdbstub_port =
         static_cast<u16>(sdl2_config->GetInteger("Debugging", "gdbstub_port", 24689));
+    Settings::values.program_args = sdl2_config->Get("Debugging", "program_args", "");
+
+    // Web Service
+    Settings::values.enable_telemetry =
+        sdl2_config->GetBoolean("WebService", "enable_telemetry", true);
+    Settings::values.web_api_url =
+        sdl2_config->Get("WebService", "web_api_url", "https://api.yuzu-emu.org");
+    Settings::values.yuzu_username = sdl2_config->Get("WebService", "yuzu_username", "");
+    Settings::values.yuzu_token = sdl2_config->Get("WebService", "yuzu_token", "");
 }
 
 void Config::Reload() {
diff --git a/src/yuzu_cmd/default_ini.h b/src/yuzu_cmd/default_ini.h
index d35c441e9..762396e3b 100644
--- a/src/yuzu_cmd/default_ini.h
+++ b/src/yuzu_cmd/default_ini.h
@@ -202,12 +202,10 @@ gdbstub_port=24689
 # Whether or not to enable telemetry
 # 0: No, 1 (default): Yes
 enable_telemetry =
-# Endpoint URL for submitting telemetry data
-telemetry_endpoint_url =
-# Endpoint URL to verify the username and token
-verify_endpoint_url =
+# URL for Web API
+web_api_url = https://api.yuzu-emu.org
 # Username and token for yuzu Web Service
-# See https://services.citra-emu.org/ for more info
+# See https://profile.yuzu-emu.org/ for more info
 yuzu_username =
 yuzu_token =
 )";
diff --git a/src/yuzu_cmd/emu_window/emu_window_sdl2.cpp b/src/yuzu_cmd/emu_window/emu_window_sdl2.cpp
index 0733301b2..155095095 100644
--- a/src/yuzu_cmd/emu_window/emu_window_sdl2.cpp
+++ b/src/yuzu_cmd/emu_window/emu_window_sdl2.cpp
@@ -98,6 +98,8 @@ bool EmuWindow_SDL2::SupportsRequiredGLExtensions() {
         unsupported_ext.push_back("ARB_texture_storage");
     if (!GLAD_GL_ARB_multi_bind)
         unsupported_ext.push_back("ARB_multi_bind");
+    if (!GLAD_GL_ARB_copy_image)
+        unsupported_ext.push_back("ARB_copy_image");
 
     // Extensions required to support some texture formats.
     if (!GLAD_GL_EXT_texture_compression_s3tc)
diff --git a/src/yuzu_cmd/yuzu.cpp b/src/yuzu_cmd/yuzu.cpp
index b2559b717..27aba95f6 100644
--- a/src/yuzu_cmd/yuzu.cpp
+++ b/src/yuzu_cmd/yuzu.cpp
@@ -10,6 +10,7 @@
 #include <fmt/ostream.h>
 
 #include "common/common_paths.h"
+#include "common/detached_tasks.h"
 #include "common/file_util.h"
 #include "common/logging/backend.h"
 #include "common/logging/filter.h"
@@ -55,9 +56,10 @@ static void PrintHelp(const char* argv0) {
     std::cout << "Usage: " << argv0
               << " [options] <filename>\n"
                  "-g, --gdbport=NUMBER  Enable gdb stub on port NUMBER\n"
-                 "-f, --fullscreen     Start in fullscreen mode\n"
+                 "-f, --fullscreen      Start in fullscreen mode\n"
                  "-h, --help            Display this help and exit\n"
-                 "-v, --version         Output version information and exit\n";
+                 "-v, --version         Output version information and exit\n"
+                 "-p, --program         Pass following string as arguments to executable\n";
 }
 
 static void PrintVersion() {
@@ -78,6 +80,7 @@ static void InitializeLogging() {
 
 /// Application entry point
 int main(int argc, char** argv) {
+    Common::DetachedTasks detached_tasks;
     Config config;
 
     int option_index = 0;
@@ -101,15 +104,13 @@ int main(int argc, char** argv) {
     bool fullscreen = false;
 
     static struct option long_options[] = {
-        {"gdbport", required_argument, 0, 'g'},
-        {"fullscreen", no_argument, 0, 'f'},
-        {"help", no_argument, 0, 'h'},
-        {"version", no_argument, 0, 'v'},
-        {0, 0, 0, 0},
+        {"gdbport", required_argument, 0, 'g'}, {"fullscreen", no_argument, 0, 'f'},
+        {"help", no_argument, 0, 'h'},          {"version", no_argument, 0, 'v'},
+        {"program", optional_argument, 0, 'p'}, {0, 0, 0, 0},
     };
 
     while (optind < argc) {
-        char arg = getopt_long(argc, argv, "g:fhv", long_options, &option_index);
+        char arg = getopt_long(argc, argv, "g:fhvp::", long_options, &option_index);
         if (arg != -1) {
             switch (arg) {
             case 'g':
@@ -133,6 +134,10 @@ int main(int argc, char** argv) {
             case 'v':
                 PrintVersion();
                 return 0;
+            case 'p':
+                Settings::values.program_args = argv[optind];
+                ++optind;
+                break;
             }
         } else {
 #ifdef _WIN32
@@ -213,5 +218,6 @@ int main(int argc, char** argv) {
         system.RunLoop();
     }
 
+    detached_tasks.WaitForAllTasks();
     return 0;
 }