System: Address Feedback

System: Correct PrepareReschedule.
Kernel: Remove a few global instances from the kernel.
2020-01-27 09:54:11 -04:00 · 2020-01-26 14:32:50 -04:00 · 2020-01-26 14:23:46 -04:00 · 2020-01-26 14:07:22 -04:00 · 2020-01-26 10:28:23 -04:00 · 2020-01-25 18:55:32 -04:00
82 changed files with 1028 additions and 2018 deletions
@@ -5,7 +5,7 @@ cd /yuzu
 ccache -s

 mkdir build || true && cd build
-cmake .. -G Ninja -DDISPLAY_VERSION=$1 -DYUZU_USE_BUNDLED_UNICORN=ON -DYUZU_USE_QT_WEB_ENGINE=ON -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=/usr/lib/ccache/gcc -DCMAKE_CXX_COMPILER=/usr/lib/ccache/g++ -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DUSE_DISCORD_PRESENCE=ON -DENABLE_VULKAN=No
+cmake .. -G Ninja -DDISPLAY_VERSION=$1 -DYUZU_USE_BUNDLED_UNICORN=ON -DYUZU_USE_QT_WEB_ENGINE=ON -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=/usr/lib/ccache/gcc -DCMAKE_CXX_COMPILER=/usr/lib/ccache/g++ -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DUSE_DISCORD_PRESENCE=ON

 ninja

@@ -13,7 +13,7 @@ echo '' >> /bin/cmd
 chmod +x /bin/cmd

 mkdir build || true && cd build
-cmake .. -G Ninja -DDISPLAY_VERSION=$1 -DCMAKE_TOOLCHAIN_FILE="$(pwd)/../CMakeModules/MinGWCross.cmake" -DUSE_CCACHE=ON -DYUZU_USE_BUNDLED_UNICORN=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DCMAKE_BUILD_TYPE=Release -DENABLE_VULKAN=No
+cmake .. -G Ninja -DDISPLAY_VERSION=$1 -DCMAKE_TOOLCHAIN_FILE="$(pwd)/../CMakeModules/MinGWCross.cmake" -DUSE_CCACHE=ON -DYUZU_USE_BUNDLED_UNICORN=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DCMAKE_BUILD_TYPE=Release
 ninja

 # Clean up the dirty hacks
@@ -2,8 +2,7 @@ QToolTip {
    border: 1px solid #76797C;
    background-color: #5A7566;
    color: white;
-    /*remove padding, for fix combobox tooltip.*/
-    padding: 0;
+    padding: 0px;                /*remove padding, for fix combobox tooltip.*/
    opacity: 200;
 }

@@ -14,7 +13,7 @@ QWidget {
    selection-color: #eff0f1;
    background-clip: border;
    border-image: none;
-    border: 0;
+    border: 0px transparent black;
    outline: 0;
 }

