fix for crashes on TLS due to openorbis being W E I R D

change default to opengl
proper memswap mechanism
2025-12-26 12:11:19 +00:00 · 2025-12-26 12:11:19 +00:00 · 2025-12-26 12:11:19 +00:00 · 2025-12-26 12:11:19 +00:00 · 2025-12-26 12:11:19 +00:00 · 2025-12-26 12:11:19 +00:00
144 changed files with 2221 additions and 4190 deletions
--- a/.ci/ps4/build.sh
+++ b/.ci/ps4/build.sh
@@ -0,0 +1,54 @@
+#!/usr/local/bin/bash -ex
+
+# SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+[ -f "ps4-toolchain.cmake" ] || cat << EOF >"ps4-toolchain.cmake"
+set(CMAKE_SYSROOT "$OO_PS4_TOOLCHAIN")
+set(CMAKE_STAGING_PREFIX "$OO_PS4_TOOLCHAIN")
+set(CMAKE_SYSTEM_NAME "OpenOrbis")
+
+set(CMAKE_C_FLAGS " -D__OPENORBIS__ -D_LIBCPP_HAS_MUSL_LIBC=1 -D_GNU_SOURCE=1 --target=x86_64-pc-freebsd12-elf -mtune=x86-64 -march=x86-64 -fPIC -funwind-tables")
+set(CMAKE_CXX_FLAGS " -D__OPENORBIS__ -D_LIBCPP_HAS_MUSL_LIBC=1 -D_GNU_SOURCE=1 --target=x86_64-pc-freebsd12-elf -mtune=x86-64 -march=x86-64 -fPIC -funwind-tables")
+
+set(CMAKE_EXE_LINKER_FLAGS "-m elf_x86_64 -pie -T $OO_PS4_TOOLCHAIN/link.x --eh-frame-hdr -L$OO_PS4_TOOLCHAIN/lib")
+set(CMAKE_C_LINK_FLAGS "-m elf_x86_64 -pie -T $OO_PS4_TOOLCHAIN/link.x --eh-frame-hdr -L$OO_PS4_TOOLCHAIN/lib")
+set(CMAKE_CXX_LINK_FLAGS "-m elf_x86_64 -pie -T $OO_PS4_TOOLCHAIN/link.x --eh-frame-hdr -L$OO_PS4_TOOLCHAIN/lib")
+
+set(CMAKE_C_COMPILER clang)
+set(CMAKE_CXX_COMPILER clang++)
+set(CMAKE_LINKER ld.lld)
+set(CMAKE_C_LINK_EXECUTABLE "<CMAKE_LINKER> <CMAKE_C_LINK_FLAGS> <OBJECTS> -o <TARGET> -lc -lkernel -lSceUserService  -lSceSysmodule -lSceNet $OO_PS4_TOOLCHAIN/lib/crt1.o <LINK_LIBRARIES>")
+set(CMAKE_CXX_LINK_EXECUTABLE "<CMAKE_LINKER> <CMAKE_CXX_LINK_FLAGS> <OBJECTS> -o <TARGET> -lc -lkernel -lc++ -lSceUserService -lSceSysmodule -lSceNet $OO_PS4_TOOLCHAIN/lib/crt1.o <LINK_LIBRARIES>")
+
+set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)
+
+# TODO: Why does cmake not set this?
+set(CMAKE_SIZEOF_VOID_P 8)
+EOF
+
+# Normally a platform has a package manager
+# PS4 does not, atleast not in the normal sense
+export EXTRA_CMAKE_FLAGS=("${EXTRA_CMAKE_FLAGS[@]}" $@)
+cmake -S . -B build -G "Unix Makefiles" \
+    -DCMAKE_TOOLCHAIN_FILE="ps4-toolchain.cmake" \
+    -DENABLE_QT_TRANSLATION=OFF \
+    -DENABLE_CUBEB=OFF \
+    -DCMAKE_BUILD_TYPE=Release \
+    -DCMAKE_CXX_FLAGS="$ARCH_FLAGS" \
+    -DCMAKE_C_FLAGS="$ARCH_FLAGS" \
+    -DENABLE_SDL2=ON \
+    -DENABLE_LIBUSB=OFF \
+    -DENABLE_UPDATE_CHECKER=OFF \
+    -DENABLE_QT=OFF \
+    -DENABLE_OPENSSL=OFF \
+    -DENABLE_WEB_SERVICE=OFF \
+    -DUSE_DISCORD_PRESENCE=OFF \
+    -DCPMUTIL_FORCE_BUNDLED=ON \
+    -DYUZU_USE_EXTERNAL_FFMPEG=ON \
+    -DYUZU_USE_CPM=ON \
+    "${EXTRA_CMAKE_FLAGS[@]}" || exit
+cmake --build build -t yuzu-cmd_pkg -- -j8
--- a/.ci/ps4/make-toolchain.sh
+++ b/.ci/ps4/make-toolchain.sh
@@ -0,0 +1,176 @@
+#!/usr/local/bin/bash -ex
+
+# SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+# Define global vars
+# These flags are used everywhere, so let's reuse them.
+export OO_PS4_TOOLCHAIN="$PWD/prefix"
+export PREFIX="$OO_PS4_TOOLCHAIN"
+export CC="clang"
+export CXX="clang++"
+export AR="llvm-ar"
+export CFLAGS="-fPIC -DPS4 -D_LIBUNWIND_IS_BAREMETAL=1"
+export CXXFLAGS="$CFLAGS -D__STDC_VERSION__=0"
+export TARGET="x86_64-scei-ps4"
+export LLVM_ROOT="$PWD/llvm-project"
+export LLVM_PATH="$PWD/llvm-project/llvm"
+export WORK_PATH="$PWD"
+
+prepare_prefix() {
+    [ -d OpenOrbis-PS4-Toolchain ] || git clone --depth=1 https://github.com/OpenOrbis/OpenOrbis-PS4-Toolchain
+    [ -d musl ] || git clone --depth=1 https://github.com/OpenOrbis/musl
+    [ -d llvm-project ] || git clone --depth=1 --branch openorbis/20.x https://github.com/seuros/llvm-project
+    [ -d create-fself ] || git clone --depth=1 https://github.com/OpenOrbis/create-fself
+    [ -d create-gp4 ] || git clone --depth=1 https://github.com/OpenOrbis/create-gp4
+    [ -d readoelf ] || git clone --depth=1 https://github.com/OpenOrbis/readoelf
+    [ -d LibOrbisPkg ] || git clone --depth=1 https://github.com/maxton/LibOrbisPkg
+
+    mkdir -p $PREFIX "$PREFIX/bin" "$PREFIX/include"
+    [ -f "$PREFIX/include/orbis/libkernel.h" ] || cp -r OpenOrbis-PS4-Toolchain/include/* "$PREFIX/include/"
+    mkdir -p $PREFIX/usr
+    [ -L "$PREFIX/usr/include" ] || ln -s $PREFIX/include $PREFIX/usr/include || echo 1
+    [ -L "$PREFIX/usr/share" ] || ln -s $PREFIX/share $PREFIX/usr/share || echo 1
+    [ -L "$PREFIX/usr/lib" ] || ln -s $PREFIX/lib $PREFIX/usr/lib || echo 1
+    [ -L "$PREFIX/usr/bin" ] || ln -s $PREFIX/bin $PREFIX/usr/bin || echo 1
+}
+
+build_musl() {
+    mkdir -p musl-build
+    cd musl-build
+    ../musl/configure --target=$TARGET --disable-shared CC="$CC" CFLAGS="$CFLAGS" --prefix=$PREFIX
+    gmake -j8 && gmake install
+    cd ..
+}
+
+build_llvm() {
+    # Build compiler-rt
+    cmake "$LLVM_ROOT/compiler-rt" -B "$WORK_PATH/llvm-build/compiler-rt" \
+        -DCMAKE_INSTALL_PREFIX="$PREFIX" \
+        -DCMAKE_C_COMPILER="$CC" -DCMAKE_CXX_COMPILER="$CXX" \
+        -DCMAKE_C_FLAGS="$CFLAGS" -DCMAKE_CXX_FLAGS="$CXXFLAGS" \
+        -DCMAKE_ASM_COMPILER="$CC" -DCMAKE_ASM_FLAGS="$CFLAGS -x assembler-with-cpp" \
+        -DLLVM_PATH="$LLVM_PATH" -DCOMPILER_RT_DEFAULT_TARGET_TRIPLE="$TARGET" \
+        -DCOMPILER_RT_BAREMETAL_BUILD=YES -DCOMPILER_RT_BUILD_BUILTINS=ON \
+        -DCOMPILER_RT_BUILD_CRT=OFF -DCOMPILER_RT_BUILD_SANITIZERS=OFF \
+        -DCOMPILER_RT_BUILD_XRAY=OFF -DCOMPILER_RT_BUILD_LIBFUZZER=OFF \
+        -DCOMPILER_RT_BUILD_PROFILE=OFF -DCOMPILER_RT_STANDALONE_BUILD=ON
+    # Build libunwind
+    cmake "$LLVM_ROOT/libunwind" -B "$WORK_PATH/llvm-build/libunwind" \
+        -DCMAKE_INSTALL_PREFIX="$PREFIX" \
+        -DCMAKE_C_COMPILER="$CC" -DCMAKE_CXX_COMPILER="$CXX" \
+        -DCMAKE_C_FLAGS="$CFLAGS -fcxx-exceptions" -DCMAKE_CXX_FLAGS="$CXXFLAGS -fcxx-exceptions" \
+        -DCMAKE_ASM_COMPILER="$CC" -DCMAKE_ASM_FLAGS="$CFLAGS -x assembler-with-cpp" \
+        -DLLVM_PATH="$LLVM_PATH" -DLIBUNWIND_USE_COMPILER_RT=YES \
+        -DLIBUNWIND_BUILD_32_BITS=NO -DLIBUNWIND_ENABLE_STATIC=ON \
+        -DLIBUNWIND_ENABLE_SHARED=OFF -DLIBUNWIND_IS_BAREMETAL=ON
+    # Build libcxxabi
+    cmake "$LLVM_ROOT/libcxxabi" -B "$WORK_PATH/llvm-build/libcxxabi" \
+        -DCMAKE_INSTALL_PREFIX="$PREFIX" \
+        -DCMAKE_C_COMPILER="$CC" -DCMAKE_CXX_COMPILER="$CXX" \
+        -DCMAKE_C_FLAGS="$CFLAGS -D_GNU_SOURCE=1 -isysroot $PREFIX -isystem $LLVM_ROOT/libcxx/include -isystem $PREFIX/include -isystem $WORK_PATH/llvm-build/libcxx/include/c++/v1" \
+        -DCMAKE_CXX_FLAGS="$CXXFLAGS -D_GNU_SOURCE=1 -isysroot $PREFIX -isystem $LLVM_ROOT/libcxx/include -isystem $PREFIX/include -isystem $WORK_PATH/llvm-build/libcxx/include/c++/v1" \
+        -DCMAKE_ASM_COMPILER="$CC" -DCMAKE_ASM_FLAGS="$CFLAGS -x assembler-with-cpp" \
+        -DLLVM_PATH="$LLVM_PATH" -DLIBCXXABI_ENABLE_SHARED=NO \
+        -DLLVM_ENABLE_RUNTIMES="rt;libunwind" \
+        -DLIBCXXABI_ENABLE_STATIC=YES -DLIBCXXABI_ENABLE_EXCEPTIONS=YES \
+        -DLIBCXXABI_USE_COMPILER_RT=YES -DLIBCXXABI_USE_LLVM_UNWINDER=YES \
+        -DLIBCXXABI_LIBUNWIND_PATH="$LLVM_ROOT/libunwind" \
+        -DLIBCXXABI_LIBCXX_INCLUDES="$LLVM_ROOT/libcxx/include" \
+        -DLIBCXXABI_ENABLE_PIC=YES
+    # Build libcxx
+    cmake "$LLVM_ROOT/libcxx" -B "$WORK_PATH/llvm-build/libcxx" \
+        -DCMAKE_INSTALL_PREFIX="$PREFIX" \
+        -DCMAKE_C_COMPILER="$CC" -DCMAKE_CXX_COMPILER="$CXX" \
+        -DCMAKE_C_FLAGS="$CFLAGS -D_LIBCPP_HAS_MUSL_LIBC=1 -D_GNU_SOURCE=1 -isysroot $PREFIX -isystem $PREFIX/include/c++/v1 -isystem $PREFIX/include" \
+        -DCMAKE_CXX_FLAGS="$CXXFLAGS -D_LIBCPP_HAS_MUSL_LIBC=1 -D_GNU_SOURCE=1 -isysroot $PREFIX -isystem $PREFIX/include/c++/v1 -isystem $PREFIX/include" \
+        -DCMAKE_ASM_COMPILER="$CC" -DCMAKE_ASM_FLAGS="$CFLAGS -x assembler-with-cpp" \
+        -DLLVM_PATH="$LLVM_PATH" -DLIBCXX_ENABLE_RTTI=YES \
+        -DLIBCXX_HAS_MUSL_LIBC=YES -DLIBCXX_ENABLE_SHARED=NO \
+        -DLIBCXX_CXX_ABI=libcxxabi -DLIBCXX_CXX_ABI_INCLUDE_PATHS="$LLVM_ROOT/libcxxabi/include" \
+        -DLIBCXX_CXX_ABI_LIBRARY_PATH="$LLVM_ROOT/libcxxabi/build/lib"
+    
+    cmake --build "$WORK_PATH/llvm-build/compiler-rt" --parallel
+    cmake --install "$WORK_PATH/llvm-build/compiler-rt"
+
+    cmake --build "$WORK_PATH/llvm-build/libunwind" --parallel
+    cmake --install "$WORK_PATH/llvm-build/libunwind"
+
+    cmake --build "$WORK_PATH/llvm-build/libcxxabi" --parallel
+    cmake --install "$WORK_PATH/llvm-build/libcxxabi"
+
+    touch "$WORK_PATH/llvm-build/libcxx/include/c++/v1/libcxx.imp"
+    cmake --build "$WORK_PATH/llvm-build/libcxx" --parallel
+    cmake --install "$WORK_PATH/llvm-build/libcxx"
+}
+
+build_tools() {
+
+    # Build create-fself
+    cd create-fself/cmd/create-fself
+    cp go-linux.mod go.mod
+    go build -ldflags "-linkmode external -extldflags -static" -o create-fself
+    mv ./create-fself $PREFIX/bin/create-fself
+    cd ../../../
+
+    # Build create-gp4
+    cd create-gp4/cmd/create-gp4
+    go build -ldflags "-linkmode external -extldflags -static" -o create-gp4
+    mv ./create-gp4 $PREFIX/bin/create-gp4
+    cd ../../../
+
+    # Build readoelf
+    cd readoelf/cmd/readoelf
+    go build -ldflags "-linkmode external -extldflags -static" -o readoelf
+    mv ./readoelf $PREFIX/bin/readoelf
+    cd ../../../
+
+    # # Pull maxton's publishing tools (<3)
+    # # Sadly maxton has passed on, we have forked the repository and will continue to update it in the future. RIP <3
+    # cd $PREFIX/bin
+    # [ -f PkgTool.Core-linux-x64-0.2.231.zip ] || wget https://github.com/maxton/LibOrbisPkg/releases/download/v0.2/PkgTool.Core-linux-x64-0.2.231.zip
+    # [ -f PkgTool.Core ] || unzip PkgTool.Core-linux-x64-0.2.231.zip
+    # chmod +x PkgTool.Core
+}
+
+finish_prefix() {
+    as $WORK_PATH/OpenOrbis-PS4-Toolchain/src/crt/crtlib.S -o $PREFIX/lib/crtlib.o
+    cp -a $WORK_PATH/OpenOrbis-PS4-Toolchain/link.x $PREFIX/
+
+    cp -a ~/OpenOrbis/PS4Toolchain/lib/libkernel* $PREFIX/lib/
+    cp -a ~/OpenOrbis/PS4Toolchain/lib/libSce* $PREFIX/lib/
+
+    cp -a ~/OpenOrbis/PS4Toolchain/lib/libSDL* $PREFIX/lib/
+    cp -r ~/OpenOrbis/PS4Toolchain/include/SDL2 $PREFIX/include/SDL2
+
+    cp $WORK_PATH/llvm-build/compiler-rt/lib/freebsd/libclang_rt.builtins-x86_64.a $PREFIX/lib/
+
+    # Combine libc++, libc++abi and libunwind into a single archive
+    cat << EOF >"mri.txt"
+CREATE $PREFIX/lib/libc++M.a
+ADDLIB $PREFIX/lib/libunwind.a
+ADDLIB $PREFIX/lib/libc++abi.a
+ADDLIB $PREFIX/lib/libc++.a
+SAVE
+END
+EOF
+    $AR -M < mri.txt
+    cp $PREFIX/lib/libc++M.a $PREFIX/lib/libc++.a
+    # Merge compiler-rt into libc
+    cat << EOF >"mri.txt"
+CREATE $PREFIX/lib/libcM.a
+ADDLIB $PREFIX/lib/libc.a
+ADDLIB $PREFIX/lib/libclang_rt.builtins-x86_64.a
+SAVE
+END
+EOF
+    $AR -M < mri.txt
+    cp $PREFIX/lib/libcM.a $PREFIX/lib/libc.a
+    rm mri.txt
+}
+
+prepare_prefix
+build_musl
+build_llvm
+build_tools
+finish_prefix
--- a/.gitignore
+++ b/.gitignore
@@ -63,3 +63,6 @@ artifacts
 *.AppImage*
 /install*
 vulkansdk*.exe
+
+# PS4 toolchain stuff
+ps4-toolchain.cmake
--- a/.patch/boost/0004-openorbis.patch
+++ b/.patch/boost/0004-openorbis.patch
@@ -0,0 +1,17 @@
+diff --git a/libs/asio/include/boost/asio/detail/impl/socket_ops.ipp b/libs/asio/include/boost/asio/detail/impl/socket_ops.ipp
+index 0129511c..10fc9b04 100644
+--- a/libs/asio/include/boost/asio/detail/impl/socket_ops.ipp
+++ b/libs/asio/include/boost/asio/detail/impl/socket_ops.ipp
+@@ -15,6 +15,12 @@
+ # pragma once
+ #endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
+ 
+// hacky fix for ps4
+#if defined(__OPENORBIS__)
+#  define FIONBIO 0
+#  define FIONREAD 1
+#endif
+
+ #include <boost/asio/detail/config.hpp>
+ 
+ #include <cctype>
--- a/.patch/enet/0001-openorbis.patch
+++ b/.patch/enet/0001-openorbis.patch
@@ -0,0 +1,13 @@
+diff --git a/unix.c b/unix.c
+index 6669216..86a2faa 100644
+--- a/unix.c
+++ b/unix.c
+@@ -53,7 +53,7 @@
+ #include <poll.h>
+ #endif
+ 
+-#if !defined(HAS_SOCKLEN_T) && !defined(__socklen_t_defined)
+#if !defined(__OPENORBIS__) && !defined(HAS_SOCKLEN_T) && !defined(__socklen_t_defined)
+ typedef int socklen_t;
+ #endif
+ 
--- a/.patch/mbedtls/0001-aesni-fix.patch
+++ b/.patch/mbedtls/0001-aesni-fix.patch
@@ -7,7 +7,7 @@ index 754c984c79..59e27afd3e 100644
  * target flag is enabled when building the library (e.g. `gcc -mpclmul -msse2`
  * or `clang -maes -mpclmul`). */
 -#if (defined(__GNUC__) || defined(__clang__)) && defined(__AES__) && defined(__PCLMUL__)
-+#if defined(__GNUC__) || defined(__clang__)
+#if (defined(__GNUC__) || defined(__clang__)) && !defined(_LIBCPP_HAS_MUSL_LIBC)
 #define MBEDTLS_AESNI_HAVE_INTRINSICS
 #endif
 /* For 32-bit, we only support intrinsics */
@@ -25,7 +25,7 @@ index 2857068..3e104ab 100644
 #pragma GCC target ("pclmul,sse2,aes")
 #define MBEDTLS_POP_TARGET_PRAGMA
 -#elif defined(__clang__) && (__clang_major__ >= 5)
-+#elif defined(__clang__)
+#elif defined(__clang__) && !defined(__OPENORBIS__)
 #pragma clang attribute push (__attribute__((target("pclmul,sse2,aes"))), apply_to=function)
 #define MBEDTLS_POP_TARGET_PRAGMA
 #endif
--- a/.patch/mbedtls/0003-openorbis.patch
+++ b/.patch/mbedtls/0003-openorbis.patch
@@ -0,0 +1,13 @@
+diff --git a/library/entropy_poll.c b/library/entropy_poll.c
+index 611768c..8950ee4 100644
+--- a/library/entropy_poll.c
+++ b/library/entropy_poll.c
+@@ -118,7 +118,7 @@ static int getrandom_wrapper(void *buf, size_t buflen, unsigned int flags)
+  *
+  * Documentation: https://netbsd.gw.com/cgi-bin/man-cgi?sysctl+7
+  */
+-#if (defined(__FreeBSD__) || defined(__NetBSD__)) && !defined(HAVE_GETRANDOM)
+#if (defined(__FreeBSD__) || defined(__NetBSD__)) && !defined(HAVE_GETRANDOM) && !defined(__OPENORBIS__)
+ #include <sys/param.h>
+ #include <sys/sysctl.h>
+ #if defined(KERN_ARND)
--- a/.patch/spirv-tools/0002-openorbis.patch
+++ b/.patch/spirv-tools/0002-openorbis.patch
@@ -0,0 +1,25 @@
+diff --git a/source/opt/loop_dependence.cpp b/source/opt/loop_dependence.cpp
+index e41c044..a51b53b 100644
+--- a/source/opt/loop_dependence.cpp
+++ b/source/opt/loop_dependence.cpp
+@@ -12,6 +12,12 @@
+ // See the License for the specific language governing permissions and
+ // limitations under the License.
+ 
+// PS4: issue?
+#ifdef __PS4__
+#pragma clang diagnostic ignored "-Wabsolute-value"
+#pragma clang diagnostic ignored "-Wshorten-64-to-32"
+#endif
+
+ #include "source/opt/loop_dependence.h"
+ 
+ #include <functional>
+@@ -19,6 +25,7 @@
+ #include <string>
+ #include <utility>
+ #include <vector>
+#include <cstdlib>
+ 
+ #include "source/opt/instruction.h"
+ #include "source/opt/scalar_analysis_nodes.h"
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -17,6 +17,7 @@ include(DownloadExternals)
 include(CMakeDependentOption)
 include(CTest)
 include(CPMUtil)
+include(OpenOrbis)

 DetectArchitecture()

--- a/CMakeModules/FindSDL2.cmake
+++ b/CMakeModules/FindSDL2.cmake
@@ -0,0 +1,391 @@
+# SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
+# file Copyright.txt or https://cmake.org/licensing for details.
+
+#  Copyright 2019 Amine Ben Hassouna <amine.benhassouna@gmail.com>
+#  Copyright 2000-2019 Kitware, Inc. and Contributors
+#  All rights reserved.
+
+#  Redistribution and use in source and binary forms, with or without
+#  modification, are permitted provided that the following conditions
+#  are met:
+
+#  * Redistributions of source code must retain the above copyright
+#    notice, this list of conditions and the following disclaimer.
+
+#  * Redistributions in binary form must reproduce the above copyright
+#    notice, this list of conditions and the following disclaimer in the
+#    documentation and/or other materials provided with the distribution.
+
+#  * Neither the name of Kitware, Inc. nor the names of Contributors
+#    may be used to endorse or promote products derived from this
+#    software without specific prior written permission.
+
+#  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+#  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+#  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+#  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+#  HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+#  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+#  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+#  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+#  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+#  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+#  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#[=======================================================================[.rst:
+FindSDL2
+--------
+
+Locate SDL2 library
+
+This module defines the following 'IMPORTED' targets:
+
+::
+
+  SDL2::Core
+    The SDL2 library, if found.
+    Libraries should link to SDL2::Core
+
+  SDL2::Main
+    The SDL2main library, if found.
+    Applications should link to SDL2::Main instead of SDL2::Core
+
+
+
+This module will set the following variables in your project:
+
+::
+
+  SDL2_LIBRARIES, the name of the library to link against
+  SDL2_INCLUDE_DIRS, where to find SDL.h
+  SDL2_FOUND, if false, do not try to link to SDL2
+  SDL2MAIN_FOUND, if false, do not try to link to SDL2main
+  SDL2_VERSION_STRING, human-readable string containing the version of SDL2
+
+
+
+This module responds to the following cache variables:
+
+::
+
+  SDL2_PATH
+    Set a custom SDL2 Library path (default: empty)
+
+  SDL2_NO_DEFAULT_PATH
+    Disable search SDL2 Library in default path.
+      If SDL2_PATH (default: ON)
+      Else (default: OFF)
+
+  SDL2_INCLUDE_DIR
+    SDL2 headers path.
+
+  SDL2_LIBRARY
+    SDL2 Library (.dll, .so, .a, etc) path.
+
+  SDL2MAIN_LIBRAY
+    SDL2main Library (.a) path.
+
+  SDL2_BUILDING_LIBRARY
+    This flag is useful only when linking to SDL2_LIBRARIES insead of
+    SDL2::Main. It is required only when building a library that links to
+    SDL2_LIBRARIES, because only applications need main() (No need to also
+    link to SDL2main).
+    If this flag is defined, then no SDL2main will be added to SDL2_LIBRARIES
+    and no SDL2::Main target will be created.
+
+
+Don't forget to include SDLmain.h and SDLmain.m in your project for the
+OS X framework based version. (Other versions link to -lSDL2main which
+this module will try to find on your behalf.) Also for OS X, this
+module will automatically add the -framework Cocoa on your behalf.
+
+
+Additional Note: If you see an empty SDL2_LIBRARY in your project
+configuration, it means CMake did not find your SDL2 library
+(SDL2.dll, libsdl2.so, SDL2.framework, etc). Set SDL2_LIBRARY to point
+to your SDL2 library, and  configure again. Similarly, if you see an
+empty SDL2MAIN_LIBRARY, you should set this value as appropriate. These
+values are used to generate the final SDL2_LIBRARIES variable and the
+SDL2::Core and SDL2::Main targets, but when these values are unset,
+SDL2_LIBRARIES, SDL2::Core and SDL2::Main does not get created.
+
+
+$SDL2DIR is an environment variable that would correspond to the
+./configure --prefix=$SDL2DIR used in building SDL2.  l.e.galup 9-20-02
+
+
+
+Created by Amine Ben Hassouna:
+  Adapt FindSDL.cmake to SDL2 (FindSDL2.cmake).
+  Add cache variables for more flexibility:
+    SDL2_PATH, SDL2_NO_DEFAULT_PATH (for details, see doc above).
+  Mark 'Threads' as a required dependency for non-OSX systems.
+  Modernize the FindSDL2.cmake module by creating specific targets:
+    SDL2::Core and SDL2::Main (for details, see doc above).
+
+
+Original FindSDL.cmake module:
+  Modified by Eric Wing.  Added code to assist with automated building
+  by using environmental variables and providing a more
+  controlled/consistent search behavior.  Added new modifications to
+  recognize OS X frameworks and additional Unix paths (FreeBSD, etc).
+  Also corrected the header search path to follow "proper" SDL
+  guidelines.  Added a search for SDLmain which is needed by some
+  platforms.  Added a search for threads which is needed by some
+  platforms.  Added needed compile switches for MinGW.
+
+On OSX, this will prefer the Framework version (if found) over others.
+People will have to manually change the cache value of SDL2_LIBRARY to
+override this selection or set the SDL2_PATH variable or the CMake
+environment CMAKE_INCLUDE_PATH to modify the search paths.
+
+Note that the header path has changed from SDL/SDL.h to just SDL.h
+This needed to change because "proper" SDL convention is #include
+"SDL.h", not <SDL/SDL.h>.  This is done for portability reasons
+because not all systems place things in SDL/ (see FreeBSD).
+#]=======================================================================]
+
+# Define options for searching SDL2 Library in a custom path
+
+set(SDL2_PATH "" CACHE STRING "Custom SDL2 Library path")
+
+set(_SDL2_NO_DEFAULT_PATH OFF)
+if(SDL2_PATH)
+  set(_SDL2_NO_DEFAULT_PATH ON)
+endif()
+
+set(SDL2_NO_DEFAULT_PATH ${_SDL2_NO_DEFAULT_PATH}
+    CACHE BOOL "Disable search SDL2 Library in default path")
+unset(_SDL2_NO_DEFAULT_PATH)
+
+set(SDL2_NO_DEFAULT_PATH_CMD)
+if(SDL2_NO_DEFAULT_PATH)
+  set(SDL2_NO_DEFAULT_PATH_CMD NO_DEFAULT_PATH)
+endif()
+
+# Search for the SDL2 include directory
+find_path(SDL2_INCLUDE_DIR SDL.h
+  HINTS
+    ENV SDL2DIR
+    ${SDL2_NO_DEFAULT_PATH_CMD}
+  PATH_SUFFIXES SDL2
+                # path suffixes to search inside ENV{SDL2DIR}
+                include/SDL2 include
+  PATHS ${SDL2_PATH}
+  DOC "Where the SDL2 headers can be found"
+)
+
+set(SDL2_INCLUDE_DIRS "${SDL2_INCLUDE_DIR}")
+
+if(CMAKE_SIZEOF_VOID_P EQUAL 8)
+  set(VC_LIB_PATH_SUFFIX lib/x64)
+else()
+  set(VC_LIB_PATH_SUFFIX lib/x86)
+endif()
+
+# SDL-2.0 is the name used by FreeBSD ports...
+# don't confuse it for the version number.
+find_library(SDL2_LIBRARY
+  NAMES SDL2 SDL-2.0
+  HINTS
+    ENV SDL2DIR
+    ${SDL2_NO_DEFAULT_PATH_CMD}
+  PATH_SUFFIXES lib ${VC_LIB_PATH_SUFFIX}
+  PATHS ${SDL2_PATH}
+  DOC "Where the SDL2 Library can be found"
+)
+
+set(SDL2_LIBRARIES "${SDL2_LIBRARY}")
+
+if(NOT SDL2_BUILDING_LIBRARY)
+  if(NOT SDL2_INCLUDE_DIR MATCHES ".framework")
+    # Non-OS X framework versions expect you to also dynamically link to
+    # SDL2main. This is mainly for Windows and OS X. Other (Unix) platforms
+    # seem to provide SDL2main for compatibility even though they don't
+    # necessarily need it.
+
+    if(SDL2_PATH)
+      set(SDL2MAIN_LIBRARY_PATHS "${SDL2_PATH}")
+    endif()
+
+    if(NOT SDL2_NO_DEFAULT_PATH)
+      set(SDL2MAIN_LIBRARY_PATHS
+            /sw
+            /opt/local
+            /opt/csw
+            /opt
+            "${SDL2MAIN_LIBRARY_PATHS}"
+      )
+    endif()
+
+    find_library(SDL2MAIN_LIBRARY
+      NAMES SDL2main
+      HINTS
+        ENV SDL2DIR
+        ${SDL2_NO_DEFAULT_PATH_CMD}
+      PATH_SUFFIXES lib ${VC_LIB_PATH_SUFFIX}
+      PATHS ${SDL2MAIN_LIBRARY_PATHS}
+      DOC "Where the SDL2main library can be found"
+    )
+    unset(SDL2MAIN_LIBRARY_PATHS)
+  endif()
+endif()
+
+# SDL2 may require threads on your system.
+# The Apple build may not need an explicit flag because one of the
+# frameworks may already provide it.
+# But for non-OSX systems, I will use the CMake Threads package.
+if(NOT APPLE)
+  find_package(Threads QUIET)
+  if(NOT Threads_FOUND)
+    set(SDL2_THREADS_NOT_FOUND "Could NOT find Threads (Threads is required by SDL2).")
+    if(SDL2_FIND_REQUIRED)
+      message(FATAL_ERROR ${SDL2_THREADS_NOT_FOUND})
+    else()
+        if(NOT SDL2_FIND_QUIETLY)
+          message(STATUS ${SDL2_THREADS_NOT_FOUND})
+        endif()
+      return()
+    endif()
+    unset(SDL2_THREADS_NOT_FOUND)
+  endif()
+endif()
+
+# MinGW needs an additional link flag, -mwindows
+# It's total link flags should look like -lmingw32 -lSDL2main -lSDL2 -mwindows
+if(MINGW)
+  set(MINGW32_LIBRARY mingw32 "-mwindows" CACHE STRING "link flags for MinGW")
+endif()
+
+if(SDL2_LIBRARY)
+  # For SDL2main
+  if(SDL2MAIN_LIBRARY AND NOT SDL2_BUILDING_LIBRARY)
+    list(FIND SDL2_LIBRARIES "${SDL2MAIN_LIBRARY}" _SDL2_MAIN_INDEX)
+    if(_SDL2_MAIN_INDEX EQUAL -1)
+      set(SDL2_LIBRARIES "${SDL2MAIN_LIBRARY}" ${SDL2_LIBRARIES})
+    endif()
+    unset(_SDL2_MAIN_INDEX)
+  endif()
+
+  # For OS X, SDL2 uses Cocoa as a backend so it must link to Cocoa.
+  # CMake doesn't display the -framework Cocoa string in the UI even
+  # though it actually is there if I modify a pre-used variable.
+  # I think it has something to do with the CACHE STRING.
+  # So I use a temporary variable until the end so I can set the
+  # "real" variable in one-shot.
+  if(APPLE)
+    set(SDL2_LIBRARIES ${SDL2_LIBRARIES} -framework Cocoa)
+  endif()
+
+  # For threads, as mentioned Apple doesn't need this.
+  # In fact, there seems to be a problem if I used the Threads package
+  # and try using this line, so I'm just skipping it entirely for OS X.
+  if(NOT APPLE)
+    set(SDL2_LIBRARIES ${SDL2_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT})
+  endif()
+
+  # For MinGW library
+  if(MINGW)
+    set(SDL2_LIBRARIES ${MINGW32_LIBRARY} ${SDL2_LIBRARIES})
+  endif()
+
+endif()
+
+# Read SDL2 version
+if(SDL2_INCLUDE_DIR AND EXISTS "${SDL2_INCLUDE_DIR}/SDL_version.h")
+  file(STRINGS "${SDL2_INCLUDE_DIR}/SDL_version.h" SDL2_VERSION_MAJOR_LINE REGEX "^#define[ \t]+SDL_MAJOR_VERSION[ \t]+[0-9]+$")
+  file(STRINGS "${SDL2_INCLUDE_DIR}/SDL_version.h" SDL2_VERSION_MINOR_LINE REGEX "^#define[ \t]+SDL_MINOR_VERSION[ \t]+[0-9]+$")
+  file(STRINGS "${SDL2_INCLUDE_DIR}/SDL_version.h" SDL2_VERSION_PATCH_LINE REGEX "^#define[ \t]+SDL_PATCHLEVEL[ \t]+[0-9]+$")
+  string(REGEX REPLACE "^#define[ \t]+SDL_MAJOR_VERSION[ \t]+([0-9]+)$" "\\1" SDL2_VERSION_MAJOR "${SDL2_VERSION_MAJOR_LINE}")
+  string(REGEX REPLACE "^#define[ \t]+SDL_MINOR_VERSION[ \t]+([0-9]+)$" "\\1" SDL2_VERSION_MINOR "${SDL2_VERSION_MINOR_LINE}")
+  string(REGEX REPLACE "^#define[ \t]+SDL_PATCHLEVEL[ \t]+([0-9]+)$" "\\1" SDL2_VERSION_PATCH "${SDL2_VERSION_PATCH_LINE}")
+  set(SDL2_VERSION_STRING ${SDL2_VERSION_MAJOR}.${SDL2_VERSION_MINOR}.${SDL2_VERSION_PATCH})
+  unset(SDL2_VERSION_MAJOR_LINE)
+  unset(SDL2_VERSION_MINOR_LINE)
+  unset(SDL2_VERSION_PATCH_LINE)
+  unset(SDL2_VERSION_MAJOR)
+  unset(SDL2_VERSION_MINOR)
+  unset(SDL2_VERSION_PATCH)
+endif()
+
+include(FindPackageHandleStandardArgs)
+
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(SDL2
+                                  REQUIRED_VARS SDL2_LIBRARY SDL2_INCLUDE_DIR
+                                  VERSION_VAR SDL2_VERSION_STRING)
+
+if(SDL2MAIN_LIBRARY)
+  FIND_PACKAGE_HANDLE_STANDARD_ARGS(SDL2main
+                                    REQUIRED_VARS SDL2MAIN_LIBRARY SDL2_INCLUDE_DIR
+                                    VERSION_VAR SDL2_VERSION_STRING)
+endif()
+
+
+mark_as_advanced(SDL2_PATH
+                 SDL2_NO_DEFAULT_PATH
+                 SDL2_LIBRARY
+                 SDL2MAIN_LIBRARY
+                 SDL2_INCLUDE_DIR
+                 SDL2_BUILDING_LIBRARY)
+
+
+# SDL2:: targets (SDL2::Core and SDL2::Main)
+if(SDL2_FOUND)
+
+  # SDL2::Core target
+  if(SDL2_LIBRARY AND NOT TARGET SDL2::Core)
+    add_library(SDL2::Core UNKNOWN IMPORTED)
+    set_target_properties(SDL2::Core PROPERTIES
+                          IMPORTED_LOCATION "${SDL2_LIBRARY}"
+                          INTERFACE_INCLUDE_DIRECTORIES "${SDL2_INCLUDE_DIR}")
+
+    if(APPLE)
+      # For OS X, SDL2 uses Cocoa as a backend so it must link to Cocoa.
+      # For more details, please see above.
+      set_property(TARGET SDL2::Core APPEND PROPERTY
+                   INTERFACE_LINK_OPTIONS -framework Cocoa)
+    else()
+      # For threads, as mentioned Apple doesn't need this.
+      # For more details, please see above.
+      set_property(TARGET SDL2::Core APPEND PROPERTY
+                   INTERFACE_LINK_LIBRARIES Threads::Threads)
+    endif()
+  endif()
+
+  # SDL2::Main target
+  # Applications should link to SDL2::Main instead of SDL2::Core
+  # For more details, please see above.
+  if(NOT SDL2_BUILDING_LIBRARY AND NOT TARGET SDL2::Main)
+
+    if(SDL2_INCLUDE_DIR MATCHES ".framework" OR NOT SDL2MAIN_LIBRARY)
+      add_library(SDL2::Main INTERFACE IMPORTED)
+      set_property(TARGET SDL2::Main PROPERTY
+                   INTERFACE_LINK_LIBRARIES SDL2::Core)
+    elseif(SDL2MAIN_LIBRARY)
+      # MinGW requires that the mingw32 library is specified before the
+      # libSDL2main.a static library when linking.
+      # The SDL2::MainInternal target is used internally to make sure that
+      # CMake respects this condition.
+      add_library(SDL2::MainInternal UNKNOWN IMPORTED)
+      set_property(TARGET SDL2::MainInternal PROPERTY
+                   IMPORTED_LOCATION "${SDL2MAIN_LIBRARY}")
+      set_property(TARGET SDL2::MainInternal PROPERTY
+                   INTERFACE_LINK_LIBRARIES SDL2::Core)
+
+      add_library(SDL2::Main INTERFACE IMPORTED)
+
+      if(MINGW)
+        # MinGW needs an additional link flag '-mwindows' and link to mingw32
+        set_property(TARGET SDL2::Main PROPERTY
+                     INTERFACE_LINK_LIBRARIES "mingw32" "-mwindows")
+      endif()
+
+      set_property(TARGET SDL2::Main APPEND PROPERTY
+                   INTERFACE_LINK_LIBRARIES SDL2::MainInternal)
+    endif()
+
+  endif()
+endif()
--- a/CMakeModules/GenerateSCMRev.cmake
+++ b/CMakeModules/GenerateSCMRev.cmake
@@ -18,10 +18,13 @@ if (DEFINED GIT_RELEASE)
  set(BUILD_VERSION "${GIT_TAG}")
  set(GIT_REFSPEC "${GIT_RELEASE}")
  set(IS_DEV_BUILD false)
-else()
+elseif(DEFINED GIT_COMMIT)
  string(SUBSTRING ${GIT_COMMIT} 0 10 BUILD_VERSION)
  set(BUILD_VERSION "${BUILD_VERSION}-${GIT_REFSPEC}")
  set(IS_DEV_BUILD true)
+else()
+  set(BUILD_VERSION "NoGitInfo")
+  set(IS_DEV_BUILD true)
 endif()

 set(GIT_DESC ${BUILD_VERSION})
--- a/CMakeModules/OpenOrbis.cmake
+++ b/CMakeModules/OpenOrbis.cmake
@@ -0,0 +1,33 @@
+# SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+function(create_ps4_pkg project target content_id)
+    set(sce_sys_dir sce_sys)
+    set(sce_sys_param ${sce_sys_dir}/param.sfo)
+    add_custom_command(
+        OUTPUT "${target}.pkg"
+        COMMAND ${CMAKE_SYSROOT}/bin/create-fself -in=bin/${target} -out=${target}.oelf --eboot eboot.bin
+        COMMAND mkdir -p ${sce_sys_dir}
+        COMMAND ${CMAKE_SYSROOT}/bin/PkgTool.Core sfo_new ${sce_sys_param}
+        COMMAND ${CMAKE_SYSROOT}/bin/PkgTool.Core sfo_setentry ${sce_sys_param} APP_TYPE --type Integer --maxsize 4 --value 1
+        COMMAND ${CMAKE_SYSROOT}/bin/PkgTool.Core sfo_setentry ${sce_sys_param} APP_VER --type Utf8 --maxsize 8 --value 1.03
+        COMMAND ${CMAKE_SYSROOT}/bin/PkgTool.Core sfo_setentry ${sce_sys_param} ATTRIBUTE --type Integer --maxsize 4 --value 0
+        COMMAND ${CMAKE_SYSROOT}/bin/PkgTool.Core sfo_setentry ${sce_sys_param} CATEGORY --type Utf8 --maxsize 4 --value gd
+        COMMAND ${CMAKE_SYSROOT}/bin/PkgTool.Core sfo_setentry ${sce_sys_param} CONTENT_ID --type Utf8 --maxsize 48 --value ${content_id}
+        COMMAND ${CMAKE_SYSROOT}/bin/PkgTool.Core sfo_setentry ${sce_sys_param} DOWNLOAD_DATA_SIZE --type Integer --maxsize 4 --value 0
+        COMMAND ${CMAKE_SYSROOT}/bin/PkgTool.Core sfo_setentry ${sce_sys_param} SYSTEM_VER --type Integer --maxsize 4 --value 0
+        COMMAND ${CMAKE_SYSROOT}/bin/PkgTool.Core sfo_setentry ${sce_sys_param} TITLE --type Utf8 --maxsize 128 --value ${target}
+        COMMAND ${CMAKE_SYSROOT}/bin/PkgTool.Core sfo_setentry ${sce_sys_param} TITLE_ID --type Utf8 --maxsize 12 --value BREW00090
+        COMMAND ${CMAKE_SYSROOT}/bin/PkgTool.Core sfo_setentry ${sce_sys_param} VERSION --type Utf8 --maxsize 8 --value 1.03
+        COMMAND ${CMAKE_SYSROOT}/bin/create-gp4 -out ${target}.gp4 --content-id=${content_id} --files "eboot.bin ${sce_sys_param} sce_module/libc.prx sce_module/libSceFios2.prx"
+        COMMAND ${CMAKE_SYSROOT}/bin/PkgTool.Core pkg_build ${target}.gp4 .
+        VERBATIM
+        WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+        DEPENDS ${project}
+    )
+    add_custom_target(${project}_pkg ALL DEPENDS "${target}.pkg")
+endfunction()
+
+if (NOT DEFINED ENV{OO_PS4_TOOLCHAIN})
+    set(ENV{OO_PS4_TOOLCHAIN} ${CMAKE_SYSROOT})
+endif ()
--- a/cpmfile.json
+++ b/cpmfile.json
@@ -19,7 +19,8 @@
        "patches": [
            "0001-clang-cl.patch",
            "0002-use-marmasm.patch",
-            "0003-armasm-options.patch"
+            "0003-armasm-options.patch",
+            "0004-openorbis.patch"
        ]
    },
    "fmt": {
@@ -96,8 +97,8 @@
        "package": "VVL",
        "repo": "KhronosGroup/Vulkan-ValidationLayers",
        "tag": "vulkan-sdk-%VERSION%",
-        "git_version": "1.4.328.1",
+        "git_version": "1.4.335.0",
        "artifact": "android-binaries-%VERSION%.zip",
-        "hash": "5ec895a453cb7c2f156830b9766953a0c2bd44dea99e6a3dac4160305041ccd3e87534b4ce0bd102392178d2a8eca48411856298f9395e60117cdfe89f72137e"
+        "hash": "48167c4a17736301bd08f9290f41830443e1f18cce8ad867fc6f289b49e18b40e93c9850b377951af82f51b5b6d7313aa6a884fc5df79f5ce3df82696c1c1244"
    }
 }
