waw

Signed-off-by: lizzie <lizzie@eden-emu.dev>

.patch/openssl-cmake/0001-cpmutil-compat.patch

@@ -0,0 +1,214 @@
+From ec4c1fdf526cb9ad045abf59b29ee495bbf5023a Mon Sep 17 00:00:00 2001
+From: crueter <crueter@eden-emu.dev>
+Date: Sat, 30 May 2026 20:56:35 -0400
+Subject: [PATCH] cpmutil compat
+
+---
+ CMakeLists.txt           | 31 ++++++++-----------
+ cmake/FetchOpenSSL.cmake | 64 ----------------------------------------
+ cmake/GetCPM.cmake       |  5 ----
+ 3 files changed, 13 insertions(+), 87 deletions(-)
+ delete mode 100644 cmake/FetchOpenSSL.cmake
+ delete mode 100644 cmake/GetCPM.cmake
+
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index 5420ecc..9ffd5a0 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -19,9 +19,7 @@ include(FetchContent)
+ include(ProcessorCount)
+ include(cmake/ConfigureOpenSSL.cmake)
+ include(cmake/DetectTargetPlatform.cmake)
+-include(cmake/FetchOpenSSL.cmake)
+ include(cmake/FindVcvarsall.cmake)
+-include(cmake/GetCPM.cmake)
+ 
+ # Custom options
+ option(OPENSSL_BUILD_VERBOSE "Enable verbose output from build" OFF)
+@@ -47,9 +45,6 @@ if("${OPENSSL_TARGET_PLATFORM}" STREQUAL "")
+     detect_target_platform(OPENSSL_TARGET_PLATFORM)
+ endif()
+ 
+-# Fetch OpenSSL source
+-fetch_openssl()
+-
+ # Apply patches
+ foreach(patch IN LISTS OPENSSL_PATCH)
+     if(EXISTS "${patch}" AND NOT IS_DIRECTORY "${patch}")
+@@ -59,13 +54,13 @@ foreach(patch IN LISTS OPENSSL_PATCH)
+ 
+         execute_process(
+             COMMAND git init
+-            WORKING_DIRECTORY ${openssl_SOURCE_DIR}
++            WORKING_DIRECTORY ${OpenSSL_SOURCE_DIR}
+             OUTPUT_QUIET
+             ERROR_QUIET
+         )
+         execute_process(
+             COMMAND git apply ${patch}
+-            WORKING_DIRECTORY ${openssl_SOURCE_DIR}
++            WORKING_DIRECTORY ${OpenSSL_SOURCE_DIR}
+             OUTPUT_QUIET
+             ERROR_QUIET
+         )
+@@ -161,8 +156,8 @@ list(PREPEND OPENSSL_CONFIGURE_OPTIONS ${OPENSSL_TARGET_PLATFORM})
+ # Configure OpenSSL
+ configure_openssl(
+     COMMAND ${VCVARSALL_COMMAND}
+-    FILE ${openssl_SOURCE_DIR}/Configure
+-    BUILD_DIR ${openssl_BINARY_DIR}
++    FILE ${OpenSSL_SOURCE_DIR}/Configure
++    BUILD_DIR ${OpenSSL_BINARY_DIR}
+     OPTIONS ${OPENSSL_CONFIGURE_OPTIONS}
+ )
+ 
+@@ -203,8 +198,8 @@ endif()
+ # Parse Makefile
+ parse_makefile(${OPENSSL_MAKEFILE} "INSTALL_LIBS" OPENSSL_STATIC_LIBS)
+ parse_makefile(${OPENSSL_MAKEFILE} "INSTALL_SHLIBS" OPENSSL_SHARED_LIBS)
+-list(TRANSFORM OPENSSL_STATIC_LIBS PREPEND "${openssl_BINARY_DIR}/")
+-list(TRANSFORM OPENSSL_SHARED_LIBS PREPEND "${openssl_BINARY_DIR}/")
++list(TRANSFORM OPENSSL_STATIC_LIBS PREPEND "${OpenSSL_BINARY_DIR}/")
++list(TRANSFORM OPENSSL_SHARED_LIBS PREPEND "${OpenSSL_BINARY_DIR}/")
+ 
+ foreach(LIBRARY IN LISTS OPENSSL_STATIC_LIBS)
+     if(LIBRARY MATCHES "crypto")
+@@ -239,14 +234,14 @@ endif()
+ 
+ # Provide same targets and variables as FindOpenSSL module
+ set(OPENSSL_FOUND ON CACHE BOOL "Override FindOpenSSL variables" FORCE)
+-set(OPENSSL_INCLUDE_DIR ${openssl_SOURCE_DIR}/include ${openssl_BINARY_DIR}/include CACHE STRING "Override FindOpenSSL variables" FORCE)
++set(OPENSSL_INCLUDE_DIR ${OpenSSL_SOURCE_DIR}/include ${OpenSSL_BINARY_DIR}/include CACHE STRING "Override FindOpenSSL variables" FORCE)
+ set(OPENSSL_CRYPTO_LIBRARY ${OPENSSL_${OPENSSL_LIBRARY_TYPE}_CRYPTO_LIBRARY} CACHE STRING "Override FindOpenSSL variables" FORCE)
+ set(OPENSSL_CRYPTO_LIBRARIES ${OPENSSL_CRYPTO_LIBRARY} ${OPENSSL_DEPENDENCIES} CACHE STRING "Override FindOpenSSL variables" FORCE)
+ set(OPENSSL_SSL_LIBRARY ${OPENSSL_${OPENSSL_LIBRARY_TYPE}_SSL_LIBRARY} CACHE STRING "Override FindOpenSSL variables" FORCE)
+ set(OPENSSL_SSL_LIBRARIES ${OPENSSL_SSL_LIBRARY} ${OPENSSL_DEPENDENCIES} CACHE STRING "Override FindOpenSSL variables" FORCE)
+ set(OPENSSL_LIBRARIES ${OPENSSL_CRYPTO_LIBRARY} ${OPENSSL_SSL_LIBRARY} ${OPENSSL_DEPENDENCIES} CACHE STRING "Override FindOpenSSL variables" FORCE)
+ set(OPENSSL_VERSION ${OPENSSL_CONFIGURED_VERSION} CACHE STRING "Override FindOpenSSL variables" FORCE)
+-set(OPENSSL_APPLINK_SOURCE ${openssl_SOURCE_DIR}/ms/applink.c CACHE STRING "Override FindOpenSSL variables" FORCE)
++set(OPENSSL_APPLINK_SOURCE ${OpenSSL_SOURCE_DIR}/ms/applink.c CACHE STRING "Override FindOpenSSL variables" FORCE)
+ 
+ add_library(OpenSSL::Crypto ${OPENSSL_LIBRARY_TYPE} IMPORTED GLOBAL)
+ add_library(OpenSSL::SSL ${OPENSSL_LIBRARY_TYPE} IMPORTED GLOBAL)
+@@ -308,8 +303,8 @@ if(ANDROID)
+ endif()
+ 
+ file(GLOB_RECURSE OPENSSL_SOURCES
+-    ${openssl_SOURCE_DIR}/*.[ch]
+-    ${openssl_SOURCE_DIR}/*.[ch].in
++    ${OpenSSL_SOURCE_DIR}/*.[ch]
++    ${OpenSSL_SOURCE_DIR}/*.[ch].in
+ )
+ 
+ set(OPENSSL_BUILD_OUTPUT
+@@ -322,7 +317,7 @@ add_custom_command(
+     OUTPUT ${OPENSSL_BUILD_OUTPUT}
+     COMMAND ${OPENSSL_BUILD_COMMAND}
+     DEPENDS ${OPENSSL_SOURCES}
+-    WORKING_DIRECTORY ${openssl_BINARY_DIR}
++    WORKING_DIRECTORY ${OpenSSL_BINARY_DIR}
+     VERBATIM
+ )
+ 
+@@ -341,7 +336,7 @@ if(OPENSSL_TEST AND NOT CMAKE_CROSSCOMPILING)
+     add_test(
+         NAME openssl-test
+         COMMAND ${OPENSSL_BUILD_TOOL} test VERBOSE_FAILURE=yes HARNESS_JOBS=${NUMBER_OF_THREADS}
+-        WORKING_DIRECTORY ${openssl_BINARY_DIR}
++        WORKING_DIRECTORY ${OpenSSL_BINARY_DIR}
+     )
+ endif()
+ 
+@@ -356,7 +351,7 @@ if(OPENSSL_INSTALL)
+     install(CODE
+         "execute_process(
+             COMMAND ${OPENSSL_INSTALL_COMMAND}
+-            WORKING_DIRECTORY \"${openssl_BINARY_DIR}\"
++            WORKING_DIRECTORY \"${OpenSSL_BINARY_DIR}\"
+         )"
+     )
+ endif()
+diff --git a/cmake/FetchOpenSSL.cmake b/cmake/FetchOpenSSL.cmake
+deleted file mode 100644
+index a43505d..0000000
+--- a/cmake/FetchOpenSSL.cmake
++++ /dev/null
+@@ -1,64 +0,0 @@
+-function(fetch_openssl)
+-    if(EXISTS "${OPENSSL_SOURCE}" AND IS_DIRECTORY "${OPENSSL_SOURCE}")
+-        # Fetch the local OpenSSL source
+-        if(NOT IS_ABSOLUTE "${OPENSSL_SOURCE}")
+-            string(PREPEND OPENSSL_SOURCE ${CMAKE_SOURCE_DIR}/)
+-        endif()
+-
+-        string(REPLACE "\\" "/" openssl-source_SOURCE_DIR "${OPENSSL_SOURCE}")
+-        set(openssl-source_BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR}/openssl-source-build)
+-    else()
+-        set(CPM_OPTIONS
+-            NAME openssl-source
+-            DOWNLOAD_ONLY ON
+-        )
+-
+-        if(NOT OPENSSL_CONFIGURE_VERBOSE)
+-            list(APPEND CPM_OPTIONS QUIET)
+-        endif()
+-
+-        if("${OPENSSL_SOURCE}" MATCHES "^http")
+-            # Download OpenSSL source from the internet
+-            list(APPEND CPM_OPTIONS URL ${OPENSSL_SOURCE})
+-        else()
+-            # Download OpenSSL source from the official website
+-            if("${OPENSSL_TARGET_VERSION}" STREQUAL "")
+-                set(OPENSSL_TARGET_VERSION ${PROJECT_VERSION})
+-            endif()
+-
+-            if(OPENSSL_TARGET_VERSION VERSION_EQUAL PROJECT_VERSION)
+-                list(APPEND CPM_OPTIONS URL_HASH SHA256=aaf51a1fe064384f811daeaeb4ec4dce7340ec8bd893027eee676af31e83a04f)
+-            endif()
+-
+-            if(OPENSSL_TARGET_VERSION MATCHES "^1\.1\.1[a-w]$")
+-                string(REPLACE "." "_" OPENSSL_TAGGED_VERSION ${OPENSSL_TARGET_VERSION})
+-                list(APPEND CPM_OPTIONS URL https://github.com/openssl/openssl/releases/download/OpenSSL_${OPENSSL_TAGGED_VERSION}/openssl-${OPENSSL_TARGET_VERSION}.tar.gz)
+-            else()
+-                list(APPEND CPM_OPTIONS URL https://github.com/openssl/openssl/releases/download/openssl-${OPENSSL_TARGET_VERSION}/openssl-${OPENSSL_TARGET_VERSION}.tar.gz)
+-            endif()
+-        endif()
+-
+-        CPMAddPackage(${CPM_OPTIONS})
+-    endif()
+-
+-    # Clean build directory if source directory has changed
+-    if(DEFINED CACHE{openssl-source_SOURCE_DIR_OLD} AND NOT openssl-source_SOURCE_DIR STREQUAL openssl-source_SOURCE_DIR_OLD)
+-        set(openssl-source_SOURCE_DIR_OLD ${openssl-source_SOURCE_DIR} CACHE INTERNAL "Previously fetched OpenSSL source")
+-
+-        if(IS_DIRECTORY ${openssl-source_BINARY_DIR})
+-            file(REMOVE_RECURSE ${openssl-source_BINARY_DIR})
+-            file(MAKE_DIRECTORY ${openssl-source_BINARY_DIR})
+-        endif()
+-    endif()
+-
+-    # Override the FindOpenSSL module
+-    FetchContent_Declare(
+-        OpenSSL
+-        SOURCE_DIR ${openssl-source_SOURCE_DIR}
+-        BINARY_DIR ${openssl-source_BINARY_DIR}
+-        OVERRIDE_FIND_PACKAGE
+-    )
+-    FetchContent_MakeAvailable(OpenSSL)
+-
+-    return(PROPAGATE openssl_SOURCE_DIR openssl_BINARY_DIR)
+-endfunction()
+diff --git a/cmake/GetCPM.cmake b/cmake/GetCPM.cmake
+deleted file mode 100644
+index bfc50f5..0000000
+--- a/cmake/GetCPM.cmake
++++ /dev/null
+@@ -1,5 +0,0 @@
+-file(
+-    DOWNLOAD https://github.com/cpm-cmake/CPM.cmake/releases/latest/download/get_cpm.cmake
+-    ${CMAKE_CURRENT_BINARY_DIR}/get_cpm.cmake
+-)
+-include(${CMAKE_CURRENT_BINARY_DIR}/get_cpm.cmake)
+-- 
+2.54.0
+

.patch/openssl-cmake/0002-use-ccache.patch

@@ -0,0 +1,54 @@
+From d46675fbb61eb6d51e478023ce4075e545ad4cfd Mon Sep 17 00:00:00 2001
+From: crueter <crueter@eden-emu.dev>
+Date: Sat, 30 May 2026 21:11:55 -0400
+Subject: [PATCH] use ccache
+
+---
+ CMakeLists.txt               |  1 -
+ cmake/ConfigureOpenSSL.cmake | 12 +++---------
+ 2 files changed, 3 insertions(+), 10 deletions(-)
+
+diff --git a/CMakeLists.txt b/CMakeLists.txt
+index 9ffd5a0..9ff14c8 100644
+--- a/CMakeLists.txt
++++ b/CMakeLists.txt
+@@ -28,7 +28,6 @@ option(OPENSSL_ENABLE_PARALLEL "Build and test in parallel if possible" ON)
+ option(OPENSSL_INSTALL "Install OpenSSL components to the <prefix> directory" OFF)
+ option(OPENSSL_INSTALL_CERT "Install cert.pem to the <openssldir> directory" OFF)
+ option(OPENSSL_TEST "Enable testing and build OpenSSL self tests" OFF)
+-option(OPENSSL_USE_CCACHE "Use ccache if available" ON)
+ 
+ if("${OPENSSL_BUILD_TARGET}" STREQUAL "")
+     # Makefile target for build
+diff --git a/cmake/ConfigureOpenSSL.cmake b/cmake/ConfigureOpenSSL.cmake
+index 211c18b..3d8cbed 100644
+--- a/cmake/ConfigureOpenSSL.cmake
++++ b/cmake/ConfigureOpenSSL.cmake
+@@ -69,15 +69,9 @@ function(apply_ccache FILE)
+         message(FATAL_ERROR "Couldn't find Makefile")
+     endif()
+ 
+-    if(OPENSSL_USE_CCACHE)
+-        find_program(CCACHE ccache)
+-
+-        if(NOT CCACHE)
+-            return()
+-        endif()
+-
++    if(USE_CCACHE)
+         file(READ ${FILE} MAKEFILE)
+-        string(REPLACE "\nCC=" "\nCC=ccache " MAKEFILE "${MAKEFILE}")
++        string(REPLACE "\nCC=" "\nCC=${CCACHE_BINARY} " MAKEFILE "${MAKEFILE}")
+ 
+         if(MSVC)
+             string(REPLACE "/Zi /Fdossl_static.pdb " "" MAKEFILE "${MAKEFILE}")
+@@ -171,4 +165,4 @@ function(configure_openssl)
+         string(REPLACE "/W3" "/W0" MAKEFILE "${MAKEFILE}")
+         file(WRITE ${OPENSSL_MAKEFILE} "${MAKEFILE}")
+     endif()
+-endfunction()
+\ No newline at end of file
++endfunction()
+-- 
+2.54.0
+

.patch/openssl-cmake/0003-use-cmake-compiler-flags.patch

@@ -0,0 +1,28 @@
+From 4a3cc92a7abad403529ed1cb4255ca63d9252de4 Mon Sep 17 00:00:00 2001
+From: crueter <crueter@eden-emu.dev>
+Date: Sat, 30 May 2026 21:48:42 -0400
+Subject: [PATCH 2/2] use cmake compiler flags
+
+---
+ cmake/ConfigureOpenSSL.cmake | 5 ++++-
+ 1 file changed, 4 insertions(+), 1 deletion(-)
+
+diff --git a/cmake/ConfigureOpenSSL.cmake b/cmake/ConfigureOpenSSL.cmake
+index 3d8cbed..3012e05 100644
+--- a/cmake/ConfigureOpenSSL.cmake
++++ b/cmake/ConfigureOpenSSL.cmake
+@@ -135,7 +135,10 @@ function(configure_openssl)
+     endif()
+ 
+     execute_process(
+-        COMMAND ${CONFIGURE_COMMAND}
++        COMMAND ${CMAKE_COMMAND} -E env
++            "CFLAGS=${CMAKE_C_FLAGS}"
++            "CXXFLAGS=${CMAKE_CXX_FLAGS}"
++            ${CONFIGURE_COMMAND}
+         WORKING_DIRECTORY ${CONFIGURE_BUILD_DIR}
+         ${VERBOSE_OPTION}
+         COMMAND_ERROR_IS_FATAL ANY
+-- 
+2.54.0
+

.patch/openssl-cmake/0004-use-shell-wrapper.patch

@@ -0,0 +1,39 @@
+--- a/CMakeLists.txt	2026-06-01 23:53:16.498043856 -0400
++++ b/CMakeLists.txt	2026-06-01 23:53:23.910543615 -0400
+@@ -312,13 +312,29 @@
+     ${OPENSSL_SHARED_CRYPTO_LIBRARY}
+     ${OPENSSL_SHARED_SSL_LIBRARY}
+ )
+-add_custom_command(
+-    OUTPUT ${OPENSSL_BUILD_OUTPUT}
+-    COMMAND ${OPENSSL_BUILD_COMMAND}
+-    DEPENDS ${OPENSSL_SOURCES}
+-    WORKING_DIRECTORY ${OpenSSL_BINARY_DIR}
+-    VERBATIM
+-)
++if (WIN32)
++    add_custom_command(
++        OUTPUT ${OPENSSL_BUILD_OUTPUT}
++        COMMAND ${OPENSSL_BUILD_COMMAND}
++        DEPENDS ${OPENSSL_SOURCES}
++        WORKING_DIRECTORY ${OpenSSL_BINARY_DIR}
++        VERBATIM)
++else()
++    set(_openssl_build_script "${CMAKE_CURRENT_BINARY_DIR}/BuildOpenSSL.cmake")
++    file(WRITE ${_openssl_build_script}
++        "execute_process(\n"
++        "    COMMAND ${OPENSSL_BUILD_COMMAND}\n"
++        "    WORKING_DIRECTORY ${OpenSSL_BINARY_DIR}\n"
++        "    RESULT_VARIABLE _r)\n"
++        "if(_r)\n"
++        "    message(FATAL_ERROR \"OpenSSL build failed: \${_r}\")\n"
++        "endif()\n")
++    add_custom_command(
++        OUTPUT ${OPENSSL_BUILD_OUTPUT}
++        COMMAND ${CMAKE_COMMAND} -P ${_openssl_build_script}
++        DEPENDS ${OPENSSL_SOURCES}
++        VERBATIM)
++endif()
+ 
+ if(PROJECT_IS_TOP_LEVEL)
+     add_custom_target(openssl-build ALL DEPENDS ${OPENSSL_BUILD_OUTPUT})

CMakeLists.txt

@@ -383,13 +383,20 @@ find_package(RenderDoc MODULE)
 # openssl funniness
 if (YUZU_USE_BUNDLED_OPENSSL)
     set(BUILD_SHARED_LIBS OFF)
+    AddJsonPackage(openssl-ci)
+else()
     AddJsonPackage(openssl)
+    set(OPENSSL_BUILD_VERBOSE ON)
+    set(OPENSSL_CONFIGURE_VERBOSE ON)
+
     if (OpenSSL_ADDED)
-        add_compile_definitions(YUZU_BUNDLED_OPENSSL)
+        AddJsonPackage(openssl-cmake)
     endif()
 endif()
 
-find_package(OpenSSL 3 REQUIRED)
+if (OpenSSL_ADDED)
+    add_compile_definitions(YUZU_BUNDLED_OPENSSL)
+endif()
 
 message(STATUS "Fetching needed dependencies with CPM")
 

cpmfile.json

@@ -1,5 +1,5 @@
 {
-    "openssl": {
+    "openssl-ci": {
         "ci": true,
         "package": "OpenSSL",
         "name": "openssl",
@@ -7,6 +7,34 @@
         "version": "3.6.0-1cb0d36b39",
         "min_version": "3"
     },
+    "openssl-cmake": {
+        "repo": "jimmy-park/openssl-cmake",
+        "hash": "2cc185c924fd70e7d886257ca0caa42b3b8f7f712f2052b4f94dde74759e27022de76178460e18c9bdfc57c366583999e198fbb6052d4e7d91c099d15a0ca63e",
+        "git_version": "3.6.2",
+        "tag": "%VERSION%",
+        "bundled": true,
+        "options": [
+            "OPENSSL_CONFIGURE_OPTIONS threads"
+        ],
+        "patches": [
+            "0001-cpmutil-compat.patch",
+            "0002-use-ccache.patch",
+            "0003-use-cmake-compiler-flags.patch",
+            "0004-use-shell-wrapper.patch"
+        ]
+    },
+    "openssl": {
+        "repo": "openssl/openssl",
+        "package": "OpenSSL",
+        "min_version": "3",
+        "version": "3",
+        "hash": "29002ce50cb95a4f4f1d0e9d3f684401fbd4eac34203dc2eef3b6334af5d44aa46bf788b63a6f5c139c383eafb7269ae87a58a9a3ad5912903b9773e545ccc0a",
+        "git_version": "3.6.2",
+        "tag": "openssl-%VERSION%",
+        "patches": [
+            "0001-add-bundled-cert.patch"
+        ]
+    },
     "boost": {
         "package": "Boost",
         "repo": "boostorg/boost",

src/android/app/src/main/java/org/yuzu/yuzu_emu/activities/EmulationActivity.kt

@@ -15,7 +15,6 @@ import android.content.BroadcastReceiver
 import android.content.Context
 import android.content.Intent
 import android.content.IntentFilter
-import android.content.pm.PackageManager
 import android.content.res.Configuration
 import android.graphics.Rect
 import android.graphics.drawable.Icon
@@ -101,7 +100,6 @@ class EmulationActivity : AppCompatActivity(), SensorEventListener, InputManager
     private var romSwapGeneration = 0
     private var hasEmulationSession = processHasEmulationSession
     private val romSwapStopTimeoutRunnable = Runnable { onRomSwapStopTimeout() }
-    private val pictureInPictureFailureActions: MutableSet<String> = mutableSetOf()
 
     private fun onRomSwapStopTimeout() {
         if (!isWaitingForRomSwapStop) {
@@ -270,18 +268,12 @@ class EmulationActivity : AppCompatActivity(), SensorEventListener, InputManager
     }
 
     override fun onUserLeaveHint() {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S ||
-            !isPictureInPictureSupported() ||
-            !BooleanSetting.PICTURE_IN_PICTURE.getBoolean() ||
-            isInPictureInPictureMode
-        ) {
-            return
-        }
-
-        val pictureInPictureParamsBuilder = PictureInPictureParams.Builder()
-            .getPictureInPictureActionsBuilder().getPictureInPictureAspectBuilder()
-        runPictureInPictureAction("enter picture-in-picture mode") {
-            enterPictureInPictureMode(pictureInPictureParamsBuilder.build())
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S) {
+            if (BooleanSetting.PICTURE_IN_PICTURE.getBoolean() && !isInPictureInPictureMode) {
+                val pictureInPictureParamsBuilder = PictureInPictureParams.Builder()
+                    .getPictureInPictureActionsBuilder().getPictureInPictureAspectBuilder()
+                enterPictureInPictureMode(pictureInPictureParamsBuilder.build())
+            }
         }
     }
 
@@ -661,29 +653,7 @@ class EmulationActivity : AppCompatActivity(), SensorEventListener, InputManager
         return this.apply { setActions(pictureInPictureActions) }
     }
 
-    private fun isPictureInPictureSupported() =
-        Build.VERSION.SDK_INT >= Build.VERSION_CODES.O &&
-            packageManager.hasSystemFeature(PackageManager.FEATURE_PICTURE_IN_PICTURE)
-
-    private fun runPictureInPictureAction(actionName: String, action: () -> Unit) {
-        try {
-            action()
-        } catch (e: IllegalStateException) {
-            if (pictureInPictureFailureActions.add(actionName)) {
-                Log.warning("[PiP] Failed to $actionName: ${e.message}")
-            }
-        } catch (e: UnsupportedOperationException) {
-            if (pictureInPictureFailureActions.add(actionName)) {
-                Log.warning("[PiP] Failed to $actionName: ${e.message}")
-            }
-        }
-    }
-
     fun buildPictureInPictureParams() {
-        if (!isPictureInPictureSupported()) {
-            return
-        }
-
         val pictureInPictureParamsBuilder = PictureInPictureParams.Builder()
             .getPictureInPictureActionsBuilder().getPictureInPictureAspectBuilder()
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
@@ -693,9 +663,7 @@ class EmulationActivity : AppCompatActivity(), SensorEventListener, InputManager
                 BooleanSetting.PICTURE_IN_PICTURE.getBoolean() && isEmulationActive
             )
         }
-        runPictureInPictureAction("set picture-in-picture params") {
-            setPictureInPictureParams(pictureInPictureParamsBuilder.build())
-        }
+        setPictureInPictureParams(pictureInPictureParamsBuilder.build())
     }
 
     fun displayMultiplayerDialog() {

src/core/CMakeLists.txt

@@ -1200,7 +1200,7 @@ else()
         $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-cast-function-type>
         $<$<CXX_COMPILER_ID:Clang>:-fsized-deallocation>)
     # pre-clang19 will spam with "OH DID YOU MEAN THIS?" otherwise...
-    if (CXX_CLANG AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 19)
+    if (CXX_CLANG AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 20)
         target_compile_options(core PRIVATE $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-cast-function-type-mismatch>)
     endif()
 endif()

src/core/hle/kernel/svc/svc_debug.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -12,8 +15,8 @@ Result DebugActiveProcess(Core::System& system, Handle* out_handle, uint64_t pro
 }
 
 Result BreakDebugProcess(Core::System& system, Handle debug_handle) {
-    UNIMPLEMENTED();
-    R_THROW(ResultNotImplemented);
+    LOG_WARNING(Service, "(STUBBED) called");
+    R_SUCCEED();
 }
 
 Result TerminateDebugProcess(Core::System& system, Handle debug_handle) {

src/frontend_common/mod_manager.cpp

@@ -3,7 +3,6 @@
 
 #include <algorithm>
 #include <filesystem>
-#include <iostream>
 #include <fmt/format.h>
 #include "common/fs/fs.h"
 #include "common/fs/fs_types.h"

src/qt_common/CMakeLists.txt

@@ -31,6 +31,10 @@ add_library(qt_common STATIC
     abstract/frontend.h abstract/frontend.cpp
     abstract/progress.h abstract/progress.cpp
 
+    game_list/model.h game_list/model.cpp
+    game_list/worker.h game_list/worker.cpp
+    game_list/game_list_p.h
+
     qt_string_lookup.h
     qt_compat.h
 

src/qt_common/game_list/game_list_p.h

@@ -17,14 +17,13 @@
 #include <QRegularExpression>
 #include <QStandardItem>
 #include <QString>
-#include <QWidget>
 
 #include "common/common_types.h"
 #include "common/logging.h"
 #include "common/string_util.h"
 #include "frontend_common/play_time_manager.h"
 #include "qt_common/config/uisettings.h"
-#include "yuzu/util/util.h"
+#include "qt_common/qt_common.h"
 
 enum class GameListItemType {
     Game = QStandardItem::UserType + 1,
@@ -204,7 +203,7 @@ public:
         setData(compatibility, CompatNumberRole);
         setText(tr(status.text));
         setToolTip(tr(status.tooltip));
-        setData(CreateCirclePixmapFromColor(status.color), Qt::DecorationRole);
+        setData(QtCommon::CreateCirclePixmapFromColor(status.color), Qt::DecorationRole);
     }
 
     int type() const override {
@@ -237,7 +236,7 @@ public:
         // representations of the data are always accurate and in the correct format.
         if (role == SizeRole) {
             qulonglong size_bytes = value.toULongLong();
-            GameListItem::setData(ReadableByteSize(size_bytes), Qt::DisplayRole);
+            GameListItem::setData(QtCommon::ReadableByteSize(size_bytes), Qt::DisplayRole);
             GameListItem::setData(value, SizeRole);
         } else {
             GameListItem::setData(value, role);
@@ -398,49 +397,3 @@ public:
         return false;
     }
 };
-
-class GameList;
-class QHBoxLayout;
-class QTreeView;
-class QLabel;
-class QLineEdit;
-class QToolButton;
-
-class GameListSearchField : public QWidget {
-    Q_OBJECT
-
-public:
-    explicit GameListSearchField(GameList* parent = nullptr);
-
-    QString filterText() const;
-    void setFilterResult(int visible_, int total_);
-
-    void clear();
-    void setFocus();
-
-private:
-    void changeEvent(QEvent*) override;
-    void RetranslateUI();
-
-    class KeyReleaseEater : public QObject {
-    public:
-        explicit KeyReleaseEater(GameList* gamelist_, QObject* parent = nullptr);
-
-    private:
-        GameList* gamelist = nullptr;
-        QString edit_filter_text_old;
-
-    protected:
-        // EventFilter in order to process systemkeys while editing the searchfield
-        bool eventFilter(QObject* obj, QEvent* event) override;
-    };
-    int visible;
-    int total;
-
-    QHBoxLayout* layout_filter = nullptr;
-    QTreeView* tree_view = nullptr;
-    QLabel* label_filter = nullptr;
-    QLineEdit* edit_filter = nullptr;
-    QLabel* label_filter_result = nullptr;
-    QToolButton* button_filter_close = nullptr;
-};

src/qt_common/game_list/model.cpp

@@ -0,0 +1,303 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include <QDir>
+#include <QIcon>
+#include <QJsonArray>
+#include <QJsonDocument>
+#include <QJsonObject>
+#include <QThreadPool>
+
+#include "common/logging.h"
+#include "common/settings.h"
+#include "core/core.h"
+#include "core/file_sys/patch_manager.h"
+#include "core/file_sys/registered_cache.h"
+#include "core/hle/service/filesystem/filesystem.h"
+#include "qt_common/config/uisettings.h"
+#include "qt_common/qt_common.h"
+#include "qt_common/util/game.h"
+
+#include "qt_common/game_list/game_list_p.h"
+#include "qt_common/game_list/worker.h"
+#include "qt_common/game_list/model.h"
+
+GameListModel::GameListModel(std::shared_ptr<FileSys::VfsFilesystem> vfs_,
+                             FileSys::ManualContentProvider* provider_,
+                             const PlayTime::PlayTimeManager& play_time_manager_,
+                             Core::System& system_, QObject* parent)
+    : QStandardItemModel{parent}, vfs{std::move(vfs_)}, provider{provider_},
+      play_time_manager{play_time_manager_}, system{system_} {
+    watcher = new QFileSystemWatcher(this);
+    external_watcher = new QFileSystemWatcher(this);
+
+    connect(watcher, &QFileSystemWatcher::directoryChanged, this,
+            &GameListModel::RefreshGameDirectory);
+    connect(external_watcher, &QFileSystemWatcher::directoryChanged, this,
+            &GameListModel::RefreshExternalContent);
+
+    insertColumns(0, COLUMN_COUNT);
+    RetranslateUI();
+
+    setSortRole(GameListItemPath::SortRole);
+}
+
+GameListModel::~GameListModel() = default;
+
+void GameListModel::PopulateAsync(QVector<UISettings::GameDir>& game_dirs) {
+    current_worker.reset();
+    removeRows(0, rowCount());
+
+    current_worker = std::make_unique<GameListWorker>(vfs, provider, game_dirs, compatibility_list,
+                                                      play_time_manager, system);
+
+    connect(current_worker.get(), &GameListWorker::DataAvailable, this, &GameListModel::WorkerEvent,
+            Qt::QueuedConnection);
+
+    QThreadPool::globalInstance()->start(current_worker.get());
+}
+
+void GameListModel::WorkerEvent() {
+    current_worker->ProcessEvents(this);
+}
+
+void GameListModel::AddDirEntry(GameListDir* entry_items) {
+    if (m_flat) {
+        return;
+    }
+    invisibleRootItem()->appendRow(entry_items);
+}
+
+void GameListModel::AddEntry(const QList<QStandardItem*>& entry_items, GameListDir* parent) {
+    if (m_flat) {
+        invisibleRootItem()->appendRow(entry_items);
+    } else {
+        parent->appendRow(entry_items);
+    }
+}
+
+void GameListModel::DonePopulating(const QStringList& watch_list) {
+    emit ShowList(!IsEmpty());
+
+    if (!m_flat) {
+        invisibleRootItem()->appendRow(new GameListAddDir());
+        invisibleRootItem()->insertRow(0, new GameListFavorites());
+
+        for (const auto id : std::as_const(UISettings::values.favorited_ids)) {
+            AddFavorite(id);
+        }
+    }
+
+    emit PopulatingCompleted(watch_list);
+}
+
+bool GameListModel::IsEmpty() const {
+    for (int i = 0; i < rowCount(); i++) {
+        const QStandardItem* child = invisibleRootItem()->child(i);
+        const auto type = static_cast<GameListItemType>(child->type());
+
+        if (!child->hasChildren() &&
+            (type == GameListItemType::SdmcDir || type == GameListItemType::UserNandDir ||
+             type == GameListItemType::SysNandDir)) {
+            invisibleRootItem()->removeRow(child->row());
+            i--;
+        }
+    }
+
+    return !invisibleRootItem()->hasChildren();
+}
+
+void GameListModel::ToggleFavorite(u64 program_id) {
+    if (!UISettings::values.favorited_ids.contains(program_id)) {
+        UISettings::values.favorited_ids.append(program_id);
+        AddFavorite(program_id);
+    } else {
+        UISettings::values.favorited_ids.removeOne(program_id);
+        RemoveFavorite(program_id);
+    }
+    emit SaveConfig();
+}
+
+void GameListModel::AddFavorite(u64 program_id) {
+    auto* favorites_row = item(0);
+
+    for (int i = 1; i < rowCount() - 1; i++) {
+        const auto* folder = item(i);
+        for (int j = 0; j < folder->rowCount(); j++) {
+            if (folder->child(j)->data(GameListItemPath::ProgramIdRole).toULongLong() ==
+                program_id) {
+                QList<QStandardItem*> list;
+                for (int k = 0; k < COLUMN_COUNT; k++) {
+                    list.append(folder->child(j, k)->clone());
+                }
+                list[0]->setData(folder->child(j)->data(GameListItem::SortRole),
+                                 GameListItem::SortRole);
+                list[0]->setText(folder->child(j)->data(Qt::DisplayRole).toString());
+
+                favorites_row->appendRow(list);
+                return;
+            }
+        }
+    }
+}
+
+void GameListModel::RemoveFavorite(u64 program_id) {
+    auto* favorites_row = item(0);
+
+    for (int i = 0; i < favorites_row->rowCount(); i++) {
+        const auto* game = favorites_row->child(i);
+        if (game->data(GameListItemPath::ProgramIdRole).toULongLong() == program_id) {
+            favorites_row->removeRow(i);
+            return;
+        }
+    }
+}
+
+void GameListModel::LoadCompatibilityList() {
+    QFile compat_list{QStringLiteral(":compatibility_list/compatibility_list.json")};
+
+    if (!compat_list.open(QFile::ReadOnly | QFile::Text)) {
+        LOG_ERROR(Frontend, "Unable to open game compatibility list");
+        return;
+    }
+
+    if (compat_list.size() == 0) {
+        LOG_WARNING(Frontend, "Game compatibility list is empty");
+        return;
+    }
+
+    const QByteArray content = compat_list.readAll();
+    if (content.isEmpty()) {
+        LOG_ERROR(Frontend, "Unable to completely read game compatibility list");
+        return;
+    }
+
+    const QJsonDocument json = QJsonDocument::fromJson(content);
+    const QJsonArray arr = json.array();
+
+    for (const QJsonValue& value : arr) {
+        const QJsonObject game = value.toObject();
+        const QString compatibility_key = QStringLiteral("compatibility");
+
+        if (!game.contains(compatibility_key) || !game[compatibility_key].isDouble()) {
+            continue;
+        }
+
+        const int compatibility = game[compatibility_key].toInt();
+        const QString directory = game[QStringLiteral("directory")].toString();
+        const QJsonArray ids = game[QStringLiteral("releases")].toArray();
+
+        for (const QJsonValue& id_ref : ids) {
+            const QJsonObject id_object = id_ref.toObject();
+            const QString id = id_object[QStringLiteral("id")].toString();
+
+            compatibility_list.emplace(id.toUpper().toStdString(),
+                                       std::make_pair(QString::number(compatibility), directory));
+        }
+    }
+}
+
+void GameListModel::RefreshGameDirectory() {
+    ResetExternalWatcher();
+
+    if (!UISettings::values.game_dirs.empty() && current_worker != nullptr) {
+        LOG_INFO(Frontend, "Change detected in the games directory. Reloading game list.");
+        QtCommon::system->GetFileSystemController().CreateFactories(*QtCommon::vfs);
+        PopulateAsync(UISettings::values.game_dirs);
+    }
+}
+
+void GameListModel::RefreshExternalContent() {
+    if (!UISettings::values.game_dirs.empty() && current_worker != nullptr) {
+        LOG_INFO(Frontend, "External content directory changed. Clearing metadata cache.");
+        QtCommon::Game::ResetMetadata(false);
+        QtCommon::system->GetFileSystemController().CreateFactories(*QtCommon::vfs);
+        PopulateAsync(UISettings::values.game_dirs);
+    }
+}
+
+void GameListModel::ResetExternalWatcher() {
+    auto watch_dirs = external_watcher->directories();
+    if (!watch_dirs.isEmpty()) {
+        external_watcher->removePaths(watch_dirs);
+    }
+
+    for (const std::string& dir : Settings::values.external_content_dirs) {
+        external_watcher->addPath(QString::fromStdString(dir));
+    }
+}
+
+void GameListModel::OnUpdateThemedIcons() {
+    for (int i = 0; i < invisibleRootItem()->rowCount(); i++) {
+        QStandardItem* child = invisibleRootItem()->child(i);
+
+        const int icon_size = UISettings::values.folder_icon_size.GetValue();
+
+        switch (child->data(GameListItem::TypeRole).value<GameListItemType>()) {
+        case GameListItemType::SdmcDir:
+            child->setData(
+                QIcon::fromTheme(QStringLiteral("sd_card"))
+                    .pixmap(icon_size)
+                    .scaled(icon_size, icon_size, Qt::IgnoreAspectRatio, Qt::SmoothTransformation),
+                Qt::DecorationRole);
+            break;
+        case GameListItemType::UserNandDir:
+        case GameListItemType::SysNandDir:
+            child->setData(
+                QIcon::fromTheme(QStringLiteral("chip"))
+                    .pixmap(icon_size)
+                    .scaled(icon_size, icon_size, Qt::IgnoreAspectRatio, Qt::SmoothTransformation),
+                Qt::DecorationRole);
+            break;
+        case GameListItemType::CustomDir: {
+            const UISettings::GameDir& game_dir =
+                UISettings::values.game_dirs[child->data(GameListDir::GameDirRole).toInt()];
+            const QString icon_name = QFileInfo::exists(QString::fromStdString(game_dir.path))
+                                          ? QStringLiteral("folder")
+                                          : QStringLiteral("bad_folder");
+            child->setData(
+                QIcon::fromTheme(icon_name).pixmap(icon_size).scaled(
+                    icon_size, icon_size, Qt::IgnoreAspectRatio, Qt::SmoothTransformation),
+                Qt::DecorationRole);
+            break;
+        }
+        case GameListItemType::AddDir:
+            child->setData(
+                QIcon::fromTheme(QStringLiteral("list-add"))
+                    .pixmap(icon_size)
+                    .scaled(icon_size, icon_size, Qt::IgnoreAspectRatio, Qt::SmoothTransformation),
+                Qt::DecorationRole);
+            break;
+        case GameListItemType::Favorites:
+            child->setData(
+                QIcon::fromTheme(QStringLiteral("star"))
+                    .pixmap(icon_size)
+                    .scaled(icon_size, icon_size, Qt::IgnoreAspectRatio, Qt::SmoothTransformation),
+                Qt::DecorationRole);
+            break;
+        default:
+            break;
+        }
+    }
+}
+
+void GameListModel::RetranslateUI() {
+    setHeaderData(COLUMN_NAME, Qt::Horizontal, tr("Name"));
+    setHeaderData(COLUMN_COMPATIBILITY, Qt::Horizontal, tr("Compatibility"));
+    setHeaderData(COLUMN_ADD_ONS, Qt::Horizontal, tr("Add-ons"));
+    setHeaderData(COLUMN_FILE_TYPE, Qt::Horizontal, tr("File type"));
+    setHeaderData(COLUMN_SIZE, Qt::Horizontal, tr("Size"));
+    setHeaderData(COLUMN_PLAY_TIME, Qt::Horizontal, tr("Play time"));
+}
+
+QFileSystemWatcher* GameListModel::GetWatcher() const {
+    return watcher;
+}
+
+const CompatibilityList& GameListModel::GetCompatibilityList() const {
+    return compatibility_list;
+}
+
+void GameListModel::SetFlat(bool flat) {
+    m_flat = flat;
+}

src/qt_common/game_list/model.h

@@ -0,0 +1,98 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include <QFileSystemWatcher>
+#include <QStandardItemModel>
+#include <QStringList>
+#include <QVector>
+#include <memory>
+
+#include "common/common_types.h"
+#include "frontend_common/play_time_manager.h"
+#include "qt_common/config/uisettings.h"
+#include "yuzu/compatibility_list.h"
+
+namespace Core {
+class System;
+}
+
+class GameListDir;
+class GameListWorker;
+class QStandardItem;
+
+namespace FileSys {
+class ManualContentProvider;
+class VfsFilesystem;
+} // namespace FileSys
+
+class GameListModel : public QStandardItemModel {
+    Q_OBJECT
+
+public:
+    enum Column {
+        COLUMN_NAME,
+        COLUMN_FILE_TYPE,
+        COLUMN_SIZE,
+        COLUMN_PLAY_TIME,
+        COLUMN_ADD_ONS,
+        COLUMN_COMPATIBILITY,
+        COLUMN_COUNT,
+    };
+
+    explicit GameListModel(std::shared_ptr<FileSys::VfsFilesystem> vfs_,
+                           FileSys::ManualContentProvider* provider_,
+                           const PlayTime::PlayTimeManager& play_time_manager_,
+                           Core::System& system_, QObject* parent = nullptr);
+    ~GameListModel() override;
+
+    void AddDirEntry(GameListDir* entry_items);
+    void AddEntry(const QList<QStandardItem*>& entry_items, GameListDir* parent);
+    void DonePopulating(const QStringList& watch_list);
+
+    void PopulateAsync(QVector<UISettings::GameDir>& game_dirs);
+    void WorkerEvent();
+
+    bool IsEmpty() const;
+
+    void ToggleFavorite(u64 program_id);
+
+    void RefreshGameDirectory();
+    void RefreshExternalContent();
+    void ResetExternalWatcher();
+
+    void LoadCompatibilityList();
+
+    void OnUpdateThemedIcons();
+    void RetranslateUI();
+
+    QFileSystemWatcher* GetWatcher() const;
+
+    const CompatibilityList& GetCompatibilityList() const;
+
+    void SetFlat(bool flat);
+
+signals:
+    void ShowList(bool show);
+    void PopulatingCompleted(const QStringList& watch_list);
+    void SaveConfig();
+
+private:
+    friend class GameListWorker;
+
+    void AddFavorite(u64 program_id);
+    void RemoveFavorite(u64 program_id);
+
+    bool m_flat = false;
+
+    std::shared_ptr<FileSys::VfsFilesystem> vfs;
+    FileSys::ManualContentProvider* provider;
+    CompatibilityList compatibility_list;
+    const PlayTime::PlayTimeManager& play_time_manager;
+    Core::System& system;
+
+    std::unique_ptr<GameListWorker> current_worker;
+    QFileSystemWatcher* watcher = nullptr;
+    QFileSystemWatcher* external_watcher = nullptr;
+};

src/qt_common/game_list/worker.cpp

@@ -33,9 +33,10 @@
 #include "qt_common/qt_common.h"
 
 #include "yuzu/compatibility_list.h"
-#include "yuzu/game/game_list.h"
-#include "yuzu/game/game_list_p.h"
-#include "yuzu/game/game_list_worker.h"
+#include "qt_common/game_list/game_list_p.h"
+
+#include "qt_common/game_list/worker.h"
+#include "qt_common/game_list/model.h"
 
 namespace {
 
@@ -250,9 +251,9 @@ GameListWorker::~GameListWorker() {
     processing_completed.Wait();
 }
 
-void GameListWorker::ProcessEvents(GameList* game_list) {
+void GameListWorker::ProcessEvents(GameListModel* model) {
     while (true) {
-        std::function<void(GameList*)> func;
+        std::function<void(GameListModel*)> func;
         {
             // Lock queue to protect concurrent modification.
             std::scoped_lock lk(lock);
@@ -268,7 +269,7 @@ void GameListWorker::ProcessEvents(GameList* game_list) {
         }
 
         // Run the function.
-        func(game_list);
+        func(model);
     }
 }
 
@@ -335,7 +336,7 @@ void GameListWorker::AddTitlesToGameList(GameListDir* parent_dir) {
 
         auto entry = MakeGameListEntry(file->GetFullPath(), name, file->GetSize(), icon, *loader,
                                        program_id, compatibility_list, play_time_manager, patch);
-        RecordEvent([=](GameList* game_list) { game_list->AddEntry(entry, parent_dir); });
+        RecordEvent([=](GameListModel* model) { model->AddEntry(entry, parent_dir); });
     }
 }
 
@@ -417,7 +418,7 @@ void GameListWorker::ScanFileSystem(ScanTarget target, const std::string& dir_pa
                             id, compatibility_list, play_time_manager, patch);
 
                         RecordEvent(
-                            [=](GameList* game_list) { game_list->AddEntry(entry, parent_dir); });
+                            [=](GameListModel* model) { model->AddEntry(entry, parent_dir); });
                     }
                 } else {
                     std::vector<u8> icon;
@@ -434,7 +435,7 @@ void GameListWorker::ScanFileSystem(ScanTarget target, const std::string& dir_pa
                         program_id, compatibility_list, play_time_manager, patch);
 
                     RecordEvent(
-                        [=](GameList* game_list) { game_list->AddEntry(entry, parent_dir); });
+                        [=](GameListModel* model) { model->AddEntry(entry, parent_dir); });
                 }
             }
         } else if (is_dir) {
@@ -457,7 +458,7 @@ void GameListWorker::run() {
     provider->ClearAllEntries();
 
     const auto DirEntryReady = [&](GameListDir* game_list_dir) {
-        RecordEvent([=](GameList* game_list) { game_list->AddDirEntry(game_list_dir); });
+        RecordEvent([=](GameListModel* model) { model->AddDirEntry(game_list_dir); });
     };
 
     for (UISettings::GameDir& game_dir : game_dirs) {
@@ -491,6 +492,6 @@ void GameListWorker::run() {
         }
     }
 
-    RecordEvent([this](GameList* game_list) { game_list->DonePopulating(watch_list); });
+    RecordEvent([this](GameListModel* model) { model->DonePopulating(watch_list); });
     processing_completed.Set();
 }

src/qt_common/game_list/worker.h

@@ -26,8 +26,8 @@ namespace Core {
 class System;
 }
 
-class GameList;
 class GameListDir;
+class GameListModel;
 class QStandardItem;
 
 namespace FileSys {
@@ -58,11 +58,11 @@ public:
     /**
      * Synchronously processes any events queued by the worker.
      *
-     * AddDirEntry is called on the game list for every discovered directory.
-     * AddEntry is called on the game list for every discovered program.
-     * DonePopulating is called on the game list when processing completes.
+     * AddDirEntry is called on the model for every discovered directory.
+     * AddEntry is called on the model for every discovered program.
+     * DonePopulating is called on the model when processing completes.
      */
-    void ProcessEvents(GameList* game_list);
+    void ProcessEvents(GameListModel* model);
 
 signals:
     void DataAvailable();
@@ -92,7 +92,7 @@ private:
 
     std::mutex lock;
     std::condition_variable cv;
-    std::deque<std::function<void(GameList*)>> queued_events;
+    std::deque<std::function<void(GameListModel*)>> queued_events;
     std::atomic_bool stop_requested = false;
     Common::Event processing_completed;
 

src/qt_common/qt_common.cpp

@@ -5,6 +5,7 @@
 
 #include "common/memory_detect.h"
 #include "core/hle/service/filesystem/filesystem.h"
+#include "frontend_common/data_manager.h"
 #include "hid_core/hid_core.h"
 #include "network/network.h"
 #include "qt_common.h"
@@ -27,6 +28,7 @@
 
 #include <thread>
 #include <JlCompress.h>
+#include <QPainter>
 
 #if !defined(WIN32) && !defined(__APPLE__)
 #include <qpa/qplatformnativeinterface.h>
@@ -307,4 +309,19 @@ void SetupHID() {
     system->HIDCore().ReloadInputDevices();
 }
 
+QString ReadableByteSize(qulonglong size) {
+    return QString::fromStdString(FrontendCommon::DataManager::ReadableBytesSize(size));
+}
+
+QPixmap CreateCirclePixmapFromColor(const QColor& color) {
+    QPixmap circle_pixmap(16, 16);
+    circle_pixmap.fill(Qt::transparent);
+    QPainter painter(&circle_pixmap);
+    painter.setRenderHint(QPainter::Antialiasing);
+    painter.setPen(color);
+    painter.setBrush(color);
+    painter.drawEllipse({circle_pixmap.width() / 2.0, circle_pixmap.height() / 2.0}, 7.0, 7.0);
+    return circle_pixmap;
+}
+
 } // namespace QtCommon