@@ -28,10 +27,10 @@ QWidget:item:selected {
 }

 QCheckBox {
-    spacing: 6px;
+    spacing: 5px;
    outline: none;
    color: #eff0f1;
-    margin: 0 2px 1px 0;
+    margin-bottom: 2px;
 }

 QCheckBox:disabled {
@@ -164,7 +163,7 @@ QMenuBar::item:selected {
 }

 QMenuBar::item:pressed {
-    border: 1px solid #18465d;
+    border: 1px solid #76797C;
    background-color: #3daee9;
    color: #eff0f1;
    margin-bottom: -1px;
@@ -172,9 +171,9 @@ QMenuBar::item:pressed {
 }

 QMenu {
-    border: 1px solid #434242;
-    padding: 2px;
+    border: 1px solid #76797C;
    color: #eff0f1;
+    margin: 2px;
 }

 QMenu::icon {
@@ -191,21 +190,11 @@ QMenu::item:selected {
    color: #eff0f1;
 }

-QMenu::item:disabled {
-    color: #54575B;
-}
-
-QMenu::item:disabled:hover,
-QMenu::item:disabled:selected {
-    background-color: #393e43;
-    color: #666;
-}
-
-QMenu::separator,
-QMenuBar::separator {
-    height: 1px;
-    background-color: #54575B;
-    margin: 2px 4px 2px 40px;
+QMenu::separator {
+    height: 2px;
+    background: #76797C;
+    margin-left: 10px;
+    margin-right: 5px;
 }

 QMenu::indicator {
@@ -214,7 +203,10 @@ QMenu::indicator {
    height: 18px;
 }

-/* non-exclusive indicator = check box style indicator (see QActionGroup::setExclusive) */
+
+/* non-exclusive indicator = check box style indicator
+   (see QActionGroup::setExclusive) */
+
 QMenu::indicator:non-exclusive:unchecked {
    image: url(:/qss_icons/rc/checkbox_unchecked.png);
 }
@@ -231,7 +223,9 @@ QMenu::indicator:non-exclusive:checked:selected {
    image: url(:/qss_icons/rc/checkbox_checked_disabled.png);
 }

+
 /* exclusive indicator = radio button style indicator (see QActionGroup::setExclusive) */
+
 QMenu::indicator:exclusive:unchecked {
    image: url(:/qss_icons/rc/radio_unchecked.png);
 }
@@ -249,12 +243,12 @@ QMenu::indicator:exclusive:checked:selected {
 }

 QMenu::right-arrow {
-    margin-right: 10px;
+    margin: 5px;
    image: url(:/qss_icons/rc/right_arrow.png)
 }

 QWidget:disabled {
-    color: #4f515b;
+    color: #454545;
    background-color: #31363b;
 }

@@ -265,30 +259,23 @@ QAbstractItemView {
    border-radius: 2px;
 }

-QAbstractItemView:disabled,
-QAbstractItemView:read-only {
-    alternate-background-color: #232629;
-}
-
-QWidget:focus {
+QWidget:focus,
+QMenuBar:focus {
    border: 1px solid #3daee9;
 }

 QTabWidget:focus,
 QCheckBox:focus,
 QRadioButton:focus,
-QSlider:focus,
-QTreeView:focus,
-QMenu:focus,
-QMenuBar:focus,
-QTabBar:focus {
+QSlider:focus {
    border: none;
 }

 QLineEdit {
    background-color: #232629;
    padding: 5px;
-    border: 1px solid #54575B;
+    border-style: solid;
+    border: 1px solid #76797C;
    border-radius: 2px;
    color: #eff0f1;
 }
@@ -298,10 +285,9 @@ QAbstractItemView QLineEdit {
 }

 QGroupBox {
-    border: 1px solid #54575B;
+    border: 1px solid #76797C;
    border-radius: 2px;
-    margin-top: 12px;
-    padding-top: 2px;
+    margin-top: 20px;
 }

 QGroupBox::title {
@@ -309,12 +295,12 @@ QGroupBox::title {
    subcontrol-position: top center;
    padding-left: 10px;
    padding-right: 10px;
-    padding-top: 2px;
+    padding-top: 10px;
 }

 QAbstractScrollArea {
    border-radius: 2px;
-    border: 1px solid #54575B;
+    border: 1px solid #76797C;
    background-color: transparent;
 }

@@ -333,7 +319,7 @@ QScrollBar::handle:horizontal {
 }

 QScrollBar::add-line:horizontal {
-    margin: 0 3px;
+    margin: 0px 3px 0px 3px;
    border-image: url(:/qss_icons/rc/right_arrow_disabled.png);
    width: 10px;
    height: 10px;
@@ -342,7 +328,7 @@ QScrollBar::add-line:horizontal {
 }

 QScrollBar::sub-line:horizontal {
-    margin: 0 3px;
+    margin: 0px 3px 0px 3px;
    border-image: url(:/qss_icons/rc/left_arrow_disabled.png);
    height: 10px;
    width: 10px;
@@ -393,7 +379,7 @@ QScrollBar::handle:vertical {
 }

 QScrollBar::sub-line:vertical {
-    margin: 3px 0;
+    margin: 3px 0px 3px 0px;
    border-image: url(:/qss_icons/rc/up_arrow_disabled.png);
    height: 10px;
    width: 10px;
@@ -402,7 +388,7 @@ QScrollBar::sub-line:vertical {
 }

 QScrollBar::add-line:vertical {
-    margin: 3px 0;
+    margin: 3px 0px 3px 0px;
    border-image: url(:/qss_icons/rc/down_arrow_disabled.png);
    height: 10px;
    width: 10px;
@@ -441,14 +427,15 @@ QScrollBar::sub-page:vertical {
 QTextEdit {
    background-color: #232629;
    color: #eff0f1;
-    border: 1px solid #54575B;
+    border: 1px solid #76797C;
 }

 QPlainTextEdit {
    background-color: #232629;
+    ;
    color: #eff0f1;
    border-radius: 2px;
-    border: 1px solid #54575B;
+    border: 1px solid #76797C;
 }

 QHeaderView::section {
@@ -480,6 +467,15 @@ QMainWindow::separator:hover {
    spacing: 2px;
 }

+QMenu::separator {
+    height: 1px;
+    background-color: #76797C;
+    color: white;
+    padding-left: 4px;
+    margin-left: 10px;
+    margin-right: 5px;
+}
+
 QFrame {
    border-radius: 2px;
    border: 1px solid #76797C;
@@ -522,19 +518,25 @@ QToolButton#qt_toolbar_ext_button {

 QPushButton {
    color: #eff0f1;
+    background-color: #31363b;
    border-width: 1px;
-    border-color: #54575B;
+    border-color: #76797C;
    border-style: solid;
-    padding: 6px 4px;
+    padding: 5px;
    border-radius: 2px;
    outline: none;
-    min-width: 100px;
-    background-color: #232629;
 }

 QPushButton:disabled {
    background-color: #31363b;
+    border-width: 1px;
    border-color: #454545;
+    border-style: solid;
+    padding-top: 5px;
+    padding-bottom: 5px;
+    padding-left: 10px;
+    padding-right: 10px;
+    border-radius: 2px;
    color: #454545;
 }

@@ -551,11 +553,11 @@ QPushButton:pressed {

 QComboBox {
    selection-background-color: #3daee9;
-    border: 1px solid #54575B;
+    border-style: solid;
+    border: 1px solid #76797C;
    border-radius: 2px;
-    padding: 4px 6px;
+    padding: 5px;
    min-width: 75px;
-    background-color: #232629;
 }

 QPushButton:checked {
@@ -569,7 +571,8 @@ QAbstractSpinBox:hover,
 QLineEdit:hover,
 QTextEdit:hover,
 QPlainTextEdit:hover,
-QAbstractView:hover {
+QAbstractView:hover,
+QTreeView:hover {
    border: 1px solid #3daee9;
    color: #eff0f1;
 }
@@ -588,7 +591,6 @@ QComboBox QAbstractItemView {
 QComboBox::drop-down {
    subcontrol-origin: padding;
    subcontrol-position: top right;
-    left: -6px;
    width: 15px;
    border-left-width: 0px;
    border-left-color: darkgray;
@@ -608,8 +610,8 @@ QComboBox::down-arrow:focus {
 }

 QAbstractSpinBox {
-    padding: 4px 6px;
-    border: 1px solid #54575B;
+    padding: 5px;
+    border: 1px solid #76797C;
    background-color: #232629;
    color: #eff0f1;
    border-radius: 2px;
@@ -620,14 +622,12 @@ QAbstractSpinBox:up-button {
    background-color: transparent;
    subcontrol-origin: border;
    subcontrol-position: center right;
-    left: -6px;
 }

 QAbstractSpinBox:down-button {
    background-color: transparent;
    subcontrol-origin: border;
    subcontrol-position: center left;
-    right: -6px;
 }

 QAbstractSpinBox::up-arrow,
@@ -654,27 +654,22 @@ QAbstractSpinBox::down-arrow:hover {
    image: url(:/qss_icons/rc/down_arrow.png);
 }

-QLabel,
-QTabWidget {
-    border: 0;
+QLabel {
+    border: 0px solid black;
 }

 QTabWidget {
-    padding-top: 1px;
+    border: 0px transparent black;
 }

 QTabWidget::pane {
    border: 1px solid #76797C;
    padding: 5px;
-    position: absolute;
-    top: -1px;
-    border-top-right-radius: 2px;
-    border-bottom-right-radius: 2px;
-    border-bottom-left-radius: 2px;
+    margin: 0px;
 }

 QTabWidget::tab-bar {
-    overflow: visible;
+    /* left: 5px; move to the right by 5px */
 }

 QTabBar {
@@ -682,6 +677,10 @@ QTabBar {
    border-radius: 3px;
 }

+QTabBar:focus {
+    border: 0px transparent black;
+}
+
 QTabBar::close-button {
    image: url(:/qss_icons/rc/close.png);
    background: transparent;
@@ -697,33 +696,36 @@ QTabBar::close-button:pressed {
    background: transparent;
 }

+
 /* TOP TABS */
+
 QTabBar::tab:top {
    color: #eff0f1;
-    border: 1px solid #54575B;
-    background-color: #2a2f33;
-    padding: 4px 16px 5px;
-    min-width: 36px;
+    border: 1px solid #76797C;
+    border-bottom: 2px transparent;
+    background-color: #31363b;
+    padding: 4px 16px 2px;
+    min-width: 38px;
    border-top-left-radius: 2px;
    border-top-right-radius: 2px;
 }

 QTabBar::tab:top:selected {
-    border-color: #76797C;
-    background-color: #31363b;
-    border-bottom-color: #31363b;
-}
-
-QTabBar::tab:top:!selected {
-    margin-top: 1px;
-    border-bottom-color: #76797C;
+    color: #eff0f1;
+    background-color: #54575B;
+    border: 1px solid #76797C;
+    border-bottom: 2px solid #3daee9;
+    border-top-left-radius: 2px;
+    border-top-right-radius: 2px;
 }

 QTabBar::tab:top:!selected:hover {
    background-color: #3daee9;
 }

+
 /* BOTTOM TABS */
+
 QTabBar::tab:bottom {
    color: #eff0f1;
    border: 1px solid #76797C;
@@ -748,7 +750,9 @@ QTabBar::tab:bottom:!selected:hover {
    background-color: #3daee9;
 }

+
 /* LEFT TABS */
+
 QTabBar::tab:left {
    color: #eff0f1;
    border: 1px solid #76797C;
@@ -773,7 +777,9 @@ QTabBar::tab:left:!selected:hover {
    background-color: #3daee9;
 }

+
 /* RIGHT TABS */
+
 QTabBar::tab:right {
    color: #eff0f1;
    border: 1px solid #76797C;
@@ -841,7 +847,7 @@ QDockWidget::float-button:pressed {

 QTreeView,
 QListView {
-    border: 1px solid #54575B;
+    border: 1px solid #76797C;
    background-color: #232629;
 }

@@ -972,8 +978,8 @@ QSlider::handle:vertical {
 }

 QToolButton {
-    background-color: #232629;
-    border: 1px solid #54575B;
+    background-color: transparent;
+    border: 1px transparent #76797C;
    border-radius: 2px;
    margin: 3px;
    padding: 5px;
@@ -982,6 +988,7 @@ QToolButton {
 QToolButton[popupMode="1"] {
    /* only for MenuButtonPopup */
    padding-right: 20px;
+    /* make way for the popup button */
    border: 1px #76797C;
    border-radius: 5px;
 }
@@ -989,6 +996,7 @@ QToolButton[popupMode="1"] {
 QToolButton[popupMode="2"] {
    /* only for InstantPopup */
    padding-right: 10px;
+    /* make way for the popup button */
    border: 1px #76797C;
 }

@@ -1007,14 +1015,19 @@ QToolButton::menu-button:pressed {
    padding: 5px;
 }

+
 /* the subcontrol below is used only in the InstantPopup or DelayedPopup mode */
+
 QToolButton::menu-indicator {
    image: url(:/qss_icons/rc/down_arrow.png);
    top: -7px;
    left: -2px;
+    /* shift it a bit */
 }

+
 /* the subcontrols below are used only in the MenuButtonPopup mode */
+
 QToolButton::menu-button {
    border: 1px transparent #76797C;
    border-top-right-radius: 6px;
@@ -1039,22 +1052,14 @@ QPushButton::menu-indicator {
 }

 QTableView {
-    border: 1px solid #54575B;
+    border: 1px solid #76797C;
    gridline-color: #31363b;
    background-color: #232629;
 }

-QTreeView:disabled {
-    background-color: #1f2225;
-}
-
 QTableView,
 QHeaderView {
-    border-radius: 0;
-}
-
-QListView:focus {
-    border-color: #54575B;
+    border-radius: 0px;
 }

 QTableView::item:pressed,
@@ -1083,7 +1088,7 @@ QHeaderView::section {
    background-color: #232629;
    color: #eff0f1;
    padding: 0 5px;
-    border: 1px solid #434242;
+    border: 1px solid #403F3F;
    border-bottom: 0;
    border-radius: 0px;
    text-align: center;
@@ -1113,7 +1118,9 @@ QHeaderView::section:checked {
    background-color: #334e5e;
 }

-/* sort indicator */
+
+/* style the sort indicator */
+
 QHeaderView::down-arrow {
    image: url(:/qss_icons/rc/down_arrow.png);
 }
@@ -1143,13 +1150,14 @@ QToolBox::tab {
 }

 QToolBox::tab:selected {
+    /* italicize selected tabs */
    font: italic;
    background-color: #31363b;
    border-color: #3daee9;
 }

 QStatusBar::item {
-    border: 0;
+    border: 0px transparent dark;
 }

 QFrame[height="3"],
@@ -1186,6 +1194,7 @@ QProgressBar::chunk {

 QDateEdit {
    selection-background-color: #3daee9;
+    border-style: solid;
    border: 1px solid #3375A3;
    border-radius: 2px;
    padding: 1px;
@@ -1209,7 +1218,7 @@ QDateEdit::drop-down {
    subcontrol-origin: padding;
    subcontrol-position: top right;
    width: 15px;
-    border-left-width: 0;
+    border-left-width: 0px;
    border-left-color: darkgray;
    border-left-style: solid;
    border-top-right-radius: 3px;
@@ -1225,14 +1234,3 @@ QDateEdit::down-arrow:hover,
 QDateEdit::down-arrow:focus {
    image: url(:/qss_icons/rc/down_arrow.png);
 }
-
-QComboBox:disabled,
-QPushButton:disabled,
-QAbstractSpinBox:disabled,
-QDateEdit:disabled,
-QLineEdit:disabled,
-QTextEdit:disabled,
-QToolButton:disabled,
-QPlainTextEdit:disabled {
-    background-color: #2b2e31;
-}
@@ -120,7 +120,7 @@ private:
            duration_cast<std::chrono::microseconds>(steady_clock::now() - time_origin);
        entry.log_class = log_class;
        entry.log_level = log_level;
-        entry.filename = filename;
+        entry.filename = Common::TrimSourcePath(filename);
        entry.line_num = line_nr;
        entry.function = function;
        entry.message = std::move(message);
@@ -23,7 +23,7 @@ struct Entry {
    std::chrono::microseconds timestamp;
    Class log_class;
    Level log_level;
-    const char* filename;
+    std::string filename;
    unsigned int line_num;
    std::string function;
    std::string message;
@@ -9,15 +9,6 @@

 namespace Log {

-// trims up to and including the last of ../, ..\, src/, src\ in a string
-constexpr const char* TrimSourcePath(std::string_view source) {
-    const auto rfind = [source](const std::string_view match) {
-        return source.rfind(match) == source.npos ? 0 : (source.rfind(match) + match.size());
-    };
-    auto idx = std::max({rfind("src/"), rfind("src\\"), rfind("../"), rfind("..\\")});
-    return source.data() + idx;
-}
-
 /// Specifies the severity or level of detail of the log message.
 enum class Level : u8 {
    Trace,    ///< Extremely detailed and repetitive debugging information that is likely to
@@ -150,24 +141,24 @@ void FmtLogMessage(Class log_class, Level log_level, const char* filename, unsig

 #ifdef _DEBUG
 #define LOG_TRACE(log_class, ...)                                                                  \
-    ::Log::FmtLogMessage(::Log::Class::log_class, ::Log::Level::Trace,                             \
-                         ::Log::TrimSourcePath(__FILE__), __LINE__, __func__, __VA_ARGS__)
+    ::Log::FmtLogMessage(::Log::Class::log_class, ::Log::Level::Trace, __FILE__, __LINE__,         \
+                         __func__, __VA_ARGS__)
 #else
 #define LOG_TRACE(log_class, fmt, ...) (void(0))
 #endif

 #define LOG_DEBUG(log_class, ...)                                                                  \
-    ::Log::FmtLogMessage(::Log::Class::log_class, ::Log::Level::Debug,                             \
-                         ::Log::TrimSourcePath(__FILE__), __LINE__, __func__, __VA_ARGS__)
+    ::Log::FmtLogMessage(::Log::Class::log_class, ::Log::Level::Debug, __FILE__, __LINE__,         \
+                         __func__, __VA_ARGS__)
 #define LOG_INFO(log_class, ...)                                                                   \
-    ::Log::FmtLogMessage(::Log::Class::log_class, ::Log::Level::Info,                              \
-                         ::Log::TrimSourcePath(__FILE__), __LINE__, __func__, __VA_ARGS__)
+    ::Log::FmtLogMessage(::Log::Class::log_class, ::Log::Level::Info, __FILE__, __LINE__,          \
+                         __func__, __VA_ARGS__)
 #define LOG_WARNING(log_class, ...)                                                                \
-    ::Log::FmtLogMessage(::Log::Class::log_class, ::Log::Level::Warning,                           \
-                         ::Log::TrimSourcePath(__FILE__), __LINE__, __func__, __VA_ARGS__)
+    ::Log::FmtLogMessage(::Log::Class::log_class, ::Log::Level::Warning, __FILE__, __LINE__,       \
+                         __func__, __VA_ARGS__)
 #define LOG_ERROR(log_class, ...)                                                                  \
-    ::Log::FmtLogMessage(::Log::Class::log_class, ::Log::Level::Error,                             \
-                         ::Log::TrimSourcePath(__FILE__), __LINE__, __func__, __VA_ARGS__)
+    ::Log::FmtLogMessage(::Log::Class::log_class, ::Log::Level::Error, __FILE__, __LINE__,         \
+                         __func__, __VA_ARGS__)
 #define LOG_CRITICAL(log_class, ...)                                                               \
-    ::Log::FmtLogMessage(::Log::Class::log_class, ::Log::Level::Critical,                          \
-                         ::Log::TrimSourcePath(__FILE__), __LINE__, __func__, __VA_ARGS__)
+    ::Log::FmtLogMessage(::Log::Class::log_class, ::Log::Level::Critical, __FILE__, __LINE__,      \
+                         __func__, __VA_ARGS__)
@@ -223,4 +223,26 @@ std::u16string UTF16StringFromFixedZeroTerminatedBuffer(std::u16string_view buff
    return std::u16string(buffer.begin(), buffer.begin() + len);
 }

+const char* TrimSourcePath(const char* path, const char* root) {
+    const char* p = path;
+
+    while (*p != '\0') {
+        const char* next_slash = p;
+        while (*next_slash != '\0' && *next_slash != '/' && *next_slash != '\\') {
+            ++next_slash;
+        }
+
+        bool is_src = Common::ComparePartialString(p, next_slash, root);
+        p = next_slash;
+
+        if (*p != '\0') {
+            ++p;
+        }
+        if (is_src) {
+            path = p;
+        }
+    }
+    return path;
+}
+
 } // namespace Common
@@ -15,14 +15,14 @@ add_library(core STATIC
    constants.h
    core.cpp
    core.h
-    core_cpu.cpp
-    core_cpu.h
+    core_manager.cpp
+    core_manager.h
    core_timing.cpp
    core_timing.h
    core_timing_util.cpp
    core_timing_util.h
-    cpu_core_manager.cpp
-    cpu_core_manager.h
+    cpu_manager.cpp
+    cpu_manager.h
    crypto/aes_util.cpp
    crypto/aes_util.h
    crypto/encryption_layer.cpp
@@ -158,6 +158,8 @@ add_library(core STATIC
    hle/kernel/mutex.h
    hle/kernel/object.cpp
    hle/kernel/object.h
+    hle/kernel/physical_core.cpp
+    hle/kernel/physical_core.h
    hle/kernel/process.cpp
    hle/kernel/process.h
    hle/kernel/process_capability.cpp
@@ -10,7 +10,7 @@
 #include "common/microprofile.h"
 #include "core/arm/dynarmic/arm_dynarmic.h"
 #include "core/core.h"
-#include "core/core_cpu.h"
+#include "core/core_manager.h"
 #include "core/core_timing.h"
 #include "core/core_timing_util.h"
 #include "core/gdbstub/gdbstub.h"
@@ -2,10 +2,24 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.

+#ifdef ARCHITECTURE_x86_64
+#include "core/arm/dynarmic/arm_dynarmic.h"
+#endif
 #include "core/arm/exclusive_monitor.h"
+#include "core/memory.h"

 namespace Core {

 ExclusiveMonitor::~ExclusiveMonitor() = default;

+std::unique_ptr<Core::ExclusiveMonitor> MakeExclusiveMonitor(Memory::Memory& memory,
+                                                             std::size_t num_cores) {
+#ifdef ARCHITECTURE_x86_64
+    return std::make_unique<Core::DynarmicExclusiveMonitor>(memory, num_cores);
+#else
+    // TODO(merry): Passthrough exclusive monitor
+    return nullptr;
+#endif
+}
+
 } // namespace Core
@@ -4,8 +4,14 @@

 #pragma once

+#include <memory>
+
 #include "common/common_types.h"

+namespace Memory {
+class Memory;
+}
+
 namespace Core {

 class ExclusiveMonitor {
@@ -22,4 +28,7 @@ public:
    virtual bool ExclusiveWrite128(std::size_t core_index, VAddr vaddr, u128 value) = 0;
 };

+std::unique_ptr<Core::ExclusiveMonitor> MakeExclusiveMonitor(Memory::Memory& memory,
+                                                             std::size_t num_cores);
+
 } // namespace Core
@@ -11,9 +11,9 @@
 #include "common/string_util.h"
 #include "core/arm/exclusive_monitor.h"
 #include "core/core.h"
-#include "core/core_cpu.h"
+#include "core/core_manager.h"
 #include "core/core_timing.h"
-#include "core/cpu_core_manager.h"
+#include "core/cpu_manager.h"
 #include "core/file_sys/bis_factory.h"
 #include "core/file_sys/card_image.h"
 #include "core/file_sys/mode.h"
@@ -28,6 +28,7 @@
 #include "core/hardware_interrupt_manager.h"
 #include "core/hle/kernel/client_port.h"
 #include "core/hle/kernel/kernel.h"
+#include "core/hle/kernel/physical_core.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/scheduler.h"
 #include "core/hle/kernel/thread.h"
@@ -113,16 +114,25 @@ FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,
 struct System::Impl {
    explicit Impl(System& system)
        : kernel{system}, fs_controller{system}, memory{system},
-          cpu_core_manager{system}, reporter{system}, applet_manager{system} {}
+          cpu_manager{system}, reporter{system}, applet_manager{system} {}

-    Cpu& CurrentCpuCore() {
-        return cpu_core_manager.GetCurrentCore();
+    CoreManager& CurrentCoreManager() {
+        return cpu_manager.GetCurrentCoreManager();
+    }
+
+    Kernel::PhysicalCore& CurrentPhysicalCore() {
+        const auto index = cpu_manager.GetActiveCoreIndex();
+        return kernel.PhysicalCore(index);
+    }
+
+    Kernel::PhysicalCore& GetPhysicalCore(std::size_t index) {
+        return kernel.PhysicalCore(index);
    }

    ResultStatus RunLoop(bool tight_loop) {
        status = ResultStatus::Success;

-        cpu_core_manager.RunLoop(tight_loop);
+        cpu_manager.RunLoop(tight_loop);

        return status;
    }
@@ -131,8 +141,8 @@ struct System::Impl {
        LOG_DEBUG(HW_Memory, "initialized OK");

        core_timing.Initialize();
-        cpu_core_manager.Initialize();
        kernel.Initialize();
+        cpu_manager.Initialize();

        const auto current_time = std::chrono::duration_cast<std::chrono::seconds>(
            std::chrono::system_clock::now().time_since_epoch());
@@ -205,7 +215,6 @@ struct System::Impl {
        // Main process has been loaded and been made current.
        // Begin GPU and CPU execution.
        gpu_core->Start();
-        cpu_core_manager.StartThreads();

        // Initialize cheat engine
        if (cheat_engine) {
@@ -259,9 +268,7 @@ struct System::Impl {
        is_powered_on = false;
        exit_lock = false;

-        if (gpu_core) {
-            gpu_core->WaitIdle();
-        }
+        gpu_core->WaitIdle();

        // Shutdown emulation session
        renderer.reset();
@@ -274,7 +281,7 @@ struct System::Impl {
        gpu_core.reset();

        // Close all CPU/threading state
-        cpu_core_manager.Shutdown();
+        cpu_manager.Shutdown();

        // Shutdown kernel and core timing
        kernel.Shutdown();
@@ -344,7 +351,7 @@ struct System::Impl {
    std::unique_ptr<Tegra::GPU> gpu_core;
    std::unique_ptr<Hardware::InterruptManager> interrupt_manager;
    Memory::Memory memory;
-    CpuCoreManager cpu_core_manager;
+    CpuManager cpu_manager;
    bool is_powered_on = false;
    bool exit_lock = false;

@@ -379,12 +386,12 @@ struct System::Impl {
 System::System() : impl{std::make_unique<Impl>(*this)} {}
 System::~System() = default;

-Cpu& System::CurrentCpuCore() {
-    return impl->CurrentCpuCore();
+CoreManager& System::CurrentCoreManager() {
+    return impl->CurrentCoreManager();
 }

-const Cpu& System::CurrentCpuCore() const {
-    return impl->CurrentCpuCore();
+const CoreManager& System::CurrentCoreManager() const {
+    return impl->CurrentCoreManager();
 }

 System::ResultStatus System::RunLoop(bool tight_loop) {
@@ -396,7 +403,7 @@ System::ResultStatus System::SingleStep() {
 }

 void System::InvalidateCpuInstructionCaches() {
-    impl->cpu_core_manager.InvalidateAllInstructionCaches();
+    impl->kernel.InvalidateAllInstructionCaches();
 }

 System::ResultStatus System::Load(Frontend::EmuWindow& emu_window, const std::string& filepath) {
@@ -408,13 +415,11 @@ bool System::IsPoweredOn() const {
 }

 void System::PrepareReschedule() {
-    CurrentCpuCore().PrepareReschedule();
+    impl->CurrentPhysicalCore().Stop();
 }

 void System::PrepareReschedule(const u32 core_index) {
-    if (core_index < GlobalScheduler().CpuCoresCount()) {
-        CpuCore(core_index).PrepareReschedule();
-    }
+    impl->kernel.PrepareReschedule(core_index);
 }

 PerfStatsResults System::GetAndResetPerfStats() {
@@ -430,31 +435,31 @@ const TelemetrySession& System::TelemetrySession() const {
 }

 ARM_Interface& System::CurrentArmInterface() {
-    return CurrentCpuCore().ArmInterface();
+    return impl->CurrentPhysicalCore().ArmInterface();
 }

 const ARM_Interface& System::CurrentArmInterface() const {
-    return CurrentCpuCore().ArmInterface();
+    return impl->CurrentPhysicalCore().ArmInterface();
 }

 std::size_t System::CurrentCoreIndex() const {
-    return CurrentCpuCore().CoreIndex();
+    return impl->cpu_manager.GetActiveCoreIndex();
 }

 Kernel::Scheduler& System::CurrentScheduler() {
-    return CurrentCpuCore().Scheduler();
+    return impl->CurrentPhysicalCore().Scheduler();
 }

 const Kernel::Scheduler& System::CurrentScheduler() const {
-    return CurrentCpuCore().Scheduler();
+    return impl->CurrentPhysicalCore().Scheduler();
 }

 Kernel::Scheduler& System::Scheduler(std::size_t core_index) {
-    return CpuCore(core_index).Scheduler();
+    return impl->GetPhysicalCore(core_index).Scheduler();
 }

 const Kernel::Scheduler& System::Scheduler(std::size_t core_index) const {
-    return CpuCore(core_index).Scheduler();
+    return impl->GetPhysicalCore(core_index).Scheduler();
 }

 /// Gets the global scheduler
@@ -476,28 +481,28 @@ const Kernel::Process* System::CurrentProcess() const {
 }

 ARM_Interface& System::ArmInterface(std::size_t core_index) {
-    return CpuCore(core_index).ArmInterface();
+    return impl->GetPhysicalCore(core_index).ArmInterface();
 }

 const ARM_Interface& System::ArmInterface(std::size_t core_index) const {
-    return CpuCore(core_index).ArmInterface();
+    return impl->GetPhysicalCore(core_index).ArmInterface();
 }

-Cpu& System::CpuCore(std::size_t core_index) {
-    return impl->cpu_core_manager.GetCore(core_index);
+CoreManager& System::GetCoreManager(std::size_t core_index) {
+    return impl->cpu_manager.GetCoreManager(core_index);
 }

-const Cpu& System::CpuCore(std::size_t core_index) const {
+const CoreManager& System::GetCoreManager(std::size_t core_index) const {
    ASSERT(core_index < NUM_CPU_CORES);
-    return impl->cpu_core_manager.GetCore(core_index);
+    return impl->cpu_manager.GetCoreManager(core_index);
 }

 ExclusiveMonitor& System::Monitor() {
-    return impl->cpu_core_manager.GetExclusiveMonitor();
+    return impl->kernel.GetExclusiveMonitor();
 }

 const ExclusiveMonitor& System::Monitor() const {
-    return impl->cpu_core_manager.GetExclusiveMonitor();
+    return impl->kernel.GetExclusiveMonitor();
 }

 Memory::Memory& System::Memory() {
@@ -93,7 +93,7 @@ class Memory;
 namespace Core {

 class ARM_Interface;
-class Cpu;
+class CoreManager;
 class ExclusiveMonitor;
 class FrameLimiter;
 class PerfStats;
@@ -218,10 +218,10 @@ public:
    const ARM_Interface& ArmInterface(std::size_t core_index) const;

    /// Gets a CPU interface to the CPU core with the specified index
-    Cpu& CpuCore(std::size_t core_index);
+    CoreManager& GetCoreManager(std::size_t core_index);

    /// Gets a CPU interface to the CPU core with the specified index
-    const Cpu& CpuCore(std::size_t core_index) const;
+    const CoreManager& GetCoreManager(std::size_t core_index) const;

    /// Gets a reference to the exclusive monitor
    ExclusiveMonitor& Monitor();
@@ -364,10 +364,10 @@ private:
    System();

    /// Returns the currently running CPU core
-    Cpu& CurrentCpuCore();
+    CoreManager& CurrentCoreManager();

    /// Returns the currently running CPU core
-    const Cpu& CurrentCpuCore() const;
+    const CoreManager& CurrentCoreManager() const;

    /**
     * Initialize the emulated system.
@@ -1,127 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <condition_variable>
-#include <mutex>
-
-#include "common/logging/log.h"
-#ifdef ARCHITECTURE_x86_64
-#include "core/arm/dynarmic/arm_dynarmic.h"
-#endif
-#include "core/arm/exclusive_monitor.h"
-#include "core/arm/unicorn/arm_unicorn.h"
-#include "core/core.h"
-#include "core/core_cpu.h"
-#include "core/core_timing.h"
-#include "core/hle/kernel/scheduler.h"
-#include "core/hle/kernel/thread.h"
-#include "core/hle/lock.h"
-#include "core/settings.h"
-
-namespace Core {
-
-void CpuBarrier::NotifyEnd() {
-    std::unique_lock lock{mutex};
-    end = true;
-    condition.notify_all();
-}
-
-bool CpuBarrier::Rendezvous() {
-    if (!Settings::values.use_multi_core) {
-        // Meaningless when running in single-core mode
-        return true;
-    }
-
-    if (!end) {
-        std::unique_lock lock{mutex};
-
-        --cores_waiting;
-        if (!cores_waiting) {
-            cores_waiting = NUM_CPU_CORES;
-            condition.notify_all();
-            return true;
-        }
-
-        condition.wait(lock);
-        return true;
-    }
-
-    return false;
-}
-
-Cpu::Cpu(System& system, ExclusiveMonitor& exclusive_monitor, CpuBarrier& cpu_barrier,
-         std::size_t core_index)
-    : cpu_barrier{cpu_barrier}, global_scheduler{system.GlobalScheduler()},
-      core_timing{system.CoreTiming()}, core_index{core_index} {
-#ifdef ARCHITECTURE_x86_64
-    arm_interface = std::make_unique<ARM_Dynarmic>(system, exclusive_monitor, core_index);
-#else
-    arm_interface = std::make_unique<ARM_Unicorn>(system);
-    LOG_WARNING(Core, "CPU JIT requested, but Dynarmic not available");
-#endif
-
-    scheduler = std::make_unique<Kernel::Scheduler>(system, *arm_interface, core_index);
-}
-
-Cpu::~Cpu() = default;
-
-std::unique_ptr<ExclusiveMonitor> Cpu::MakeExclusiveMonitor(
-    [[maybe_unused]] Memory::Memory& memory, [[maybe_unused]] std::size_t num_cores) {
-#ifdef ARCHITECTURE_x86_64
-    return std::make_unique<DynarmicExclusiveMonitor>(memory, num_cores);
-#else
-    // TODO(merry): Passthrough exclusive monitor
-    return nullptr;
-#endif
-}
-
-void Cpu::RunLoop(bool tight_loop) {
-    // Wait for all other CPU cores to complete the previous slice, such that they run in lock-step
-    if (!cpu_barrier.Rendezvous()) {
-        // If rendezvous failed, session has been killed
-        return;
-    }
-
-    Reschedule();
-
-    // If we don't have a currently active thread then don't execute instructions,
-    // instead advance to the next event and try to yield to the next thread
-    if (Kernel::GetCurrentThread() == nullptr) {
-        LOG_TRACE(Core, "Core-{} idling", core_index);
-        core_timing.Idle();
-    } else {
-        if (tight_loop) {
-            arm_interface->Run();
-        } else {
-            arm_interface->Step();
-        }
-        // We are stopping a run, exclusive state must be cleared
-        arm_interface->ClearExclusiveState();
-    }
-    core_timing.Advance();
-
-    Reschedule();
-}
-
-void Cpu::SingleStep() {
-    return RunLoop(false);
-}
-
-void Cpu::PrepareReschedule() {
-    arm_interface->PrepareReschedule();
-}
-
-void Cpu::Reschedule() {
-    // Lock the global kernel mutex when we manipulate the HLE state
-    std::lock_guard lock(HLE::g_hle_lock);
-
-    global_scheduler.SelectThread(core_index);
-    scheduler->TryDoContextSwitch();
-}
-
-void Cpu::Shutdown() {
-    scheduler->Shutdown();
-}
-
-} // namespace Core
@@ -1,120 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <atomic>
-#include <condition_variable>
-#include <cstddef>
-#include <memory>
-#include <mutex>
-#include "common/common_types.h"
-
-namespace Kernel {
-class GlobalScheduler;
-class Scheduler;
-} // namespace Kernel
-
-namespace Core {
-class System;
-}
-
-namespace Core::Timing {
-class CoreTiming;
-}
-
-namespace Memory {
-class Memory;
-}
-
-namespace Core {
-
-class ARM_Interface;
-class ExclusiveMonitor;
-
-constexpr unsigned NUM_CPU_CORES{4};
-
-class CpuBarrier {
-public:
-    bool IsAlive() const {
-        return !end;
-    }
-
-    void NotifyEnd();
-
-    bool Rendezvous();
-
-private:
-    unsigned cores_waiting{NUM_CPU_CORES};
-    std::mutex mutex;
-    std::condition_variable condition;
-    std::atomic<bool> end{};
-};
-
-class Cpu {
-public:
-    Cpu(System& system, ExclusiveMonitor& exclusive_monitor, CpuBarrier& cpu_barrier,
-        std::size_t core_index);
-    ~Cpu();
-
-    void RunLoop(bool tight_loop = true);
-
-    void SingleStep();
-
-    void PrepareReschedule();
-
-    ARM_Interface& ArmInterface() {
-        return *arm_interface;
-    }
-
-    const ARM_Interface& ArmInterface() const {
-        return *arm_interface;
-    }
-
-    Kernel::Scheduler& Scheduler() {
-        return *scheduler;
-    }
-
-    const Kernel::Scheduler& Scheduler() const {
-        return *scheduler;
-    }
-
-    bool IsMainCore() const {
-        return core_index == 0;
-    }
-
-    std::size_t CoreIndex() const {
-        return core_index;
-    }
-
-    void Shutdown();
-
-    /**
-     * Creates an exclusive monitor to handle exclusive reads/writes.
-     *
-     * @param memory The current memory subsystem that the monitor may wish
-     *               to keep track of.
-     *
-     * @param num_cores The number of cores to assume about the CPU.
-     *
-     * @returns The constructed exclusive monitor instance, or nullptr if the current
-     *          CPU backend is unable to use an exclusive monitor.
-     */
-    static std::unique_ptr<ExclusiveMonitor> MakeExclusiveMonitor(Memory::Memory& memory,
-                                                                  std::size_t num_cores);
-
-private:
-    void Reschedule();
-
-    std::unique_ptr<ARM_Interface> arm_interface;
-    CpuBarrier& cpu_barrier;
-    Kernel::GlobalScheduler& global_scheduler;
-    std::unique_ptr<Kernel::Scheduler> scheduler;
-    Timing::CoreTiming& core_timing;
-
-    std::atomic<bool> reschedule_pending = false;
-    std::size_t core_index;
-};
-
-} // namespace Core
@@ -0,0 +1,70 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <condition_variable>
+#include <mutex>
+
+#include "common/logging/log.h"
+#ifdef ARCHITECTURE_x86_64
+#include "core/arm/dynarmic/arm_dynarmic.h"
+#endif
+#include "core/arm/exclusive_monitor.h"
+#include "core/arm/unicorn/arm_unicorn.h"
+#include "core/core.h"
+#include "core/core_manager.h"
+#include "core/core_timing.h"
+#include "core/hle/kernel/kernel.h"
+#include "core/hle/kernel/physical_core.h"
+#include "core/hle/kernel/scheduler.h"
+#include "core/hle/kernel/thread.h"
+#include "core/hle/lock.h"
+#include "core/settings.h"
+
+namespace Core {
+
+CoreManager::CoreManager(System& system, std::size_t core_index)
+    : global_scheduler{system.GlobalScheduler()}, physical_core{system.Kernel().PhysicalCore(
+                                                      core_index)},
+      core_timing{system.CoreTiming()}, core_index{core_index} {}
+
+CoreManager::~CoreManager() = default;
+
+void CoreManager::RunLoop(bool tight_loop) {
+    Reschedule();
+
+    // If we don't have a currently active thread then don't execute instructions,
+    // instead advance to the next event and try to yield to the next thread
+    if (Kernel::GetCurrentThread() == nullptr) {
+        LOG_TRACE(Core, "Core-{} idling", core_index);
+        core_timing.Idle();
+    } else {
+        if (tight_loop) {
+            physical_core.Run();
+        } else {
+            physical_core.Step();
+        }
+    }
+    core_timing.Advance();
+
+    Reschedule();
+}
+
+void CoreManager::SingleStep() {
+    return RunLoop(false);
+}
+
+void CoreManager::PrepareReschedule() {
+    physical_core.Stop();
+}
+
+void CoreManager::Reschedule() {
+    // Lock the global kernel mutex when we manipulate the HLE state
+    std::lock_guard lock(HLE::g_hle_lock);
+
+    global_scheduler.SelectThread(core_index);
+
+    physical_core.Scheduler().TryDoContextSwitch();
+}
+
+} // namespace Core
@@ -0,0 +1,63 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <atomic>
+#include <cstddef>
+#include <memory>
+#include "common/common_types.h"
+
+namespace Kernel {
+class GlobalScheduler;
+class PhysicalCore;
+} // namespace Kernel
+
+namespace Core {
+class System;
+}
+
+namespace Core::Timing {
+class CoreTiming;
+}
+
+namespace Memory {
+class Memory;
+}
+
+namespace Core {
+
+constexpr unsigned NUM_CPU_CORES{4};
+
+class CoreManager {
+public:
+    CoreManager(System& system, std::size_t core_index);
+    ~CoreManager();
+
+    void RunLoop(bool tight_loop = true);
+
+    void SingleStep();
+
+    void PrepareReschedule();
+
+    bool IsMainCore() const {
+        return core_index == 0;
+    }
+
+    std::size_t CoreIndex() const {
+        return core_index;
+    }
+
+private:
+    void Reschedule();
+
+    Kernel::GlobalScheduler& global_scheduler;
+    Kernel::PhysicalCore& physical_core;
+    Timing::CoreTiming& core_timing;
+
+    std::atomic<bool> reschedule_pending = false;
+    std::size_t core_index;
+};
+
+} // namespace Core
@@ -1,152 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "common/assert.h"
-#include "core/arm/exclusive_monitor.h"
-#include "core/core.h"
-#include "core/core_cpu.h"
-#include "core/core_timing.h"
-#include "core/cpu_core_manager.h"
-#include "core/gdbstub/gdbstub.h"
-#include "core/settings.h"
-
-namespace Core {
-namespace {
-void RunCpuCore(const System& system, Cpu& cpu_state) {
-    while (system.IsPoweredOn()) {
-        cpu_state.RunLoop(true);
-    }
-}
-} // Anonymous namespace
-
-CpuCoreManager::CpuCoreManager(System& system) : system{system} {}
-CpuCoreManager::~CpuCoreManager() = default;
-
-void CpuCoreManager::Initialize() {
-    barrier = std::make_unique<CpuBarrier>();
-    exclusive_monitor = Cpu::MakeExclusiveMonitor(system.Memory(), cores.size());
-
-    for (std::size_t index = 0; index < cores.size(); ++index) {
-        cores[index] = std::make_unique<Cpu>(system, *exclusive_monitor, *barrier, index);
-    }
-}
-
-void CpuCoreManager::StartThreads() {
-    // Create threads for CPU cores 1-3, and build thread_to_cpu map
-    // CPU core 0 is run on the main thread
-    thread_to_cpu[std::this_thread::get_id()] = cores[0].get();
-    if (!Settings::values.use_multi_core) {
-        return;
-    }
-
-    for (std::size_t index = 0; index < core_threads.size(); ++index) {
-        core_threads[index] = std::make_unique<std::thread>(RunCpuCore, std::cref(system),
-                                                            std::ref(*cores[index + 1]));
-        thread_to_cpu[core_threads[index]->get_id()] = cores[index + 1].get();
-    }
-}
-
-void CpuCoreManager::Shutdown() {
-    barrier->NotifyEnd();
-    if (Settings::values.use_multi_core) {
-        for (auto& thread : core_threads) {
-            thread->join();
-            thread.reset();
-        }
-    }
-
-    thread_to_cpu.clear();
-    for (auto& cpu_core : cores) {
-        cpu_core->Shutdown();
-        cpu_core.reset();
-    }
-
-    exclusive_monitor.reset();
-    barrier.reset();
-}
-
-Cpu& CpuCoreManager::GetCore(std::size_t index) {
-    return *cores.at(index);
-}
-
-const Cpu& CpuCoreManager::GetCore(std::size_t index) const {
-    return *cores.at(index);
-}
-
-ExclusiveMonitor& CpuCoreManager::GetExclusiveMonitor() {
-    return *exclusive_monitor;
-}
-
-const ExclusiveMonitor& CpuCoreManager::GetExclusiveMonitor() const {
-    return *exclusive_monitor;
-}
-
-Cpu& CpuCoreManager::GetCurrentCore() {
-    if (Settings::values.use_multi_core) {
-        const auto& search = thread_to_cpu.find(std::this_thread::get_id());
-        ASSERT(search != thread_to_cpu.end());
-        ASSERT(search->second);
-        return *search->second;
-    }
-
-    // Otherwise, use single-threaded mode active_core variable
-    return *cores[active_core];
-}
-
-const Cpu& CpuCoreManager::GetCurrentCore() const {
-    if (Settings::values.use_multi_core) {
-        const auto& search = thread_to_cpu.find(std::this_thread::get_id());
-        ASSERT(search != thread_to_cpu.end());
-        ASSERT(search->second);
-        return *search->second;
-    }
-
-    // Otherwise, use single-threaded mode active_core variable
-    return *cores[active_core];
-}
-
-void CpuCoreManager::RunLoop(bool tight_loop) {
-    // Update thread_to_cpu in case Core 0 is run from a different host thread
-    thread_to_cpu[std::this_thread::get_id()] = cores[0].get();
-
-    if (GDBStub::IsServerEnabled()) {
-        GDBStub::HandlePacket();
-
-        // If the loop is halted and we want to step, use a tiny (1) number of instructions to
-        // execute. Otherwise, get out of the loop function.
-        if (GDBStub::GetCpuHaltFlag()) {
-            if (GDBStub::GetCpuStepFlag()) {
-                tight_loop = false;
-            } else {
-                return;
-            }
-        }
-    }
-
-    auto& core_timing = system.CoreTiming();
-    core_timing.ResetRun();
-    bool keep_running{};
-    do {
-        keep_running = false;
-        for (active_core = 0; active_core < NUM_CPU_CORES; ++active_core) {
-            core_timing.SwitchContext(active_core);
-            if (core_timing.CanCurrentContextRun()) {
-                cores[active_core]->RunLoop(tight_loop);
-            }
-            keep_running |= core_timing.CanCurrentContextRun();
-        }
-    } while (keep_running);
-
-    if (GDBStub::IsServerEnabled()) {
-        GDBStub::SetCpuStepFlag(false);
-    }
-}
-
-void CpuCoreManager::InvalidateAllInstructionCaches() {
-    for (auto& cpu : cores) {
-        cpu->ArmInterface().ClearInstructionCache();
-    }
-}
-
-} // namespace Core
@@ -1,62 +0,0 @@
-// Copyright 2018 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <array>
-#include <map>
-#include <memory>
-#include <thread>
-
-namespace Core {
-
-class Cpu;
-class CpuBarrier;
-class ExclusiveMonitor;
-class System;
-
-class CpuCoreManager {
-public:
-    explicit CpuCoreManager(System& system);
-    CpuCoreManager(const CpuCoreManager&) = delete;
-    CpuCoreManager(CpuCoreManager&&) = delete;
-
-    ~CpuCoreManager();
-
-    CpuCoreManager& operator=(const CpuCoreManager&) = delete;
-    CpuCoreManager& operator=(CpuCoreManager&&) = delete;
-
-    void Initialize();
-    void StartThreads();
-    void Shutdown();
-
-    Cpu& GetCore(std::size_t index);
-    const Cpu& GetCore(std::size_t index) const;
-
-    Cpu& GetCurrentCore();
-    const Cpu& GetCurrentCore() const;
-
-    ExclusiveMonitor& GetExclusiveMonitor();
-    const ExclusiveMonitor& GetExclusiveMonitor() const;
-
-    void RunLoop(bool tight_loop);
-
-    void InvalidateAllInstructionCaches();
-
-private:
-    static constexpr std::size_t NUM_CPU_CORES = 4;
-
-    std::unique_ptr<ExclusiveMonitor> exclusive_monitor;
-    std::unique_ptr<CpuBarrier> barrier;
-    std::array<std::unique_ptr<Cpu>, NUM_CPU_CORES> cores;
-    std::array<std::unique_ptr<std::thread>, NUM_CPU_CORES - 1> core_threads;
-    std::size_t active_core{}; ///< Active core, only used in single thread mode
-
-    /// Map of guest threads to CPU cores
-    std::map<std::thread::id, Cpu*> thread_to_cpu;
-
-    System& system;
-};
-
-} // namespace Core
@@ -0,0 +1,83 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "common/assert.h"
+#include "core/arm/exclusive_monitor.h"
+#include "core/core.h"
+#include "core/core_manager.h"
+#include "core/core_timing.h"
+#include "core/cpu_manager.h"
+#include "core/gdbstub/gdbstub.h"
+#include "core/settings.h"
+
+namespace Core {
+
+CpuManager::CpuManager(System& system) : system{system} {}
+CpuManager::~CpuManager() = default;
+
+void CpuManager::Initialize() {
+    for (std::size_t index = 0; index < core_managers.size(); ++index) {
+        core_managers[index] = std::make_unique<CoreManager>(system, index);
+    }
+}
+
+void CpuManager::Shutdown() {
+    for (auto& cpu_core : core_managers) {
+        cpu_core.reset();
+    }
+}
+
+CoreManager& CpuManager::GetCoreManager(std::size_t index) {
+    return *core_managers.at(index);
+}
+
+const CoreManager& CpuManager::GetCoreManager(std::size_t index) const {
+    return *core_managers.at(index);
+}
+
+CoreManager& CpuManager::GetCurrentCoreManager() {
+    // Otherwise, use single-threaded mode active_core variable
+    return *core_managers[active_core];
+}
+
+const CoreManager& CpuManager::GetCurrentCoreManager() const {
+    // Otherwise, use single-threaded mode active_core variable
+    return *core_managers[active_core];
+}
+
+void CpuManager::RunLoop(bool tight_loop) {
+    if (GDBStub::IsServerEnabled()) {
+        GDBStub::HandlePacket();
+
+        // If the loop is halted and we want to step, use a tiny (1) number of instructions to
+        // execute. Otherwise, get out of the loop function.
+        if (GDBStub::GetCpuHaltFlag()) {
+            if (GDBStub::GetCpuStepFlag()) {
+                tight_loop = false;
+            } else {
+                return;
+            }
+        }
+    }
+
+    auto& core_timing = system.CoreTiming();
+    core_timing.ResetRun();
+    bool keep_running{};
+    do {
+        keep_running = false;
+        for (active_core = 0; active_core < NUM_CPU_CORES; ++active_core) {
+            core_timing.SwitchContext(active_core);
+            if (core_timing.CanCurrentContextRun()) {
+                core_managers[active_core]->RunLoop(tight_loop);
+            }
+            keep_running |= core_timing.CanCurrentContextRun();
+        }
+    } while (keep_running);
+
+    if (GDBStub::IsServerEnabled()) {
+        GDBStub::SetCpuStepFlag(false);
+    }
+}
+
+} // namespace Core
@@ -0,0 +1,50 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <array>
+#include <memory>
+
+namespace Core {
+
+class CoreManager;
+class System;
+
+class CpuManager {
+public:
+    explicit CpuManager(System& system);
+    CpuManager(const CpuManager&) = delete;
+    CpuManager(CpuManager&&) = delete;
+
+    ~CpuManager();
+
+    CpuManager& operator=(const CpuManager&) = delete;
+    CpuManager& operator=(CpuManager&&) = delete;
+
+    void Initialize();
+    void Shutdown();
+
+    CoreManager& GetCoreManager(std::size_t index);
+    const CoreManager& GetCoreManager(std::size_t index) const;
+
+    CoreManager& GetCurrentCoreManager();
+    const CoreManager& GetCurrentCoreManager() const;
+
+    std::size_t GetActiveCoreIndex() const {
+        return active_core;
+    }
+
+    void RunLoop(bool tight_loop);
+
+private:
+    static constexpr std::size_t NUM_CPU_CORES = 4;
+
+    std::array<std::unique_ptr<CoreManager>, NUM_CPU_CORES> core_managers;
+    std::size_t active_core{}; ///< Active core, only used in single thread mode
+
+    System& system;
+};
+
+} // namespace Core
@@ -75,13 +75,6 @@ public:
        return nullptr;
    }

-    /// Returns if window is shown (not minimized)
-    virtual bool IsShown() const = 0;
-
-    /// Retrieves Vulkan specific handlers from the window
-    virtual void RetrieveVulkanHandlers(void* get_instance_proc_addr, void* instance,
-                                        void* surface) const = 0;
-
    /**
     * Signal that a touch pressed event has occurred (e.g. mouse click pressed)
     * @param framebuffer_x Framebuffer x-coordinate that was pressed
@@ -35,7 +35,7 @@
 #include "common/swap.h"
 #include "core/arm/arm_interface.h"
 #include "core/core.h"
-#include "core/core_cpu.h"
+#include "core/core_manager.h"
 #include "core/gdbstub/gdbstub.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/scheduler.h"
@@ -8,7 +8,6 @@
 #include "common/assert.h"
 #include "common/common_types.h"
 #include "core/core.h"
-#include "core/core_cpu.h"
 #include "core/hle/kernel/address_arbiter.h"
 #include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/scheduler.h"
@@ -3,13 +3,15 @@
 // Refer to the license.txt file included.

 #include <atomic>
+#include <functional>
 #include <memory>
 #include <mutex>
 #include <utility>

 #include "common/assert.h"
 #include "common/logging/log.h"
-
+#include "core/arm/arm_interface.h"
+#include "core/arm/exclusive_monitor.h"
 #include "core/core.h"
 #include "core/core_timing.h"
 #include "core/core_timing_util.h"
@@ -17,6 +19,7 @@
 #include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/handle_table.h"
 #include "core/hle/kernel/kernel.h"
+#include "core/hle/kernel/physical_core.h"
 #include "core/hle/kernel/process.h"
 #include "core/hle/kernel/resource_limit.h"
 #include "core/hle/kernel/scheduler.h"
@@ -98,6 +101,7 @@ struct KernelCore::Impl {
    void Initialize(KernelCore& kernel) {
        Shutdown();

+        InitializePhysicalCores(kernel);
        InitializeSystemResourceLimit(kernel);
        InitializeThreads();
        InitializePreemption();
@@ -121,6 +125,21 @@ struct KernelCore::Impl {
        global_scheduler.Shutdown();

        named_ports.clear();
+
+        for (auto& core : cores) {
+            core.Shutdown();
+        }
+        cores.clear();
+
+        exclusive_monitor.reset(nullptr);
+    }
+
+    void InitializePhysicalCores(KernelCore& kernel) {
+        exclusive_monitor =
+            Core::MakeExclusiveMonitor(system.Memory(), global_scheduler.CpuCoresCount());
+        for (std::size_t i = 0; i < global_scheduler.CpuCoresCount(); i++) {
+            cores.emplace_back(system, kernel, i, *exclusive_monitor);
+        }
    }

    // Creates the default system resource limit
@@ -186,6 +205,9 @@ struct KernelCore::Impl {
    /// the ConnectToPort SVC.
    NamedPortTable named_ports;

+    std::unique_ptr<Core::ExclusiveMonitor> exclusive_monitor;
+    std::vector<Kernel::PhysicalCore> cores;
+
    // System context
    Core::System& system;
 };
@@ -240,6 +262,34 @@ const Kernel::GlobalScheduler& KernelCore::GlobalScheduler() const {
    return impl->global_scheduler;
 }

+Kernel::PhysicalCore& KernelCore::PhysicalCore(std::size_t id) {
+    return impl->cores[id];
+}
+
+const Kernel::PhysicalCore& KernelCore::PhysicalCore(std::size_t id) const {
+    return impl->cores[id];
+}
+
+Core::ExclusiveMonitor& KernelCore::GetExclusiveMonitor() {
+    return *impl->exclusive_monitor;
+}
+
+const Core::ExclusiveMonitor& KernelCore::GetExclusiveMonitor() const {
+    return *impl->exclusive_monitor;
+}
+
+void KernelCore::InvalidateAllInstructionCaches() {
+    for (std::size_t i = 0; i < impl->global_scheduler.CpuCoresCount(); i++) {
+        PhysicalCore(i).ArmInterface().ClearInstructionCache();
+    }
+}
+
+void KernelCore::PrepareReschedule(std::size_t id) {
+    if (id < impl->global_scheduler.CpuCoresCount()) {
+        impl->cores[id].Stop();
+    }
+}
+
 void KernelCore::AddNamedPort(std::string name, std::shared_ptr<ClientPort> port) {
    impl->named_ports.emplace(std::move(name), std::move(port));
 }
@@ -11,8 +11,9 @@
 #include "core/hle/kernel/object.h"

 namespace Core {
+class ExclusiveMonitor;
 class System;
-}
+} // namespace Core

 namespace Core::Timing {
 class CoreTiming;
@@ -25,6 +26,7 @@ class AddressArbiter;
 class ClientPort;
 class GlobalScheduler;
 class HandleTable;
+class PhysicalCore;
 class Process;
 class ResourceLimit;
 class Thread;
@@ -84,6 +86,21 @@ public:
    /// Gets the sole instance of the global scheduler
    const Kernel::GlobalScheduler& GlobalScheduler() const;

+    /// Gets the an instance of the respective physical CPU core.
+    Kernel::PhysicalCore& PhysicalCore(std::size_t id);
+
+    /// Gets the an instance of the respective physical CPU core.
+    const Kernel::PhysicalCore& PhysicalCore(std::size_t id) const;
+
+    /// Stops execution of 'id' core, in order to reschedule a new thread.
+    void PrepareReschedule(std::size_t id);
+
+    Core::ExclusiveMonitor& GetExclusiveMonitor();
+
+    const Core::ExclusiveMonitor& GetExclusiveMonitor() const;
+
+    void InvalidateAllInstructionCaches();
+
    /// Adds a port to the named port table
    void AddNamedPort(std::string name, std::shared_ptr<ClientPort> port);

@@ -0,0 +1,52 @@
+// Copyright 2020 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include "common/logging/log.h"
+#include "core/arm/arm_interface.h"
+#ifdef ARCHITECTURE_x86_64
+#include "core/arm/dynarmic/arm_dynarmic.h"
+#endif
+#include "core/arm/exclusive_monitor.h"
+#include "core/arm/unicorn/arm_unicorn.h"
+#include "core/core.h"
+#include "core/hle/kernel/kernel.h"
+#include "core/hle/kernel/physical_core.h"
+#include "core/hle/kernel/scheduler.h"
+#include "core/hle/kernel/thread.h"
+
+namespace Kernel {
+
+PhysicalCore::PhysicalCore(Core::System& system, KernelCore& kernel, std::size_t id,
+                           Core::ExclusiveMonitor& exclusive_monitor)
+    : core_index{id}, kernel{kernel} {
+#ifdef ARCHITECTURE_x86_64
+    arm_interface = std::make_shared<Core::ARM_Dynarmic>(system, exclusive_monitor, core_index);
+#else
+    arm_interface = std::make_shared<Core::ARM_Unicorn>(system);
+    LOG_WARNING(Core, "CPU JIT requested, but Dynarmic not available");
+#endif
+
+    scheduler = std::make_shared<Kernel::Scheduler>(system, *arm_interface, core_index);
+}
+
+PhysicalCore::~PhysicalCore() = default;
+
+void PhysicalCore::Run() {
+    arm_interface->Run();
+    arm_interface->ClearExclusiveState();
+}
+
+void PhysicalCore::Step() {
+    arm_interface->Step();
+}
+
+void PhysicalCore::Stop() {
+    arm_interface->PrepareReschedule();
+}
+
+void PhysicalCore::Shutdown() {
+    scheduler->Shutdown();
+}
+
+} // namespace Kernel
@@ -0,0 +1,74 @@
+// Copyright 2020 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <cstddef>
+#include <memory>
+
+namespace Kernel {
+class Scheduler;
+} // namespace Kernel
+
+namespace Core {
+class ARM_Interface;
+class ExclusiveMonitor;
+class System;
+} // namespace Core
+
+namespace Kernel {
+
+class PhysicalCore {
+public:
+    PhysicalCore(Core::System& system, KernelCore& kernel, std::size_t id,
+                 Core::ExclusiveMonitor& exclusive_monitor);
+
+    ~PhysicalCore();
+
+    /// Execute current jit state
+    void Run();
+    /// Execute a single instruction in current jit.
+    void Step();
+    /// Stop JIT execution/exit
+    void Stop();
+
+    // Shutdown this physical core.
+    void Shutdown();
+
+    Core::ARM_Interface& ArmInterface() {
+        return *arm_interface;
+    }
+
+    const Core::ARM_Interface& ArmInterface() const {
+        return *arm_interface;
+    }
+
+    bool IsMainCore() const {
+        return core_index == 0;
+    }
+
+    bool IsSystemCore() const {
+        return core_index == 3;
+    }
+
+    std::size_t CoreIndex() const {
+        return core_index;
+    }
+
+    Kernel::Scheduler& Scheduler() {
+        return *scheduler;
+    }
+
+    const Kernel::Scheduler& Scheduler() const {
+        return *scheduler;
+    }
+
+private:
+    std::size_t core_index;
+    KernelCore& kernel;
+    std::shared_ptr<Core::ARM_Interface> arm_interface;
+    std::shared_ptr<Kernel::Scheduler> scheduler;
+};
+
+} // namespace Kernel
@@ -14,7 +14,6 @@
 #include "common/logging/log.h"
 #include "core/arm/arm_interface.h"
 #include "core/core.h"
-#include "core/core_cpu.h"
 #include "core/core_timing.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/process.h"
@@ -15,7 +15,7 @@
 #include "common/string_util.h"
 #include "core/arm/exclusive_monitor.h"
 #include "core/core.h"
-#include "core/core_cpu.h"
+#include "core/core_manager.h"
 #include "core/core_timing.h"
 #include "core/core_timing_util.h"
 #include "core/hle/kernel/address_arbiter.h"
@@ -13,7 +13,6 @@
 #include "common/thread_queue_list.h"
 #include "core/arm/arm_interface.h"
 #include "core/core.h"
-#include "core/core_cpu.h"
 #include "core/core_timing.h"
 #include "core/core_timing_util.h"
 #include "core/hle/kernel/errors.h"
@@ -356,7 +355,7 @@ void Thread::SetActivity(ThreadActivity value) {
        // Set status if not waiting
        if (status == ThreadStatus::Ready || status == ThreadStatus::Running) {
            SetStatus(ThreadStatus::Paused);
-            Core::System::GetInstance().CpuCore(processor_id).PrepareReschedule();
+            kernel.PrepareReschedule(processor_id);
        }
    } else if (status == ThreadStatus::Paused) {
        // Ready to reschedule
@@ -7,7 +7,6 @@
 #include "common/common_types.h"
 #include "common/logging/log.h"
 #include "core/core.h"
-#include "core/core_cpu.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/object.h"
 #include "core/hle/kernel/process.h"
@@ -96,7 +95,7 @@ void WaitObject::WakeupWaitingThread(std::shared_ptr<Thread> thread) {
    }
    if (resume) {
        thread->ResumeFromWait();
-        Core::System::GetInstance().PrepareReschedule(thread->GetProcessorID());
+        kernel.PrepareReschedule(thread->GetProcessorID());
    }
 }

@@ -42,26 +42,6 @@ void BSD::Socket(Kernel::HLERequestContext& ctx) {
    rb.Push<u32>(0); // bsd errno
 }

-void BSD::Select(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service, "(STUBBED) called");
-
-    IPC::ResponseBuilder rb{ctx, 4};
-
-    rb.Push(RESULT_SUCCESS);
-    rb.Push<u32>(0); // ret
-    rb.Push<u32>(0); // bsd errno
-}
-
-void BSD::Bind(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service, "(STUBBED) called");
-
-    IPC::ResponseBuilder rb{ctx, 4};
-
-    rb.Push(RESULT_SUCCESS);
-    rb.Push<u32>(0); // ret
-    rb.Push<u32>(0); // bsd errno
-}
-
 void BSD::Connect(Kernel::HLERequestContext& ctx) {
    LOG_WARNING(Service, "(STUBBED) called");

@@ -72,26 +52,6 @@ void BSD::Connect(Kernel::HLERequestContext& ctx) {
    rb.Push<u32>(0); // bsd errno
 }

-void BSD::Listen(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service, "(STUBBED) called");
-
-    IPC::ResponseBuilder rb{ctx, 4};
-
-    rb.Push(RESULT_SUCCESS);
-    rb.Push<u32>(0); // ret
-    rb.Push<u32>(0); // bsd errno
-}
-
-void BSD::SetSockOpt(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service, "(STUBBED) called");
-
-    IPC::ResponseBuilder rb{ctx, 4};
-
-    rb.Push(RESULT_SUCCESS);
-    rb.Push<u32>(0); // ret
-    rb.Push<u32>(0); // bsd errno
-}
-
 void BSD::SendTo(Kernel::HLERequestContext& ctx) {
    LOG_WARNING(Service, "(STUBBED) called");

@@ -120,7 +80,7 @@ BSD::BSD(const char* name) : ServiceFramework(name) {
        {2, &BSD::Socket, "Socket"},
        {3, nullptr, "SocketExempt"},
        {4, nullptr, "Open"},
-        {5, &BSD::Select, "Select"},
+        {5, nullptr, "Select"},
        {6, nullptr, "Poll"},
        {7, nullptr, "Sysctl"},
        {8, nullptr, "Recv"},
@@ -128,15 +88,15 @@ BSD::BSD(const char* name) : ServiceFramework(name) {
        {10, nullptr, "Send"},
        {11, &BSD::SendTo, "SendTo"},
        {12, nullptr, "Accept"},
-        {13, &BSD::Bind, "Bind"},
+        {13, nullptr, "Bind"},
        {14, &BSD::Connect, "Connect"},
        {15, nullptr, "GetPeerName"},
        {16, nullptr, "GetSockName"},
        {17, nullptr, "GetSockOpt"},
-        {18, &BSD::Listen, "Listen"},
+        {18, nullptr, "Listen"},
        {19, nullptr, "Ioctl"},
        {20, nullptr, "Fcntl"},
-        {21, &BSD::SetSockOpt, "SetSockOpt"},
+        {21, nullptr, "SetSockOpt"},
        {22, nullptr, "Shutdown"},
        {23, nullptr, "ShutdownAllSockets"},
        {24, nullptr, "Write"},
@@ -18,11 +18,7 @@ private:
    void RegisterClient(Kernel::HLERequestContext& ctx);
    void StartMonitoring(Kernel::HLERequestContext& ctx);
    void Socket(Kernel::HLERequestContext& ctx);
-    void Select(Kernel::HLERequestContext& ctx);
-    void Bind(Kernel::HLERequestContext& ctx);
    void Connect(Kernel::HLERequestContext& ctx);
-    void Listen(Kernel::HLERequestContext& ctx);
-    void SetSockOpt(Kernel::HLERequestContext& ctx);
    void SendTo(Kernel::HLERequestContext& ctx);
    void Close(Kernel::HLERequestContext& ctx);

@@ -97,8 +97,7 @@ std::optional<VAddr> AppLoader_NSO::LoadModule(Kernel::Process& process,
        if (nso_header.IsSegmentCompressed(i)) {
            data = DecompressSegment(data, nso_header.segments[i]);
        }
-        program_image.resize(nso_header.segments[i].location +
-                             PageAlignSize(static_cast<u32>(data.size())));
+        program_image.resize(nso_header.segments[i].location + data.size());
        std::memcpy(program_image.data() + nso_header.segments[i].location, data.data(),
                    data.size());
        codeset.segments[i].addr = nso_header.segments[i].location;
@@ -106,12 +105,8 @@ std::optional<VAddr> AppLoader_NSO::LoadModule(Kernel::Process& process,
        codeset.segments[i].size = PageAlignSize(static_cast<u32>(data.size()));
    }

-    if (should_pass_arguments) {
-        std::vector<u8> arg_data{Settings::values.program_args.begin(),
-                                 Settings::values.program_args.end()};
-        if (arg_data.empty()) {
-            arg_data.resize(NSO_ARGUMENT_DEFAULT_SIZE);
-        }
+    if (should_pass_arguments && !Settings::values.program_args.empty()) {
+        const auto arg_data = Settings::values.program_args;
        codeset.DataSegment().size += NSO_ARGUMENT_DATA_ALLOCATION_SIZE;
        NSOArgumentHeader args_header{
            NSO_ARGUMENT_DATA_ALLOCATION_SIZE, static_cast<u32_le>(arg_data.size()), {}};
@@ -56,8 +56,6 @@ static_assert(sizeof(NSOHeader) == 0x100, "NSOHeader has incorrect size.");
 static_assert(std::is_trivially_copyable_v<NSOHeader>, "NSOHeader must be trivially copyable.");

 constexpr u64 NSO_ARGUMENT_DATA_ALLOCATION_SIZE = 0x9000;
-// NOTE: Official software default argument state is unverified.
-constexpr u64 NSO_ARGUMENT_DEFAULT_SIZE = 1;

 struct NSOArgumentHeader {
    u32_le allocated_size;
@@ -371,11 +371,6 @@ enum class SDMCSize : u64 {
    S1TB = 0x10000000000ULL,
 };

-enum class RendererBackend {
-    OpenGL = 0,
-    Vulkan = 1,
-};
-
 struct Values {
    // System
    bool use_docked_mode;
@@ -424,10 +419,6 @@ struct Values {
    SDMCSize sdmc_size;

    // Renderer
-    RendererBackend renderer_backend;
-    bool renderer_debug;
-    int vulkan_device;
-
    float resolution_factor;
    bool use_frame_limit;
    u16 frame_limit;
@@ -46,16 +46,6 @@ static u64 GenerateTelemetryId() {
    return telemetry_id;
 }

-static const char* TranslateRenderer(Settings::RendererBackend backend) {
-    switch (backend) {
-    case Settings::RendererBackend::OpenGL:
-        return "OpenGL";
-    case Settings::RendererBackend::Vulkan:
-        return "Vulkan";
-    }
-    return "Unknown";
-}
-
 u64 GetTelemetryId() {
    u64 telemetry_id{};
    const std::string filename{FileUtil::GetUserPath(FileUtil::UserPath::ConfigDir) +
@@ -179,7 +169,7 @@ void TelemetrySession::AddInitialInfo(Loader::AppLoader& app_loader) {
    AddField(field_type, "Audio_SinkId", Settings::values.sink_id);
    AddField(field_type, "Audio_EnableAudioStretching", Settings::values.enable_audio_stretching);
    AddField(field_type, "Core_UseMultiCore", Settings::values.use_multi_core);
-    AddField(field_type, "Renderer_Backend", TranslateRenderer(Settings::values.renderer_backend));
+    AddField(field_type, "Renderer_Backend", "OpenGL");
    AddField(field_type, "Renderer_ResolutionFactor", Settings::values.resolution_factor);
    AddField(field_type, "Renderer_UseFrameLimit", Settings::values.use_frame_limit);
    AddField(field_type, "Renderer_FrameLimit", Settings::values.frame_limit);
@@ -154,7 +154,6 @@ if (ENABLE_VULKAN)
        renderer_vulkan/maxwell_to_vk.cpp
        renderer_vulkan/maxwell_to_vk.h
        renderer_vulkan/renderer_vulkan.h
-        renderer_vulkan/renderer_vulkan.cpp
        renderer_vulkan/vk_blit_screen.cpp
        renderer_vulkan/vk_blit_screen.h
        renderer_vulkan/vk_buffer_cache.cpp
@@ -101,10 +101,7 @@ public:
    void TickFrame() {
        ++epoch;
        while (!pending_destruction.empty()) {
-            // Delay at least 4 frames before destruction.
-            // This is due to triple buffering happening on some drivers.
-            static constexpr u64 epochs_to_destroy = 5;
-            if (pending_destruction.front()->GetEpoch() + epochs_to_destroy > epoch) {
+            if (pending_destruction.front()->GetEpoch() + 1 > epoch) {
                break;
            }
            pending_destruction.pop_front();
@@ -1019,6 +1019,7 @@ private:
                }
                return {{"gl_ViewportIndex", Type::Int}};
            case 3:
+                UNIMPLEMENTED_MSG("Requires some state changes for gl_PointSize to work in shader");
                return {{"gl_PointSize", Type::Float}};
            }
            return {};
@@ -176,19 +176,6 @@ GLint GetSwizzleSource(SwizzleSource source) {
    return GL_NONE;
 }

-GLenum GetComponent(PixelFormat format, bool is_first) {
-    switch (format) {
-    case PixelFormat::Z24S8:
-    case PixelFormat::Z32FS8:
-        return is_first ? GL_DEPTH_COMPONENT : GL_STENCIL_INDEX;
-    case PixelFormat::S8Z24:
-        return is_first ? GL_STENCIL_INDEX : GL_DEPTH_COMPONENT;
-    default:
-        UNREACHABLE();
-        return GL_DEPTH_COMPONENT;
-    }
-}
-
 void ApplyTextureDefaults(const SurfaceParams& params, GLuint texture) {
    if (params.IsBuffer()) {
        return;
@@ -197,7 +184,7 @@ void ApplyTextureDefaults(const SurfaceParams& params, GLuint texture) {
    glTextureParameteri(texture, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTextureParameteri(texture, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTextureParameteri(texture, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-    glTextureParameteri(texture, GL_TEXTURE_MAX_LEVEL, static_cast<GLint>(params.num_levels - 1));
+    glTextureParameteri(texture, GL_TEXTURE_MAX_LEVEL, params.num_levels - 1);
    if (params.num_levels == 1) {
        glTextureParameterf(texture, GL_TEXTURE_LOD_BIAS, 1000.0f);
    }
@@ -429,21 +416,11 @@ void CachedSurfaceView::ApplySwizzle(SwizzleSource x_source, SwizzleSource y_sou
    if (new_swizzle == swizzle)
        return;
    swizzle = new_swizzle;
-    const std::array gl_swizzle = {GetSwizzleSource(x_source), GetSwizzleSource(y_source),
-                                   GetSwizzleSource(z_source), GetSwizzleSource(w_source)};
+    const std::array<GLint, 4> gl_swizzle = {GetSwizzleSource(x_source), GetSwizzleSource(y_source),
+                                             GetSwizzleSource(z_source),
+                                             GetSwizzleSource(w_source)};
    const GLuint handle = GetTexture();
-    const PixelFormat format = surface.GetSurfaceParams().pixel_format;
-    switch (format) {
-    case PixelFormat::Z24S8:
-    case PixelFormat::Z32FS8:
-    case PixelFormat::S8Z24:
-        glTextureParameteri(handle, GL_DEPTH_STENCIL_TEXTURE_MODE,
-                            GetComponent(format, x_source == SwizzleSource::R));
-        break;
-    default:
-        glTextureParameteriv(handle, GL_TEXTURE_SWIZZLE_RGBA, gl_swizzle.data());
-        break;
-    }
+    glTextureParameteriv(handle, GL_TEXTURE_SWIZZLE_RGBA, gl_swizzle.data());
 }

 OGLTextureView CachedSurfaceView::CreateTextureView() const {
@@ -552,11 +529,8 @@ void TextureCacheOpenGL::ImageBlit(View& src_view, View& dst_view,
    const Common::Rectangle<u32>& dst_rect = copy_config.dst_rect;
    const bool is_linear = copy_config.filter == Tegra::Engines::Fermi2D::Filter::Linear;

-    glBlitFramebuffer(static_cast<GLint>(src_rect.left), static_cast<GLint>(src_rect.top),
-                      static_cast<GLint>(src_rect.right), static_cast<GLint>(src_rect.bottom),
-                      static_cast<GLint>(dst_rect.left), static_cast<GLint>(dst_rect.top),
-                      static_cast<GLint>(dst_rect.right), static_cast<GLint>(dst_rect.bottom),
-                      buffers,
+    glBlitFramebuffer(src_rect.left, src_rect.top, src_rect.right, src_rect.bottom, dst_rect.left,
+                      dst_rect.top, dst_rect.right, dst_rect.bottom, buffers,
                      is_linear && (buffers == GL_COLOR_BUFFER_BIT) ? GL_LINEAR : GL_NEAREST);
 }

@@ -1,265 +0,0 @@
-// Copyright 2018 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <memory>
-#include <optional>
-#include <vector>
-
-#include <fmt/format.h>
-
-#include "common/assert.h"
-#include "common/logging/log.h"
-#include "common/telemetry.h"
-#include "core/core.h"
-#include "core/core_timing.h"
-#include "core/frontend/emu_window.h"
-#include "core/memory.h"
-#include "core/perf_stats.h"
-#include "core/settings.h"
-#include "core/telemetry_session.h"
-#include "video_core/gpu.h"
-#include "video_core/renderer_vulkan/declarations.h"
-#include "video_core/renderer_vulkan/renderer_vulkan.h"
-#include "video_core/renderer_vulkan/vk_blit_screen.h"
-#include "video_core/renderer_vulkan/vk_device.h"
-#include "video_core/renderer_vulkan/vk_memory_manager.h"
-#include "video_core/renderer_vulkan/vk_rasterizer.h"
-#include "video_core/renderer_vulkan/vk_resource_manager.h"
-#include "video_core/renderer_vulkan/vk_scheduler.h"
-#include "video_core/renderer_vulkan/vk_swapchain.h"
-
-namespace Vulkan {
-
-namespace {
-
-VkBool32 DebugCallback(VkDebugUtilsMessageSeverityFlagBitsEXT severity_,
-                       VkDebugUtilsMessageTypeFlagsEXT type,
-                       const VkDebugUtilsMessengerCallbackDataEXT* data,
-                       [[maybe_unused]] void* user_data) {
-    const vk::DebugUtilsMessageSeverityFlagBitsEXT severity{severity_};
-    const char* message{data->pMessage};
-
-    if (severity & vk::DebugUtilsMessageSeverityFlagBitsEXT::eError) {
-        LOG_CRITICAL(Render_Vulkan, "{}", message);
-    } else if (severity & vk::DebugUtilsMessageSeverityFlagBitsEXT::eWarning) {
-        LOG_WARNING(Render_Vulkan, "{}", message);
-    } else if (severity & vk::DebugUtilsMessageSeverityFlagBitsEXT::eInfo) {
-        LOG_INFO(Render_Vulkan, "{}", message);
-    } else if (severity & vk::DebugUtilsMessageSeverityFlagBitsEXT::eVerbose) {
-        LOG_DEBUG(Render_Vulkan, "{}", message);
-    }
-    return VK_FALSE;
-}
-
-std::string GetReadableVersion(u32 version) {
-    return fmt::format("{}.{}.{}", VK_VERSION_MAJOR(version), VK_VERSION_MINOR(version),
-                       VK_VERSION_PATCH(version));
-}
-
-std::string GetDriverVersion(const VKDevice& device) {
-    // Extracted from
-    // https://github.com/SaschaWillems/vulkan.gpuinfo.org/blob/5dddea46ea1120b0df14eef8f15ff8e318e35462/functions.php#L308-L314
-    const u32 version = device.GetDriverVersion();
-
-    if (device.GetDriverID() == vk::DriverIdKHR::eNvidiaProprietary) {
-        const u32 major = (version >> 22) & 0x3ff;
-        const u32 minor = (version >> 14) & 0x0ff;
-        const u32 secondary = (version >> 6) & 0x0ff;
-        const u32 tertiary = version & 0x003f;
-        return fmt::format("{}.{}.{}.{}", major, minor, secondary, tertiary);
-    }
-    if (device.GetDriverID() == vk::DriverIdKHR::eIntelProprietaryWindows) {
-        const u32 major = version >> 14;
-        const u32 minor = version & 0x3fff;
-        return fmt::format("{}.{}", major, minor);
-    }
-
-    return GetReadableVersion(version);
-}
-
-std::string BuildCommaSeparatedExtensions(std::vector<std::string> available_extensions) {
-    std::sort(std::begin(available_extensions), std::end(available_extensions));
-
-    static constexpr std::size_t AverageExtensionSize = 64;
-    std::string separated_extensions;
-    separated_extensions.reserve(available_extensions.size() * AverageExtensionSize);
-
-    const auto end = std::end(available_extensions);
-    for (auto extension = std::begin(available_extensions); extension != end; ++extension) {
-        if (const bool is_last = extension + 1 == end; is_last) {
-            separated_extensions += *extension;
-        } else {
-            separated_extensions += fmt::format("{},", *extension);
-        }
-    }
-    return separated_extensions;
-}
-
-} // Anonymous namespace
-
-RendererVulkan::RendererVulkan(Core::Frontend::EmuWindow& window, Core::System& system)
-    : RendererBase(window), system{system} {}
-
-RendererVulkan::~RendererVulkan() {
-    ShutDown();
-}
-
-void RendererVulkan::SwapBuffers(const Tegra::FramebufferConfig* framebuffer) {
-    const auto& layout = render_window.GetFramebufferLayout();
-    if (framebuffer && layout.width > 0 && layout.height > 0 && render_window.IsShown()) {
-        const VAddr framebuffer_addr = framebuffer->address + framebuffer->offset;
-        const bool use_accelerated =
-            rasterizer->AccelerateDisplay(*framebuffer, framebuffer_addr, framebuffer->stride);
-        const bool is_srgb = use_accelerated && screen_info.is_srgb;
-        if (swapchain->HasFramebufferChanged(layout) || swapchain->GetSrgbState() != is_srgb) {
-            swapchain->Create(layout.width, layout.height, is_srgb);
-            blit_screen->Recreate();
-        }
-
-        scheduler->WaitWorker();
-
-        swapchain->AcquireNextImage();
-        const auto [fence, render_semaphore] = blit_screen->Draw(*framebuffer, use_accelerated);
-
-        scheduler->Flush(false, render_semaphore);
-
-        if (swapchain->Present(render_semaphore, fence)) {
-            blit_screen->Recreate();
-        }
-
-        render_window.SwapBuffers();
-        rasterizer->TickFrame();
-    }
-
-    render_window.PollEvents();
-}
-
-bool RendererVulkan::Init() {
-    PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr{};
-    render_window.RetrieveVulkanHandlers(&vkGetInstanceProcAddr, &instance, &surface);
-    const vk::DispatchLoaderDynamic dldi(instance, vkGetInstanceProcAddr);
-
-    std::optional<vk::DebugUtilsMessengerEXT> callback;
-    if (Settings::values.renderer_debug && dldi.vkCreateDebugUtilsMessengerEXT) {
-        callback = CreateDebugCallback(dldi);
-        if (!callback) {
-            return false;
-        }
-    }
-
-    if (!PickDevices(dldi)) {
-        if (callback) {
-            instance.destroy(*callback, nullptr, dldi);
-        }
-        return false;
-    }
-    debug_callback = UniqueDebugUtilsMessengerEXT(
-        *callback, vk::ObjectDestroy<vk::Instance, vk::DispatchLoaderDynamic>(
-                       instance, nullptr, device->GetDispatchLoader()));
-
-    Report();
-
-    memory_manager = std::make_unique<VKMemoryManager>(*device);
-
-    resource_manager = std::make_unique<VKResourceManager>(*device);
-
-    const auto& framebuffer = render_window.GetFramebufferLayout();
-    swapchain = std::make_unique<VKSwapchain>(surface, *device);
-    swapchain->Create(framebuffer.width, framebuffer.height, false);
-
-    scheduler = std::make_unique<VKScheduler>(*device, *resource_manager);
-
-    rasterizer = std::make_unique<RasterizerVulkan>(system, render_window, screen_info, *device,
-                                                    *resource_manager, *memory_manager, *scheduler);
-
-    blit_screen = std::make_unique<VKBlitScreen>(system, render_window, *rasterizer, *device,
-                                                 *resource_manager, *memory_manager, *swapchain,
-                                                 *scheduler, screen_info);
-
-    return true;
-}
-
-void RendererVulkan::ShutDown() {
-    if (!device) {
-        return;
-    }
-    const auto dev = device->GetLogical();
-    const auto& dld = device->GetDispatchLoader();
-    if (dev && dld.vkDeviceWaitIdle) {
-        dev.waitIdle(dld);
-    }
-
-    rasterizer.reset();
-    blit_screen.reset();
-    scheduler.reset();
-    swapchain.reset();
-    memory_manager.reset();
-    resource_manager.reset();
-    device.reset();
-}
-
-std::optional<vk::DebugUtilsMessengerEXT> RendererVulkan::CreateDebugCallback(
-    const vk::DispatchLoaderDynamic& dldi) {
-    const vk::DebugUtilsMessengerCreateInfoEXT callback_ci(
-        {},
-        vk::DebugUtilsMessageSeverityFlagBitsEXT::eError |
-            vk::DebugUtilsMessageSeverityFlagBitsEXT::eWarning |
-            vk::DebugUtilsMessageSeverityFlagBitsEXT::eInfo |
-            vk::DebugUtilsMessageSeverityFlagBitsEXT::eVerbose,
-        vk::DebugUtilsMessageTypeFlagBitsEXT::eGeneral |
-            vk::DebugUtilsMessageTypeFlagBitsEXT::eValidation |
-            vk::DebugUtilsMessageTypeFlagBitsEXT::ePerformance,
-        &DebugCallback, nullptr);
-    vk::DebugUtilsMessengerEXT callback;
-    if (instance.createDebugUtilsMessengerEXT(&callback_ci, nullptr, &callback, dldi) !=
-        vk::Result::eSuccess) {
-        LOG_ERROR(Render_Vulkan, "Failed to create debug callback");
-        return {};
-    }
-    return callback;
-}
-
-bool RendererVulkan::PickDevices(const vk::DispatchLoaderDynamic& dldi) {
-    const auto devices = instance.enumeratePhysicalDevices(dldi);
-
-    // TODO(Rodrigo): Choose device from config file
-    const s32 device_index = Settings::values.vulkan_device;
-    if (device_index < 0 || device_index >= static_cast<s32>(devices.size())) {
-        LOG_ERROR(Render_Vulkan, "Invalid device index {}!", device_index);
-        return false;
-    }
-    const vk::PhysicalDevice physical_device = devices[device_index];
-
-    if (!VKDevice::IsSuitable(dldi, physical_device, surface)) {
-        return false;
-    }
-
-    device = std::make_unique<VKDevice>(dldi, physical_device, surface);
-    return device->Create(dldi, instance);
-}
-
-void RendererVulkan::Report() const {
-    const std::string vendor_name{device->GetVendorName()};
-    const std::string model_name{device->GetModelName()};
-    const std::string driver_version = GetDriverVersion(*device);
-    const std::string driver_name = fmt::format("{} {}", vendor_name, driver_version);
-
-    const std::string api_version = GetReadableVersion(device->GetApiVersion());
-
-    const std::string extensions = BuildCommaSeparatedExtensions(device->GetAvailableExtensions());
-
-    LOG_INFO(Render_Vulkan, "Driver: {}", driver_name);
-    LOG_INFO(Render_Vulkan, "Device: {}", model_name);
-    LOG_INFO(Render_Vulkan, "Vulkan: {}", api_version);
-
-    auto& telemetry_session = system.TelemetrySession();
-    constexpr auto field = Telemetry::FieldType::UserSystem;
-    telemetry_session.AddField(field, "GPU_Vendor", vendor_name);
-    telemetry_session.AddField(field, "GPU_Model", model_name);
-    telemetry_session.AddField(field, "GPU_Vulkan_Driver", driver_name);
-    telemetry_session.AddField(field, "GPU_Vulkan_Version", api_version);
-    telemetry_session.AddField(field, "GPU_Vulkan_Extensions", extensions);
-}
-
-} // namespace Vulkan
@@ -400,10 +400,8 @@ std::vector<const char*> VKDevice::LoadExtensions(const vk::DispatchLoaderDynami
             VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME, true);
        Test(extension, ext_subgroup_size_control, VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME,
             false);
-        if (Settings::values.renderer_debug) {
-            Test(extension, nv_device_diagnostic_checkpoints,
-                 VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_EXTENSION_NAME, true);
-        }
+        Test(extension, nv_device_diagnostic_checkpoints,
+             VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_EXTENSION_NAME, true);
    }

    if (khr_shader_float16_int8) {
@@ -325,6 +325,9 @@ VKPipelineCache::DecompileShaders(const GraphicsPipelineCacheKey& key) {
    specialization.tessellation.primitive = fixed_state.tessellation.primitive;
    specialization.tessellation.spacing = fixed_state.tessellation.spacing;
    specialization.tessellation.clockwise = fixed_state.tessellation.clockwise;
+    for (const auto& rt : key.renderpass_params.color_attachments) {
+        specialization.enabled_rendertargets.set(rt.index);
+    }

    SPIRVProgram program;
    std::vector<vk::DescriptorSetLayoutBinding> bindings;
@@ -542,10 +542,11 @@ private:
            return;
        }

-        for (u32 rt = 0; rt < static_cast<u32>(std::size(frag_colors)); ++rt) {
-            if (!IsRenderTargetEnabled(rt)) {
+        for (u32 rt = 0; rt < static_cast<u32>(frag_colors.size()); ++rt) {
+            if (!specialization.enabled_rendertargets[rt]) {
                continue;
            }
+
            const Id id = AddGlobalVariable(OpVariable(t_out_float4, spv::StorageClass::Output));
            Name(id, fmt::format("frag_color{}", rt));
            Decorate(id, spv::Decoration::Location, rt);
@@ -851,15 +852,6 @@ private:
        return binding;
    }

-    bool IsRenderTargetEnabled(u32 rt) const {
-        for (u32 component = 0; component < 4; ++component) {
-            if (header.ps.IsColorComponentOutputEnabled(rt, component)) {
-                return true;
-            }
-        }
-        return false;
-    }
-
    bool IsInputAttributeArray() const {
        return stage == ShaderType::TesselationControl || stage == ShaderType::TesselationEval ||
               stage == ShaderType::Geometry;
@@ -1897,14 +1889,19 @@ private:
            // rendertargets/components are skipped in the register assignment.
            u32 current_reg = 0;
            for (u32 rt = 0; rt < Maxwell::NumRenderTargets; ++rt) {
+                if (!specialization.enabled_rendertargets[rt]) {
+                    // Skip rendertargets that are not enabled
+                    continue;
+                }
                // TODO(Subv): Figure out how dual-source blending is configured in the Switch.
                for (u32 component = 0; component < 4; ++component) {
-                    if (!header.ps.IsColorComponentOutputEnabled(rt, component)) {
-                        continue;
+                    const Id pointer = AccessElement(t_out_float, frag_colors.at(rt), component);
+                    if (header.ps.IsColorComponentOutputEnabled(rt, component)) {
+                        OpStore(pointer, SafeGetRegister(current_reg));
+                        ++current_reg;
+                    } else {
+                        OpStore(pointer, component == 3 ? v_float_one : v_float_zero);
                    }
-                    const Id pointer = AccessElement(t_out_float, frag_colors[rt], component);
-                    OpStore(pointer, SafeGetRegister(current_reg));
-                    ++current_reg;
                }
            }
            if (header.ps.omap.depth) {
@@ -102,6 +102,9 @@ struct Specialization final {
        Maxwell::TessellationSpacing spacing{};
        bool clockwise{};
    } tessellation;
+
+    // Fragment specific
+    std::bitset<8> enabled_rendertargets;
 };
 // Old gcc versions don't consider this trivially copyable.
 // static_assert(std::is_trivially_copyable_v<Specialization>);
@@ -69,16 +69,13 @@ u32 ShaderIR::DecodeOther(NodeBlock& bb, u32 pc) {
    case OpCode::Id::MOV_SYS: {
        const Node value = [this, instr] {
            switch (instr.sys20) {
-            case SystemVariable::LaneId:
-                LOG_WARNING(HW_GPU, "MOV_SYS instruction with LaneId is incomplete");
-                return Immediate(0U);
            case SystemVariable::InvocationId:
                return Operation(OperationCode::InvocationId);
            case SystemVariable::Ydirection:
                return Operation(OperationCode::YNegate);
            case SystemVariable::InvocationInfo:
                LOG_WARNING(HW_GPU, "MOV_SYS instruction with InvocationInfo is incomplete");
-                return Immediate(0U);
+                return Immediate(0u);
            case SystemVariable::Tid: {
                Node value = Immediate(0);
                value = BitfieldInsert(value, Operation(OperationCode::LocalInvocationIdX), 0, 9);
@@ -191,7 +188,7 @@ u32 ShaderIR::DecodeOther(NodeBlock& bb, u32 pc) {
        UNIMPLEMENTED_IF_MSG(cc != Tegra::Shader::ConditionCode::T, "SYNC condition code used: {}",
                             static_cast<u32>(cc));

-        if (decompiled) {
+        if (disable_flow_stack) {
            break;
        }

@@ -203,7 +200,7 @@ u32 ShaderIR::DecodeOther(NodeBlock& bb, u32 pc) {
        const Tegra::Shader::ConditionCode cc = instr.flow_condition_code;
        UNIMPLEMENTED_IF_MSG(cc != Tegra::Shader::ConditionCode::T, "BRK condition code used: {}",
                             static_cast<u32>(cc));
-        if (decompiled) {
+        if (disable_flow_stack) {
            break;
        }

@@ -161,16 +161,16 @@ u32 ShaderIR::DecodeTexture(NodeBlock& bb, u32 pc) {
    case OpCode::Id::TXD: {
        UNIMPLEMENTED_IF_MSG(instr.txd.UsesMiscMode(TextureMiscMode::AOFFI),
                             "AOFFI is not implemented");
+        UNIMPLEMENTED_IF_MSG(instr.txd.is_array != 0, "TXD Array is not implemented");

-        const bool is_array = instr.txd.is_array != 0;
        u64 base_reg = instr.gpr8.Value();
        const auto derivate_reg = instr.gpr20.Value();
        const auto texture_type = instr.txd.texture_type.Value();
        const auto coord_count = GetCoordCount(texture_type);

-        const Sampler* sampler =
-            is_bindless ? GetBindlessSampler(base_reg, {{texture_type, is_array, false}})
-                        : GetSampler(instr.sampler, {{texture_type, is_array, false}});
+        const Sampler* sampler = is_bindless
+                                     ? GetBindlessSampler(base_reg, {{texture_type, false, false}})
+                                     : GetSampler(instr.sampler, {{texture_type, false, false}});
        Node4 values;
        if (sampler == nullptr) {
            for (u32 element = 0; element < values.size(); ++element) {
@@ -179,7 +179,6 @@ u32 ShaderIR::DecodeTexture(NodeBlock& bb, u32 pc) {
            WriteTexInstructionFloat(bb, instr, values);
            break;
        }
-
        if (is_bindless) {
            base_reg++;
        }
@@ -193,14 +192,8 @@ u32 ShaderIR::DecodeTexture(NodeBlock& bb, u32 pc) {
            derivates.push_back(GetRegister(derivate_reg + derivate + 1));
        }

-        Node array_node = {};
-        if (is_array) {
-            const Node info_reg = GetRegister(base_reg + coord_count);
-            array_node = BitfieldExtract(info_reg, 0, 16);
-        }
-
        for (u32 element = 0; element < values.size(); ++element) {
-            MetaTexture meta{*sampler, array_node, {}, {}, {}, derivates, {}, {}, {}, element};
+            MetaTexture meta{*sampler, {}, {}, {}, {}, derivates, {}, {}, {}, element};
            values[element] = Operation(OperationCode::TextureGradient, std::move(meta), coords);
        }

@@ -135,7 +135,7 @@ std::vector<CopyParams> SurfaceBaseImpl::BreakDownLayered(const SurfaceParams& i
        for (u32 level = 0; level < mipmaps; level++) {
            const u32 width = SurfaceParams::IntersectWidth(params, in_params, level, level);
            const u32 height = SurfaceParams::IntersectHeight(params, in_params, level, level);
-            result.emplace_back(0, 0, layer, 0, 0, layer, level, level, width, height, 1);
+            result.emplace_back(width, height, layer, level);
        }
    }
    return result;
@@ -3,32 +3,19 @@
 // Refer to the license.txt file included.

 #include <memory>
-#include "common/logging/log.h"
 #include "core/core.h"
 #include "core/settings.h"
 #include "video_core/gpu_asynch.h"
 #include "video_core/gpu_synch.h"
 #include "video_core/renderer_base.h"
 #include "video_core/renderer_opengl/renderer_opengl.h"
-#ifdef HAS_VULKAN
-#include "video_core/renderer_vulkan/renderer_vulkan.h"
-#endif
 #include "video_core/video_core.h"

 namespace VideoCore {

 std::unique_ptr<RendererBase> CreateRenderer(Core::Frontend::EmuWindow& emu_window,
                                             Core::System& system) {
-    switch (Settings::values.renderer_backend) {
-    case Settings::RendererBackend::OpenGL:
-        return std::make_unique<OpenGL::RendererOpenGL>(emu_window, system);
-#ifdef HAS_VULKAN
-    case Settings::RendererBackend::Vulkan:
-        return std::make_unique<Vulkan::RendererVulkan>(emu_window, system);
-#endif
-    default:
-        return nullptr;
-    }
+    return std::make_unique<OpenGL::RendererOpenGL>(emu_window, system);
 }

 std::unique_ptr<Tegra::GPU> CreateGPU(Core::System& system) {
@@ -117,7 +117,6 @@ bool TelemetryJson::SubmitTestcase() {
    impl->SerializeSection(Telemetry::FieldType::Session, "Session");
    impl->SerializeSection(Telemetry::FieldType::UserFeedback, "UserFeedback");
    impl->SerializeSection(Telemetry::FieldType::UserSystem, "UserSystem");
-    impl->SerializeSection(Telemetry::FieldType::UserConfig, "UserConfig");

    auto content = impl->TopSection().dump();
    Client client(impl->host, impl->username, impl->token);
@@ -36,6 +36,9 @@ add_executable(yuzu
    configuration/configure_filesystem.cpp
    configuration/configure_filesystem.h
    configuration/configure_filesystem.ui
+    configuration/configure_gamelist.cpp
+    configuration/configure_gamelist.h
+    configuration/configure_gamelist.ui
    configuration/configure_general.cpp
    configuration/configure_general.h
    configuration/configure_general.ui
@@ -72,9 +75,6 @@ add_executable(yuzu
    configuration/configure_touchscreen_advanced.cpp
    configuration/configure_touchscreen_advanced.h
    configuration/configure_touchscreen_advanced.ui
-    configuration/configure_ui.cpp
-    configuration/configure_ui.h
-    configuration/configure_ui.ui
    configuration/configure_web.cpp
    configuration/configure_web.h
    configuration/configure_web.ui
@@ -200,8 +200,3 @@ if (MSVC)
    copy_yuzu_SDL_deps(yuzu)
    copy_yuzu_unicorn_deps(yuzu)
 endif()
-
-if (ENABLE_VULKAN)
-    target_include_directories(yuzu PRIVATE ../../externals/Vulkan-Headers/include)
-    target_compile_definitions(yuzu PRIVATE HAS_VULKAN)
-endif()
@@ -2,30 +2,19 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.

-#include <glad/glad.h>
-
 #include <QApplication>
 #include <QHBoxLayout>
 #include <QKeyEvent>
-#include <QMessageBox>
 #include <QOffscreenSurface>
 #include <QOpenGLWindow>
 #include <QPainter>
 #include <QScreen>
-#include <QStringList>
 #include <QWindow>
-#ifdef HAS_VULKAN
-#include <QVulkanWindow>
-#endif
-
 #include <fmt/format.h>
-
-#include "common/assert.h"
 #include "common/microprofile.h"
 #include "common/scm_rev.h"
 #include "core/core.h"
 #include "core/frontend/framebuffer_layout.h"
-#include "core/frontend/scope_acquire_window_context.h"
 #include "core/settings.h"
 #include "input_common/keyboard.h"
 #include "input_common/main.h"
@@ -125,10 +114,19 @@ private:
    QOpenGLContext context;
 };

-class GWidgetInternal : public QWindow {
+// This class overrides paintEvent and resizeEvent to prevent the GUI thread from stealing GL
+// context.
+// The corresponding functionality is handled in EmuThread instead
+class GGLWidgetInternal : public QOpenGLWindow {
 public:
-    GWidgetInternal(GRenderWindow* parent) : parent(parent) {}
-    virtual ~GWidgetInternal() = default;
+    GGLWidgetInternal(GRenderWindow* parent, QOpenGLContext* shared_context)
+        : QOpenGLWindow(shared_context), parent(parent) {}
+
+    void paintEvent(QPaintEvent* ev) override {
+        if (do_painting) {
+            QPainter painter(this);
+        }
+    }

    void resizeEvent(QResizeEvent* ev) override {
        parent->OnClientAreaResized(ev->size().width(), ev->size().height());
@@ -184,47 +182,11 @@ public:
        do_painting = true;
    }

-    std::pair<unsigned, unsigned> GetSize() const {
-        return std::make_pair(width(), height());
-    }
-
-protected:
-    bool IsPaintingEnabled() const {
-        return do_painting;
-    }
-
 private:
    GRenderWindow* parent;
-    bool do_painting = false;
+    bool do_painting;
 };

-// This class overrides paintEvent and resizeEvent to prevent the GUI thread from stealing GL
-// context.
-// The corresponding functionality is handled in EmuThread instead
-class GGLWidgetInternal final : public GWidgetInternal, public QOpenGLWindow {
-public:
-    GGLWidgetInternal(GRenderWindow* parent, QOpenGLContext* shared_context)
-        : GWidgetInternal(parent), QOpenGLWindow(shared_context) {}
-    ~GGLWidgetInternal() override = default;
-
-    void paintEvent(QPaintEvent* ev) override {
-        if (IsPaintingEnabled()) {
-            QPainter painter(this);
-        }
-    }
-};
-
-#ifdef HAS_VULKAN
-class GVKWidgetInternal final : public GWidgetInternal {
-public:
-    GVKWidgetInternal(GRenderWindow* parent, QVulkanInstance* instance) : GWidgetInternal(parent) {
-        setSurfaceType(QSurface::SurfaceType::VulkanSurface);
-        setVulkanInstance(instance);
-    }
-    ~GVKWidgetInternal() override = default;
-};
-#endif
-
 GRenderWindow::GRenderWindow(GMainWindow* parent, EmuThread* emu_thread)
    : QWidget(parent), emu_thread(emu_thread) {
    setWindowTitle(QStringLiteral("yuzu %1 | %2-%3")
@@ -239,15 +201,9 @@ GRenderWindow::GRenderWindow(GMainWindow* parent, EmuThread* emu_thread)

 GRenderWindow::~GRenderWindow() {
    InputCommon::Shutdown();
-
-    // Avoid an unordered destruction that generates a segfault
-    delete child;
 }

 void GRenderWindow::moveContext() {
-    if (!context) {
-        return;
-    }
    DoneCurrent();

    // If the thread started running, move the GL Context to the new thread. Otherwise, move it
@@ -259,9 +215,8 @@ void GRenderWindow::moveContext() {
 }

 void GRenderWindow::SwapBuffers() {
-    if (context) {
-        context->swapBuffers(child);
-    }
+    context->swapBuffers(child);
+
    if (!first_frame) {
        first_frame = true;
        emit FirstFrameDisplayed();
@@ -269,38 +224,15 @@ void GRenderWindow::SwapBuffers() {
 }

 void GRenderWindow::MakeCurrent() {
-    if (context) {
-        context->makeCurrent(child);
-    }
+    context->makeCurrent(child);
 }

 void GRenderWindow::DoneCurrent() {
-    if (context) {
-        context->doneCurrent();
-    }
+    context->doneCurrent();
 }

 void GRenderWindow::PollEvents() {}

-bool GRenderWindow::IsShown() const {
-    return !isMinimized();
-}
-
-void GRenderWindow::RetrieveVulkanHandlers(void* get_instance_proc_addr, void* instance,
-                                           void* surface) const {
-#ifdef HAS_VULKAN
-    const auto instance_proc_addr = vk_instance->getInstanceProcAddr("vkGetInstanceProcAddr");
-    const VkInstance instance_copy = vk_instance->vkInstance();
-    const VkSurfaceKHR surface_copy = vk_instance->surfaceForWindow(child);
-
-    std::memcpy(get_instance_proc_addr, &instance_proc_addr, sizeof(instance_proc_addr));
-    std::memcpy(instance, &instance_copy, sizeof(instance_copy));
-    std::memcpy(surface, &surface_copy, sizeof(surface_copy));
-#else
-    UNREACHABLE_MSG("Executing Vulkan code without compiling Vulkan");
-#endif
-}
-
 // On Qt 5.0+, this correctly gets the size of the framebuffer (pixels).
 //
 // Older versions get the window size (density independent pixels),
@@ -309,9 +241,10 @@ void GRenderWindow::RetrieveVulkanHandlers(void* get_instance_proc_addr, void* i
 void GRenderWindow::OnFramebufferSizeChanged() {
    // Screen changes potentially incur a change in screen DPI, hence we should update the
    // framebuffer size
-    const qreal pixelRatio{GetWindowPixelRatio()};
-    const auto size{child->GetSize()};
-    UpdateCurrentFramebufferLayout(size.first * pixelRatio, size.second * pixelRatio);
+    const qreal pixel_ratio = GetWindowPixelRatio();
+    const u32 width = child->QPaintDevice::width() * pixel_ratio;
+    const u32 height = child->QPaintDevice::height() * pixel_ratio;
+    UpdateCurrentFramebufferLayout(width, height);
 }

 void GRenderWindow::ForwardKeyPressEvent(QKeyEvent* event) {
@@ -357,7 +290,7 @@ qreal GRenderWindow::GetWindowPixelRatio() const {
 }

 std::pair<u32, u32> GRenderWindow::ScaleTouch(const QPointF pos) const {
-    const qreal pixel_ratio{GetWindowPixelRatio()};
+    const qreal pixel_ratio = GetWindowPixelRatio();
    return {static_cast<u32>(std::max(std::round(pos.x() * pixel_ratio), qreal{0.0})),
            static_cast<u32>(std::max(std::round(pos.y() * pixel_ratio), qreal{0.0}))};
 }
@@ -423,46 +356,50 @@ std::unique_ptr<Core::Frontend::GraphicsContext> GRenderWindow::CreateSharedCont
    return std::make_unique<GGLContext>(context.get());
 }

-bool GRenderWindow::InitRenderTarget() {
+void GRenderWindow::InitRenderTarget() {
    shared_context.reset();
    context.reset();
-    if (child) {
-        delete child;
-    }
-    if (container) {
-        delete container;
-    }
-    if (layout()) {
-        delete layout();
-    }
+
+    delete child;
+    child = nullptr;
+
+    delete container;
+    container = nullptr;
+
+    delete layout();

    first_frame = false;

-    switch (Settings::values.renderer_backend) {
-    case Settings::RendererBackend::OpenGL:
-        if (!InitializeOpenGL()) {
-            return false;
-        }
-        break;
-    case Settings::RendererBackend::Vulkan:
-        if (!InitializeVulkan()) {
-            return false;
-        }
-        break;
-    }
+    // TODO: One of these flags might be interesting: WA_OpaquePaintEvent, WA_NoBackground,
+    // WA_DontShowOnScreen, WA_DeleteOnClose
+    QSurfaceFormat fmt;
+    fmt.setVersion(4, 3);
+    fmt.setProfile(QSurfaceFormat::CompatibilityProfile);
+    fmt.setOption(QSurfaceFormat::FormatOption::DeprecatedFunctions);
+    // TODO: expose a setting for buffer value (ie default/single/double/triple)
+    fmt.setSwapBehavior(QSurfaceFormat::DefaultSwapBehavior);
+    shared_context = std::make_unique<QOpenGLContext>();
+    shared_context->setFormat(fmt);
+    shared_context->create();
+    context = std::make_unique<QOpenGLContext>();
+    context->setShareContext(shared_context.get());
+    context->setFormat(fmt);
+    context->create();
+    fmt.setSwapInterval(0);

+    child = new GGLWidgetInternal(this, shared_context.get());
    container = QWidget::createWindowContainer(child, this);
-    QBoxLayout* layout = new QHBoxLayout(this);

+    QBoxLayout* layout = new QHBoxLayout(this);
    layout->addWidget(container);
    layout->setMargin(0);
    setLayout(layout);

-    // Reset minimum required size to avoid resizing issues on the main window after restarting.
+    // Reset minimum size to avoid unwanted resizes when this function is called for a second time.
    setMinimumSize(1, 1);

-    // Show causes the window to actually be created and the gl context as well, but we don't want
-    // the widget to be shown yet, so immediately hide it.
+    // Show causes the window to actually be created and the OpenGL context as well, but we don't
+    // want the widget to be shown yet, so immediately hide it.
    show();
    hide();

@@ -473,17 +410,9 @@ bool GRenderWindow::InitRenderTarget() {
    OnMinimalClientAreaChangeRequest(GetActiveConfig().min_client_area_size);

    OnFramebufferSizeChanged();
-    NotifyClientAreaSizeChanged(child->GetSize());
+    NotifyClientAreaSizeChanged(std::pair<unsigned, unsigned>(child->width(), child->height()));

    BackupGeometry();
-
-    if (Settings::values.renderer_backend == Settings::RendererBackend::OpenGL) {
-        if (!LoadOpenGL()) {
-            return false;
-        }
-    }
-
-    return true;
 }

 void GRenderWindow::CaptureScreenshot(u32 res_scale, const QString& screenshot_path) {
@@ -512,113 +441,6 @@ void GRenderWindow::OnMinimalClientAreaChangeRequest(std::pair<u32, u32> minimal
    setMinimumSize(minimal_size.first, minimal_size.second);
 }

-bool GRenderWindow::InitializeOpenGL() {
-    // TODO: One of these flags might be interesting: WA_OpaquePaintEvent, WA_NoBackground,
-    // WA_DontShowOnScreen, WA_DeleteOnClose
-    QSurfaceFormat fmt;
-    fmt.setVersion(4, 3);
-    fmt.setProfile(QSurfaceFormat::CompatibilityProfile);
-    fmt.setOption(QSurfaceFormat::FormatOption::DeprecatedFunctions);
-    // TODO: expose a setting for buffer value (ie default/single/double/triple)
-    fmt.setSwapBehavior(QSurfaceFormat::DefaultSwapBehavior);
-    shared_context = std::make_unique<QOpenGLContext>();
-    shared_context->setFormat(fmt);
-    shared_context->create();
-    context = std::make_unique<QOpenGLContext>();
-    context->setShareContext(shared_context.get());
-    context->setFormat(fmt);
-    context->create();
-    fmt.setSwapInterval(false);
-
-    child = new GGLWidgetInternal(this, shared_context.get());
-    return true;
-}
-
-bool GRenderWindow::InitializeVulkan() {
-#ifdef HAS_VULKAN
-    vk_instance = std::make_unique<QVulkanInstance>();
-    vk_instance->setApiVersion(QVersionNumber(1, 1, 0));
-    vk_instance->setFlags(QVulkanInstance::Flag::NoDebugOutputRedirect);
-    if (Settings::values.renderer_debug) {
-        const auto supported_layers{vk_instance->supportedLayers()};
-        const bool found =
-            std::find_if(supported_layers.begin(), supported_layers.end(), [](const auto& layer) {
-                constexpr const char searched_layer[] = "VK_LAYER_LUNARG_standard_validation";
-                return layer.name == searched_layer;
-            });
-        if (found) {
-            vk_instance->setLayers(QByteArrayList() << "VK_LAYER_LUNARG_standard_validation");
-            vk_instance->setExtensions(QByteArrayList() << VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
-        }
-    }
-    if (!vk_instance->create()) {
-        QMessageBox::critical(
-            this, tr("Error while initializing Vulkan 1.1!"),
-            tr("Your OS doesn't seem to support Vulkan 1.1 instances, or you do not have the "
-               "latest graphics drivers."));
-        return false;
-    }
-
-    child = new GVKWidgetInternal(this, vk_instance.get());
-    return true;
-#else
-    QMessageBox::critical(this, tr("Vulkan not available!"),
-                          tr("yuzu has not been compiled with Vulkan support."));
-    return false;
-#endif
-}
-
-bool GRenderWindow::LoadOpenGL() {
-    Core::Frontend::ScopeAcquireWindowContext acquire_context{*this};
-    if (!gladLoadGL()) {
-        QMessageBox::critical(this, tr("Error while initializing OpenGL 4.3!"),
-                              tr("Your GPU may not support OpenGL 4.3, or you do not have the "
-                                 "latest graphics driver."));
-        return false;
-    }
-
-    QStringList unsupported_gl_extensions = GetUnsupportedGLExtensions();
-    if (!unsupported_gl_extensions.empty()) {
-        QMessageBox::critical(
-            this, tr("Error while initializing OpenGL!"),
-            tr("Your GPU may not support one or more required OpenGL extensions. Please ensure you "
-               "have the latest graphics driver.<br><br>Unsupported extensions:<br>") +
-                unsupported_gl_extensions.join(QStringLiteral("<br>")));
-        return false;
-    }
-    return true;
-}
-
-QStringList GRenderWindow::GetUnsupportedGLExtensions() const {
-    QStringList unsupported_ext;
-
-    if (!GLAD_GL_ARB_buffer_storage)
-        unsupported_ext.append(QStringLiteral("ARB_buffer_storage"));
-    if (!GLAD_GL_ARB_direct_state_access)
-        unsupported_ext.append(QStringLiteral("ARB_direct_state_access"));
-    if (!GLAD_GL_ARB_vertex_type_10f_11f_11f_rev)
-        unsupported_ext.append(QStringLiteral("ARB_vertex_type_10f_11f_11f_rev"));
-    if (!GLAD_GL_ARB_texture_mirror_clamp_to_edge)
-        unsupported_ext.append(QStringLiteral("ARB_texture_mirror_clamp_to_edge"));
-    if (!GLAD_GL_ARB_multi_bind)
-        unsupported_ext.append(QStringLiteral("ARB_multi_bind"));
-    if (!GLAD_GL_ARB_clip_control)
-        unsupported_ext.append(QStringLiteral("ARB_clip_control"));
-
-    // Extensions required to support some texture formats.
-    if (!GLAD_GL_EXT_texture_compression_s3tc)
-        unsupported_ext.append(QStringLiteral("EXT_texture_compression_s3tc"));
-    if (!GLAD_GL_ARB_texture_compression_rgtc)
-        unsupported_ext.append(QStringLiteral("ARB_texture_compression_rgtc"));
-    if (!GLAD_GL_ARB_depth_buffer_float)
-        unsupported_ext.append(QStringLiteral("ARB_depth_buffer_float"));
-
-    for (const QString& ext : unsupported_ext)
-        LOG_CRITICAL(Frontend, "Unsupported GL extension: {}", ext.toStdString());
-
-    return unsupported_ext;
-}
-
 void GRenderWindow::OnEmulationStarting(EmuThread* emu_thread) {
    this->emu_thread = emu_thread;
    child->DisablePainting();
@@ -7,28 +7,17 @@
 #include <atomic>
 #include <condition_variable>
 #include <mutex>
-
 #include <QImage>
 #include <QThread>
 #include <QWidget>
-
-#include "common/thread.h"
 #include "core/core.h"
 #include "core/frontend/emu_window.h"

 class QKeyEvent;
 class QScreen;
 class QTouchEvent;
-class QStringList;
-class QSurface;
-class QOpenGLContext;
-#ifdef HAS_VULKAN
-class QVulkanInstance;
-#endif

-class GWidgetInternal;
 class GGLWidgetInternal;
-class GVKWidgetInternal;
 class GMainWindow;
 class GRenderWindow;
 class QSurface;
@@ -134,9 +123,6 @@ public:
    void MakeCurrent() override;
    void DoneCurrent() override;
    void PollEvents() override;
-    bool IsShown() const override;
-    void RetrieveVulkanHandlers(void* get_instance_proc_addr, void* instance,
-                                void* surface) const override;
    std::unique_ptr<Core::Frontend::GraphicsContext> CreateSharedContext() const override;

    void ForwardKeyPressEvent(QKeyEvent* event);
@@ -156,7 +142,7 @@ public:

    void OnClientAreaResized(u32 width, u32 height);

-    bool InitRenderTarget();
+    void InitRenderTarget();

    void CaptureScreenshot(u32 res_scale, const QString& screenshot_path);

@@ -179,13 +165,10 @@ private:

    void OnMinimalClientAreaChangeRequest(std::pair<u32, u32> minimal_size) override;

-    bool InitializeOpenGL();
-    bool InitializeVulkan();
-    bool LoadOpenGL();
-    QStringList GetUnsupportedGLExtensions() const;
-
    QWidget* container = nullptr;
-    GWidgetInternal* child = nullptr;
+    GGLWidgetInternal* child = nullptr;
+
+    QByteArray geometry;

    EmuThread* emu_thread;
    // Context that backs the GGLWidgetInternal (and will be used by core to render)
@@ -194,14 +177,9 @@ private:
    // current
    std::unique_ptr<QOpenGLContext> shared_context;

-#ifdef HAS_VULKAN
-    std::unique_ptr<QVulkanInstance> vk_instance;
-#endif
-
    /// Temporary storage of the screenshot taken
    QImage screenshot_image;

-    QByteArray geometry;
    bool first_frame = false;

 protected:
@@ -624,10 +624,6 @@ void Config::ReadPathValues() {
 void Config::ReadRendererValues() {
    qt_config->beginGroup(QStringLiteral("Renderer"));

-    Settings::values.renderer_backend =
-        static_cast<Settings::RendererBackend>(ReadSetting(QStringLiteral("backend"), 0).toInt());
-    Settings::values.renderer_debug = ReadSetting(QStringLiteral("debug"), false).toBool();
-    Settings::values.vulkan_device = ReadSetting(QStringLiteral("vulkan_device"), 0).toInt();
    Settings::values.resolution_factor =
        ReadSetting(QStringLiteral("resolution_factor"), 1.0).toFloat();
    Settings::values.use_frame_limit =
@@ -1060,9 +1056,6 @@ void Config::SavePathValues() {
 void Config::SaveRendererValues() {
    qt_config->beginGroup(QStringLiteral("Renderer"));

-    WriteSetting(QStringLiteral("backend"), static_cast<int>(Settings::values.renderer_backend), 0);
-    WriteSetting(QStringLiteral("debug"), Settings::values.renderer_debug, false);
-    WriteSetting(QStringLiteral("vulkan_device"), Settings::values.vulkan_device, 0);
    WriteSetting(QStringLiteral("resolution_factor"),
                 static_cast<double>(Settings::values.resolution_factor), 1.0);
    WriteSetting(QStringLiteral("use_frame_limit"), Settings::values.use_frame_limit, true);
@@ -48,7 +48,7 @@
         <string>General</string>
        </attribute>
       </widget>
-       <widget class="ConfigureUi" name="uiTab">
+       <widget class="ConfigureGameList" name="gameListTab">
        <attribute name="title">
         <string>Game List</string>
        </attribute>
@@ -166,9 +166,9 @@
   <container>1</container>
  </customwidget>
  <customwidget>
-   <class>ConfigureUi</class>
+   <class>ConfigureGameList</class>
   <extends>QWidget</extends>
-   <header>configuration/configure_ui.h</header>
+   <header>configuration/configure_gamelist.h</header>
   <container>1</container>
  </customwidget>
  <customwidget>
@@ -36,8 +36,6 @@ void ConfigureDebug::SetConfiguration() {
    ui->homebrew_args_edit->setText(QString::fromStdString(Settings::values.program_args));
    ui->reporting_services->setChecked(Settings::values.reporting_services);
    ui->quest_flag->setChecked(Settings::values.quest_flag);
-    ui->enable_graphics_debugging->setEnabled(!Core::System::GetInstance().IsPoweredOn());
-    ui->enable_graphics_debugging->setChecked(Settings::values.renderer_debug);
 }

 void ConfigureDebug::ApplyConfiguration() {
@@ -48,7 +46,6 @@ void ConfigureDebug::ApplyConfiguration() {
    Settings::values.program_args = ui->homebrew_args_edit->text().toStdString();
    Settings::values.reporting_services = ui->reporting_services->isChecked();
    Settings::values.quest_flag = ui->quest_flag->isChecked();
-    Settings::values.renderer_debug = ui->enable_graphics_debugging->isChecked();
    Debugger::ToggleConsole();
    Log::Filter filter;
    filter.ParseFilterString(Settings::values.log_filter);
@@ -7,7 +7,7 @@
    <x>0</x>
    <y>0</y>
    <width>400</width>
-    <height>467</height>
+    <height>474</height>
   </rect>
  </property>
  <property name="windowTitle">
@@ -103,6 +103,44 @@
        </item>
       </layout>
      </item>
+      <item>
+       <widget class="QCheckBox" name="reporting_services">
+        <property name="text">
+         <string>Enable Verbose Reporting Services</string>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <widget class="QLabel" name="label">
+        <property name="font">
+         <font>
+          <italic>true</italic>
+         </font>
+        </property>
+        <property name="text">
+         <string>This will be reset automatically when yuzu closes.</string>
+        </property>
+        <property name="indent">
+         <number>20</number>
+        </property>
+       </widget>
+      </item>
+     </layout>
+    </widget>
+   </item>
+   <item>
+    <widget class="QGroupBox" name="groupBox_5">
+     <property name="title">
+      <string>Advanced</string>
+     </property>
+     <layout class="QVBoxLayout" name="verticalLayout">
+      <item>
+       <widget class="QCheckBox" name="quest_flag">
+        <property name="text">
+         <string>Kiosk (Quest) Mode</string>
+        </property>
+       </widget>
+      </item>
     </layout>
    </widget>
   </item>
@@ -129,95 +167,6 @@
     </layout>
    </widget>
   </item>
-   <item>
-    <widget class="QGroupBox" name="groupBox_4">
-     <property name="title">
-      <string>Graphics</string>
-     </property>
-     <layout class="QVBoxLayout" name="verticalLayout_6">
-      <item>
-       <widget class="QCheckBox" name="enable_graphics_debugging">
-        <property name="enabled">
-         <bool>true</bool>
-        </property>
-        <property name="whatsThis">
-         <string>When checked, the graphics API enters in a slower debugging mode</string>
-        </property>
-        <property name="text">
-         <string>Enable Graphics Debugging</string>
-        </property>
-       </widget>
-      </item>
-     </layout>
-    </widget>
-   </item>
-   <item>
-    <widget class="QGroupBox" name="groupBox_5">
-     <property name="title">
-      <string>Dump</string>
-     </property>
-     <layout class="QVBoxLayout" name="verticalLayout_6">
-      <item>
-       <widget class="QCheckBox" name="dump_decompressed_nso">
-        <property name="whatsThis">
-         <string>When checked, any NSO yuzu tries to load or patch will be copied decompressed to the yuzu/dump directory.</string>
-        </property>
-        <property name="text">
-         <string>Dump Decompressed NSOs</string>
-        </property>
-       </widget>
-      </item>
-      <item>
-       <widget class="QCheckBox" name="dump_exefs">
-        <property name="whatsThis">
-         <string>When checked, any game that yuzu loads will have its ExeFS dumped to the yuzu/dump directory.</string>
-        </property>
-        <property name="text">
-         <string>Dump ExeFS</string>
-        </property>
-       </widget>
-      </item>
-      <item>
-       <widget class="QCheckBox" name="reporting_services">
-        <property name="text">
-         <string>Enable Verbose Reporting Services</string>
-        </property>
-       </widget>
-      </item>
-      <item>
-       <widget class="QLabel" name="label">
-        <property name="font">
-         <font>
-          <italic>true</italic>
-         </font>
-        </property>
-        <property name="text">
-         <string>This will be reset automatically when yuzu closes.</string>
-        </property>
-        <property name="indent">
-         <number>20</number>
-        </property>
-       </widget>
-      </item>
-     </layout>
-    </widget>
-   </item>
-   <item>
-    <widget class="QGroupBox" name="groupBox_6">
-     <property name="title">
-      <string>Advanced</string>
-     </property>
-     <layout class="QVBoxLayout" name="verticalLayout_7">
-      <item>
-       <widget class="QCheckBox" name="quest_flag">
-        <property name="text">
-         <string>Kiosk (Quest) Mode</string>
-        </property>
-       </widget>
-      </item>
-     </layout>
-    </widget>
-   </item>
   <item>
    <spacer name="verticalSpacer">
     <property name="orientation">
@@ -236,19 +185,6 @@
   </item>
  </layout>
 </widget>
- <tabstops>
-  <tabstop>toggle_gdbstub</tabstop>
-  <tabstop>gdbport_spinbox</tabstop>
-  <tabstop>log_filter_edit</tabstop>
-  <tabstop>toggle_console</tabstop>
-  <tabstop>open_log_button</tabstop>
-  <tabstop>homebrew_args_edit</tabstop>
-  <tabstop>enable_graphics_debugging</tabstop>
-  <tabstop>dump_decompressed_nso</tabstop>
-  <tabstop>dump_exefs</tabstop>
-  <tabstop>reporting_services</tabstop>
-  <tabstop>quest_flag</tabstop>
- </tabstops>
 <resources/>
 <connections>
  <connection>
@@ -34,7 +34,7 @@ void ConfigureDialog::SetConfiguration() {}

 void ConfigureDialog::ApplyConfiguration() {
    ui->generalTab->ApplyConfiguration();
-    ui->uiTab->ApplyConfiguration();
+    ui->gameListTab->ApplyConfiguration();
    ui->systemTab->ApplyConfiguration();
    ui->profileManagerTab->ApplyConfiguration();
    ui->filesystemTab->applyConfiguration();
@@ -74,7 +74,7 @@ Q_DECLARE_METATYPE(QList<QWidget*>);

 void ConfigureDialog::PopulateSelectionList() {
    const std::array<std::pair<QString, QList<QWidget*>>, 5> items{
-        {{tr("General"), {ui->generalTab, ui->webTab, ui->debugTab, ui->uiTab}},
+        {{tr("General"), {ui->generalTab, ui->webTab, ui->debugTab, ui->gameListTab}},
         {tr("System"), {ui->systemTab, ui->profileManagerTab, ui->serviceTab, ui->filesystemTab}},
         {tr("Graphics"), {ui->graphicsTab}},
         {tr("Audio"), {ui->audioTab}},
@@ -108,7 +108,7 @@ void ConfigureDialog::UpdateVisibleTabs() {
        {ui->audioTab, tr("Audio")},
        {ui->debugTab, tr("Debug")},
        {ui->webTab, tr("Web")},
-        {ui->uiTab, tr("UI")},
+        {ui->gameListTab, tr("Game List")},
        {ui->filesystemTab, tr("Filesystem")},
        {ui->serviceTab, tr("Services")},
    };
@@ -7,8 +7,8 @@

 #include "common/common_types.h"
 #include "core/settings.h"
-#include "ui_configure_ui.h"
-#include "yuzu/configuration/configure_ui.h"
+#include "ui_configure_gamelist.h"
+#include "yuzu/configuration/configure_gamelist.h"
 #include "yuzu/uisettings.h"

 namespace {
@@ -26,40 +26,35 @@ constexpr std::array row_text_names{
 };
 } // Anonymous namespace

-ConfigureUi::ConfigureUi(QWidget* parent) : QWidget(parent), ui(new Ui::ConfigureUi) {
+ConfigureGameList::ConfigureGameList(QWidget* parent)
+    : QWidget(parent), ui(new Ui::ConfigureGameList) {
    ui->setupUi(this);

-    for (const auto& theme : UISettings::themes) {
-        ui->theme_combobox->addItem(QString::fromUtf8(theme.first),
-                                    QString::fromUtf8(theme.second));
-    }
-
    InitializeIconSizeComboBox();
    InitializeRowComboBoxes();

    SetConfiguration();

    // Force game list reload if any of the relevant settings are changed.
-    connect(ui->show_unknown, &QCheckBox::stateChanged, this, &ConfigureUi::RequestGameListUpdate);
+    connect(ui->show_unknown, &QCheckBox::stateChanged, this,
+            &ConfigureGameList::RequestGameListUpdate);
    connect(ui->icon_size_combobox, QOverload<int>::of(&QComboBox::currentIndexChanged), this,
-            &ConfigureUi::RequestGameListUpdate);
+            &ConfigureGameList::RequestGameListUpdate);
    connect(ui->row_1_text_combobox, QOverload<int>::of(&QComboBox::currentIndexChanged), this,
-            &ConfigureUi::RequestGameListUpdate);
+            &ConfigureGameList::RequestGameListUpdate);
    connect(ui->row_2_text_combobox, QOverload<int>::of(&QComboBox::currentIndexChanged), this,
-            &ConfigureUi::RequestGameListUpdate);
+            &ConfigureGameList::RequestGameListUpdate);

    // Update text ComboBoxes after user interaction.
    connect(ui->row_1_text_combobox, QOverload<int>::of(&QComboBox::activated),
-            [=]() { ConfigureUi::UpdateSecondRowComboBox(); });
+            [=]() { ConfigureGameList::UpdateSecondRowComboBox(); });
    connect(ui->row_2_text_combobox, QOverload<int>::of(&QComboBox::activated),
-            [=]() { ConfigureUi::UpdateFirstRowComboBox(); });
+            [=]() { ConfigureGameList::UpdateFirstRowComboBox(); });
 }

-ConfigureUi::~ConfigureUi() = default;
+ConfigureGameList::~ConfigureGameList() = default;

-void ConfigureUi::ApplyConfiguration() {
-    UISettings::values.theme =
-        ui->theme_combobox->itemData(ui->theme_combobox->currentIndex()).toString();
+void ConfigureGameList::ApplyConfiguration() {
    UISettings::values.show_unknown = ui->show_unknown->isChecked();
    UISettings::values.show_add_ons = ui->show_add_ons->isChecked();
    UISettings::values.icon_size = ui->icon_size_combobox->currentData().toUInt();
@@ -68,19 +63,18 @@ void ConfigureUi::ApplyConfiguration() {
    Settings::Apply();
 }

-void ConfigureUi::RequestGameListUpdate() {
+void ConfigureGameList::RequestGameListUpdate() {
    UISettings::values.is_game_list_reload_pending.exchange(true);
 }

-void ConfigureUi::SetConfiguration() {
-    ui->theme_combobox->setCurrentIndex(ui->theme_combobox->findData(UISettings::values.theme));
+void ConfigureGameList::SetConfiguration() {
    ui->show_unknown->setChecked(UISettings::values.show_unknown);
    ui->show_add_ons->setChecked(UISettings::values.show_add_ons);
    ui->icon_size_combobox->setCurrentIndex(
        ui->icon_size_combobox->findData(UISettings::values.icon_size));
 }

-void ConfigureUi::changeEvent(QEvent* event) {
+void ConfigureGameList::changeEvent(QEvent* event) {
    if (event->type() == QEvent::LanguageChange) {
        RetranslateUI();
    }
@@ -88,7 +82,7 @@ void ConfigureUi::changeEvent(QEvent* event) {
    QWidget::changeEvent(event);
 }

-void ConfigureUi::RetranslateUI() {
+void ConfigureGameList::RetranslateUI() {
    ui->retranslateUi(this);

    for (int i = 0; i < ui->icon_size_combobox->count(); i++) {
@@ -103,18 +97,18 @@ void ConfigureUi::RetranslateUI() {
    }
 }

-void ConfigureUi::InitializeIconSizeComboBox() {
+void ConfigureGameList::InitializeIconSizeComboBox() {
    for (const auto& size : default_icon_sizes) {
        ui->icon_size_combobox->addItem(QString::fromUtf8(size.second), size.first);
    }
 }

-void ConfigureUi::InitializeRowComboBoxes() {
+void ConfigureGameList::InitializeRowComboBoxes() {
    UpdateFirstRowComboBox(true);
    UpdateSecondRowComboBox(true);
 }

-void ConfigureUi::UpdateFirstRowComboBox(bool init) {
+void ConfigureGameList::UpdateFirstRowComboBox(bool init) {
    const int currentIndex =
        init ? UISettings::values.row_1_text_id
             : ui->row_1_text_combobox->findData(ui->row_1_text_combobox->currentData());
@@ -133,7 +127,7 @@ void ConfigureUi::UpdateFirstRowComboBox(bool init) {
        ui->row_1_text_combobox->findData(ui->row_2_text_combobox->currentData()));
 }

-void ConfigureUi::UpdateSecondRowComboBox(bool init) {
+void ConfigureGameList::UpdateSecondRowComboBox(bool init) {
    const int currentIndex =
        init ? UISettings::values.row_2_text_id
             : ui->row_2_text_combobox->findData(ui->row_2_text_combobox->currentData());
@@ -8,15 +8,15 @@
 #include <QWidget>

 namespace Ui {
-class ConfigureUi;
+class ConfigureGameList;
 }

-class ConfigureUi : public QWidget {
+class ConfigureGameList : public QWidget {
    Q_OBJECT

 public:
-    explicit ConfigureUi(QWidget* parent = nullptr);
-    ~ConfigureUi() override;
+    explicit ConfigureGameList(QWidget* parent = nullptr);
+    ~ConfigureGameList() override;

    void ApplyConfiguration();

@@ -34,5 +34,5 @@ private:
    void UpdateFirstRowComboBox(bool init = false);
    void UpdateSecondRowComboBox(bool init = false);

-    std::unique_ptr<Ui::ConfigureUi> ui;
+    std::unique_ptr<Ui::ConfigureGameList> ui;
 };
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
- <class>ConfigureUi</class>
- <widget class="QWidget" name="ConfigureUi">
+ <class>ConfigureGameList</class>
+ <widget class="QWidget" name="ConfigureGameList">
  <property name="geometry">
   <rect>
    <x>0</x>
@@ -21,34 +21,7 @@
       <property name="title">
        <string>General</string>
       </property>
-       <layout class="QHBoxLayout" name="horizontalLayout">
-        <item>
-         <layout class="QVBoxLayout" name="verticalLayout">
-          <item>
-           <layout class="QHBoxLayout" name="horizontalLayout_3">
-            <item>
-             <widget class="QLabel" name="theme_label">
-              <property name="text">
-               <string>Theme:</string>
-              </property>
-             </widget>
-            </item>
-            <item>
-             <widget class="QComboBox" name="theme_combobox"/>
-            </item>
-           </layout>
-          </item>
-         </layout>
-        </item>
-       </layout>
-      </widget>
-     </item>
-     <item>
-      <widget class="QGroupBox" name="GameListGroupBox">
-       <property name="title">
-        <string>Game List</string>
-       </property>
-       <layout class="QHBoxLayout" name="GameListHorizontalLayout">
+       <layout class="QHBoxLayout" name="GeneralHorizontalLayout">
        <item>
         <layout class="QVBoxLayout" name="GeneralVerticalLayout">
          <item>
@@ -65,6 +38,19 @@
            </property>
           </widget>
          </item>
+         </layout>
+        </item>
+       </layout>
+      </widget>
+     </item>
+     <item>
+      <widget class="QGroupBox" name="IconSizeGroupBox">
+       <property name="title">
+        <string>Icon Size</string>
+       </property>
+       <layout class="QHBoxLayout" name="icon_size_qhbox_layout">
+        <item>
+         <layout class="QVBoxLayout" name="icon_size_qvbox_layout">
          <item>
           <layout class="QHBoxLayout" name="icon_size_qhbox_layout_2">
            <item>
@@ -79,6 +65,19 @@
            </item>
           </layout>
          </item>
+         </layout>
+        </item>
+       </layout>
+      </widget>
+     </item>
+     <item>
+      <widget class="QGroupBox" name="RowGroupBox">
+       <property name="title">
+        <string>Row Text</string>
+       </property>
+       <layout class="QHBoxLayout" name="RowHorizontalLayout">
+        <item>
+         <layout class="QVBoxLayout" name="RowVerticalLayout">
          <item>
           <layout class="QHBoxLayout" name="row_1_qhbox_layout">
            <item>
@@ -15,6 +15,11 @@ ConfigureGeneral::ConfigureGeneral(QWidget* parent)

    ui->setupUi(this);

+    for (const auto& theme : UISettings::themes) {
+        ui->theme_combobox->addItem(QString::fromUtf8(theme.first),
+                                    QString::fromUtf8(theme.second));
+    }
+
    SetConfiguration();

    connect(ui->toggle_frame_limit, &QCheckBox::toggled, ui->frame_limit, &QSpinBox::setEnabled);
@@ -25,6 +30,7 @@ ConfigureGeneral::~ConfigureGeneral() = default;
 void ConfigureGeneral::SetConfiguration() {
    ui->toggle_check_exit->setChecked(UISettings::values.confirm_before_closing);
    ui->toggle_user_on_boot->setChecked(UISettings::values.select_user_on_boot);
+    ui->theme_combobox->setCurrentIndex(ui->theme_combobox->findData(UISettings::values.theme));
    ui->toggle_background_pause->setChecked(UISettings::values.pause_when_in_background);

    ui->toggle_frame_limit->setChecked(Settings::values.use_frame_limit);
@@ -35,6 +41,8 @@ void ConfigureGeneral::SetConfiguration() {
 void ConfigureGeneral::ApplyConfiguration() {
    UISettings::values.confirm_before_closing = ui->toggle_check_exit->isChecked();
    UISettings::values.select_user_on_boot = ui->toggle_user_on_boot->isChecked();
+    UISettings::values.theme =
+        ui->theme_combobox->itemData(ui->theme_combobox->currentIndex()).toString();
    UISettings::values.pause_when_in_background = ui->toggle_background_pause->isChecked();

    Settings::values.use_frame_limit = ui->toggle_frame_limit->isChecked();
@@ -65,12 +65,39 @@
            </property>
           </widget>
          </item>
+           <item>
+             <widget class="QCheckBox" name="toggle_background_pause">
+               <property name="text">
+                 <string>Pause emulation when in background</string>
+               </property>
+             </widget>
+           </item>
+         </layout>
+        </item>
+       </layout>
+      </widget>
+     </item>
+     <item>
+      <widget class="QGroupBox" name="theme_group_box">
+       <property name="title">
+        <string>Theme</string>
+       </property>
+       <layout class="QHBoxLayout" name="theme_qhbox_layout">
+        <item>
+         <layout class="QVBoxLayout" name="theme_qvbox_layout">
          <item>
-           <widget class="QCheckBox" name="toggle_background_pause">
-            <property name="text">
-             <string>Pause emulation when in background</string>
-            </property>
-           </widget>
+           <layout class="QHBoxLayout" name="theme_qhbox_layout_2">
+            <item>
+             <widget class="QLabel" name="theme_label">
+              <property name="text">
+               <string>Theme:</string>
+              </property>
+             </widget>
+            </item>
+            <item>
+             <widget class="QComboBox" name="theme_combobox"/>
+            </item>
+           </layout>
          </item>
         </layout>
        </item>
@@ -3,13 +3,6 @@
 // Refer to the license.txt file included.

 #include <QColorDialog>
-#include <QComboBox>
-#ifdef HAS_VULKAN
-#include <QVulkanInstance>
-#endif
-
-#include "common/common_types.h"
-#include "common/logging/log.h"
 #include "core/core.h"
 #include "core/settings.h"
 #include "ui_configure_graphics.h"
@@ -58,18 +51,10 @@ Resolution FromResolutionFactor(float factor) {

 ConfigureGraphics::ConfigureGraphics(QWidget* parent)
    : QWidget(parent), ui(new Ui::ConfigureGraphics) {
-    vulkan_device = Settings::values.vulkan_device;
-    RetrieveVulkanDevices();
-
    ui->setupUi(this);

    SetConfiguration();

-    connect(ui->api, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this,
-            [this] { UpdateDeviceComboBox(); });
-    connect(ui->device, static_cast<void (QComboBox::*)(int)>(&QComboBox::activated), this,
-            [this](int device) { UpdateDeviceSelection(device); });
-
    connect(ui->bg_button, &QPushButton::clicked, this, [this] {
        const QColor new_bg_color = QColorDialog::getColor(bg_color);
        if (!new_bg_color.isValid()) {
@@ -79,22 +64,11 @@ ConfigureGraphics::ConfigureGraphics(QWidget* parent)
    });
 }

-void ConfigureGraphics::UpdateDeviceSelection(int device) {
-    if (device == -1) {
-        return;
-    }
-    if (GetCurrentGraphicsBackend() == Settings::RendererBackend::Vulkan) {
-        vulkan_device = device;
-    }
-}
-
 ConfigureGraphics::~ConfigureGraphics() = default;

 void ConfigureGraphics::SetConfiguration() {
    const bool runtime_lock = !Core::System::GetInstance().IsPoweredOn();

-    ui->api->setEnabled(runtime_lock);
-    ui->api->setCurrentIndex(static_cast<int>(Settings::values.renderer_backend));
    ui->resolution_factor_combobox->setCurrentIndex(
        static_cast<int>(FromResolutionFactor(Settings::values.resolution_factor)));
    ui->use_disk_shader_cache->setEnabled(runtime_lock);
@@ -106,12 +80,9 @@ void ConfigureGraphics::SetConfiguration() {
    ui->force_30fps_mode->setChecked(Settings::values.force_30fps_mode);
    UpdateBackgroundColorButton(QColor::fromRgbF(Settings::values.bg_red, Settings::values.bg_green,
                                                 Settings::values.bg_blue));
-    UpdateDeviceComboBox();
 }

 void ConfigureGraphics::ApplyConfiguration() {
-    Settings::values.renderer_backend = GetCurrentGraphicsBackend();
-    Settings::values.vulkan_device = vulkan_device;
    Settings::values.resolution_factor =
        ToResolutionFactor(static_cast<Resolution>(ui->resolution_factor_combobox->currentIndex()));
    Settings::values.use_disk_shader_cache = ui->use_disk_shader_cache->isChecked();
@@ -145,68 +116,3 @@ void ConfigureGraphics::UpdateBackgroundColorButton(QColor color) {
    const QIcon color_icon(pixmap);
    ui->bg_button->setIcon(color_icon);
 }
-
-void ConfigureGraphics::UpdateDeviceComboBox() {
-    ui->device->clear();
-
-    bool enabled = false;
-    switch (GetCurrentGraphicsBackend()) {
-    case Settings::RendererBackend::OpenGL:
-        ui->device->addItem(tr("OpenGL Graphics Device"));
-        enabled = false;
-        break;
-    case Settings::RendererBackend::Vulkan:
-        for (const auto device : vulkan_devices) {
-            ui->device->addItem(device);
-        }
-        ui->device->setCurrentIndex(vulkan_device);
-        enabled = !vulkan_devices.empty();
-        break;
-    }
-    ui->device->setEnabled(enabled && !Core::System::GetInstance().IsPoweredOn());
-}
-
-void ConfigureGraphics::RetrieveVulkanDevices() {
-#ifdef HAS_VULKAN
-    QVulkanInstance instance;
-    instance.setApiVersion(QVersionNumber(1, 1, 0));
-    if (!instance.create()) {
-        LOG_INFO(Frontend, "Vulkan 1.1 not available");
-        return;
-    }
-    const auto vkEnumeratePhysicalDevices{reinterpret_cast<PFN_vkEnumeratePhysicalDevices>(
-        instance.getInstanceProcAddr("vkEnumeratePhysicalDevices"))};
-    if (vkEnumeratePhysicalDevices == nullptr) {
-        LOG_INFO(Frontend, "Failed to get pointer to vkEnumeratePhysicalDevices");
-        return;
-    }
-    u32 physical_device_count;
-    if (vkEnumeratePhysicalDevices(instance.vkInstance(), &physical_device_count, nullptr) !=
-        VK_SUCCESS) {
-        LOG_INFO(Frontend, "Failed to get physical devices count");
-        return;
-    }
-    std::vector<VkPhysicalDevice> physical_devices(physical_device_count);
-    if (vkEnumeratePhysicalDevices(instance.vkInstance(), &physical_device_count,
-                                   physical_devices.data()) != VK_SUCCESS) {
-        LOG_INFO(Frontend, "Failed to get physical devices");
-        return;
-    }
-
-    const auto vkGetPhysicalDeviceProperties{reinterpret_cast<PFN_vkGetPhysicalDeviceProperties>(
-        instance.getInstanceProcAddr("vkGetPhysicalDeviceProperties"))};
-    if (vkGetPhysicalDeviceProperties == nullptr) {
-        LOG_INFO(Frontend, "Failed to get pointer to vkGetPhysicalDeviceProperties");
-        return;
-    }
-    for (const auto physical_device : physical_devices) {
-        VkPhysicalDeviceProperties properties;
-        vkGetPhysicalDeviceProperties(physical_device, &properties);
-        vulkan_devices.push_back(QString::fromUtf8(properties.deviceName));
-    }
-#endif
-}
-
-Settings::RendererBackend ConfigureGraphics::GetCurrentGraphicsBackend() const {
-    return static_cast<Settings::RendererBackend>(ui->api->currentIndex());
-}
@@ -5,10 +5,7 @@
 #pragma once

 #include <memory>
-#include <vector>
-#include <QString>
 #include <QWidget>
-#include "core/settings.h"

 namespace Ui {
 class ConfigureGraphics;
@@ -30,16 +27,7 @@ private:
    void SetConfiguration();

    void UpdateBackgroundColorButton(QColor color);
-    void UpdateDeviceComboBox();
-    void UpdateDeviceSelection(int device);
-
-    void RetrieveVulkanDevices();
-
-    Settings::RendererBackend GetCurrentGraphicsBackend() const;

    std::unique_ptr<Ui::ConfigureGraphics> ui;
    QColor bg_color;
-
-    std::vector<QString> vulkan_devices;
-    u32 vulkan_device{};
 };
@@ -7,69 +7,21 @@
    <x>0</x>
    <y>0</y>
    <width>400</width>
-    <height>321</height>
+    <height>300</height>
   </rect>
  </property>
  <property name="windowTitle">
   <string>Form</string>
  </property>
-  <layout class="QVBoxLayout" name="verticalLayout_1">
+  <layout class="QVBoxLayout" name="verticalLayout">
   <item>
-    <layout class="QVBoxLayout" name="verticalLayout_2">
-     <item>
-      <widget class="QGroupBox" name="groupBox_2">
-       <property name="title">
-        <string>API Settings</string>
-       </property>
-       <layout class="QVBoxLayout" name="verticalLayout_3">
-        <item>
-         <layout class="QHBoxLayout" name="horizontalLayout_4">
-          <item>
-           <widget class="QLabel" name="label_2">
-            <property name="text">
-             <string>API:</string>
-            </property>
-           </widget>
-          </item>
-          <item>
-           <widget class="QComboBox" name="api">
-            <item>
-             <property name="text">
-              <string notr="true">OpenGL</string>
-             </property>
-            </item>
-            <item>
-             <property name="text">
-              <string notr="true">Vulkan</string>
-             </property>
-            </item>
-           </widget>
-          </item>
-         </layout>
-        </item>
-        <item>
-         <layout class="QHBoxLayout" name="horizontalLayout_5">
-          <item>
-           <widget class="QLabel" name="label_3">
-            <property name="text">
-             <string>Device:</string>
-            </property>
-           </widget>
-          </item>
-          <item>
-           <widget class="QComboBox" name="device"/>
-          </item>
-         </layout>
-        </item>
-       </layout>
-      </widget>
-     </item>
+    <layout class="QVBoxLayout" name="verticalLayout_3">
     <item>
      <widget class="QGroupBox" name="groupBox">
       <property name="title">
-        <string>Graphics Settings</string>
+        <string>Graphics</string>
       </property>
-       <layout class="QVBoxLayout" name="verticalLayout_4">
+       <layout class="QVBoxLayout" name="verticalLayout_2">
        <item>
         <widget class="QCheckBox" name="use_disk_shader_cache">
          <property name="text">
@@ -77,13 +29,6 @@
          </property>
         </widget>
        </item>
-        <item>
-         <widget class="QCheckBox" name="use_asynchronous_gpu_emulation">
-          <property name="text">
-           <string>Use asynchronous GPU emulation</string>
-          </property>
-         </widget>
-        </item>
        <item>
         <widget class="QCheckBox" name="use_accurate_gpu_emulation">
          <property name="text">
@@ -91,6 +36,13 @@
          </property>
         </widget>
        </item>
+        <item>
+         <widget class="QCheckBox" name="use_asynchronous_gpu_emulation">
+          <property name="text">
+           <string>Use asynchronous GPU emulation</string>
+          </property>
+         </widget>
+        </item>
        <item>
         <widget class="QCheckBox" name="force_30fps_mode">
          <property name="text">
@@ -99,11 +51,11 @@
         </widget>
        </item>
        <item>
-         <layout class="QHBoxLayout" name="horizontalLayout_2">
+         <layout class="QHBoxLayout" name="horizontalLayout">
          <item>
           <widget class="QLabel" name="label">
            <property name="text">
-             <string>Internal Resolution:</string>
+             <string>Internal Resolution</string>
            </property>
           </widget>
          </item>
@@ -139,7 +91,7 @@
         </layout>
        </item>
        <item>
-         <layout class="QHBoxLayout" name="horizontalLayout_3">
+         <layout class="QHBoxLayout" name="horizontalLayout_6">
          <item>
           <widget class="QLabel" name="bg_label">
            <property name="text">
@@ -806,12 +806,70 @@ void GMainWindow::AllowOSSleep() {
 #endif
 }

+QStringList GMainWindow::GetUnsupportedGLExtensions() {
+    QStringList unsupported_ext;
+
+    if (!GLAD_GL_ARB_buffer_storage) {
+        unsupported_ext.append(QStringLiteral("ARB_buffer_storage"));
+    }
+    if (!GLAD_GL_ARB_direct_state_access) {
+        unsupported_ext.append(QStringLiteral("ARB_direct_state_access"));
+    }
+    if (!GLAD_GL_ARB_vertex_type_10f_11f_11f_rev) {
+        unsupported_ext.append(QStringLiteral("ARB_vertex_type_10f_11f_11f_rev"));
+    }
+    if (!GLAD_GL_ARB_texture_mirror_clamp_to_edge) {
+        unsupported_ext.append(QStringLiteral("ARB_texture_mirror_clamp_to_edge"));
+    }
+    if (!GLAD_GL_ARB_multi_bind) {
+        unsupported_ext.append(QStringLiteral("ARB_multi_bind"));
+    }
+    if (!GLAD_GL_ARB_clip_control) {
+        unsupported_ext.append(QStringLiteral("ARB_clip_control"));
+    }
+
+    // Extensions required to support some texture formats.
+    if (!GLAD_GL_EXT_texture_compression_s3tc) {
+        unsupported_ext.append(QStringLiteral("EXT_texture_compression_s3tc"));
+    }
+    if (!GLAD_GL_ARB_texture_compression_rgtc) {
+        unsupported_ext.append(QStringLiteral("ARB_texture_compression_rgtc"));
+    }
+    if (!GLAD_GL_ARB_depth_buffer_float) {
+        unsupported_ext.append(QStringLiteral("ARB_depth_buffer_float"));
+    }
+
+    for (const QString& ext : unsupported_ext) {
+        LOG_CRITICAL(Frontend, "Unsupported GL extension: {}", ext.toStdString());
+    }
+
+    return unsupported_ext;
+}
+
 bool GMainWindow::LoadROM(const QString& filename) {
    // Shutdown previous session if the emu thread is still active...
    if (emu_thread != nullptr)
        ShutdownGame();

-    if (!render_window->InitRenderTarget()) {
+    render_window->InitRenderTarget();
+
+    {
+        Core::Frontend::ScopeAcquireWindowContext acquire_context{*render_window};
+        if (!gladLoadGL()) {
+            QMessageBox::critical(this, tr("Error while initializing OpenGL 4.3 Core!"),
+                                  tr("Your GPU may not support OpenGL 4.3, or you do not "
+                                     "have the latest graphics driver."));
+            return false;
+        }
+    }
+
+    const QStringList unsupported_gl_extensions = GetUnsupportedGLExtensions();
+    if (!unsupported_gl_extensions.empty()) {
+        QMessageBox::critical(this, tr("Error while initializing OpenGL Core!"),
+                              tr("Your GPU may not support one or more required OpenGL"
+                                 "extensions. Please ensure you have the latest graphics "
+                                 "driver.<br><br>Unsupported extensions:<br>") +
+                                  unsupported_gl_extensions.join(QStringLiteral("<br>")));
        return false;
    }

@@ -922,9 +980,7 @@ void GMainWindow::BootGame(const QString& filename) {
    // Create and start the emulation thread
    emu_thread = std::make_unique<EmuThread>(render_window);
    emit EmulationStarting(emu_thread.get());
-    if (Settings::values.renderer_backend == Settings::RendererBackend::OpenGL) {
-        render_window->moveContext();
-    }
+    render_window->moveContext();
    emu_thread->start();

    connect(render_window, &GRenderWindow::Closed, this, &GMainWindow::OnStopGame);
@@ -2139,18 +2195,6 @@ void GMainWindow::closeEvent(QCloseEvent* event) {
    QWidget::closeEvent(event);
 }

-void GMainWindow::keyPressEvent(QKeyEvent* event) {
-    if (render_window) {
-        render_window->ForwardKeyPressEvent(event);
-    }
-}
-
-void GMainWindow::keyReleaseEvent(QKeyEvent* event) {
-    if (render_window) {
-        render_window->ForwardKeyReleaseEvent(event);
-    }
-}
-
 static bool IsSingleFileDropEvent(QDropEvent* event) {
    const QMimeData* mimeData = event->mimeData();
    return mimeData->hasUrls() && mimeData->urls().length() == 1;
@@ -2183,6 +2227,18 @@ void GMainWindow::dragMoveEvent(QDragMoveEvent* event) {
    event->acceptProposedAction();
 }

+void GMainWindow::keyPressEvent(QKeyEvent* event) {
+    if (render_window) {
+        render_window->ForwardKeyPressEvent(event);
+    }
+}
+
+void GMainWindow::keyReleaseEvent(QKeyEvent* event) {
+    if (render_window) {
+        render_window->ForwardKeyReleaseEvent(event);
+    }
+}
+
 bool GMainWindow::ConfirmChangeGame() {
    if (emu_thread == nullptr)
        return true;
@@ -130,6 +130,7 @@ private:
    void PreventOSSleep();
    void AllowOSSleep();

+    QStringList GetUnsupportedGLExtensions();
    bool LoadROM(const QString& filename);
    void BootGame(const QString& filename);
    void ShutdownGame();
@@ -8,22 +8,11 @@ add_executable(yuzu-cmd
    emu_window/emu_window_sdl2_gl.h
    emu_window/emu_window_sdl2.cpp
    emu_window/emu_window_sdl2.h
-    emu_window/emu_window_sdl2_gl.cpp
-    emu_window/emu_window_sdl2_gl.h
    resource.h
    yuzu.cpp
    yuzu.rc
 )

-if (ENABLE_VULKAN)
-    target_sources(yuzu-cmd PRIVATE
-                   emu_window/emu_window_sdl2_vk.cpp
-                   emu_window/emu_window_sdl2_vk.h)
-
-    target_include_directories(yuzu-cmd PRIVATE ../../externals/Vulkan-Headers/include)
-    target_compile_definitions(yuzu-cmd PRIVATE HAS_VULKAN)
-endif()
-
 create_target_directory_groups(yuzu-cmd)

 target_link_libraries(yuzu-cmd PRIVATE common core input_common)
@@ -371,12 +371,6 @@ void Config::ReadValues() {
    Settings::values.use_multi_core = sdl2_config->GetBoolean("Core", "use_multi_core", false);

    // Renderer
-    const int renderer_backend = sdl2_config->GetInteger(
-        "Renderer", "backend", static_cast<int>(Settings::RendererBackend::OpenGL));
-    Settings::values.renderer_backend = static_cast<Settings::RendererBackend>(renderer_backend);
-    Settings::values.renderer_debug = sdl2_config->GetBoolean("Renderer", "debug", false);
-    Settings::values.vulkan_device = sdl2_config->GetInteger("Renderer", "vulkan_device", 0);
-
    Settings::values.resolution_factor =
        static_cast<float>(sdl2_config->GetReal("Renderer", "resolution_factor", 1.0));
    Settings::values.use_frame_limit = sdl2_config->GetBoolean("Renderer", "use_frame_limit", true);
@@ -98,17 +98,6 @@ udp_pad_index=
 use_multi_core=

 [Renderer]
-# Which backend API to use.
-# 0 (default): OpenGL, 1: Vulkan
-backend =
-
-# Enable graphics API debugging mode.
-# 0 (default): Disabled, 1: Enabled
-debug =
-
-# Which Vulkan physical device to use (defaults to 0)
-vulkan_device =
-
 # Whether to use software or hardware rendering.
 # 0: Software, 1 (default): Hardware
 use_hw_renderer =
@@ -89,10 +89,6 @@ bool EmuWindow_SDL2::IsOpen() const {
    return is_open;
 }

-bool EmuWindow_SDL2::IsShown() const {
-    return is_shown;
-}
-
 void EmuWindow_SDL2::OnResize() {
    int width, height;
    SDL_GetWindowSize(render_window, &width, &height);
@@ -21,9 +21,6 @@ public:
    /// Whether the window is still open, and a close request hasn't yet been sent
    bool IsOpen() const;

-    /// Returns if window is shown (not minimized)
-    bool IsShown() const override;
-
 protected:
    /// Called by PollEvents when a key is pressed or released.
    void OnKeyEvent(int key, u8 state);
@@ -9,7 +9,6 @@
 #include <SDL.h>
 #include <fmt/format.h>
 #include <glad/glad.h>
-#include "common/assert.h"
 #include "common/logging/log.h"
 #include "common/scm_rev.h"
 #include "common/string_util.h"
@@ -152,12 +151,6 @@ void EmuWindow_SDL2_GL::DoneCurrent() {
    SDL_GL_MakeCurrent(render_window, nullptr);
 }

-void EmuWindow_SDL2_GL::RetrieveVulkanHandlers(void* get_instance_proc_addr, void* instance,
-                                               void* surface) const {
-    // Should not have been called from OpenGL
-    UNREACHABLE();
-}
-
 std::unique_ptr<Core::Frontend::GraphicsContext> EmuWindow_SDL2_GL::CreateSharedContext() const {
    return std::make_unique<SDLGLContext>();
 }
@@ -22,10 +22,6 @@ public:
    /// Releases the GL context from the caller thread
    void DoneCurrent() override;

-    /// Ignored in OpenGL
-    void RetrieveVulkanHandlers(void* get_instance_proc_addr, void* instance,
-                                void* surface) const override;
-
    std::unique_ptr<Core::Frontend::GraphicsContext> CreateSharedContext() const override;

 private:
@@ -1,162 +0,0 @@
-// Copyright 2018 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <algorithm>
-#include <string>
-#include <vector>
-#include <SDL.h>
-#include <SDL_vulkan.h>
-#include <fmt/format.h>
-#include <vulkan/vulkan.h>
-#include "common/assert.h"
-#include "common/logging/log.h"
-#include "common/scm_rev.h"
-#include "core/settings.h"
-#include "yuzu_cmd/emu_window/emu_window_sdl2_vk.h"
-
-EmuWindow_SDL2_VK::EmuWindow_SDL2_VK(bool fullscreen) : EmuWindow_SDL2(fullscreen) {
-    if (SDL_Vulkan_LoadLibrary(nullptr) != 0) {
-        LOG_CRITICAL(Frontend, "SDL failed to load the Vulkan library: {}", SDL_GetError());
-        exit(EXIT_FAILURE);
-    }
-
-    vkGetInstanceProcAddr =
-        reinterpret_cast<PFN_vkGetInstanceProcAddr>(SDL_Vulkan_GetVkGetInstanceProcAddr());
-    if (vkGetInstanceProcAddr == nullptr) {
-        LOG_CRITICAL(Frontend, "Failed to retrieve Vulkan function pointer!");
-        exit(EXIT_FAILURE);
-    }
-
-    const std::string window_title = fmt::format("yuzu {} | {}-{} (Vulkan)", Common::g_build_name,
-                                                 Common::g_scm_branch, Common::g_scm_desc);
-    render_window =
-        SDL_CreateWindow(window_title.c_str(),
-                         SDL_WINDOWPOS_UNDEFINED, // x position
-                         SDL_WINDOWPOS_UNDEFINED, // y position
-                         Layout::ScreenUndocked::Width, Layout::ScreenUndocked::Height,
-                         SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI | SDL_WINDOW_VULKAN);
-
-    const bool use_standard_layers = UseStandardLayers(vkGetInstanceProcAddr);
-
-    u32 extra_ext_count{};
-    if (!SDL_Vulkan_GetInstanceExtensions(render_window, &extra_ext_count, NULL)) {
-        LOG_CRITICAL(Frontend, "Failed to query Vulkan extensions count from SDL! {}",
-                     SDL_GetError());
-        exit(1);
-    }
-
-    auto extra_ext_names = std::make_unique<const char* []>(extra_ext_count);
-    if (!SDL_Vulkan_GetInstanceExtensions(render_window, &extra_ext_count, extra_ext_names.get())) {
-        LOG_CRITICAL(Frontend, "Failed to query Vulkan extensions from SDL! {}", SDL_GetError());
-        exit(1);
-    }
-    std::vector<const char*> enabled_extensions;
-    enabled_extensions.insert(enabled_extensions.begin(), extra_ext_names.get(),
-                              extra_ext_names.get() + extra_ext_count);
-
-    std::vector<const char*> enabled_layers;
-    if (use_standard_layers) {
-        enabled_extensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME);
-        enabled_layers.push_back("VK_LAYER_LUNARG_standard_validation");
-    }
-
-    VkApplicationInfo app_info{};
-    app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
-    app_info.apiVersion = VK_API_VERSION_1_1;
-    app_info.applicationVersion = VK_MAKE_VERSION(0, 1, 0);
-    app_info.pApplicationName = "yuzu-emu";
-    app_info.engineVersion = VK_MAKE_VERSION(0, 1, 0);
-    app_info.pEngineName = "yuzu-emu";
-
-    VkInstanceCreateInfo instance_ci{};
-    instance_ci.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
-    instance_ci.pApplicationInfo = &app_info;
-    instance_ci.enabledExtensionCount = static_cast<u32>(enabled_extensions.size());
-    instance_ci.ppEnabledExtensionNames = enabled_extensions.data();
-    if (Settings::values.renderer_debug) {
-        instance_ci.enabledLayerCount = static_cast<u32>(enabled_layers.size());
-        instance_ci.ppEnabledLayerNames = enabled_layers.data();
-    }
-
-    const auto vkCreateInstance =
-        reinterpret_cast<PFN_vkCreateInstance>(vkGetInstanceProcAddr(nullptr, "vkCreateInstance"));
-    if (vkCreateInstance == nullptr ||
-        vkCreateInstance(&instance_ci, nullptr, &vk_instance) != VK_SUCCESS) {
-        LOG_CRITICAL(Frontend, "Failed to create Vulkan instance!");
-        exit(EXIT_FAILURE);
-    }
-
-    vkDestroyInstance = reinterpret_cast<PFN_vkDestroyInstance>(
-        vkGetInstanceProcAddr(vk_instance, "vkDestroyInstance"));
-    if (vkDestroyInstance == nullptr) {
-        LOG_CRITICAL(Frontend, "Failed to retrieve Vulkan function pointer!");
-        exit(EXIT_FAILURE);
-    }
-
-    if (!SDL_Vulkan_CreateSurface(render_window, vk_instance, &vk_surface)) {
-        LOG_CRITICAL(Frontend, "Failed to create Vulkan surface! {}", SDL_GetError());
-        exit(EXIT_FAILURE);
-    }
-
-    OnResize();
-    OnMinimalClientAreaChangeRequest(GetActiveConfig().min_client_area_size);
-    SDL_PumpEvents();
-    LOG_INFO(Frontend, "yuzu Version: {} | {}-{} (Vulkan)", Common::g_build_name,
-             Common::g_scm_branch, Common::g_scm_desc);
-}
-
-EmuWindow_SDL2_VK::~EmuWindow_SDL2_VK() {
-    vkDestroyInstance(vk_instance, nullptr);
-}
-
-void EmuWindow_SDL2_VK::SwapBuffers() {}
-
-void EmuWindow_SDL2_VK::MakeCurrent() {
-    // Unused on Vulkan
-}
-
-void EmuWindow_SDL2_VK::DoneCurrent() {
-    // Unused on Vulkan
-}
-
-void EmuWindow_SDL2_VK::RetrieveVulkanHandlers(void* get_instance_proc_addr, void* instance,
-                                               void* surface) const {
-    const auto instance_proc_addr = vkGetInstanceProcAddr;
-    std::memcpy(get_instance_proc_addr, &instance_proc_addr, sizeof(instance_proc_addr));
-    std::memcpy(instance, &vk_instance, sizeof(vk_instance));
-    std::memcpy(surface, &vk_surface, sizeof(vk_surface));
-}
-
-std::unique_ptr<Core::Frontend::GraphicsContext> EmuWindow_SDL2_VK::CreateSharedContext() const {
-    return nullptr;
-}
-
-bool EmuWindow_SDL2_VK::UseStandardLayers(PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr) const {
-    if (!Settings::values.renderer_debug) {
-        return false;
-    }
-
-    const auto vkEnumerateInstanceLayerProperties =
-        reinterpret_cast<PFN_vkEnumerateInstanceLayerProperties>(
-            vkGetInstanceProcAddr(nullptr, "vkEnumerateInstanceLayerProperties"));
-    if (vkEnumerateInstanceLayerProperties == nullptr) {
-        LOG_CRITICAL(Frontend, "Failed to retrieve Vulkan function pointer!");
-        return false;
-    }
-
-    u32 available_layers_count{};
-    if (vkEnumerateInstanceLayerProperties(&available_layers_count, nullptr) != VK_SUCCESS) {
-        LOG_CRITICAL(Frontend, "Failed to enumerate Vulkan validation layers!");
-        return false;
-    }
-    std::vector<VkLayerProperties> layers(available_layers_count);
-    if (vkEnumerateInstanceLayerProperties(&available_layers_count, layers.data()) != VK_SUCCESS) {
-        LOG_CRITICAL(Frontend, "Failed to enumerate Vulkan validation layers!");
-        return false;
-    }
-
-    return std::find_if(layers.begin(), layers.end(), [&](const auto& layer) {
-               return layer.layerName == std::string("VK_LAYER_LUNARG_standard_validation");
-           }) != layers.end();
-}
@@ -1,39 +0,0 @@
-// Copyright 2018 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <vulkan/vulkan.h>
-#include "core/frontend/emu_window.h"
-#include "yuzu_cmd/emu_window/emu_window_sdl2.h"
-
-class EmuWindow_SDL2_VK final : public EmuWindow_SDL2 {
-public:
-    explicit EmuWindow_SDL2_VK(bool fullscreen);
-    ~EmuWindow_SDL2_VK();
-
-    /// Swap buffers to display the next frame
-    void SwapBuffers() override;
-
-    /// Makes the graphics context current for the caller thread
-    void MakeCurrent() override;
-
-    /// Releases the GL context from the caller thread
-    void DoneCurrent() override;
-
-    /// Retrieves Vulkan specific handlers from the window
-    void RetrieveVulkanHandlers(void* get_instance_proc_addr, void* instance,
-                                void* surface) const override;
-
-    std::unique_ptr<Core::Frontend::GraphicsContext> CreateSharedContext() const override;
-
-private:
-    bool UseStandardLayers(PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr) const;
-
-    VkInstance vk_instance{};
-    VkSurfaceKHR vk_surface{};
-
-    PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr{};
-    PFN_vkDestroyInstance vkDestroyInstance{};
-};
@@ -32,9 +32,6 @@
 #include "yuzu_cmd/config.h"
 #include "yuzu_cmd/emu_window/emu_window_sdl2.h"
 #include "yuzu_cmd/emu_window/emu_window_sdl2_gl.h"
-#ifdef HAS_VULKAN
-#include "yuzu_cmd/emu_window/emu_window_sdl2_vk.h"
-#endif

 #include "core/file_sys/registered_cache.h"

@@ -177,20 +174,7 @@ int main(int argc, char** argv) {
    Settings::values.use_gdbstub = use_gdbstub;
    Settings::Apply();

-    std::unique_ptr<EmuWindow_SDL2> emu_window;
-    switch (Settings::values.renderer_backend) {
-    case Settings::RendererBackend::OpenGL:
-        emu_window = std::make_unique<EmuWindow_SDL2_GL>(fullscreen);
-        break;
-    case Settings::RendererBackend::Vulkan:
-#ifdef HAS_VULKAN
-        emu_window = std::make_unique<EmuWindow_SDL2_VK>(fullscreen);
-        break;
-#else
-        LOG_CRITICAL(Frontend, "Vulkan backend has not been compiled!");
-        return 1;
-#endif
-    }
+    std::unique_ptr<EmuWindow_SDL2> emu_window{std::make_unique<EmuWindow_SDL2_GL>(fullscreen)};

    if (!Settings::values.use_multi_core) {
        // Single core mode must acquire OpenGL context for entire emulation session
@@ -5,15 +5,10 @@
 #include <algorithm>
 #include <cstdlib>
 #include <string>
-
-#include <fmt/format.h>
-
 #define SDL_MAIN_HANDLED
 #include <SDL.h>
-
+#include <fmt/format.h>
 #include <glad/glad.h>
-
-#include "common/assert.h"
 #include "common/logging/log.h"
 #include "common/scm_rev.h"
 #include "core/settings.h"
@@ -125,11 +120,3 @@ void EmuWindow_SDL2_Hide::MakeCurrent() {
 void EmuWindow_SDL2_Hide::DoneCurrent() {
    SDL_GL_MakeCurrent(render_window, nullptr);
 }
-
-bool EmuWindow_SDL2_Hide::IsShown() const {
-    return false;
-}
-
-void EmuWindow_SDL2_Hide::RetrieveVulkanHandlers(void*, void*, void*) const {
-    UNREACHABLE();
-}
@@ -25,13 +25,6 @@ public:
    /// Releases the GL context from the caller thread
    void DoneCurrent() override;

-    /// Whether the screen is being shown or not.
-    bool IsShown() const override;
-
-    /// Retrieves Vulkan specific handlers from the window
-    void RetrieveVulkanHandlers(void* get_instance_proc_addr, void* instance,
-                                void* surface) const override;
-
    /// Whether the window is still open, and a close request hasn't yet been sent
    bool IsOpen() const;
Author	SHA1	Message	Date
Fernando Sahmkow	2d1984c20c	System: Address Feedback	2020-01-27 09:54:11 -04:00
Fernando Sahmkow	de4b01f75d	System: Correct PrepareReschedule.	2020-01-26 14:32:50 -04:00
Fernando Sahmkow	a1630ab53e	Kernel: Remove a few global instances from the kernel.	2020-01-26 14:23:46 -04:00
Fernando Sahmkow	e4a1ead897	Core: Refactor CpuCoreManager to CpuManager and Cpu to Core Manager. This commit instends on better naming the new purpose of this classes.	2020-01-26 14:07:22 -04:00
Fernando Sahmkow	450341b397	ArmInterface: Delegate Exclusive monitor factory to exclusive monitor interfasce.	2020-01-26 10:28:23 -04:00
Fernando Sahmkow	4d6a86b03f	Core: Refactor CPU Management. This commit moves ARM Interface and Scheduler handling into the kernel.	2020-01-25 18:55:32 -04:00
Fernando Sahmkow	ab89ced244	Kernel: Implement Physical Core.	2020-01-24 15:38:20 -04:00