--- a/docs/Caveats.md
+++ b/docs/Caveats.md
@@ -207,3 +207,10 @@ Install [Qt6 compatibility libraries](github.com/ANightly/qt6windows7) specifica
 The package install may randomly hang at times, in which case it has to be restarted. ALWAYS do a `sudo pkg update` or the chances of it hanging will be close to 90%. If "multiple" installs fail at once, try installing 1 by 1 the packages.

 When CMake invokes certain file syscalls - it may sometimes cause crashes or corruptions on the (kernel?) address space - so reboot the system if there is a "hang" in CMake.
+
+## PlayStation 4 (OpenOrbis cross compile)
+
+```sh
+export OO_PS4_TOOLCHAIN="$HOME/OpenOrbis/PS4Toolchain"
+export DOTNET_SYSTEM_GLOBALIZATION_INVARIANT=1
+```
--- a/docs/user/Basics.md
+++ b/docs/user/Basics.md
@@ -26,6 +26,7 @@ Eden will store configuration files in the following directories:
 - **Android**: Data is stored internally.
 - **Linux, macOS, FreeBSD, Solaris, OpenBSD**: `$XDG_DATA_HOME`, `$XDG_CACHE_HOME`, `$XDG_CONFIG_HOME`.
 - **HaikuOS**: `/boot/home/config/settings/eden`
+- **PlayStation 4**: `/data/eden`

 If a `user` directory is present in the current working directory, that will override all global configuration directories and the emulator will use that instead.

--- a/externals/CMakeLists.txt
+++ b/externals/CMakeLists.txt
@@ -147,7 +147,11 @@ if (ENABLE_SDL2)
        AddJsonPackage(sdl2)
    endif()

-    find_package(SDL2 2.26.4 REQUIRED)
+    if (PLATFORM_PS4)
+        set(SDL2_LIBRARY ${CMAKE_SYSROOT}/lib/libSDL2.a)
+        set(SDL2_INCLUDE_DIR ${CMAKE_SYSROOT}/include/SDL2)
+    endif()
+    find_package(SDL2 REQUIRED)
 endif()

 set(BUILD_SHARED_LIBS OFF)
--- a/externals/cmake-modules/DetectPlatform.cmake
+++ b/externals/cmake-modules/DetectPlatform.cmake
@@ -17,6 +17,8 @@

 if (${CMAKE_SYSTEM_NAME} STREQUAL "SunOS")
    set(PLATFORM_SUN ON)
+elseif (${CMAKE_SYSTEM_NAME} STREQUAL "OpenOrbis")
+    set(PLATFORM_PS4 ON)
 elseif (${CMAKE_SYSTEM_NAME} STREQUAL "FreeBSD")
    set(PLATFORM_FREEBSD ON)
 elseif (${CMAKE_SYSTEM_NAME} STREQUAL "OpenBSD")
--- a/externals/cpmfile.json
+++ b/externals/cpmfile.json
@@ -104,7 +104,8 @@
        "skip_updates": true,
        "patches": [
            "0001-aesni-fix.patch",
-            "0002-arm64-aes-fix.patch"
+            "0002-arm64-aes-fix.patch",
+            "0003-openorbis.patch"
        ]
    },
    "enet": {
@@ -113,16 +114,19 @@
        "hash": "a0d2fa8c957704dd49e00a726284ac5ca034b50b00d2b20a94fa1bbfbb80841467834bfdc84aa0ed0d6aab894608fd6c86c3b94eee46343f0e6d9c22e391dbf9",
        "version": "1.3",
        "git_version": "1.3.18",
-        "find_args": "MODULE"
+        "find_args": "MODULE",
+        "patches": [
+            "0001-openorbis.patch"
+        ]
    },
    "vulkan-utility-headers": {
        "package": "VulkanUtilityLibraries",
        "repo": "scripts/VulkanUtilityHeaders",
        "tag": "%VERSION%",
-        "git_version": "1.4.328",
+        "git_version": "1.4.335",
        "artifact": "VulkanUtilityHeaders.tar.zst",
        "git_host": "git.crueter.xyz",
-        "hash": "9922217b39faf73cd4fc1510f2fdba14a49aa5c0d77f9ee24ee0512cef16b234d0cabc83c1fec861fa5df1d43e7f086ca9b6501753899119f39c5ca530cb0dae"
+        "hash": "16dac0e6586702580c4279e4cd37ffe3cf909c93eb31b5069da7af36436d47b270a9cbaac953bb66c22ed12ed67ffa096688599267f307dfb62be1bc09f79833"
    },
    "spirv-tools": {
        "package": "SPIRV-Tools",
@@ -134,7 +138,8 @@
            "SPIRV_SKIP_EXECUTABLES ON"
        ],
        "patches": [
-            "0001-netbsd-fix.patch"
+            "0001-netbsd-fix.patch",
+            "0002-openorbis.patch"
        ]
    },
    "spirv-headers": {
--- a/externals/ffmpeg/CMakeLists.txt
+++ b/externals/ffmpeg/CMakeLists.txt
@@ -13,63 +13,106 @@ set(FFmpeg_HWACCEL_FLAGS)
 set(FFmpeg_HWACCEL_INCLUDE_DIRS)
 set(FFmpeg_HWACCEL_LDFLAGS)

-if (UNIX AND NOT ANDROID)
-    find_package(PkgConfig REQUIRED)
-    if (NOT ANDROID)
-        pkg_check_modules(LIBVA libva)
-        pkg_check_modules(CUDA cuda)
-        pkg_check_modules(FFNVCODEC ffnvcodec)
-        pkg_check_modules(VDPAU vdpau)
+if (NOT YUZU_USE_BUNDLED_FFMPEG)
+    set(FFmpeg_CROSS_COMPILE_FLAGS "")
+    if (ANDROID)
+        # TODO: Maybe use CMAKE_SYSROOT? and probably provide a toolchain file for android
+        # I mean isn't that the "proper" way anyways?
+        string(TOLOWER "${CMAKE_HOST_SYSTEM_NAME}" FFmpeg_HOST_SYSTEM_NAME)
+        set(TOOLCHAIN "${ANDROID_NDK}/toolchains/llvm/prebuilt/${FFmpeg_HOST_SYSTEM_NAME}-${CMAKE_HOST_SYSTEM_PROCESSOR}")
+        set(SYSROOT "${TOOLCHAIN}/sysroot")
+        set(FFmpeg_CPU "armv8-a")
+        list(APPEND FFmpeg_CROSS_COMPILE_FLAGS
+            --enable-cross-compile
+            --arch=arm64
+            #--cpu=${FFmpeg_CPU}
+            --cross-prefix="${TOOLCHAIN}/bin/aarch64-linux-android-"
+            --sysroot="${SYSROOT}"
+            --target-os=android
+            --extra-ldflags="--ld-path=${TOOLCHAIN}/bin/ld.lld"
+            --extra-ldflags="-nostdlib"
+        )
+        set(FFmpeg_IS_CROSS_COMPILING TRUE)
+    # User attempts to do a FFmpeg cross compilation because...
+    # Here we just quickly test against host/system processors not matching
+    # TODO: Test for versions not matching as well?
+    elseif (NOT (CMAKE_HOST_SYSTEM_PROCESSOR MATCHES CMAKE_SYSTEM_PROCESSOR
+    AND CMAKE_HOST_SYSTEM_NAME MATCHES CMAKE_SYSTEM_NAME))
+        string(TOLOWER "${CMAKE_SYSTEM_NAME}" FFmpeg_SYSTEM_NAME)
+        if (FFmpeg_SYSTEM_NAME STREQUAL "openorbis")
+            set(FFmpeg_SYSTEM_NAME "freebsd") # Emulates FBSD :)
+        endif()
+        # TODO: Can we really do better? Auto-detection? Something clever?
+        list(APPEND FFmpeg_CROSS_COMPILE_FLAGS
+            --enable-cross-compile
+            --arch="${CMAKE_SYSTEM_PROCESSOR}"
+            --target-os="${FFmpeg_SYSTEM_NAME}"
+            --sysroot="${CMAKE_SYSROOT}"
+        )
+        if (DEFINED FFmpeg_CROSS_PREFIX)
+            list(APPEND FFmpeg_CROSS_COMPILE_FLAGS --cross-prefix="${FFmpeg_CROSS_PREFIX}")
+        else()
+            message(WARNING "Please set FFmpeg_CROSS_PREFIX to your cross toolchain prefix, for example: \${CMAKE_STAGING_PREFIX}/bin/${CMAKE_SYSTEM_PROCESSOR}-${CMAKE_SYSTEM_NAME}-")
+        endif()
+        set(FFmpeg_IS_CROSS_COMPILING TRUE)
    endif()
+endif()

-    if (NOT APPLE)
-        # In Solaris needs explicit linking for ffmpeg which links to /lib/amd64/libX11.so
-        if(PLATFORM_SUN)
-            find_library(LIBDRM_LIB libdrm PATHS /usr/lib/64 /usr/lib/amd64 /usr/lib)
-            if(LIBDRM_LIB)
+if (PLATFORM_PS4)
+    list(APPEND FFmpeg_HWACCEL_FLAGS
+        --disable-vaapi
+    )
+elseif (UNIX AND NOT DEFINED FFmpeg_IS_CROSS_COMPILING)
+    find_package(PkgConfig REQUIRED)
+    pkg_check_modules(LIBVA libva)
+    pkg_check_modules(CUDA cuda)
+    pkg_check_modules(FFNVCODEC ffnvcodec)
+    pkg_check_modules(VDPAU vdpau)
+
+    find_package(X11)
+    if(X11_FOUND)
+        if (NOT APPLE)
+            # In Solaris needs explicit linking for ffmpeg which links to /lib/amd64/libX11.so
+            if(PLATFORM_SUN)
                list(APPEND FFmpeg_HWACCEL_LIBRARIES
                    X11
-                    "${LIBDRM_LIB}")
-                message(STATUS "Found libdrm at: ${LIBDRM_LIB}")
+                    "${CMAKE_SYSROOT}/usr/lib/xorg/amd64/libdrm.so")
            else()
-                message(WARNING "libdrm not found, disabling libdrm support")
-                list(APPEND FFmpeg_HWACCEL_FLAGS
-                    --disable-libdrm)
+                pkg_check_modules(LIBDRM libdrm REQUIRED)
+                list(APPEND FFmpeg_HWACCEL_LIBRARIES
+                    ${LIBDRM_LIBRARIES})
+                list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS
+                    ${LIBDRM_INCLUDE_DIRS})
            endif()
-        else()
-            pkg_check_modules(LIBDRM libdrm REQUIRED)
-            list(APPEND FFmpeg_HWACCEL_LIBRARIES
-                ${LIBDRM_LIBRARIES})
-            list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS
-                ${LIBDRM_INCLUDE_DIRS})
            list(APPEND FFmpeg_HWACCEL_FLAGS
                --enable-libdrm)
        endif()
-    endif()
-
-    if(LIBVA_FOUND)
-        find_package(X11 REQUIRED)
-        pkg_check_modules(LIBVA-DRM libva-drm REQUIRED)
-        pkg_check_modules(LIBVA-X11 libva-x11 REQUIRED)
-        list(APPEND FFmpeg_HWACCEL_LIBRARIES
-            ${X11_LIBRARIES}
-            ${LIBVA-DRM_LIBRARIES}
-            ${LIBVA-X11_LIBRARIES}
-            ${LIBVA_LIBRARIES})
-        list(APPEND FFmpeg_HWACCEL_FLAGS
-            --enable-hwaccel=h264_vaapi
-            --enable-hwaccel=vp8_vaapi
-            --enable-hwaccel=vp9_vaapi)
-        list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS
-            ${X11_INCLUDE_DIRS}
-            ${LIBVA-DRM_INCLUDE_DIRS}
-            ${LIBVA-X11_INCLUDE_DIRS}
-            ${LIBVA_INCLUDE_DIRS}
-        )
-        message(STATUS "ffmpeg: va-api libraries version ${LIBVA_VERSION} found")
+        if(LIBVA_FOUND)
+            pkg_check_modules(LIBVA-DRM libva-drm REQUIRED)
+            pkg_check_modules(LIBVA-X11 libva-x11 REQUIRED)
+            list(APPEND FFmpeg_HWACCEL_LIBRARIES
+                ${X11_LIBRARIES}
+                ${LIBVA-DRM_LIBRARIES}
+                ${LIBVA-X11_LIBRARIES}
+                ${LIBVA_LIBRARIES})
+            list(APPEND FFmpeg_HWACCEL_FLAGS
+                --enable-hwaccel=h264_vaapi
+                --enable-hwaccel=vp8_vaapi
+                --enable-hwaccel=vp9_vaapi)
+            list(APPEND FFmpeg_HWACCEL_INCLUDE_DIRS
+                ${X11_INCLUDE_DIRS}
+                ${LIBVA-DRM_INCLUDE_DIRS}
+                ${LIBVA-X11_INCLUDE_DIRS}
+                ${LIBVA_INCLUDE_DIRS}
+            )
+            message(STATUS "ffmpeg: va-api libraries version ${LIBVA_VERSION} found")
+        else()
+            list(APPEND FFmpeg_HWACCEL_FLAGS --disable-vaapi)
+            message(WARNING "ffmpeg: libva-dev not found, disabling Video Acceleration API (VA-API)...")
+        endif()
    else()
        list(APPEND FFmpeg_HWACCEL_FLAGS --disable-vaapi)
-        message(WARNING "ffmpeg: libva-dev not found, disabling Video Acceleration API (VA-API)...")
+        message(WARNING "ffmpeg: X11 libraries not found, disabling VA-API...")
    endif()

    if (FFNVCODEC_FOUND)
@@ -113,6 +156,23 @@ if (UNIX AND NOT ANDROID)
    endif()
 endif()

+if (PLATFORM_PS4)
+    list(APPEND FFmpeg_CROSS_COMPILE_LIBS
+        -lc
+        -lkernel
+        -lSceUserService
+        -lSceSysmodule
+        -lSceNet
+        -lSceLibcInternal
+    )
+    list(APPEND FFmpeg_CROSS_COMPILE_FLAGS
+        --disable-pthreads
+        --extra-cflags=${CMAKE_SYSROOT}/usr/include
+        --extra-cxxflags=${CMAKE_SYSROOT}/usr/include
+        --extra-libs="${FFmpeg_CROSS_COMPILE_LIBS}"
+    )
+endif()
+
 if (YUZU_USE_BUNDLED_FFMPEG)
    AddJsonPackage(ffmpeg-ci)

@@ -183,24 +243,6 @@ else()

    find_program(BASH_PROGRAM bash REQUIRED)

-    set(FFmpeg_CROSS_COMPILE_FLAGS "")
-    if (ANDROID)
-        string(TOLOWER "${CMAKE_HOST_SYSTEM_NAME}" FFmpeg_HOST_SYSTEM_NAME)
-        set(TOOLCHAIN "${ANDROID_NDK}/toolchains/llvm/prebuilt/${FFmpeg_HOST_SYSTEM_NAME}-${CMAKE_HOST_SYSTEM_PROCESSOR}")
-        set(SYSROOT "${TOOLCHAIN}/sysroot")
-        set(FFmpeg_CPU "armv8-a")
-        list(APPEND FFmpeg_CROSS_COMPILE_FLAGS
-            --arch=arm64
-            #--cpu=${FFmpeg_CPU}
-            --enable-cross-compile
-            --cross-prefix=${TOOLCHAIN}/bin/aarch64-linux-android-
-            --sysroot=${SYSROOT}
-            --target-os=android
-            --extra-ldflags="--ld-path=${TOOLCHAIN}/bin/ld.lld"
-            --extra-ldflags="-nostdlib"
-        )
-    endif()
-
    # `configure` parameters builds only exactly what yuzu needs from FFmpeg
    # `--disable-vdpau` is needed to avoid linking issues
    set(FFmpeg_CC ${CMAKE_C_COMPILER_LAUNCHER}  ${CMAKE_C_COMPILER})
@@ -217,15 +259,18 @@ else()
                --disable-ffmpeg
                --disable-ffprobe
                --disable-network
-                --disable-postproc
                --disable-swresample
                --enable-decoder=h264
                --enable-decoder=vp8
                --enable-decoder=vp9
                --enable-filter=yadif,scale
                --enable-pic
-                --cc="${FFmpeg_CC}"
-                --cxx="${FFmpeg_CXX}"
+                --cc=${FFmpeg_CC}
+                --cxx=${FFmpeg_CXX}
+                --ld=${CMAKE_LINKER}
+                --extra-cflags=${CMAKE_C_FLAGS}
+                --extra-cxxflags=${CMAKE_CXX_FLAGS}
+                --extra-ldflags=${CMAKE_C_LINK_FLAGS}
                ${FFmpeg_HWACCEL_FLAGS}
                ${FFmpeg_CROSS_COMPILE_FLAGS}
        WORKING_DIRECTORY
@@ -257,7 +302,7 @@ else()
        OUTPUT
            ${FFmpeg_BUILD_LIBRARIES}
        COMMAND
-            make ${FFmpeg_MAKE_ARGS}
+            gmake ${FFmpeg_MAKE_ARGS}
        WORKING_DIRECTORY
            ${FFmpeg_BUILD_DIR}
    )
--- a/src/android/app/build.gradle.kts
+++ b/src/android/app/build.gradle.kts
@@ -18,6 +18,7 @@ plugins {
    id("androidx.navigation.safeargs.kotlin")
    id("org.jlleitschuh.gradle.ktlint") version "11.4.0"
    id("com.github.triplet.play") version "3.8.6"
+    id("idea")
 }

 /**
@@ -27,6 +28,8 @@ plugins {
 */
 val autoVersion = (((System.currentTimeMillis() / 1000) - 1451606400) / 10).toInt()