src/qt_common/qt_common.h

@@ -45,5 +45,19 @@ void SetupHID();
 const QString tr(const char* str);
 const QString tr(const std::string& str);
 
+// TODO: Find a better place for these
+
+/// Convert a size in bytes into a readable format (KiB, MiB, etc.)
+[[nodiscard]] QString ReadableByteSize(qulonglong size);
+
+/**
+ * Creates a circle pixmap from a specified color
+ * @param color The color the pixmap shall have
+ * @return QPixmap circle pixmap
+ */
+[[nodiscard]] QPixmap CreateCirclePixmapFromColor(const QColor& color);
+
+
+
 std::filesystem::path GetEdenCommand();
 } // namespace QtCommon

src/qt_common/util/mod.cpp

@@ -33,10 +33,13 @@ QStringList GetModFolders(const QString& root, const QString& fallbackName) {
             std_path = paths[0];
 
         QString default_name;
-        if (!fallbackName.isEmpty())
-            default_name = fallbackName;
-        else if (!paths.empty())
+
+        // If this is an atmosphere-packed mod, the default name will end up as the game's title ID.
+        // So in this case ignore it and use the zip name instead
+        if (!paths.empty() && std_path.string().find("atmosphere") == std::string::npos)
             default_name = QString::fromStdString(std_path.filename().string());
+        else if (!fallbackName.isEmpty())
+            default_name = fallbackName;
         else
             default_name = root.split(QLatin1Char('/')).last();
 

src/shader_recompiler/ir_opt/texture_pass.cpp

@@ -12,6 +12,7 @@
 #include <limits>
 #include <boost/container/small_vector.hpp>
 
+#include "common/settings.h"
 #include "shader_recompiler/environment.h"
 #include "shader_recompiler/frontend/ir/basic_block.h"
 #include "shader_recompiler/frontend/ir/breadth_first_search.h"
@@ -820,8 +821,7 @@ void TexturePass(Environment& env, IR::Program& program, const HostTranslateInfo
             const auto insert_point{IR::Block::InstructionList::s_iterator_to(*inst)};
             IR::IREmitter ir{*texture_inst.block, insert_point};
             const IR::U32 shift{ir.Imm32(size_shift)};
-            inst->SetArg(0, ir.UMin(ir.ShiftRightLogical(cbuf.dynamic_offset, shift),
-                        ir.Imm32(count - 1)));
+            inst->SetArg(0, ir.UMin(ir.ShiftRightLogical(cbuf.dynamic_offset, shift), ir.Imm32(count - 1)));
         } else {
             inst->SetArg(0, IR::Value{});
         }

src/video_core/buffer_cache/buffer_cache.h

@@ -1893,23 +1893,17 @@ Binding BufferCache<P>::StorageBufferBinding(GPUVAddr ssbo_addr, u32 cbuf_index,
         return NULL_BINDING;
     }
 
-    // xbzk: New size logic. Fixes MCI.
-    // If ever the * comment below prove wrong, the 'if' block may be removed.
     const auto size = [&]() {
-        const bool is_nvn_cbuf = cbuf_index == 0;
-        if (is_nvn_cbuf) {
-            // * The NVN driver buffer (index 0) is known to pack the SSBO address followed by its size.
-            const u64 next_qword = gpu_memory->Read<u64>(ssbo_addr + 8);
-            const u32 upper_32 = static_cast<u32>(next_qword >> 32);
-            // Hardware-based detection: GPU addresses have non-zero upper bits
-            if (upper_32 == 0) {
-                // This is a size field, not a GPU address
-                return static_cast<u32>(next_qword);  // Return lower_32
-            }
+        const u32 memory_layout_size =
+            static_cast<u32>(gpu_memory->GetMemoryLayoutSize(gpu_addr));
+        const u64 next_qword = gpu_memory->Read<u64>(ssbo_addr + 8);
+        const u32 packed_size = static_cast<u32>(next_qword);
+        const bool next_qword_is_size = static_cast<u32>(next_qword >> 32) == 0 &&
+                                        packed_size != 0 &&
+                                        packed_size <= memory_layout_size;
+        if (next_qword_is_size) {
+            return packed_size;
         }
-        // Fall through: either not NVN cbuf (Doom Eternal & +), or NVN but ssbo_addr+8 is a GPU address (MCI)
-        const u32 memory_layout_size = static_cast<u32>(gpu_memory->GetMemoryLayoutSize(gpu_addr));
-        // Cap at 8MB to prevent allocator overflow from misinterpreted addresses
         return (std::min)(memory_layout_size, static_cast<u32>(8_MiB));
     }();
 

src/video_core/renderer_vulkan/blit_image.cpp

@@ -436,7 +436,7 @@ void TransitionImageLayout(vk::CommandBuffer& cmdbuf, VkImage image, VkImageLayo
             .layerCount = 1,
         },
     };
-    cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
+    cmdbuf.PipelineBarrier(vk::PIPELINE_STAGE_GRAPHICS_COMPUTE, vk::PIPELINE_STAGE_GRAPHICS_COMPUTE,
                            0, barrier);
 }
 

