65 files changed, 2387 insertions, 93 deletions

diff --git a/src/common/common_funcs.h b/src/common/common_funcs.h
index 98421bced..367b6bf6e 100644
--- a/src/common/common_funcs.h
+++ b/src/common/common_funcs.h
@@ -64,14 +64,20 @@ __declspec(dllimport) void __stdcall DebugBreak(void);
         using T = std::underlying_type_t<type>;                                                    \
         return static_cast<type>(static_cast<T>(a) & static_cast<T>(b));                           \
     }                                                                                              \
-    constexpr type& operator|=(type& a, type b) noexcept {                                         \
+    [[nodiscard]] constexpr type operator^(type a, type b) noexcept {                              \
         using T = std::underlying_type_t<type>;                                                    \
-        a = static_cast<type>(static_cast<T>(a) | static_cast<T>(b));                              \
+        return static_cast<type>(static_cast<T>(a) ^ static_cast<T>(b));                           \
+    }                                                                                              \
+    constexpr type& operator|=(type& a, type b) noexcept {                                         \
+        a = a | b;                                                                                 \
         return a;                                                                                  \
     }                                                                                              \
     constexpr type& operator&=(type& a, type b) noexcept {                                         \
-        using T = std::underlying_type_t<type>;                                                    \
-        a = static_cast<type>(static_cast<T>(a) & static_cast<T>(b));                              \
+        a = a & b;                                                                                 \
+        return a;                                                                                  \
+    }                                                                                              \
+    constexpr type& operator^=(type& a, type b) noexcept {                                         \
+        a = a ^ b;                                                                                 \
         return a;                                                                                  \
     }                                                                                              \
     [[nodiscard]] constexpr type operator~(type key) noexcept {                                    \
diff --git a/src/common/math_util.h b/src/common/math_util.h
index cc35c90ee..b35ad8507 100644
--- a/src/common/math_util.h
+++ b/src/common/math_util.h
@@ -9,7 +9,7 @@
 
 namespace Common {
 
-constexpr float PI = 3.14159265f;
+constexpr float PI = 3.1415926535f;
 
 template <class T>
 struct Rectangle {
diff --git a/src/common/quaternion.h b/src/common/quaternion.h
index da44f35cd..4d0871eb4 100644
--- a/src/common/quaternion.h
+++ b/src/common/quaternion.h
@@ -36,6 +36,36 @@ public:
         T length = std::sqrt(xyz.Length2() + w * w);
         return {xyz / length, w / length};
     }
+
+    [[nodiscard]] std::array<decltype(-T{}), 16> ToMatrix() const {
+        const T x2 = xyz[0] * xyz[0];
+        const T y2 = xyz[1] * xyz[1];
+        const T z2 = xyz[2] * xyz[2];
+
+        const T xy = xyz[0] * xyz[1];
+        const T wz = w * xyz[2];
+        const T xz = xyz[0] * xyz[2];
+        const T wy = w * xyz[1];
+        const T yz = xyz[1] * xyz[2];
+        const T wx = w * xyz[0];
+
+        return {1.0f - 2.0f * (y2 + z2),
+                2.0f * (xy + wz),
+                2.0f * (xz - wy),
+                0.0f,
+                2.0f * (xy - wz),
+                1.0f - 2.0f * (x2 + z2),
+                2.0f * (yz + wx),
+                0.0f,
+                2.0f * (xz + wy),
+                2.0f * (yz - wx),
+                1.0f - 2.0f * (x2 + y2),
+                0.0f,
+                0.0f,
+                0.0f,
+                0.0f,
+                1.0f};
+    }
 };
 
 template <typename T>
diff --git a/src/common/thread.cpp b/src/common/thread.cpp
index 8e5935e6a..d2c1ac60d 100644
--- a/src/common/thread.cpp
+++ b/src/common/thread.cpp
@@ -2,6 +2,8 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include "common/common_funcs.h"
+#include "common/logging/log.h"
 #include "common/thread.h"
 #ifdef __APPLE__
 #include <mach/mach.h>
@@ -19,6 +21,8 @@
 #include <unistd.h>
 #endif
 
+#include <string>
+
 #ifdef __FreeBSD__
 #define cpu_set_t cpuset_t
 #endif
@@ -110,6 +114,14 @@ void SetCurrentThreadName(const char* name) {
     pthread_set_name_np(pthread_self(), name);
 #elif defined(__NetBSD__)
     pthread_setname_np(pthread_self(), "%s", (void*)name);
+#elif defined(__linux__)
+    // Linux limits thread names to 15 characters and will outright reject any
+    // attempt to set a longer name with ERANGE.
+    std::string truncated(name, std::min(strlen(name), static_cast<size_t>(15)));
+    if (int e = pthread_setname_np(pthread_self(), truncated.c_str())) {
+        errno = e;
+        LOG_ERROR(Common, "Failed to set thread name to '{}': {}", truncated, GetLastErrorMsg());
+    }
 #else
     pthread_setname_np(pthread_self(), name);
 #endif
diff --git a/src/common/thread.h b/src/common/thread.h
index 52b359413..a8c17c71a 100644
--- a/src/common/thread.h
+++ b/src/common/thread.h
@@ -4,6 +4,7 @@
 
 #pragma once
 
+#include <atomic>
 #include <chrono>
 #include <condition_variable>
 #include <cstddef>
@@ -25,13 +26,13 @@ public:
 
     void Wait() {
         std::unique_lock lk{mutex};
-        condvar.wait(lk, [&] { return is_set; });
+        condvar.wait(lk, [&] { return is_set.load(); });
         is_set = false;
     }
 
     bool WaitFor(const std::chrono::nanoseconds& time) {
         std::unique_lock lk{mutex};
-        if (!condvar.wait_for(lk, time, [this] { return is_set; }))
+        if (!condvar.wait_for(lk, time, [this] { return is_set.load(); }))
             return false;
         is_set = false;
         return true;
@@ -40,7 +41,7 @@ public:
     template <class Clock, class Duration>
     bool WaitUntil(const std::chrono::time_point<Clock, Duration>& time) {
         std::unique_lock lk{mutex};
-        if (!condvar.wait_until(lk, time, [this] { return is_set; }))
+        if (!condvar.wait_until(lk, time, [this] { return is_set.load(); }))
             return false;
         is_set = false;
         return true;
@@ -54,9 +55,9 @@ public:
     }
 
 private:
-    bool is_set = false;
     std::condition_variable condvar;
     std::mutex mutex;
+    std::atomic_bool is_set{false};
 };
 
 class Barrier {
diff --git a/src/core/cpu_manager.cpp b/src/core/cpu_manager.cpp
index ef0bae556..688b99eba 100644
--- a/src/core/cpu_manager.cpp
+++ b/src/core/cpu_manager.cpp
@@ -328,7 +328,7 @@ void CpuManager::RunThread(std::size_t core) {
     system.RegisterCoreThread(core);
     std::string name;
     if (is_multicore) {
-        name = "yuzu:CoreCPUThread_" + std::to_string(core);
+        name = "yuzu:CPUCore_" + std::to_string(core);
     } else {
         name = "yuzu:CPUThread";
     }
diff --git a/src/core/crypto/partition_data_manager.cpp b/src/core/crypto/partition_data_manager.cpp
index 46136d04a..5f1c86a09 100644
--- a/src/core/crypto/partition_data_manager.cpp
+++ b/src/core/crypto/partition_data_manager.cpp
@@ -26,6 +26,7 @@
 #include "core/file_sys/vfs.h"
 #include "core/file_sys/vfs_offset.h"
 #include "core/file_sys/vfs_vector.h"
+#include "core/loader/loader.h"
 
 using Common::AsArray;
 
diff --git a/src/core/file_sys/bis_factory.cpp b/src/core/file_sys/bis_factory.cpp
index 9ffda2e14..e04a54c3c 100644
--- a/src/core/file_sys/bis_factory.cpp
+++ b/src/core/file_sys/bis_factory.cpp
@@ -8,7 +8,6 @@
 #include "core/file_sys/bis_factory.h"
 #include "core/file_sys/mode.h"
 #include "core/file_sys/registered_cache.h"
-#include "core/settings.h"
 
 namespace FileSys {
 
diff --git a/src/core/file_sys/bis_factory.h b/src/core/file_sys/bis_factory.h
index 8f0451c98..438d3f8d8 100644
--- a/src/core/file_sys/bis_factory.h
+++ b/src/core/file_sys/bis_factory.h
@@ -6,7 +6,8 @@
 
 #include <memory>
 
-#include "core/file_sys/vfs.h"
+#include "common/common_types.h"
+#include "core/file_sys/vfs_types.h"
 
 namespace FileSys {
 
diff --git a/src/core/file_sys/card_image.cpp b/src/core/file_sys/card_image.cpp
index 664a47e7f..956da68f7 100644
--- a/src/core/file_sys/card_image.cpp
+++ b/src/core/file_sys/card_image.cpp
@@ -8,11 +8,11 @@
 #include <fmt/ostream.h>
 
 #include "common/logging/log.h"
+#include "core/crypto/key_manager.h"
 #include "core/file_sys/card_image.h"
 #include "core/file_sys/content_archive.h"
 #include "core/file_sys/nca_metadata.h"
 #include "core/file_sys/partition_filesystem.h"
-#include "core/file_sys/romfs.h"
 #include "core/file_sys/submission_package.h"
 #include "core/file_sys/vfs_concat.h"
 #include "core/file_sys/vfs_offset.h"
@@ -31,7 +31,8 @@ constexpr std::array partition_names{
 
 XCI::XCI(VirtualFile file_)
     : file(std::move(file_)), program_nca_status{Loader::ResultStatus::ErrorXCIMissingProgramNCA},
-      partitions(partition_names.size()), partitions_raw(partition_names.size()) {
+      partitions(partition_names.size()),
+      partitions_raw(partition_names.size()), keys{Core::Crypto::KeyManager::Instance()} {
     if (file->ReadObject(&header) != sizeof(GamecardHeader)) {
         status = Loader::ResultStatus::ErrorBadXCIHeader;
         return;
diff --git a/src/core/file_sys/card_image.h b/src/core/file_sys/card_image.h
index e1b136426..2d0a0f285 100644
--- a/src/core/file_sys/card_image.h
+++ b/src/core/file_sys/card_image.h
@@ -9,9 +9,12 @@
 #include <vector>
 #include "common/common_types.h"
 #include "common/swap.h"
-#include "core/crypto/key_manager.h"
 #include "core/file_sys/vfs.h"
 
+namespace Core::Crypto {
+class KeyManager;
+}
+
 namespace Loader {
 enum class ResultStatus : u16;
 }
@@ -140,6 +143,6 @@ private:
 
     u64 update_normal_partition_end;
 
-    Core::Crypto::KeyManager& keys = Core::Crypto::KeyManager::Instance();
+    Core::Crypto::KeyManager& keys;
 };
 } // namespace FileSys
diff --git a/src/core/file_sys/content_archive.cpp b/src/core/file_sys/content_archive.cpp
index 5039341c7..426fb6bb5 100644
--- a/src/core/file_sys/content_archive.cpp
+++ b/src/core/file_sys/content_archive.cpp
@@ -10,10 +10,10 @@
 #include "common/logging/log.h"
 #include "core/crypto/aes_util.h"
 #include "core/crypto/ctr_encryption_layer.h"
+#include "core/crypto/key_manager.h"
 #include "core/file_sys/content_archive.h"
 #include "core/file_sys/nca_patch.h"
 #include "core/file_sys/partition_filesystem.h"
-#include "core/file_sys/romfs.h"
 #include "core/file_sys/vfs_offset.h"
 #include "core/loader/loader.h"
 
@@ -119,7 +119,8 @@ static bool IsValidNCA(const NCAHeader& header) {
 }
 
 NCA::NCA(VirtualFile file_, VirtualFile bktr_base_romfs_, u64 bktr_base_ivfc_offset)
-    : file(std::move(file_)), bktr_base_romfs(std::move(bktr_base_romfs_)) {
+    : file(std::move(file_)),
+      bktr_base_romfs(std::move(bktr_base_romfs_)), keys{Core::Crypto::KeyManager::Instance()} {
     if (file == nullptr) {
         status = Loader::ResultStatus::ErrorNullFile;
         return;
diff --git a/src/core/file_sys/content_archive.h b/src/core/file_sys/content_archive.h
index d25cbcf91..69292232a 100644
--- a/src/core/file_sys/content_archive.h
+++ b/src/core/file_sys/content_archive.h
@@ -158,7 +158,7 @@ private:
     bool encrypted = false;
     bool is_update = false;
 
-    Core::Crypto::KeyManager& keys = Core::Crypto::KeyManager::Instance();
+    Core::Crypto::KeyManager& keys;
 };
 
 } // namespace FileSys
diff --git a/src/core/file_sys/control_metadata.cpp b/src/core/file_sys/control_metadata.cpp
index 63cd2eead..b0a130345 100644
--- a/src/core/file_sys/control_metadata.cpp
+++ b/src/core/file_sys/control_metadata.cpp
@@ -5,6 +5,7 @@
 #include "common/string_util.h"
 #include "common/swap.h"
 #include "core/file_sys/control_metadata.h"
+#include "core/file_sys/vfs.h"
 
 namespace FileSys {
 
diff --git a/src/core/file_sys/control_metadata.h b/src/core/file_sys/control_metadata.h
index e37b2fadf..9ab86e35b 100644
--- a/src/core/file_sys/control_metadata.h
+++ b/src/core/file_sys/control_metadata.h
@@ -10,7 +10,7 @@
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/swap.h"
-#include "core/file_sys/vfs.h"
+#include "core/file_sys/vfs_types.h"
 
 namespace FileSys {
 
diff --git a/src/core/file_sys/kernel_executable.cpp b/src/core/file_sys/kernel_executable.cpp
index 76313679d..ef93ef3ed 100644
--- a/src/core/file_sys/kernel_executable.cpp
+++ b/src/core/file_sys/kernel_executable.cpp
@@ -2,9 +2,12 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.
 
+#include <cstring>
+
 #include "common/string_util.h"
 #include "core/file_sys/kernel_executable.h"
 #include "core/file_sys/vfs_offset.h"
+#include "core/loader/loader.h"
 
 namespace FileSys {
 
diff --git a/src/core/file_sys/kernel_executable.h b/src/core/file_sys/kernel_executable.h
index 324a57384..044c554d3 100644
--- a/src/core/file_sys/kernel_executable.h
+++ b/src/core/file_sys/kernel_executable.h
@@ -4,10 +4,17 @@
 
 #pragma once
 
+#include <array>
+#include <vector>
+
 #include "common/common_funcs.h"
+#include "common/common_types.h"
 #include "common/swap.h"
 #include "core/file_sys/vfs_types.h"
-#include "core/loader/loader.h"
+
+namespace Loader {
+enum class ResultStatus : u16;
+}
 
 namespace FileSys {
 
diff --git a/src/core/file_sys/nca_metadata.cpp b/src/core/file_sys/nca_metadata.cpp
index 93d0df6b9..2d1476e3a 100644
--- a/src/core/file_sys/nca_metadata.cpp
+++ b/src/core/file_sys/nca_metadata.cpp
@@ -7,6 +7,7 @@
 #include "common/logging/log.h"
 #include "common/swap.h"
 #include "core/file_sys/nca_metadata.h"
+#include "core/file_sys/vfs.h"
 
 namespace FileSys {
 
diff --git a/src/core/file_sys/nca_metadata.h b/src/core/file_sys/nca_metadata.h
index 1f82fff0a..53535e5f5 100644
--- a/src/core/file_sys/nca_metadata.h
+++ b/src/core/file_sys/nca_metadata.h
@@ -10,7 +10,7 @@
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/swap.h"
-#include "core/file_sys/vfs.h"
+#include "core/file_sys/vfs_types.h"
 
 namespace FileSys {
 class CNMT;
diff --git a/src/core/file_sys/partition_filesystem.cpp b/src/core/file_sys/partition_filesystem.cpp
index 846986736..48a2ed4d4 100644
--- a/src/core/file_sys/partition_filesystem.cpp
+++ b/src/core/file_sys/partition_filesystem.cpp
@@ -21,7 +21,7 @@ bool PartitionFilesystem::Header::HasValidMagicValue() const {
            magic == Common::MakeMagic('P', 'F', 'S', '0');
 }
 
-PartitionFilesystem::PartitionFilesystem(std::shared_ptr<VfsFile> file) {
+PartitionFilesystem::PartitionFilesystem(VirtualFile file) {
     // At least be as large as the header
     if (file->GetSize() < sizeof(Header)) {
         status = Loader::ResultStatus::ErrorBadPFSHeader;
@@ -89,11 +89,11 @@ std::map<std::string, u64> PartitionFilesystem::GetFileSizes() const {
     return sizes;
 }
 
-std::vector<std::shared_ptr<VfsFile>> PartitionFilesystem::GetFiles() const {
+std::vector<VirtualFile> PartitionFilesystem::GetFiles() const {
     return pfs_files;
 }
 
-std::vector<std::shared_ptr<VfsDirectory>> PartitionFilesystem::GetSubdirectories() const {
+std::vector<VirtualDir> PartitionFilesystem::GetSubdirectories() const {
     return {};
 }
 
@@ -101,7 +101,7 @@ std::string PartitionFilesystem::GetName() const {
     return is_hfs ? "HFS0" : "PFS0";
 }
 
-std::shared_ptr<VfsDirectory> PartitionFilesystem::GetParentDirectory() const {
+VirtualDir PartitionFilesystem::GetParentDirectory() const {
     // TODO(DarkLordZach): Add support for nested containers.
     return nullptr;
 }
diff --git a/src/core/file_sys/partition_filesystem.h b/src/core/file_sys/partition_filesystem.h
index 279193b19..0f831148e 100644
--- a/src/core/file_sys/partition_filesystem.h
+++ b/src/core/file_sys/partition_filesystem.h
@@ -24,7 +24,7 @@ namespace FileSys {
  */
 class PartitionFilesystem : public ReadOnlyVfsDirectory {
 public:
-    explicit PartitionFilesystem(std::shared_ptr<VfsFile> file);
+    explicit PartitionFilesystem(VirtualFile file);
     ~PartitionFilesystem() override;
 
     Loader::ResultStatus GetStatus() const;
@@ -32,10 +32,10 @@ public:
     std::map<std::string, u64> GetFileOffsets() const;
     std::map<std::string, u64> GetFileSizes() const;
 
-    std::vector<std::shared_ptr<VfsFile>> GetFiles() const override;
-    std::vector<std::shared_ptr<VfsDirectory>> GetSubdirectories() const override;
+    std::vector<VirtualFile> GetFiles() const override;
+    std::vector<VirtualDir> GetSubdirectories() const override;
     std::string GetName() const override;
-    std::shared_ptr<VfsDirectory> GetParentDirectory() const override;
+    VirtualDir GetParentDirectory() const override;
     void PrintDebugInfo() const;
 
 private:
diff --git a/src/core/file_sys/patch_manager.cpp b/src/core/file_sys/patch_manager.cpp
index 729dbb5f4..c228d253e 100644
--- a/src/core/file_sys/patch_manager.cpp
+++ b/src/core/file_sys/patch_manager.cpp
@@ -49,8 +49,7 @@ std::string FormatTitleVersion(u32 version, TitleVersionFormat format) {
     return fmt::format("v{}.{}.{}", bytes[3], bytes[2], bytes[1]);
 }
 
-std::shared_ptr<VfsDirectory> FindSubdirectoryCaseless(const std::shared_ptr<VfsDirectory> dir,
-                                                       std::string_view name) {
+VirtualDir FindSubdirectoryCaseless(const VirtualDir dir, std::string_view name) {
 #ifdef _WIN32
     return dir->GetSubdirectory(name);
 #else
diff --git a/src/core/file_sys/patch_manager.h b/src/core/file_sys/patch_manager.h
index f4cb918dd..532f4995f 100644
--- a/src/core/file_sys/patch_manager.h
+++ b/src/core/file_sys/patch_manager.h
@@ -6,10 +6,11 @@
 
 #include <map>
 #include <memory>
+#include <optional>
 #include <string>
 #include "common/common_types.h"
 #include "core/file_sys/nca_metadata.h"
-#include "core/file_sys/vfs.h"
+#include "core/file_sys/vfs_types.h"
 #include "core/memory/dmnt_cheat_types.h"
 
 namespace Core {
@@ -31,8 +32,7 @@ std::string FormatTitleVersion(u32 version,
 
 // Returns a directory with name matching name case-insensitive. Returns nullptr if directory
 // doesn't have a directory with name.
-std::shared_ptr<VfsDirectory> FindSubdirectoryCaseless(const std::shared_ptr<VfsDirectory> dir,
-                                                       std::string_view name);
+VirtualDir FindSubdirectoryCaseless(VirtualDir dir, std::string_view name);
 
 // A centralized class to manage patches to games.
 class PatchManager {
diff --git a/src/core/file_sys/program_metadata.cpp b/src/core/file_sys/program_metadata.cpp
index 43169bf9f..9cf49bf44 100644
--- a/src/core/file_sys/program_metadata.cpp
+++ b/src/core/file_sys/program_metadata.cpp
@@ -7,6 +7,7 @@
 
 #include "common/logging/log.h"
 #include "core/file_sys/program_metadata.h"
+#include "core/file_sys/vfs.h"
 #include "core/loader/loader.h"
 
 namespace FileSys {
diff --git a/src/core/file_sys/program_metadata.h b/src/core/file_sys/program_metadata.h
index 35069972b..455532567 100644
--- a/src/core/file_sys/program_metadata.h
+++ b/src/core/file_sys/program_metadata.h
@@ -9,7 +9,7 @@
 #include "common/bit_field.h"
 #include "common/common_types.h"
 #include "common/swap.h"
-#include "core/file_sys/vfs.h"
+#include "core/file_sys/vfs_types.h"
 
 namespace Loader {
 enum class ResultStatus : u16;
diff --git a/src/core/file_sys/romfs.h b/src/core/file_sys/romfs.h
index 2fd07ed04..82e683782 100644
--- a/src/core/file_sys/romfs.h
+++ b/src/core/file_sys/romfs.h
@@ -4,7 +4,6 @@
 
 #pragma once
 
-#include <array>
 #include "core/file_sys/vfs.h"
 
 namespace FileSys {
diff --git a/src/core/file_sys/sdmc_factory.cpp b/src/core/file_sys/sdmc_factory.cpp
index 6f732e4d8..cb56d8f2d 100644
--- a/src/core/file_sys/sdmc_factory.cpp
+++ b/src/core/file_sys/sdmc_factory.cpp
@@ -5,8 +5,8 @@
 #include <memory>
 #include "core/file_sys/registered_cache.h"
 #include "core/file_sys/sdmc_factory.h"
+#include "core/file_sys/vfs.h"
 #include "core/file_sys/xts_archive.h"
-#include "core/settings.h"
 
 namespace FileSys {
 
diff --git a/src/core/file_sys/sdmc_factory.h b/src/core/file_sys/sdmc_factory.h
index 42dc4e08a..2bb92ba93 100644
--- a/src/core/file_sys/sdmc_factory.h
+++ b/src/core/file_sys/sdmc_factory.h
@@ -5,7 +5,7 @@
 #pragma once
 
 #include <memory>
-#include "core/file_sys/vfs.h"
+#include "core/file_sys/vfs_types.h"
 #include "core/hle/result.h"
 
 namespace FileSys {
diff --git a/src/core/file_sys/submission_package.cpp b/src/core/file_sys/submission_package.cpp
index 175a8266a..b9ce93b7c 100644
--- a/src/core/file_sys/submission_package.cpp
+++ b/src/core/file_sys/submission_package.cpp
@@ -54,7 +54,7 @@ void SetTicketKeys(const std::vector<VirtualFile>& files) {
 
 NSP::NSP(VirtualFile file_)
     : file(std::move(file_)), status{Loader::ResultStatus::Success},
-      pfs(std::make_shared<PartitionFilesystem>(file)) {
+      pfs(std::make_shared<PartitionFilesystem>(file)), keys{Core::Crypto::KeyManager::Instance()} {
     if (pfs->GetStatus() != Loader::ResultStatus::Success) {
         status = pfs->GetStatus();
         return;
diff --git a/src/core/file_sys/submission_package.h b/src/core/file_sys/submission_package.h
index cf89de6a9..2db5e46b8 100644
--- a/src/core/file_sys/submission_package.h
+++ b/src/core/file_sys/submission_package.h
@@ -10,6 +10,10 @@
 #include "common/common_types.h"
 #include "core/file_sys/vfs.h"
 
+namespace Core::Crypto {
+class KeyManager;
+}
+
 namespace Loader {
 enum class ResultStatus : u16;
 }
@@ -73,7 +77,7 @@ private:
     std::map<u64, std::map<std::pair<TitleType, ContentRecordType>, std::shared_ptr<NCA>>> ncas;
     std::vector<VirtualFile> ticket_files;
 
-    Core::Crypto::KeyManager& keys = Core::Crypto::KeyManager::Instance();
+    Core::Crypto::KeyManager& keys;
 
     VirtualFile romfs;
     VirtualDir exefs;
diff --git a/src/core/file_sys/xts_archive.cpp b/src/core/file_sys/xts_archive.cpp
index ccf5966d0..24c58e7ae 100644
--- a/src/core/file_sys/xts_archive.cpp
+++ b/src/core/file_sys/xts_archive.cpp
@@ -15,8 +15,9 @@
 #include "common/hex_util.h"
 #include "common/string_util.h"
 #include "core/crypto/aes_util.h"
+#include "core/crypto/key_manager.h"
 #include "core/crypto/xts_encryption_layer.h"
-#include "core/file_sys/partition_filesystem.h"
+#include "core/file_sys/content_archive.h"
 #include "core/file_sys/vfs_offset.h"
 #include "core/file_sys/xts_archive.h"
 #include "core/loader/loader.h"
@@ -43,7 +44,9 @@ static bool CalculateHMAC256(Destination* out, const SourceKey* key, std::size_t
     return true;
 }
 
-NAX::NAX(VirtualFile file_) : header(std::make_unique<NAXHeader>()), file(std::move(file_)) {
+NAX::NAX(VirtualFile file_)
+    : header(std::make_unique<NAXHeader>()),
+      file(std::move(file_)), keys{Core::Crypto::KeyManager::Instance()} {
     std::string path = Common::FS::SanitizePath(file->GetFullPath());
     static const std::regex nax_path_regex("/registered/(000000[0-9A-F]{2})/([0-9A-F]{32})\\.nca",
                                            std::regex_constants::ECMAScript |
@@ -60,7 +63,8 @@ NAX::NAX(VirtualFile file_) : header(std::make_unique<NAXHeader>()), file(std::m
 }
 
 NAX::NAX(VirtualFile file_, std::array<u8, 0x10> nca_id)
-    : header(std::make_unique<NAXHeader>()), file(std::move(file_)) {
+    : header(std::make_unique<NAXHeader>()),
+      file(std::move(file_)), keys{Core::Crypto::KeyManager::Instance()} {
     Core::Crypto::SHA256Hash hash{};
     mbedtls_sha256_ret(nca_id.data(), nca_id.size(), hash.data(), 0);
     status = Parse(fmt::format("/registered/000000{:02X}/{}.nca", hash[0],
diff --git a/src/core/file_sys/xts_archive.h b/src/core/file_sys/xts_archive.h
index 563531bb6..c472e226e 100644
--- a/src/core/file_sys/xts_archive.h
+++ b/src/core/file_sys/xts_archive.h
@@ -9,12 +9,16 @@
 #include "common/common_types.h"
 #include "common/swap.h"
 #include "core/crypto/key_manager.h"
-#include "core/file_sys/content_archive.h"
 #include "core/file_sys/vfs.h"
-#include "core/loader/loader.h"
+
+namespace Loader {
+enum class ResultStatus : u16;
+}
 
 namespace FileSys {
 
+class NCA;
+
 struct NAXHeader {
     std::array<u8, 0x20> hmac;
     u64_le magic;
@@ -62,6 +66,6 @@ private:
 
     VirtualFile dec_file;
 
-    Core::Crypto::KeyManager& keys = Core::Crypto::KeyManager::Instance();
+    Core::Crypto::KeyManager& keys;
 };
 } // namespace FileSys
diff --git a/src/core/frontend/framebuffer_layout.h b/src/core/frontend/framebuffer_layout.h
index 91ecc30ab..e2e3bbbb3 100644
--- a/src/core/frontend/framebuffer_layout.h
+++ b/src/core/frontend/framebuffer_layout.h
@@ -4,6 +4,7 @@
 
 #pragma once
 
+#include "common/common_types.h"
 #include "common/math_util.h"
 
 namespace Layout {
diff --git a/src/core/hle/kernel/kernel.cpp b/src/core/hle/kernel/kernel.cpp
index cabe8d418..f2b0fe2fd 100644
--- a/src/core/hle/kernel/kernel.cpp
+++ b/src/core/hle/kernel/kernel.cpp
@@ -219,6 +219,7 @@ struct KernelCore::Impl {
                 return static_cast<u32>(system.GetCpuManager().CurrentCore());
             }
         }
+        std::unique_lock lock{register_thread_mutex};
         const auto it = host_thread_ids.find(this_id);
         if (it == host_thread_ids.end()) {
             return Core::INVALID_HOST_THREAD_ID;
@@ -324,7 +325,7 @@ struct KernelCore::Impl {
     std::unordered_map<std::thread::id, u32> host_thread_ids;
     u32 registered_thread_ids{Core::Hardware::NUM_CPU_CORES};
     std::bitset<Core::Hardware::NUM_CPU_CORES> registered_core_threads;
-    std::mutex register_thread_mutex;
+    mutable std::mutex register_thread_mutex;
 
     // Kernel memory management
     std::unique_ptr<Memory::MemoryManager> memory_manager;
diff --git a/src/core/hle/kernel/scheduler.cpp b/src/core/hle/kernel/scheduler.cpp
index a4b234424..5cbd3b912 100644
--- a/src/core/hle/kernel/scheduler.cpp
+++ b/src/core/hle/kernel/scheduler.cpp
@@ -756,7 +756,11 @@ void Scheduler::SwitchToCurrent() {
             current_thread = selected_thread;
             is_context_switch_pending = false;
         }
-        while (!is_context_switch_pending) {
+        const auto is_switch_pending = [this] {
+            std::scoped_lock lock{guard};
+            return is_context_switch_pending;
+        };
+        do {
             if (current_thread != nullptr && !current_thread->IsHLEThread()) {
                 current_thread->context_guard.lock();
                 if (!current_thread->IsRunnable()) {
@@ -775,7 +779,7 @@ void Scheduler::SwitchToCurrent() {
                 next_context = &idle_thread->GetHostContext();
             }
             Common::Fiber::YieldTo(switch_fiber, *next_context);
-        }
+        } while (!is_switch_pending());
     }
 }
 
diff --git a/src/core/hle/service/filesystem/fsp_srv.cpp b/src/core/hle/service/filesystem/fsp_srv.cpp
index 26fd87f58..649128be4 100644
--- a/src/core/hle/service/filesystem/fsp_srv.cpp
+++ b/src/core/hle/service/filesystem/fsp_srv.cpp
@@ -844,8 +844,7 @@ void FSP_SRV::OpenSaveDataFileSystem(Kernel::HLERequestContext& ctx) {
         return;
     }
 
-    FileSys::StorageId id;
-
+    FileSys::StorageId id{};
     switch (parameters.space_id) {
     case FileSys::SaveDataSpaceId::NandUser:
         id = FileSys::StorageId::NandUser;
@@ -857,6 +856,10 @@ void FSP_SRV::OpenSaveDataFileSystem(Kernel::HLERequestContext& ctx) {
     case FileSys::SaveDataSpaceId::NandSystem:
         id = FileSys::StorageId::NandSystem;
         break;
+    case FileSys::SaveDataSpaceId::TemporaryStorage:
+    case FileSys::SaveDataSpaceId::ProperSystem:
+    case FileSys::SaveDataSpaceId::SafeMode:
+        UNREACHABLE();
     }
 
     auto filesystem =
@@ -902,7 +905,14 @@ void FSP_SRV::ReadSaveDataFileSystemExtraDataWithMaskBySaveDataAttribute(
     // Stub this to None for now, backend needs an impl to read/write the SaveDataExtraData
     constexpr auto flags = static_cast<u32>(FileSys::SaveDataFlags::None);
 
-    LOG_WARNING(Service_FS, "(STUBBED) called, flags={}", flags);
+    LOG_WARNING(Service_FS,
+                "(STUBBED) called, flags={}, space_id={}, attribute.title_id={:016X}\n"
+                "attribute.user_id={:016X}{:016X}, attribute.save_id={:016X}\n"
+                "attribute.type={}, attribute.rank={}, attribute.index={}",
+                flags, static_cast<u32>(parameters.space_id), parameters.attribute.title_id,
+                parameters.attribute.user_id[1], parameters.attribute.user_id[0],
+                parameters.attribute.save_id, static_cast<u32>(parameters.attribute.type),
+                static_cast<u32>(parameters.attribute.rank), parameters.attribute.index);
 
     IPC::ResponseBuilder rb{ctx, 3};
     rb.Push(RESULT_SUCCESS);
diff --git a/src/core/hle/service/hid/controllers/touchscreen.cpp b/src/core/hle/service/hid/controllers/touchscreen.cpp
index e326f8f5c..0df395e85 100644
--- a/src/core/hle/service/hid/controllers/touchscreen.cpp
+++ b/src/core/hle/service/hid/controllers/touchscreen.cpp
@@ -40,9 +40,14 @@ void Controller_Touchscreen::OnUpdate(const Core::Timing::CoreTiming& core_timin
     cur_entry.sampling_number = last_entry.sampling_number + 1;
     cur_entry.sampling_number2 = cur_entry.sampling_number;
 
-    const auto [x, y, pressed] = touch_device->GetStatus();
+    bool pressed = false;
+    float x, y;
+    std::tie(x, y, pressed) = touch_device->GetStatus();
     auto& touch_entry = cur_entry.states[0];
     touch_entry.attribute.raw = 0;
+    if (!pressed && touch_btn_device) {
+        std::tie(x, y, pressed) = touch_btn_device->GetStatus();
+    }
     if (pressed && Settings::values.touchscreen.enabled) {
         touch_entry.x = static_cast<u16>(x * Layout::ScreenUndocked::Width);
         touch_entry.y = static_cast<u16>(y * Layout::ScreenUndocked::Height);
@@ -63,5 +68,10 @@ void Controller_Touchscreen::OnUpdate(const Core::Timing::CoreTiming& core_timin
 
 void Controller_Touchscreen::OnLoadInputDevices() {
     touch_device = Input::CreateDevice<Input::TouchDevice>(Settings::values.touchscreen.device);
+    if (Settings::values.use_touch_from_button) {
+        touch_btn_device = Input::CreateDevice<Input::TouchDevice>("engine:touch_from_button");
+    } else {
+        touch_btn_device.reset();
+    }
 }
 } // namespace Service::HID
diff --git a/src/core/hle/service/hid/controllers/touchscreen.h b/src/core/hle/service/hid/controllers/touchscreen.h
index a1d97269e..4d9042adc 100644
--- a/src/core/hle/service/hid/controllers/touchscreen.h
+++ b/src/core/hle/service/hid/controllers/touchscreen.h
@@ -68,6 +68,7 @@ private:
                   "TouchScreenSharedMemory is an invalid size");
     TouchScreenSharedMemory shared_memory{};
     std::unique_ptr<Input::TouchDevice> touch_device;
+    std::unique_ptr<Input::TouchDevice> touch_btn_device;
     s64_le last_touch{};
 };
 } // namespace Service::HID
diff --git a/src/core/hle/service/ns/ns.cpp b/src/core/hle/service/ns/ns.cpp
index 886450be2..58ee1f712 100644
--- a/src/core/hle/service/ns/ns.cpp
+++ b/src/core/hle/service/ns/ns.cpp
@@ -5,6 +5,7 @@
 #include "common/logging/log.h"
 #include "core/file_sys/control_metadata.h"
 #include "core/file_sys/patch_manager.h"
+#include "core/file_sys/vfs.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/hle_ipc.h"
 #include "core/hle/service/ns/errors.h"
diff --git a/src/core/settings.h b/src/core/settings.h
index 732c6a894..80f0d95a7 100644
--- a/src/core/settings.h
+++ b/src/core/settings.h
@@ -67,6 +67,11 @@ private:
     Type local{};
 };
 
+struct TouchFromButtonMap {
+    std::string name;
+    std::vector<std::string> buttons;
+};
+
 struct Values {
     // Audio
     std::string audio_device_id;
@@ -145,15 +150,18 @@ struct Values {
     ButtonsRaw debug_pad_buttons;
     AnalogsRaw debug_pad_analogs;
 
-    std::string motion_device;
-
     bool vibration_enabled;
 
+    std::string motion_device;
+    std::string touch_device;
     TouchscreenInput touchscreen;
     std::atomic_bool is_device_reload_pending{true};
+    bool use_touch_from_button;
+    int touch_from_button_map_index;
     std::string udp_input_address;
     u16 udp_input_port;
     u8 udp_pad_index;
+    std::vector<TouchFromButtonMap> touch_from_button_maps;
 
     // Data Storage
     bool use_virtual_sd;
diff --git a/src/input_common/CMakeLists.txt b/src/input_common/CMakeLists.txt
index 56267c8a8..09361e37e 100644
--- a/src/input_common/CMakeLists.txt
+++ b/src/input_common/CMakeLists.txt
@@ -7,8 +7,12 @@ add_library(input_common STATIC
     main.h
     motion_emu.cpp
     motion_emu.h
+    motion_input.cpp
+    motion_input.h
     settings.cpp
     settings.h
+    touch_from_button.cpp
+    touch_from_button.h
     gcadapter/gc_adapter.cpp
     gcadapter/gc_adapter.h
     gcadapter/gc_poller.cpp
diff --git a/src/input_common/gcadapter/gc_poller.cpp b/src/input_common/gcadapter/gc_poller.cpp
index 71cd85eeb..1c8d8523a 100644
--- a/src/input_common/gcadapter/gc_poller.cpp
+++ b/src/input_common/gcadapter/gc_poller.cpp
@@ -38,7 +38,8 @@ public:
     explicit GCAxisButton(int port_, int axis_, float threshold_, bool trigger_if_greater_,
                           GCAdapter::Adapter* adapter)
         : port(port_), axis(axis_), threshold(threshold_), trigger_if_greater(trigger_if_greater_),
-          gcadapter(adapter), origin_value(adapter->GetOriginValue(port_, axis_)) {}
+          gcadapter(adapter),
+          origin_value(static_cast<float>(adapter->GetOriginValue(port_, axis_))) {}
 
     bool GetStatus() const override {
         if (gcadapter->DeviceConnected(port)) {
@@ -151,8 +152,9 @@ public:
     GCAnalog(int port_, int axis_x_, int axis_y_, float deadzone_, GCAdapter::Adapter* adapter,
              float range_)
         : port(port_), axis_x(axis_x_), axis_y(axis_y_), deadzone(deadzone_), gcadapter(adapter),
-          origin_value_x(adapter->GetOriginValue(port_, axis_x_)),
-          origin_value_y(adapter->GetOriginValue(port_, axis_y_)), range(range_) {}
+          origin_value_x(static_cast<float>(adapter->GetOriginValue(port_, axis_x_))),
+          origin_value_y(static_cast<float>(adapter->GetOriginValue(port_, axis_y_))),
+          range(range_) {}
 
     float GetAxis(int axis) const {
         if (gcadapter->DeviceConnected(port)) {
diff --git a/src/input_common/main.cpp b/src/input_common/main.cpp
index 57e7a25fe..ea1a1cee6 100644
--- a/src/input_common/main.cpp
+++ b/src/input_common/main.cpp
@@ -11,6 +11,7 @@
 #include "input_common/keyboard.h"
 #include "input_common/main.h"
 #include "input_common/motion_emu.h"
+#include "input_common/touch_from_button.h"
 #include "input_common/udp/udp.h"
 #ifdef HAVE_SDL2
 #include "input_common/sdl/sdl.h"
@@ -32,6 +33,8 @@ struct InputSubsystem::Impl {
                                                     std::make_shared<AnalogFromButton>());
         motion_emu = std::make_shared<MotionEmu>();
         Input::RegisterFactory<Input::MotionDevice>("motion_emu", motion_emu);
+        Input::RegisterFactory<Input::TouchDevice>("touch_from_button",
+                                                   std::make_shared<TouchFromButtonFactory>());
 
 #ifdef HAVE_SDL2
         sdl = SDL::Init();
@@ -46,6 +49,7 @@ struct InputSubsystem::Impl {
         Input::UnregisterFactory<Input::AnalogDevice>("analog_from_button");
         Input::UnregisterFactory<Input::MotionDevice>("motion_emu");
         motion_emu.reset();
+        Input::UnregisterFactory<Input::TouchDevice>("touch_from_button");
 #ifdef HAVE_SDL2
         sdl.reset();
 #endif
@@ -171,6 +175,13 @@ const GCButtonFactory* InputSubsystem::GetGCButtons() const {
     return impl->gcbuttons.get();
 }
 
+void InputSubsystem::ReloadInputDevices() {
+    if (!impl->udp) {
+        return;
+    }
+    impl->udp->ReloadUDPClient();
+}
+
 std::vector<std::unique_ptr<Polling::DevicePoller>> InputSubsystem::GetPollers(
     Polling::DeviceType type) const {
 #ifdef HAVE_SDL2
diff --git a/src/input_common/main.h b/src/input_common/main.h
index 58e5dc250..f3fbf696e 100644
--- a/src/input_common/main.h
+++ b/src/input_common/main.h
@@ -115,6 +115,9 @@ public:
     /// Retrieves the underlying GameCube button handler.
     [[nodiscard]] const GCButtonFactory* GetGCButtons() const;
 
+    /// Reloads the input devices
+    void ReloadInputDevices();
+
     /// Get all DevicePoller from all backends for a specific device type
     [[nodiscard]] std::vector<std::unique_ptr<Polling::DevicePoller>> GetPollers(
         Polling::DeviceType type) const;
diff --git a/src/input_common/motion_input.cpp b/src/input_common/motion_input.cpp
new file mode 100644
index 000000000..22a849866
--- /dev/null
+++ b/src/input_common/motion_input.cpp
@@ -0,0 +1,181 @@
+// Copyright 2020 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included
+
+#include "common/math_util.h"
+#include "input_common/motion_input.h"
+
+namespace InputCommon {
+
+MotionInput::MotionInput(f32 new_kp, f32 new_ki, f32 new_kd)
+    : kp(new_kp), ki(new_ki), kd(new_kd), quat{{0, 0, -1}, 0} {}
+
+void MotionInput::SetAcceleration(const Common::Vec3f& acceleration) {
+    accel = acceleration;
+}
+
+void MotionInput::SetGyroscope(const Common::Vec3f& gyroscope) {
+    gyro = gyroscope - gyro_drift;
+    if (gyro.Length2() < gyro_threshold) {
+        gyro = {};
+    }
+}
+
+void MotionInput::SetQuaternion(const Common::Quaternion<f32>& quaternion) {
+    quat = quaternion;
+}
+
+void MotionInput::SetGyroDrift(const Common::Vec3f& drift) {
+    gyro_drift = drift;
+}
+
+void MotionInput::SetGyroThreshold(f32 threshold) {
+    gyro_threshold = threshold;
+}
+
+void MotionInput::EnableReset(bool reset) {
+    reset_enabled = reset;
+}
+
+void MotionInput::ResetRotations() {
+    rotations = {};
+}
+
+bool MotionInput::IsMoving(f32 sensitivity) const {
+    return gyro.Length() >= sensitivity || accel.Length() <= 0.9f || accel.Length() >= 1.1f;
+}
+
+bool MotionInput::IsCalibrated(f32 sensitivity) const {
+    return real_error.Length() < sensitivity;
+}
+
+void MotionInput::UpdateRotation(u64 elapsed_time) {
+    const f32 sample_period = elapsed_time / 1000000.0f;
+    if (sample_period > 0.1f) {
+        return;
+    }
+    rotations += gyro * sample_period;
+}
+
+void MotionInput::UpdateOrientation(u64 elapsed_time) {
+    if (!IsCalibrated(0.1f)) {
+        ResetOrientation();
+    }
+    // Short name local variable for readability
+    f32 q1 = quat.w;
+    f32 q2 = quat.xyz[0];
+    f32 q3 = quat.xyz[1];
+    f32 q4 = quat.xyz[2];
+    const f32 sample_period = elapsed_time / 1000000.0f;
+
+    // ignore invalid elapsed time
+    if (sample_period > 0.1f) {
+        return;
+    }
+
+    const auto normal_accel = accel.Normalized();
+    auto rad_gyro = gyro * Common::PI * 2;
+    const f32 swap = rad_gyro.x;
+    rad_gyro.x = rad_gyro.y;
+    rad_gyro.y = -swap;
+    rad_gyro.z = -rad_gyro.z;
+
+    // Ignore drift correction if acceleration is not reliable
+    if (accel.Length() >= 0.75f && accel.Length() <= 1.25f) {
+        const f32 ax = -normal_accel.x;
+        const f32 ay = normal_accel.y;
+        const f32 az = -normal_accel.z;
+
+        // Estimated direction of gravity
+        const f32 vx = 2.0f * (q2 * q4 - q1 * q3);
+        const f32 vy = 2.0f * (q1 * q2 + q3 * q4);
+        const f32 vz = q1 * q1 - q2 * q2 - q3 * q3 + q4 * q4;
+
+        // Error is cross product between estimated direction and measured direction of gravity
+        const Common::Vec3f new_real_error = {az * vx - ax * vz, ay * vz - az * vy,
+                                              ax * vy - ay * vx};
+
+        derivative_error = new_real_error - real_error;
+        real_error = new_real_error;
+
+        // Prevent integral windup
+        if (ki != 0.0f && !IsCalibrated(0.05f)) {
+            integral_error += real_error;
+        } else {
+            integral_error = {};
+        }
+
+        // Apply feedback terms
+        rad_gyro += kp * real_error;
+        rad_gyro += ki * integral_error;
+        rad_gyro += kd * derivative_error;
+    }
+
+    const f32 gx = rad_gyro.y;
+    const f32 gy = rad_gyro.x;
+    const f32 gz = rad_gyro.z;
+
+    // Integrate rate of change of quaternion
+    const f32 pa = q2;
+    const f32 pb = q3;
+    const f32 pc = q4;
+    q1 = q1 + (-q2 * gx - q3 * gy - q4 * gz) * (0.5f * sample_period);
+    q2 = pa + (q1 * gx + pb * gz - pc * gy) * (0.5f * sample_period);
+    q3 = pb + (q1 * gy - pa * gz + pc * gx) * (0.5f * sample_period);
+    q4 = pc + (q1 * gz + pa * gy - pb * gx) * (0.5f * sample_period);
+
+    quat.w = q1;
+    quat.xyz[0] = q2;
+    quat.xyz[1] = q3;
+    quat.xyz[2] = q4;
+    quat = quat.Normalized();
+}
+
+std::array<Common::Vec3f, 3> MotionInput::GetOrientation() const {
+    const Common::Quaternion<float> quad{
+        .xyz = {-quat.xyz[1], -quat.xyz[0], -quat.w},
+        .w = -quat.xyz[2],
+    };
+    const std::array<float, 16> matrix4x4 = quad.ToMatrix();
+
+    return {Common::Vec3f(matrix4x4[0], matrix4x4[1], -matrix4x4[2]),
+            Common::Vec3f(matrix4x4[4], matrix4x4[5], -matrix4x4[6]),
+            Common::Vec3f(-matrix4x4[8], -matrix4x4[9], matrix4x4[10])};
+}
+
+Common::Vec3f MotionInput::GetAcceleration() const {
+    return accel;
+}
+
+Common::Vec3f MotionInput::GetGyroscope() const {
+    return gyro;
+}
+
+Common::Quaternion<f32> MotionInput::GetQuaternion() const {
+    return quat;
+}
+
+Common::Vec3f MotionInput::GetRotations() const {
+    return rotations;
+}
+
+void MotionInput::ResetOrientation() {
+    if (!reset_enabled) {
+        return;
+    }
+    if (!IsMoving(0.5f) && accel.z <= -0.9f) {
+        ++reset_counter;
+        if (reset_counter > 900) {
+            // TODO: calculate quaternion from gravity vector
+            quat.w = 0;
+            quat.xyz[0] = 0;
+            quat.xyz[1] = 0;
+            quat.xyz[2] = -1;
+            integral_error = {};
+            reset_counter = 0;
+        }
+    } else {
+        reset_counter = 0;
+    }
+}
+} // namespace InputCommon
diff --git a/src/input_common/motion_input.h b/src/input_common/motion_input.h
new file mode 100644
index 000000000..54b4439d9
--- /dev/null
+++ b/src/input_common/motion_input.h
@@ -0,0 +1,68 @@
+// Copyright 2020 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included
+
+#pragma once
+
+#include "common/common_types.h"
+#include "common/quaternion.h"
+#include "common/vector_math.h"
+
+namespace InputCommon {
+
+class MotionInput {
+public:
+    MotionInput(f32 new_kp, f32 new_ki, f32 new_kd);
+
+    MotionInput(const MotionInput&) = default;
+    MotionInput& operator=(const MotionInput&) = default;
+
+    MotionInput(MotionInput&&) = default;
+    MotionInput& operator=(MotionInput&&) = default;
+
+    void SetAcceleration(const Common::Vec3f& acceleration);
+    void SetGyroscope(const Common::Vec3f& acceleration);
+    void SetQuaternion(const Common::Quaternion<f32>& quaternion);
+    void SetGyroDrift(const Common::Vec3f& drift);
+    void SetGyroThreshold(f32 threshold);
+
+    void EnableReset(bool reset);
+    void ResetRotations();
+
+    void UpdateRotation(u64 elapsed_time);
+    void UpdateOrientation(u64 elapsed_time);
+
+    std::array<Common::Vec3f, 3> GetOrientation() const;
+    Common::Vec3f GetAcceleration() const;
+    Common::Vec3f GetGyroscope() const;
+    Common::Vec3f GetRotations() const;
+    Common::Quaternion<f32> GetQuaternion() const;
+
+    bool IsMoving(f32 sensitivity) const;
+    bool IsCalibrated(f32 sensitivity) const;
+
+private:
+    void ResetOrientation();
+
+    // PID constants
+    const f32 kp;
+    const f32 ki;
+    const f32 kd;
+
+    // PID errors
+    Common::Vec3f real_error;
+    Common::Vec3f integral_error;
+    Common::Vec3f derivative_error;
+
+    Common::Quaternion<f32> quat;
+    Common::Vec3f rotations;
+    Common::Vec3f accel;
+    Common::Vec3f gyro;
+    Common::Vec3f gyro_drift;
+
+    f32 gyro_threshold = 0.0f;
+    u32 reset_counter = 0;
+    bool reset_enabled = true;
+};
+
+} // namespace InputCommon
diff --git a/src/input_common/touch_from_button.cpp b/src/input_common/touch_from_button.cpp
new file mode 100644
index 000000000..98da0ef1a
--- /dev/null
+++ b/src/input_common/touch_from_button.cpp
@@ -0,0 +1,50 @@
+// Copyright 2020 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "core/frontend/framebuffer_layout.h"
+#include "core/settings.h"
+#include "input_common/touch_from_button.h"
+
+namespace InputCommon {
+
+class TouchFromButtonDevice final : public Input::TouchDevice {
+public:
+    TouchFromButtonDevice() {
+        for (const auto& config_entry :
+             Settings::values.touch_from_button_maps[Settings::values.touch_from_button_map_index]
+                 .buttons) {
+            const Common::ParamPackage package{config_entry};
+            map.emplace_back(
+                Input::CreateDevice<Input::ButtonDevice>(config_entry),
+                std::clamp(package.Get("x", 0), 0, static_cast<int>(Layout::ScreenUndocked::Width)),
+                std::clamp(package.Get("y", 0), 0,
+                           static_cast<int>(Layout::ScreenUndocked::Height)));
+        }
+    }
+
+    std::tuple<float, float, bool> GetStatus() const override {
+        for (const auto& m : map) {
+            const bool state = std::get<0>(m)->GetStatus();
+            if (state) {
+                const float x = static_cast<float>(std::get<1>(m)) /
+                                static_cast<int>(Layout::ScreenUndocked::Width);
+                const float y = static_cast<float>(std::get<2>(m)) /
+                                static_cast<int>(Layout::ScreenUndocked::Height);
+                return {x, y, true};
+            }
+        }
+        return {};
+    }
+
+private:
+    // A vector of the mapped button, its x and its y-coordinate
+    std::vector<std::tuple<std::unique_ptr<Input::ButtonDevice>, int, int>> map;
+};
+
+std::unique_ptr<Input::TouchDevice> TouchFromButtonFactory::Create(
+    const Common::ParamPackage& params) {
+    return std::make_unique<TouchFromButtonDevice>();
+}
+
+} // namespace InputCommon
diff --git a/src/input_common/touch_from_button.h b/src/input_common/touch_from_button.h
new file mode 100644
index 000000000..8b4d1aa96
--- /dev/null
+++ b/src/input_common/touch_from_button.h
@@ -0,0 +1,23 @@
+// Copyright 2020 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <memory>
+#include "core/frontend/input.h"
+
+namespace InputCommon {
+
+/**
+ * A touch device factory that takes a list of button devices and combines them into a touch device.
+ */
+class TouchFromButtonFactory final : public Input::Factory<Input::TouchDevice> {
+public:
+    /**
+     * Creates a touch device from a list of button devices
+     */
+    std::unique_ptr<Input::TouchDevice> Create(const Common::ParamPackage& params) override;
+};
+
+} // namespace InputCommon
diff --git a/src/video_core/renderer_vulkan/vk_device.cpp b/src/video_core/renderer_vulkan/vk_device.cpp
index 030b4dbd3..4205bd573 100644
--- a/src/video_core/renderer_vulkan/vk_device.cpp
+++ b/src/video_core/renderer_vulkan/vk_device.cpp
@@ -380,6 +380,14 @@ bool VKDevice::Create() {
 
     CollectTelemetryParameters();
 
+    if (ext_extended_dynamic_state && driver_id == VK_DRIVER_ID_AMD_PROPRIETARY_KHR) {
+        // AMD's proprietary driver supports VK_EXT_extended_dynamic_state but the <stride> field
+        // seems to be bugged. Blacklisting it for now.
+        LOG_WARNING(Render_Vulkan,
+                    "Blacklisting AMD proprietary from VK_EXT_extended_dynamic_state");
+        ext_extended_dynamic_state = false;
+    }
+
     graphics_queue = logical.GetQueue(graphics_family);
     present_queue = logical.GetQueue(present_family);
 
@@ -691,12 +699,7 @@ std::vector<const char*> VKDevice::LoadExtensions() {
         }
     }
 
-    if (has_ext_extended_dynamic_state && driver_id == VK_DRIVER_ID_AMD_PROPRIETARY) {
-        // AMD's proprietary driver supports VK_EXT_extended_dynamic_state but the <stride> field
-        // seems to be bugged. Blacklisting it for now.
-        LOG_WARNING(Render_Vulkan,
-                    "Blacklisting AMD proprietary from VK_EXT_extended_dynamic_state");
-    } else if (has_ext_extended_dynamic_state) {
+    if (has_ext_extended_dynamic_state) {
         VkPhysicalDeviceExtendedDynamicStateFeaturesEXT dynamic_state;
         dynamic_state.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT;
         dynamic_state.pNext = nullptr;
diff --git a/src/video_core/shader/async_shaders.cpp b/src/video_core/shader/async_shaders.cpp
index f815584f7..aabd62c5c 100644
--- a/src/video_core/shader/async_shaders.cpp
+++ b/src/video_core/shader/async_shaders.cpp
@@ -73,11 +73,11 @@ void AsyncShaders::KillWorkers() {
     worker_threads.clear();
 }
 
-bool AsyncShaders::HasWorkQueued() {
+bool AsyncShaders::HasWorkQueued() const {
     return !pending_queue.empty();
 }
 
-bool AsyncShaders::HasCompletedWork() {
+bool AsyncShaders::HasCompletedWork() const {
     std::shared_lock lock{completed_mutex};
     return !finished_work.empty();
 }
@@ -102,7 +102,7 @@ bool AsyncShaders::IsShaderAsync(const Tegra::GPU& gpu) const {
 }
 
 std::vector<AsyncShaders::Result> AsyncShaders::GetCompletedWork() {
-    std::vector<AsyncShaders::Result> results;
+    std::vector<Result> results;
     {
         std::unique_lock lock{completed_mutex};
         results.assign(std::make_move_iterator(finished_work.begin()),
diff --git a/src/video_core/shader/async_shaders.h b/src/video_core/shader/async_shaders.h
index d5ae814d5..7cf8d994c 100644
--- a/src/video_core/shader/async_shaders.h
+++ b/src/video_core/shader/async_shaders.h
@@ -5,11 +5,10 @@
 #pragma once
 
 #include <condition_variable>
-#include <deque>
 #include <memory>
 #include <shared_mutex>
 #include <thread>
-#include "common/bit_field.h"
+
 #include "common/common_types.h"
 #include "video_core/renderer_opengl/gl_device.h"
 #include "video_core/renderer_opengl/gl_resource_manager.h"
@@ -17,7 +16,6 @@
 #include "video_core/renderer_vulkan/vk_device.h"
 #include "video_core/renderer_vulkan/vk_pipeline_cache.h"
 #include "video_core/renderer_vulkan/vk_scheduler.h"
-#include "video_core/renderer_vulkan/vk_update_descriptor.h"
 
 namespace Core::Frontend {
 class EmuWindow;
@@ -70,20 +68,20 @@ public:
     void KillWorkers();
 
     /// Check to see if any shaders have actually been compiled
-    bool HasCompletedWork();
+    [[nodiscard]] bool HasCompletedWork() const;
 
     /// Deduce if a shader can be build on another thread of MUST be built in sync. We cannot build
     /// every shader async as some shaders are only built and executed once. We try to "guess" which
     /// shader would be used only once
-    bool IsShaderAsync(const Tegra::GPU& gpu) const;
+    [[nodiscard]] bool IsShaderAsync(const Tegra::GPU& gpu) const;
 
     /// Pulls completed compiled shaders
-    std::vector<Result> GetCompletedWork();
+    [[nodiscard]] std::vector<Result> GetCompletedWork();
 
     void QueueOpenGLShader(const OpenGL::Device& device, Tegra::Engines::ShaderType shader_type,
                            u64 uid, std::vector<u64> code, std::vector<u64> code_b, u32 main_offset,
-                           VideoCommon::Shader::CompilerSettings compiler_settings,
-                           const VideoCommon::Shader::Registry& registry, VAddr cpu_addr);
+                           CompilerSettings compiler_settings, const Registry& registry,
+                           VAddr cpu_addr);
 
     void QueueVulkanShader(Vulkan::VKPipelineCache* pp_cache, const Vulkan::VKDevice& device,
                            Vulkan::VKScheduler& scheduler,
@@ -97,7 +95,7 @@ private:
     void ShaderCompilerThread(Core::Frontend::GraphicsContext* context);
 
     /// Check our worker queue to see if we have any work queued already
-    bool HasWorkQueued();
+    [[nodiscard]] bool HasWorkQueued() const;
 
     struct WorkerParams {
         Backend backend;
@@ -108,8 +106,8 @@ private:
         std::vector<u64> code;
         std::vector<u64> code_b;
         u32 main_offset;
-        VideoCommon::Shader::CompilerSettings compiler_settings;
-        std::optional<VideoCommon::Shader::Registry> registry;
+        CompilerSettings compiler_settings;
+        std::optional<Registry> registry;
         VAddr cpu_address;
 
         // For Vulkan
@@ -125,13 +123,13 @@ private:
     };
 
     std::condition_variable cv;
-    std::mutex queue_mutex;
-    std::shared_mutex completed_mutex;
+    mutable std::mutex queue_mutex;
+    mutable std::shared_mutex completed_mutex;
     std::atomic<bool> is_thread_exiting{};
     std::vector<std::unique_ptr<Core::Frontend::GraphicsContext>> context_list;
     std::vector<std::thread> worker_threads;
     std::queue<WorkerParams> pending_queue;
-    std::vector<AsyncShaders::Result> finished_work;
+    std::vector<Result> finished_work;
     Core::Frontend::EmuWindow& emu_window;
 };
 
diff --git a/src/yuzu/CMakeLists.txt b/src/yuzu/CMakeLists.txt
index 6987e85e1..3ea4e5601 100644
--- a/src/yuzu/CMakeLists.txt
+++ b/src/yuzu/CMakeLists.txt
@@ -68,6 +68,9 @@ add_executable(yuzu
     configuration/configure_input_advanced.cpp
     configuration/configure_input_advanced.h
     configuration/configure_input_advanced.ui
+    configuration/configure_motion_touch.cpp
+    configuration/configure_motion_touch.h
+    configuration/configure_motion_touch.ui
     configuration/configure_mouse_advanced.cpp
     configuration/configure_mouse_advanced.h
     configuration/configure_mouse_advanced.ui
@@ -86,9 +89,13 @@ add_executable(yuzu
     configuration/configure_system.cpp
     configuration/configure_system.h
     configuration/configure_system.ui
+    configuration/configure_touch_from_button.cpp
+    configuration/configure_touch_from_button.h
+    configuration/configure_touch_from_button.ui
     configuration/configure_touchscreen_advanced.cpp
     configuration/configure_touchscreen_advanced.h
     configuration/configure_touchscreen_advanced.ui
+    configuration/configure_touch_widget.h
     configuration/configure_ui.cpp
     configuration/configure_ui.h
     configuration/configure_ui.ui
diff --git a/src/yuzu/configuration/config.cpp b/src/yuzu/configuration/config.cpp
index 588bbd677..2bc55a26a 100644
--- a/src/yuzu/configuration/config.cpp
+++ b/src/yuzu/configuration/config.cpp
@@ -420,14 +420,64 @@ void Config::ReadControlValues() {
     ReadKeyboardValues();
     ReadMouseValues();
     ReadTouchscreenValues();
+    ReadMotionTouchValues();
 
     Settings::values.vibration_enabled =
         ReadSetting(QStringLiteral("vibration_enabled"), true).toBool();
+    Settings::values.use_docked_mode =
+        ReadSetting(QStringLiteral("use_docked_mode"), false).toBool();
+
+    qt_config->endGroup();
+}
+
+void Config::ReadMotionTouchValues() {
+    int num_touch_from_button_maps =
+        qt_config->beginReadArray(QStringLiteral("touch_from_button_maps"));
+
+    if (num_touch_from_button_maps > 0) {
+        const auto append_touch_from_button_map = [this] {
+            Settings::TouchFromButtonMap map;
+            map.name = ReadSetting(QStringLiteral("name"), QStringLiteral("default"))
+                           .toString()
+                           .toStdString();
+            const int num_touch_maps = qt_config->beginReadArray(QStringLiteral("entries"));
+            map.buttons.reserve(num_touch_maps);
+            for (int i = 0; i < num_touch_maps; i++) {
+                qt_config->setArrayIndex(i);
+                std::string touch_mapping =
+                    ReadSetting(QStringLiteral("bind")).toString().toStdString();
+                map.buttons.emplace_back(std::move(touch_mapping));
+            }
+            qt_config->endArray(); // entries
+            Settings::values.touch_from_button_maps.emplace_back(std::move(map));
+        };
+
+        for (int i = 0; i < num_touch_from_button_maps; ++i) {
+            qt_config->setArrayIndex(i);
+            append_touch_from_button_map();
+        }
+    } else {
+        Settings::values.touch_from_button_maps.emplace_back(
+            Settings::TouchFromButtonMap{"default", {}});
+        num_touch_from_button_maps = 1;
+    }
+    qt_config->endArray();
+
     Settings::values.motion_device =
         ReadSetting(QStringLiteral("motion_device"),
                     QStringLiteral("engine:motion_emu,update_period:100,sensitivity:0.01"))
             .toString()
             .toStdString();
+    Settings::values.touch_device =
+        ReadSetting(QStringLiteral("touch_device"), QStringLiteral("engine:emu_window"))
+            .toString()
+            .toStdString();
+    Settings::values.use_touch_from_button =
+        ReadSetting(QStringLiteral("use_touch_from_button"), false).toBool();
+    Settings::values.touch_from_button_map_index =
+        ReadSetting(QStringLiteral("touch_from_button_map"), 0).toInt();
+    Settings::values.touch_from_button_map_index =
+        std::clamp(Settings::values.touch_from_button_map_index, 0, num_touch_from_button_maps - 1);
     Settings::values.udp_input_address =
         ReadSetting(QStringLiteral("udp_input_address"),
                     QString::fromUtf8(InputCommon::CemuhookUDP::DEFAULT_ADDR))
@@ -438,10 +488,6 @@ void Config::ReadControlValues() {
             .toInt());
     Settings::values.udp_pad_index =
         static_cast<u8>(ReadSetting(QStringLiteral("udp_pad_index"), 0).toUInt());
-    Settings::values.use_docked_mode =
-        ReadSetting(QStringLiteral("use_docked_mode"), false).toBool();
-
-    qt_config->endGroup();
 }
 
 void Config::ReadCoreValues() {
@@ -934,6 +980,43 @@ void Config::SaveTouchscreenValues() {
     WriteSetting(QStringLiteral("touchscreen_diameter_y"), touchscreen.diameter_y, 15);
 }
 
+void Config::SaveMotionTouchValues() {
+    WriteSetting(QStringLiteral("motion_device"),
+                 QString::fromStdString(Settings::values.motion_device),
+                 QStringLiteral("engine:motion_emu,update_period:100,sensitivity:0.01"));
+    WriteSetting(QStringLiteral("touch_device"),
+                 QString::fromStdString(Settings::values.touch_device),
+                 QStringLiteral("engine:emu_window"));
+    WriteSetting(QStringLiteral("use_touch_from_button"), Settings::values.use_touch_from_button,
+                 false);
+    WriteSetting(QStringLiteral("touch_from_button_map"),
+                 Settings::values.touch_from_button_map_index, 0);
+    WriteSetting(QStringLiteral("udp_input_address"),
+                 QString::fromStdString(Settings::values.udp_input_address),
+                 QString::fromUtf8(InputCommon::CemuhookUDP::DEFAULT_ADDR));
+    WriteSetting(QStringLiteral("udp_input_port"), Settings::values.udp_input_port,
+                 InputCommon::CemuhookUDP::DEFAULT_PORT);
+    WriteSetting(QStringLiteral("udp_pad_index"), Settings::values.udp_pad_index, 0);
+
+    qt_config->beginWriteArray(QStringLiteral("touch_from_button_maps"));
+    for (std::size_t p = 0; p < Settings::values.touch_from_button_maps.size(); ++p) {
+        qt_config->setArrayIndex(static_cast<int>(p));
+        WriteSetting(QStringLiteral("name"),
+                     QString::fromStdString(Settings::values.touch_from_button_maps[p].name),
+                     QStringLiteral("default"));
+        qt_config->beginWriteArray(QStringLiteral("entries"));
+        for (std::size_t q = 0; q < Settings::values.touch_from_button_maps[p].buttons.size();
+             ++q) {
+            qt_config->setArrayIndex(static_cast<int>(q));
+            WriteSetting(
+                QStringLiteral("bind"),
+                QString::fromStdString(Settings::values.touch_from_button_maps[p].buttons[q]));
+        }
+        qt_config->endArray();
+    }
+    qt_config->endArray();
+}
+
 void Config::SaveValues() {
     if (global) {
         SaveControlValues();
@@ -976,18 +1059,16 @@ void Config::SaveControlValues() {
     SaveDebugValues();
     SaveMouseValues();
     SaveTouchscreenValues();
+    SaveMotionTouchValues();
 
     WriteSetting(QStringLiteral("vibration_enabled"), Settings::values.vibration_enabled, true);
     WriteSetting(QStringLiteral("motion_device"),
                  QString::fromStdString(Settings::values.motion_device),
                  QStringLiteral("engine:motion_emu,update_period:100,sensitivity:0.01"));
+    WriteSetting(QStringLiteral("touch_device"),
+                 QString::fromStdString(Settings::values.touch_device),
+                 QStringLiteral("engine:emu_window"));
     WriteSetting(QStringLiteral("keyboard_enabled"), Settings::values.keyboard_enabled, false);
-    WriteSetting(QStringLiteral("udp_input_address"),
-                 QString::fromStdString(Settings::values.udp_input_address),
-                 QString::fromUtf8(InputCommon::CemuhookUDP::DEFAULT_ADDR));
-    WriteSetting(QStringLiteral("udp_input_port"), Settings::values.udp_input_port,
-                 InputCommon::CemuhookUDP::DEFAULT_PORT);
-    WriteSetting(QStringLiteral("udp_pad_index"), Settings::values.udp_pad_index, 0);
     WriteSetting(QStringLiteral("use_docked_mode"), Settings::values.use_docked_mode, false);
 
     qt_config->endGroup();
diff --git a/src/yuzu/configuration/config.h b/src/yuzu/configuration/config.h
index aa929d134..ca0d29c6c 100644
--- a/src/yuzu/configuration/config.h
+++ b/src/yuzu/configuration/config.h
@@ -38,6 +38,7 @@ private:
     void ReadKeyboardValues();
     void ReadMouseValues();
     void ReadTouchscreenValues();
+    void ReadMotionTouchValues();
 
     // Read functions bases off the respective config section names.
     void ReadAudioValues();
@@ -64,6 +65,7 @@ private:
     void SaveDebugValues();
     void SaveMouseValues();
     void SaveTouchscreenValues();
+    void SaveMotionTouchValues();
 
     // Save functions based off the respective config section names.
     void SaveAudioValues();
diff --git a/src/yuzu/configuration/configure_input.cpp b/src/yuzu/configuration/configure_input.cpp
index 5223eed1d..ae3e31762 100644
--- a/src/yuzu/configuration/configure_input.cpp
+++ b/src/yuzu/configuration/configure_input.cpp
@@ -20,6 +20,7 @@
 #include "yuzu/configuration/configure_input.h"
 #include "yuzu/configuration/configure_input_advanced.h"
 #include "yuzu/configuration/configure_input_player.h"
+#include "yuzu/configuration/configure_motion_touch.h"
 #include "yuzu/configuration/configure_mouse_advanced.h"
 #include "yuzu/configuration/configure_touchscreen_advanced.h"
 
@@ -127,6 +128,10 @@ void ConfigureInput::Initialize(InputCommon::InputSubsystem* input_subsystem) {
     });
     connect(advanced, &ConfigureInputAdvanced::CallTouchscreenConfigDialog,
             [this] { CallConfigureDialog<ConfigureTouchscreenAdvanced>(*this); });
+    connect(advanced, &ConfigureInputAdvanced::CallMotionTouchConfigDialog,
+            [this, input_subsystem] {
+                CallConfigureDialog<ConfigureMotionTouch>(*this, input_subsystem);
+            });
 
     connect(ui->buttonClearAll, &QPushButton::clicked, [this] { ClearAll(); });
     connect(ui->buttonRestoreDefaults, &QPushButton::clicked, [this] { RestoreDefaults(); });
diff --git a/src/yuzu/configuration/configure_input_advanced.cpp b/src/yuzu/configuration/configure_input_advanced.cpp
index db42b826b..81f9dc16c 100644
--- a/src/yuzu/configuration/configure_input_advanced.cpp
+++ b/src/yuzu/configuration/configure_input_advanced.cpp
@@ -86,6 +86,8 @@ ConfigureInputAdvanced::ConfigureInputAdvanced(QWidget* parent)
     connect(ui->mouse_advanced, &QPushButton::clicked, this, [this] { CallMouseConfigDialog(); });
     connect(ui->touchscreen_advanced, &QPushButton::clicked, this,
             [this] { CallTouchscreenConfigDialog(); });
+    connect(ui->buttonMotionTouch, &QPushButton::clicked, this,
+            &ConfigureInputAdvanced::CallMotionTouchConfigDialog);
 
     LoadConfiguration();
 }
diff --git a/src/yuzu/configuration/configure_input_advanced.h b/src/yuzu/configuration/configure_input_advanced.h
index d8fcec52d..50bb87768 100644
--- a/src/yuzu/configuration/configure_input_advanced.h
+++ b/src/yuzu/configuration/configure_input_advanced.h
@@ -28,6 +28,7 @@ signals:
     void CallDebugControllerDialog();
     void CallMouseConfigDialog();
     void CallTouchscreenConfigDialog();
+    void CallMotionTouchConfigDialog();
 
 private:
     void changeEvent(QEvent* event) override;
diff --git a/src/yuzu/configuration/configure_motion_touch.cpp b/src/yuzu/configuration/configure_motion_touch.cpp
new file mode 100644
index 000000000..c7d085151
--- /dev/null
+++ b/src/yuzu/configuration/configure_motion_touch.cpp
@@ -0,0 +1,314 @@
+// Copyright 2018 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <array>
+#include <QCloseEvent>
+#include <QLabel>
+#include <QMessageBox>
+#include <QPushButton>
+#include <QVBoxLayout>
+#include "common/logging/log.h"
+#include "core/settings.h"
+#include "input_common/main.h"
+#include "input_common/udp/client.h"
+#include "input_common/udp/udp.h"
+#include "ui_configure_motion_touch.h"
+#include "yuzu/configuration/configure_motion_touch.h"
+#include "yuzu/configuration/configure_touch_from_button.h"
+
+CalibrationConfigurationDialog::CalibrationConfigurationDialog(QWidget* parent,
+                                                               const std::string& host, u16 port,
+                                                               u8 pad_index, u16 client_id)
+    : QDialog(parent) {
+    layout = new QVBoxLayout;
+    status_label = new QLabel(tr("Communicating with the server..."));
+    cancel_button = new QPushButton(tr("Cancel"));
+    connect(cancel_button, &QPushButton::clicked, this, [this] {
+        if (!completed) {
+            job->Stop();
+        }
+        accept();
+    });
+    layout->addWidget(status_label);
+    layout->addWidget(cancel_button);
+    setLayout(layout);
+
+    using namespace InputCommon::CemuhookUDP;
+    job = std::make_unique<CalibrationConfigurationJob>(
+        host, port, pad_index, client_id,
+        [this](CalibrationConfigurationJob::Status status) {
+            QString text;
+            switch (status) {
+            case CalibrationConfigurationJob::Status::Ready:
+                text = tr("Touch the top left corner <br>of your touchpad.");
+                break;
+            case CalibrationConfigurationJob::Status::Stage1Completed:
+                text = tr("Now touch the bottom right corner <br>of your touchpad.");
+                break;
+            case CalibrationConfigurationJob::Status::Completed:
+                text = tr("Configuration completed!");
+                break;
+            }
+            QMetaObject::invokeMethod(this, "UpdateLabelText", Q_ARG(QString, text));
+            if (status == CalibrationConfigurationJob::Status::Completed) {
+                QMetaObject::invokeMethod(this, "UpdateButtonText", Q_ARG(QString, tr("OK")));
+            }
+        },
+        [this](u16 min_x_, u16 min_y_, u16 max_x_, u16 max_y_) {
+            completed = true;
+            min_x = min_x_;
+            min_y = min_y_;
+            max_x = max_x_;
+            max_y = max_y_;
+        });
+}
+
+CalibrationConfigurationDialog::~CalibrationConfigurationDialog() = default;
+
+void CalibrationConfigurationDialog::UpdateLabelText(const QString& text) {
+    status_label->setText(text);
+}
+
+void CalibrationConfigurationDialog::UpdateButtonText(const QString& text) {
+    cancel_button->setText(text);
+}
+
+constexpr std::array<std::pair<const char*, const char*>, 2> MotionProviders = {{
+    {"motion_emu", QT_TRANSLATE_NOOP("ConfigureMotionTouch", "Mouse (Right Click)")},
+    {"cemuhookudp", QT_TRANSLATE_NOOP("ConfigureMotionTouch", "CemuhookUDP")},
+}};
+
+constexpr std::array<std::pair<const char*, const char*>, 2> TouchProviders = {{
+    {"emu_window", QT_TRANSLATE_NOOP("ConfigureMotionTouch", "Emulator Window")},
+    {"cemuhookudp", QT_TRANSLATE_NOOP("ConfigureMotionTouch", "CemuhookUDP")},
+}};
+
+ConfigureMotionTouch::ConfigureMotionTouch(QWidget* parent,
+                                           InputCommon::InputSubsystem* input_subsystem_)
+    : QDialog(parent), input_subsystem{input_subsystem_},
+      ui(std::make_unique<Ui::ConfigureMotionTouch>()) {
+    ui->setupUi(this);
+    for (const auto& [provider, name] : MotionProviders) {
+        ui->motion_provider->addItem(tr(name), QString::fromUtf8(provider));
+    }
+    for (const auto& [provider, name] : TouchProviders) {
+        ui->touch_provider->addItem(tr(name), QString::fromUtf8(provider));
+    }
+
+    ui->udp_learn_more->setOpenExternalLinks(true);
+    ui->udp_learn_more->setText(
+        tr("<a "
+           "href='https://yuzu-emu.org/wiki/"
+           "using-a-controller-or-android-phone-for-motion-or-touch-input'><span "
+           "style=\"text-decoration: underline; color:#039be5;\">Learn More</span></a>"));
+
+    SetConfiguration();
+    UpdateUiDisplay();
+    ConnectEvents();
+}
+
+ConfigureMotionTouch::~ConfigureMotionTouch() = default;
+
+void ConfigureMotionTouch::SetConfiguration() {
+    const Common::ParamPackage motion_param(Settings::values.motion_device);
+    const Common::ParamPackage touch_param(Settings::values.touch_device);
+    const std::string motion_engine = motion_param.Get("engine", "motion_emu");
+    const std::string touch_engine = touch_param.Get("engine", "emu_window");
+
+    ui->motion_provider->setCurrentIndex(
+        ui->motion_provider->findData(QString::fromStdString(motion_engine)));
+    ui->touch_provider->setCurrentIndex(
+        ui->touch_provider->findData(QString::fromStdString(touch_engine)));
+    ui->touch_from_button_checkbox->setChecked(Settings::values.use_touch_from_button);
+    touch_from_button_maps = Settings::values.touch_from_button_maps;
+    for (const auto& touch_map : touch_from_button_maps) {
+        ui->touch_from_button_map->addItem(QString::fromStdString(touch_map.name));
+    }
+    ui->touch_from_button_map->setCurrentIndex(Settings::values.touch_from_button_map_index);
+    ui->motion_sensitivity->setValue(motion_param.Get("sensitivity", 0.01f));
+
+    min_x = touch_param.Get("min_x", 100);
+    min_y = touch_param.Get("min_y", 50);
+    max_x = touch_param.Get("max_x", 1800);
+    max_y = touch_param.Get("max_y", 850);
+
+    ui->udp_server->setText(QString::fromStdString(Settings::values.udp_input_address));
+    ui->udp_port->setText(QString::number(Settings::values.udp_input_port));
+    ui->udp_pad_index->setCurrentIndex(Settings::values.udp_pad_index);
+}
+
+void ConfigureMotionTouch::UpdateUiDisplay() {
+    const QString motion_engine = ui->motion_provider->currentData().toString();
+    const QString touch_engine = ui->touch_provider->currentData().toString();
+    const QString cemuhook_udp = QStringLiteral("cemuhookudp");
+
+    if (motion_engine == QStringLiteral("motion_emu")) {
+        ui->motion_sensitivity_label->setVisible(true);
+        ui->motion_sensitivity->setVisible(true);
+    } else {
+        ui->motion_sensitivity_label->setVisible(false);
+        ui->motion_sensitivity->setVisible(false);
+    }
+
+    if (touch_engine == cemuhook_udp) {
+        ui->touch_calibration->setVisible(true);
+        ui->touch_calibration_config->setVisible(true);
+        ui->touch_calibration_label->setVisible(true);
+        ui->touch_calibration->setText(
+            QStringLiteral("(%1, %2) - (%3, %4)").arg(min_x).arg(min_y).arg(max_x).arg(max_y));
+    } else {
+        ui->touch_calibration->setVisible(false);
+        ui->touch_calibration_config->setVisible(false);
+        ui->touch_calibration_label->setVisible(false);
+    }
+
+    if (motion_engine == cemuhook_udp || touch_engine == cemuhook_udp) {
+        ui->udp_config_group_box->setVisible(true);
+    } else {
+        ui->udp_config_group_box->setVisible(false);
+    }
+}
+
+void ConfigureMotionTouch::ConnectEvents() {
+    connect(ui->motion_provider, qOverload<int>(&QComboBox::currentIndexChanged), this,
+            [this](int index) { UpdateUiDisplay(); });
+    connect(ui->touch_provider, qOverload<int>(&QComboBox::currentIndexChanged), this,
+            [this](int index) { UpdateUiDisplay(); });
+    connect(ui->udp_test, &QPushButton::clicked, this, &ConfigureMotionTouch::OnCemuhookUDPTest);
+    connect(ui->touch_calibration_config, &QPushButton::clicked, this,
+            &ConfigureMotionTouch::OnConfigureTouchCalibration);
+    connect(ui->touch_from_button_config_btn, &QPushButton::clicked, this,
+            &ConfigureMotionTouch::OnConfigureTouchFromButton);
+    connect(ui->buttonBox, &QDialogButtonBox::rejected, this, [this] {
+        if (CanCloseDialog()) {
+            reject();
+        }
+    });
+}
+
+void ConfigureMotionTouch::OnCemuhookUDPTest() {
+    ui->udp_test->setEnabled(false);
+    ui->udp_test->setText(tr("Testing"));
+    udp_test_in_progress = true;
+    InputCommon::CemuhookUDP::TestCommunication(
+        ui->udp_server->text().toStdString(), static_cast<u16>(ui->udp_port->text().toInt()),
+        static_cast<u8>(ui->udp_pad_index->currentIndex()), 24872,
+        [this] {
+            LOG_INFO(Frontend, "UDP input test success");
+            QMetaObject::invokeMethod(this, "ShowUDPTestResult", Q_ARG(bool, true));
+        },
+        [this] {
+            LOG_ERROR(Frontend, "UDP input test failed");
+            QMetaObject::invokeMethod(this, "ShowUDPTestResult", Q_ARG(bool, false));
+        });
+}
+
+void ConfigureMotionTouch::OnConfigureTouchCalibration() {
+    ui->touch_calibration_config->setEnabled(false);
+    ui->touch_calibration_config->setText(tr("Configuring"));
+    CalibrationConfigurationDialog dialog(
+        this, ui->udp_server->text().toStdString(), static_cast<u16>(ui->udp_port->text().toUInt()),
+        static_cast<u8>(ui->udp_pad_index->currentIndex()), 24872);
+    dialog.exec();
+    if (dialog.completed) {
+        min_x = dialog.min_x;
+        min_y = dialog.min_y;
+        max_x = dialog.max_x;
+        max_y = dialog.max_y;
+        LOG_INFO(Frontend,
+                 "UDP touchpad calibration config success: min_x={}, min_y={}, max_x={}, max_y={}",
+                 min_x, min_y, max_x, max_y);
+        UpdateUiDisplay();
+    } else {
+        LOG_ERROR(Frontend, "UDP touchpad calibration config failed");
+    }
+    ui->touch_calibration_config->setEnabled(true);
+    ui->touch_calibration_config->setText(tr("Configure"));
+}
+
+void ConfigureMotionTouch::closeEvent(QCloseEvent* event) {
+    if (CanCloseDialog()) {
+        event->accept();
+    } else {
+        event->ignore();
+    }
+}
+
+void ConfigureMotionTouch::ShowUDPTestResult(bool result) {
+    udp_test_in_progress = false;
+    if (result) {
+        QMessageBox::information(this, tr("Test Successful"),
+                                 tr("Successfully received data from the server."));
+    } else {
+        QMessageBox::warning(this, tr("Test Failed"),
+                             tr("Could not receive valid data from the server.<br>Please verify "
+                                "that the server is set up correctly and "
+                                "the address and port are correct."));
+    }
+    ui->udp_test->setEnabled(true);
+    ui->udp_test->setText(tr("Test"));
+}
+
+void ConfigureMotionTouch::OnConfigureTouchFromButton() {
+    ConfigureTouchFromButton dialog{this, touch_from_button_maps, input_subsystem,
+                                    ui->touch_from_button_map->currentIndex()};
+    if (dialog.exec() != QDialog::Accepted) {
+        return;
+    }
+    touch_from_button_maps = dialog.GetMaps();
+
+    while (ui->touch_from_button_map->count() > 0) {
+        ui->touch_from_button_map->removeItem(0);
+    }
+    for (const auto& touch_map : touch_from_button_maps) {
+        ui->touch_from_button_map->addItem(QString::fromStdString(touch_map.name));
+    }
+    ui->touch_from_button_map->setCurrentIndex(dialog.GetSelectedIndex());
+}
+
+bool ConfigureMotionTouch::CanCloseDialog() {
+    if (udp_test_in_progress) {
+        QMessageBox::warning(this, tr("Citra"),
+                             tr("UDP Test or calibration configuration is in progress.<br>Please "
+                                "wait for them to finish."));
+        return false;
+    }
+    return true;
+}
+
+void ConfigureMotionTouch::ApplyConfiguration() {
+    if (!CanCloseDialog()) {
+        return;
+    }
+
+    std::string motion_engine = ui->motion_provider->currentData().toString().toStdString();
+    std::string touch_engine = ui->touch_provider->currentData().toString().toStdString();
+
+    Common::ParamPackage motion_param{}, touch_param{};
+    motion_param.Set("engine", std::move(motion_engine));
+    touch_param.Set("engine", std::move(touch_engine));
+
+    if (motion_engine == "motion_emu") {
+        motion_param.Set("sensitivity", static_cast<float>(ui->motion_sensitivity->value()));
+    }
+
+    if (touch_engine == "cemuhookudp") {
+        touch_param.Set("min_x", min_x);
+        touch_param.Set("min_y", min_y);
+        touch_param.Set("max_x", max_x);
+        touch_param.Set("max_y", max_y);
+    }
+
+    Settings::values.motion_device = motion_param.Serialize();
+    Settings::values.touch_device = touch_param.Serialize();
+    Settings::values.use_touch_from_button = ui->touch_from_button_checkbox->isChecked();
+    Settings::values.touch_from_button_map_index = ui->touch_from_button_map->currentIndex();
+    Settings::values.touch_from_button_maps = touch_from_button_maps;
+    Settings::values.udp_input_address = ui->udp_server->text().toStdString();
+    Settings::values.udp_input_port = static_cast<u16>(ui->udp_port->text().toInt());
+    Settings::values.udp_pad_index = static_cast<u8>(ui->udp_pad_index->currentIndex());
+    input_subsystem->ReloadInputDevices();
+
+    accept();
+}
diff --git a/src/yuzu/configuration/configure_motion_touch.h b/src/yuzu/configuration/configure_motion_touch.h
new file mode 100644
index 000000000..3d4b5d659
--- /dev/null
+++ b/src/yuzu/configuration/configure_motion_touch.h
@@ -0,0 +1,90 @@
+// Copyright 2018 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <memory>
+#include <QDialog>
+#include "common/param_package.h"
+
+class QLabel;
+class QPushButton;
+class QVBoxLayout;
+
+namespace InputCommon {
+class InputSubsystem;
+}
+
+namespace InputCommon::CemuhookUDP {
+class CalibrationConfigurationJob;
+}
+
+namespace Ui {
+class ConfigureMotionTouch;
+}
+
+/// A dialog for touchpad calibration configuration.
+class CalibrationConfigurationDialog : public QDialog {
+    Q_OBJECT
+public:
+    explicit CalibrationConfigurationDialog(QWidget* parent, const std::string& host, u16 port,
+                                            u8 pad_index, u16 client_id);
+    ~CalibrationConfigurationDialog() override;
+
+private:
+    Q_INVOKABLE void UpdateLabelText(const QString& text);
+    Q_INVOKABLE void UpdateButtonText(const QString& text);
+
+    QVBoxLayout* layout;
+    QLabel* status_label;
+    QPushButton* cancel_button;
+    std::unique_ptr<InputCommon::CemuhookUDP::CalibrationConfigurationJob> job;
+
+    // Configuration results
+    bool completed{};
+    u16 min_x{};
+    u16 min_y{};
+    u16 max_x{};
+    u16 max_y{};
+
+    friend class ConfigureMotionTouch;
+};
+
+class ConfigureMotionTouch : public QDialog {
+    Q_OBJECT
+
+public:
+    explicit ConfigureMotionTouch(QWidget* parent, InputCommon::InputSubsystem* input_subsystem_);
+    ~ConfigureMotionTouch() override;
+
+public slots:
+    void ApplyConfiguration();
+
+private slots:
+    void OnCemuhookUDPTest();
+    void OnConfigureTouchCalibration();
+    void OnConfigureTouchFromButton();
+
+private:
+    void closeEvent(QCloseEvent* event) override;
+    Q_INVOKABLE void ShowUDPTestResult(bool result);
+    void SetConfiguration();
+    void UpdateUiDisplay();
+    void ConnectEvents();
+    bool CanCloseDialog();
+
+    InputCommon::InputSubsystem* input_subsystem;
+
+    std::unique_ptr<Ui::ConfigureMotionTouch> ui;
+
+    // Coordinate system of the CemuhookUDP touch provider
+    int min_x{};
+    int min_y{};
+    int max_x{};
+    int max_y{};
+
+    bool udp_test_in_progress{};
+
+    std::vector<Settings::TouchFromButtonMap> touch_from_button_maps;
+};
diff --git a/src/yuzu/configuration/configure_motion_touch.ui b/src/yuzu/configuration/configure_motion_touch.ui
new file mode 100644
index 000000000..602cf8cd8
--- /dev/null
+++ b/src/yuzu/configuration/configure_motion_touch.ui
@@ -0,0 +1,327 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>ConfigureMotionTouch</class>
+ <widget class="QDialog" name="ConfigureMotionTouch">
+  <property name="windowTitle">
+   <string>Configure Motion / Touch</string>
+  </property>
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>500</width>
+    <height>450</height>
+   </rect>
+  </property>
+  <layout class="QVBoxLayout">
+   <item>
+    <widget class="QGroupBox" name="motion_group_box">
+     <property name="title">
+      <string>Motion</string>
+     </property>
+     <layout class="QVBoxLayout">
+      <item>
+       <layout class="QHBoxLayout">
+        <item>
+         <widget class="QLabel" name="motion_provider_label">
+          <property name="text">
+           <string>Motion Provider:</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QComboBox" name="motion_provider"/>
+        </item>
+       </layout>
+      </item>
+      <item>
+       <layout class="QHBoxLayout">
+        <item>
+         <widget class="QLabel" name="motion_sensitivity_label">
+          <property name="text">
+           <string>Sensitivity:</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QDoubleSpinBox" name="motion_sensitivity">
+          <property name="alignment">
+           <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+          </property>
+          <property name="decimals">
+           <number>4</number>
+          </property>
+          <property name="minimum">
+           <double>0.010000000000000</double>
+          </property>
+          <property name="maximum">
+           <double>10.000000000000000</double>
+          </property>
+          <property name="singleStep">
+           <double>0.001000000000000</double>
+          </property>
+          <property name="value">
+           <double>0.010000000000000</double>
+          </property>
+         </widget>
+        </item>
+       </layout>
+      </item>
+     </layout>
+    </widget>
+   </item>
+   <item>
+    <widget class="QGroupBox" name="touch_group_box">
+     <property name="title">
+      <string>Touch</string>
+     </property>
+     <layout class="QVBoxLayout">
+      <item>
+       <layout class="QHBoxLayout">
+        <item>
+         <widget class="QLabel" name="touch_provider_label">
+          <property name="text">
+           <string>Touch Provider:</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QComboBox" name="touch_provider"/>
+        </item>
+       </layout>
+      </item>
+      <item>
+       <layout class="QHBoxLayout">
+        <item>
+         <widget class="QLabel" name="touch_calibration_label">
+          <property name="text">
+           <string>Calibration:</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QLabel" name="touch_calibration">
+          <property name="text">
+           <string>(100, 50) - (1800, 850)</string>
+          </property>
+          <property name="alignment">
+           <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QPushButton" name="touch_calibration_config">
+          <property name="sizePolicy">
+           <sizepolicy hsizetype="Maximum" vsizetype="Fixed">
+            <horstretch>0</horstretch>
+            <verstretch>0</verstretch>
+           </sizepolicy>
+          </property>
+          <property name="text">
+           <string>Configure</string>
+          </property>
+         </widget>
+        </item>
+       </layout>
+      </item>
+      <item>
+       <layout class="QHBoxLayout">
+        <item>
+         <widget class="QCheckBox" name="touch_from_button_checkbox">
+          <property name="sizePolicy">
+           <sizepolicy hsizetype="Maximum" vsizetype="Fixed">
+            <horstretch>0</horstretch>
+            <verstretch>0</verstretch>
+           </sizepolicy>
+          </property>
+          <property name="text">
+           <string>Use button mapping:</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QComboBox" name="touch_from_button_map"/>
+        </item>
+        <item>
+         <widget class="QPushButton" name="touch_from_button_config_btn">
+          <property name="sizePolicy">
+           <sizepolicy hsizetype="Maximum" vsizetype="Fixed">
+            <horstretch>0</horstretch>
+            <verstretch>0</verstretch>
+           </sizepolicy>
+          </property>
+          <property name="text">
+           <string>Configure</string>
+          </property>
+         </widget>
+        </item>
+       </layout>
+      </item>
+     </layout>
+    </widget>
+   </item>
+   <item>
+    <widget class="QGroupBox" name="udp_config_group_box">
+     <property name="title">
+      <string>CemuhookUDP Config</string>
+     </property>
+     <layout class="QVBoxLayout">
+      <item>
+       <widget class="QLabel" name="udp_help">
+        <property name="text">
+         <string>You may use any Cemuhook compatible UDP input source to provide motion and touch input.</string>
+        </property>
+        <property name="alignment">
+         <set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop</set>
+        </property>
+        <property name="wordWrap">
+         <bool>true</bool>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <layout class="QHBoxLayout">
+        <item>
+         <widget class="QLabel" name="udp_server_label">
+          <property name="text">
+           <string>Server:</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QLineEdit" name="udp_server">
+          <property name="sizePolicy">
+           <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
+            <horstretch>0</horstretch>
+            <verstretch>0</verstretch>
+           </sizepolicy>
+          </property>
+         </widget>
+        </item>
+       </layout>
+      </item>
+      <item>
+       <layout class="QHBoxLayout">
+        <item>
+         <widget class="QLabel" name="udp_port_label">
+          <property name="text">
+           <string>Port:</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QLineEdit" name="udp_port">
+          <property name="sizePolicy">
+           <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
+            <horstretch>0</horstretch>
+            <verstretch>0</verstretch>
+           </sizepolicy>
+          </property>
+         </widget>
+        </item>
+       </layout>
+      </item>
+      <item>
+       <layout class="QHBoxLayout">
+        <item>
+         <widget class="QLabel" name="udp_pad_index_label">
+          <property name="text">
+           <string>Pad:</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QComboBox" name="udp_pad_index">
+          <item>
+           <property name="text">
+            <string>Pad 1</string>
+           </property>
+          </item>
+          <item>
+           <property name="text">
+            <string>Pad 2</string>
+           </property>
+          </item>
+          <item>
+           <property name="text">
+            <string>Pad 3</string>
+           </property>
+          </item>
+          <item>
+           <property name="text">
+            <string>Pad 4</string>
+           </property>
+          </item>
+         </widget>
+        </item>
+       </layout>
+      </item>
+      <item>
+       <layout class="QHBoxLayout">
+        <item>
+         <widget class="QLabel" name="udp_learn_more">
+          <property name="text">
+           <string>Learn More</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QPushButton" name="udp_test">
+          <property name="sizePolicy">
+           <sizepolicy hsizetype="Maximum" vsizetype="Fixed">
+            <horstretch>0</horstretch>
+            <verstretch>0</verstretch>
+           </sizepolicy>
+          </property>
+          <property name="text">
+           <string>Test</string>
+          </property>
+         </widget>
+        </item>
+       </layout>
+      </item>
+     </layout>
+    </widget>
+   </item>
+   <item>
+    <spacer>
+     <property name="orientation">
+      <enum>Qt::Vertical</enum>
+     </property>
+     <property name="sizeHint" stdset="0">
+      <size>
+       <width>167</width>
+       <height>55</height>
+      </size>
+     </property>
+    </spacer>
+   </item>
+   <item>
+    <widget class="QDialogButtonBox" name="buttonBox">
+     <property name="standardButtons">
+      <set>QDialogButtonBox::Cancel|QDialogButtonBox::Ok</set>
+     </property>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections>
+  <connection>
+   <sender>buttonBox</sender>
+   <signal>accepted()</signal>
+   <receiver>ConfigureMotionTouch</receiver>
+   <slot>ApplyConfiguration()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>220</x>
+     <y>380</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>220</x>
+     <y>200</y>
+    </hint>
+   </hints>
+  </connection>
+ </connections>
+</ui>
diff --git a/src/yuzu/configuration/configure_touch_from_button.cpp b/src/yuzu/configuration/configure_touch_from_button.cpp
new file mode 100644
index 000000000..15557e4b8
--- /dev/null
+++ b/src/yuzu/configuration/configure_touch_from_button.cpp
@@ -0,0 +1,623 @@
+// Copyright 2020 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <QInputDialog>
+#include <QKeyEvent>
+#include <QMessageBox>
+#include <QMouseEvent>
+#include <QResizeEvent>
+#include <QStandardItemModel>
+#include <QTimer>
+#include "common/param_package.h"
+#include "core/frontend/framebuffer_layout.h"
+#include "core/settings.h"
+#include "input_common/main.h"
+#include "ui_configure_touch_from_button.h"
+#include "yuzu/configuration/configure_touch_from_button.h"
+#include "yuzu/configuration/configure_touch_widget.h"
+
+static QString GetKeyName(int key_code) {
+    switch (key_code) {
+    case Qt::Key_Shift:
+        return QObject::tr("Shift");
+    case Qt::Key_Control:
+        return QObject::tr("Ctrl");
+    case Qt::Key_Alt:
+        return QObject::tr("Alt");
+    case Qt::Key_Meta:
+        return QString{};
+    default:
+        return QKeySequence(key_code).toString();
+    }
+}
+
+static QString ButtonToText(const Common::ParamPackage& param) {
+    if (!param.Has("engine")) {
+        return QObject::tr("[not set]");
+    }
+
+    if (param.Get("engine", "") == "keyboard") {
+        return GetKeyName(param.Get("code", 0));
+    }
+
+    if (param.Get("engine", "") == "sdl") {
+        if (param.Has("hat")) {
+            const QString hat_str = QString::fromStdString(param.Get("hat", ""));
+            const QString direction_str = QString::fromStdString(param.Get("direction", ""));
+
+            return QObject::tr("Hat %1 %2").arg(hat_str, direction_str);
+        }
+
+        if (param.Has("axis")) {
+            const QString axis_str = QString::fromStdString(param.Get("axis", ""));
+            const QString direction_str = QString::fromStdString(param.Get("direction", ""));
+
+            return QObject::tr("Axis %1%2").arg(axis_str, direction_str);
+        }
+
+        if (param.Has("button")) {
+            const QString button_str = QString::fromStdString(param.Get("button", ""));
+
+            return QObject::tr("Button %1").arg(button_str);
+        }
+
+        return {};
+    }
+
+    return QObject::tr("[unknown]");
+}
+
+ConfigureTouchFromButton::ConfigureTouchFromButton(
+    QWidget* parent, const std::vector<Settings::TouchFromButtonMap>& touch_maps,
+    InputCommon::InputSubsystem* input_subsystem_, const int default_index)
+    : QDialog(parent), ui(std::make_unique<Ui::ConfigureTouchFromButton>()),
+      touch_maps(touch_maps), input_subsystem{input_subsystem_}, selected_index(default_index),
+      timeout_timer(std::make_unique<QTimer>()), poll_timer(std::make_unique<QTimer>()) {
+    ui->setupUi(this);
+    binding_list_model = new QStandardItemModel(0, 3, this);
+    binding_list_model->setHorizontalHeaderLabels(
+        {tr("Button"), tr("X", "X axis"), tr("Y", "Y axis")});
+    ui->binding_list->setModel(binding_list_model);
+    ui->bottom_screen->SetCoordLabel(ui->coord_label);
+
+    SetConfiguration();
+    UpdateUiDisplay();
+    ConnectEvents();
+}
+
+ConfigureTouchFromButton::~ConfigureTouchFromButton() = default;
+
+void ConfigureTouchFromButton::showEvent(QShowEvent* ev) {
+    QWidget::showEvent(ev);
+
+    // width values are not valid in the constructor
+    const int w =
+        ui->binding_list->viewport()->contentsRect().width() / binding_list_model->columnCount();
+    if (w <= 0) {
+        return;
+    }
+    ui->binding_list->setColumnWidth(0, w);
+    ui->binding_list->setColumnWidth(1, w);
+    ui->binding_list->setColumnWidth(2, w);
+}
+
+void ConfigureTouchFromButton::SetConfiguration() {
+    for (const auto& touch_map : touch_maps) {
+        ui->mapping->addItem(QString::fromStdString(touch_map.name));
+    }
+
+    ui->mapping->setCurrentIndex(selected_index);
+}
+
+void ConfigureTouchFromButton::UpdateUiDisplay() {
+    ui->button_delete->setEnabled(touch_maps.size() > 1);
+    ui->button_delete_bind->setEnabled(false);
+
+    binding_list_model->removeRows(0, binding_list_model->rowCount());
+
+    for (const auto& button_str : touch_maps[selected_index].buttons) {
+        Common::ParamPackage package{button_str};
+        QStandardItem* button = new QStandardItem(ButtonToText(package));
+        button->setData(QString::fromStdString(button_str));
+        button->setEditable(false);
+        QStandardItem* xcoord = new QStandardItem(QString::number(package.Get("x", 0)));
+        QStandardItem* ycoord = new QStandardItem(QString::number(package.Get("y", 0)));
+        binding_list_model->appendRow({button, xcoord, ycoord});
+
+        const int dot = ui->bottom_screen->AddDot(package.Get("x", 0), package.Get("y", 0));
+        button->setData(dot, DataRoleDot);
+    }
+}
+
+void ConfigureTouchFromButton::ConnectEvents() {
+    connect(ui->mapping, qOverload<int>(&QComboBox::currentIndexChanged), this, [this](int index) {
+        SaveCurrentMapping();
+        selected_index = index;
+        UpdateUiDisplay();
+    });
+    connect(ui->button_new, &QPushButton::clicked, this, &ConfigureTouchFromButton::NewMapping);
+    connect(ui->button_delete, &QPushButton::clicked, this,
+            &ConfigureTouchFromButton::DeleteMapping);
+    connect(ui->button_rename, &QPushButton::clicked, this,
+            &ConfigureTouchFromButton::RenameMapping);
+    connect(ui->button_delete_bind, &QPushButton::clicked, this,
+            &ConfigureTouchFromButton::DeleteBinding);
+    connect(ui->binding_list, &QTreeView::doubleClicked, this,
+            &ConfigureTouchFromButton::EditBinding);
+    connect(ui->binding_list->selectionModel(), &QItemSelectionModel::selectionChanged, this,
+            &ConfigureTouchFromButton::OnBindingSelection);
+    connect(binding_list_model, &QStandardItemModel::itemChanged, this,
+            &ConfigureTouchFromButton::OnBindingChanged);
+    connect(ui->binding_list->model(), &QStandardItemModel::rowsAboutToBeRemoved, this,
+            &ConfigureTouchFromButton::OnBindingDeleted);
+    connect(ui->bottom_screen, &TouchScreenPreview::DotAdded, this,
+            &ConfigureTouchFromButton::NewBinding);
+    connect(ui->bottom_screen, &TouchScreenPreview::DotSelected, this,
+            &ConfigureTouchFromButton::SetActiveBinding);
+    connect(ui->bottom_screen, &TouchScreenPreview::DotMoved, this,
+            &ConfigureTouchFromButton::SetCoordinates);
+    connect(ui->buttonBox, &QDialogButtonBox::accepted, this,
+            &ConfigureTouchFromButton::ApplyConfiguration);
+
+    connect(timeout_timer.get(), &QTimer::timeout, [this]() { SetPollingResult({}, true); });
+
+    connect(poll_timer.get(), &QTimer::timeout, [this]() {
+        Common::ParamPackage params;
+        for (auto& poller : device_pollers) {
+            params = poller->GetNextInput();
+            if (params.Has("engine")) {
+                SetPollingResult(params, false);
+                return;
+            }
+        }
+    });
+}
+
+void ConfigureTouchFromButton::SaveCurrentMapping() {
+    auto& map = touch_maps[selected_index];
+    map.buttons.clear();
+    for (int i = 0, rc = binding_list_model->rowCount(); i < rc; ++i) {
+        const auto bind_str = binding_list_model->index(i, 0)
+                                  .data(Qt::ItemDataRole::UserRole + 1)
+                                  .toString()
+                                  .toStdString();
+        if (bind_str.empty()) {
+            continue;
+        }
+        Common::ParamPackage params{bind_str};
+        if (!params.Has("engine")) {
+            continue;
+        }
+        params.Set("x", binding_list_model->index(i, 1).data().toInt());
+        params.Set("y", binding_list_model->index(i, 2).data().toInt());
+        map.buttons.emplace_back(params.Serialize());
+    }
+}
+
+void ConfigureTouchFromButton::NewMapping() {
+    const QString name =
+        QInputDialog::getText(this, tr("New Profile"), tr("Enter the name for the new profile."));
+    if (name.isEmpty()) {
+        return;
+    }
+    touch_maps.emplace_back(Settings::TouchFromButtonMap{name.toStdString(), {}});
+    ui->mapping->addItem(name);
+    ui->mapping->setCurrentIndex(ui->mapping->count() - 1);
+}
+
+void ConfigureTouchFromButton::DeleteMapping() {
+    const auto answer = QMessageBox::question(
+        this, tr("Delete Profile"), tr("Delete profile %1?").arg(ui->mapping->currentText()));
+    if (answer != QMessageBox::Yes) {
+        return;
+    }
+    const bool blocked = ui->mapping->blockSignals(true);
+    ui->mapping->removeItem(selected_index);
+    ui->mapping->blockSignals(blocked);
+    touch_maps.erase(touch_maps.begin() + selected_index);
+    selected_index = ui->mapping->currentIndex();
+    UpdateUiDisplay();
+}
+
+void ConfigureTouchFromButton::RenameMapping() {
+    const QString new_name = QInputDialog::getText(this, tr("Rename Profile"), tr("New name:"));
+    if (new_name.isEmpty()) {
+        return;
+    }
+    ui->mapping->setItemText(selected_index, new_name);
+    touch_maps[selected_index].name = new_name.toStdString();
+}
+
+void ConfigureTouchFromButton::GetButtonInput(const int row_index, const bool is_new) {
+    binding_list_model->item(row_index, 0)->setText(tr("[press key]"));
+
+    input_setter = [this, row_index, is_new](const Common::ParamPackage& params,
+                                             const bool cancel) {
+        auto* cell = binding_list_model->item(row_index, 0);
+        if (cancel) {
+            if (is_new) {
+                binding_list_model->removeRow(row_index);
+            } else {
+                cell->setText(
+                    ButtonToText(Common::ParamPackage{cell->data().toString().toStdString()}));
+            }
+        } else {
+            cell->setText(ButtonToText(params));
+            cell->setData(QString::fromStdString(params.Serialize()));
+        }
+    };
+
+    device_pollers = input_subsystem->GetPollers(InputCommon::Polling::DeviceType::Button);
+
+    for (auto& poller : device_pollers) {
+        poller->Start();
+    }
+
+    grabKeyboard();
+    grabMouse();
+    qApp->setOverrideCursor(QCursor(Qt::CursorShape::ArrowCursor));
+    timeout_timer->start(5000); // Cancel after 5 seconds
+    poll_timer->start(200);     // Check for new inputs every 200ms
+}
+
+void ConfigureTouchFromButton::NewBinding(const QPoint& pos) {
+    auto* button = new QStandardItem();
+    button->setEditable(false);
+    auto* x_coord = new QStandardItem(QString::number(pos.x()));
+    auto* y_coord = new QStandardItem(QString::number(pos.y()));
+
+    const int dot_id = ui->bottom_screen->AddDot(pos.x(), pos.y());
+    button->setData(dot_id, DataRoleDot);
+
+    binding_list_model->appendRow({button, x_coord, y_coord});
+    ui->binding_list->setFocus();
+    ui->binding_list->setCurrentIndex(button->index());
+
+    GetButtonInput(binding_list_model->rowCount() - 1, true);
+}
+
+void ConfigureTouchFromButton::EditBinding(const QModelIndex& qi) {
+    if (qi.row() >= 0 && qi.column() == 0) {
+        GetButtonInput(qi.row(), false);
+    }
+}
+
+void ConfigureTouchFromButton::DeleteBinding() {
+    const int row_index = ui->binding_list->currentIndex().row();
+    if (row_index < 0) {
+        return;
+    }
+    ui->bottom_screen->RemoveDot(binding_list_model->index(row_index, 0).data(DataRoleDot).toInt());
+    binding_list_model->removeRow(row_index);
+}
+
+void ConfigureTouchFromButton::OnBindingSelection(const QItemSelection& selected,
+                                                  const QItemSelection& deselected) {
+    ui->button_delete_bind->setEnabled(!selected.isEmpty());
+    if (!selected.isEmpty()) {
+        const auto dot_data = selected.indexes().first().data(DataRoleDot);
+        if (dot_data.isValid()) {
+            ui->bottom_screen->HighlightDot(dot_data.toInt());
+        }
+    }
+    if (!deselected.isEmpty()) {
+        const auto dot_data = deselected.indexes().first().data(DataRoleDot);
+        if (dot_data.isValid()) {
+            ui->bottom_screen->HighlightDot(dot_data.toInt(), false);
+        }
+    }
+}
+
+void ConfigureTouchFromButton::OnBindingChanged(QStandardItem* item) {
+    if (item->column() == 0) {
+        return;
+    }
+
+    const bool blocked = binding_list_model->blockSignals(true);
+    item->setText(QString::number(
+        std::clamp(item->text().toInt(), 0,
+                   static_cast<int>((item->column() == 1 ? Layout::ScreenUndocked::Width
+                                                         : Layout::ScreenUndocked::Height) -
+                                    1))));
+    binding_list_model->blockSignals(blocked);
+
+    const auto dot_data = binding_list_model->index(item->row(), 0).data(DataRoleDot);
+    if (dot_data.isValid()) {
+        ui->bottom_screen->MoveDot(dot_data.toInt(),
+                                   binding_list_model->item(item->row(), 1)->text().toInt(),
+                                   binding_list_model->item(item->row(), 2)->text().toInt());
+    }
+}
+
+void ConfigureTouchFromButton::OnBindingDeleted(const QModelIndex& parent, int first, int last) {
+    for (int i = first; i <= last; ++i) {
+        const auto ix = binding_list_model->index(i, 0);
+        if (!ix.isValid()) {
+            return;
+        }
+        const auto dot_data = ix.data(DataRoleDot);
+        if (dot_data.isValid()) {
+            ui->bottom_screen->RemoveDot(dot_data.toInt());
+        }
+    }
+}
+
+void ConfigureTouchFromButton::SetActiveBinding(const int dot_id) {
+    for (int i = 0; i < binding_list_model->rowCount(); ++i) {
+        if (binding_list_model->index(i, 0).data(DataRoleDot) == dot_id) {
+            ui->binding_list->setCurrentIndex(binding_list_model->index(i, 0));
+            ui->binding_list->setFocus();
+            return;
+        }
+    }
+}
+
+void ConfigureTouchFromButton::SetCoordinates(const int dot_id, const QPoint& pos) {
+    for (int i = 0; i < binding_list_model->rowCount(); ++i) {
+        if (binding_list_model->item(i, 0)->data(DataRoleDot) == dot_id) {
+            binding_list_model->item(i, 1)->setText(QString::number(pos.x()));
+            binding_list_model->item(i, 2)->setText(QString::number(pos.y()));
+            return;
+        }
+    }
+}
+
+void ConfigureTouchFromButton::SetPollingResult(const Common::ParamPackage& params,
+                                                const bool cancel) {
+    releaseKeyboard();
+    releaseMouse();
+    qApp->restoreOverrideCursor();
+    timeout_timer->stop();
+    poll_timer->stop();
+    for (auto& poller : device_pollers) {
+        poller->Stop();
+    }
+    if (input_setter) {
+        (*input_setter)(params, cancel);
+        input_setter.reset();
+    }
+}
+
+void ConfigureTouchFromButton::keyPressEvent(QKeyEvent* event) {
+    if (!input_setter && event->key() == Qt::Key_Delete) {
+        DeleteBinding();
+        return;
+    }
+
+    if (!input_setter) {
+        return QDialog::keyPressEvent(event);
+    }
+
+    if (event->key() != Qt::Key_Escape) {
+        SetPollingResult(Common::ParamPackage{InputCommon::GenerateKeyboardParam(event->key())},
+                         false);
+    } else {
+        SetPollingResult({}, true);
+    }
+}
+
+void ConfigureTouchFromButton::ApplyConfiguration() {
+    SaveCurrentMapping();
+    accept();
+}
+
+int ConfigureTouchFromButton::GetSelectedIndex() const {
+    return selected_index;
+}
+
+std::vector<Settings::TouchFromButtonMap> ConfigureTouchFromButton::GetMaps() const {
+    return touch_maps;
+}
+
+TouchScreenPreview::TouchScreenPreview(QWidget* parent) : QFrame(parent) {
+    setBackgroundRole(QPalette::ColorRole::Base);
+}
+
+TouchScreenPreview::~TouchScreenPreview() = default;
+
+void TouchScreenPreview::SetCoordLabel(QLabel* const label) {
+    coord_label = label;
+}
+
+int TouchScreenPreview::AddDot(const int device_x, const int device_y) {
+    QFont dot_font{QStringLiteral("monospace")};
+    dot_font.setStyleHint(QFont::Monospace);
+    dot_font.setPointSize(20);
+
+    auto* dot = new QLabel(this);
+    dot->setAttribute(Qt::WA_TranslucentBackground);
+    dot->setFont(dot_font);
+    dot->setText(QChar(0xD7)); // U+00D7 Multiplication Sign
+    dot->setAlignment(Qt::AlignmentFlag::AlignCenter);
+    dot->setProperty(PropId, ++max_dot_id);
+    dot->setProperty(PropX, device_x);
+    dot->setProperty(PropY, device_y);
+    dot->setCursor(Qt::CursorShape::PointingHandCursor);
+    dot->setMouseTracking(true);
+    dot->installEventFilter(this);
+    dot->show();
+    PositionDot(dot, device_x, device_y);
+    dots.emplace_back(max_dot_id, dot);
+    return max_dot_id;
+}
+
+void TouchScreenPreview::RemoveDot(const int id) {
+    const auto iter = std::find_if(dots.begin(), dots.end(),
+                                   [id](const auto& entry) { return entry.first == id; });
+    if (iter == dots.cend()) {
+        return;
+    }
+
+    iter->second->deleteLater();
+    dots.erase(iter);
+}
+
+void TouchScreenPreview::HighlightDot(const int id, const bool active) const {
+    for (const auto& dot : dots) {
+        if (dot.first == id) {
+            // use color property from the stylesheet, or fall back to the default palette
+            if (dot_highlight_color.isValid()) {
+                dot.second->setStyleSheet(
+                    active ? QStringLiteral("color: %1").arg(dot_highlight_color.name())
+                           : QString{});
+            } else {
+                dot.second->setForegroundRole(active ? QPalette::ColorRole::LinkVisited
+                                                     : QPalette::ColorRole::NoRole);
+            }
+            if (active) {
+                dot.second->raise();
+            }
+            return;
+        }
+    }
+}
+
+void TouchScreenPreview::MoveDot(const int id, const int device_x, const int device_y) const {
+    const auto iter = std::find_if(dots.begin(), dots.end(),
+                                   [id](const auto& entry) { return entry.first == id; });
+    if (iter == dots.cend()) {
+        return;
+    }
+
+    iter->second->setProperty(PropX, device_x);
+    iter->second->setProperty(PropY, device_y);
+    PositionDot(iter->second, device_x, device_y);
+}
+
+void TouchScreenPreview::resizeEvent(QResizeEvent* event) {
+    if (ignore_resize) {
+        return;
+    }
+
+    const int target_width = std::min(width(), height() * 4 / 3);
+    const int target_height = std::min(height(), width() * 3 / 4);
+    if (target_width == width() && target_height == height()) {
+        return;
+    }
+    ignore_resize = true;
+    setGeometry((parentWidget()->contentsRect().width() - target_width) / 2, y(), target_width,
+                target_height);
+    ignore_resize = false;
+
+    if (event->oldSize().width() != target_width || event->oldSize().height() != target_height) {
+        for (const auto& dot : dots) {
+            PositionDot(dot.second);
+        }
+    }
+}
+
+void TouchScreenPreview::mouseMoveEvent(QMouseEvent* event) {
+    if (!coord_label) {
+        return;
+    }
+    const auto pos = MapToDeviceCoords(event->x(), event->y());
+    if (pos) {
+        coord_label->setText(QStringLiteral("X: %1, Y: %2").arg(pos->x()).arg(pos->y()));
+    } else {
+        coord_label->clear();
+    }
+}
+
+void TouchScreenPreview::leaveEvent(QEvent* event) {
+    if (coord_label) {
+        coord_label->clear();
+    }
+}
+
+void TouchScreenPreview::mousePressEvent(QMouseEvent* event) {
+    if (event->button() != Qt::MouseButton::LeftButton) {
+        return;
+    }
+    const auto pos = MapToDeviceCoords(event->x(), event->y());
+    if (pos) {
+        emit DotAdded(*pos);
+    }
+}
+
+bool TouchScreenPreview::eventFilter(QObject* obj, QEvent* event) {
+    switch (event->type()) {
+    case QEvent::Type::MouseButtonPress: {
+        const auto mouse_event = static_cast<QMouseEvent*>(event);
+        if (mouse_event->button() != Qt::MouseButton::LeftButton) {
+            break;
+        }
+        emit DotSelected(obj->property(PropId).toInt());
+
+        drag_state.dot = qobject_cast<QLabel*>(obj);
+        drag_state.start_pos = mouse_event->globalPos();
+        return true;
+    }
+    case QEvent::Type::MouseMove: {
+        if (!drag_state.dot) {
+            break;
+        }
+        const auto mouse_event = static_cast<QMouseEvent*>(event);
+        if (!drag_state.active) {
+            drag_state.active =
+                (mouse_event->globalPos() - drag_state.start_pos).manhattanLength() >=
+                QApplication::startDragDistance();
+            if (!drag_state.active) {
+                break;
+            }
+        }
+        auto current_pos = mapFromGlobal(mouse_event->globalPos());
+        current_pos.setX(std::clamp(current_pos.x(), contentsMargins().left(),
+                                    contentsMargins().left() + contentsRect().width() - 1));
+        current_pos.setY(std::clamp(current_pos.y(), contentsMargins().top(),
+                                    contentsMargins().top() + contentsRect().height() - 1));
+        const auto device_coord = MapToDeviceCoords(current_pos.x(), current_pos.y());
+        if (device_coord) {
+            drag_state.dot->setProperty(PropX, device_coord->x());
+            drag_state.dot->setProperty(PropY, device_coord->y());
+            PositionDot(drag_state.dot, device_coord->x(), device_coord->y());
+            emit DotMoved(drag_state.dot->property(PropId).toInt(), *device_coord);
+            if (coord_label) {
+                coord_label->setText(
+                    QStringLiteral("X: %1, Y: %2").arg(device_coord->x()).arg(device_coord->y()));
+            }
+        }
+        return true;
+    }
+    case QEvent::Type::MouseButtonRelease: {
+        drag_state.dot.clear();
+        drag_state.active = false;
+        return true;
+    }
+    default:
+        break;
+    }
+    return obj->eventFilter(obj, event);
+}
+
+std::optional<QPoint> TouchScreenPreview::MapToDeviceCoords(const int screen_x,
+                                                            const int screen_y) const {
+    const float t_x = 0.5f + static_cast<float>(screen_x - contentsMargins().left()) *
+                                 (Layout::ScreenUndocked::Width - 1) / (contentsRect().width() - 1);
+    const float t_y = 0.5f + static_cast<float>(screen_y - contentsMargins().top()) *
+                                 (Layout::ScreenUndocked::Height - 1) /
+                                 (contentsRect().height() - 1);
+    if (t_x >= 0.5f && t_x < Layout::ScreenUndocked::Width && t_y >= 0.5f &&
+        t_y < Layout::ScreenUndocked::Height) {
+
+        return QPoint{static_cast<int>(t_x), static_cast<int>(t_y)};
+    }
+    return std::nullopt;
+}
+
+void TouchScreenPreview::PositionDot(QLabel* const dot, const int device_x,
+                                     const int device_y) const {
+    const float device_coord_x =
+        static_cast<float>(device_x >= 0 ? device_x : dot->property(PropX).toInt());
+    int x_coord = static_cast<int>(
+        device_coord_x * (contentsRect().width() - 1) / (Layout::ScreenUndocked::Width - 1) +
+        contentsMargins().left() - static_cast<float>(dot->width()) / 2 + 0.5f);
+
+    const float device_coord_y =
+        static_cast<float>(device_y >= 0 ? device_y : dot->property(PropY).toInt());
+    const int y_coord = static_cast<int>(
+        device_coord_y * (contentsRect().height() - 1) / (Layout::ScreenUndocked::Height - 1) +
+        contentsMargins().top() - static_cast<float>(dot->height()) / 2 + 0.5f);
+
+    dot->move(x_coord, y_coord);
+}
diff --git a/src/yuzu/configuration/configure_touch_from_button.h b/src/yuzu/configuration/configure_touch_from_button.h
new file mode 100644
index 000000000..d9513e3bc
--- /dev/null
+++ b/src/yuzu/configuration/configure_touch_from_button.h
@@ -0,0 +1,92 @@
+// Copyright 2020 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <functional>
+#include <memory>
+#include <optional>
+#include <vector>
+#include <QDialog>
+
+class QItemSelection;
+class QModelIndex;
+class QStandardItemModel;
+class QStandardItem;
+class QTimer;
+
+namespace Common {
+class ParamPackage;
+}
+
+namespace InputCommon {
+class InputSubsystem;
+}
+
+namespace InputCommon::Polling {
+class DevicePoller;
+}
+
+namespace Settings {
+struct TouchFromButtonMap;
+}
+
+namespace Ui {
+class ConfigureTouchFromButton;
+}
+
+class ConfigureTouchFromButton : public QDialog {
+    Q_OBJECT
+
+public:
+    explicit ConfigureTouchFromButton(QWidget* parent,
+                                      const std::vector<Settings::TouchFromButtonMap>& touch_maps,
+                                      InputCommon::InputSubsystem* input_subsystem_,
+                                      int default_index = 0);
+    ~ConfigureTouchFromButton() override;
+
+    int GetSelectedIndex() const;
+    std::vector<Settings::TouchFromButtonMap> GetMaps() const;
+
+public slots:
+    void ApplyConfiguration();
+    void NewBinding(const QPoint& pos);
+    void SetActiveBinding(int dot_id);
+    void SetCoordinates(int dot_id, const QPoint& pos);
+
+protected:
+    void showEvent(QShowEvent* ev) override;
+    void keyPressEvent(QKeyEvent* event) override;
+
+private slots:
+    void NewMapping();
+    void DeleteMapping();
+    void RenameMapping();
+    void EditBinding(const QModelIndex& qi);
+    void DeleteBinding();
+    void OnBindingSelection(const QItemSelection& selected, const QItemSelection& deselected);
+    void OnBindingChanged(QStandardItem* item);
+    void OnBindingDeleted(const QModelIndex& parent, int first, int last);
+
+private:
+    void SetConfiguration();
+    void UpdateUiDisplay();
+    void ConnectEvents();
+    void GetButtonInput(int row_index, bool is_new);
+    void SetPollingResult(const Common::ParamPackage& params, bool cancel);
+    void SaveCurrentMapping();
+
+    std::unique_ptr<Ui::ConfigureTouchFromButton> ui;
+    std::vector<Settings::TouchFromButtonMap> touch_maps;
+    QStandardItemModel* binding_list_model;
+    InputCommon::InputSubsystem* input_subsystem;
+    int selected_index;
+
+    std::unique_ptr<QTimer> timeout_timer;
+    std::unique_ptr<QTimer> poll_timer;
+    std::vector<std::unique_ptr<InputCommon::Polling::DevicePoller>> device_pollers;
+    std::optional<std::function<void(const Common::ParamPackage&, bool)>> input_setter;
+
+    static constexpr int DataRoleDot = Qt::ItemDataRole::UserRole + 2;
+};
diff --git a/src/yuzu/configuration/configure_touch_from_button.ui b/src/yuzu/configuration/configure_touch_from_button.ui
new file mode 100644
index 000000000..f581e27e0
--- /dev/null
+++ b/src/yuzu/configuration/configure_touch_from_button.ui
@@ -0,0 +1,231 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>ConfigureTouchFromButton</class>
+ <widget class="QDialog" name="ConfigureTouchFromButton">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>500</width>
+    <height>500</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Configure Touchscreen Mappings</string>
+  </property>
+  <layout class="QVBoxLayout">
+   <item>
+    <layout class="QHBoxLayout" name="horizontalLayout">
+     <item>
+      <widget class="QLabel" name="label">
+       <property name="text">
+        <string>Mapping:</string>
+       </property>
+       <property name="textFormat">
+        <enum>Qt::PlainText</enum>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QComboBox" name="mapping">
+       <property name="sizePolicy">
+        <sizepolicy hsizetype="MinimumExpanding" vsizetype="Fixed">
+         <horstretch>0</horstretch>
+         <verstretch>0</verstretch>
+        </sizepolicy>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QPushButton" name="button_new">
+       <property name="sizePolicy">
+        <sizepolicy hsizetype="Maximum" vsizetype="Fixed">
+         <horstretch>0</horstretch>
+         <verstretch>0</verstretch>
+        </sizepolicy>
+       </property>
+       <property name="text">
+        <string>New</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QPushButton" name="button_delete">
+       <property name="sizePolicy">
+        <sizepolicy hsizetype="Maximum" vsizetype="Fixed">
+         <horstretch>0</horstretch>
+         <verstretch>0</verstretch>
+        </sizepolicy>
+       </property>
+       <property name="text">
+        <string>Delete</string>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QPushButton" name="button_rename">
+       <property name="sizePolicy">
+        <sizepolicy hsizetype="Maximum" vsizetype="Fixed">
+         <horstretch>0</horstretch>
+         <verstretch>0</verstretch>
+        </sizepolicy>
+       </property>
+       <property name="text">
+        <string>Rename</string>
+       </property>
+      </widget>
+     </item>
+    </layout>
+   </item>
+   <item>
+    <widget class="Line" name="line">
+     <property name="orientation">
+      <enum>Qt::Horizontal</enum>
+     </property>
+    </widget>
+   </item>
+   <item>
+    <layout class="QHBoxLayout" name="horizontalLayout_2">
+     <item>
+      <widget class="QLabel" name="label_2">
+       <property name="text">
+        <string>Click the bottom area to add a point, then press a button to bind.
+Drag points to change position, or double-click table cells to edit values.</string>
+       </property>
+       <property name="textFormat">
+        <enum>Qt::PlainText</enum>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <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>
+     <item>
+      <widget class="QPushButton" name="button_delete_bind">
+       <property name="text">
+        <string>Delete Point</string>
+       </property>
+      </widget>
+     </item>
+    </layout>
+   </item>
+   <item>
+    <widget class="QTreeView" name="binding_list">
+     <property name="sizePolicy">
+      <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
+       <horstretch>0</horstretch>
+       <verstretch>0</verstretch>
+      </sizepolicy>
+     </property>
+     <property name="rootIsDecorated">
+      <bool>false</bool>
+     </property>
+     <property name="uniformRowHeights">
+      <bool>true</bool>
+     </property>
+     <property name="itemsExpandable">
+      <bool>false</bool>
+     </property>
+    </widget>
+   </item>
+   <item>
+    <widget class="TouchScreenPreview" name="bottom_screen">
+     <property name="sizePolicy">
+      <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
+       <horstretch>0</horstretch>
+       <verstretch>0</verstretch>
+      </sizepolicy>
+     </property>
+     <property name="minimumSize">
+      <size>
+       <width>160</width>
+       <height>120</height>
+      </size>
+     </property>
+     <property name="baseSize">
+      <size>
+       <width>320</width>
+       <height>240</height>
+      </size>
+     </property>
+     <property name="cursor">
+      <cursorShape>CrossCursor</cursorShape>
+     </property>
+     <property name="mouseTracking">
+      <bool>true</bool>
+     </property>
+     <property name="autoFillBackground">
+      <bool>true</bool>
+     </property>
+     <property name="frameShape">
+      <enum>QFrame::StyledPanel</enum>
+     </property>
+     <property name="frameShadow">
+      <enum>QFrame::Sunken</enum>
+     </property>
+    </widget>
+   </item>
+   <item>
+    <layout class="QHBoxLayout" name="horizontalLayout_3">
+     <item>
+      <widget class="QLabel" name="coord_label">
+       <property name="sizePolicy">
+        <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
+         <horstretch>0</horstretch>
+         <verstretch>0</verstretch>
+        </sizepolicy>
+       </property>
+       <property name="textFormat">
+        <enum>Qt::PlainText</enum>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QDialogButtonBox" name="buttonBox">
+       <property name="standardButtons">
+        <set>QDialogButtonBox::Cancel|QDialogButtonBox::Ok</set>
+       </property>
+      </widget>
+     </item>
+    </layout>
+   </item>
+  </layout>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>TouchScreenPreview</class>
+   <extends>QFrame</extends>
+   <header>yuzu/configuration/configure_touch_widget.h</header>
+   <container>1</container>
+  </customwidget>
+ </customwidgets>
+ <resources/>
+ <connections>
+  <connection>
+   <sender>buttonBox</sender>
+   <signal>rejected()</signal>
+   <receiver>ConfigureTouchFromButton</receiver>
+   <slot>reject()</slot>
+   <hints>
+    <hint type="sourcelabel">
+     <x>249</x>
+     <y>428</y>
+    </hint>
+    <hint type="destinationlabel">
+     <x>249</x>
+     <y>224</y>
+    </hint>
+   </hints>
+  </connection>
+ </connections>
+</ui>
diff --git a/src/yuzu/configuration/configure_touch_widget.h b/src/yuzu/configuration/configure_touch_widget.h
new file mode 100644
index 000000000..347b46583
--- /dev/null
+++ b/src/yuzu/configuration/configure_touch_widget.h
@@ -0,0 +1,62 @@
+// Copyright 2020 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <optional>
+#include <utility>
+#include <vector>
+#include <QFrame>
+#include <QPointer>
+
+class QLabel;
+
+// Widget for representing touchscreen coordinates
+class TouchScreenPreview : public QFrame {
+    Q_OBJECT
+    Q_PROPERTY(QColor dotHighlightColor MEMBER dot_highlight_color)
+
+public:
+    explicit TouchScreenPreview(QWidget* parent);
+    ~TouchScreenPreview() override;
+
+    void SetCoordLabel(QLabel*);
+    int AddDot(int device_x, int device_y);
+    void RemoveDot(int id);
+    void HighlightDot(int id, bool active = true) const;
+    void MoveDot(int id, int device_x, int device_y) const;
+
+signals:
+    void DotAdded(const QPoint& pos);
+    void DotSelected(int dot_id);
+    void DotMoved(int dot_id, const QPoint& pos);
+
+protected:
+    void resizeEvent(QResizeEvent*) override;
+    void mouseMoveEvent(QMouseEvent*) override;
+    void leaveEvent(QEvent*) override;
+    void mousePressEvent(QMouseEvent*) override;
+    bool eventFilter(QObject*, QEvent*) override;
+
+private:
+    std::optional<QPoint> MapToDeviceCoords(int screen_x, int screen_y) const;
+    void PositionDot(QLabel* dot, int device_x = -1, int device_y = -1) const;
+
+    bool ignore_resize = false;
+    QPointer<QLabel> coord_label;
+
+    std::vector<std::pair<int, QLabel*>> dots;
+    int max_dot_id = 0;
+    QColor dot_highlight_color;
+    static constexpr char PropId[] = "dot_id";
+    static constexpr char PropX[] = "device_x";
+    static constexpr char PropY[] = "device_y";
+
+    struct DragState {
+        bool active = false;
+        QPointer<QLabel> dot;
+        QPoint start_pos;
+    };
+    DragState drag_state;
+};
diff --git a/src/yuzu/main.ui b/src/yuzu/main.ui
index 87ea985d8..2f3792247 100644
--- a/src/yuzu/main.ui
+++ b/src/yuzu/main.ui
@@ -293,7 +293,7 @@
     <bool>false</bool>
    </property>
    <property name="text">
-    <string>Configure Current Game..</string>
+    <string>Configure Current Game...</string>
    </property>
   </action>
  </widget>