+val edenDir = project(":Eden").projectDir
+
@Suppress("UnstableApiUsage")
 android {
    namespace = "org.yuzu.yuzu_emu"
@@ -36,7 +39,6 @@ android {

    buildFeatures {
        viewBinding = true
-        buildConfig = true
    }

    compileOptions {
@@ -241,11 +243,17 @@ android {
    externalNativeBuild {
        cmake {
            version = "3.22.1"
-            path = file("../../../CMakeLists.txt")
+            path = file("${edenDir}/CMakeLists.txt")
        }
    }
 }

+idea {
+    module {
+        // Inclusion to exclude build/ dir from non-Android
+        excludeDirs.add(file("${edenDir}/build"))
+    }
+}

 tasks.register<Delete>("ktlintReset", fun Delete.() {
    delete(File(layout.buildDirectory.toString() + File.separator + "intermediates/ktLint"))
@@ -346,7 +354,7 @@ fun getGitVersion(): String {
 }

 afterEvaluate {
-    val artifactsDir = layout.projectDirectory.dir("../../../artifacts")
+    val artifactsDir = layout.projectDirectory.dir("${edenDir}/artifacts")
    val outputsDir = layout.buildDirectory.dir("outputs").get()

    android.applicationVariants.forEach { variant ->
--- a/src/android/gradle.properties
+++ b/src/android/gradle.properties
@@ -14,6 +14,8 @@ android.useAndroidX=true
 # Kotlin code style for this project: "official" or "obsolete":
 kotlin.code.style=official
 kotlin.parallel.tasks.in.project=true
+android.defaults.buildfeatures.buildconfig=true
+
 # Android Gradle plugin 8.0.2
 android.suppressUnsupportedCompileSdk=34
 android.native.buildOutput=verbose
--- a/src/android/settings.gradle.kts
+++ b/src/android/settings.gradle.kts
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later

@@ -19,3 +22,6 @@ dependencyResolutionManagement {
 }

 include(":app")
+
+include("Eden")
+project(":Eden").projectDir = file("../..")
--- a/src/audio_core/CMakeLists.txt
+++ b/src/audio_core/CMakeLists.txt
@@ -251,8 +251,8 @@ if (ENABLE_SDL2)
        sink/sdl2_sink.cpp
        sink/sdl2_sink.h
    )
-
-    target_link_libraries(audio_core PRIVATE SDL2::SDL2)
+    target_include_directories(audio_core PRIVATE ${CMAKE_SYSROOT}/include/SDL2)
+    target_link_libraries(audio_core PRIVATE SDL2)
    target_compile_definitions(audio_core PRIVATE HAVE_SDL2)
 endif()

--- a/src/common/announce_multiplayer_room.h
+++ b/src/common/announce_multiplayer_room.h
@@ -34,8 +34,8 @@ struct Member {
 struct RoomInformation {
    std::string name;          ///< Name of the server
    std::string description;   ///< Server description
-    u32 member_slots;          ///< Maximum number of members in this room
-    u16 port;                  ///< The port of this room
+    u32 member_slots{};        ///< Maximum number of members in this room
+    u16 port{};                ///< The port of this room
    GameInfo preferred_game;   ///< Game to advertise that you want to play
    std::string host_username; ///< Forum username of the host
 };
@@ -46,8 +46,8 @@ struct Room {
    std::string id;
    std::string verify_uid; ///< UID used for verification
    std::string ip;
-    u32 net_version;
-    bool has_password;
+    u32 net_version{};
+    bool has_password = false;

    std::vector<Member> members;
 };
--- a/src/common/fs/fs.cpp
+++ b/src/common/fs/fs.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -171,11 +174,14 @@ bool CreateDir(const fs::path& path) {
        return false;
    }

+    // TODO: Maybe this is what causes death?
+#ifndef __OPENORBIS__
    if (!Exists(path.parent_path())) {
        LOG_ERROR(Common_Filesystem, "Parent directory of path={} does not exist",
                  PathToUTF8String(path));
        return false;
    }
+#endif

    if (IsDir(path)) {
        LOG_DEBUG(Common_Filesystem, "Filesystem object at path={} exists and is a directory",
--- a/src/common/fs/path_util.cpp
+++ b/src/common/fs/path_util.cpp
@@ -130,6 +130,10 @@ public:
        ASSERT(!eden_path.empty());
        eden_path_cache = eden_path / CACHE_DIR;
        eden_path_config = eden_path / CONFIG_DIR;
+#elif defined(__OPENORBIS__)
+        eden_path = "/data/eden";
+        eden_path_cache = eden_path / CACHE_DIR;
+        eden_path_config = eden_path / CONFIG_DIR;
 #else
        eden_path = GetCurrentDir() / PORTABLE_DIR;
        if (!Exists(eden_path) || !IsDir(eden_path)) {
--- a/src/common/host_memory.cpp
+++ b/src/common/host_memory.cpp
@@ -30,19 +30,21 @@
 #include <sys/random.h>
 #include <mach/vm_map.h>
 #include <mach/mach.h>
+#elif defined(__OPENORBIS__)
+#include <orbis/libkernel.h>
 #endif

 // FreeBSD
 #ifndef MAP_NORESERVE
-#define MAP_NORESERVE 0
+#   define MAP_NORESERVE 0
 #endif
 // Solaris 11 and illumos
 #ifndef MAP_ALIGNED_SUPER
-#define MAP_ALIGNED_SUPER 0
+#   define MAP_ALIGNED_SUPER 0
 #endif
 // macOS
 #ifndef MAP_ANONYMOUS
-#define MAP_ANONYMOUS MAP_ANON
+#   define MAP_ANONYMOUS MAP_ANON
 #endif

 #endif // ^^^ POSIX ^^^
@@ -68,8 +70,8 @@ static int memfd_create(const char* name, unsigned int flags) {

 namespace Common {

-constexpr size_t PageAlignment = 0x1000;
-constexpr size_t HugePageSize = 0x200000;
+[[maybe_unused]] constexpr size_t PageAlignment = 0x1000;
+[[maybe_unused]] constexpr size_t HugePageSize = 0x200000;

 #ifdef _WIN32

@@ -438,13 +440,15 @@ static void* ChooseVirtualBase(size_t virtual_size) {

 #else

-static void* ChooseVirtualBase(size_t virtual_size) {
+static void* ChooseVirtualBase(size_t size) {
 #if defined(__FreeBSD__) || defined(__DragonFly__) || defined(__OpenBSD__) || defined(__sun__) || defined(__HAIKU__) || defined(__managarm__) || defined(__AIX__)
-    void* virtual_base = mmap(nullptr, virtual_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE | MAP_ALIGNED_SUPER, -1, 0);
+    void* virtual_base = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE | MAP_ALIGNED_SUPER, -1, 0);
    if (virtual_base != MAP_FAILED)
        return virtual_base;
+    return mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE, -1, 0);
+#else
+    return mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE, -1, 0);
 #endif
-    return mmap(nullptr, virtual_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE, -1, 0);
 }

 #endif
@@ -500,9 +504,12 @@ class HostMemory::Impl {
 public:
    explicit Impl(size_t backing_size_, size_t virtual_size_)
        : backing_size{backing_size_}, virtual_size{virtual_size_} {
+#ifdef __OPENORBIS__
+
+#else
        long page_size = sysconf(_SC_PAGESIZE);
-        ASSERT_MSG(page_size == 0x1000, "page size {:#x} is incompatible with 4K paging",
-                   page_size);
+        ASSERT_MSG(page_size == 0x1000, "page size {:#x} is incompatible with 4K paging", page_size);
+#endif
        // Backing memory initialization
 #if defined(__sun__) || defined(__HAIKU__) || defined(__NetBSD__) || defined(__DragonFly__)
        fd = shm_open_anon(O_RDWR | O_CREAT | O_EXCL | O_NOFOLLOW, 0600);
@@ -578,10 +585,7 @@ public:
 #endif
        int flags = (fd > 0 ? MAP_SHARED : MAP_PRIVATE) | MAP_FIXED;
        void* ret = mmap(virtual_base + virtual_offset, length, prot_flags, flags, fd, host_offset);
-        ASSERT_MSG(ret != MAP_FAILED,
-               "mmap(virt_off=0x{:X}, host_off=0x{:X}, len=0x{:X}, virt_size=0x{:X}, backing_size=0x{:X}, perms=0x{:X}) failed: {}",
-               virtual_offset, host_offset, length, virtual_size, backing_size,
-               static_cast<u32>(perms), strerror(errno));
+        ASSERT_MSG(ret != MAP_FAILED, "mmap: {}", strerror(errno));
    }

    void Unmap(size_t virtual_offset, size_t length) {
@@ -695,31 +699,25 @@ private:

 #endif // ^^^ POSIX ^^^

-HostMemory::HostMemory(size_t backing_size_, size_t virtual_size_)
-    : backing_size(backing_size_), virtual_size(virtual_size_) {
-    try {
-        // Try to allocate a fastmem arena.
-        // The implementation will fail with std::bad_alloc on errors.
-        impl =
-            std::make_unique<HostMemory::Impl>(AlignUp(backing_size, PageAlignment),
-                                               AlignUp(virtual_size, PageAlignment) + HugePageSize);
-        backing_base = impl->backing_base;
-        virtual_base = impl->virtual_base;
-
-        if (virtual_base) {
-            // Ensure the virtual base is aligned to the L2 block size.
-            virtual_base = reinterpret_cast<u8*>(
-                Common::AlignUp(reinterpret_cast<uintptr_t>(virtual_base), HugePageSize));
-            virtual_base_offset = virtual_base - impl->virtual_base;
-        }
-
-    } catch (const std::bad_alloc&) {
-        LOG_CRITICAL(HW_Memory,
-                     "Fastmem unavailable, falling back to VirtualBuffer for memory allocation");
-        fallback_buffer = std::make_unique<Common::VirtualBuffer<u8>>(backing_size);
-        backing_base = fallback_buffer->data();
-        virtual_base = nullptr;
+HostMemory::HostMemory(size_t backing_size_, size_t virtual_size_) : backing_size(backing_size_), virtual_size(virtual_size_) {
+#ifdef __OPENORBIS__
+    Common::InitSwap();
+    LOG_WARNING(HW_Memory, "Platform doesn't support fastmem");
+    fallback_buffer.emplace(backing_size);
+    backing_base = fallback_buffer->data();
+    virtual_base = nullptr;
+#else
+    // Try to allocate a fastmem arena.
+    // The implementation will fail with std::bad_alloc on errors.
+    impl = std::make_unique<HostMemory::Impl>(AlignUp(backing_size, PageAlignment), AlignUp(virtual_size, PageAlignment) + HugePageSize);
+    backing_base = impl->backing_base;
+    virtual_base = impl->virtual_base;
+    if (virtual_base) {
+        // Ensure the virtual base is aligned to the L2 block size.
+        virtual_base = reinterpret_cast<u8*>(Common::AlignUp(uintptr_t(virtual_base), HugePageSize));
+        virtual_base_offset = virtual_base - impl->virtual_base;
    }
+#endif
 }

 HostMemory::~HostMemory() = default;
--- a/src/common/host_memory.h
+++ b/src/common/host_memory.h
@@ -1,9 +1,13 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

 #pragma once

 #include <memory>
+#include <optional>
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/virtual_buffer.h"
@@ -81,7 +85,7 @@ private:
    size_t virtual_base_offset{};

    // Fallback if fastmem is not supported on this platform
-    std::unique_ptr<Common::VirtualBuffer<u8>> fallback_buffer;
+    std::optional<Common::VirtualBuffer<u8>> fallback_buffer;
 };

 } // namespace Common
--- a/src/common/memory_detect.cpp
+++ b/src/common/memory_detect.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -8,7 +11,7 @@
 // clang-format on
 #else
 #include <sys/types.h>
-#if defined(__APPLE__) || defined(__FreeBSD__)
+#if defined(__APPLE__) || (defined(__FreeBSD__) && !defined(__OPENORBIS__))
 #include <sys/sysctl.h>
 #elif defined(__linux__)
 #include <sys/sysinfo.h>
@@ -43,6 +46,8 @@ static MemoryInfo Detect() {
    sysctlbyname("vm.swapusage", &vmusage, &sizeof_vmusage, nullptr, 0);
    mem_info.TotalPhysicalMemory = ramsize;
    mem_info.TotalSwapMemory = vmusage.xsu_total;
+#elif defined(__OPENORBIS__)
+    mem_info.TotalPhysicalMemory = mem_info.TotalSwapMemory = 0;
 #elif defined(__FreeBSD__)
    u_long physmem, swap_total;
    std::size_t sizeof_u_long = sizeof(u_long);
--- a/src/common/settings.h
+++ b/src/common/settings.h
@@ -196,7 +196,14 @@ struct Values {
                                             linkage, false, "dump_audio_commands", Category::Audio, Specialization::Default, false};

    // Core
-    SwitchableSetting<bool> use_multi_core{linkage, true, "use_multi_core", Category::Core};
+    SwitchableSetting<bool> use_multi_core{linkage,
+#ifdef __OPENORBIS__
+        // Re-enable once proper TLS support is added
+        false,
+#else
+        true,
+#endif
+        "use_multi_core", Category::Core};
    SwitchableSetting<MemoryLayout, true> memory_layout_mode{linkage,
                                                             MemoryLayout::Memory_4Gb,
                                                             "memory_layout_mode",
@@ -318,14 +325,14 @@ struct Values {

    // Renderer
    SwitchableSetting<RendererBackend, true> renderer_backend{linkage,
-#if defined(__sun__) || defined(__managarm__)
+#if defined(__sun__) || defined(__managarm__) || defined(__OPENORBIS__)
                                                              RendererBackend::OpenGL,
 #else
                                                              RendererBackend::Vulkan,
 #endif
                                                              "backend", Category::Renderer};
    SwitchableSetting<ShaderBackend, true> shader_backend{linkage,
-#if defined(__sun__) || defined(__managarm__)
+#if defined(__sun__) || defined(__managarm__) || defined(__OPENORBIS__)
                                                          ShaderBackend::Glsl,
 #else
                                                          ShaderBackend::SpirV,
@@ -466,7 +473,7 @@ struct Values {
                                                   true};
    SwitchableSetting<bool> async_presentation{linkage,
 #ifdef ANDROID
-                                               false,
+                                               true,
 #else
                                               false,
 #endif
--- a/src/common/slot_vector.h
+++ b/src/common/slot_vector.h
@@ -130,17 +130,6 @@ public:
        ResetStorageBit(id.index);
    }

-    [[nodiscard]] bool Contains(SlotId id) const noexcept {
-        if (!id) {
-            return false;
-        }
-        const size_t word = id.index / 64;
-        if (word >= stored_bitset.size()) {
-            return false;
-        }
-        return ((stored_bitset[word] >> (id.index % 64)) & 1) != 0;
-    }
-
    [[nodiscard]] Iterator begin() noexcept {
        const auto it = std::ranges::find_if(stored_bitset, [](u64 value) { return value != 0; });
        if (it == stored_bitset.end()) {
--- a/src/common/virtual_buffer.cpp
+++ b/src/common/virtual_buffer.cpp
@@ -10,30 +10,147 @@
 #include <sys/mman.h>
 #endif

+#ifdef __OPENORBIS__
+#include <ranges>
+#include <csignal>
+#include <boost/container/static_vector.hpp>
+#include <orbis/SystemService.h>
+typedef void (*SceKernelExceptionHandler)(int32_t, void*);
+extern "C" int32_t sceKernelInstallExceptionHandler(int32_t signum, SceKernelExceptionHandler handler);
+#endif
+
 #include "common/assert.h"
 #include "common/virtual_buffer.h"
+#include "common/logging/log.h"
+
+// PlayStation 4
+// Flag needs to be undef-ed on non PS4 since it has different semantics
+// on some platforms.
+#ifdef __OPENORBIS__
+#   ifndef MAP_SYSTEM
+#       define MAP_SYSTEM 0x2000
+#   endif
+#   ifndef MAP_VOID
+#       define MAP_VOID 0x100
+#   endif
+// sigaction(2) has a motherfucking bug on musl where the thing isnt even properly prefixed
+#   undef sa_sigaction
+#   define sa_sigaction __sa_handler.__sa_sigaction
+#endif

 namespace Common {

-void* AllocateMemoryPages(std::size_t size) noexcept {
-#ifdef _WIN32
-    void* base = VirtualAlloc(nullptr, size, MEM_COMMIT, PAGE_READWRITE);
-#else
-    void* base = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE, -1, 0);
-    if (base == MAP_FAILED)
-        base = nullptr;
-#endif
-    ASSERT(base);
-    return base;
+#ifdef __OPENORBIS__
+
+namespace Orbis {
+struct Ucontext {
+    struct Sigset {
+        u64 bits[2];
+    } uc_sigmask;
+    int field1_0x10[12];
+    struct Mcontext {
+        u64 mc_onstack;
+        u64 mc_rdi;
+        u64 mc_rsi;
+        u64 mc_rdx;
+        u64 mc_rcx;
+        u64 mc_r8;
+        u64 mc_r9;
+        u64 mc_rax;
+        u64 mc_rbx;
+        u64 mc_rbp;
+        u64 mc_r10;
+        u64 mc_r11;
+        u64 mc_r12;
+        u64 mc_r13;
+        u64 mc_r14;
+        u64 mc_r15;
+        int mc_trapno;
+        u16 mc_fs;
+        u16 mc_gs;
+        u64 mc_addr;
+        int mc_flags;
+        u16 mc_es;
+        u16 mc_ds;
+        u64 mc_err;
+        u64 mc_rip;
+        u64 mc_cs;
+        u64 mc_rflags;
+        u64 mc_rsp;
+        u64 mc_ss;
+        u64 mc_len;
+        u64 mc_fpformat;
+        u64 mc_ownedfp;
+        u64 mc_lbrfrom;
+        u64 mc_lbrto;
+        u64 mc_aux1;
+        u64 mc_aux2;
+        u64 mc_fpstate[104];
+        u64 mc_fsbase;
+        u64 mc_gsbase;
+        u64 mc_spare[6];
+    } uc_mcontext;
+    struct Ucontext* uc_link;
+    struct ExStack {
+        void* ss_sp;
+        std::size_t ss_size;
+        int ss_flags;
+        int _align;
+    } uc_stack;
+    int uc_flags;
+    int __spare[4];
+    int field7_0x4f4[3];
+};
 }

-void FreeMemoryPages(void* base, [[maybe_unused]] std::size_t size) noexcept {
-    if (!base)
+static boost::container::static_vector<std::pair<void*, size_t>, 16> swap_regions;
+extern "C" int sceKernelRemoveExceptionHandler(s32 sig_num);
+static void SwapHandler(int sig, void* raw_context) {
+    auto& mctx = ((Orbis::Ucontext*)raw_context)->uc_mcontext;
+    if (std::ranges::find_if(swap_regions, [addr = mctx.mc_addr](auto const& e) {
+        return uintptr_t(addr) >= uintptr_t(e.first) && uintptr_t(addr) < uintptr_t(e.first) + e.second;
+    }) != swap_regions.end()) {
+        size_t const page_size = 4096;
+        size_t const page_mask = ~0xfff;
+        // should replace the existing mapping... ugh
+        void* aligned_addr = reinterpret_cast<void*>(uintptr_t(mctx.mc_addr) & page_mask);
+        void* res = mmap(aligned_addr, page_size, PROT_READ | PROT_WRITE, MAP_FIXED | MAP_ANON | MAP_PRIVATE, -1, 0);
+        ASSERT(res != MAP_FAILED);
+    } else {
+        LOG_ERROR(HW_Memory, "fault in addr {:#x} at {:#x}", mctx.mc_addr, mctx.mc_rip); // print caller address
+        sceKernelRemoveExceptionHandler(SIGSEGV); // to not catch the next signal
+    }
+}
+void InitSwap() noexcept {
+    sceKernelInstallExceptionHandler(SIGSEGV, &SwapHandler);
+}
+#else
+void InitSwap() noexcept {}
+#endif
+
+void* AllocateMemoryPages(std::size_t size) noexcept {
+#ifdef _WIN32
+    void* addr = VirtualAlloc(nullptr, size, MEM_COMMIT, PAGE_READWRITE);
+    ASSERT(addr != nullptr);
+#elif defined(__OPENORBIS__)
+    void* addr = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_VOID | MAP_PRIVATE, -1, 0);
+    ASSERT(addr != MAP_FAILED);
+    swap_regions.emplace_back(addr, size);
+#else
+    void* addr = mmap(nullptr, size, PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE, -1, 0);
+    ASSERT(addr != MAP_FAILED);
+#endif
+    return addr;
+}
+
+void FreeMemoryPages(void* addr, [[maybe_unused]] std::size_t size) noexcept {
+    if (!addr)
        return;
 #ifdef _WIN32
-    ASSERT(VirtualFree(base, 0, MEM_RELEASE));
+    VirtualFree(addr, 0, MEM_RELEASE);
 #else
-    ASSERT(munmap(base, size) == 0);
+    int rc = munmap(addr, size);
+    ASSERT(rc == 0);
 #endif
 }

--- a/src/common/virtual_buffer.h
+++ b/src/common/virtual_buffer.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -9,6 +12,7 @@ namespace Common {

 void* AllocateMemoryPages(std::size_t size) noexcept;
 void FreeMemoryPages(void* base, std::size_t size) noexcept;
+void InitSwap() noexcept;

 template <typename T>
 class VirtualBuffer final {
@@ -32,9 +36,10 @@ public:
    VirtualBuffer(const VirtualBuffer&) = delete;
    VirtualBuffer& operator=(const VirtualBuffer&) = delete;

-    VirtualBuffer(VirtualBuffer&& other) noexcept
-        : alloc_size{std::exchange(other.alloc_size, 0)}, base_ptr{std::exchange(other.base_ptr),
-                                                                   nullptr} {}
+    VirtualBuffer(VirtualBuffer&& other) noexcept {
+        alloc_size = std::exchange(other.alloc_size, 0);
+        base_ptr = std::exchange(other.base_ptr, nullptr);
+    }

    VirtualBuffer& operator=(VirtualBuffer&& other) noexcept {
        alloc_size = std::exchange(other.alloc_size, 0);
--- a/src/core/arm/dynarmic/arm_dynarmic_32.cpp
+++ b/src/core/arm/dynarmic/arm_dynarmic_32.cpp
@@ -295,7 +295,7 @@ std::shared_ptr<Dynarmic::A32::Jit> ArmDynarmic32::MakeJit(Common::PageTable* pa
    // Curated optimizations
    case Settings::CpuAccuracy::Auto:
        config.unsafe_optimizations = true;
-#if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__sun__) || defined(__HAIKU__) || defined(__DragonFly__) || defined(__NetBSD__)
+#if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__sun__) || defined(__HAIKU__) || defined(__DragonFly__) || defined(__NetBSD__) || defined(__OPENORBIS__)
        config.fastmem_pointer = std::nullopt;
        config.fastmem_exclusive_access = false;
 #endif
--- a/src/core/arm/nce/arm_nce.cpp
+++ b/src/core/arm/nce/arm_nce.cpp
@@ -391,28 +391,15 @@ const std::size_t CACHE_PAGE_SIZE = 4096;

 void ArmNce::ClearInstructionCache() {
 #ifdef __aarch64__
-    // Use IC IALLU to actually invalidate L1 instruction cache
+    // Ensure all previous memory operations complete
    asm volatile("dsb ish\n"
-                 "ic iallu\n"
                 "dsb ish\n"
                 "isb" ::: "memory");
 #endif
 }

 void ArmNce::InvalidateCacheRange(u64 addr, std::size_t size) {
-#ifdef ARCHITECTURE_arm64
-    // Invalidate instruction cache for specific range instead of full flush
-    constexpr u64 cache_line_size = 64;
-    const u64 aligned_addr = addr & ~(cache_line_size - 1);
-    const u64 end_addr = (addr + size + cache_line_size - 1) & ~(cache_line_size - 1);
-
-    asm volatile("dsb ish" ::: "memory");
-    for (u64 i = aligned_addr; i < end_addr; i += cache_line_size) {
-        asm volatile("ic ivau, %0" :: "r"(i) : "memory");
-    }
-    asm volatile("dsb ish\n"
-                 "isb" ::: "memory");
-#endif
+    this->ClearInstructionCache();
 }

 } // namespace Core
--- a/src/core/device_memory.h
+++ b/src/core/device_memory.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -26,27 +29,22 @@ public:

    template <typename T>
    Common::PhysicalAddress GetPhysicalAddr(const T* ptr) const {
-        return (reinterpret_cast<uintptr_t>(ptr) -
-                reinterpret_cast<uintptr_t>(buffer.BackingBasePointer())) +
-               DramMemoryMap::Base;
+        return (uintptr_t(ptr) - uintptr_t(buffer.BackingBasePointer())) + DramMemoryMap::Base;
    }

    template <typename T>
    PAddr GetRawPhysicalAddr(const T* ptr) const {
-        return static_cast<PAddr>(reinterpret_cast<uintptr_t>(ptr) -
-                                  reinterpret_cast<uintptr_t>(buffer.BackingBasePointer()));
+        return PAddr(uintptr_t(ptr) - uintptr_t(buffer.BackingBasePointer()));
    }

    template <typename T>
    T* GetPointer(Common::PhysicalAddress addr) {
-        return reinterpret_cast<T*>(buffer.BackingBasePointer() +
-                                    (GetInteger(addr) - DramMemoryMap::Base));
+        return reinterpret_cast<T*>(buffer.BackingBasePointer() + (GetInteger(addr) - DramMemoryMap::Base));
    }

    template <typename T>
    const T* GetPointer(Common::PhysicalAddress addr) const {
-        return reinterpret_cast<T*>(buffer.BackingBasePointer() +
-                                    (GetInteger(addr) - DramMemoryMap::Base));
+        return reinterpret_cast<T*>(buffer.BackingBasePointer() + (GetInteger(addr) - DramMemoryMap::Base));
    }

    template <typename T>
--- a/src/core/device_memory_manager.inc
+++ b/src/core/device_memory_manager.inc
@@ -161,7 +161,7 @@ struct DeviceMemoryManagerAllocator {

 template <typename Traits>
 DeviceMemoryManager<Traits>::DeviceMemoryManager(const DeviceMemory& device_memory_)
-    : physical_base{reinterpret_cast<const uintptr_t>(device_memory_.buffer.BackingBasePointer())},
+    : physical_base{uintptr_t(device_memory_.buffer.BackingBasePointer())},
      device_inter{nullptr}, compressed_physical_ptr(device_as_size >> Memory::YUZU_PAGEBITS),
      compressed_device_addr(1ULL << ((Settings::values.memory_layout_mode.GetValue() ==
                                               Settings::MemoryLayout::Memory_4Gb
--- a/src/core/frontend/applets/cabinet.h
+++ b/src/core/frontend/applets/cabinet.h
@@ -21,7 +21,7 @@ namespace Core::Frontend {
 struct CabinetParameters {
    Service::NFP::TagInfo tag_info;
    Service::NFP::RegisterInfo register_info;
-    Service::NFP::CabinetMode mode;
+    Service::NFP::CabinetMode mode{};
 };

 using CabinetCallback = std::function<void(bool, const std::string&)>;
--- a/src/core/frontend/applets/software_keyboard.h
+++ b/src/core/frontend/applets/software_keyboard.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -20,9 +23,9 @@ struct KeyboardInitializeParameters {
    std::u16string initial_text;
    char16_t left_optional_symbol_key;
    char16_t right_optional_symbol_key;
-    u32 max_text_length;
-    u32 min_text_length;
-    s32 initial_cursor_position;
+    u32 max_text_length{};
+    u32 min_text_length{};
+    s32 initial_cursor_position{};
    Service::AM::Frontend::SwkbdType type;
    Service::AM::Frontend::SwkbdPasswordMode password_mode;
    Service::AM::Frontend::SwkbdTextDrawType text_draw_type;
@@ -34,12 +37,12 @@ struct KeyboardInitializeParameters {
 };

 struct InlineAppearParameters {
-    u32 max_text_length;
-    u32 min_text_length;
-    f32 key_top_scale_x;
-    f32 key_top_scale_y;
-    f32 key_top_translate_x;
-    f32 key_top_translate_y;
+    u32 max_text_length{};
+    u32 min_text_length{};
+    f32 key_top_scale_x{};
+    f32 key_top_scale_y{};
+    f32 key_top_translate_x{};
+    f32 key_top_translate_y{};
    Service::AM::Frontend::SwkbdType type;
    Service::AM::Frontend::SwkbdKeyDisableFlags key_disable_flags;
    bool key_top_as_floating;
@@ -50,7 +53,7 @@ struct InlineAppearParameters {

 struct InlineTextParameters {
    std::u16string input_text;
-    s32 cursor_position;
+    s32 cursor_position{};
 };

 class SoftwareKeyboardApplet : public Applet {
--- a/src/core/hle/kernel/kernel.cpp
+++ b/src/core/hle/kernel/kernel.cpp
@@ -69,7 +69,9 @@ struct KernelCore::Impl {
        global_object_list_container = std::make_unique<KAutoObjectWithListContainer>(kernel);
        global_scheduler_context = std::make_unique<Kernel::GlobalSchedulerContext>(kernel);

+#ifndef __OPENORBIS__
        is_phantom_mode_for_singlecore = false;
+#endif

        // Derive the initial memory layout from the emulated board
        Init::InitializeSlabResourceCounts(kernel);
@@ -356,7 +358,11 @@ struct KernelCore::Impl {
        application_process->Open();
    }

+#ifdef __OPENORBIS__
+    static inline u8 host_thread_id = UINT8_MAX;
+#else
    static inline thread_local u8 host_thread_id = UINT8_MAX;
+#endif

    /// Sets the host thread ID for the caller.
    u32 SetHostThreadId(std::size_t core_id) {
@@ -380,8 +386,14 @@ struct KernelCore::Impl {
            ASSERT(KThread::InitializeDummyThread(thread, nullptr).IsSuccess());
            return thread;
        }};
+#ifdef __OPENORBIS__
+        // No proper TLS yet
+        static KThread raw_thread{system.Kernel()};
+        static KThread* thread = existing_thread ? existing_thread : initialize(&raw_thread);
+#else
        thread_local KThread raw_thread{system.Kernel()};
        thread_local KThread* thread = existing_thread ? existing_thread : initialize(&raw_thread);
+#endif
        return thread;
    }

@@ -407,22 +419,33 @@ struct KernelCore::Impl {
        return this_id;
    }

+#ifdef __OPENORBIS__
+    bool IsPhantomModeForSingleCore() const {
+        return true;
+    }
+    void SetIsPhantomModeForSingleCore(bool value) {}
+#else
+    // Forces singlecore
    static inline thread_local bool is_phantom_mode_for_singlecore{false};
-
    bool IsPhantomModeForSingleCore() const {
        return is_phantom_mode_for_singlecore;
    }
-
    void SetIsPhantomModeForSingleCore(bool value) {
        ASSERT(!is_multicore);
        is_phantom_mode_for_singlecore = value;
    }
+#endif

    bool IsShuttingDown() const {
        return is_shutting_down.load(std::memory_order_relaxed);
    }

+#ifdef __OPENORBIS__
+    // PS4 doesn't have proper TLS handling
+    static inline KThread* current_thread{nullptr};
+#else
    static inline thread_local KThread* current_thread{nullptr};
+#endif

    KThread* GetCurrentEmuThread() {
        if (!current_thread) {
--- a/src/core/hle/service/hle_ipc.cpp
+++ b/src/core/hle/service/hle_ipc.cpp
@@ -1,12 +1,8 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

 #include <algorithm>
 #include <array>
-#include <cstring>
 #include <sstream>

 #include <boost/range/algorithm_ext/erase.hpp>
@@ -191,7 +187,7 @@ void HLERequestContext::ParseCommandBuffer(u32_le* src_cmdbuf, bool incoming) {
        buffer_w_descriptors.push_back(rp.PopRaw<IPC::BufferDescriptorABW>());
    }

-    buffer_c_offset = rp.GetCurrentOffset() + command_header->data_size;
+    const auto buffer_c_offset = rp.GetCurrentOffset() + command_header->data_size;

    if (!command_header->IsTipc()) {
        // Padding to align to 16 bytes
@@ -298,15 +294,7 @@ Result HLERequestContext::WriteToOutgoingCommandBuffer() {
    }

    // Write the domain objects to the command buffer, these go after the raw untranslated data.
-
-    if (buffer_c_offset != 0 && !buffer_c_descriptors.empty()) {
-        constexpr u32 WORDS_PER_DESCRIPTOR = sizeof(IPC::BufferDescriptorC) / sizeof(u32);
-        u32 descriptor_offset = buffer_c_offset;
-        for (const auto& descriptor : buffer_c_descriptors) {
-            std::memcpy(&cmd_buf[descriptor_offset], &descriptor, sizeof(descriptor));
-            descriptor_offset += WORDS_PER_DESCRIPTOR;
-        }
-    }
+    // TODO(Subv): This completely ignores C buffers.

    if (GetManager()->IsDomain()) {
        current_offset = domain_offset - static_cast<u32>(outgoing_domain_objects.size());
@@ -405,14 +393,10 @@ std::size_t HLERequestContext::WriteBuffer(const void* buffer, std::size_t size,
    const bool is_buffer_b{BufferDescriptorB().size() > buffer_index &&
                           BufferDescriptorB()[buffer_index].Size()};
    const std::size_t buffer_size{GetWriteBufferSize(buffer_index)};
-    if (buffer_size == 0) {
-        LOG_WARNING(Core, "WriteBuffer target index {} has zero capacity", buffer_index);
-        return 0;
-    }
    if (size > buffer_size) {
-        LOG_WARNING(Core, "size ({:016X}) is greater than buffer_size ({:016X}); clamping",
-                    size, buffer_size);
-        size = buffer_size;
+        LOG_CRITICAL(Core, "size ({:016X}) is greater than buffer_size ({:016X})", size,
+                     buffer_size);
+        size = buffer_size; // TODO(bunnei): This needs to be HW tested
    }

    if (is_buffer_b) {
@@ -434,25 +418,15 @@ std::size_t HLERequestContext::WriteBuffer(const void* buffer, std::size_t size,

 std::size_t HLERequestContext::WriteBufferB(const void* buffer, std::size_t size,
                                            std::size_t buffer_index) const {
-    if (buffer_index >= BufferDescriptorB().size()) {
-        LOG_WARNING(Core, "WriteBufferB invalid buffer index {}", buffer_index);
-        return 0;
-    }
-
-    if (size == 0) {
-        LOG_WARNING(Core, "skip empty buffer write (B)");
+    if (buffer_index >= BufferDescriptorB().size() || size == 0) {
        return 0;
    }

    const auto buffer_size{BufferDescriptorB()[buffer_index].Size()};
-    if (buffer_size == 0) {
-        LOG_WARNING(Core, "WriteBufferB target index {} has zero capacity", buffer_index);
-        return 0;
-    }
    if (size > buffer_size) {
-        LOG_WARNING(Core, "size ({:016X}) is greater than buffer_size ({:016X}); clamping",
-                    size, buffer_size);
-        size = buffer_size;
+        LOG_CRITICAL(Core, "size ({:016X}) is greater than buffer_size ({:016X})", size,
+                     buffer_size);
+        size = buffer_size; // TODO(bunnei): This needs to be HW tested
    }

    memory.WriteBlock(BufferDescriptorB()[buffer_index].Address(), buffer, size);
@@ -461,25 +435,15 @@ std::size_t HLERequestContext::WriteBufferB(const void* buffer, std::size_t size

 std::size_t HLERequestContext::WriteBufferC(const void* buffer, std::size_t size,
                                            std::size_t buffer_index) const {
-    if (buffer_index >= BufferDescriptorC().size()) {
-        LOG_WARNING(Core, "WriteBufferC invalid buffer index {}", buffer_index);
-        return 0;
-    }
-
-    if (size == 0) {
-        LOG_WARNING(Core, "skip empty buffer write (C)");
+    if (buffer_index >= BufferDescriptorC().size() || size == 0) {
        return 0;
    }

    const auto buffer_size{BufferDescriptorC()[buffer_index].Size()};
-    if (buffer_size == 0) {
-        LOG_WARNING(Core, "WriteBufferC target index {} has zero capacity", buffer_index);
-        return 0;
-    }
    if (size > buffer_size) {
-        LOG_WARNING(Core, "size ({:016X}) is greater than buffer_size ({:016X}); clamping",
-                    size, buffer_size);
-        size = buffer_size;
+        LOG_CRITICAL(Core, "size ({:016X}) is greater than buffer_size ({:016X})", size,
+                     buffer_size);
+        size = buffer_size; // TODO(bunnei): This needs to be HW tested
    }

    memory.WriteBlock(BufferDescriptorC()[buffer_index].Address(), buffer, size);
@@ -509,20 +473,12 @@ std::size_t HLERequestContext::GetWriteBufferSize(std::size_t buffer_index) cons
        ASSERT_OR_EXECUTE_MSG(
            BufferDescriptorB().size() > buffer_index, { return 0; },
            "BufferDescriptorB invalid buffer_index {}", buffer_index);
-        const auto size = BufferDescriptorB()[buffer_index].Size();
-        if (size == 0) {
-            LOG_WARNING(Core, "BufferDescriptorB index {} has zero size", buffer_index);
-        }
-        return size;
+        return BufferDescriptorB()[buffer_index].Size();
    } else {
        ASSERT_OR_EXECUTE_MSG(
            BufferDescriptorC().size() > buffer_index, { return 0; },
            "BufferDescriptorC invalid buffer_index {}", buffer_index);
-        const auto size = BufferDescriptorC()[buffer_index].Size();
-        if (size == 0) {
-            LOG_WARNING(Core, "BufferDescriptorC index {} has zero size", buffer_index);
-        }
-        return size;
+        return BufferDescriptorC()[buffer_index].Size();
    }
    return 0;
 }
--- a/src/core/hle/service/hle_ipc.h
+++ b/src/core/hle/service/hle_ipc.h
@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -425,7 +422,6 @@ private:
    u32 data_payload_offset{};
    u32 handles_offset{};
    u32 domain_offset{};
-    u32 buffer_c_offset{};

    std::weak_ptr<SessionRequestManager> manager{};
    bool is_deferred{false};
--- a/src/core/hle/service/nfc/nfc_types.h
+++ b/src/core/hle/service/nfc/nfc_types.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later

@@ -79,7 +82,7 @@ using DeviceHandle = u64;

 // This is nn::nfc::TagInfo
 struct TagInfo {
-    UniqueSerialNumber uuid;
+    UniqueSerialNumber uuid{};
    u8 uuid_length;
    INSERT_PADDING_BYTES(0x15);
    NfcProtocol protocol;
--- a/src/core/hle/service/nfp/nfp_types.h
+++ b/src/core/hle/service/nfp/nfp_types.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later

@@ -315,7 +318,7 @@ static_assert(sizeof(ModelInfo) == 0x40, "ModelInfo is an invalid size");
 // This is nn::nfp::RegisterInfo
 struct RegisterInfo {
    Service::Mii::CharInfo mii_char_info;
-    WriteDate creation_date;
+    WriteDate creation_date{};
    AmiiboName amiibo_name;
    u8 font_region;
    INSERT_PADDING_BYTES(0x7A);
--- a/src/core/hle/service/ns/platform_service_manager.cpp
+++ b/src/core/hle/service/ns/platform_service_manager.cpp
@@ -164,7 +164,7 @@ IPlatformServiceManager::IPlatformServiceManager(Core::System& system_, const ch
    // Rebuild shared fonts from data ncas or synthesize

    impl->shared_font = std::make_shared<Kernel::PhysicalMemory>(SHARED_FONT_MEM_SIZE);
-    for (auto font : SHARED_FONTS) {
+    for (auto& font : SHARED_FONTS) {
        FileSys::VirtualFile romfs;
        const auto nca =
            nand->GetEntry(static_cast<u64>(font.first), FileSys::ContentRecordType::Data);
@@ -261,7 +261,7 @@ Result IPlatformServiceManager::GetSharedFontInOrderOfPriority(
                                    out_font_sizes.size(), impl->shared_font_regions.size()});

    for (size_t i = 0; i < max_size; i++) {
-        auto region = impl->GetSharedFontRegion(i);
+        auto& region = impl->GetSharedFontRegion(i);

        out_font_codes[i] = static_cast<u32>(i);
        out_font_offsets[i] = region.offset;
--- a/src/dynarmic/src/dynarmic/backend/exception_handler_posix.cpp
+++ b/src/dynarmic/src/dynarmic/backend/exception_handler_posix.cpp
@@ -59,12 +59,16 @@ public:
        signal_stack_size = std::max<size_t>(SIGSTKSZ, 2 * 1024 * 1024);
        signal_stack_memory = mmap(nullptr, signal_stack_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);

+#ifdef __OPENORBIS__
+        fmt::print(stderr, "no fastmem on PS4\n");
+        supports_fast_mem = false;
+#else
        stack_t signal_stack{};
        signal_stack.ss_sp = signal_stack_memory;
        signal_stack.ss_size = signal_stack_size;
        signal_stack.ss_flags = 0;
        if (sigaltstack(&signal_stack, nullptr) != 0) {
-            fmt::print(stderr, "dynarmic: POSIX SigHandler: init failure at sigaltstack\n");
+            fmt::print(stderr, "POSIX SigHandler: init failure at sigaltstack\n");
            supports_fast_mem = false;
            return;
        }
@@ -75,16 +79,17 @@ public:
        sa.sa_flags = SA_SIGINFO | SA_ONSTACK | SA_RESTART;
        sigemptyset(&sa.sa_mask);
        if (sigaction(SIGSEGV, &sa, &old_sa_segv) != 0) {
-            fmt::print(stderr, "dynarmic: POSIX SigHandler: could not set SIGSEGV handler\n");
+            fmt::print(stderr, "POSIX SigHandler: could not set SIGSEGV handler\n");
            supports_fast_mem = false;
            return;
        }
-#ifdef __APPLE__
+#   ifdef __APPLE__
        if (sigaction(SIGBUS, &sa, &old_sa_bus) != 0) {
-            fmt::print(stderr, "dynarmic: POSIX SigHandler: could not set SIGBUS handler\n");
+            fmt::print(stderr, "POSIX SigHandler: could not set SIGBUS handler\n");
            supports_fast_mem = false;
            return;
        }
+#   endif
 #endif
    }

@@ -145,6 +150,9 @@ void SigHandler::SigAction(int sig, siginfo_t* info, void* raw_context) {
 #    error "Invalid architecture"
 #endif

+#ifdef __OPENORBIS__
+    // No fastmem
+#else
    struct sigaction* retry_sa = sig == SIGSEGV ? &sig_handler->old_sa_segv : &sig_handler->old_sa_bus;
    if (retry_sa->sa_flags & SA_SIGINFO) {
        retry_sa->sa_sigaction(sig, info, raw_context);
@@ -158,6 +166,7 @@ void SigHandler::SigAction(int sig, siginfo_t* info, void* raw_context) {
        return;
    }
    retry_sa->sa_handler(sig);
+#endif
 }

 }  // anonymous namespace
--- a/src/dynarmic/src/dynarmic/common/context.h
+++ b/src/dynarmic/src/dynarmic/common/context.h
@@ -60,7 +60,7 @@
 #    elif defined(__linux__)
 #        define CTX_RIP (mctx.gregs[REG_RIP])
 #        define CTX_RSP (mctx.gregs[REG_RSP])
-#    elif defined(__FreeBSD__)
+#    elif defined(__FreeBSD__) || defined(__DragonFly__)
 #        define CTX_RIP (mctx.mc_rip)
 #        define CTX_RSP (mctx.mc_rsp)
 #    elif defined(__NetBSD__)
@@ -72,9 +72,9 @@
 #    elif defined(__sun__)
 #        define CTX_RIP (mctx.gregs[REG_RIP])
 #        define CTX_RSP (mctx.gregs[REG_RSP])
-#    elif defined(__DragonFly__)
-#        define CTX_RIP (mctx.mc_rip)
-#        define CTX_RSP (mctx.mc_rsp)
+#    elif defined(__OPENORBIS__)
+#        define CTX_RIP (mctx.gregs[REG_RIP])
+#        define CTX_RSP (mctx.gregs[REG_RSP])
 #    else
 #        error "Unknown platform"
 #    endif
@@ -97,7 +97,7 @@
 #        define CTX_Q(i) (fpctx->vregs[i])
 #        define CTX_FPSR (fpctx->fpsr)
 #        define CTX_FPCR (fpctx->fpcr)
-#    elif defined(__FreeBSD__)
+#    elif defined(__FreeBSD__) || defined(__DragonFly__)
 #        define CTX_PC (mctx.mc_gpregs.gp_elr)
 #        define CTX_SP (mctx.mc_gpregs.gp_sp)
 #        define CTX_LR (mctx.mc_gpregs.gp_lr)
--- a/src/dynarmic/tests/CMakeLists.txt
+++ b/src/dynarmic/tests/CMakeLists.txt
@@ -134,4 +134,4 @@ target_include_directories(dynarmic_tests PRIVATE . ../src)
 target_compile_options(dynarmic_tests PRIVATE ${DYNARMIC_CXX_FLAGS})
 target_compile_definitions(dynarmic_tests PRIVATE FMT_USE_USER_DEFINED_LITERALS=1)

-add_test(dynarmic_tests dynarmic_tests --durations yes)
+add_test(NAME dynarmic_tests COMMAND dynarmic_tests --durations yes)
--- a/src/frontend_common/play_time_manager.h
+++ b/src/frontend_common/play_time_manager.h
@@ -48,7 +48,7 @@ private:
    void Save();

    PlayTimeDatabase database;
-    u64 running_program_id;
+    u64 running_program_id{};
    std::jthread play_time_thread;
 };

--- a/src/input_common/CMakeLists.txt
+++ b/src/input_common/CMakeLists.txt
@@ -75,7 +75,8 @@ if (ENABLE_SDL2)
        helpers/joycon_protocol/rumble.cpp
        helpers/joycon_protocol/rumble.h
    )
-    target_link_libraries(input_common PRIVATE SDL2::SDL2)
+    target_include_directories(input_common PRIVATE ${CMAKE_SYSROOT}/include/SDL2)
+    target_link_libraries(input_common PRIVATE SDL2)
    target_compile_definitions(input_common PRIVATE HAVE_SDL2)
 endif()

--- a/src/input_common/drivers/joycon.cpp
+++ b/src/input_common/drivers/joycon.cpp
@@ -23,12 +23,14 @@ Joycons::Joycons(const std::string& input_engine_) : InputEngine(input_engine_)
        return;
    }
    LOG_INFO(Input, "Joycon driver Initialization started");
-    const int init_res = SDL_hid_init();
-    if (init_res == 0) {
+#if SDL_VERSION_ATLEAST(2, 26, 4)
+    int const res = SDL_hid_init();
+    if (res == 0) {
        Setup();
    } else {
-        LOG_ERROR(Input, "Hidapi could not be initialized. failed with error = {}", init_res);
+        LOG_ERROR(Input, "Hidapi could not be initialized. failed with error = {}", res);
    }
+#endif
 }

 Joycons::~Joycons() {
@@ -55,7 +57,9 @@ void Joycons::Reset() {
        }
        device->Stop();
    }
+#if SDL_VERSION_ATLEAST(2, 26, 4)
    SDL_hid_exit();
+#endif
 }

 void Joycons::Setup() {
@@ -80,9 +84,9 @@ void Joycons::Setup() {
 }

 void Joycons::ScanThread(std::stop_token stop_token) {
+#if SDL_VERSION_ATLEAST(2, 26, 4)
    constexpr u16 nintendo_vendor_id = 0x057e;
    Common::SetCurrentThreadName("JoyconScanThread");
-
    do {
        SDL_hid_device_info* devs = SDL_hid_enumerate(nintendo_vendor_id, 0x0);
        SDL_hid_device_info* cur_dev = devs;
@@ -98,6 +102,7 @@ void Joycons::ScanThread(std::stop_token stop_token) {

        SDL_hid_free_enumeration(devs);
    } while (Common::StoppableTimedWait(stop_token, std::chrono::seconds{5}));
+#endif
 }

 bool Joycons::IsDeviceNew(SDL_hid_device_info* device_info) const {
--- a/src/input_common/drivers/joycon.h
+++ b/src/input_common/drivers/joycon.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -6,7 +9,14 @@
 #include <array>
 #include <span>
 #include <thread>
-#include <SDL_hidapi.h>
+
+#include <SDL.h>
+#if SDL_VERSION_ATLEAST(2, 26, 4)
+#   include <SDL_hidapi.h>
+#else
+struct SDL_hid_device;
+struct SDL_hid_device_info;
+#endif

 #include "input_common/input_engine.h"

--- a/src/input_common/drivers/sdl_driver.cpp
+++ b/src/input_common/drivers/sdl_driver.cpp
@@ -42,6 +42,7 @@ public:
    }

    void EnableMotion() {
+#if SDL_VERSION_ATLEAST(2, 26, 4)
        if (!sdl_controller) {
            return;
        }
@@ -58,12 +59,14 @@ public:
        if (has_gyro) {
            SDL_GameControllerSetSensorEnabled(controller, SDL_SENSOR_GYRO, SDL_TRUE);
        }
+#endif
    }

    bool HasMotion() const {
        return has_gyro || has_accel;
    }

+#if SDL_VERSION_ATLEAST(2, 26, 4)
    bool UpdateMotion(SDL_ControllerSensorEvent event) {
        constexpr float gravity_constant = 9.80665f;
        std::scoped_lock lock{mutex};
@@ -105,6 +108,7 @@ public:
        motion.delta_timestamp = time_difference * 1000;
        return true;
    }
+#endif

    const BasicMotion& GetMotion() const {
        return motion;
@@ -149,13 +153,15 @@ public:
    }

    bool HasHDRumble() const {
+#if SDL_VERSION_ATLEAST(2, 26, 4)
        if (sdl_controller) {
-            const auto type = SDL_GameControllerGetType(sdl_controller.get());
+            auto const type = SDL_GameControllerGetType(sdl_controller.get());
            return (type == SDL_CONTROLLER_TYPE_NINTENDO_SWITCH_PRO) ||
                   (type == SDL_CONTROLLER_TYPE_NINTENDO_SWITCH_JOYCON_LEFT) ||
                   (type == SDL_CONTROLLER_TYPE_NINTENDO_SWITCH_JOYCON_RIGHT) ||
                   (type == SDL_CONTROLLER_TYPE_PS5);
        }
+#endif
        return false;
    }

@@ -252,26 +258,21 @@ public:
    }

    std::string GetControllerName() const {
+#if SDL_VERSION_ATLEAST(2, 26, 4)
        if (sdl_controller) {
            switch (SDL_GameControllerGetType(sdl_controller.get())) {
-            case SDL_CONTROLLER_TYPE_XBOX360:
-                return "Xbox 360 Controller";
-            case SDL_CONTROLLER_TYPE_XBOXONE:
-                return "Xbox One Controller";
-            case SDL_CONTROLLER_TYPE_PS3:
-                return "DualShock 3 Controller";
-            case SDL_CONTROLLER_TYPE_PS4:
-                return "DualShock 4 Controller";
-            case SDL_CONTROLLER_TYPE_PS5:
-                return "DualSense Controller";
+            case SDL_CONTROLLER_TYPE_XBOX360: return "Xbox 360 Controller";
+            case SDL_CONTROLLER_TYPE_XBOXONE: return "Xbox One Controller";
+            case SDL_CONTROLLER_TYPE_PS3: return "DualShock 3 Controller";
+            case SDL_CONTROLLER_TYPE_PS4: return "DualShock 4 Controller";
+            case SDL_CONTROLLER_TYPE_PS5: return "DualSense Controller";
            default:
+                if (auto const name = SDL_GameControllerName(sdl_controller.get()); name)
+                    return name;
                break;
            }
-            const auto name = SDL_GameControllerName(sdl_controller.get());
-            if (name) {
-                return name;
-            }
        }
+#endif

        if (sdl_joystick) {
            const auto name = SDL_JoystickName(sdl_joystick.get());
@@ -456,6 +457,7 @@ void SDLDriver::HandleGameControllerEvent(const SDL_Event& event) {
        }
        break;
    }
+#if SDL_VERSION_ATLEAST(2, 26, 4)
    case SDL_CONTROLLERSENSORUPDATE: {
        if (auto joystick = GetSDLJoystickBySDLID(event.csensor.which)) {
            if (joystick->UpdateMotion(event.csensor)) {
@@ -472,6 +474,7 @@ void SDLDriver::HandleGameControllerEvent(const SDL_Event& event) {
        }
        break;
    }
+#endif
    case SDL_JOYDEVICEREMOVED:
        LOG_DEBUG(Input, "Controller removed with Instance_ID {}", event.jdevice.which);
        CloseJoystick(SDL_JoystickFromInstanceID(event.jdevice.which));
@@ -489,6 +492,7 @@ void SDLDriver::CloseJoysticks() {
 }

 SDLDriver::SDLDriver(std::string input_engine_) : InputEngine(std::move(input_engine_)) {
+#if SDL_VERSION_ATLEAST(2, 26, 4)
    // Set our application name. Currently passed to DBus by SDL and visible to the user through
    // their desktop environment.
    SDL_SetHint(SDL_HINT_APP_NAME, "Eden");
@@ -531,6 +535,7 @@ SDLDriver::SDLDriver(std::string input_engine_) : InputEngine(std::move(input_en
    // Disable hidapi driver for xbox. Already default on Windows, this causes conflict with native
    // driver on Linux.
    SDL_SetHint(SDL_HINT_JOYSTICK_HIDAPI_XBOX, "0");
+#endif

    // If the frontend is going to manage the event loop, then we don't start one here
    start_thread = SDL_WasInit(SDL_INIT_JOYSTICK | SDL_INIT_GAMECONTROLLER) == 0;
@@ -835,6 +840,7 @@ ButtonBindings SDLDriver::GetDefaultButtonBinding(
    auto slr_button = SDL_CONTROLLER_BUTTON_LEFTSHOULDER;
    auto srr_button = SDL_CONTROLLER_BUTTON_RIGHTSHOULDER;

+#if SDL_VERSION_ATLEAST(2, 26, 4)
    if (joystick->IsJoyconLeft()) {
        sll_button = SDL_CONTROLLER_BUTTON_PADDLE2;
        srl_button = SDL_CONTROLLER_BUTTON_PADDLE4;
@@ -843,6 +849,7 @@ ButtonBindings SDLDriver::GetDefaultButtonBinding(
        slr_button = SDL_CONTROLLER_BUTTON_PADDLE3;
        srr_button = SDL_CONTROLLER_BUTTON_PADDLE1;
    }
+#endif

    return {
        std::pair{Settings::NativeButton::A, SDL_CONTROLLER_BUTTON_B},
@@ -864,7 +871,9 @@ ButtonBindings SDLDriver::GetDefaultButtonBinding(
        {Settings::NativeButton::SLRight, slr_button},
        {Settings::NativeButton::SRRight, srr_button},
        {Settings::NativeButton::Home, SDL_CONTROLLER_BUTTON_GUIDE},
+#if SDL_VERSION_ATLEAST(2, 26, 4)
        {Settings::NativeButton::Screenshot, SDL_CONTROLLER_BUTTON_MISC1},
+#endif
    };
 }

--- a/src/input_common/helpers/joycon_driver.cpp
+++ b/src/input_common/helpers/joycon_driver.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -38,8 +41,8 @@ Common::Input::DriverResult JoyconDriver::RequestDeviceAccess(SDL_hid_device_inf
        return Common::Input::DriverResult::UnsupportedControllerType;
    }

-    hidapi_handle->handle =
-        SDL_hid_open(device_info->vendor_id, device_info->product_id, device_info->serial_number);
+#if SDL_VERSION_ATLEAST(2, 26, 4)
+    hidapi_handle->handle = SDL_hid_open(device_info->vendor_id, device_info->product_id, device_info->serial_number);
    std::memcpy(&handle_serial_number, device_info->serial_number, 15);
    if (!hidapi_handle->handle) {
        LOG_ERROR(Input, "Yuzu can't gain access to this device: ID {:04X}:{:04X}.",
@@ -48,6 +51,9 @@ Common::Input::DriverResult JoyconDriver::RequestDeviceAccess(SDL_hid_device_inf
    }
    SDL_hid_set_nonblocking(hidapi_handle->handle, 1);
    return Common::Input::DriverResult::Success;
+#else
+    return Common::Input::DriverResult::UnsupportedControllerType;
+#endif
 }

 Common::Input::DriverResult JoyconDriver::InitializeDevice() {
@@ -138,8 +144,6 @@ void JoyconDriver::InputThread(std::stop_token stop_token) {
    Common::SetCurrentThreadName("JoyconInput");
    input_thread_running = true;

-    // Max update rate is 5ms, ensure we are always able to read a bit faster
-    constexpr int ThreadDelay = 3;
    std::vector<u8> buffer(MaxBufferSize);

    while (!stop_token.stop_requested()) {
@@ -150,14 +154,17 @@ void JoyconDriver::InputThread(std::stop_token stop_token) {
            continue;
        }

+#if SDL_VERSION_ATLEAST(2, 26, 4)
+        // Max update rate is 5ms, ensure we are always able to read a bit faster
+        int constexpr thread_delay = 3;
        // By disabling the input thread we can ensure custom commands will succeed as no package is
        // skipped
        if (!disable_input_thread) {
-            status = SDL_hid_read_timeout(hidapi_handle->handle, buffer.data(), buffer.size(),
-                                          ThreadDelay);
+            status = SDL_hid_read_timeout(hidapi_handle->handle, buffer.data(), buffer.size(), thread_delay);
        } else {
-            std::this_thread::sleep_for(std::chrono::milliseconds(ThreadDelay));
+            std::this_thread::sleep_for(std::chrono::milliseconds(thread_delay));
        }
+#endif

        if (IsPayloadCorrect(status, buffer)) {
            OnNewData(buffer);
@@ -690,19 +697,18 @@ void JoyconDriver::SetCallbacks(const JoyconCallbacks& callbacks) {
    joycon_poller->SetCallbacks(callbacks);
 }

-Common::Input::DriverResult JoyconDriver::GetDeviceType(SDL_hid_device_info* device_info,
-                                                        ControllerType& controller_type) {
+Common::Input::DriverResult JoyconDriver::GetDeviceType(SDL_hid_device_info* device_info, ControllerType& controller_type) {
+#if SDL_VERSION_ATLEAST(2, 26, 4)
    static constexpr std::array<std::pair<u32, ControllerType>, 6> supported_devices{
        std::pair<u32, ControllerType>{0x2006, ControllerType::Left},
        {0x2007, ControllerType::Right},
        {0x2009, ControllerType::Pro},
    };
-    constexpr u16 nintendo_vendor_id = 0x057e;

+    constexpr u16 nintendo_vendor_id = 0x057e;
    controller_type = ControllerType::None;
-    if (device_info->vendor_id != nintendo_vendor_id) {
+    if (device_info->vendor_id != nintendo_vendor_id)
        return Common::Input::DriverResult::UnsupportedControllerType;
-    }

    for (const auto& [product_id, type] : supported_devices) {
        if (device_info->product_id == static_cast<u16>(product_id)) {
@@ -710,16 +716,20 @@ Common::Input::DriverResult JoyconDriver::GetDeviceType(SDL_hid_device_info* dev
            return Common::Input::DriverResult::Success;
        }
    }
+#endif
    return Common::Input::DriverResult::UnsupportedControllerType;
 }

-Common::Input::DriverResult JoyconDriver::GetSerialNumber(SDL_hid_device_info* device_info,
-                                                          SerialNumber& serial_number) {
+Common::Input::DriverResult JoyconDriver::GetSerialNumber(SDL_hid_device_info* device_info, SerialNumber& serial_number) {
+#if SDL_VERSION_ATLEAST(2, 26, 4)
    if (device_info->serial_number == nullptr) {
        return Common::Input::DriverResult::Unknown;
    }
    std::memcpy(&serial_number, device_info->serial_number, 15);
    return Common::Input::DriverResult::Success;
+#else
+    return Common::Input::DriverResult::Unknown;
+#endif
 }

 } // namespace InputCommon::Joycon
--- a/src/input_common/helpers/joycon_protocol/common_protocol.cpp
+++ b/src/input_common/helpers/joycon_protocol/common_protocol.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -15,11 +18,15 @@ u8 JoyconCommonProtocol::GetCounter() {
 }

 void JoyconCommonProtocol::SetBlocking() {
+#if SDL_VERSION_ATLEAST(2, 26, 4)
    SDL_hid_set_nonblocking(hidapi_handle->handle, 0);
+#endif
 }

 void JoyconCommonProtocol::SetNonBlocking() {
+#if SDL_VERSION_ATLEAST(2, 26, 4)
    SDL_hid_set_nonblocking(hidapi_handle->handle, 1);
+#endif
 }

 Common::Input::DriverResult JoyconCommonProtocol::GetDeviceType(ControllerType& controller_type) {
@@ -35,26 +42,23 @@ Common::Input::DriverResult JoyconCommonProtocol::GetDeviceType(ControllerType&
    return result;
 }

-Common::Input::DriverResult JoyconCommonProtocol::CheckDeviceAccess(
-    SDL_hid_device_info* device_info) {
+Common::Input::DriverResult JoyconCommonProtocol::CheckDeviceAccess(SDL_hid_device_info* device_info) {
    ControllerType controller_type{ControllerType::None};
    const auto result = GetDeviceType(controller_type);
-
    if (result != Common::Input::DriverResult::Success || controller_type == ControllerType::None) {
        return Common::Input::DriverResult::UnsupportedControllerType;
    }
-
-    hidapi_handle->handle =
-        SDL_hid_open(device_info->vendor_id, device_info->product_id, device_info->serial_number);
-
+#if SDL_VERSION_ATLEAST(2, 26, 4)
+    hidapi_handle->handle = SDL_hid_open(device_info->vendor_id, device_info->product_id, device_info->serial_number);
    if (!hidapi_handle->handle) {
-        LOG_ERROR(Input, "Yuzu can't gain access to this device: ID {:04X}:{:04X}.",
-                  device_info->vendor_id, device_info->product_id);
+        LOG_ERROR(Input, "Yuzu can't gain access to this device: ID {:04X}:{:04X}.", device_info->vendor_id, device_info->product_id);
        return Common::Input::DriverResult::HandleInUse;
    }
-
    SetNonBlocking();
    return Common::Input::DriverResult::Success;
+#else
+    return Common::Input::DriverResult::UnsupportedControllerType;
+#endif
 }

 Common::Input::DriverResult JoyconCommonProtocol::SetReportMode(ReportMode report_mode) {
@@ -63,21 +67,21 @@ Common::Input::DriverResult JoyconCommonProtocol::SetReportMode(ReportMode repor
 }

 Common::Input::DriverResult JoyconCommonProtocol::SendRawData(std::span<const u8> buffer) {
-    const auto result = SDL_hid_write(hidapi_handle->handle, buffer.data(), buffer.size());
-
-    if (result == -1) {
+#if SDL_VERSION_ATLEAST(2, 26, 4)
+    auto const result = SDL_hid_write(hidapi_handle->handle, buffer.data(), buffer.size());
+    if (result == -1)
        return Common::Input::DriverResult::ErrorWritingData;
-    }
-
    return Common::Input::DriverResult::Success;
+#else
+    return Common::Input::DriverResult::ErrorWritingData;
+#endif
 }

-Common::Input::DriverResult JoyconCommonProtocol::GetSubCommandResponse(
-    SubCommand sc, SubCommandResponse& output) {
+Common::Input::DriverResult JoyconCommonProtocol::GetSubCommandResponse(SubCommand sc, SubCommandResponse& output) {
+#if SDL_VERSION_ATLEAST(2, 26, 4)
    constexpr int timeout_mili = 66;
    constexpr int MaxTries = 10;
    int tries = 0;
-
    do {
        int result = SDL_hid_read_timeout(hidapi_handle->handle, reinterpret_cast<u8*>(&output),
                                          sizeof(SubCommandResponse), timeout_mili);
@@ -88,9 +92,8 @@ Common::Input::DriverResult JoyconCommonProtocol::GetSubCommandResponse(
        if (tries++ > MaxTries) {
            return Common::Input::DriverResult::Timeout;
        }
-    } while (output.input_report.report_mode != ReportMode::SUBCMD_REPLY &&
-             output.sub_command != sc);
-
+    } while (output.input_report.report_mode != ReportMode::SUBCMD_REPLY && output.sub_command != sc);
+#endif
    return Common::Input::DriverResult::Success;
 }

@@ -218,12 +221,11 @@ Common::Input::DriverResult JoyconCommonProtocol::ConfigureMCU(const MCUConfig&
    return result;
 }

-Common::Input::DriverResult JoyconCommonProtocol::GetMCUDataResponse(ReportMode report_mode,
-                                                                     MCUCommandResponse& output) {
+Common::Input::DriverResult JoyconCommonProtocol::GetMCUDataResponse(ReportMode report_mode, MCUCommandResponse& output) {
+#if SDL_VERSION_ATLEAST(2, 26, 4)
    constexpr int TimeoutMili = 200;
    constexpr int MaxTries = 9;
    int tries = 0;
-
    do {
        int result = SDL_hid_read_timeout(hidapi_handle->handle, reinterpret_cast<u8*>(&output),
                                          sizeof(MCUCommandResponse), TimeoutMili);
@@ -234,9 +236,8 @@ Common::Input::DriverResult JoyconCommonProtocol::GetMCUDataResponse(ReportMode
        if (tries++ > MaxTries) {
            return Common::Input::DriverResult::Timeout;
        }
-    } while (output.input_report.report_mode != report_mode ||
-             output.mcu_report == MCUReport::EmptyAwaitingCmd);
-
+    } while (output.input_report.report_mode != report_mode || output.mcu_report == MCUReport::EmptyAwaitingCmd);
+#endif
    return Common::Input::DriverResult::Success;
 }

--- a/src/input_common/helpers/joycon_protocol/joycon_types.h
+++ b/src/input_common/helpers/joycon_protocol/joycon_types.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -10,7 +13,14 @@

 #include <array>
 #include <functional>
-#include <SDL_hidapi.h>
+
+#include <SDL.h>
+#if SDL_VERSION_ATLEAST(2, 26, 4)
+#   include <SDL_hidapi.h>
+#else
+struct SDL_hid_device;
+struct SDL_hid_device_info;
+#endif

 #include "common/bit_field.h"
 #include "common/common_funcs.h"
--- a/src/input_common/helpers/joycon_protocol/poller.cpp
+++ b/src/input_common/helpers/joycon_protocol/poller.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

--- a/src/input_common/main.cpp
+++ b/src/input_common/main.cpp
@@ -82,7 +82,10 @@ struct InputSubsystem::Impl {
 #ifdef ENABLE_LIBUSB
        RegisterEngine("gcpad", gcadapter);
 #endif
+#ifndef __OPENORBIS__
+        // TODO: Issue in PS4, crash for UDP_client
        RegisterEngine("cemuhookudp", udp_client);
+#endif
        RegisterEngine("tas", tas_input);
        RegisterEngine("camera", camera);
 #ifdef ANDROID
@@ -116,7 +119,9 @@ struct InputSubsystem::Impl {
 #ifdef ENABLE_LIBUSB
        UnregisterEngine(gcadapter);
 #endif
+#ifndef __OPENORBIS__
        UnregisterEngine(udp_client);
+#endif
        UnregisterEngine(tas_input);
        UnregisterEngine(camera);
 #ifdef ANDROID
@@ -152,8 +157,10 @@ struct InputSubsystem::Impl {
        auto gcadapter_devices = gcadapter->GetInputDevices();
        devices.insert(devices.end(), gcadapter_devices.begin(), gcadapter_devices.end());
 #endif
+#ifndef __OPENORBIS__
        auto udp_devices = udp_client->GetInputDevices();
        devices.insert(devices.end(), udp_devices.begin(), udp_devices.end());
+#endif
 #ifdef HAVE_SDL2
        auto joycon_devices = joycon->GetInputDevices();
        devices.insert(devices.end(), joycon_devices.begin(), joycon_devices.end());
@@ -186,9 +193,11 @@ struct InputSubsystem::Impl {
            return gcadapter;
        }
 #endif
+#ifndef __OPENORBIS__
        if (engine == udp_client->GetEngineName()) {
            return udp_client;
        }
+#endif
 #ifdef HAVE_SDL2
        if (engine == sdl->GetEngineName()) {
            return sdl;
@@ -271,9 +280,11 @@ struct InputSubsystem::Impl {
            return true;
        }
 #endif
+#ifndef __OPENORBIS__
        if (engine == udp_client->GetEngineName()) {
            return true;
        }
+#endif
        if (engine == tas_input->GetEngineName()) {
            return true;
        }
@@ -300,7 +311,9 @@ struct InputSubsystem::Impl {
 #ifdef ENABLE_LIBUSB
        gcadapter->BeginConfiguration();
 #endif
+#ifndef __OPENORBIS__
        udp_client->BeginConfiguration();
+#endif
 #ifdef HAVE_SDL2
        sdl->BeginConfiguration();
        joycon->BeginConfiguration();
@@ -316,7 +329,9 @@ struct InputSubsystem::Impl {
 #ifdef ENABLE_LIBUSB
        gcadapter->EndConfiguration();
 #endif
+#ifndef __OPENORBIS__
        udp_client->EndConfiguration();
+#endif
 #ifdef HAVE_SDL2
        sdl->EndConfiguration();
        joycon->EndConfiguration();
@@ -341,7 +356,9 @@ struct InputSubsystem::Impl {
    std::shared_ptr<Mouse> mouse;
    std::shared_ptr<TouchScreen> touch_screen;
    std::shared_ptr<TasInput::Tas> tas_input;
+#ifndef __OPENORBIS__
    std::shared_ptr<CemuhookUDP::UDPClient> udp_client;
+#endif
    std::shared_ptr<Camera> camera;
    std::shared_ptr<VirtualAmiibo> virtual_amiibo;
    std::shared_ptr<VirtualGamepad> virtual_gamepad;
@@ -470,7 +487,9 @@ bool InputSubsystem::IsStickInverted(const Common::ParamPackage& params) const {
 }

 void InputSubsystem::ReloadInputDevices() {
+#ifndef __OPENORBIS__
    impl->udp_client.get()->ReloadSockets();
+#endif
 }

 void InputSubsystem::BeginMapping(Polling::InputType type) {
--- a/src/network/room_member.h
+++ b/src/network/room_member.h
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2017 Citra Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -53,7 +56,7 @@ struct ChatEntry {

 /// Represents a system status message.
 struct StatusMessageEntry {
-    StatusMessageTypes type; ///< Type of the message
+    StatusMessageTypes type{}; ///< Type of the message
    /// Subject of the message. i.e. the user who is joining/leaving/being banned, etc.
    std::string nickname;
    std::string username;
--- a/src/qt_common/config/uisettings.h
+++ b/src/qt_common/config/uisettings.h
@@ -159,7 +159,13 @@ struct Values {
    Setting<bool> enable_discord_presence{linkage, false, "enable_discord_presence", Category::Ui};

    // logging
-    Setting<bool> show_console{linkage, false, "showConsole", Category::Ui};
+    Setting<bool> show_console{linkage,
+#ifdef __OPENORBIS__
+        true,
+#else
+        false,
+#endif
+        "showConsole", Category::Ui};

    // Screenshots
    Setting<bool> enable_screenshot_save_as{linkage, true, "enable_screenshot_save_as",
--- a/src/shader_recompiler/backend/spirv/emit_spirv.cpp
+++ b/src/shader_recompiler/backend/spirv/emit_spirv.cpp
@@ -11,7 +11,6 @@
 #include <vector>
 #include <spirv-tools/optimizer.hpp>

-#include "common/logging/log.h"
 #include "common/settings.h"
 #include "shader_recompiler/backend/spirv/emit_spirv.h"
 #include "shader_recompiler/backend/spirv/emit_spirv_instructions.h"
@@ -440,23 +439,15 @@ void SetupCapabilities(const Profile& profile, const Info& info, EmitContext& ct
        ctx.AddExtension("SPV_KHR_shader_draw_parameters");
        ctx.AddCapability(spv::Capability::DrawParameters);
    }
-    const bool stage_supports_warp = profile.SupportsWarpIntrinsics(ctx.stage);
-    const bool needs_warp_intrinsics = info.uses_subgroup_vote ||
-                                       info.uses_subgroup_invocation_id ||
-                                       info.uses_subgroup_shuffles;
-
-    if (needs_warp_intrinsics && profile.support_vote && stage_supports_warp) {
+    if ((info.uses_subgroup_vote || info.uses_subgroup_invocation_id ||
+         info.uses_subgroup_shuffles) &&
+        profile.support_vote) {
        ctx.AddCapability(spv::Capability::GroupNonUniformBallot);
        ctx.AddCapability(spv::Capability::GroupNonUniformShuffle);
        if (!profile.warp_size_potentially_larger_than_guest) {
            // vote ops are only used when not taking the long path
            ctx.AddCapability(spv::Capability::GroupNonUniformVote);
        }
-    } else if (needs_warp_intrinsics && !stage_supports_warp) {
-        LOG_WARNING(Shader,
-                    "Warp intrinsics requested in stage {} but the device does not report subgroup "
-                    "support; falling back to scalar approximations",
-                    static_cast<u32>(ctx.stage));
    }
    if (info.uses_int64_bit_atomics && profile.support_int64_atomics) {
        ctx.AddCapability(spv::Capability::Int64Atomics);
--- a/src/shader_recompiler/backend/spirv/emit_spirv_context_get_set.cpp
+++ b/src/shader_recompiler/backend/spirv/emit_spirv_context_get_set.cpp
@@ -491,24 +491,9 @@ void EmitSetPatch(EmitContext& ctx, IR::Patch patch, Id value) {
 }

 void EmitSetFragColor(EmitContext& ctx, u32 index, u32 component, Id value) {
-    const AttributeType output_type{ctx.runtime_info.color_output_types[index]};
-    Id pointer_type{ctx.output_f32};
-    Id store_value{value};
-    switch (output_type) {
-    case AttributeType::SignedInt:
-        pointer_type = ctx.output_s32;
-        store_value = ctx.OpBitcast(ctx.S32[1], value);
-        break;
-    case AttributeType::UnsignedInt:
-        pointer_type = ctx.output_u32;
-        store_value = ctx.OpBitcast(ctx.U32[1], value);
-        break;
-    default:
-        break;
-    }
    const Id component_id{ctx.Const(component)};
-    const Id pointer{ctx.OpAccessChain(pointer_type, ctx.frag_color.at(index), component_id)};
-    ctx.OpStore(pointer, store_value);
+    const Id pointer{ctx.OpAccessChain(ctx.output_f32, ctx.frag_color.at(index), component_id)};
+    ctx.OpStore(pointer, value);
 }

 void EmitSetSampleMask(EmitContext& ctx, Id value) {
--- a/src/shader_recompiler/backend/spirv/emit_spirv_image.cpp
+++ b/src/shader_recompiler/backend/spirv/emit_spirv_image.cpp
@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -198,41 +195,6 @@ Id Texture(EmitContext& ctx, IR::TextureInstInfo info, [[maybe_unused]] const IR
    }
 }

-Id TextureColorResultType(EmitContext& ctx, const TextureDefinition& def) {
-    switch (def.component_type) {
-    case SamplerComponentType::Float:
-    case SamplerComponentType::Depth:
-        return ctx.F32[4];
-    case SamplerComponentType::Sint:
-        return ctx.S32[4];
-    case SamplerComponentType::Stencil:
-        return ctx.U32[4];
-    case SamplerComponentType::Uint:
-        return ctx.U32[4];
-    }
-    throw InvalidArgument("Invalid sampler component type {}", def.component_type);
-}
-
-Id TextureSampleResultToFloat(EmitContext& ctx, const TextureDefinition& def, Id color) {
-    switch (def.component_type) {
-    case SamplerComponentType::Float:
-    case SamplerComponentType::Depth:
-        return color;
-    case SamplerComponentType::Sint:
-        return ctx.OpConvertSToF(ctx.F32[4], color);
-    case SamplerComponentType::Stencil:
-        {
-            const Id converted{ctx.OpConvertUToF(ctx.F32[4], color)};
-            const Id inv255{ctx.Const(1.0f / 255.0f)};
-            const Id scale{ctx.ConstantComposite(ctx.F32[4], inv255, inv255, inv255, inv255)};
-            return ctx.OpFMul(ctx.F32[4], converted, scale);
-        }
-    case SamplerComponentType::Uint:
-        return ctx.OpConvertUToF(ctx.F32[4], color);
-    }
-    throw InvalidArgument("Invalid sampler component type {}", def.component_type);
-}
-
 Id TextureImage(EmitContext& ctx, IR::TextureInstInfo info, const IR::Value& index) {
    if (!index.IsImmediate() || index.U32() != 0) {
        throw NotImplementedException("Indirect image indexing");
@@ -487,39 +449,31 @@ Id EmitBoundImageWrite(EmitContext&) {
 Id EmitImageSampleImplicitLod(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id coords,
                              Id bias_lc, const IR::Value& offset) {
    const auto info{inst->Flags<IR::TextureInstInfo>()};
-    const TextureDefinition& def{ctx.textures.at(info.descriptor_index)};
-    const Id color_type{TextureColorResultType(ctx, def)};
-    const Id texture{Texture(ctx, info, index)};
-    Id color{};
    if (ctx.stage == Stage::Fragment) {
        const ImageOperands operands(ctx, info.has_bias != 0, false, info.has_lod_clamp != 0,
                                     bias_lc, offset);
-        color = Emit(&EmitContext::OpImageSparseSampleImplicitLod,
-                     &EmitContext::OpImageSampleImplicitLod, ctx, inst, color_type, texture,
-                     coords, operands.MaskOptional(), operands.Span());
+        return Emit(&EmitContext::OpImageSparseSampleImplicitLod,
+                    &EmitContext::OpImageSampleImplicitLod, ctx, inst, ctx.F32[4],
+                    Texture(ctx, info, index), coords, operands.MaskOptional(), operands.Span());
    } else {
        // We can't use implicit lods on non-fragment stages on SPIR-V. Maxwell hardware behaves as
        // if the lod was explicitly zero.  This may change on Turing with implicit compute
        // derivatives
        const Id lod{ctx.Const(0.0f)};
        const ImageOperands operands(ctx, false, true, info.has_lod_clamp != 0, lod, offset);
-        color = Emit(&EmitContext::OpImageSparseSampleExplicitLod,
-                     &EmitContext::OpImageSampleExplicitLod, ctx, inst, color_type, texture,
-                     coords, operands.Mask(), operands.Span());
+        return Emit(&EmitContext::OpImageSparseSampleExplicitLod,
+                    &EmitContext::OpImageSampleExplicitLod, ctx, inst, ctx.F32[4],
+                    Texture(ctx, info, index), coords, operands.Mask(), operands.Span());
    }
-    return TextureSampleResultToFloat(ctx, def, color);
 }

 Id EmitImageSampleExplicitLod(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id coords,
                              Id lod, const IR::Value& offset) {
    const auto info{inst->Flags<IR::TextureInstInfo>()};
-    const TextureDefinition& def{ctx.textures.at(info.descriptor_index)};
-    const Id color_type{TextureColorResultType(ctx, def)};
    const ImageOperands operands(ctx, false, true, false, lod, offset);
-    const Id color{Emit(&EmitContext::OpImageSparseSampleExplicitLod,
-                        &EmitContext::OpImageSampleExplicitLod, ctx, inst, color_type,
-                        Texture(ctx, info, index), coords, operands.Mask(), operands.Span())};
-    return TextureSampleResultToFloat(ctx, def, color);
+    return Emit(&EmitContext::OpImageSparseSampleExplicitLod,
+                &EmitContext::OpImageSampleExplicitLod, ctx, inst, ctx.F32[4],
+                Texture(ctx, info, index), coords, operands.Mask(), operands.Span());
 }

 Id EmitImageSampleDrefImplicitLod(EmitContext& ctx, IR::Inst* inst, const IR::Value& index,
@@ -555,18 +509,13 @@ Id EmitImageSampleDrefExplicitLod(EmitContext& ctx, IR::Inst* inst, const IR::Va
 Id EmitImageGather(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id coords,
                   const IR::Value& offset, const IR::Value& offset2) {
    const auto info{inst->Flags<IR::TextureInstInfo>()};
-    const TextureDefinition& def{ctx.textures.at(info.descriptor_index)};
-    const Id color_type{TextureColorResultType(ctx, def)};
    const ImageOperands operands(ctx, offset, offset2);
-    const Id texture{Texture(ctx, info, index)};
    if (ctx.profile.need_gather_subpixel_offset) {
        coords = ImageGatherSubpixelOffset(ctx, info, TextureImage(ctx, info, index), coords);
    }
-    const Id color{
-        Emit(&EmitContext::OpImageSparseGather, &EmitContext::OpImageGather, ctx, inst, color_type,
-             texture, coords, ctx.Const(info.gather_component), operands.MaskOptional(),
-             operands.Span())};
-    return TextureSampleResultToFloat(ctx, def, color);
+    return Emit(&EmitContext::OpImageSparseGather, &EmitContext::OpImageGather, ctx, inst,
+                ctx.F32[4], Texture(ctx, info, index), coords, ctx.Const(info.gather_component),
+                operands.MaskOptional(), operands.Span());
 }

 Id EmitImageGatherDref(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id coords,
@@ -584,9 +533,6 @@ Id EmitImageGatherDref(EmitContext& ctx, IR::Inst* inst, const IR::Value& index,
 Id EmitImageFetch(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id coords, Id offset,
                  Id lod, Id ms) {
    const auto info{inst->Flags<IR::TextureInstInfo>()};
-    const TextureDefinition* def =
-        info.type == TextureType::Buffer ? nullptr : &ctx.textures.at(info.descriptor_index);
-    const Id result_type{def ? TextureColorResultType(ctx, *def) : ctx.F32[4]};
    AddOffsetToCoordinates(ctx, info, coords, offset);
    if (info.type == TextureType::Buffer) {
        lod = Id{};
@@ -596,13 +542,8 @@ Id EmitImageFetch(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id c
        lod = Id{};
    }
    const ImageOperands operands(lod, ms);
-    Id color{Emit(&EmitContext::OpImageSparseFetch, &EmitContext::OpImageFetch, ctx, inst,
-                  result_type, TextureImage(ctx, info, index), coords, operands.MaskOptional(),
-                  operands.Span())};
-    if (def) {
-        color = TextureSampleResultToFloat(ctx, *def, color);
-    }
-    return color;
+    return Emit(&EmitContext::OpImageSparseFetch, &EmitContext::OpImageFetch, ctx, inst, ctx.F32[4],
+                TextureImage(ctx, info, index), coords, operands.MaskOptional(), operands.Span());
 }

 Id EmitImageQueryDimensions(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id lod,
@@ -647,17 +588,14 @@ Id EmitImageQueryLod(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, I
 Id EmitImageGradient(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id coords,
                     Id derivatives, const IR::Value& offset, Id lod_clamp) {
    const auto info{inst->Flags<IR::TextureInstInfo>()};
-    const TextureDefinition& def{ctx.textures.at(info.descriptor_index)};
-    const Id color_type{TextureColorResultType(ctx, def)};
    const auto operands = info.num_derivatives == 3
                              ? ImageOperands(ctx, info.has_lod_clamp != 0, derivatives,
                                              ctx.Def(offset), {}, lod_clamp)
                              : ImageOperands(ctx, info.has_lod_clamp != 0, derivatives,
                                              info.num_derivatives, offset, lod_clamp);
-    const Id color{Emit(&EmitContext::OpImageSparseSampleExplicitLod,
-                        &EmitContext::OpImageSampleExplicitLod, ctx, inst, color_type,
-                        Texture(ctx, info, index), coords, operands.Mask(), operands.Span())};
-    return TextureSampleResultToFloat(ctx, def, color);
+    return Emit(&EmitContext::OpImageSparseSampleExplicitLod,
+                &EmitContext::OpImageSampleExplicitLod, ctx, inst, ctx.F32[4],
+                Texture(ctx, info, index), coords, operands.Mask(), operands.Span());
 }

 Id EmitImageRead(EmitContext& ctx, IR::Inst* inst, const IR::Value& index, Id coords) {
--- a/src/shader_recompiler/backend/spirv/emit_spirv_warp.cpp
+++ b/src/shader_recompiler/backend/spirv/emit_spirv_warp.cpp
@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -81,25 +78,9 @@ Id AddPartitionBase(EmitContext& ctx, Id thread_id) {
    const Id partition_base{ctx.OpShiftLeftLogical(ctx.U32[1], partition_idx, ctx.Const(5u))};
    return ctx.OpIAdd(ctx.U32[1], thread_id, partition_base);
 }
-
-bool SupportsWarpIntrinsics(const EmitContext& ctx) {
-    return ctx.profile.SupportsWarpIntrinsics(ctx.stage);
-}
-
-void SetAlwaysInBounds(EmitContext& ctx, IR::Inst* inst) {
-    SetInBoundsFlag(inst, ctx.true_value);
-}
-
-Id FallbackBallotMask(EmitContext& ctx, Id pred) {
-    const Id full_mask{ctx.Const(0xFFFFFFFFu)};
-    return ctx.OpSelect(ctx.U32[1], pred, full_mask, ctx.u32_zero_value);
-}
 } // Anonymous namespace

 Id EmitLaneId(EmitContext& ctx) {
-    if (!SupportsWarpIntrinsics(ctx)) {
-        return ctx.u32_zero_value;
-    }
    const Id id{GetThreadId(ctx)};
    if (!ctx.profile.warp_size_potentially_larger_than_guest) {
        return id;
@@ -108,9 +89,6 @@ Id EmitLaneId(EmitContext& ctx) {
 }

 Id EmitVoteAll(EmitContext& ctx, Id pred) {
-    if (!SupportsWarpIntrinsics(ctx)) {
-        return pred;
-    }
    if (!ctx.profile.warp_size_potentially_larger_than_guest) {
        return ctx.OpGroupNonUniformAll(ctx.U1, SubgroupScope(ctx), pred);
    }
@@ -124,9 +102,6 @@ Id EmitVoteAll(EmitContext& ctx, Id pred) {
 }

 Id EmitVoteAny(EmitContext& ctx, Id pred) {
-    if (!SupportsWarpIntrinsics(ctx)) {
-        return pred;
-    }
    if (!ctx.profile.warp_size_potentially_larger_than_guest) {
        return ctx.OpGroupNonUniformAny(ctx.U1, SubgroupScope(ctx), pred);
    }
@@ -140,9 +115,6 @@ Id EmitVoteAny(EmitContext& ctx, Id pred) {
 }

 Id EmitVoteEqual(EmitContext& ctx, Id pred) {
-    if (!SupportsWarpIntrinsics(ctx)) {
-        return pred;
-    }
    if (!ctx.profile.warp_size_potentially_larger_than_guest) {
        return ctx.OpGroupNonUniformAllEqual(ctx.U1, SubgroupScope(ctx), pred);
    }
@@ -157,9 +129,6 @@ Id EmitVoteEqual(EmitContext& ctx, Id pred) {
 }

 Id EmitSubgroupBallot(EmitContext& ctx, Id pred) {
-    if (!SupportsWarpIntrinsics(ctx)) {
-        return FallbackBallotMask(ctx, pred);
-    }
    const Id ballot{ctx.OpGroupNonUniformBallot(ctx.U32[4], SubgroupScope(ctx), pred)};
    if (!ctx.profile.warp_size_potentially_larger_than_guest) {
        return ctx.OpCompositeExtract(ctx.U32[1], ballot, 0U);
@@ -168,46 +137,27 @@ Id EmitSubgroupBallot(EmitContext& ctx, Id pred) {
 }

 Id EmitSubgroupEqMask(EmitContext& ctx) {
-    if (!SupportsWarpIntrinsics(ctx)) {
-        return ctx.u32_zero_value;
-    }
    return LoadMask(ctx, ctx.subgroup_mask_eq);
 }

 Id EmitSubgroupLtMask(EmitContext& ctx) {
-    if (!SupportsWarpIntrinsics(ctx)) {
-        return ctx.u32_zero_value;
-    }
    return LoadMask(ctx, ctx.subgroup_mask_lt);
 }

 Id EmitSubgroupLeMask(EmitContext& ctx) {
-    if (!SupportsWarpIntrinsics(ctx)) {
-        return ctx.u32_zero_value;
-    }
    return LoadMask(ctx, ctx.subgroup_mask_le);
 }

 Id EmitSubgroupGtMask(EmitContext& ctx) {
-    if (!SupportsWarpIntrinsics(ctx)) {
-        return ctx.u32_zero_value;
-    }
    return LoadMask(ctx, ctx.subgroup_mask_gt);
 }

 Id EmitSubgroupGeMask(EmitContext& ctx) {
-    if (!SupportsWarpIntrinsics(ctx)) {
-        return ctx.u32_zero_value;
-    }
    return LoadMask(ctx, ctx.subgroup_mask_ge);
 }

 Id EmitShuffleIndex(EmitContext& ctx, IR::Inst* inst, Id value, Id index, Id clamp,
                    Id segmentation_mask) {
-    if (!SupportsWarpIntrinsics(ctx)) {
-        SetAlwaysInBounds(ctx, inst);
-        return value;
-    }
    const Id not_seg_mask{ctx.OpNot(ctx.U32[1], segmentation_mask)};
    const Id thread_id{EmitLaneId(ctx)};
    const Id min_thread_id{ComputeMinThreadId(ctx, thread_id, segmentation_mask)};
@@ -227,10 +177,6 @@ Id EmitShuffleIndex(EmitContext& ctx, IR::Inst* inst, Id value, Id index, Id cla

 Id EmitShuffleUp(EmitContext& ctx, IR::Inst* inst, Id value, Id index, Id clamp,
                 Id segmentation_mask) {
-    if (!SupportsWarpIntrinsics(ctx)) {
-        SetAlwaysInBounds(ctx, inst);
-        return value;
-    }
    const Id thread_id{EmitLaneId(ctx)};
    const Id max_thread_id{GetMaxThreadId(ctx, thread_id, clamp, segmentation_mask)};
    Id src_thread_id{ctx.OpISub(ctx.U32[1], thread_id, index)};
@@ -246,10 +192,6 @@ Id EmitShuffleUp(EmitContext& ctx, IR::Inst* inst, Id value, Id index, Id clamp,

 Id EmitShuffleDown(EmitContext& ctx, IR::Inst* inst, Id value, Id index, Id clamp,
                   Id segmentation_mask) {
-    if (!SupportsWarpIntrinsics(ctx)) {
-        SetAlwaysInBounds(ctx, inst);
-        return value;
-    }
    const Id thread_id{EmitLaneId(ctx)};
    const Id max_thread_id{GetMaxThreadId(ctx, thread_id, clamp, segmentation_mask)};
    Id src_thread_id{ctx.OpIAdd(ctx.U32[1], thread_id, index)};
@@ -265,10 +207,6 @@ Id EmitShuffleDown(EmitContext& ctx, IR::Inst* inst, Id value, Id index, Id clam

 Id EmitShuffleButterfly(EmitContext& ctx, IR::Inst* inst, Id value, Id index, Id clamp,
                        Id segmentation_mask) {
-    if (!SupportsWarpIntrinsics(ctx)) {
-        SetAlwaysInBounds(ctx, inst);
-        return value;
-    }
    const Id thread_id{EmitLaneId(ctx)};
    const Id max_thread_id{GetMaxThreadId(ctx, thread_id, clamp, segmentation_mask)};
    Id src_thread_id{ctx.OpBitwiseXor(ctx.U32[1], thread_id, index)};
--- a/src/shader_recompiler/backend/spirv/spirv_emit_context.cpp
+++ b/src/shader_recompiler/backend/spirv/spirv_emit_context.cpp
@@ -28,41 +28,27 @@ enum class Operation {
    FPMax,
 };

-Id ComponentScalarType(EmitContext& ctx, SamplerComponentType component_type) {
-    switch (component_type) {
-    case SamplerComponentType::Float:
-    case SamplerComponentType::Depth:
-        return ctx.F32[1];
-    case SamplerComponentType::Sint:
-        return ctx.S32[1];
-    case SamplerComponentType::Stencil:
-        return ctx.U32[1];
-    case SamplerComponentType::Uint:
-        return ctx.U32[1];
-    }
-    throw InvalidArgument("Invalid sampler component type {}", component_type);
-}
-
-Id ImageType(EmitContext& ctx, const TextureDescriptor& desc, Id sampled_type) {
+Id ImageType(EmitContext& ctx, const TextureDescriptor& desc) {
    const spv::ImageFormat format{spv::ImageFormat::Unknown};
+    const Id type{ctx.F32[1]};
    const bool depth{desc.is_depth};
    const bool ms{desc.is_multisample};
    switch (desc.type) {
    case TextureType::Color1D:
-        return ctx.TypeImage(sampled_type, spv::Dim::Dim1D, depth, false, false, 1, format);
+        return ctx.TypeImage(type, spv::Dim::Dim1D, depth, false, false, 1, format);
    case TextureType::ColorArray1D:
-        return ctx.TypeImage(sampled_type, spv::Dim::Dim1D, depth, true, false, 1, format);
+        return ctx.TypeImage(type, spv::Dim::Dim1D, depth, true, false, 1, format);
    case TextureType::Color2D:
    case TextureType::Color2DRect:
-        return ctx.TypeImage(sampled_type, spv::Dim::Dim2D, depth, false, ms, 1, format);
+        return ctx.TypeImage(type, spv::Dim::Dim2D, depth, false, ms, 1, format);
    case TextureType::ColorArray2D:
-        return ctx.TypeImage(sampled_type, spv::Dim::Dim2D, depth, true, ms, 1, format);
+        return ctx.TypeImage(type, spv::Dim::Dim2D, depth, true, ms, 1, format);
    case TextureType::Color3D:
-        return ctx.TypeImage(sampled_type, spv::Dim::Dim3D, depth, false, false, 1, format);
+        return ctx.TypeImage(type, spv::Dim::Dim3D, depth, false, false, 1, format);
    case TextureType::ColorCube:
-        return ctx.TypeImage(sampled_type, spv::Dim::Cube, depth, false, false, 1, format);
+        return ctx.TypeImage(type, spv::Dim::Cube, depth, false, false, 1, format);
    case TextureType::ColorArrayCube:
-        return ctx.TypeImage(sampled_type, spv::Dim::Cube, depth, true, false, 1, format);
+        return ctx.TypeImage(type, spv::Dim::Cube, depth, true, false, 1, format);
    case TextureType::Buffer:
        break;
    }
@@ -329,9 +315,6 @@ void DefineSsbos(EmitContext& ctx, StorageTypeDefinition& type_def,
        ctx.Decorate(id, spv::Decoration::Binding, binding);
        ctx.Decorate(id, spv::Decoration::DescriptorSet, 0U);
        ctx.Name(id, fmt::format("ssbo{}", index));
-        if (!desc.is_written) {
-            ctx.Decorate(id, spv::Decoration::NonWritable);
-        }
        if (ctx.profile.supported_spirv >= 0x00010400) {
            ctx.interfaces.push_back(id);
        }
@@ -563,7 +546,6 @@ void EmitContext::DefineCommonTypes(const Info& info) {

    output_f32 = Name(TypePointer(spv::StorageClass::Output, F32[1]), "output_f32");
    output_u32 = Name(TypePointer(spv::StorageClass::Output, U32[1]), "output_u32");
-    output_s32 = Name(TypePointer(spv::StorageClass::Output, S32[1]), "output_s32");

    if (info.uses_int8 && profile.support_int8) {
        AddCapability(spv::Capability::Int8);
@@ -1377,8 +1359,7 @@ void EmitContext::DefineImageBuffers(const Info& info, u32& binding) {
 void EmitContext::DefineTextures(const Info& info, u32& binding, u32& scaling_index) {
    textures.reserve(info.texture_descriptors.size());
    for (const TextureDescriptor& desc : info.texture_descriptors) {
-        const Id result_type{ComponentScalarType(*this, desc.component_type)};
-        const Id image_type{ImageType(*this, desc, result_type)};
+        const Id image_type{ImageType(*this, desc)};
        const Id sampled_type{TypeSampledImage(image_type)};
        const Id pointer_type{TypePointer(spv::StorageClass::UniformConstant, sampled_type)};
        const Id desc_type{DescType(*this, sampled_type, pointer_type, desc.count)};
@@ -1391,10 +1372,8 @@ void EmitContext::DefineTextures(const Info& info, u32& binding, u32& scaling_in
            .sampled_type = sampled_type,
            .pointer_type = pointer_type,
            .image_type = image_type,
-            .result_type = result_type,
            .count = desc.count,
            .is_multisample = desc.is_multisample,
-            .component_type = desc.component_type,
        });
        if (profile.supported_spirv >= 0x00010400) {
            interfaces.push_back(id);
@@ -1437,7 +1416,6 @@ void EmitContext::DefineImages(const Info& info, u32& binding, u32& scaling_inde
 void EmitContext::DefineInputs(const IR::Program& program) {
    const Info& info{program.info};
    const VaryingState loads{info.loads.mask | info.passthrough.mask};
-    const bool stage_supports_warp = profile.SupportsWarpIntrinsics(stage);

    if (info.uses_workgroup_id) {
        workgroup_id = DefineInput(*this, U32[3], false, spv::BuiltIn::WorkgroupId);
@@ -1454,37 +1432,24 @@ void EmitContext::DefineInputs(const IR::Program& program) {
    }
    if (info.uses_sample_id) {
        sample_id = DefineInput(*this, U32[1], false, spv::BuiltIn::SampleId);
-        if (stage == Stage::Fragment) {
-            Decorate(sample_id, spv::Decoration::Flat);
-        }
    }
    if (info.uses_is_helper_invocation) {
        is_helper_invocation = DefineInput(*this, U1, false, spv::BuiltIn::HelperInvocation);
    }
-    if (info.uses_subgroup_mask && stage_supports_warp) {
+    if (info.uses_subgroup_mask) {
        subgroup_mask_eq = DefineInput(*this, U32[4], false, spv::BuiltIn::SubgroupEqMaskKHR);
        subgroup_mask_lt = DefineInput(*this, U32[4], false, spv::BuiltIn::SubgroupLtMaskKHR);
        subgroup_mask_le = DefineInput(*this, U32[4], false, spv::BuiltIn::SubgroupLeMaskKHR);
        subgroup_mask_gt = DefineInput(*this, U32[4], false, spv::BuiltIn::SubgroupGtMaskKHR);
        subgroup_mask_ge = DefineInput(*this, U32[4], false, spv::BuiltIn::SubgroupGeMaskKHR);
-        if (stage == Stage::Fragment) {
-            Decorate(subgroup_mask_eq, spv::Decoration::Flat);
-            Decorate(subgroup_mask_lt, spv::Decoration::Flat);
-            Decorate(subgroup_mask_le, spv::Decoration::Flat);
-            Decorate(subgroup_mask_gt, spv::Decoration::Flat);
-            Decorate(subgroup_mask_ge, spv::Decoration::Flat);
-        }
    }
-    if (stage_supports_warp &&
-        (info.uses_fswzadd || info.uses_subgroup_invocation_id || info.uses_subgroup_shuffles ||
-         (profile.warp_size_potentially_larger_than_guest &&
-          (info.uses_subgroup_vote || info.uses_subgroup_mask)))) {
+    if (info.uses_fswzadd || info.uses_subgroup_invocation_id || info.uses_subgroup_shuffles ||
+        (profile.warp_size_potentially_larger_than_guest &&
+         (info.uses_subgroup_vote || info.uses_subgroup_mask))) {
        AddCapability(spv::Capability::GroupNonUniform);
        subgroup_local_invocation_id =
            DefineInput(*this, U32[1], false, spv::BuiltIn::SubgroupLocalInvocationId);
-        if (stage == Stage::Fragment) {
-            Decorate(subgroup_local_invocation_id, spv::Decoration::Flat);
-        }
+        Decorate(subgroup_local_invocation_id, spv::Decoration::Flat);
    }
    if (info.uses_fswzadd) {
        const Id f32_one{Const(1.0f)};
@@ -1496,9 +1461,6 @@ void EmitContext::DefineInputs(const IR::Program& program) {
    }
    if (loads[IR::Attribute::PrimitiveId]) {
        primitive_id = DefineInput(*this, U32[1], false, spv::BuiltIn::PrimitiveId);
-        if (stage == Stage::Fragment) {
-            Decorate(primitive_id, spv::Decoration::Flat);
-        }
    }
    if (loads[IR::Attribute::Layer]) {
        AddCapability(spv::Capability::Geometry);
@@ -1590,21 +1552,17 @@ void EmitContext::DefineInputs(const IR::Program& program) {
        if (stage != Stage::Fragment) {
            continue;
        }
-        const bool is_integer = input_type == AttributeType::SignedInt ||
-                                input_type == AttributeType::UnsignedInt;
-        if (is_integer) {
+        switch (info.interpolation[index]) {
+        case Interpolation::Smooth:
+            // Default
+            // Decorate(id, spv::Decoration::Smooth);
+            break;
+        case Interpolation::NoPerspective:
+            Decorate(id, spv::Decoration::NoPerspective);
+            break;
+        case Interpolation::Flat:
            Decorate(id, spv::Decoration::Flat);
-        } else {
-            switch (info.interpolation[index]) {
-            case Interpolation::Smooth:
-                break;
-            case Interpolation::NoPerspective:
-                Decorate(id, spv::Decoration::NoPerspective);
-                break;
-            case Interpolation::Flat:
-                Decorate(id, spv::Decoration::Flat);
-                break;
-            }
+            break;
        }
    }
    if (stage == Stage::TessellationEval) {
@@ -1700,18 +1658,7 @@ void EmitContext::DefineOutputs(const IR::Program& program) {
            if (!info.stores_frag_color[index] && !profile.need_declared_frag_colors) {
                continue;
            }
-            const AttributeType output_type{runtime_info.color_output_types[index]};
-            const Id vec_type = [&, output_type]() -> Id {
-                switch (output_type) {
-                case AttributeType::SignedInt:
-                    return S32[4];
-                case AttributeType::UnsignedInt:
-                    return U32[4];
-                default:
-                    return F32[4];
-                }
-            }();
-            frag_color[index] = DefineOutput(*this, vec_type, std::nullopt);
+            frag_color[index] = DefineOutput(*this, F32[4], std::nullopt);
            Decorate(frag_color[index], spv::Decoration::Location, index);
            Name(frag_color[index], fmt::format("frag_color{}", index));
        }
--- a/src/shader_recompiler/backend/spirv/spirv_emit_context.h
+++ b/src/shader_recompiler/backend/spirv/spirv_emit_context.h
@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -39,10 +36,8 @@ struct TextureDefinition {
    Id sampled_type;
    Id pointer_type;
    Id image_type;
-    Id result_type;
    u32 count;
    bool is_multisample;
-    SamplerComponentType component_type;
 };

 struct TextureBufferDefinition {
@@ -249,7 +244,6 @@ public:

    Id output_f32{};
    Id output_u32{};
-    Id output_s32{};

    Id image_buffer_type{};
    Id image_u32{};
--- a/src/shader_recompiler/environment.h
+++ b/src/shader_recompiler/environment.h
@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -25,8 +22,6 @@ public:

    [[nodiscard]] virtual TextureType ReadTextureType(u32 raw_handle) = 0;

-    [[nodiscard]] virtual SamplerComponentType ReadTextureComponentType(u32 raw_handle) = 0;
-
    [[nodiscard]] virtual TexturePixelFormat ReadTexturePixelFormat(u32 raw_handle) = 0;

    [[nodiscard]] virtual bool IsTexturePixelFormatInteger(u32 raw_handle) = 0;
--- a/src/shader_recompiler/ir_opt/texture_pass.cpp
+++ b/src/shader_recompiler/ir_opt/texture_pass.cpp
@@ -396,10 +396,6 @@ bool IsTexturePixelFormatInteger(Environment& env, const ConstBufferAddr& cbuf)
    return env.IsTexturePixelFormatInteger(GetTextureHandle(env, cbuf));
 }

-SamplerComponentType ReadTextureComponentType(Environment& env, const ConstBufferAddr& cbuf) {
-    return env.ReadTextureComponentType(GetTextureHandle(env, cbuf));
-}
-
 class Descriptors {
 public:
    explicit Descriptors(TextureBufferDescriptors& texture_buffer_descriptors_,
@@ -437,9 +433,7 @@ public:

    u32 Add(const TextureDescriptor& desc) {
        const u32 index{Add(texture_descriptors, desc, [&desc](const auto& existing) {
-            return desc.type == existing.type &&
-                   desc.component_type == existing.component_type &&
-                   desc.is_depth == existing.is_depth &&
+            return desc.type == existing.type && desc.is_depth == existing.is_depth &&
                   desc.has_secondary == existing.has_secondary &&
                   desc.cbuf_index == existing.cbuf_index &&
                   desc.cbuf_offset == existing.cbuf_offset &&
@@ -672,12 +666,10 @@ void TexturePass(Environment& env, IR::Program& program, const HostTranslateInfo
                    .secondary_shift_left = cbuf.secondary_shift_left,
                    .count = cbuf.count,
                    .size_shift = DESCRIPTOR_SIZE_SHIFT,
-                    .component_type = ReadTextureComponentType(env, cbuf),
                });
            } else {
                index = descriptors.Add(TextureDescriptor{
                    .type = flags.type,
-                    .component_type = ReadTextureComponentType(env, cbuf),
                    .is_depth = flags.is_depth != 0,
                    .is_multisample = is_multisample,
                    .has_secondary = cbuf.has_secondary,
--- a/src/shader_recompiler/profile.h
+++ b/src/shader_recompiler/profile.h
@@ -1,15 +1,9 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

 #pragma once

-#include <limits>
-
 #include "common/common_types.h"
-#include "shader_recompiler/stage.h"

 namespace Shader {

@@ -52,8 +46,6 @@ struct Profile {
    bool support_multi_viewport{};
    bool support_geometry_streams{};

-    u32 warp_stage_support_mask{std::numeric_limits<u32>::max()};
-
    bool warp_size_potentially_larger_than_guest{};

    bool lower_left_origin_mode{};
@@ -98,11 +90,6 @@ struct Profile {
    u64 min_ssbo_alignment{};

    u32 max_user_clip_distances{};
-
-    bool SupportsWarpIntrinsics(Stage stage) const {
-        const u32 bit = 1u << static_cast<u32>(stage);
-        return (warp_stage_support_mask & bit) != 0;
-    }
 };

 } // namespace Shader
--- a/src/shader_recompiler/runtime_info.h
+++ b/src/shader_recompiler/runtime_info.h
@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -83,7 +80,6 @@ struct TransformFeedbackVarying {

 struct RuntimeInfo {
    std::array<AttributeType, 32> generic_input_types{};
-    std::array<AttributeType, 8> color_output_types{};
    VaryingState previous_stage_stores;
    std::map<IR::Attribute, IR::Attribute> previous_stage_legacy_stores_mapping;

--- a/src/shader_recompiler/shader_info.h
+++ b/src/shader_recompiler/shader_info.h
@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -154,14 +151,6 @@ enum class ImageFormat : u32 {
    R32G32B32A32_UINT,
 };

-enum class SamplerComponentType : u8 {
-    Float,
-    Sint,
-    Uint,
-    Depth,
-    Stencil,
-};
-
 enum class Interpolation {
    Smooth,
    Flat,
@@ -194,7 +183,6 @@ struct TextureBufferDescriptor {
    u32 secondary_shift_left;
    u32 count;
    u32 size_shift;
-    SamplerComponentType component_type;

    auto operator<=>(const TextureBufferDescriptor&) const = default;
 };
@@ -216,7 +204,6 @@ using ImageBufferDescriptors = boost::container::small_vector<ImageBufferDescrip

 struct TextureDescriptor {
    TextureType type;
-    SamplerComponentType component_type;
    bool is_depth;
    bool is_multisample;
    bool has_secondary;
--- a/src/video_core/buffer_cache/buffer_cache.h
+++ b/src/video_core/buffer_cache/buffer_cache.h
@@ -407,12 +407,6 @@ void BufferCache<P>::SetComputeUniformBufferState(u32 mask,

 template <class P>
 void BufferCache<P>::UnbindGraphicsStorageBuffers(size_t stage) {
-    if constexpr (requires { runtime.ShouldLimitDynamicStorageBuffers(); }) {
-        if (runtime.ShouldLimitDynamicStorageBuffers()) {
-            channel_state->total_graphics_storage_buffers -=
-                static_cast<u32>(std::popcount(channel_state->enabled_storage_buffers[stage]));
-        }
-    }
    channel_state->enabled_storage_buffers[stage] = 0;
    channel_state->written_storage_buffers[stage] = 0;
 }
@@ -420,26 +414,8 @@ void BufferCache<P>::UnbindGraphicsStorageBuffers(size_t stage) {
 template <class P>
 bool BufferCache<P>::BindGraphicsStorageBuffer(size_t stage, size_t ssbo_index, u32 cbuf_index,
                                               u32 cbuf_offset, bool is_written) {
-    const bool already_enabled =
-        ((channel_state->enabled_storage_buffers[stage] >> ssbo_index) & 1U) != 0;
-    if constexpr (requires { runtime.ShouldLimitDynamicStorageBuffers(); }) {
-        if (runtime.ShouldLimitDynamicStorageBuffers() && !already_enabled) {
-            const u32 max_bindings = runtime.GetMaxDynamicStorageBuffers();
-            if (channel_state->total_graphics_storage_buffers >= max_bindings) {
-                LOG_WARNING(HW_GPU,
-                            "Skipping graphics storage buffer {} due to driver limit {}",
-                            ssbo_index, max_bindings);
-                return false;
-            }
-        }
-    }
    channel_state->enabled_storage_buffers[stage] |= 1U << ssbo_index;
    channel_state->written_storage_buffers[stage] |= (is_written ? 1U : 0U) << ssbo_index;
-    if constexpr (requires { runtime.ShouldLimitDynamicStorageBuffers(); }) {
-        if (runtime.ShouldLimitDynamicStorageBuffers() && !already_enabled) {
-            ++channel_state->total_graphics_storage_buffers;
-        }
-    }

    const auto& cbufs = maxwell3d->state.shader_stages[stage];
    const GPUVAddr ssbo_addr = cbufs.const_buffers[cbuf_index].address + cbuf_offset;
@@ -470,12 +446,6 @@ void BufferCache<P>::BindGraphicsTextureBuffer(size_t stage, size_t tbo_index, G

 template <class P>
 void BufferCache<P>::UnbindComputeStorageBuffers() {
-    if constexpr (requires { runtime.ShouldLimitDynamicStorageBuffers(); }) {
-        if (runtime.ShouldLimitDynamicStorageBuffers()) {
-            channel_state->total_compute_storage_buffers -=
-                static_cast<u32>(std::popcount(channel_state->enabled_compute_storage_buffers));
-        }
-    }
    channel_state->enabled_compute_storage_buffers = 0;
    channel_state->written_compute_storage_buffers = 0;
    channel_state->image_compute_texture_buffers = 0;
@@ -489,26 +459,8 @@ void BufferCache<P>::BindComputeStorageBuffer(size_t ssbo_index, u32 cbuf_index,
                  ssbo_index);
        return;
    }
-    const bool already_enabled =
-        ((channel_state->enabled_compute_storage_buffers >> ssbo_index) & 1U) != 0;
-    if constexpr (requires { runtime.ShouldLimitDynamicStorageBuffers(); }) {
-        if (runtime.ShouldLimitDynamicStorageBuffers() && !already_enabled) {
-            const u32 max_bindings = runtime.GetMaxDynamicStorageBuffers();
-            if (channel_state->total_compute_storage_buffers >= max_bindings) {
-                LOG_WARNING(HW_GPU,
-                            "Skipping compute storage buffer {} due to driver limit {}",
-                            ssbo_index, max_bindings);
-                return;
-            }
-        }
-    }
    channel_state->enabled_compute_storage_buffers |= 1U << ssbo_index;
    channel_state->written_compute_storage_buffers |= (is_written ? 1U : 0U) << ssbo_index;
-    if constexpr (requires { runtime.ShouldLimitDynamicStorageBuffers(); }) {
-        if (runtime.ShouldLimitDynamicStorageBuffers() && !already_enabled) {
-            ++channel_state->total_compute_storage_buffers;
-        }
-    }

    const auto& launch_desc = kepler_compute->launch_description;
    if (((launch_desc.const_buffer_enable_mask >> cbuf_index) & 1) == 0) {
@@ -841,23 +793,9 @@ void BufferCache<P>::BindHostGraphicsUniformBuffer(size_t stage, u32 index, u32
    const u32 size = (std::min)(binding.size, (*channel_state->uniform_buffer_sizes)[stage][index]);
    Buffer& buffer = slot_buffers[binding.buffer_id];
    TouchBuffer(buffer, binding.buffer_id);
-    const bool has_host_buffer = binding.buffer_id != NULL_BUFFER_ID;
-    const u32 offset = has_host_buffer ? buffer.Offset(device_addr) : 0;
-    const bool needs_alignment_stream = [&]() {
-        if constexpr (IS_OPENGL) {
-            return false;
-        } else {
-            if (!has_host_buffer) {
-                return false;
-            }
-            const u32 alignment = runtime.GetUniformBufferAlignment();
-            return alignment > 1 && (offset % alignment) != 0;
-        }
-    }();
-    const bool use_fast_buffer = needs_alignment_stream ||
-                                 (has_host_buffer &&
-                                  size <= channel_state->uniform_buffer_skip_cache_size &&
-                                  !memory_tracker.IsRegionGpuModified(device_addr, size));
+    const bool use_fast_buffer = binding.buffer_id != NULL_BUFFER_ID &&
+                                 size <= channel_state->uniform_buffer_skip_cache_size &&
+                                 !memory_tracker.IsRegionGpuModified(device_addr, size);
    if (use_fast_buffer) {
        if constexpr (IS_OPENGL) {
            if (runtime.HasFastBufferSubData()) {
@@ -896,6 +834,7 @@ void BufferCache<P>::BindHostGraphicsUniformBuffer(size_t stage, u32 index, u32
    if (!needs_bind) {
        return;
    }
+    const u32 offset = buffer.Offset(device_addr);
    if constexpr (IS_OPENGL) {
        // Mark the index as dirty if offset doesn't match
        const bool is_copy_bind = offset != 0 && !runtime.SupportsNonZeroUniformOffset();
@@ -1012,30 +951,9 @@ void BufferCache<P>::BindHostComputeUniformBuffers() {
        TouchBuffer(buffer, binding.buffer_id);
        const u32 size =
            (std::min)(binding.size, (*channel_state->compute_uniform_buffer_sizes)[index]);
-        const bool has_host_buffer = binding.buffer_id != NULL_BUFFER_ID;
-        const u32 offset = has_host_buffer ? buffer.Offset(binding.device_addr) : 0;
-        const bool needs_alignment_stream = [&]() {
-            if constexpr (IS_OPENGL) {
-                return false;
-            } else {
-                if (!has_host_buffer) {
-                    return false;
-                }
-                const u32 alignment = runtime.GetUniformBufferAlignment();
-                return alignment > 1 && (offset % alignment) != 0;
-            }
-        }();
-        if constexpr (!IS_OPENGL) {
-            if (needs_alignment_stream) {
-                const std::span<u8> span =
-                    runtime.BindMappedUniformBuffer(0, binding_index, size);
-                device_memory.ReadBlockUnsafe(binding.device_addr, span.data(), size);
-                return;
-            }
-        }
-
        SynchronizeBuffer(buffer, binding.device_addr, size);

+        const u32 offset = buffer.Offset(binding.device_addr);
        buffer.MarkUsage(offset, size);
        if constexpr (NEEDS_BIND_UNIFORM_INDEX) {
            runtime.BindComputeUniformBuffer(binding_index, buffer, offset, size);
@@ -1787,21 +1705,26 @@ 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;
-        // The NVN driver buffer (index 0) is known to pack the SSBO address followed by its size.
        if (is_nvn_cbuf) {
-            const u32 ssbo_size = gpu_memory->Read<u32>(ssbo_addr + 8);
-            if (ssbo_size != 0) {
-                return ssbo_size;
+            // * 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
            }
        }
-        // Other titles (notably Doom Eternal) may use STG/LDG on buffer addresses in custom defined
-        // cbufs, which do not store the sizes adjacent to the addresses, so use the fully
-        // mapped buffer size for now.
+        // 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));
    }();
+
    // Alignment only applies to the offset of the buffer
    const u32 alignment = runtime.GetStorageBufferAlignment();
    const GPUVAddr aligned_gpu_addr = Common::AlignDown(gpu_addr, alignment);
--- a/src/video_core/buffer_cache/buffer_cache_base.h
+++ b/src/video_core/buffer_cache/buffer_cache_base.h
@@ -8,7 +8,6 @@

 #include <algorithm>
 #include <array>
-#include <bit>
 #include <functional>
 #include <memory>
 #include <mutex>
@@ -133,9 +132,6 @@ public:
    u32 enabled_compute_storage_buffers = 0;
    u32 written_compute_storage_buffers = 0;

-    u32 total_graphics_storage_buffers = 0;
-    u32 total_compute_storage_buffers = 0;
-
    std::array<u32, NUM_STAGES> enabled_texture_buffers{};
    std::array<u32, NUM_STAGES> written_texture_buffers{};
    std::array<u32, NUM_STAGES> image_texture_buffers{};
--- a/src/video_core/compatible_formats.cpp
+++ b/src/video_core/compatible_formats.cpp
@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -238,9 +235,6 @@ constexpr Table MakeViewTable() {
    EnableRange(view, VIEW_CLASS_ASTC_10x10_RGBA);
    EnableRange(view, VIEW_CLASS_ASTC_12x10_RGBA);
    EnableRange(view, VIEW_CLASS_ASTC_12x12_RGBA);
-    Enable(view, PixelFormat::D24_UNORM_S8_UINT, PixelFormat::S8_UINT);
-    Enable(view, PixelFormat::S8_UINT_D24_UNORM, PixelFormat::S8_UINT);
-    Enable(view, PixelFormat::D32_FLOAT_S8_UINT, PixelFormat::S8_UINT);
    return view;
 }

--- a/src/video_core/control/scheduler.cpp
+++ b/src/video_core/control/scheduler.cpp
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later

@@ -17,7 +20,7 @@ void Scheduler::Push(s32 channel, CommandList&& entries) {
    std::unique_lock lk(scheduling_guard);
    auto it = channels.find(channel);
    ASSERT(it != channels.end());
-    auto channel_state = it->second;
+    auto& channel_state = it->second;
    gpu.BindChannel(channel_state->bind_id);
    channel_state->dma_pusher->Push(std::move(entries));
    channel_state->dma_pusher->DispatchCalls();
--- a/src/video_core/dma_pusher.cpp
+++ b/src/video_core/dma_pusher.cpp
@@ -43,66 +43,90 @@ void DmaPusher::DispatchCalls() {

 bool DmaPusher::Step() {
    if (!ib_enable || dma_pushbuffer.empty()) {
+        // pushbuffer empty and IB empty or nonexistent - nothing to do
        return false;
    }

-    CommandList& command_list = dma_pushbuffer.front();
+    CommandList& command_list{dma_pushbuffer.front()};

-    const size_t prefetch_size = command_list.prefetch_command_list.size();
-    const size_t command_list_size = command_list.command_lists.size();
+    ASSERT_OR_EXECUTE(
+        command_list.command_lists.size() || command_list.prefetch_command_list.size(), {
+            // Somehow the command_list is empty, in order to avoid a crash
+            // We ignore it and assume its size is 0.
+            dma_pushbuffer.pop();
+            dma_pushbuffer_subindex = 0;
+            return true;
+        });

-    if (prefetch_size == 0 && command_list_size == 0) {
+    if (command_list.prefetch_command_list.size()) {
+        // Prefetched command list from nvdrv, used for things like synchronization
+        ProcessCommands(VideoCommon::FixSmallVectorADL(command_list.prefetch_command_list));
        dma_pushbuffer.pop();
-        dma_pushbuffer_subindex = 0;
-        return true;
-    }
-
-    if (prefetch_size > 0) {
-        ProcessCommands(command_list.prefetch_command_list);
-        dma_pushbuffer.pop();
-        return true;
-    }
-
-    auto& current_command = command_list.command_lists[dma_pushbuffer_subindex];
-    const CommandListHeader& header = current_command;
-    dma_state.dma_get = header.addr;
-
-    if (signal_sync && !synced) {
-        std::unique_lock lk(sync_mutex);
-        sync_cv.wait(lk, [this]() { return synced; });
-        signal_sync = false;
-        synced = false;
-    }
-
-    if (header.size > 0 && dma_state.method >= MacroRegistersStart && subchannels[dma_state.subchannel]) {
-        subchannels[dma_state.subchannel]->current_dirty = memory_manager.IsMemoryDirty(dma_state.dma_get, header.size * sizeof(u32));
-    }
-
-    if (header.size > 0) {
-        if (Settings::IsDMALevelDefault() ? (Settings::IsGPULevelMedium() || Settings::IsGPULevelHigh()) : Settings::IsDMALevelSafe()) {
-            Tegra::Memory::GpuGuestMemory<Tegra::CommandHeader, Tegra::Memory::GuestMemoryFlags::SafeRead>headers(memory_manager, dma_state.dma_get, header.size, &command_headers);
-            ProcessCommands(headers);
-        } else {
-            Tegra::Memory::GpuGuestMemory<Tegra::CommandHeader, Tegra::Memory::GuestMemoryFlags::UnsafeRead>headers(memory_manager, dma_state.dma_get, header.size, &command_headers);
-            ProcessCommands(headers);
-        }
-    }
-
-    if (++dma_pushbuffer_subindex >= command_list_size) {
-        dma_pushbuffer.pop();
-        dma_pushbuffer_subindex = 0;
    } else {
-        signal_sync = command_list.command_lists[dma_pushbuffer_subindex].sync && Settings::values.sync_memory_operations.GetValue();
-    }
+        const CommandListHeader command_list_header{
+            command_list.command_lists[dma_pushbuffer_subindex++]};

-    if (signal_sync) {
-        rasterizer->SignalFence([this]() {
+        if (signal_sync) {
+            std::unique_lock lk(sync_mutex);
+            sync_cv.wait(lk, [this]() { return synced; });
+            signal_sync = false;
+            synced = false;
+        }
+
+        dma_state.dma_get = command_list_header.addr;
+
+        if (command_list_header.size == 0) {
+            return true;
+        }
+
+        // Push buffer non-empty, read a word
+        if (dma_state.method >= MacroRegistersStart) {
+            if (subchannels[dma_state.subchannel]) {
+                subchannels[dma_state.subchannel]->current_dirty = memory_manager.IsMemoryDirty(
+                    dma_state.dma_get, command_list_header.size * sizeof(u32));
+            }
+        }
+
+        const auto safe_process = [&] {
+            Tegra::Memory::GpuGuestMemory<Tegra::CommandHeader,
+                                          Tegra::Memory::GuestMemoryFlags::SafeRead>
+                headers(memory_manager, dma_state.dma_get, command_list_header.size,
+                        &command_headers);
+            ProcessCommands(headers);
+        };
+
+        const auto unsafe_process = [&] {
+            Tegra::Memory::GpuGuestMemory<Tegra::CommandHeader,
+                                          Tegra::Memory::GuestMemoryFlags::UnsafeRead>
+                headers(memory_manager, dma_state.dma_get, command_list_header.size,
+                        &command_headers);
+            ProcessCommands(headers);
+        };
+
+        const bool use_safe = Settings::IsDMALevelDefault() ? (Settings::IsGPULevelMedium() || Settings::IsGPULevelHigh()) : Settings::IsDMALevelSafe();
+
+        if (use_safe) {
+            safe_process();
+        } else {
+            unsafe_process();
+        }
+
+        if (dma_pushbuffer_subindex >= command_list.command_lists.size()) {
+            // We've gone through the current list, remove it from the queue
+            dma_pushbuffer.pop();
+            dma_pushbuffer_subindex = 0;
+        } else if (command_list.command_lists[dma_pushbuffer_subindex].sync && Settings::values.sync_memory_operations.GetValue()) {
+            signal_sync = true;
+        }
+
+        if (signal_sync) {
+            rasterizer->SignalFence([this]() {
            std::scoped_lock lk(sync_mutex);
            synced = true;
            sync_cv.notify_all();
-        });
+            });
+        }
    }
-
    return true;
 }

--- a/src/video_core/fence_manager.h
+++ b/src/video_core/fence_manager.h
@@ -91,10 +91,6 @@ public:
            uncommitted_operations.clear();
        }
        QueueFence(new_fence);
-        //if (!new_fence->IsStubbed()) {
-        //    std::scoped_lock lock{texture_cache.mutex};
-        //    texture_cache.CommitPendingGpuAccesses(new_fence->WaitTick());
-        //}
        fences.push(std::move(new_fence));
        if (should_flush) {
            rasterizer.FlushCommands();
@@ -183,7 +179,7 @@ private:
                    return;
                }
            }
-            PopAsyncFlushes(current_fence->WaitTick());
+            PopAsyncFlushes();
            auto operations = std::move(pending_operations.front());
            pending_operations.pop_front();
            for (auto& operation : operations) {
@@ -218,7 +214,7 @@ private:
            if (!current_fence->IsStubbed()) {
                WaitFence(current_fence);
            }
-            PopAsyncFlushes(current_fence->WaitTick());
+            PopAsyncFlushes();
            for (auto& operation : current_operations) {
                operation();
            }
@@ -241,11 +237,10 @@ private:
               query_cache.HasUncommittedFlushes();
    }

-    void PopAsyncFlushes(u64 completed_tick) {
+    void PopAsyncFlushes() {
        {
            std::scoped_lock lock{buffer_cache.mutex, texture_cache.mutex};
            texture_cache.PopAsyncFlushes();
-            texture_cache.CompleteGpuAccesses(completed_tick);
            buffer_cache.PopAsyncFlushes();
        }
        query_cache.PopAsyncFlushes();
--- a/src/video_core/query_cache/query_cache.h
+++ b/src/video_core/query_cache/query_cache.h
@@ -211,12 +211,6 @@ void QueryCacheBase<Traits>::CounterClose(QueryType counter_type) {
    streamer->CloseCounter();
 }

-template <typename Traits>
-bool QueryCacheBase<Traits>::HasStreamer(QueryType counter_type) const {
-    const size_t index = static_cast<size_t>(counter_type);
-    return impl->streamers[index] != nullptr;
-}
-
 template <typename Traits>
 void QueryCacheBase<Traits>::CounterReset(QueryType counter_type) {
    size_t index = static_cast<size_t>(counter_type);
--- a/src/video_core/query_cache/query_cache_base.h
+++ b/src/video_core/query_cache/query_cache_base.h
@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later

@@ -95,8 +92,6 @@ public:

    void CounterReset(QueryType counter_type);

-    [[nodiscard]] bool HasStreamer(QueryType counter_type) const;
-
    void CounterClose(QueryType counter_type);

    void CounterReport(GPUVAddr addr, QueryType counter_type, QueryPropertiesFlags flags,
--- a/src/video_core/renderer_opengl/gl_buffer_cache.h
+++ b/src/video_core/renderer_opengl/gl_buffer_cache.h
@@ -198,10 +198,6 @@ public:
        return device.CanReportMemoryUsage();
    }

-    u32 GetUniformBufferAlignment() const {
-        return static_cast<u32>(device.GetUniformBufferAlignment());
-    }
-
    u32 GetStorageBufferAlignment() const {
        return static_cast<u32>(device.GetShaderStorageBufferAlignment());
    }
--- a/src/video_core/renderer_opengl/gl_compute_pipeline.cpp
+++ b/src/video_core/renderer_opengl/gl_compute_pipeline.cpp
@@ -7,50 +7,13 @@
 #include <cstring>
 #include <bit>
 #include <numeric>
-#include <optional>
 #include "common/cityhash.h"
 #include "common/settings.h" // for enum class Settings::ShaderBackend
 #include "video_core/renderer_opengl/gl_compute_pipeline.h"
 #include "video_core/renderer_opengl/gl_shader_manager.h"
 #include "video_core/renderer_opengl/gl_shader_util.h"
-#include "video_core/surface.h"

 namespace OpenGL {
-namespace {
-
-std::optional<VideoCore::Surface::PixelFormatNumeric>
-NumericFromComponentType(Shader::SamplerComponentType component_type) {
-    using VideoCore::Surface::PixelFormatNumeric;
-    switch (component_type) {
-    case Shader::SamplerComponentType::Float:
-        return PixelFormatNumeric::Float;
-    case Shader::SamplerComponentType::Sint:
-        return PixelFormatNumeric::Sint;
-    case Shader::SamplerComponentType::Uint:
-        return PixelFormatNumeric::Uint;
-    default:
-        return std::nullopt;
-    }
-}
-
-VideoCore::Surface::PixelFormat ResolveTexelBufferFormat(
-    VideoCore::Surface::PixelFormat format, Shader::SamplerComponentType component_type) {
-    const auto desired_numeric = NumericFromComponentType(component_type);
-    if (!desired_numeric) {
-        return format;
-    }
-    const auto current_numeric = VideoCore::Surface::GetPixelFormatNumericType(format);
-    if (*desired_numeric == current_numeric) {
-        return format;
-    }
-    if (const auto variant =
-            VideoCore::Surface::FindPixelFormatVariant(format, *desired_numeric)) {
-        return *variant;
-    }
-    return format;
-}
-
-} // Anonymous namespace

 using Shader::ImageBufferDescriptor;
 using Tegra::Texture::TexturePair;
@@ -211,12 +174,8 @@ void ComputePipeline::Configure() {
                is_written = desc.is_written;
            }
            ImageView& image_view{texture_cache.GetImageView(views[texbuf_index].id)};
-            auto buffer_format = image_view.format;
-            if constexpr (!is_image) {
-                buffer_format = ResolveTexelBufferFormat(buffer_format, desc.component_type);
-            }
            buffer_cache.BindComputeTextureBuffer(texbuf_index, image_view.GpuAddr(),
-                                                  image_view.BufferSize(), buffer_format,
+                                                  image_view.BufferSize(), image_view.format,
                                                  is_written, is_image);
            ++texbuf_index;
        }
@@ -246,8 +205,7 @@ void ComputePipeline::Configure() {
    for (const auto& desc : info.texture_descriptors) {
        for (u32 index = 0; index < desc.count; ++index) {
            ImageView& image_view{texture_cache.GetImageView((views_it++)->id)};
-            textures[texture_binding] =
-                image_view.SampledView(desc.type, desc.component_type);
+            textures[texture_binding] = image_view.Handle(desc.type);
            if (texture_cache.IsRescaling(image_view)) {
                texture_scaling_mask |= 1u << texture_binding;
            }
--- a/src/video_core/renderer_opengl/gl_fence_manager.h
+++ b/src/video_core/renderer_opengl/gl_fence_manager.h
@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -28,10 +25,6 @@ public:

    void Wait();

-    [[nodiscard]] u64 WaitTick() const noexcept {
-        return 0;
-    }
-
 private:
    OGLSync sync_object;
 };
--- a/src/video_core/renderer_opengl/gl_graphics_pipeline.cpp
+++ b/src/video_core/renderer_opengl/gl_graphics_pipeline.cpp
@@ -6,7 +6,6 @@

 #include <algorithm>
 #include <array>
-#include <optional>
 #include <string>
 #include <vector>
 #include <bit>
@@ -19,7 +18,6 @@
 #include "video_core/renderer_opengl/gl_shader_util.h"
 #include "video_core/renderer_opengl/gl_state_tracker.h"
 #include "video_core/shader_notify.h"
-#include "video_core/surface.h"
 #include "video_core/texture_cache/texture_cache.h"

 #if defined(_MSC_VER) && defined(NDEBUG)
@@ -41,38 +39,6 @@ using VideoCommon::ImageId;
 constexpr u32 MAX_TEXTURES = 64;
 constexpr u32 MAX_IMAGES = 8;

-std::optional<VideoCore::Surface::PixelFormatNumeric>
-NumericFromComponentType(Shader::SamplerComponentType component_type) {
-    using VideoCore::Surface::PixelFormatNumeric;
-    switch (component_type) {
-    case Shader::SamplerComponentType::Float:
-        return PixelFormatNumeric::Float;
-    case Shader::SamplerComponentType::Sint:
-        return PixelFormatNumeric::Sint;
-    case Shader::SamplerComponentType::Uint:
-        return PixelFormatNumeric::Uint;
-    default:
-        return std::nullopt;
-    }
-}
-
-VideoCore::Surface::PixelFormat ResolveTexelBufferFormat(
-    VideoCore::Surface::PixelFormat format, Shader::SamplerComponentType component_type) {
-    const auto desired_numeric = NumericFromComponentType(component_type);
-    if (!desired_numeric) {
-        return format;
-    }
-    const auto current_numeric = VideoCore::Surface::GetPixelFormatNumericType(format);
-    if (*desired_numeric == current_numeric) {
-        return format;
-    }
-    if (const auto variant =
-            VideoCore::Surface::FindPixelFormatVariant(format, *desired_numeric)) {
-        return *variant;
-    }
-    return format;
-}
-
 GLenum Stage(size_t stage_index) {
    switch (stage_index) {
    case 0:
@@ -431,12 +397,8 @@ bool GraphicsPipeline::ConfigureImpl(bool is_indexed) {
                    is_written = desc.is_written;
                }
                ImageView& image_view{texture_cache.GetImageView(texture_buffer_it->id)};
-                auto buffer_format = image_view.format;
-                if constexpr (!is_image) {
-                    buffer_format = ResolveTexelBufferFormat(buffer_format, desc.component_type);
-                }
                buffer_cache.BindGraphicsTextureBuffer(stage, index, image_view.GpuAddr(),
-                                                       image_view.BufferSize(), buffer_format,
+                                                       image_view.BufferSize(), image_view.format,
                                                       is_written, is_image);
                ++index;
                ++texture_buffer_it;
@@ -521,8 +483,7 @@ bool GraphicsPipeline::ConfigureImpl(bool is_indexed) {
        for (const auto& desc : info.texture_descriptors) {
            for (u32 index = 0; index < desc.count; ++index) {
                ImageView& image_view{texture_cache.GetImageView((views_it++)->id)};
-                textures[texture_binding] =
-                    image_view.SampledView(desc.type, desc.component_type);
+                textures[texture_binding] = image_view.Handle(desc.type);
                if (texture_cache.IsRescaling(image_view)) {
                    texture_scaling_mask |= 1u << stage_texture_binding;
                }
--- a/src/video_core/renderer_opengl/gl_shader_cache.cpp
+++ b/src/video_core/renderer_opengl/gl_shader_cache.cpp
@@ -220,7 +220,6 @@ ShaderCache::ShaderCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,
          .support_gl_sparse_textures = device.HasSparseTexture2(),
          .support_gl_derivative_control = device.HasDerivativeControl(),
          .support_geometry_streams = true,
-          .warp_stage_support_mask = 0xFFFFFFFFu,

          .warp_size_potentially_larger_than_guest = device.IsWarpSizePotentiallyLargerThanGuest(),

--- a/src/video_core/renderer_opengl/gl_texture_cache.cpp
+++ b/src/video_core/renderer_opengl/gl_texture_cache.cpp
@@ -692,15 +692,6 @@ bool TextureCacheRuntime::HasNativeASTC() const noexcept {
    return device.HasASTC();
 }

-bool TextureCacheRuntime::SupportsLinearFilter(VideoCore::Surface::PixelFormat format) const noexcept {
-    using VideoCore::Surface::GetFormatType;
-    using VideoCore::Surface::IsPixelFormatInteger;
-    if (IsPixelFormatInteger(format)) {
-        return false;
-    }
-    return GetFormatType(format) == VideoCore::Surface::SurfaceType::ColorTexture;
-}
-
 Image::Image(TextureCacheRuntime& runtime_, const VideoCommon::ImageInfo& info_, GPUVAddr gpu_addr_,
             VAddr cpu_addr_)
    : VideoCommon::ImageBase(info_, gpu_addr_, cpu_addr_), runtime{&runtime_} {
@@ -1238,13 +1229,6 @@ GLuint ImageView::StorageView(Shader::TextureType texture_type, Shader::ImageFor
    return view;
 }

-GLuint ImageView::SampledView(Shader::TextureType view_type,
-                              Shader::SamplerComponentType /*component_type*/) {
-    // OpenGL swizzles already configure depth/stencil selection per TIC entry,
-    // so fall back to the default view handle.
-    return Handle(view_type);
-}
-
 void ImageView::SetupView(Shader::TextureType view_type) {
    views[static_cast<size_t>(view_type)] = MakeView(view_type, internal_format);
 }
--- a/src/video_core/renderer_opengl/gl_texture_cache.h
+++ b/src/video_core/renderer_opengl/gl_texture_cache.h
@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -16,7 +13,6 @@
 #include "video_core/renderer_opengl/gl_resource_manager.h"
 #include "video_core/renderer_opengl/gl_staging_buffer_pool.h"
 #include "video_core/renderer_opengl/util_shaders.h"
-#include "video_core/surface.h"
 #include "video_core/texture_cache/image_view_base.h"
 #include "video_core/texture_cache/texture_cache_base.h"

@@ -133,8 +129,6 @@ public:
        return false;
    }

-    bool SupportsLinearFilter(VideoCore::Surface::PixelFormat format) const noexcept;
-
    bool HasBrokenTextureViewFormats() const noexcept {
        return has_broken_texture_view_formats;
    }
@@ -143,8 +137,6 @@ public:

    void TickFrame() {}

-    void WaitForGpuTick(u64) {}
-
    StateTracker& GetStateTracker() {
        return state_tracker;
    }
@@ -272,9 +264,6 @@ public:
    [[nodiscard]] GLuint StorageView(Shader::TextureType texture_type,
                                     Shader::ImageFormat image_format);

-    [[nodiscard]] GLuint SampledView(Shader::TextureType view_type,
-                                     Shader::SamplerComponentType component_type);
-
    [[nodiscard]] GLuint Handle(Shader::TextureType handle_type) const noexcept {
        return views[static_cast<size_t>(handle_type)];
    }
--- a/src/video_core/renderer_vulkan/blit_image.cpp
+++ b/src/video_core/renderer_vulkan/blit_image.cpp
@@ -525,24 +525,18 @@ BlitImageHelper::BlitImageHelper(const Device& device_, Scheduler& scheduler_,
          nullptr, PUSH_CONSTANT_RANGE<VK_SHADER_STAGE_FRAGMENT_BIT, sizeof(float) * 4>))),
      full_screen_vert(BuildShader(device, FULL_SCREEN_TRIANGLE_VERT_SPV)),
      blit_color_to_color_frag(BuildShader(device, BLIT_COLOR_FLOAT_FRAG_SPV)),
-      blit_depth_stencil_frag(device.IsExtShaderStencilExportSupported() 
-                             ? BuildShader(device, VULKAN_BLIT_DEPTH_STENCIL_FRAG_SPV) 
-                             : vk::ShaderModule{}),
+      blit_depth_stencil_frag(BuildShader(device, VULKAN_BLIT_DEPTH_STENCIL_FRAG_SPV)),
      clear_color_vert(BuildShader(device, VULKAN_COLOR_CLEAR_VERT_SPV)),
      clear_color_frag(BuildShader(device, VULKAN_COLOR_CLEAR_FRAG_SPV)),
      clear_stencil_frag(BuildShader(device, VULKAN_DEPTHSTENCIL_CLEAR_FRAG_SPV)),
      convert_depth_to_float_frag(BuildShader(device, CONVERT_DEPTH_TO_FLOAT_FRAG_SPV)),
      convert_float_to_depth_frag(BuildShader(device, CONVERT_FLOAT_TO_DEPTH_FRAG_SPV)),
-      convert_abgr8_to_d24s8_frag(device.IsExtShaderStencilExportSupported() 
-                                 ? BuildShader(device, CONVERT_ABGR8_TO_D24S8_FRAG_SPV) 
-                                 : vk::ShaderModule{}),
+      convert_abgr8_to_d24s8_frag(BuildShader(device, CONVERT_ABGR8_TO_D24S8_FRAG_SPV)),
      convert_abgr8_to_d32f_frag(BuildShader(device, CONVERT_ABGR8_TO_D32F_FRAG_SPV)),
      convert_d32f_to_abgr8_frag(BuildShader(device, CONVERT_D32F_TO_ABGR8_FRAG_SPV)),
      convert_d24s8_to_abgr8_frag(BuildShader(device, CONVERT_D24S8_TO_ABGR8_FRAG_SPV)),
      convert_s8d24_to_abgr8_frag(BuildShader(device, CONVERT_S8D24_TO_ABGR8_FRAG_SPV)),
-      convert_abgr8_srgb_to_d24s8_frag(device.IsExtShaderStencilExportSupported() 
-                                      ? BuildShader(device, CONVERT_ABGR8_SRGB_TO_D24S8_FRAG_SPV) 
-                                      : vk::ShaderModule{}),
+      convert_abgr8_srgb_to_d24s8_frag(BuildShader(device, CONVERT_ABGR8_SRGB_TO_D24S8_FRAG_SPV)),
      convert_rgba_to_bgra_frag(BuildShader(device, CONVERT_RGBA8_TO_BGRA8_FRAG_SPV)),
      convert_yuv420_to_rgb_comp(BuildShader(device, CONVERT_YUV420_TO_RGB_COMP_SPV)),
      convert_rgb_to_yuv420_comp(BuildShader(device, CONVERT_RGB_TO_YUV420_COMP_SPV)),
@@ -673,11 +667,6 @@ void BlitImageHelper::ConvertR16ToD16(const Framebuffer* dst_framebuffer,

 void BlitImageHelper::ConvertABGR8ToD24S8(const Framebuffer* dst_framebuffer,
                                          const ImageView& src_image_view) {
-    if (!device.IsExtShaderStencilExportSupported()) {
-        // Shader requires VK_EXT_shader_stencil_export which is not available
-        LOG_WARNING(Render_Vulkan, "ConvertABGR8ToD24S8 requires shader_stencil_export, skipping");
-        return;
-    }
    ConvertPipelineDepthTargetEx(convert_abgr8_to_d24s8_pipeline, dst_framebuffer->RenderPass(),
                                 convert_abgr8_to_d24s8_frag);
    Convert(*convert_abgr8_to_d24s8_pipeline, dst_framebuffer, src_image_view);
@@ -713,11 +702,6 @@ void BlitImageHelper::ConvertS8D24ToABGR8(const Framebuffer* dst_framebuffer,

 void BlitImageHelper::ConvertABGR8SRGBToD24S8(const Framebuffer* dst_framebuffer,
                                             const ImageView& src_image_view) {
-    if (!device.IsExtShaderStencilExportSupported()) {
-        // Shader requires VK_EXT_shader_stencil_export which is not available
-        LOG_WARNING(Render_Vulkan, "ConvertABGR8SRGBToD24S8 requires shader_stencil_export, skipping");
-        return;
-    }
    ConvertPipelineDepthTargetEx(convert_abgr8_srgb_to_d24s8_pipeline,
                                dst_framebuffer->RenderPass(),
                                convert_abgr8_srgb_to_d24s8_frag);
--- a/src/video_core/renderer_vulkan/fixed_pipeline_state.cpp
+++ b/src/video_core/renderer_vulkan/fixed_pipeline_state.cpp
@@ -59,7 +59,7 @@ void FixedPipelineState::Refresh(Tegra::Engines::Maxwell3D& maxwell3d, DynamicFe
    raw1 = 0;
    extended_dynamic_state.Assign(features.has_extended_dynamic_state ? 1 : 0);
    extended_dynamic_state_2.Assign(features.has_extended_dynamic_state_2 ? 1 : 0);
-    extended_dynamic_state_2_logic_op.Assign(features.has_extended_dynamic_state_2_logic_op ? 1 : 0);
+    extended_dynamic_state_2_extra.Assign(features.has_extended_dynamic_state_2_extra ? 1 : 0);
    extended_dynamic_state_3_blend.Assign(features.has_extended_dynamic_state_3_blend ? 1 : 0);
    extended_dynamic_state_3_enables.Assign(features.has_extended_dynamic_state_3_enables ? 1 : 0);
    dynamic_vertex_input.Assign(features.has_dynamic_vertex_input ? 1 : 0);
@@ -157,7 +157,7 @@ void FixedPipelineState::Refresh(Tegra::Engines::Maxwell3D& maxwell3d, DynamicFe
            return static_cast<u16>(array.stride.Value());
        });
    }
-    if (!extended_dynamic_state_2_logic_op) {
+    if (!extended_dynamic_state_2_extra) {
        dynamic_state.Refresh2(regs, topology_, extended_dynamic_state_2);
    }
    if (!extended_dynamic_state_3_blend) {
--- a/src/video_core/renderer_vulkan/fixed_pipeline_state.h
+++ b/src/video_core/renderer_vulkan/fixed_pipeline_state.h
@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -23,11 +20,9 @@ using Maxwell = Tegra::Engines::Maxwell3D::Regs;
 struct DynamicFeatures {
    bool has_extended_dynamic_state;
    bool has_extended_dynamic_state_2;
-    bool has_extended_dynamic_state_2_logic_op;
-    bool has_extended_dynamic_state_2_patch_control_points;
+    bool has_extended_dynamic_state_2_extra;
    bool has_extended_dynamic_state_3_blend;
    bool has_extended_dynamic_state_3_enables;
-    bool has_dual_source_blend;
    bool has_dynamic_vertex_input;
 };

@@ -191,7 +186,7 @@ struct FixedPipelineState {
        u32 raw1;
        BitField<0, 1, u32> extended_dynamic_state;
        BitField<1, 1, u32> extended_dynamic_state_2;
-        BitField<2, 1, u32> extended_dynamic_state_2_logic_op;
+        BitField<2, 1, u32> extended_dynamic_state_2_extra;
        BitField<3, 1, u32> extended_dynamic_state_3_blend;
        BitField<4, 1, u32> extended_dynamic_state_3_enables;
        BitField<5, 1, u32> dynamic_vertex_input;
--- a/src/video_core/renderer_vulkan/maxwell_to_vk.cpp
+++ b/src/video_core/renderer_vulkan/maxwell_to_vk.cpp
@@ -165,7 +165,7 @@ struct FormatTuple {
    {VK_FORMAT_R16G16_SINT, Attachable | Storage},             // R16G16_SINT
    {VK_FORMAT_R16G16_SNORM, Attachable | Storage},            // R16G16_SNORM
    {VK_FORMAT_R32G32B32_SFLOAT},                              // R32G32B32_FLOAT
-    {VK_FORMAT_A8B8G8R8_SRGB_PACK32, Attachable | Storage},    // A8B8G8R8_SRGB
+    {VK_FORMAT_A8B8G8R8_SRGB_PACK32, Attachable},              // A8B8G8R8_SRGB
    {VK_FORMAT_R8G8_UNORM, Attachable | Storage},              // R8G8_UNORM
    {VK_FORMAT_R8G8_SNORM, Attachable | Storage},              // R8G8_SNORM
    {VK_FORMAT_R8G8_SINT, Attachable | Storage},               // R8G8_SINT
@@ -177,7 +177,7 @@ struct FormatTuple {
    {VK_FORMAT_ASTC_8x8_UNORM_BLOCK},                          // ASTC_2D_8X8_UNORM
    {VK_FORMAT_ASTC_8x5_UNORM_BLOCK},                          // ASTC_2D_8X5_UNORM
    {VK_FORMAT_ASTC_5x4_UNORM_BLOCK},                          // ASTC_2D_5X4_UNORM
-    {VK_FORMAT_B8G8R8A8_SRGB, Attachable | Storage},           // B8G8R8A8_SRGB
+    {VK_FORMAT_B8G8R8A8_SRGB, Attachable},                     // B8G8R8A8_SRGB
    {VK_FORMAT_BC1_RGBA_SRGB_BLOCK},                           // BC1_RGBA_SRGB
    {VK_FORMAT_BC2_SRGB_BLOCK},                                // BC2_SRGB
    {VK_FORMAT_BC3_SRGB_BLOCK},                                // BC3_SRGB
--- a/src/video_core/renderer_vulkan/pipeline_helper.h
+++ b/src/video_core/renderer_vulkan/pipeline_helper.h
@@ -189,16 +189,12 @@ inline void PushImageDescriptors(TextureCache& texture_cache,
            const VideoCommon::ImageViewId image_view_id{(views++)->id};
            const VideoCommon::SamplerId sampler_id{*(samplers++)};
            ImageView& image_view{texture_cache.GetImageView(image_view_id)};
-            const VkImageView vk_image_view{
-                image_view.SampledView(desc.type, desc.component_type)};
+            const VkImageView vk_image_view{image_view.Handle(desc.type)};
            const Sampler& sampler{texture_cache.GetSampler(sampler_id)};
-            const bool supports_linear_filter{
-                texture_cache.SupportsLinearFilter(image_view.format)};
-            const bool supports_depth_compare_sampling{
-                image_view.SupportsDepthCompareSampling()};
-            const VkSampler vk_sampler{
-                sampler.SelectHandle(supports_linear_filter, image_view.SupportsAnisotropy(),
-                                     supports_depth_compare_sampling)};
+            const bool use_fallback_sampler{sampler.HasAddedAnisotropy() &&
+                                            !image_view.SupportsAnisotropy()};
+            const VkSampler vk_sampler{use_fallback_sampler ? sampler.HandleWithDefaultAnisotropy()
+                                                            : sampler.Handle()};
            guest_descriptor_queue.AddSampledImage(vk_image_view, vk_sampler);
            rescaling.PushTexture(texture_cache.IsRescaling(image_view));
        }
--- a/src/video_core/renderer_vulkan/present/layer.cpp
+++ b/src/video_core/renderer_vulkan/present/layer.cpp
@@ -280,6 +280,7 @@ void Layer::UpdateRawImage(const Tegra::FramebufferConfig& framebuffer, size_t i
        Tegra::Texture::UnswizzleTexture(
            mapped_span.subspan(image_offset, linear_size), std::span(host_ptr, tiled_size),
            bytes_per_pixel, framebuffer.width, framebuffer.height, 1, block_height_log2, 0);
+        buffer.Flush();  // Ensure host writes are visible before the GPU copy.
    }

    const VkBufferImageCopy copy{
--- a/src/video_core/renderer_vulkan/vk_buffer_cache.cpp
+++ b/src/video_core/renderer_vulkan/vk_buffer_cache.cpp
@@ -7,7 +7,6 @@
 #include <algorithm>
 #include <array>
 #include <cstring>
-#include <limits>
 #include <span>
 #include <vector>

@@ -334,13 +333,6 @@ BufferCacheRuntime::BufferCacheRuntime(const Device& device_, MemoryAllocator& m
      staging_pool{staging_pool_}, guest_descriptor_queue{guest_descriptor_queue_},
      quad_index_pass(device, scheduler, descriptor_pool, staging_pool,
                      compute_pass_descriptor_queue) {
-    const VkDriverIdKHR driver_id = device.GetDriverID();
-    limit_dynamic_storage_buffers = driver_id == VK_DRIVER_ID_QUALCOMM_PROPRIETARY ||
-                                    driver_id == VK_DRIVER_ID_MESA_TURNIP ||
-                                    driver_id == VK_DRIVER_ID_ARM_PROPRIETARY;
-    if (limit_dynamic_storage_buffers) {
-        max_dynamic_storage_buffers = device.GetMaxDescriptorSetStorageBuffersDynamic();
-    }
    if (device.GetDriverID() != VK_DRIVER_ID_QUALCOMM_PROPRIETARY) {
        // TODO: FixMe: Uint8Pass compute shader does not build on some Qualcomm drivers.
        uint8_pass = std::make_unique<Uint8Pass>(device, scheduler, descriptor_pool, staging_pool,
@@ -416,10 +408,6 @@ bool BufferCacheRuntime::CanReportMemoryUsage() const {
    return device.CanReportMemoryUsage();
 }

-u32 BufferCacheRuntime::GetUniformBufferAlignment() const {
-    return static_cast<u32>(device.GetUniformBufferAlignment());
-}
-
 u32 BufferCacheRuntime::GetStorageBufferAlignment() const {
    return static_cast<u32>(device.GetStorageBufferAlignment());
 }
@@ -595,15 +583,7 @@ void BufferCacheRuntime::BindVertexBuffer(u32 index, VkBuffer buffer, u32 offset
    if (index >= device.GetMaxVertexInputBindings()) {
        return;
    }
-    if (!device.HasNullDescriptor() && buffer == VK_NULL_HANDLE) {
-        ReserveNullBuffer();
-        buffer = *null_buffer;
-        offset = 0;
-        size = std::numeric_limits<u32>::max();
-    }
-    // Use BindVertexBuffers2EXT only if EDS1 is supported AND VIDS is not active
-    // When VIDS is active, the pipeline doesn't declare VERTEX_INPUT_BINDING_STRIDE as dynamic
-    if (device.IsExtExtendedDynamicStateSupported() && !device.IsExtVertexInputDynamicStateSupported()) {
+    if (device.IsExtExtendedDynamicStateSupported()) {
        scheduler.Record([index, buffer, offset, size, stride](vk::CommandBuffer cmdbuf) {
            const VkDeviceSize vk_offset = buffer != VK_NULL_HANDLE ? offset : 0;
            const VkDeviceSize vk_size = buffer != VK_NULL_HANDLE ? size : VK_WHOLE_SIZE;
@@ -643,8 +623,7 @@ void BufferCacheRuntime::BindVertexBuffers(VideoCommon::HostBindings<Buffer>& bi
    if (binding_count == 0) {
        return;
    }
-    // Use BindVertexBuffers2EXT only if EDS1 is supported AND VIDS is not active
-    if (device.IsExtExtendedDynamicStateSupported() && !device.IsExtVertexInputDynamicStateSupported()) {
+    if (device.IsExtExtendedDynamicStateSupported()) {
        scheduler.Record([bindings_ = std::move(bindings),
                          buffer_handles_ = std::move(buffer_handles),
                          binding_count](vk::CommandBuffer cmdbuf) {
@@ -701,50 +680,27 @@ void BufferCacheRuntime::BindTransformFeedbackBuffers(VideoCommon::HostBindings<
 }

 void BufferCacheRuntime::ReserveNullBuffer() {
-    const VkBufferUsageFlags expected_usage = NullBufferUsageFlags();
-    if (null_buffer && null_buffer_usage_flags != expected_usage) {
-        RefreshNullBuffer();
-    }
    if (!null_buffer) {
        null_buffer = CreateNullBuffer();
    }
 }

-VkBufferUsageFlags BufferCacheRuntime::NullBufferUsageFlags() const {
-    VkBufferUsageFlags usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT |
-                              VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT |
-                              VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT |
-                              VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT |
-                              VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_INDEX_BUFFER_BIT |
-                              VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT;
-    if (device.IsExtTransformFeedbackSupported()) {
-        usage |= VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT;
-    }
-    return usage;
-}
-
-void BufferCacheRuntime::RefreshNullBuffer() {
-    if (!null_buffer) {
-        return;
-    }
-    scheduler.Finish();
-    null_buffer.reset();
-    null_buffer = CreateNullBuffer();
-}
-
 vk::Buffer BufferCacheRuntime::CreateNullBuffer() {
    VkBufferCreateInfo create_info{
        .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
        .pNext = nullptr,
        .flags = 0,
        .size = 4,
-        .usage = NullBufferUsageFlags(),
+        .usage = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT | VK_BUFFER_USAGE_INDEX_BUFFER_BIT |
+                 VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT,
        .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
        .queueFamilyIndexCount = 0,
        .pQueueFamilyIndices = nullptr,
    };
+    if (device.IsExtTransformFeedbackSupported()) {
+        create_info.usage |= VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT;
+    }
    vk::Buffer ret = memory_allocator.CreateBuffer(create_info, MemoryUsage::DeviceLocal);
-    null_buffer_usage_flags = create_info.usage;
    if (device.HasDebuggingToolAttached()) {
        ret.SetObjectNameEXT("Null buffer");
    }
--- a/src/video_core/renderer_vulkan/vk_buffer_cache.h
+++ b/src/video_core/renderer_vulkan/vk_buffer_cache.h
@@ -6,8 +6,6 @@

 #pragma once

-#include <limits>
-
 #include "video_core/buffer_cache/buffer_cache_base.h"
 #include "video_core/buffer_cache/memory_tracker_base.h"
 #include "video_core/buffer_cache/usage_tracker.h"
@@ -96,8 +94,6 @@ public:

    bool CanReportMemoryUsage() const;

-    u32 GetUniformBufferAlignment() const;
-
    u32 GetStorageBufferAlignment() const;

    [[nodiscard]] StagingBufferRef UploadStagingBuffer(size_t size);
@@ -131,9 +127,6 @@ public:

    void BindTransformFeedbackBuffers(VideoCommon::HostBindings<Buffer>& bindings);

-    /// Forces destruction and recreation of the shared null buffer so new usage flags take effect.
-    void RefreshNullBuffer();
-
    std::span<u8> BindMappedUniformBuffer([[maybe_unused]] size_t /*stage*/,
                                          [[maybe_unused]] u32 /*binding_index*/,
                                          u32 size) {
@@ -162,14 +155,6 @@ public:
        guest_descriptor_queue.AddTexelBuffer(buffer.View(offset, size, format));
    }

-    bool ShouldLimitDynamicStorageBuffers() const {
-        return limit_dynamic_storage_buffers;
-    }
-
-    u32 GetMaxDynamicStorageBuffers() const {
-        return max_dynamic_storage_buffers;
-    }
-
 private:
    void BindBuffer(VkBuffer buffer, u32 offset, u32 size) {
        guest_descriptor_queue.AddBuffer(buffer, offset, size);
@@ -177,7 +162,6 @@ private:

    void ReserveNullBuffer();
    vk::Buffer CreateNullBuffer();
-    VkBufferUsageFlags NullBufferUsageFlags() const;

    struct UniformRing {
        static constexpr size_t NUM_FRAMES = 3;
@@ -207,13 +191,9 @@ private:
    std::shared_ptr<QuadStripIndexBuffer> quad_strip_index_buffer;

    vk::Buffer null_buffer;
-    VkBufferUsageFlags null_buffer_usage_flags = 0;

    std::unique_ptr<Uint8Pass> uint8_pass;
    QuadIndexedPass quad_index_pass;
-
-    bool limit_dynamic_storage_buffers = false;
-    u32 max_dynamic_storage_buffers = std::numeric_limits<u32>::max();
 };

 struct BufferCacheParams {
--- a/src/video_core/renderer_vulkan/vk_compute_pass.cpp
+++ b/src/video_core/renderer_vulkan/vk_compute_pass.cpp
@@ -418,9 +418,6 @@ ConditionalRenderingResolvePass::ConditionalRenderingResolvePass(

 void ConditionalRenderingResolvePass::Resolve(VkBuffer dst_buffer, VkBuffer src_buffer,
                                              u32 src_offset, bool compare_to_zero) {
-    if (!device.IsExtConditionalRendering()) {
-        return;
-    }
    const size_t compare_size = compare_to_zero ? 8 : 24;

    compute_pass_descriptor_queue.Acquire();
@@ -451,7 +448,7 @@ void ConditionalRenderingResolvePass::Resolve(VkBuffer dst_buffer, VkBuffer src_
        cmdbuf.BindDescriptorSets(VK_PIPELINE_BIND_POINT_COMPUTE, *layout, 0, set, {});
        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_CONDITIONAL_RENDERING_BIT_EXT, 0, write_barrier);
    });
 }

@@ -462,14 +459,10 @@ QueriesPrefixScanPass::QueriesPrefixScanPass(
          device_, descriptor_pool_, QUERIES_SCAN_DESCRIPTOR_SET_BINDINGS,
          QUERIES_SCAN_DESCRIPTOR_UPDATE_TEMPLATE, QUERIES_SCAN_BANK_INFO,
          COMPUTE_PUSH_CONSTANT_RANGE<sizeof(QueriesPrefixScanPushConstants)>,
-          device_.IsSubgroupFeatureSupported(VK_SUBGROUP_FEATURE_BASIC_BIT,
-                                             VK_SHADER_STAGE_COMPUTE_BIT) &&
-                  device_.IsSubgroupFeatureSupported(VK_SUBGROUP_FEATURE_ARITHMETIC_BIT,
-                                                      VK_SHADER_STAGE_COMPUTE_BIT) &&
-                  device_.IsSubgroupFeatureSupported(VK_SUBGROUP_FEATURE_SHUFFLE_BIT,
-                                                      VK_SHADER_STAGE_COMPUTE_BIT) &&
-                  device_.IsSubgroupFeatureSupported(VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT,
-                                                      VK_SHADER_STAGE_COMPUTE_BIT)
+          device_.IsSubgroupFeatureSupported(VK_SUBGROUP_FEATURE_BASIC_BIT) &&
+                  device_.IsSubgroupFeatureSupported(VK_SUBGROUP_FEATURE_ARITHMETIC_BIT) &&
+                  device_.IsSubgroupFeatureSupported(VK_SUBGROUP_FEATURE_SHUFFLE_BIT) &&
+                  device_.IsSubgroupFeatureSupported(VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT)
              ? std::span<const u32>(QUERIES_PREFIX_SCAN_SUM_COMP_SPV)
              : std::span<const u32>(QUERIES_PREFIX_SCAN_SUM_NOSUBGROUPS_COMP_SPV)),
      scheduler{scheduler_}, compute_pass_descriptor_queue{compute_pass_descriptor_queue_} {}
@@ -477,14 +470,6 @@ QueriesPrefixScanPass::QueriesPrefixScanPass(
 void QueriesPrefixScanPass::Run(VkBuffer accumulation_buffer, VkBuffer dst_buffer,
                                VkBuffer src_buffer, size_t number_of_sums,
                                size_t min_accumulation_limit, size_t max_accumulation_limit) {
-    constexpr VkAccessFlags BASE_DST_ACCESS = VK_ACCESS_SHADER_READ_BIT |
-                                              VK_ACCESS_TRANSFER_READ_BIT |
-                                              VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT |
-                                              VK_ACCESS_INDIRECT_COMMAND_READ_BIT |
-                                              VK_ACCESS_INDEX_READ_BIT |
-                                              VK_ACCESS_UNIFORM_READ_BIT;
-    const VkAccessFlags conditional_access =
-        device.IsExtConditionalRendering() ? VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT : 0;
    size_t current_runs = number_of_sums;
    size_t offset = 0;
    while (current_runs != 0) {
@@ -501,18 +486,22 @@ void QueriesPrefixScanPass::Run(VkBuffer accumulation_buffer, VkBuffer dst_buffe

        scheduler.RequestOutsideRenderPassOperationContext();
        scheduler.Record([this, descriptor_data, min_accumulation_limit, max_accumulation_limit,
-                          runs_to_do, used_offset, conditional_access](vk::CommandBuffer cmdbuf) {
+                          runs_to_do, used_offset](vk::CommandBuffer cmdbuf) {
            static constexpr VkMemoryBarrier read_barrier{
                .sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER,
                .pNext = nullptr,
                .srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
                .dstAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT,
            };
-            const VkMemoryBarrier write_barrier{
+            static constexpr VkMemoryBarrier write_barrier{
                .sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER,
                .pNext = nullptr,
                .srcAccessMask = VK_ACCESS_SHADER_WRITE_BIT,
-                .dstAccessMask = BASE_DST_ACCESS | conditional_access,
+                .dstAccessMask = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_TRANSFER_READ_BIT |
+                                 VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT |
+                                 VK_ACCESS_INDIRECT_COMMAND_READ_BIT | VK_ACCESS_INDEX_READ_BIT |
+                                 VK_ACCESS_UNIFORM_READ_BIT |
+                                 VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT,
            };
            const QueriesPrefixScanPushConstants uniforms{
                .min_accumulation_base = static_cast<u32>(min_accumulation_limit),
@@ -530,7 +519,8 @@ 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_CONDITIONAL_RENDERING_BIT_EXT, 0,
+                                   write_barrier);
        });
    }
 }
--- a/src/video_core/renderer_vulkan/vk_compute_pipeline.cpp
+++ b/src/video_core/renderer_vulkan/vk_compute_pipeline.cpp
@@ -18,49 +18,14 @@
 #include "video_core/renderer_vulkan/vk_scheduler.h"
 #include "video_core/renderer_vulkan/vk_update_descriptor.h"
 #include "video_core/shader_notify.h"
-#include "video_core/surface.h"
-#include "video_core/texture_cache/texture_cache.h"
 #include "video_core/vulkan_common/vulkan_device.h"
 #include "video_core/vulkan_common/vulkan_wrapper.h"
-#include <optional>

 namespace Vulkan {

 using Shader::ImageBufferDescriptor;
 using Shader::Backend::SPIRV::RESCALING_LAYOUT_WORDS_OFFSET;
 using Tegra::Texture::TexturePair;
-using VideoCore::Surface::PixelFormat;
-using VideoCore::Surface::PixelFormatNumeric;
-
-static std::optional<PixelFormatNumeric> NumericFromComponentType(
-    Shader::SamplerComponentType component_type) {
-    switch (component_type) {
-    case Shader::SamplerComponentType::Float:
-        return PixelFormatNumeric::Float;
-    case Shader::SamplerComponentType::Sint:
-        return PixelFormatNumeric::Sint;
-    case Shader::SamplerComponentType::Uint:
-        return PixelFormatNumeric::Uint;
-    default:
-        return std::nullopt;
-    }
-}
-
-static PixelFormat ResolveTexelBufferFormat(PixelFormat format,
-                                     Shader::SamplerComponentType component_type) {
-    const auto desired_numeric = NumericFromComponentType(component_type);
-    if (!desired_numeric) {
-        return format;
-    }
-    const auto current_numeric = VideoCore::Surface::GetPixelFormatNumericType(format);
-    if (*desired_numeric == current_numeric) {
-        return format;
-    }
-    if (const auto variant = VideoCore::Surface::FindPixelFormatVariant(format, *desired_numeric)) {
-        return *variant;
-    }
-    return format;
-}

 ComputePipeline::ComputePipeline(const Device& device_, vk::PipelineCache& pipeline_cache_,
                                 DescriptorPool& descriptor_pool,
@@ -217,12 +182,8 @@ void ComputePipeline::Configure(Tegra::Engines::KeplerCompute& kepler_compute,
                is_written = desc.is_written;
            }
            ImageView& image_view = texture_cache.GetImageView(views[index].id);
-            VideoCore::Surface::PixelFormat buffer_format = image_view.format;
-            if constexpr (!is_image) {
-                buffer_format = ResolveTexelBufferFormat(buffer_format, desc.component_type);
-            }
            buffer_cache.BindComputeTextureBuffer(index, image_view.GpuAddr(),
-                                                  image_view.BufferSize(), buffer_format,
+                                                  image_view.BufferSize(), image_view.format,
                                                  is_written, is_image);
            ++index;
        }
--- a/src/video_core/renderer_vulkan/vk_fence_manager.h
+++ b/src/video_core/renderer_vulkan/vk_fence_manager.h
@@ -34,10 +34,6 @@ public:

    void Wait();

-    [[nodiscard]] u64 WaitTick() const noexcept {
-        return wait_tick;
-    }
-
 private:
    Scheduler& scheduler;
    u64 wait_tick = 0;
--- a/src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp
+++ b/src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp
@@ -5,8 +5,6 @@
 // SPDX-License-Identifier: GPL-2.0-or-later

 #include <algorithm>
-#include <array>
-#include <optional>
 #include <iostream>
 #include <span>

@@ -25,9 +23,7 @@
 #include "video_core/renderer_vulkan/vk_texture_cache.h"
 #include "video_core/renderer_vulkan/vk_update_descriptor.h"
 #include "video_core/shader_notify.h"
-#include "video_core/texture_cache/samples_helper.h"
 #include "video_core/texture_cache/texture_cache.h"
-#include "video_core/surface.h"
 #include "video_core/vulkan_common/vulkan_device.h"

 #if defined(_MSC_VER) && defined(NDEBUG)
@@ -48,83 +44,10 @@ using Tegra::Texture::TexturePair;
 using VideoCore::Surface::PixelFormat;
 using VideoCore::Surface::PixelFormatFromDepthFormat;
 using VideoCore::Surface::PixelFormatFromRenderTargetFormat;
-using VideoCore::Surface::PixelFormatNumeric;

 constexpr size_t NUM_STAGES = Maxwell::MaxShaderStage;
 constexpr size_t MAX_IMAGE_ELEMENTS = 64;

-std::optional<PixelFormatNumeric> NumericFromComponentType(
-    Shader::SamplerComponentType component_type) {
-    switch (component_type) {
-    case Shader::SamplerComponentType::Float:
-        return PixelFormatNumeric::Float;
-    case Shader::SamplerComponentType::Sint:
-        return PixelFormatNumeric::Sint;
-    case Shader::SamplerComponentType::Uint:
-        return PixelFormatNumeric::Uint;
-    default:
-        return std::nullopt;
-    }
-}
-
-PixelFormat ResolveTexelBufferFormat(PixelFormat format,
-                                     Shader::SamplerComponentType component_type) {
-    const auto desired_numeric = NumericFromComponentType(component_type);
-    if (!desired_numeric) {
-        return format;
-    }
-    const auto current_numeric = VideoCore::Surface::GetPixelFormatNumericType(format);
-    if (*desired_numeric == current_numeric) {
-        return format;
-    }
-    if (const auto variant = VideoCore::Surface::FindPixelFormatVariant(format, *desired_numeric)) {
-        return *variant;
-    }
-    return format;
-}
-
-bool UsesDualSourceFactor(Maxwell::Blend::Factor factor) {
-    switch (factor) {
-    case Maxwell::Blend::Factor::Source1Color_D3D:
-    case Maxwell::Blend::Factor::Source1Color_GL:
-    case Maxwell::Blend::Factor::OneMinusSource1Color_D3D:
-    case Maxwell::Blend::Factor::OneMinusSource1Color_GL:
-    case Maxwell::Blend::Factor::Source1Alpha_D3D:
-    case Maxwell::Blend::Factor::Source1Alpha_GL:
-    case Maxwell::Blend::Factor::OneMinusSource1Alpha_D3D:
-    case Maxwell::Blend::Factor::OneMinusSource1Alpha_GL:
-        return true;
-    default:
-        return false;
-    }
-}
-
-Maxwell::Blend::Factor FallbackDualSourceFactor(Maxwell::Blend::Factor factor) {
-    switch (factor) {
-    case Maxwell::Blend::Factor::Source1Color_D3D:
-    case Maxwell::Blend::Factor::Source1Color_GL:
-        return Maxwell::Blend::Factor::SourceColor_D3D;
-    case Maxwell::Blend::Factor::OneMinusSource1Color_D3D:
-    case Maxwell::Blend::Factor::OneMinusSource1Color_GL:
-        return Maxwell::Blend::Factor::OneMinusSourceColor_D3D;
-    case Maxwell::Blend::Factor::Source1Alpha_D3D:
-    case Maxwell::Blend::Factor::Source1Alpha_GL:
-        return Maxwell::Blend::Factor::SourceAlpha_D3D;
-    case Maxwell::Blend::Factor::OneMinusSource1Alpha_D3D:
-    case Maxwell::Blend::Factor::OneMinusSource1Alpha_GL:
-        return Maxwell::Blend::Factor::OneMinusSourceAlpha_D3D;
-    default:
-        return factor;
-    }
-}
-
-bool AttachmentUsesDualSource(const FixedPipelineState::BlendingAttachment& blend) {
-    return UsesDualSourceFactor(blend.SourceRGBFactor()) ||
-           UsesDualSourceFactor(blend.DestRGBFactor()) ||
-           UsesDualSourceFactor(blend.SourceAlphaFactor()) ||
-           UsesDualSourceFactor(blend.DestAlphaFactor());
-}
-
 DescriptorLayoutBuilder MakeBuilder(const Device& device, std::span<const Shader::Info> infos) {
    DescriptorLayoutBuilder builder{device};
    for (size_t index = 0; index < infos.size(); ++index) {
@@ -340,7 +263,6 @@ GraphicsPipeline::GraphicsPipeline(
        std::ranges::copy(info->constant_buffer_used_sizes, uniform_buffer_sizes[stage].begin());
        num_textures += Shader::NumDescriptors(info->texture_descriptors);
    }
-    fragment_has_color0_output = stage_infos[NUM_STAGES - 1].stores_frag_color[0];
    auto func{[this, shader_notify, &render_pass_cache, &descriptor_pool, pipeline_statistics] {
        DescriptorLayoutBuilder builder{MakeBuilder(device, stage_infos)};
        uses_push_descriptor = builder.CanUsePushDescriptor();
@@ -494,12 +416,8 @@ bool GraphicsPipeline::ConfigureImpl(bool is_indexed) {
                    is_written = desc.is_written;
                }
                ImageView& image_view{texture_cache.GetImageView(texture_buffer_it->id)};
-                VideoCore::Surface::PixelFormat buffer_format = image_view.format;
-                if constexpr (!is_image) {
-                    buffer_format = ResolveTexelBufferFormat(buffer_format, desc.component_type);
-                }
                buffer_cache.BindGraphicsTextureBuffer(stage, index, image_view.GpuAddr(),
-                                                       image_view.BufferSize(), buffer_format,
+                                                       image_view.BufferSize(), image_view.format,
                                                       is_written, is_image);
                ++index;
                ++texture_buffer_it;
@@ -784,18 +702,13 @@ void GraphicsPipeline::MakePipeline(VkRenderPass render_pass) {
        .lineWidth = 1.0f,
        // TODO(alekpop): Transfer from regs
    };
-    const bool smooth_lines_supported =
-        device.IsExtLineRasterizationSupported() && device.SupportsSmoothLines();
-    const bool stippled_lines_supported =
-        device.IsExtLineRasterizationSupported() && device.SupportsStippledRectangularLines();
    VkPipelineRasterizationLineStateCreateInfoEXT line_state{
        .sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT,
        .pNext = nullptr,
-        .lineRasterizationMode = key.state.smooth_lines != 0 && smooth_lines_supported
+        .lineRasterizationMode = key.state.smooth_lines != 0
                                     ? VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT
                                     : VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT,
-        .stippledLineEnable =
-            (dynamic.line_stipple_enable && stippled_lines_supported) ? VK_TRUE : VK_FALSE,
+        .stippledLineEnable = dynamic.line_stipple_enable ? VK_TRUE : VK_FALSE,
        .lineStippleFactor = key.state.line_stipple_factor,
        .lineStipplePattern = static_cast<uint16_t>(key.state.line_stipple_pattern),
    };
@@ -826,25 +739,17 @@ void GraphicsPipeline::MakePipeline(VkRenderPass render_pass) {
        provoking_vertex.pNext = std::exchange(rasterization_ci.pNext, &provoking_vertex);
    }

-    const bool supports_alpha_output = fragment_has_color0_output;
-    const bool alpha_to_one_supported = device.SupportsAlphaToOne();
-    const auto msaa_mode = key.state.msaa_mode.Value();
-    const VkSampleCountFlagBits vk_samples = MaxwellToVK::MsaaMode(msaa_mode);
-    VkPipelineMultisampleStateCreateInfo multisample_ci{
+    const VkPipelineMultisampleStateCreateInfo multisample_ci{
        .sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
        .pNext = nullptr,
        .flags = 0,
-        .rasterizationSamples = vk_samples,
+        .rasterizationSamples = MaxwellToVK::MsaaMode(key.state.msaa_mode),
        .sampleShadingEnable = Settings::values.sample_shading.GetValue() ? VK_TRUE : VK_FALSE,
        .minSampleShading = static_cast<float>(Settings::values.sample_shading_fraction.GetValue()) / 100.0f,
        .pSampleMask = nullptr,
-        .alphaToCoverageEnable =
-            supports_alpha_output && key.state.alpha_to_coverage_enabled != 0 ? VK_TRUE : VK_FALSE,
-        .alphaToOneEnable = supports_alpha_output && alpha_to_one_supported &&
-                           key.state.alpha_to_one_enabled != 0 ? VK_TRUE : VK_FALSE,
+        .alphaToCoverageEnable = key.state.alpha_to_coverage_enabled != 0 ? VK_TRUE : VK_FALSE,
+        .alphaToOneEnable = key.state.alpha_to_one_enabled != 0 ? VK_TRUE : VK_FALSE,
    };
-
-
    const VkPipelineDepthStencilStateCreateInfo depth_stencil_ci{
        .sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,
        .pNext = nullptr,
@@ -866,12 +771,6 @@ void GraphicsPipeline::MakePipeline(VkRenderPass render_pass) {
    }
    static_vector<VkPipelineColorBlendAttachmentState, Maxwell::NumRenderTargets> cb_attachments;
    const size_t num_attachments{NumAttachments(key.state)};
-    const bool supports_dual_source_blend = device.SupportsDualSourceBlend();
-    const u32 max_dual_source_attachments = supports_dual_source_blend
-                                                ? device.MaxFragmentDualSrcAttachments()
-                                                : 0;
-    u32 granted_dual_source_attachments = 0;
-    bool logged_dual_source_warning = false;
    for (size_t index = 0; index < num_attachments; ++index) {
        static constexpr std::array mask_table{
            VK_COLOR_COMPONENT_R_BIT,
@@ -885,30 +784,13 @@ void GraphicsPipeline::MakePipeline(VkRenderPass render_pass) {
        for (size_t i = 0; i < mask_table.size(); ++i) {
            write_mask |= mask[i] ? mask_table[i] : 0;
        }
-        const bool attachment_uses_dual_source = AttachmentUsesDualSource(blend);
-        const bool allow_dual_source = attachment_uses_dual_source && supports_dual_source_blend &&
-                                       granted_dual_source_attachments < max_dual_source_attachments;
-        if (allow_dual_source) {
-            ++granted_dual_source_attachments;
-        } else if (attachment_uses_dual_source && !logged_dual_source_warning) {
-            LOG_WARNING(Render_Vulkan,
-                        "Dual-source blend factors exceed device limit (maxFragmentDualSrcAttachments={}), falling back to single-source factors",
-                        max_dual_source_attachments);
-            logged_dual_source_warning = true;
-        }
-        const auto sanitize_factor = [&](Maxwell::Blend::Factor factor) {
-            if (allow_dual_source || !UsesDualSourceFactor(factor)) {
-                return factor;
-            }
-            return FallbackDualSourceFactor(factor);
-        };
        cb_attachments.push_back({
            .blendEnable = blend.enable != 0,
-            .srcColorBlendFactor = MaxwellToVK::BlendFactor(sanitize_factor(blend.SourceRGBFactor())),
-            .dstColorBlendFactor = MaxwellToVK::BlendFactor(sanitize_factor(blend.DestRGBFactor())),
+            .srcColorBlendFactor = MaxwellToVK::BlendFactor(blend.SourceRGBFactor()),
+            .dstColorBlendFactor = MaxwellToVK::BlendFactor(blend.DestRGBFactor()),
            .colorBlendOp = MaxwellToVK::BlendEquation(blend.EquationRGB()),
-            .srcAlphaBlendFactor = MaxwellToVK::BlendFactor(sanitize_factor(blend.SourceAlphaFactor())),
-            .dstAlphaBlendFactor = MaxwellToVK::BlendFactor(sanitize_factor(blend.DestAlphaFactor())),
+            .srcAlphaBlendFactor = MaxwellToVK::BlendFactor(blend.SourceAlphaFactor()),
+            .dstAlphaBlendFactor = MaxwellToVK::BlendFactor(blend.DestAlphaFactor()),
            .alphaBlendOp = MaxwellToVK::BlendEquation(blend.EquationAlpha()),
            .colorWriteMask = write_mask,
        });
@@ -924,25 +806,14 @@ void GraphicsPipeline::MakePipeline(VkRenderPass render_pass) {
        .blendConstants = {}
    };
    static_vector<VkDynamicState, 34> dynamic_states{
-        VK_DYNAMIC_STATE_VIEWPORT,
-        VK_DYNAMIC_STATE_SCISSOR,
-        VK_DYNAMIC_STATE_DEPTH_BIAS,
+        VK_DYNAMIC_STATE_VIEWPORT,           VK_DYNAMIC_STATE_SCISSOR,
+        VK_DYNAMIC_STATE_DEPTH_BIAS,         VK_DYNAMIC_STATE_BLEND_CONSTANTS,
+        VK_DYNAMIC_STATE_DEPTH_BOUNDS,       VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK,
+        VK_DYNAMIC_STATE_STENCIL_WRITE_MASK, VK_DYNAMIC_STATE_STENCIL_REFERENCE,
        VK_DYNAMIC_STATE_LINE_WIDTH,
    };
-
-    if (device.UsesAdvancedCoreDynamicState()) {
-        static constexpr std::array core_dynamic_states{
-            VK_DYNAMIC_STATE_BLEND_CONSTANTS,
-            VK_DYNAMIC_STATE_DEPTH_BOUNDS,
-            VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK,
-            VK_DYNAMIC_STATE_STENCIL_WRITE_MASK,
-            VK_DYNAMIC_STATE_STENCIL_REFERENCE,
-        };
-        dynamic_states.insert(dynamic_states.end(), core_dynamic_states.begin(),
-                              core_dynamic_states.end());
-    }
    if (key.state.extended_dynamic_state) {
-        static constexpr std::array extended{
+        std::vector<VkDynamicState> extended{
            VK_DYNAMIC_STATE_CULL_MODE_EXT,
            VK_DYNAMIC_STATE_FRONT_FACE_EXT,
            VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE_EXT,
@@ -952,68 +823,51 @@ void GraphicsPipeline::MakePipeline(VkRenderPass render_pass) {
            VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE_EXT,
            VK_DYNAMIC_STATE_STENCIL_OP_EXT,
        };
+        if (!device.IsExtVertexInputDynamicStateSupported()) {
+            extended.push_back(VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT);
+        }
+        if (key.state.dynamic_vertex_input) {
+            dynamic_states.push_back(VK_DYNAMIC_STATE_VERTEX_INPUT_EXT);
+        }
        dynamic_states.insert(dynamic_states.end(), extended.begin(), extended.end());
-        
-        // VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT is part of EDS1
-        // Only use it if VIDS is not active (VIDS replaces it with full vertex input control)
-        if (!key.state.dynamic_vertex_input) {
-            dynamic_states.push_back(VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT);
+        if (key.state.extended_dynamic_state_2) {
+            static constexpr std::array extended2{
+                VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT,
+                VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT,
+                VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT,
+            };
+            dynamic_states.insert(dynamic_states.end(), extended2.begin(), extended2.end());
        }
-    }
-    
-    // VK_DYNAMIC_STATE_VERTEX_INPUT_EXT (VIDS) - Independent from EDS
-    // Provides full dynamic vertex input control, replaces VERTEX_INPUT_BINDING_STRIDE
-    if (key.state.dynamic_vertex_input) {
-        dynamic_states.push_back(VK_DYNAMIC_STATE_VERTEX_INPUT_EXT);
-    }
-    
-    // EDS2 - Core (3 states)
-    if (key.state.extended_dynamic_state_2) {
-        static constexpr std::array extended2{
-            VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT,
-            VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT,
-            VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT,
-        };
-        dynamic_states.insert(dynamic_states.end(), extended2.begin(), extended2.end());
-    }
-    
-    // EDS2 - LogicOp (granular)
-    if (key.state.extended_dynamic_state_2_logic_op) {
-        dynamic_states.push_back(VK_DYNAMIC_STATE_LOGIC_OP_EXT);
-    }
-    
-    // EDS3 - Blending (composite: 3 states)
-    if (key.state.extended_dynamic_state_3_blend) {
-        static constexpr std::array extended3{
-            VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT,
-            VK_DYNAMIC_STATE_COLOR_BLEND_EQUATION_EXT,
-            VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT,
-        };
-        dynamic_states.insert(dynamic_states.end(), extended3.begin(), extended3.end());
-    }
-    
-    // EDS3 - Enables (composite: per-feature)
-    if (key.state.extended_dynamic_state_3_enables) {
-        if (device.SupportsDynamicState3DepthClampEnable()) {
-            dynamic_states.push_back(VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT);
+        if (key.state.extended_dynamic_state_2_extra) {
+            dynamic_states.push_back(VK_DYNAMIC_STATE_LOGIC_OP_EXT);
        }
-        if (device.SupportsDynamicState3LogicOpEnable()) {
-            dynamic_states.push_back(VK_DYNAMIC_STATE_LOGIC_OP_ENABLE_EXT);
+        if (key.state.extended_dynamic_state_3_blend) {
+            static constexpr std::array extended3{
+                VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT,
+                VK_DYNAMIC_STATE_COLOR_BLEND_EQUATION_EXT,
+                VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT,
+
+                // VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT,
+            };
+            dynamic_states.insert(dynamic_states.end(), extended3.begin(), extended3.end());
        }
-        if (device.SupportsDynamicState3LineRasterizationMode()) {
-            dynamic_states.push_back(VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT);
-        }
-        if (device.SupportsDynamicState3ConservativeRasterizationMode()) {
-            dynamic_states.push_back(VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT);
-        }
-        if (device.SupportsDynamicState3LineStippleEnable()) {
-            dynamic_states.push_back(VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT);
-        }
-        if (device.SupportsDynamicState3AlphaToCoverageEnable()) {
-            dynamic_states.push_back(VK_DYNAMIC_STATE_ALPHA_TO_COVERAGE_ENABLE_EXT);
-        }
-        if (device.SupportsDynamicState3AlphaToOneEnable()) {
-            dynamic_states.push_back(VK_DYNAMIC_STATE_ALPHA_TO_ONE_ENABLE_EXT);
+        if (key.state.extended_dynamic_state_3_enables) {
+            static constexpr std::array extended3{
+                VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT,
+                VK_DYNAMIC_STATE_LOGIC_OP_ENABLE_EXT,
+
+                // additional state3 extensions
+                VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT,
+
+                VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT,
+
+                VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT,
+                VK_DYNAMIC_STATE_ALPHA_TO_COVERAGE_ENABLE_EXT,
+                VK_DYNAMIC_STATE_ALPHA_TO_ONE_ENABLE_EXT,
+                VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT,
+                VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT,
+            };
+            dynamic_states.insert(dynamic_states.end(), extended3.begin(), extended3.end());
        }
    }

--- a/src/video_core/renderer_vulkan/vk_graphics_pipeline.h
+++ b/src/video_core/renderer_vulkan/vk_graphics_pipeline.h
@@ -82,17 +82,6 @@ public:
        const std::array<const Shader::Info*, NUM_STAGES>& infos);

    bool HasDynamicVertexInput() const noexcept { return key.state.dynamic_vertex_input; }
-    bool SupportsAlphaToCoverage() const noexcept {
-        return fragment_has_color0_output;
-    }
-
-    bool SupportsAlphaToOne() const noexcept {
-        return fragment_has_color0_output;
-    }
-
-    bool UsesExtendedDynamicState() const noexcept {
-        return key.state.extended_dynamic_state != 0;
-    }
    GraphicsPipeline& operator=(GraphicsPipeline&&) noexcept = delete;
    GraphicsPipeline(GraphicsPipeline&&) noexcept = delete;

@@ -160,7 +149,6 @@ private:
    std::array<u32, 5> enabled_uniform_buffer_masks{};
    VideoCommon::UniformBufferSizes uniform_buffer_sizes{};
    u32 num_textures{};
-    bool fragment_has_color0_output{};

    vk::DescriptorSetLayout descriptor_set_layout;
    DescriptorAllocator descriptor_allocator;
--- a/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp
+++ b/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp
@@ -36,7 +36,6 @@
 #include "video_core/renderer_vulkan/vk_scheduler.h"
 #include "video_core/renderer_vulkan/vk_shader_util.h"
 #include "video_core/renderer_vulkan/vk_update_descriptor.h"
-#include "video_core/surface.h"
 #include "video_core/shader_cache.h"
 #include "video_core/shader_environment.h"
 #include "video_core/shader_notify.h"
@@ -106,41 +105,6 @@ Shader::CompareFunction MaxwellToCompareFunction(Maxwell::ComparisonOp compariso
    return {};
 }

-Shader::AttributeType RenderTargetAttributeType(Tegra::RenderTargetFormat format) {
-    if (format == Tegra::RenderTargetFormat::NONE) {
-        return Shader::AttributeType::Float;
-    }
-    const auto pixel_format{
-        VideoCore::Surface::PixelFormatFromRenderTargetFormat(format)};
-    if (!VideoCore::Surface::IsPixelFormatInteger(pixel_format)) {
-        return Shader::AttributeType::Float;
-    }
-    if (VideoCore::Surface::IsPixelFormatSignedInteger(pixel_format)) {
-        return Shader::AttributeType::SignedInt;
-    }
-    return Shader::AttributeType::UnsignedInt;
-}
-
-VkShaderStageFlagBits StageToVkStage(Shader::Stage stage) {
-    switch (stage) {
-    case Shader::Stage::VertexA:
-    case Shader::Stage::VertexB:
-        return VK_SHADER_STAGE_VERTEX_BIT;
-    case Shader::Stage::TessellationControl:
-        return VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT;
-    case Shader::Stage::TessellationEval:
-        return VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT;
-    case Shader::Stage::Geometry:
-        return VK_SHADER_STAGE_GEOMETRY_BIT;
-    case Shader::Stage::Fragment:
-        return VK_SHADER_STAGE_FRAGMENT_BIT;
-    case Shader::Stage::Compute:
-        return VK_SHADER_STAGE_COMPUTE_BIT;
-    default:
-        return VK_SHADER_STAGE_VERTEX_BIT;
-    }
-}
-
 Shader::AttributeType CastAttributeType(const FixedPipelineState::VertexAttribute& attr) {
    if (attr.enabled == 0) {
        return Shader::AttributeType::Disabled;
@@ -265,10 +229,6 @@ Shader::RuntimeInfo MakeRuntimeInfo(std::span<const Shader::IR::Program> program
        info.alpha_test_func = MaxwellToCompareFunction(
            key.state.UnpackComparisonOp(key.state.alpha_test_func.Value()));
        info.alpha_test_reference = std::bit_cast<float>(key.state.alpha_test_ref);
-        for (size_t index = 0; index < Maxwell::NumRenderTargets; ++index) {
-            const auto format = static_cast<Tegra::RenderTargetFormat>(key.state.color_formats[index]);
-            info.color_output_types[index] = RenderTargetAttributeType(format);
-        }
        break;
    default:
        break;
@@ -309,8 +269,8 @@ size_t GetTotalPipelineWorkers() {
    const size_t max_core_threads =
        std::max<size_t>(static_cast<size_t>(std::thread::hardware_concurrency()), 2ULL) - 1ULL;
 #ifdef ANDROID
-    // Leave at least one core free on Android to reduce thermal pressure.
-    constexpr size_t free_cores = 1ULL;
+    // Leave at least a few cores free in android
+    constexpr size_t free_cores = 3ULL;
    if (max_core_threads <= free_cores) {
        return 1ULL;
    }
@@ -357,7 +317,6 @@ PipelineCache::PipelineCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,
              "VkPipelineBuilder"),
      serialization_thread(1, "VkPipelineSerialization") {
    const auto& float_control{device.FloatControlProperties()};
-    const bool float_controls_supported{device.IsKhrShaderFloatControlsSupported()};
    const VkDriverId driver_id{device.GetDriverID()};
    profile = Shader::Profile{
        .supported_spirv = device.SupportedSpirvVersion(),
@@ -367,24 +326,20 @@ PipelineCache::PipelineCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,
        .support_int16 = device.IsShaderInt16Supported(),
        .support_int64 = device.IsShaderInt64Supported(),
        .support_vertex_instance_id = false,
-        .support_float_controls = float_controls_supported,
-        .support_separate_denorm_behavior = float_controls_supported &&
+        .support_float_controls = device.IsKhrShaderFloatControlsSupported(),
+        .support_separate_denorm_behavior =
            float_control.denormBehaviorIndependence == VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL,
-        .support_separate_rounding_mode = float_controls_supported &&
+        .support_separate_rounding_mode =
            float_control.roundingModeIndependence == VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL,
-        .support_fp16_denorm_preserve = float_controls_supported &&
-            float_control.shaderDenormPreserveFloat16 != VK_FALSE,
-        .support_fp32_denorm_preserve = float_controls_supported &&
-            float_control.shaderDenormPreserveFloat32 != VK_FALSE,
-        .support_fp16_denorm_flush = float_controls_supported &&
-            float_control.shaderDenormFlushToZeroFloat16 != VK_FALSE,
-        .support_fp32_denorm_flush = float_controls_supported &&
-            float_control.shaderDenormFlushToZeroFloat32 != VK_FALSE,
-        .support_fp16_signed_zero_nan_preserve = float_controls_supported &&
+        .support_fp16_denorm_preserve = float_control.shaderDenormPreserveFloat16 != VK_FALSE,
+        .support_fp32_denorm_preserve = float_control.shaderDenormPreserveFloat32 != VK_FALSE,
+        .support_fp16_denorm_flush = float_control.shaderDenormFlushToZeroFloat16 != VK_FALSE,
+        .support_fp32_denorm_flush = float_control.shaderDenormFlushToZeroFloat32 != VK_FALSE,
+        .support_fp16_signed_zero_nan_preserve =
            float_control.shaderSignedZeroInfNanPreserveFloat16 != VK_FALSE,
-        .support_fp32_signed_zero_nan_preserve = float_controls_supported &&
+        .support_fp32_signed_zero_nan_preserve =
            float_control.shaderSignedZeroInfNanPreserveFloat32 != VK_FALSE,
-        .support_fp64_signed_zero_nan_preserve = float_controls_supported &&
+        .support_fp64_signed_zero_nan_preserve =
            float_control.shaderSignedZeroInfNanPreserveFloat64 != VK_FALSE,
        .support_explicit_workgroup_layout = device.IsKhrWorkgroupMemoryExplicitLayoutSupported(),
        .support_vote = device.IsSubgroupFeatureSupported(VK_SUBGROUP_FEATURE_VOTE_BIT),
@@ -440,27 +395,6 @@ PipelineCache::PipelineCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,
        .support_conditional_barrier = device.SupportsConditionalBarriers(),
    };

-    profile.warp_stage_support_mask = 0;
-    static constexpr std::array kAllStages{
-        Shader::Stage::VertexA,          Shader::Stage::VertexB,
-        Shader::Stage::TessellationControl, Shader::Stage::TessellationEval,
-        Shader::Stage::Geometry,         Shader::Stage::Fragment,
-        Shader::Stage::Compute,
-    };
-    for (const auto stage : kAllStages) {
-        const auto vk_stage = StageToVkStage(stage);
-        if (device.SupportsWarpIntrinsics(vk_stage)) {
-            profile.warp_stage_support_mask |= 1u << static_cast<u32>(stage);
-        }
-    }
-    profile.support_vote = profile.warp_stage_support_mask != 0;
-
-    if (!profile.SupportsWarpIntrinsics(Shader::Stage::Fragment)) {
-        LOG_WARNING(Render_Vulkan,
-                    "Fragment shaders lack subgroup support on this driver; warp intrinsics will be "
-                    "approximated and visual artifacts may remain");
-    }
-
    if (device.GetMaxVertexInputAttributes() < Maxwell::NumVertexAttributes) {
        LOG_WARNING(Render_Vulkan, "maxVertexInputAttributes is too low: {} < {}",
                    device.GetMaxVertexInputAttributes(), Maxwell::NumVertexAttributes);
@@ -470,40 +404,14 @@ PipelineCache::PipelineCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,
                    device.GetMaxVertexInputBindings(), Maxwell::NumVertexArrays);
    }

-    LOG_INFO(Render_Vulkan, "DynamicState setting value: {}", Settings::values.dyna_state.GetValue());
-    
-    dynamic_features = {};
-    
-    // User granularity enforced in vulkan_device.cpp switch statement:
-    //   Level 0: Core Dynamic States only
-    //   Level 1: Core + EDS1
-    //   Level 2: Core + EDS1 + EDS2 (accumulative)
-    //   Level 3: Core + EDS1 + EDS2 + EDS3 (accumulative)
-    // Here we only verify if extensions were successfully loaded by the device
-    
-    dynamic_features.has_extended_dynamic_state = 
-        device.IsExtExtendedDynamicStateSupported();
-    
-    dynamic_features.has_extended_dynamic_state_2 = 
-        device.IsExtExtendedDynamicState2Supported();
-    dynamic_features.has_extended_dynamic_state_2_logic_op = 
-        device.IsExtExtendedDynamicState2ExtrasSupported();
-    dynamic_features.has_extended_dynamic_state_2_patch_control_points = false;
-    
-    dynamic_features.has_extended_dynamic_state_3_blend = 
-        device.IsExtExtendedDynamicState3BlendingSupported();
-    dynamic_features.has_dual_source_blend = device.SupportsDualSourceBlend();
-    if (!dynamic_features.has_dual_source_blend) {
-        LOG_WARNING(Render_Vulkan, "Dual-source blending unsupported, disabling dynamic blend");
-        dynamic_features.has_extended_dynamic_state_3_blend = false;
-    }
-    dynamic_features.has_extended_dynamic_state_3_enables = 
-        device.IsExtExtendedDynamicState3EnablesSupported();
-    
-    // VIDS: Independent toggle (not affected by dyna_state levels)
-    dynamic_features.has_dynamic_vertex_input = 
-        device.IsExtVertexInputDynamicStateSupported() && 
-        Settings::values.vertex_input_dynamic_state.GetValue();
+    dynamic_features = DynamicFeatures{
+        .has_extended_dynamic_state = device.IsExtExtendedDynamicStateSupported(),
+        .has_extended_dynamic_state_2 = device.IsExtExtendedDynamicState2Supported(),
+        .has_extended_dynamic_state_2_extra = device.IsExtExtendedDynamicState2ExtrasSupported(),
+        .has_extended_dynamic_state_3_blend = device.IsExtExtendedDynamicState3BlendingSupported(),
+        .has_extended_dynamic_state_3_enables = device.IsExtExtendedDynamicState3EnablesSupported(),
+        .has_dynamic_vertex_input = device.IsExtVertexInputDynamicStateSupported(),
+    };
 }

 PipelineCache::~PipelineCache() {
@@ -513,13 +421,6 @@ PipelineCache::~PipelineCache() {
    }
 }

-void PipelineCache::DrainPendingBuilds() {
-    if (!device.HasBrokenParallelShaderCompiling()) {
-        return;
-    }
-    workers.WaitForRequests();
-}
-
 GraphicsPipeline* PipelineCache::CurrentGraphicsPipeline() {

    if (!RefreshStages(graphics_key.unique_hashes)) {
@@ -550,17 +451,12 @@ ComputePipeline* PipelineCache::CurrentComputePipeline() {
        .shared_memory_size = qmd.shared_alloc,
        .workgroup_size{qmd.block_dim_x, qmd.block_dim_y, qmd.block_dim_z},
    };
-    const auto [pair, inserted]{compute_cache.try_emplace(key)};
+    const auto [pair, is_new]{compute_cache.try_emplace(key)};
    auto& pipeline{pair->second};
-    if (!pipeline) {
-        auto [slot, should_build] = AcquireComputeBuildSlot(key);
-        if (!should_build) {
-            WaitForBuildCompletion(slot);
-        } else {
-            pipeline = CreateComputePipeline(key, shader);
-            ReleaseComputeBuildSlot(key, slot);
-        }
+    if (!is_new) {
+        return pipeline.get();
    }
+    pipeline = CreateComputePipeline(key, shader);
    return pipeline.get();
 }

@@ -620,8 +516,8 @@ void PipelineCache::LoadDiskResources(u64 title_id, std::stop_token stop_loading
                dynamic_features.has_extended_dynamic_state ||
            (key.state.extended_dynamic_state_2 != 0) !=
                dynamic_features.has_extended_dynamic_state_2 ||
-            (key.state.extended_dynamic_state_2_logic_op != 0) !=
-                dynamic_features.has_extended_dynamic_state_2_logic_op ||
+            (key.state.extended_dynamic_state_2_extra != 0) !=
+                dynamic_features.has_extended_dynamic_state_2_extra ||
            (key.state.extended_dynamic_state_3_blend != 0) !=
                dynamic_features.has_extended_dynamic_state_3_blend ||
            (key.state.extended_dynamic_state_3_enables != 0) !=
@@ -676,20 +572,13 @@ void PipelineCache::LoadDiskResources(u64 title_id, std::stop_token stop_loading
 }

 GraphicsPipeline* PipelineCache::CurrentGraphicsPipelineSlowPath() {
-    const auto [pair, inserted]{graphics_cache.try_emplace(graphics_key)};
+    const auto [pair, is_new]{graphics_cache.try_emplace(graphics_key)};
    auto& pipeline{pair->second};
+    if (is_new) {
+        pipeline = CreateGraphicsPipeline();
+    }
    if (!pipeline) {
-        const auto key = pair->first;
-        auto [slot, should_build] = AcquireGraphicsBuildSlot(key);
-        if (!should_build) {
-            WaitForBuildCompletion(slot);
-        } else {
-            pipeline = CreateGraphicsPipeline();
-            ReleaseGraphicsBuildSlot(key, slot);
-        }
-        if (!pipeline) {
-            return nullptr;
-        }
+        return nullptr;
    }
    if (current_pipeline) {
        current_pipeline->AddTransition(pipeline.get());
@@ -712,7 +601,6 @@ GraphicsPipeline* PipelineCache::BuiltPipeline(GraphicsPipeline* pipeline) const
    if (draw_state.index_buffer.count <= 6 || draw_state.vertex_buffer.count <= 6) {
        return pipeline;
    }
-    scheduler.KeepAliveTick();
    return nullptr;
 }

@@ -816,10 +704,6 @@ std::unique_ptr<GraphicsPipeline> PipelineCache::CreateGraphicsPipeline(
    }
    LOG_ERROR(Render_Vulkan, "{}", exception.what());
    return nullptr;
-} catch (const vk::Exception& exception) {
-    LOG_ERROR(Render_Vulkan, "Failed to create graphics pipeline 0x{:016x}: {}", key.Hash(),
-              exception.what());
-    return nullptr;
 }

 std::unique_ptr<GraphicsPipeline> PipelineCache::CreateGraphicsPipeline() {
@@ -883,19 +767,6 @@ std::unique_ptr<ComputePipeline> PipelineCache::CreateComputePipeline(
    }

    auto program{TranslateProgram(pools.inst, pools.block, env, cfg, host_info)};
-    const VkDriverIdKHR driver_id = device.GetDriverID();
-    const bool needs_shared_mem_clamp =
-        driver_id == VK_DRIVER_ID_QUALCOMM_PROPRIETARY ||
-        driver_id == VK_DRIVER_ID_ARM_PROPRIETARY;
-    const u32 max_shared_memory = device.GetMaxComputeSharedMemorySize();
-    if (needs_shared_mem_clamp && program.shared_memory_size > max_shared_memory) {
-        LOG_WARNING(Render_Vulkan,
-                    "Compute shader 0x{:016x} requests {}KB shared memory but device max is {}KB - clamping",
-                    key.unique_hash,
-                    program.shared_memory_size / 1024,
-                    max_shared_memory / 1024);
-        program.shared_memory_size = max_shared_memory;
-    }
    const std::vector<u32> code{EmitSPIRV(profile, program, this->optimize_spirv_output)};
    device.SaveShader(code);
    vk::ShaderModule spv_module{BuildShader(device, code)};
@@ -911,10 +782,6 @@ std::unique_ptr<ComputePipeline> PipelineCache::CreateComputePipeline(
 } catch (const Shader::Exception& exception) {
    LOG_ERROR(Render_Vulkan, "{}", exception.what());
    return nullptr;
-} catch (const vk::Exception& exception) {
-    LOG_ERROR(Render_Vulkan, "Failed to create compute pipeline 0x{:016x}: {}", key.Hash(),
-              exception.what());
-    return nullptr;
 }

 void PipelineCache::SerializeVulkanPipelineCache(const std::filesystem::path& filename,
@@ -1012,68 +879,4 @@ vk::PipelineCache PipelineCache::LoadVulkanPipelineCache(const std::filesystem::
    }
 }

-auto PipelineCache::AcquireGraphicsBuildSlot(const GraphicsPipelineCacheKey& key)
-    -> std::pair<InFlightPipelinePtr, bool> {
-    std::scoped_lock lock(graphics_inflight_mutex);
-    auto [it, inserted] = graphics_inflight_builds.try_emplace(key);
-    if (inserted || !it->second) {
-        it->second = std::make_shared<InFlightPipelineBuild>();
-        return {it->second, true};
-    }
-    return {it->second, false};
-}
-
-auto PipelineCache::AcquireComputeBuildSlot(const ComputePipelineCacheKey& key)
-    -> std::pair<InFlightPipelinePtr, bool> {
-    std::scoped_lock lock(compute_inflight_mutex);
-    auto [it, inserted] = compute_inflight_builds.try_emplace(key);
-    if (inserted || !it->second) {
-        it->second = std::make_shared<InFlightPipelineBuild>();
-        return {it->second, true};
-    }
-    return {it->second, false};
-}
-
-void PipelineCache::ReleaseGraphicsBuildSlot(const GraphicsPipelineCacheKey& key,
-                                             const InFlightPipelinePtr& slot) {
-    if (!slot) {
-        return;
-    }
-    {
-        std::scoped_lock slot_lock(slot->mutex);
-        slot->building = false;
-    }
-    slot->cv.notify_all();
-    std::scoped_lock map_lock(graphics_inflight_mutex);
-    auto it = graphics_inflight_builds.find(key);
-    if (it != graphics_inflight_builds.end() && it->second == slot) {
-        graphics_inflight_builds.erase(it);
-    }
-}
-
-void PipelineCache::ReleaseComputeBuildSlot(const ComputePipelineCacheKey& key,
-                                            const InFlightPipelinePtr& slot) {
-    if (!slot) {
-        return;
-    }
-    {
-        std::scoped_lock slot_lock(slot->mutex);
-        slot->building = false;
-    }
-    slot->cv.notify_all();
-    std::scoped_lock map_lock(compute_inflight_mutex);
-    auto it = compute_inflight_builds.find(key);
-    if (it != compute_inflight_builds.end() && it->second == slot) {
-        compute_inflight_builds.erase(it);
-    }
-}
-
-void PipelineCache::WaitForBuildCompletion(const InFlightPipelinePtr& slot) const {
-    if (!slot) {
-        return;
-    }
-    std::unique_lock lock(slot->mutex);
-    slot->cv.wait(lock, [&] { return !slot->building; });
-}
-
 } // namespace Vulkan
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
lizzie	13330d9f40	fix for crashes on TLS due to openorbis being W E I R D	2025-12-26 12:11:19 +00:00
lizzie	83839afee4	change default to opengl	2025-12-26 12:11:19 +00:00
lizzie	abf7f9e660	proper memswap mechanism	2025-12-26 12:11:19 +00:00
lizzie	2e9b83ec60	more stupid stuff	2025-12-26 12:11:19 +00:00
lizzie	31bf016581	fixes 4 stuff	2025-12-26 12:11:19 +00:00
lizzie	158491ca24	swap handling	2025-12-26 12:11:19 +00:00
lizzie	94e2dedf26	license	2025-12-26 12:11:19 +00:00
lizzie	571970c155	add sce_module so it loads on real hw	2025-12-26 12:11:19 +00:00
lizzie	3813d0cc48	fixes for mbedtls	2025-12-26 12:11:19 +00:00
lizzie	dac749063f	adapt to new master	2025-12-26 12:11:19 +00:00
lizzie	f178cb394c	evil haxx	2025-12-26 12:11:19 +00:00
lizzie	07bfa08f99	extra ps4 defs	2025-12-26 12:11:19 +00:00
lizzie	1514146522	make virtual buffer become an optional	2025-12-26 12:11:19 +00:00
lizzie	66143bf7a5	force NO fastmem	2025-12-26 12:11:19 +00:00
lizzie	0dc71ff89a	more memory stuffs	2025-12-26 12:11:19 +00:00
lizzie	7d5e78b3dc	more memory shit	2025-12-26 12:11:19 +00:00
lizzie	9bebc88bcd	MAP_SYSTEM	2025-12-26 12:11:19 +00:00
lizzie	628b1a84b9	(likely) fixes for virtual dmem?	2025-12-26 12:11:19 +00:00
lizzie	2aeb14b096	disable fastmem	2025-12-26 12:11:19 +00:00
lizzie	891c3aee4b	try to fix the paths	2025-12-26 12:11:19 +00:00
lizzie	70496b0400	sysconf stub cuz crash(?) + some stderrp stuff	2025-12-26 12:11:19 +00:00
lizzie	96c1abcbf7	the orb	2025-12-26 12:11:19 +00:00
lizzie	f4d80a0bda	fself + pkg stuffs	2025-12-26 12:11:19 +00:00
lizzie	2ef9cb72c4	make .pkg and .self	2025-12-26 12:11:19 +00:00
lizzie	40b88aaf08	exclude more stuff from vulkan	2025-12-26 12:11:19 +00:00
lizzie	da120cd2b4	exclude from vulkan surface selection	2025-12-26 12:11:19 +00:00
lizzie	9688243e6c	buildable toolchain script + fixes for ffmpeg	2025-12-26 12:11:19 +00:00
lizzie	9dc1b595e0	merge	2025-12-26 12:11:19 +00:00
lizzie	f9977fb46c	merge	2025-12-26 12:11:19 +00:00
lizzie	818ff96fac	fix	2025-12-26 12:11:19 +00:00
lizzie	d057db0a86	[port] initial proof-of-concept PlayStation 4 port Signed-off-by: lizzie <lizzie@eden-emu.dev>	2025-12-26 12:11:19 +00:00
xbzk	cfae726289	[video_core] nvn descriptor layout fix (#3206 ) Yxzx presumes this: // The NVN driver buffer (index 0) is known to pack the SSBO address followed by its size. But in MCI i`ve discovered that there are no sizes, both registers are GPU addresses (hence the 2.8gb allocation, it was an address actually) Method could be much simpler but for safety i`ve routed both old and new worlds. Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/3206 Reviewed-by: Caio Oliveira <caiooliveirafarias0@gmail.com> Reviewed-by: Lizzie <lizzie@eden-emu.dev> Co-authored-by: xbzk <xbzk@eden-emu.dev> Co-committed-by: xbzk <xbzk@eden-emu.dev>	2025-12-26 04:54:14 +01:00
Gamer64	bb94cff886	[chore] Fixed a couple memory leaks using up ~15 MB each iteration (#398 ) Co-authored-by: Jarrod Norwell <official.antique@gmail.com> Co-authored-by: Gamer64 <76565986+Gamer64ytb@users.noreply.github.com> Co-authored-by: Caio Oliveira <caiooliveirafarias0@gmail.com> Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/398 Reviewed-by: Caio Oliveira <caiooliveirafarias0@gmail.com> Reviewed-by: Lizzie <lizzie@eden-emu.dev> Co-authored-by: Gamer64 <gamer64@eden-emu.dev> Co-committed-by: Gamer64 <gamer64@eden-emu.dev>	2025-12-26 02:55:52 +01:00
lizzie	370997f42e	[externals/ffmpeg] remove --disable-postproc causing issues in OpenOrbis toolchain (#3203 ) why was disable-postproc added? either way this fixes build errors not only on PS4 but also on Haiku i think Signed-off-by: lizzie lizzie@eden-emu.dev Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/3203 Reviewed-by: Caio Oliveira <caiooliveirafarias0@gmail.com> Co-authored-by: lizzie <lizzie@eden-emu.dev> Co-committed-by: lizzie <lizzie@eden-emu.dev>	2025-12-26 02:36:08 +01:00
crueter	5213cc5689	Revert "[vk] Correct polygon draw topology mapping for line and point modes (#2834 )" (#3158 ) This reverts commit `6ba25b6cc0`. Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/3158 Reviewed-by: Maufeat <sahyno1996@gmail.com> Reviewed-by: Lizzie <lizzie@eden-emu.dev> Reviewed-by: Caio Oliveira <caiooliveirafarias0@gmail.com>	2025-12-26 02:33:53 +01:00
lizzie	bc9af86269	[externals] update Vulkan headers from 1.4.328.1 -> 1.4.335.0 (#3202 ) notably adds access to `VK_KHR_maintenance10` :) I'm not sure if we want to update vk as regularly as with other deps as the only worthwhile change I saw was the addition of maintainance10 Signed-off-by: lizzie lizzie@eden-emu.dev Co-authored-by: Caio Oliveira <caiooliveirafarias0@gmail.com> Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/3202 Reviewed-by: Caio Oliveira <caiooliveirafarias0@gmail.com> Reviewed-by: crueter <crueter@eden-emu.dev> Co-authored-by: lizzie <lizzie@eden-emu.dev> Co-committed-by: lizzie <lizzie@eden-emu.dev>	2025-12-25 20:48:28 +01:00
Caio Oliveira	00ec67d65b	[android] Properly set Root of the Project (#3177 ) Signed-off-by: Caio Oliveira <caiooliveirafarias0@gmail.com> Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/3177 Reviewed-by: MaranBr <maranbr@eden-emu.dev> Reviewed-by: Lizzie <lizzie@eden-emu.dev> Co-authored-by: Caio Oliveira <caiooliveirafarias0@gmail.com> Co-committed-by: Caio Oliveira <caiooliveirafarias0@gmail.com>	2025-12-23 22:23:56 +01:00
Marcin Serwin	fbd28a9d34	[cmake] fix dynarmic tests (#3192 ) The old style `add_test` invocation is not target aware which means that trying to run the test via `ninja test` results in: Could not find executable dynarmic_tests Signed-off-by: Marcin Serwin <marcin@serwin.dev> Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/3192 Co-authored-by: Marcin Serwin <marcin@serwin.dev> Co-committed-by: Marcin Serwin <marcin@serwin.dev>	2025-12-23 01:34:58 +01:00
Caio Oliveira	3413fbd9da	[FIXUP] Partially revert "[NCE] Fix cache invalidation and signal interrupt race condition (#3063 )" (#3190 ) * this fixes Jamboree and SSB This reverts commit `e3c942b209`. Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/3190 Reviewed-by: Maufeat <sahyno1996@gmail.com> Reviewed-by: MaranBr <maranbr@eden-emu.dev> Co-authored-by: Caio Oliveira <caiooliveirafarias0@gmail.com> Co-committed-by: Caio Oliveira <caiooliveirafarias0@gmail.com>	2025-12-22 02:58:40 +01:00