src/video_core/renderer_vulkan/present/util.cpp

@@ -69,7 +69,7 @@ void TransitionImageLayout(vk::CommandBuffer& cmdbuf, VkImage image, VkImageLayo
             .layerCount = 1,
         },
     };
-    cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
+    cmdbuf.PipelineBarrier(vk::PIPELINE_STAGE_GRAPHICS_COMPUTE, vk::PIPELINE_STAGE_GRAPHICS_COMPUTE,
                            0, barrier);
 }
 
@@ -171,10 +171,10 @@ void DownloadColorImage(vk::CommandBuffer& cmdbuf, VkImage image, VkBuffer buffe
         .imageOffset{.x = 0, .y = 0, .z = 0},
         .imageExtent{extent},
     };
-    cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, 0,
+    cmdbuf.PipelineBarrier(vk::PIPELINE_STAGE_GRAPHICS_COMPUTE_TRANSFER, VK_PIPELINE_STAGE_TRANSFER_BIT, 0,
                            read_barrier);
     cmdbuf.CopyImageToBuffer(image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, buffer, copy);
-    cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0,
+    cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, vk::PIPELINE_STAGE_GRAPHICS_COMPUTE, 0,
                            memory_write_barrier, nullptr, image_write_barrier);
 }
 

src/video_core/renderer_vulkan/renderer_vulkan.cpp

@@ -8,7 +8,6 @@
 #include <array>
 #include <cstring>
 #include <memory>
-#include <mutex>
 #include <optional>
 #include <string>
 #include <vector>
@@ -172,11 +171,7 @@ try
 
 RendererVulkan::~RendererVulkan() {
     scheduler.RegisterOnSubmit([] {});
-    scheduler.Finish();
-    {
-        std::scoped_lock lock{scheduler.submit_mutex};
-        void(device.GetLogical().WaitIdle());
-    }
+    void(device.GetLogical().WaitIdle());
 }
 
 void RendererVulkan::Composite(std::span<const Tegra::FramebufferConfig> framebuffers) {

src/video_core/renderer_vulkan/vk_blit_screen.cpp

@@ -8,7 +8,6 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include <vulkan/vulkan_core.h>
-#include <mutex>
 #include "video_core/framebuffer_config.h"
 #include "video_core/present.h"
 #include "video_core/renderer_vulkan/present/filters.h"
@@ -32,10 +31,7 @@ BlitScreen::~BlitScreen() = default;
 void BlitScreen::WaitIdle() {
     present_manager.WaitPresent();
     scheduler.Finish();
-    {
-        std::scoped_lock lock{scheduler.submit_mutex};
-        device.GetLogical().WaitIdle();
-    }
+    device.GetLogical().WaitIdle();
 }
 
 void BlitScreen::SetWindowAdaptPass() {

src/video_core/renderer_vulkan/vk_buffer_cache.cpp

@@ -437,13 +437,13 @@ void BufferCacheRuntime::CopyBuffer(VkBuffer dst_buffer, VkBuffer src_buffer,
     scheduler.RequestOutsideRenderPassOperationContext();
     scheduler.Record([src_buffer, dst_buffer, vk_copies, barrier](vk::CommandBuffer cmdbuf) {
         if (barrier) {
-            cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
+            cmdbuf.PipelineBarrier(vk::PIPELINE_STAGE_GRAPHICS_COMPUTE_TRANSFER,
                                    VK_PIPELINE_STAGE_TRANSFER_BIT, 0, READ_BARRIER);
         }
         cmdbuf.CopyBuffer(src_buffer, dst_buffer, VideoCommon::FixSmallVectorADL(vk_copies));
         if (barrier) {
             cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT,
-                                   VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, WRITE_BARRIER);
+                                   vk::PIPELINE_STAGE_GRAPHICS_COMPUTE, 0, WRITE_BARRIER);
         }
     });
 }
@@ -457,7 +457,7 @@ void BufferCacheRuntime::PreCopyBarrier() {
     };
     scheduler.RequestOutsideRenderPassOperationContext();
     scheduler.Record([](vk::CommandBuffer cmdbuf) {
-        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
+        cmdbuf.PipelineBarrier(vk::PIPELINE_STAGE_GRAPHICS_COMPUTE_TRANSFER, VK_PIPELINE_STAGE_TRANSFER_BIT,
                                0, READ_BARRIER);
     });
 }
@@ -471,7 +471,7 @@ void BufferCacheRuntime::PostCopyBarrier() {
     };
     scheduler.RequestOutsideRenderPassOperationContext();
     scheduler.Record([](vk::CommandBuffer cmdbuf) {
-        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
+        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, vk::PIPELINE_STAGE_GRAPHICS_COMPUTE,
                                0, WRITE_BARRIER);
     });
 }
@@ -495,10 +495,10 @@ void BufferCacheRuntime::ClearBuffer(VkBuffer dest_buffer, u32 offset, size_t si
 
     scheduler.RequestOutsideRenderPassOperationContext();
     scheduler.Record([dest_buffer, offset, size, value](vk::CommandBuffer cmdbuf) {
-        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
+        cmdbuf.PipelineBarrier(vk::PIPELINE_STAGE_GRAPHICS_COMPUTE_TRANSFER, VK_PIPELINE_STAGE_TRANSFER_BIT,
                                0, READ_BARRIER);
         cmdbuf.FillBuffer(dest_buffer, offset, size, value);
-        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
+        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, vk::PIPELINE_STAGE_GRAPHICS_COMPUTE,
                                0, WRITE_BARRIER);
     });
 }

src/video_core/renderer_vulkan/vk_compute_pass.cpp

@@ -454,8 +454,8 @@ void ConditionalRenderingResolvePass::Resolve(VkBuffer dst_buffer, VkBuffer src_
         const VkDescriptorSet set = descriptor_allocator.Commit();
         device.GetLogical().UpdateDescriptorSet(set, *descriptor_template, descriptor_data);
 
-        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
-                               VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, 0, read_barrier);
+        cmdbuf.PipelineBarrier(vk::PIPELINE_STAGE_GRAPHICS_COMPUTE_TRANSFER,
+                       VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, 0, read_barrier);
         cmdbuf.BindPipeline(VK_PIPELINE_BIND_POINT_COMPUTE, *pipeline);
         cmdbuf.BindDescriptorSets(VK_PIPELINE_BIND_POINT_COMPUTE, *layout, 0, set, {});
         cmdbuf.PushConstants(*layout, VK_SHADER_STAGE_COMPUTE_BIT, uniforms);
@@ -537,7 +537,7 @@ void QueriesPrefixScanPass::Run(VkBuffer accumulation_buffer, VkBuffer dst_buffe
             cmdbuf.PushConstants(*layout, VK_SHADER_STAGE_COMPUTE_BIT, uniforms);
             cmdbuf.Dispatch(1, 1, 1);
             cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
-                                   VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, write_barrier);
+                                   vk::PIPELINE_STAGE_GRAPHICS_COMPUTE, 0, write_barrier);
         });
     }
 }
@@ -589,9 +589,9 @@ void ASTCDecoderPass::Assemble(Image& image, const StagingBufferRef& map,
                 .layerCount = VK_REMAINING_ARRAY_LAYERS,
             },
         };
-        cmdbuf.PipelineBarrier(is_initialized ? VK_PIPELINE_STAGE_ALL_COMMANDS_BIT
-                                              : VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
-                               VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, 0, image_barrier);
+        cmdbuf.PipelineBarrier(is_initialized ? vk::PIPELINE_STAGE_GRAPHICS_COMPUTE_TRANSFER
+                              : VkPipelineStageFlags(VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT),
+                       VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, 0, image_barrier);
         cmdbuf.BindPipeline(VK_PIPELINE_BIND_POINT_COMPUTE, vk_pipeline);
     });
     for (const VideoCommon::SwizzleParameters& swizzle : swizzles) {
@@ -648,7 +648,7 @@ void ASTCDecoderPass::Assemble(Image& image, const StagingBufferRef& map,
             },
         };
         cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
-                               VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, image_barrier);
+                       vk::PIPELINE_STAGE_GRAPHICS_COMPUTE, 0, image_barrier);
     });
     scheduler.Finish();
 }

src/video_core/renderer_vulkan/vk_pipeline_cache.cpp

@@ -492,8 +492,7 @@ PipelineCache::PipelineCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,
         device.IsExtExtendedDynamicState3BlendingSupported();
     dynamic_features.has_extended_dynamic_state_3_enables =
         device.IsExtExtendedDynamicState3EnablesSupported();
-    dynamic_features.has_dynamic_state3_depth_clamp_enable =
-        device.SupportsDynamicState3DepthClampEnable();
+    dynamic_features.has_dynamic_state3_depth_clamp_enable = false;
     dynamic_features.has_dynamic_state3_logic_op_enable =
         device.SupportsDynamicState3LogicOpEnable();
     dynamic_features.has_dynamic_state3_line_stipple_enable =

src/video_core/renderer_vulkan/vk_present_manager.cpp

@@ -429,7 +429,7 @@ void PresentManager::CopyToSwapchainImpl(Frame* frame) {
         },
     };
 
-    cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT, {},
+    cmdbuf.PipelineBarrier(vk::PIPELINE_STAGE_GRAPHICS_COMPUTE_TRANSFER, VK_PIPELINE_STAGE_TRANSFER_BIT, {},
                            {}, {}, pre_barriers);
 
     if (blit_supported) {

src/video_core/renderer_vulkan/vk_query_cache.cpp

@@ -157,9 +157,8 @@ public:
         ReserveHostQuery();
 
         scheduler.Record([query_pool = current_query_pool,
-                          query_index = current_bank_slot](vk::CommandBuffer cmdbuf) {
+                                 query_index = current_bank_slot](vk::CommandBuffer cmdbuf) {
             const bool use_precise = Settings::IsGPULevelHigh();
-            cmdbuf.ResetQueryPool(query_pool, static_cast<u32>(query_index), 1);
             cmdbuf.BeginQuery(query_pool, static_cast<u32>(query_index),
                               use_precise ? VK_QUERY_CONTROL_PRECISE_BIT : 0);
         });
@@ -221,7 +220,8 @@ public:
         }
         PauseCounter();
         const auto driver_id = device.GetDriverID();
-        if (driver_id == VK_DRIVER_ID_ARM_PROPRIETARY || driver_id == VK_DRIVER_ID_MESA_TURNIP) {
+        if (driver_id == VK_DRIVER_ID_QUALCOMM_PROPRIETARY ||
+            driver_id == VK_DRIVER_ID_ARM_PROPRIETARY || driver_id == VK_DRIVER_ID_MESA_TURNIP) {
             pending_sync.clear();
             sync_values_stash.clear();
             return;
@@ -846,7 +846,7 @@ public:
         scheduler.RequestOutsideRenderPassOperationContext();
         scheduler.Record([](vk::CommandBuffer cmdbuf) {
             cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT,
-                                   VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, WRITE_BARRIER);
+                                   vk::PIPELINE_STAGE_HOST, 0, WRITE_BARRIER);
         });
 
         std::scoped_lock lk(flush_guard);
@@ -1587,13 +1587,13 @@ void QueryCacheRuntime::Barriers(bool is_prebarrier) {
     impl->scheduler.RequestOutsideRenderPassOperationContext();
     if (is_prebarrier) {
         impl->scheduler.Record([](vk::CommandBuffer cmdbuf) {
-            cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
+            cmdbuf.PipelineBarrier(vk::PIPELINE_STAGE_GRAPHICS_COMPUTE_TRANSFER,
                                    VK_PIPELINE_STAGE_TRANSFER_BIT, 0, READ_BARRIER);
         });
     } else {
         impl->scheduler.Record([](vk::CommandBuffer cmdbuf) {
             cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT,
-                                   VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, WRITE_BARRIER);
+                                   vk::PIPELINE_STAGE_GRAPHICS_COMPUTE_TRANSFER_HOST, 0, WRITE_BARRIER);
         });
     }
 }

src/video_core/renderer_vulkan/vk_rasterizer.cpp

@@ -580,7 +580,7 @@ void RasterizerVulkan::DispatchCompute() {
         .srcAccessMask = VK_ACCESS_MEMORY_WRITE_BIT,
         .dstAccessMask = VK_ACCESS_MEMORY_READ_BIT,
     };
-    scheduler.Record([](vk::CommandBuffer cmdbuf) { cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
+    scheduler.Record([](vk::CommandBuffer cmdbuf) { cmdbuf.PipelineBarrier(vk::PIPELINE_STAGE_GRAPHICS_COMPUTE_TRANSFER, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
                                0, READ_BARRIER); });
     scheduler.Record([dim](vk::CommandBuffer cmdbuf) { cmdbuf.Dispatch(dim[0], dim[1], dim[2]); });
 

src/video_core/renderer_vulkan/vk_scheduler.cpp

@@ -267,8 +267,7 @@ u64 Scheduler::SubmitExecution(VkSemaphore signal_semaphore, VkSemaphore wait_se
             .srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
             .dstAccessMask = VK_ACCESS_MEMORY_READ_BIT | VK_ACCESS_MEMORY_WRITE_BIT,
         };
-        upload_cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_VERTEX_SHADER_BIT
-            | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, 0, WRITE_BARRIER);
+        upload_cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, WRITE_BARRIER);
         upload_cmdbuf.End();
         cmdbuf.End();
 
@@ -372,7 +371,7 @@ void Scheduler::EndRenderPass()
             }
             cmdbuf.EndRenderPass();
             cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT |
-                                   VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
+                                   VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT, vk::PIPELINE_STAGE_GRAPHICS_COMPUTE,
                                    0, nullptr, nullptr, vk::Span(barriers.data(), num_images));
         });
 

src/video_core/renderer_vulkan/vk_texture_cache.cpp

@@ -860,12 +860,12 @@ void BlitScale(Scheduler& scheduler, VkImage src_image, VkImage dst_image, const
                 .subresourceRange = subresource_range,
             },
         };
-        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
-                               0, nullptr, nullptr, read_barriers);
+        cmdbuf.PipelineBarrier(vk::PIPELINE_STAGE_GRAPHICS_COMPUTE_TRANSFER, VK_PIPELINE_STAGE_TRANSFER_BIT,
+                       0, nullptr, nullptr, read_barriers);
         cmdbuf.BlitImage(src_image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, dst_image,
                          VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, regions, vk_filter);
-        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
-                               0, nullptr, nullptr, write_barriers);
+        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, vk::PIPELINE_STAGE_GRAPHICS_COMPUTE,
+                       0, nullptr, nullptr, write_barriers);
     });
 }
 } // Anonymous namespace
@@ -1123,19 +1123,19 @@ void TextureCacheRuntime::ReinterpretImage(Image& dst, Image& src,
                 .subresourceRange = dst_range.SubresourceRange(dst_aspect_mask),
             },
         };
-        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
-                               0, {}, {}, pre_barriers);
+        cmdbuf.PipelineBarrier(vk::PIPELINE_STAGE_GRAPHICS_COMPUTE_TRANSFER, VK_PIPELINE_STAGE_TRANSFER_BIT,
+                       0, {}, {}, pre_barriers);
 
         cmdbuf.CopyImageToBuffer(src_image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, copy_buffer,
                                  vk_in_copies);
-        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
-                               0, WRITE_BARRIER, nullptr, middle_in_barrier);
+        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, vk::PIPELINE_STAGE_GRAPHICS_COMPUTE,
+                       0, WRITE_BARRIER, nullptr, middle_in_barrier);
 
-        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
-                               0, READ_BARRIER, {}, middle_out_barrier);
+        cmdbuf.PipelineBarrier(vk::PIPELINE_STAGE_GRAPHICS_COMPUTE_TRANSFER, VK_PIPELINE_STAGE_TRANSFER_BIT,
+                       0, READ_BARRIER, {}, middle_out_barrier);
         cmdbuf.CopyBufferToImage(copy_buffer, dst_image, VK_IMAGE_LAYOUT_GENERAL, vk_out_copies);
-        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
-                               0, {}, {}, post_barriers);
+        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, vk::PIPELINE_STAGE_GRAPHICS_COMPUTE,
+                       0, {}, {}, post_barriers);
     });
 }
 
@@ -1261,8 +1261,8 @@ void TextureCacheRuntime::BlitImage(Framebuffer* dst_framebuffer, ImageView& dst
                 .layerCount = VK_REMAINING_ARRAY_LAYERS,
             },
         };
-        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
-                               0, nullptr, nullptr, read_barriers);
+        cmdbuf.PipelineBarrier(vk::PIPELINE_STAGE_GRAPHICS_COMPUTE_TRANSFER, VK_PIPELINE_STAGE_TRANSFER_BIT,
+                       0, nullptr, nullptr, read_barriers);
         if (is_resolve) {
             cmdbuf.ResolveImage(src_image, VK_IMAGE_LAYOUT_GENERAL, dst_image,
                                 VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
@@ -1274,8 +1274,8 @@ void TextureCacheRuntime::BlitImage(Framebuffer* dst_framebuffer, ImageView& dst
                 src_image, VK_IMAGE_LAYOUT_GENERAL, dst_image, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
                 MakeImageBlit(dst_region, src_region, dst_layers, src_layers), vk_filter);
         }
-        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
-                               0, write_barrier);
+        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, vk::PIPELINE_STAGE_GRAPHICS_COMPUTE,
+                       0, write_barrier);
     });
 }
 
@@ -1852,7 +1852,7 @@ void Image::DownloadMemory(std::span<VkBuffer> buffers_span, std::span<size_t> o
                         .layerCount = VK_REMAINING_ARRAY_LAYERS,
                     },
                 };
-                cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
+                cmdbuf.PipelineBarrier(vk::PIPELINE_STAGE_GRAPHICS_COMPUTE_TRANSFER, VK_PIPELINE_STAGE_TRANSFER_BIT,
                                        0, read_barrier);
 
                 for (size_t index = 0; index < buffers.size(); index++) {
@@ -1884,7 +1884,7 @@ void Image::DownloadMemory(std::span<VkBuffer> buffers_span, std::span<size_t> o
                         .layerCount = VK_REMAINING_ARRAY_LAYERS,
                     },
                 };
-                cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
+                cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, vk::PIPELINE_STAGE_GRAPHICS_COMPUTE,
                                        0, memory_write_barrier, nullptr, image_write_barrier);
             });
             return;
@@ -1919,7 +1919,7 @@ void Image::DownloadMemory(std::span<VkBuffer> buffers_span, std::span<size_t> o
                     .layerCount = VK_REMAINING_ARRAY_LAYERS,
                 },
             };
-            cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT,
+            cmdbuf.PipelineBarrier(vk::PIPELINE_STAGE_GRAPHICS_COMPUTE_TRANSFER, VK_PIPELINE_STAGE_TRANSFER_BIT,
                                    0, read_barrier);
 
             for (size_t index = 0; index < buffers.size(); index++) {
@@ -1951,7 +1951,7 @@ void Image::DownloadMemory(std::span<VkBuffer> buffers_span, std::span<size_t> o
                     .layerCount = VK_REMAINING_ARRAY_LAYERS,
                 },
             };
-            cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
+            cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, vk::PIPELINE_STAGE_GRAPHICS_COMPUTE,
                                    0, memory_write_barrier, nullptr, image_write_barrier);
         });
     }
@@ -2524,8 +2524,8 @@ void TextureCacheRuntime::TransitionImageLayout(Image& image) {
         };
         scheduler.RequestOutsideRenderPassOperationContext();
         scheduler.Record([barrier](vk::CommandBuffer cmdbuf) {
-            cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
-                                   VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, barrier);
+            cmdbuf.PipelineBarrier(vk::PIPELINE_STAGE_GRAPHICS_COMPUTE,
+                                   vk::PIPELINE_STAGE_GRAPHICS_COMPUTE, 0, barrier);
         });
     }
 }

src/video_core/vulkan_common/vulkan_device.cpp

@@ -486,11 +486,15 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
     CollectToolingInfo();
 
     if (is_qualcomm) {
-        // Qualcomm Adreno GPUs doesn't handle scaled vertex attributes; keep emulation enabled
+        LOG_WARNING(Render_Vulkan,
+                    "Qualcomm drivers require scaled vertex format emulation");
         must_emulate_scaled_formats = true;
         LOG_WARNING(Render_Vulkan,
-                    "Qualcomm drivers require scaled vertex format emulation; forcing fallback");
-
+                    "Qualcomm drivers have broken provoking vertex");
+        RemoveExtension(extensions.provoking_vertex, VK_EXT_PROVOKING_VERTEX_EXTENSION_NAME);
+        LOG_WARNING(Render_Vulkan,
+                    "Qualcomm drivers have slow push descriptor implementation");
+        RemoveExtension(extensions.push_descriptor, VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME);
         LOG_WARNING(Render_Vulkan,
                     "Disabling shader float controls and 64-bit integer features on Qualcomm proprietary drivers");
         RemoveExtension(extensions.shader_float_controls, VK_KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME);

src/video_core/vulkan_common/vulkan_wrapper.cpp

@@ -123,7 +123,6 @@ void Load(VkDevice device, DeviceDispatch& dld) noexcept {
     X(vkCmdEndDebugUtilsLabelEXT);
     X(vkCmdFillBuffer);
     X(vkCmdPipelineBarrier);
-    X(vkCmdResetQueryPool);
     X(vkCmdPushConstants);
     X(vkCmdPushDescriptorSetWithTemplateKHR);
     X(vkCmdSetBlendConstants);

src/video_core/vulkan_common/vulkan_wrapper.h

@@ -146,6 +146,18 @@ inline VkResult Filter(VkResult result) {
     return result;
 }
 
+inline constexpr VkPipelineStageFlags PIPELINE_STAGE_GRAPHICS_COMPUTE =
+    VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT | VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
+
+inline constexpr VkPipelineStageFlags PIPELINE_STAGE_GRAPHICS_COMPUTE_TRANSFER =
+    PIPELINE_STAGE_GRAPHICS_COMPUTE | VK_PIPELINE_STAGE_TRANSFER_BIT;
+
+inline constexpr VkPipelineStageFlags PIPELINE_STAGE_GRAPHICS_COMPUTE_TRANSFER_HOST =
+    PIPELINE_STAGE_GRAPHICS_COMPUTE_TRANSFER | VK_PIPELINE_STAGE_HOST_BIT;
+
+inline constexpr VkPipelineStageFlags PIPELINE_STAGE_HOST = VK_PIPELINE_STAGE_HOST_BIT;
+
+
 /// Table holding Vulkan instance function pointers.
 struct InstanceDispatch {
     PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr{};
@@ -225,7 +237,6 @@ struct DeviceDispatch : InstanceDispatch {
     PFN_vkCmdEndTransformFeedbackEXT vkCmdEndTransformFeedbackEXT{};
     PFN_vkCmdFillBuffer vkCmdFillBuffer{};
     PFN_vkCmdPipelineBarrier vkCmdPipelineBarrier{};
-    PFN_vkCmdResetQueryPool vkCmdResetQueryPool{};
     PFN_vkCmdPushConstants vkCmdPushConstants{};
     PFN_vkCmdPushDescriptorSetWithTemplateKHR vkCmdPushDescriptorSetWithTemplateKHR{};
     PFN_vkCmdResolveImage vkCmdResolveImage{};
@@ -1169,10 +1180,6 @@ public:
         dld->vkCmdEndQuery(handle, query_pool, query);
     }
 
-    void ResetQueryPool(VkQueryPool query_pool, u32 first_query, u32 query_count) const noexcept {
-        dld->vkCmdResetQueryPool(handle, query_pool, first_query, query_count);
-    }
-
     void BindDescriptorSets(VkPipelineBindPoint bind_point, VkPipelineLayout layout, u32 first,
                             Span<VkDescriptorSet> sets, Span<u32> dynamic_offsets) const noexcept {
         dld->vkCmdBindDescriptorSets(handle, bind_point, layout, first, sets.size(), sets.data(),

src/yuzu/CMakeLists.txt

@@ -156,13 +156,12 @@ add_executable(yuzu
     debugger/controller.cpp
     debugger/controller.h
 
-    game/game_list.cpp
-    game/game_list.h
-    game/game_list_p.h
-    game/game_list_worker.cpp
-    game/game_list_worker.h
-    game/game_card.h
-    game/game_card.cpp
+    game/game_list.cpp game/game_list.h
+    game/game_grid.cpp game/game_grid.h
+
+    game/game_tree.h game/game_tree.cpp
+    game/game_card.h game/game_card.cpp
+    game/search_field.h game/search_field.cpp
 
     hotkeys.cpp
     hotkeys.h
@@ -219,18 +218,16 @@ add_executable(yuzu
     util/util.h
     compatdb.cpp
     compatdb.h
-    user_data_migration.cpp
-    user_data_migration.h
+
+    user_data_migration.h user_data_migration.cpp
 
     yuzu.qrc
     yuzu.rc
     migration_dialog.h migration_dialog.cpp
-    migration_worker.h
-    migration_worker.cpp
+    migration_worker.h migration_worker.cpp
+    libqt_common.h libqt_common.cpp
 
-    deps_dialog.cpp
-    deps_dialog.h
-    deps_dialog.ui
+    deps_dialog.cpp deps_dialog.h deps_dialog.ui
 
     data_dialog.h data_dialog.cpp data_dialog.ui
     data_widget.ui
@@ -242,7 +239,6 @@ add_executable(yuzu
     configuration/addon/mod_select_dialog.h configuration/addon/mod_select_dialog.cpp configuration/addon/mod_select_dialog.ui
 
     render/performance_overlay.h render/performance_overlay.cpp render/performance_overlay.ui
-    libqt_common.h libqt_common.cpp
     updater/update_dialog.h updater/update_dialog.cpp updater/update_dialog.ui)
 
 set_target_properties(yuzu PROPERTIES OUTPUT_NAME "eden")

src/yuzu/configuration/configure_per_game.cpp

@@ -30,6 +30,7 @@
 #include "core/loader/loader.h"
 #include "frontend_common/config.h"
 #include "qt_common/config/uisettings.h"
+#include "qt_common/qt_common.h"
 #include "qt_common/util/vk.h"
 #include "ui_configure_per_game.h"
 #include "yuzu/configuration/configuration_shared.h"
@@ -205,6 +206,6 @@ void ConfigurePerGame::LoadConfiguration() {
     ui->display_format->setText(
         QString::fromStdString(Loader::GetFileTypeString(loader->GetFileType())));
 
-    const auto valueText = ReadableByteSize(file->GetSize());
+    const auto valueText = QtCommon::ReadableByteSize(file->GetSize());
     ui->display_size->setText(valueText);
 }

src/yuzu/game/game_card.cpp

@@ -18,34 +18,27 @@ void GameCard::paint(QPainter* painter, const QStyleOptionViewItem& option,
     painter->save();
     painter->setRenderHint(QPainter::Antialiasing);
 
-    // Padding, dimensions, alignment...
+    constexpr int cardMargin = 8;
+    constexpr int cardCornerRadius = 10;
+
     const int column = index.row() % m_columns;
     const int cell_width = option.rect.width();
-    const int fixed_card_width = cell_width - m_padding;
-    const int margins = 8;
+    const int card_width = cell_width - m_padding;
 
-    // The gist of it is that this anchors the left and right sides to the edges,
-    // while maintaining an even gap between each card.
-    // I just smashed random keys into my keyboard until something worked.
-    // Don't even bother trying to figure out what the hell this is doing.
-    const auto total_row_width = m_columns * cell_width;
-    const auto total_gap_space = total_row_width - (margins * 2) - (m_columns * fixed_card_width);
-    const auto gap = (m_columns > 1) ? (total_gap_space / (m_columns - 1)) : 0;
+    const int row_width = m_columns * cell_width;
+    const int total_gap = row_width - cardMargin * 2 - m_columns * card_width;
+    const int gap = (m_columns > 1) ? (total_gap / (m_columns - 1)) : 0;
 
-    const auto relative_x = margins + (column * (fixed_card_width + gap));
-    const auto x_pos = option.rect.left() - (column * cell_width) + static_cast<int>(relative_x);
+    const int card_left = option.rect.left() - column * cell_width + cardMargin + column * (card_width + gap) + 4;
+    const QRect cardRect(card_left, option.rect.top() + 4, card_width - 8,
+                         option.rect.height() - cardMargin);
 
-    // also, add some additional padding here to prevent card overlap
-    QRect cardRect(x_pos + 4, option.rect.top() + 4, fixed_card_width - 8,
-                   option.rect.height() - margins);
-
-    // colors
     QPalette palette = option.palette;
     QColor backgroundColor = palette.window().color();
     QColor borderColor = palette.dark().color();
     QColor textColor = palette.text().color();
 
-    // if it's selected add a blue background
+    // highlight blue on select
     if (option.state & QStyle::State_Selected) {
         backgroundColor = palette.highlight().color();
         borderColor = palette.highlight().color().lighter(150);
@@ -54,63 +47,45 @@ void GameCard::paint(QPainter* painter, const QStyleOptionViewItem& option,
         backgroundColor = backgroundColor.lighter(120);
     }
 
-    // bg
     painter->setBrush(backgroundColor);
     painter->setPen(QPen(borderColor, 1));
-    painter->drawRoundedRect(cardRect, 10, 10);
+    painter->drawRoundedRect(cardRect, cardCornerRadius, cardCornerRadius);
 
-    // icon
-    int _iconsize = UISettings::values.game_icon_size.GetValue();
-    QSize iconSize(_iconsize, _iconsize);
-    QPixmap iconPixmap = index.data(Qt::DecorationRole).value<QPixmap>();
+    const u32 icon_size = UISettings::values.game_icon_size.GetValue();
+    QPixmap icon_pixmap = index.data(Qt::DecorationRole).value<QPixmap>();
 
     QRect iconRect;
-    if (!iconPixmap.isNull()) {
-        QSize scaledSize = iconPixmap.size();
-        scaledSize.scale(iconSize, Qt::KeepAspectRatio);
+    if (!icon_pixmap.isNull()) {
+        QSize scaled = icon_pixmap.size();
+        scaled.scale(icon_size, icon_size, Qt::KeepAspectRatio);
 
-        int x = cardRect.left() + (cardRect.width() - scaledSize.width()) / 2;
-        int y = cardRect.top() + margins;
-
-        iconRect = QRect(x, y, scaledSize.width(), scaledSize.height());
+        iconRect = {cardRect.left() + (cardRect.width() - scaled.width()) / 2,
+                    cardRect.top() + cardMargin, scaled.width(), scaled.height()};
 
         painter->setRenderHint(QPainter::SmoothPixmapTransform, true);
 
-        // Put this in a separate thing on the painter stack to prevent clipping the text.
         painter->save();
-
-        // round image edges
-        QPainterPath path;
-        path.addRoundedRect(iconRect, 10, 10);
-        painter->setClipPath(path);
-
-        painter->drawPixmap(iconRect, iconPixmap);
-
+        QPainterPath clip_path;
+        clip_path.addRoundedRect(iconRect, cardCornerRadius, cardCornerRadius);
+        painter->setClipPath(clip_path);
+        painter->drawPixmap(iconRect, icon_pixmap);
         painter->restore();
     } else {
-        // if there is no icon just draw a blank rect
-        iconRect = QRect(cardRect.left() + margins, cardRect.top() + margins, _iconsize, _iconsize);
+        iconRect = {cardRect.left() + cardMargin, cardRect.top() + cardMargin,
+                    static_cast<int>(icon_size), static_cast<int>(icon_size)};
     }
 
     if (UISettings::values.show_game_name.GetValue()) {
-        // padding + text
         QRect textRect = cardRect;
-        textRect.setTop(iconRect.bottom() + margins);
-        textRect.adjust(margins, 0, -margins, -margins);
+        textRect.setTop(iconRect.bottom() + cardMargin);
+        textRect.adjust(cardMargin, 0, -cardMargin, -cardMargin);
 
-        // We are already crammed on space, ignore the row 2
-        QString title = index.data(Qt::DisplayRole).toString();
-        title = title.split(QLatin1Char('\n')).first();
+        QString title = index.data(Qt::DisplayRole).toString().split(QLatin1Char('\n')).first();
 
-        // now draw text
         painter->setPen(textColor);
         QFont font = option.font;
         font.setBold(true);
-
-        // TODO(crueter): fix this abysmal scaling
-        font.setPixelSize(1.5 + std::max(10.0, std::sqrt(_iconsize)));
-
-        // TODO(crueter): elide mode
+        font.setPixelSize(std::max(11.0, std::sqrt(static_cast<double>(icon_size))));
         painter->setFont(font);
 
         painter->drawText(textRect, Qt::AlignHCenter | Qt::AlignTop | Qt::TextWordWrap, title);

src/yuzu/game/game_grid.cpp

@@ -0,0 +1,118 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include <QScroller>
+#include <QScrollerProperties>
+
+#include "qt_common/config/uisettings.h"
+#include "yuzu/game/game_card.h"
+#include "yuzu/game/game_grid.h"
+#include "qt_common/game_list/game_list_p.h"
+#include "qt_common/game_list/model.h"
+
+GameGrid::GameGrid(QWidget* parent) : QListView{parent} {
+    m_gameCard = new GameCard(this);
+    setItemDelegate(m_gameCard);
+
+    setViewMode(QListView::ListMode);
+    setResizeMode(QListView::Fixed);
+    setUniformItemSizes(true);
+    setSelectionMode(QAbstractItemView::SingleSelection);
+    setVerticalScrollMode(QAbstractItemView::ScrollPerPixel);
+    setHorizontalScrollMode(QAbstractItemView::ScrollPerPixel);
+
+    setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+
+    setEditTriggers(QAbstractItemView::NoEditTriggers);
+    setContextMenuPolicy(Qt::CustomContextMenu);
+    setGridSize(QSize(140, 160));
+    m_gameCard->setSize(gridSize(), 0, 4);
+
+    setSpacing(10);
+    setWordWrap(true);
+    setTextElideMode(Qt::ElideRight);
+    setFlow(QListView::LeftToRight);
+    setWrapping(true);
+}
+
+void GameGrid::SetModel(GameListModel* model) {
+    QListView::setModel(model);
+    UpdateIconSize();
+}
+
+void GameGrid::ApplyFilter(const QString& edit_filter_text, GameListModel* model) {
+    int row_count = model->rowCount();
+
+    auto ContainsAllWords = [](const QString& haystack, const QString& userinput) {
+        const QStringList userinput_split =
+            userinput.split(QLatin1Char{' '}, Qt::SkipEmptyParts);
+        return std::all_of(userinput_split.begin(), userinput_split.end(),
+                           [&haystack](const QString& s) { return haystack.contains(s); });
+    };
+
+    for (int i = 0; i < row_count; ++i) {
+        QStandardItem* item = model->item(i, 0);
+        if (!item)
+            continue;
+
+        const QString file_path =
+            item->data(GameListItemPath::FullPathRole).toString().toLower();
+        const QString file_title =
+            item->data(GameListItemPath::TitleRole).toString().toLower();
+        const QString file_name = file_path.mid(file_path.lastIndexOf(QLatin1Char{'/'}) + 1) +
+                                  QLatin1Char{' '} + file_title;
+
+        if (edit_filter_text.isEmpty() || ContainsAllWords(file_name, edit_filter_text)) {
+            setRowHidden(i, false);
+        } else {
+            setRowHidden(i, true);
+        }
+    }
+}
+
+void GameGrid::UpdateIconSize() {
+    const u32 icon_size = UISettings::values.game_icon_size.GetValue();
+
+    int heightMargin = 0;
+    int widthMargin = 80;
+
+    if (UISettings::values.show_game_name) {
+        switch (icon_size) {
+        case 128:
+            heightMargin = 65;
+            break;
+        case 0:
+            widthMargin = 120;
+            heightMargin = 120;
+            break;
+        case 64:
+            heightMargin = 77;
+            break;
+        case 32:
+        case 256:
+            heightMargin = 81;
+            break;
+        }
+    } else {
+        widthMargin = 24;
+        heightMargin = 24;
+    }
+
+    const int view_width = viewport()->width();
+
+    const double spacing = 0.01;
+    const int min_item_width = icon_size + widthMargin;
+
+    int columns = std::max(1, (view_width - 16) / min_item_width);
+    int stretched_width = ((view_width) - (spacing * (columns - 1))) / columns;
+
+    QSize grid_size(stretched_width, icon_size + heightMargin);
+    if (gridSize() != grid_size) {
+        setUpdatesEnabled(false);
+
+        setGridSize(grid_size);
+        m_gameCard->setSize(grid_size, stretched_width - min_item_width, columns);
+
+        setUpdatesEnabled(true);
+    }
+}

src/yuzu/game/game_grid.h

@@ -0,0 +1,26 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include <QListView>
+#include <QString>
+
+#include "common/common_types.h"
+
+class GameCard;
+class GameListModel;
+
+class GameGrid : public QListView {
+    Q_OBJECT
+
+public:
+    explicit GameGrid(QWidget* parent = nullptr);
+
+    void SetModel(GameListModel* model);
+    void ApplyFilter(const QString& edit_filter_text, GameListModel* model);
+    void UpdateIconSize();
+
+private:
+    GameCard* m_gameCard = nullptr;
+};

src/yuzu/game/game_list.h

@@ -6,14 +6,12 @@
 
 #pragma once
 
-#include <QFileSystemWatcher>
 #include <QLabel>
 #include <QLineEdit>
 #include <QList>
 #include <QPushButton>
 #include <QStandardItemModel>
 #include <QString>
-#include <QTreeView>
 #include <QVBoxLayout>
 #include <QVector>
 #include <QWidget>
@@ -28,21 +26,22 @@
 
 class QVariantAnimation;
 
-class QListView;
-
 class GameCard;
-namespace Core {
-class System;
-}
-
+class GameListModel;
+class GameTree;
+class GameGrid;
+class GameListSearchField;
 class ControllerNavigation;
 class GameListWorker;
-class GameListSearchField;
 class GameListDir;
 class MainWindow;
 enum class AmLaunchType;
 enum class StartGameType;
 
+namespace Core {
+class System;
+}
+
 namespace FileSys {
 class ManualContentProvider;
 class VfsFilesystem;
@@ -62,16 +61,6 @@ class GameList : public QWidget {
     Q_OBJECT
 
 public:
-    enum {
-        COLUMN_NAME,
-        COLUMN_FILE_TYPE,
-        COLUMN_SIZE,
-        COLUMN_PLAY_TIME,
-        COLUMN_ADD_ONS,
-        COLUMN_COMPATIBILITY,
-        COLUMN_COUNT, // Number of columns
-    };
-
     explicit GameList(std::shared_ptr<FileSys::VfsFilesystem> vfs_,
                       FileSys::ManualContentProvider* provider_,
                       PlayTime::PlayTimeManager& play_time_manager_, Core::System& system_,
@@ -95,13 +84,11 @@ public:
     /// Disables events from the emulated controller
     void UnloadController();
 
-    bool IsTreeMode();
     void ResetViewMode();
 
 public slots:
     void RefreshGameDirectory();
     void RefreshExternalContent();
-    void ResetExternalWatcher();
 
 signals:
     void BootGame(const QString& game_path, StartGameType type);
@@ -130,27 +117,20 @@ signals:
     void SaveConfig();
 
 private slots:
-    void OnItemExpanded(const QModelIndex& item);
     void OnTextChanged(const QString& new_text);
     void OnFilterCloseClicked();
     void OnUpdateThemedIcons();
-
-    void UpdateIconSize();
+    void OnPopulatingCompleted(const QStringList& watch_list);
 
 private:
-    friend class GameListWorker;
-    void WorkerEvent();
+    void SetupViews();
+    void SetupScrollAnimation();
+    bool eventFilter(QObject* obj, QEvent* event) override;
+    void changeEvent(QEvent*) override;
 
-    void AddDirEntry(GameListDir* entry_items);
-    void AddEntry(const QList<QStandardItem*>& entry_items, GameListDir* parent);
-    void DonePopulating(const QStringList& watch_list);
-
-private:
     void ValidateEntry(const QModelIndex& item);
 
     void ToggleFavorite(u64 program_id);
-    void AddFavorite(u64 program_id);
-    void RemoveFavorite(u64 program_id);
 
     void PopupContextMenu(const QPoint& menu_location);
     void AddGamePopup(QMenu& context_menu, u64 program_id, const std::string& path);
@@ -158,41 +138,32 @@ private:
     void AddPermDirPopup(QMenu& context_menu, QModelIndex selected);
     void AddFavoritesPopup(QMenu& context_menu);
 
-    void changeEvent(QEvent*) override;
     void RetranslateUI();
 
+    friend class GameListSearchField;
+
     std::shared_ptr<FileSys::VfsFilesystem> vfs;
     FileSys::ManualContentProvider* provider;
-    GameListSearchField* search_field;
+    GameListSearchField* search_field = nullptr;
     MainWindow* main_window = nullptr;
     QVBoxLayout* layout = nullptr;
 
-    QTreeView* tree_view = nullptr;
-    QListView* list_view = nullptr;
-    GameCard* m_gameCard = nullptr;
+    GameTree* tree_view = nullptr;
+    GameGrid* grid_view = nullptr;
+    GameListModel* item_model = nullptr;
 
-    QStandardItemModel* item_model = nullptr;
-    std::unique_ptr<GameListWorker> current_worker;
-    QFileSystemWatcher* watcher = nullptr;
-    QFileSystemWatcher* external_watcher = nullptr;
     ControllerNavigation* controller_navigation = nullptr;
-    CompatibilityList compatibility_list;
 
     QVariantAnimation* vertical_scroll = nullptr;
     QVariantAnimation* horizontal_scroll = nullptr;
     int vertical_scroll_target = 0;
     int horizontal_scroll_target = 0;
 
-    void SetupScrollAnimation();
-    bool eventFilter(QObject* obj, QEvent* event) override;
-
-    friend class GameListSearchField;
-
     const PlayTime::PlayTimeManager& play_time_manager;
     Core::System& system;
 
     bool m_isTreeMode = true;
-    QAbstractItemView* m_currentView = tree_view;
+    QAbstractItemView* m_currentView = nullptr;
 };
 
 class GameListPlaceholder : public QWidget {

src/yuzu/game/game_tree.cpp

@@ -0,0 +1,173 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include <QApplication>
+#include <QHeaderView>
+#include <QScroller>
+#include <QScrollerProperties>
+
+#include "qt_common/config/uisettings.h"
+#include "qt_common/game_list/game_list_p.h"
+#include "yuzu/game/game_tree.h"
+#include "qt_common/game_list/model.h"
+
+GameTree::GameTree(QWidget* parent) : QTreeView{parent} {
+    setAlternatingRowColors(true);
+    setSelectionMode(QHeaderView::SingleSelection);
+    setSelectionBehavior(QHeaderView::SelectRows);
+    setVerticalScrollMode(QHeaderView::ScrollPerPixel);
+    setHorizontalScrollMode(QHeaderView::ScrollPerPixel);
+    setSortingEnabled(true);
+    setEditTriggers(QHeaderView::NoEditTriggers);
+    setContextMenuPolicy(Qt::CustomContextMenu);
+    setAttribute(Qt::WA_AcceptTouchEvents, true);
+    setStyleSheet(QStringLiteral("QTreeView{ border: none; }"));
+
+    connect(this, &QTreeView::expanded, this, &GameTree::OnItemExpanded);
+    connect(this, &QTreeView::collapsed, this, &GameTree::OnItemExpanded);
+}
+
+void GameTree::SetModel(GameListModel* model) {
+    QTreeView::setModel(model);
+    LoadInterfaceLayout();
+    UpdateColumnVisibility(model);
+}
+
+void GameTree::OnItemExpanded(const QModelIndex& item) {
+    const auto type = item.data(GameListItem::TypeRole).value<GameListItemType>();
+    const bool is_dir = type == GameListItemType::CustomDir || type == GameListItemType::SdmcDir ||
+                        type == GameListItemType::UserNandDir ||
+                        type == GameListItemType::SysNandDir;
+    const bool is_fave = type == GameListItemType::Favorites;
+    if (!is_dir && !is_fave) {
+        return;
+    }
+    const bool is_expanded = isExpanded(item);
+    if (is_fave) {
+        UISettings::values.favorites_expanded = is_expanded;
+        return;
+    }
+    const int item_dir_index = item.data(GameListDir::GameDirRole).toInt();
+    UISettings::values.game_dirs[item_dir_index].expanded = is_expanded;
+}
+
+void GameTree::SaveInterfaceLayout() {
+    UISettings::values.gamelist_header_state = header()->saveState();
+}
+
+void GameTree::LoadInterfaceLayout() {
+    auto* hdr = header();
+
+    if (hdr->restoreState(UISettings::values.gamelist_header_state))
+        return;
+
+    hdr->resizeSection(GameListModel::COLUMN_NAME, 840);
+}
+
+void GameTree::UpdateColumnVisibility(GameListModel* model) {
+    Q_UNUSED(model)
+    setColumnHidden(GameListModel::COLUMN_ADD_ONS, !UISettings::values.show_add_ons);
+    setColumnHidden(GameListModel::COLUMN_COMPATIBILITY, !UISettings::values.show_compat);
+    setColumnHidden(GameListModel::COLUMN_FILE_TYPE, !UISettings::values.show_types);
+    setColumnHidden(GameListModel::COLUMN_SIZE, !UISettings::values.show_size);
+    setColumnHidden(GameListModel::COLUMN_PLAY_TIME, !UISettings::values.show_play_time);
+}
+
+QString GameTree::GetLastFilterResultItem() const {
+    QString file_path;
+
+    auto* model = qobject_cast<GameListModel*>(QTreeView::model());
+    if (!model)
+        return {};
+
+    for (int i = 1; i < model->rowCount() - 1; ++i) {
+        const QStandardItem* folder = model->item(i, 0);
+        const QModelIndex folder_index = folder->index();
+        const int children_count = folder->rowCount();
+
+        for (int j = 0; j < children_count; ++j) {
+            if (isRowHidden(j, folder_index)) {
+                continue;
+            }
+
+            const QStandardItem* child = folder->child(j, 0);
+            file_path = child->data(GameListItemPath::FullPathRole).toString();
+        }
+    }
+
+    return file_path;
+}
+
+int GameTree::FilterClosedResultCount(GameListModel* model) {
+    int children_total = 0;
+
+    auto hide_favorites_row = UISettings::values.favorited_ids.size() == 0;
+    setRowHidden(0, model->invisibleRootItem()->index(), hide_favorites_row);
+
+    for (int i = 1; i < model->rowCount() - 1; ++i) {
+        auto* folder = model->item(i, 0);
+        const QModelIndex folder_index = folder->index();
+        const int children_count = folder->rowCount();
+        for (int j = 0; j < children_count; ++j) {
+            ++children_total;
+            setRowHidden(j, folder_index, false);
+        }
+    }
+
+    return children_total;
+}
+
+void GameTree::ApplyFilter(const QString& edit_filter_text, GameListModel* model) {
+    int children_total = 0;
+    int result_count = 0;
+
+    if (edit_filter_text.isEmpty()) {
+        children_total = FilterClosedResultCount(model);
+        emit FilterResultReady(children_total, children_total);
+        return;
+    }
+
+    setRowHidden(0, model->invisibleRootItem()->index(), true);
+
+    for (int i = 1; i < model->rowCount() - 1; ++i) {
+        auto* folder = model->item(i, 0);
+        const QModelIndex folder_index = folder->index();
+        const int children_count = folder->rowCount();
+
+        for (int j = 0; j < children_count; ++j) {
+            ++children_total;
+
+            const QStandardItem* child = folder->child(j, 0);
+
+            const auto program_id = child->data(GameListItemPath::ProgramIdRole).toULongLong();
+
+            const QString file_path =
+                child->data(GameListItemPath::FullPathRole).toString().toLower();
+            const QString file_title =
+                child->data(GameListItemPath::TitleRole).toString().toLower();
+            const QString file_program_id =
+                QStringLiteral("%1").arg(program_id, 16, 16, QLatin1Char{'0'});
+
+            const QString file_name =
+                file_path.mid(file_path.lastIndexOf(QLatin1Char{'/'}) + 1) + QLatin1Char{' '} +
+                file_title;
+
+            auto ContainsAllWords = [](const QString& haystack, const QString& userinput) {
+                const QStringList userinput_split =
+                    userinput.split(QLatin1Char{' '}, Qt::SkipEmptyParts);
+                return std::all_of(userinput_split.begin(), userinput_split.end(),
+                                   [&haystack](const QString& s) { return haystack.contains(s); });
+            };
+
+            if (ContainsAllWords(file_name, edit_filter_text) ||
+                (file_program_id.size() == 16 && file_program_id.contains(edit_filter_text))) {
+                setRowHidden(j, folder_index, false);
+                ++result_count;
+            } else {
+                setRowHidden(j, folder_index, true);
+            }
+        }
+    }
+
+    emit FilterResultReady(result_count, children_total);
+}

src/yuzu/game/game_tree.h

@@ -0,0 +1,35 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include <QHeaderView>
+#include <QString>
+#include <QTreeView>
+
+class GameListModel;
+
+class GameTree : public QTreeView {
+    Q_OBJECT
+
+public:
+    explicit GameTree(QWidget* parent = nullptr);
+
+    void SetModel(GameListModel* model);
+
+    QString GetLastFilterResultItem() const;
+    int FilterClosedResultCount(GameListModel* model);
+    void ApplyFilter(const QString& edit_filter_text, GameListModel* model);
+
+    void SaveInterfaceLayout();
+    void LoadInterfaceLayout();
+
+    void UpdateColumnVisibility(GameListModel* model);
+
+signals:
+    void ItemExpandedChanged(const QModelIndex& item);
+    void FilterResultReady(int visible, int total);
+
+private slots:
+    void OnItemExpanded(const QModelIndex& item);
+};

src/yuzu/game/search_field.cpp

@@ -0,0 +1,124 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "game/game_list.h"
+#include "game/search_field.h"
+
+#include <QKeyEvent>
+#include <QToolButton>
+
+// TODO: Remove GameList dependence?
+GameListSearchField::KeyReleaseEater::KeyReleaseEater(GameList* gamelist_, QObject* parent)
+    : QObject(parent), gamelist{gamelist_} {}
+
+// EventFilter in order to process systemkeys while editing the searchfield
+bool GameListSearchField::KeyReleaseEater::eventFilter(QObject* obj, QEvent* event) {
+    // If it isn't a KeyRelease event then continue with standard event processing
+    if (event->type() != QEvent::KeyRelease)
+        return QObject::eventFilter(obj, event);
+
+    QKeyEvent* keyEvent = static_cast<QKeyEvent*>(event);
+    QString edit_filter_text = gamelist->search_field->edit_filter->text().toLower();
+
+    // If the searchfield's text hasn't changed special function keys get checked
+    // If no function key changes the searchfield's text the filter doesn't need to get reloaded
+    if (edit_filter_text == edit_filter_text_old) {
+        switch (keyEvent->key()) {
+        // Escape: Resets the searchfield
+        case Qt::Key_Escape: {
+            if (edit_filter_text_old.isEmpty()) {
+                return QObject::eventFilter(obj, event);
+            } else {
+                gamelist->search_field->edit_filter->clear();
+                edit_filter_text.clear();
+            }
+            break;
+        }
+        // Return and Enter
+        // If the enter key gets pressed first checks how many and which entry is visible
+        // If there is only one result launch this game
+        case Qt::Key_Return:
+        case Qt::Key_Enter: {
+            if (gamelist->search_field->visible == 1) {
+                const QString file_path = gamelist->GetLastFilterResultItem();
+
+                // To avoid loading error dialog loops while confirming them using enter
+                // Also users usually want to run a different game after closing one
+                gamelist->search_field->edit_filter->clear();
+                edit_filter_text.clear();
+                emit gamelist->GameChosen(file_path);
+            } else {
+                return QObject::eventFilter(obj, event);
+            }
+            break;
+        }
+        default:
+            return QObject::eventFilter(obj, event);
+        }
+    }
+    edit_filter_text_old = edit_filter_text;
+    return QObject::eventFilter(obj, event);
+}
+
+void GameListSearchField::setFilterResult(int visible_, int total_) {
+    visible = visible_;
+    total = total_;
+
+    label_filter_result->setText(tr("%1 of %n result(s)", "", total).arg(visible));
+}
+
+QString GameListSearchField::filterText() const {
+    return edit_filter->text();
+}
+
+void GameListSearchField::clear() {
+    edit_filter->clear();
+}
+
+void GameListSearchField::setFocus() {
+    if (edit_filter->isVisible()) {
+        edit_filter->setFocus();
+    }
+}
+
+GameListSearchField::GameListSearchField(GameList* parent) : QWidget{parent} {
+    auto* const key_release_eater = new KeyReleaseEater(parent, this);
+    layout_filter = new QHBoxLayout;
+    layout_filter->setContentsMargins(8, 8, 8, 8);
+    label_filter = new QLabel;
+    edit_filter = new QLineEdit;
+    edit_filter->clear();
+    edit_filter->installEventFilter(key_release_eater);
+    edit_filter->setClearButtonEnabled(true);
+    connect(edit_filter, &QLineEdit::textChanged, parent, &GameList::OnTextChanged);
+    label_filter_result = new QLabel;
+    button_filter_close = new QToolButton(this);
+    button_filter_close->setText(QStringLiteral("X"));
+    button_filter_close->setCursor(Qt::ArrowCursor);
+    button_filter_close->setStyleSheet(
+        QStringLiteral("QToolButton{ border: none; padding: 0px; color: "
+                       "#000000; font-weight: bold; background: #F0F0F0; }"
+                       "QToolButton:hover{ border: none; padding: 0px; color: "
+                       "#EEEEEE; font-weight: bold; background: #E81123}"));
+    connect(button_filter_close, &QToolButton::clicked, parent, &GameList::OnFilterCloseClicked);
+    layout_filter->setSpacing(10);
+    layout_filter->addWidget(label_filter);
+    layout_filter->addWidget(edit_filter);
+    layout_filter->addWidget(label_filter_result);
+    layout_filter->addWidget(button_filter_close);
+    setLayout(layout_filter);
+    RetranslateUI();
+}
+
+void GameListSearchField::changeEvent(QEvent* event) {
+    if (event->type() == QEvent::LanguageChange) {
+        RetranslateUI();
+    }
+
+    QWidget::changeEvent(event);
+}
+
+void GameListSearchField::RetranslateUI() {
+    label_filter->setText(tr("Filter:"));
+    edit_filter->setPlaceholderText(tr("Enter pattern to filter"));
+}

src/yuzu/game/search_field.h

@@ -0,0 +1,52 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include <QWidget>
+
+class GameList;
+class QHBoxLayout;
+class QTreeView;
+class QLabel;
+class QLineEdit;
+class QToolButton;
+
+class GameListSearchField : public QWidget {
+    Q_OBJECT
+
+public:
+    explicit GameListSearchField(GameList* parent = nullptr);
+
+    QString filterText() const;
+    void setFilterResult(int visible_, int total_);
+
+    void clear();
+    void setFocus();
+
+private:
+    void changeEvent(QEvent*) override;
+    void RetranslateUI();
+
+    class KeyReleaseEater : public QObject {
+    public:
+        explicit KeyReleaseEater(GameList* gamelist_, QObject* parent = nullptr);
+
+    private:
+        GameList* gamelist = nullptr;
+        QString edit_filter_text_old;
+
+    protected:
+        // EventFilter in order to process systemkeys while editing the searchfield
+        bool eventFilter(QObject* obj, QEvent* event) override;
+    };
+    int visible;
+    int total;
+
+    QHBoxLayout* layout_filter = nullptr;
+    QTreeView* tree_view = nullptr;
+    QLabel* label_filter = nullptr;
+    QLineEdit* edit_filter = nullptr;
+    QLabel* label_filter_result = nullptr;
+    QToolButton* button_filter_close = nullptr;
+};

src/yuzu/multiplayer/chat_room.cpp

@@ -20,7 +20,7 @@
 #include "common/logging.h"
 #include "network/announce_multiplayer_session.h"
 #include "ui_chat_room.h"
-#include "yuzu/game/game_list_p.h"
+#include "qt_common/game_list/game_list_p.h"
 #include "yuzu/multiplayer/chat_room.h"
 #include "yuzu/multiplayer/message.h"
 #ifdef ENABLE_WEB_SERVICE

src/yuzu/multiplayer/client_room.cpp

@@ -14,7 +14,7 @@
 #include "common/logging.h"
 #include "network/announce_multiplayer_session.h"
 #include "ui_client_room.h"
-#include "yuzu/game/game_list_p.h"
+#include "qt_common/game_list/game_list_p.h"
 #include "yuzu/multiplayer/client_room.h"
 #include "yuzu/multiplayer/message.h"
 #include "yuzu/multiplayer/moderation_dialog.h"

src/yuzu/multiplayer/host_room.cpp

@@ -20,7 +20,7 @@
 #include "network/announce_multiplayer_session.h"
 #include "qt_common/config/uisettings.h"
 #include "ui_host_room.h"
-#include "yuzu/game/game_list_p.h"
+#include "qt_common/game_list/game_list_p.h"
 #include "yuzu/main_window.h"
 #include "yuzu/multiplayer/host_room.h"
 #include "yuzu/multiplayer/message.h"

src/yuzu/multiplayer/lobby.cpp

@@ -15,7 +15,7 @@
 #include "network/network.h"
 #include "qt_common/config/uisettings.h"
 #include "ui_lobby.h"
-#include "yuzu/game/game_list_p.h"
+#include "qt_common/game_list/game_list_p.h"
 #include "yuzu/main_window.h"
 #include "yuzu/multiplayer/client_room.h"
 #include "yuzu/multiplayer/lobby.h"

src/yuzu/util/util.cpp

@@ -4,14 +4,11 @@
 // SPDX-FileCopyrightText: 2015 Citra Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include <cmath>
 #include <QPainter>
 
 #include "applets/qt_profile_select.h"
-#include "common/logging.h"
 #include "core/frontend/applets/profile_select.h"
 #include "core/hle/service/acc/profile_manager.h"
-#include "frontend_common/data_manager.h"
 #include "qt_common/qt_common.h"
 #include "yuzu/util/util.h"
 
@@ -28,21 +25,6 @@ QFont GetMonospaceFont() {
     return font;
 }
 
-QString ReadableByteSize(qulonglong size) {
-    return QString::fromStdString(FrontendCommon::DataManager::ReadableBytesSize(size));
-}
-
-QPixmap CreateCirclePixmapFromColor(const QColor& color) {
-    QPixmap circle_pixmap(16, 16);
-    circle_pixmap.fill(Qt::transparent);
-    QPainter painter(&circle_pixmap);
-    painter.setRenderHint(QPainter::Antialiasing);
-    painter.setPen(color);
-    painter.setBrush(color);
-    painter.drawEllipse({circle_pixmap.width() / 2.0, circle_pixmap.height() / 2.0}, 7.0, 7.0);
-    return circle_pixmap;
-}
-
 const std::optional<Common::UUID> GetProfileID() {
     // if there's only a single profile, the user probably wants to use that... right?
     const auto& profiles = QtCommon::system->GetProfileManager().FindExistingProfileUUIDs();

src/yuzu/util/util.h

@@ -13,16 +13,6 @@
 /// Returns a QFont object appropriate to use as a monospace font for debugging widgets, etc.
 [[nodiscard]] QFont GetMonospaceFont();
 
-/// Convert a size in bytes into a readable format (KiB, MiB, etc.)
-[[nodiscard]] QString ReadableByteSize(qulonglong size);
-
-/**
- * Creates a circle pixmap from a specified color
- * @param color The color the pixmap shall have
- * @return QPixmap circle pixmap
- */
-[[nodiscard]] QPixmap CreateCirclePixmapFromColor(const QColor& color);
-
 /**
  * Prompt the user for a profile ID. If there is only one valid profile, returns that profile.
  * @return The selected profile, or an std::nullopt if none were selected