add MMPX filter

Signed-off-by: lizzie <lizzie@eden-emu.dev>
better logic
2025-09-29 17:56:14 +00:00 · 2025-09-29 17:55:52 +00:00 · 2025-09-29 17:55:52 +00:00 · 2025-09-29 17:55:52 +00:00 · 2025-09-29 17:55:51 +00:00 · 2025-09-29 19:41:01 +02:00
39 changed files with 749 additions and 347 deletions
--- a/.ci/windows/install-msvc.ps1
+++ b/.ci/windows/install-msvc.ps1
@ -10,7 +10,7 @@ if (-not ([bool](net session 2>$null))) {
 }

 $VSVer = "17"
-$ExeFile = "vs_BuildTools.exe"
+$ExeFile = "vs_community.exe"
 $Uri = "https://aka.ms/vs/$VSVer/release/$ExeFile"
 $Destination = "./$ExeFile"

@ -19,21 +19,39 @@ $WebClient = New-Object System.Net.WebClient
 $WebClient.DownloadFile($Uri, $Destination)
 Write-Host "Finished downloading $ExeFile"

-$VSROOT = "C:/VSBuildTools/$VSVer"
 $Arguments = @(
-    "--installPath `"$VSROOT`"",                               # set custom installation path
-    "--quiet",                                                  # suppress UI
-    "--wait",                                                   # wait for installation to complete
-    "--norestart",                                              # prevent automatic restart
-    "--add Microsoft.VisualStudio.Workload.VCTools",            # add C++ build tools workload
-    "--add Microsoft.VisualStudio.Component.VC.Tools.x86.x64",  # add core x86/x64 C++ tools
-    "--add Microsoft.VisualStudio.Component.Windows10SDK.19041" # add specific Windows SDK
+    "--quiet",                                                  # Suppress installer UI
+    "--wait",                                                   # Wait for installation to complete
+    "--norestart",                                              # Prevent automatic restart
+    "--force",                                                  # Force installation even if components are already installed
+    "--add Microsoft.VisualStudio.Workload.NativeDesktop",      # Desktop development with C++
+    "--add Microsoft.VisualStudio.Component.VC.Tools.x86.x64",  # Core C++ compiler/tools for x86/x64
+    "--add Microsoft.VisualStudio.Component.Windows11SDK.26100",# Windows 11 SDK (26100)
+    "--add Microsoft.VisualStudio.Component.Windows10SDK.19041",# Windows 10 SDK (19041)
+    "--add Microsoft.VisualStudio.Component.VC.Llvm.Clang",     # LLVM Clang compiler
+    "--add Microsoft.VisualStudio.Component.VC.Llvm.ClangToolset", # LLVM Clang integration toolset
+    "--add Microsoft.VisualStudio.Component.Windows11SDK.22621",# Windows 11 SDK (22621)
+    "--add Microsoft.VisualStudio.Component.VC.CMake.Project",  # CMake project support
+    "--add Microsoft.VisualStudio.ComponentGroup.VC.Tools.142.x86.x64", # VC++ 14.2 toolset
+    "--add Microsoft.VisualStudio.ComponentGroup.NativeDesktop.Llvm.Clang" # LLVM Clang for native desktop
 )

 Write-Host "Installing Visual Studio Build Tools"
-$InstallProcess = Start-Process -FilePath $Destination -NoNewWindow -PassThru -Wait -ArgumentList $Arguments
-$ExitCode = $InstallProcess.ExitCode
+$InstallProcess = Start-Process -FilePath $Destination -NoNewWindow -PassThru -ArgumentList $Arguments

+# Spinner while installing
+$Spinner = "|/-\"
+$i = 0
+while (-not $InstallProcess.HasExited) {
+    Write-Host -NoNewline ("`rInstalling... " + $Spinner[$i % $Spinner.Length])
+    Start-Sleep -Milliseconds 250
+    $i++
+}
+
+# Clear spinner line
+Write-Host "`rSetup completed!           "
+
+$ExitCode = $InstallProcess.ExitCode
 if ($ExitCode -ne 0) {
    Write-Host "Error installing Visual Studio Build Tools (Error: $ExitCode)"
    Exit $ExitCode
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -895,13 +895,13 @@ if (MSVC AND CXX_CLANG)
 endif()

 if (YUZU_USE_FASTER_LD)
+    # fallback if everything fails (bfd)
+    set(LINKER bfd)
    # clang should always use lld
    find_program(LLD lld)
-
    if (LLD)
        set(LINKER lld)
    endif()
-
    # GNU appears to work better with mold
    # TODO: mold has been slow lately, see if better options exist (search for gold?)
    if (CXX_GCC)
@ -910,7 +910,6 @@ if (YUZU_USE_FASTER_LD)
            set(LINKER mold)
        endif()
    endif()
-
    message(NOTICE "Selecting ${LINKER} as linker")
    add_link_options("-fuse-ld=${LINKER}")
 endif()
--- a/docs/Deps.md
+++ b/docs/Deps.md
@ -4,8 +4,8 @@ To build Eden, you MUST have a C++ compiler.
 * On Linux, this is usually [GCC](https://gcc.gnu.org/) 11+ or [Clang](https://clang.llvm.org/) v14+
  - GCC 12 also requires Clang 14+
 * On Windows, this is either:
-  - **[MSVC](https://visualstudio.microsoft.com/downloads/)**,
-    * *A convenience script to install the **minimal** version (Visual Build Tools) is provided in `.ci/windows/install-msvc.ps1`*
+  - **[MSVC](https://visualstudio.microsoft.com/downloads/)** (you should select *Community* option),
+    * *A convenience script to install the Visual Community Studio 2022 with necessary tools is provided in `.ci/windows/install-msvc.ps1`*
  - clang-cl - can be downloaded from the MSVC installer,
  - or **[MSYS2](https://www.msys2.org)**
 * On macOS, this is Apple Clang
@ -211,4 +211,4 @@ Then install the libraries: `sudo pkg install qt6 boost glslang libzip library/l

 ## All Done

-You may now return to the **[root build guide](Build.md)**.
+You may now return to the **[root build guide](Build.md)**.
--- a/docs/Development.md
+++ b/docs/Development.md
@ -36,6 +36,28 @@ Pull requests are only to be merged by core developers when properly tested and
 - Maintainers are permitted to change namespaces at will.
 - Commits within PRs are not required to be namespaced, but it is highly recommended.

+## Adding new settings
+
+When adding new settings, use `tr("Setting:")` if the setting is meant to be a field, otherwise use `tr("Setting")` if the setting is meant to be a Yes/No or checkmark type of setting, see [this short style guide](https://learn.microsoft.com/en-us/style-guide/punctuation/colons#in-ui).
+
+- The majority of software must work with the default option selected for such setting. Unless the setting significantly degrades performance.
+- Debug settings must never be turned on by default.
+- Provide reasonable bounds (for example, a setting controlling the amount of VRAM should never be 0).
+- The description of the setting must be short and concise, if the setting "does a lot of things" consider splitting the setting into multiple if possible.
+- Try to avoid excessive/redundant explainations "recommended for most users and games" can just be "(recommended)".
+- Try to not write "slow/fast" options unless it clearly degrades/increases performance for a given case, as most options may modify behaviour that result in different metrics accross different systems. If for example the option is an "accuracy" option, writing "High" is sufficient to imply "Slow". No need to write "High (Slow)".
+
+Some examples:
+- "[...] negatively affecting image quality", "[...] degrading image quality": Same wording but with less filler.
+- "[...] this may cause some glitches or crashes in some games", "[...] this may cause soft-crashes": Crashes implies there may be glitches (as crashes are technically a form of a fatal glitch). The entire sentence is structured as "may cause [...] on some games", which is redundant, because "may cause [...] in games" has the same semantic meaning ("may" is a chance that it will occur on "some" given set).
+- "FIFO Relaxed is similar to FIFO [...]", "FIFO Relaxed [...]": The name already implies similarity.
+- "[...] but may also reduce performance in some cases", "[...] but may degrade performance": Again, "some cases" and "may" implies there is a probability.
+- "[...] it can [...] in some cases", "[...] it can [...]": Implied probability.
+
+Before adding a new setting, consider:
+- Does the piece of code that the setting pertains to, make a significant difference if it's on/off?
+- Can it be auto-detected?
+
 # IDE setup

 ## VSCode
--- a/docs/User.md
+++ b/docs/User.md
@ -9,3 +9,21 @@ Eden will store configuration in the following directories:
 - **Linux, macOS, FreeBSD, Solaris, OpenBSD**: `$XDG_DATA_HOME`, `$XDG_CACHE_HOME`, `$XDG_CONFIG_HOME`.

 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.
+
+# Enhancements
+
+## Filters
+
+Various graphical filters exist - each of them aimed at a specific target/image quality preset.
+
+- **Nearest**: Provides no filtering - useful for debugging.
+- **Bilinear**: Provides the hardware default filtering of the Tegra X1.
+- **Bicubic**: Provides a bicubic interpolation using a Catmull-Rom (or hardware-accelerated) implementation.
+- **Zero-Tangent, B-Spline, Mitchell**: Provides bicubic interpolation using the respective matrix weights. They're normally not hardware accelerated unless the device supports the `VK_QCOM_filter_cubic_weights` extension. The matrix weights are those matching [the specification itself](https://registry.khronos.org/vulkan/specs/latest/html/vkspec.html#VkSamplerCubicWeightsCreateInfoQCOM).
+- **Spline-1**: Bicubic interpolation (similar to Mitchell) but with a faster texel fetch method. Generally less blurry than bicubic.
+- **Gaussian**: Whole-area blur, an applied gaussian blur is done to the entire frame.
+- **Lanczos**: An implementation using `a = 3` (49 texel fetches). Provides sharper edges but blurrier artifacts.
+- **ScaleForce**: Experimental texture upscale method, see [ScaleFish](https://github.com/BreadFish64/ScaleFish).
+- **FSR**: Uses AMD FidelityFX Super Resolution to enhance image quality.
+- **Area**: Area interpolation (high kernel count).
+- **MMPX**: Nearest-neighbour filter aimed at providing higher pixel-art quality.
--- a/src/android/app/src/main/res/values/arrays.xml
+++ b/src/android/app/src/main/res/values/arrays.xml
@ -251,10 +251,16 @@
        <item>@string/scaling_filter_nearest_neighbor</item>
        <item>@string/scaling_filter_bilinear</item>
        <item>@string/scaling_filter_bicubic</item>
+        <item>@string/scaling_filter_zero_tangent</item>
+        <item>@string/scaling_filter_bspline</item>
+        <item>@string/scaling_filter_mitchell</item>
+        <item>@string/scaling_filter_spline1</item>
        <item>@string/scaling_filter_gaussian</item>
+        <item>@string/scaling_filter_lanczos</item>
        <item>@string/scaling_filter_scale_force</item>
        <item>@string/scaling_filter_fsr</item>
        <item>@string/scaling_filter_area</item>
+        <item>@string/scaling_filter_mmpx</item>
    </string-array>

    <integer-array name="rendererScalingFilterValues">
@ -265,6 +271,12 @@
        <item>4</item>
        <item>5</item>
        <item>6</item>
+        <item>7</item>
+        <item>8</item>
+        <item>9</item>
+        <item>10</item>
+        <item>11</item>
+        <item>12</item>
    </integer-array>

    <string-array name="rendererAntiAliasingNames">
--- a/src/android/app/src/main/res/values/strings.xml
+++ b/src/android/app/src/main/res/values/strings.xml
@ -865,12 +865,12 @@
    <string name="abort_button">Abort</string>
    <string name="continue_button">Continue</string>
    <string name="system_archive_not_found">System Archive Not Found</string>
-    <string name="system_archive_not_found_message">%s is missing. Please dump your system archives.\nContinuing emulation may result in crashes and bugs.</string>
+    <string name="system_archive_not_found_message">%s is missing. Please dump your system archives.\nContinuing emulation may result in crashes.</string>
    <string name="system_archive_general">A system archive</string>
    <string name="save_load_error">Save/Load Error</string>
    <string name="fatal_error">Fatal Error</string>
-    <string name="fatal_error_message">A fatal error occurred. Check the log for details.\nContinuing emulation may result in crashes and bugs.</string>
-    <string name="performance_warning">Turning off this setting will significantly reduce emulation performance! For the best experience, it is recommended that you leave this setting enabled.</string>
+    <string name="fatal_error_message">A fatal error occurred. Check the log for details.\nContinuing emulation may result in crashes.</string>
+    <string name="performance_warning">Turning off this setting will significantly degrade performance. It's recommended that you leave this setting enabled.</string>
    <string name="device_memory_inadequate">Device RAM: %1$s\nRecommended: %2$s</string>
    <string name="memory_formatted">%1$s %2$s</string>
    <string name="no_game_present">No bootable game present!</string>
@ -941,12 +941,12 @@
    <!-- Renderer Accuracy -->
    <string name="renderer_accuracy_normal">Normal</string>
    <string name="renderer_accuracy_high">High</string>
-    <string name="renderer_accuracy_extreme">Extreme (Slow)</string>
+    <string name="renderer_accuracy_extreme">Extreme</string>

    <!-- DMA Accuracy -->
    <string name="dma_accuracy_default">Default</string>
-    <string name="dma_accuracy_unsafe">Unsafe (fast)</string>
-    <string name="dma_accuracy_safe">Safe (stable)</string>
+    <string name="dma_accuracy_unsafe">Unsafe</string>
+    <string name="dma_accuracy_safe">Safe</string>

    <!-- ASTC Decoding Method -->
    <string name="accelerate_astc">ASTC Decoding Method</string>
@ -992,10 +992,16 @@
    <string name="scaling_filter_nearest_neighbor">Nearest Neighbor</string>
    <string name="scaling_filter_bilinear">Bilinear</string>
    <string name="scaling_filter_bicubic">Bicubic</string>
+    <string name="scaling_filter_spline1">Spline-1</string>
    <string name="scaling_filter_gaussian">Gaussian</string>
+    <string name="scaling_filter_lanczos">Lanczos</string>
    <string name="scaling_filter_scale_force">ScaleForce</string>
    <string name="scaling_filter_fsr">AMD FidelityFX™ Super Resolution</string>
    <string name="scaling_filter_area">Area</string>
+    <string name="scaling_filter_zero_tangent">Zero-Tangent</string>
+    <string name="scaling_filter_bspline">B-Spline</string>
+    <string name="scaling_filter_mitchell">Mitchell</string>
+    <string name="scaling_filter_mmpx">MMPX</string>

    <!-- Anti-Aliasing -->
    <string name="anti_aliasing_none">None</string>
--- a/src/common/settings.h
+++ b/src/common/settings.h
@ -178,7 +178,7 @@ struct Values {
    SwitchableSetting<std::string> audio_input_device_id{
                                                         linkage, "auto", "input_device", Category::Audio, Specialization::RuntimeList};
    SwitchableSetting<AudioMode, true> sound_index{
-                                                   linkage,       AudioMode::Stereo,     AudioMode::Mono,         AudioMode::Surround,
+                                                   linkage,       AudioMode::Stereo,
                                                   "sound_index", Category::SystemAudio, Specialization::Default, true,
                                                   true};
    SwitchableSetting<u8, true> volume{linkage,
@ -199,8 +199,6 @@ struct Values {
    SwitchableSetting<bool> use_multi_core{linkage, true, "use_multi_core", Category::Core};
    SwitchableSetting<MemoryLayout, true> memory_layout_mode{linkage,
                                                             MemoryLayout::Memory_4Gb,
-                                                             MemoryLayout::Memory_4Gb,
-                                                             MemoryLayout::Memory_12Gb,
                                                             "memory_layout_mode",
                                                             Category::Core,
                                                             Specialization::Default,
@ -240,9 +238,8 @@ struct Values {
 #endif
                                                    "cpu_backend",
                                                    Category::Cpu};
-    SwitchableSetting<CpuAccuracy, true> cpu_accuracy{linkage,           CpuAccuracy::Auto,
-                                                      CpuAccuracy::Auto, CpuAccuracy::Paranoid,
-                                                      "cpu_accuracy",    Category::Cpu};
+    SwitchableSetting<CpuAccuracy, true> cpu_accuracy{linkage, CpuAccuracy::Auto,
+                                                      "cpu_accuracy", Category::Cpu};

    SwitchableSetting<bool> use_fast_cpu_time{linkage,
                                              false,
@ -324,10 +321,10 @@ struct Values {

    // Renderer
    SwitchableSetting<RendererBackend, true> renderer_backend{
-                                                              linkage,   RendererBackend::Vulkan, RendererBackend::OpenGL, RendererBackend::Null,
+                                                              linkage, RendererBackend::Vulkan,
                                                              "backend", Category::Renderer};
    SwitchableSetting<ShaderBackend, true> shader_backend{
-                                                          linkage,          ShaderBackend::SpirV, ShaderBackend::Glsl,        ShaderBackend::SpirV,
+                                                          linkage, ShaderBackend::SpirV,
                                                          "shader_backend", Category::Renderer,  Specialization::RuntimeList};
    SwitchableSetting<int> vulkan_device{linkage, 0, "vulkan_device", Category::Renderer,
                                         Specialization::RuntimeList};
@ -342,8 +339,6 @@ struct Values {
                                                  Category::Renderer};
    SwitchableSetting<SpirvOptimizeMode, true> optimize_spirv_output{linkage,
                                                                     SpirvOptimizeMode::Never,
-                                                                     SpirvOptimizeMode::Never,
-                                                                     SpirvOptimizeMode::Always,
                                                                     "optimize_spirv_output",
                                                                     Category::Renderer};
    SwitchableSetting<bool> use_asynchronous_gpu_emulation{
@ -354,12 +349,10 @@ struct Values {
 #else
                                                            AstcDecodeMode::Gpu,
 #endif
-                                                            AstcDecodeMode::Cpu,
-                                                            AstcDecodeMode::CpuAsynchronous,
                                                            "accelerate_astc",
                                                            Category::Renderer};
    SwitchableSetting<VSyncMode, true> vsync_mode{
-                                                  linkage,     VSyncMode::Fifo,    VSyncMode::Immediate,        VSyncMode::FifoRelaxed,
+                                                  linkage,     VSyncMode::Fifo,
                                                  "use_vsync", Category::Renderer, Specialization::RuntimeList, true,
                                                  true};
    SwitchableSetting<NvdecEmulation> nvdec_emulation{linkage, NvdecEmulation::Gpu,
@ -372,8 +365,6 @@ struct Values {
 #else
                                                            FullscreenMode::Exclusive,
 #endif
-                                                            FullscreenMode::Borderless,
-                                                            FullscreenMode::Exclusive,
                                                            "fullscreen_mode",
                                                            Category::Renderer,
                                                            Specialization::Default,
@ -381,8 +372,6 @@ struct Values {
                                                            true};
    SwitchableSetting<AspectRatio, true> aspect_ratio{linkage,
                                                      AspectRatio::R16_9,
-                                                      AspectRatio::R16_9,
-                                                      AspectRatio::Stretch,
                                                      "aspect_ratio",
                                                      Category::Renderer,
                                                      Specialization::Default,
@ -430,8 +419,6 @@ struct Values {
 #else
                                                      GpuAccuracy::High,
 #endif
-                                                      GpuAccuracy::Normal,
-                                                      GpuAccuracy::Extreme,
                                                      "gpu_accuracy",
                                                      Category::RendererAdvanced,
                                                      Specialization::Default,
@ -442,8 +429,6 @@ struct Values {

    SwitchableSetting<DmaAccuracy, true> dma_accuracy{linkage,
                                                      DmaAccuracy::Default,
-                                                      DmaAccuracy::Default,
-                                                      DmaAccuracy::Safe,
                                                      "dma_accuracy",
                                                      Category::RendererAdvanced,
                                                      Specialization::Default,
@ -456,20 +441,14 @@ struct Values {
 #else
                                                           AnisotropyMode::Automatic,
 #endif
-                                                           AnisotropyMode::Automatic,
-                                                           AnisotropyMode::X16,
                                                           "max_anisotropy",
                                                           Category::RendererAdvanced};
    SwitchableSetting<AstcRecompression, true> astc_recompression{linkage,
                                                                  AstcRecompression::Uncompressed,
-                                                                  AstcRecompression::Uncompressed,
-                                                                  AstcRecompression::Bc3,
                                                                  "astc_recompression",
                                                                  Category::RendererAdvanced};
    SwitchableSetting<VramUsageMode, true> vram_usage_mode{linkage,
                                                           VramUsageMode::Conservative,
-                                                           VramUsageMode::Conservative,
-                                                           VramUsageMode::Aggressive,
                                                           "vram_usage_mode",
                                                           Category::RendererAdvanced};
    SwitchableSetting<bool> skip_cpu_inner_invalidation{linkage,
@ -595,14 +574,10 @@ struct Values {
    // System
    SwitchableSetting<Language, true> language_index{linkage,
                                                     Language::EnglishAmerican,
-                                                     Language::Japanese,
-                                                     Language::Serbian,
                                                     "language_index",
                                                     Category::System};
-    SwitchableSetting<Region, true> region_index{linkage,        Region::Usa,    Region::Japan,
-                                                 Region::Taiwan, "region_index", Category::System};
-    SwitchableSetting<TimeZone, true> time_zone_index{linkage,           TimeZone::Auto,
-                                                      TimeZone::Auto,    TimeZone::Zulu,
+    SwitchableSetting<Region, true> region_index{linkage, Region::Usa, "region_index", Category::System};
+    SwitchableSetting<TimeZone, true> time_zone_index{linkage, TimeZone::Auto,
                                                      "time_zone_index", Category::System};
    // Measured in seconds since epoch
    SwitchableSetting<bool> custom_rtc_enabled{
--- a/src/common/settings_enums.h
+++ b/src/common/settings_enums.h
@ -10,6 +10,7 @@
 #pragma once

 #include <string>
+#include <string_view>
 #include <utility>
 #include <vector>
 #include "common/common_types.h"
@ -18,8 +19,10 @@ namespace Settings {

 template <typename T>
 struct EnumMetadata {
-    static std::vector<std::pair<std::string, T>> Canonicalizations();
+    static std::vector<std::pair<std::string_view, T>> Canonicalizations();
    static u32 Index();
+    static constexpr T GetFirst();
+    static constexpr T GetLast();
 };

 #define PAIR_45(N, X, ...) {#X, N::X} __VA_OPT__(, PAIR_46(N, __VA_ARGS__))
@ -69,138 +72,101 @@ struct EnumMetadata {
 #define PAIR_1(N, X, ...) {#X, N::X} __VA_OPT__(, PAIR_2(N, __VA_ARGS__))
 #define PAIR(N, X, ...) {#X, N::X} __VA_OPT__(, PAIR_1(N, __VA_ARGS__))

-#define ENUM(NAME, ...)                                                                            \
-    enum class NAME : u32 { __VA_ARGS__ };                                                         \
-    template <>                                                                                    \
-    inline std::vector<std::pair<std::string, NAME>> EnumMetadata<NAME>::Canonicalizations() {     \
-        return {PAIR(NAME, __VA_ARGS__)};                                                          \
-    }                                                                                              \
-    template <>                                                                                    \
-    inline u32 EnumMetadata<NAME>::Index() {                                                       \
-        return __COUNTER__;                                                                        \
+#define PP_HEAD(A, ...) A
+
+#define ENUM(NAME, ...) \
+    enum class NAME : u32 { __VA_ARGS__ }; \
+    template<> inline std::vector<std::pair<std::string_view, NAME>> EnumMetadata<NAME>::Canonicalizations() { \
+        return {PAIR(NAME, __VA_ARGS__)}; \
+    } \
+    template<> inline u32 EnumMetadata<NAME>::Index() { \
+        return __COUNTER__; \
+    } \
+    template<> inline constexpr NAME EnumMetadata<NAME>::GetFirst() { \
+        return NAME::PP_HEAD(__VA_ARGS__); \
+    } \
+    template<> inline constexpr NAME EnumMetadata<NAME>::GetLast() { \
+        return (std::vector<std::pair<std::string_view, NAME>>{PAIR(NAME, __VA_ARGS__)}).back().second; \
    }

 // AudioEngine must be specified discretely due to having existing but slightly different
 // canonicalizations
 // TODO (lat9nq): Remove explicit definition of AudioEngine/sink_id
-enum class AudioEngine : u32 {
-    Auto,
-    Cubeb,
-    Sdl2,
-    Null,
-    Oboe,
-};
-
-template <>
-inline std::vector<std::pair<std::string, AudioEngine>>
-EnumMetadata<AudioEngine>::Canonicalizations() {
+enum class AudioEngine : u32 { Auto, Cubeb, Sdl2, Null, Oboe, };
+template<>
+inline std::vector<std::pair<std::string_view, AudioEngine>> EnumMetadata<AudioEngine>::Canonicalizations() {
    return {
        {"auto", AudioEngine::Auto}, {"cubeb", AudioEngine::Cubeb}, {"sdl2", AudioEngine::Sdl2},
        {"null", AudioEngine::Null}, {"oboe", AudioEngine::Oboe},
    };
 }
-
-template <>
+/// @brief This is just a sufficiently large number that is more than the number of other enums declared here
+template<>
 inline u32 EnumMetadata<AudioEngine>::Index() {
-    // This is just a sufficiently large number that is more than the number of other enums declared
-    // here
    return 100;
 }
+template<>
+inline constexpr AudioEngine EnumMetadata<AudioEngine>::GetFirst() {
+    return AudioEngine::Auto;
+}
+template<>
+inline constexpr AudioEngine EnumMetadata<AudioEngine>::GetLast() {
+    return AudioEngine::Oboe;
+}

 ENUM(AudioMode, Mono, Stereo, Surround);
+static_assert(EnumMetadata<AudioMode>::GetFirst() == AudioMode::Mono);
+static_assert(EnumMetadata<AudioMode>::GetLast() == AudioMode::Surround);

 ENUM(Language, Japanese, EnglishAmerican, French, German, Italian, Spanish, Chinese, Korean, Dutch,
     Portuguese, Russian, Taiwanese, EnglishBritish, FrenchCanadian, SpanishLatin,
     ChineseSimplified, ChineseTraditional, PortugueseBrazilian, Serbian);
-
 ENUM(Region, Japan, Usa, Europe, Australia, China, Korea, Taiwan);
-
 ENUM(TimeZone, Auto, Default, Cet, Cst6Cdt, Cuba, Eet, Egypt, Eire, Est, Est5Edt, Gb, GbEire, Gmt,
-     GmtPlusZero, GmtMinusZero, GmtZero, Greenwich, Hongkong, Hst, Iceland, Iran, Israel, Jamaica,
-     Japan, Kwajalein, Libya, Met, Mst, Mst7Mdt, Navajo, Nz, NzChat, Poland, Portugal, Prc, Pst8Pdt,
-     Roc, Rok, Singapore, Turkey, Uct, Universal, Utc, WSu, Wet, Zulu);
-
+    GmtPlusZero, GmtMinusZero, GmtZero, Greenwich, Hongkong, Hst, Iceland, Iran, Israel, Jamaica,
+    Japan, Kwajalein, Libya, Met, Mst, Mst7Mdt, Navajo, Nz, NzChat, Poland, Portugal, Prc, Pst8Pdt,
+    Roc, Rok, Singapore, Turkey, Uct, Universal, Utc, WSu, Wet, Zulu);
 ENUM(AnisotropyMode, Automatic, Default, X2, X4, X8, X16);
-
 ENUM(AstcDecodeMode, Cpu, Gpu, CpuAsynchronous);
-
 ENUM(AstcRecompression, Uncompressed, Bc1, Bc3);
-
 ENUM(VSyncMode, Immediate, Mailbox, Fifo, FifoRelaxed);
-
 ENUM(VramUsageMode, Conservative, Aggressive);
-
 ENUM(RendererBackend, OpenGL, Vulkan, Null);
-
 ENUM(ShaderBackend, Glsl, Glasm, SpirV);
-
 ENUM(GpuAccuracy, Normal, High, Extreme);
-
 ENUM(DmaAccuracy, Default, Unsafe, Safe);
-
 ENUM(CpuBackend, Dynarmic, Nce);
-
 ENUM(CpuAccuracy, Auto, Accurate, Unsafe, Paranoid);
-
 ENUM(CpuClock, Boost, Fast)
-
 ENUM(MemoryLayout, Memory_4Gb, Memory_6Gb, Memory_8Gb, Memory_10Gb, Memory_12Gb);
-
 ENUM(ConfirmStop, Ask_Always, Ask_Based_On_Game, Ask_Never);
-
 ENUM(FullscreenMode, Borderless, Exclusive);
-
 ENUM(NvdecEmulation, Off, Cpu, Gpu);
-
-ENUM(ResolutionSetup,
-     Res1_4X,
-     Res1_2X,
-     Res3_4X,
-     Res1X,
-     Res3_2X,
-     Res2X,
-     Res3X,
-     Res4X,
-     Res5X,
-     Res6X,
-     Res7X,
-     Res8X);
-
-ENUM(ScalingFilter, NearestNeighbor, Bilinear, Bicubic, Spline1, Gaussian, Lanczos, ScaleForce, Fsr, Area, MaxEnum);
-
+ENUM(ResolutionSetup, Res1_4X, Res1_2X, Res3_4X, Res1X, Res3_2X, Res2X, Res3X, Res4X, Res5X, Res6X, Res7X, Res8X);
+ENUM(ScalingFilter, NearestNeighbor, Bilinear, Bicubic, ZeroTangent, BSpline, Mitchell, Spline1, Gaussian, Lanczos, ScaleForce, Fsr, Area, Mmpx, MaxEnum);
 ENUM(AntiAliasing, None, Fxaa, Smaa, MaxEnum);
-
 ENUM(AspectRatio, R16_9, R4_3, R21_9, R16_10, Stretch);
-
 ENUM(ConsoleMode, Handheld, Docked);
-
 ENUM(AppletMode, HLE, LLE);
-
 ENUM(SpirvOptimizeMode, Never, OnLoad, Always);
-
 ENUM(GpuOverclock, Low, Medium, High)
-
 ENUM(TemperatureUnits, Celsius, Fahrenheit)

 template <typename Type>
-inline std::string CanonicalizeEnum(Type id) {
+inline std::string_view CanonicalizeEnum(Type id) {
    const auto group = EnumMetadata<Type>::Canonicalizations();
-    for (auto& [name, value] : group) {
-        if (value == id) {
+    for (auto& [name, value] : group)
+        if (value == id)
            return name;
-        }
-    }
    return "unknown";
 }

 template <typename Type>
 inline Type ToEnum(const std::string& canonicalization) {
    const auto group = EnumMetadata<Type>::Canonicalizations();
-    for (auto& [name, value] : group) {
-        if (name == canonicalization) {
+    for (auto& [name, value] : group)
+        if (name == canonicalization)
            return value;
-        }
-    }
    return {};
 }
 } // namespace Settings
--- a/src/common/settings_setting.h
+++ b/src/common/settings_setting.h
@ -72,10 +72,17 @@ public:
                     u32 specialization_ = Specialization::Default, bool save_ = true,
                     bool runtime_modifiable_ = false, BasicSetting* other_setting_ = nullptr)
        requires(ranged)
-        : BasicSetting(linkage, name, category_, save_, runtime_modifiable_, specialization_,
-                       other_setting_),
+        : BasicSetting(linkage, name, category_, save_, runtime_modifiable_, specialization_, other_setting_),
          value{default_val}, default_value{default_val}, maximum{max_val}, minimum{min_val} {}

+    explicit Setting(Linkage& linkage, const Type& default_val,
+                     const std::string& name, Category category_,
+                     u32 specialization_ = Specialization::Default, bool save_ = true,
+                     bool runtime_modifiable_ = false, BasicSetting* other_setting_ = nullptr)
+        requires(ranged && std::is_enum_v<Type>)
+        : BasicSetting(linkage, name, category_, save_, runtime_modifiable_, specialization_, other_setting_),
+          value{default_val}, default_value{default_val}, maximum{EnumMetadata<Type>::GetLast()}, minimum{EnumMetadata<Type>::GetFirst()} {}
+
    /**
     *  Returns a reference to the setting's value.
     *
@ -119,9 +126,6 @@ protected:
            return value_.has_value() ? std::to_string(*value_) : "none";
        } else if constexpr (std::is_same_v<Type, bool>) {
            return value_ ? "true" : "false";
-        } else if constexpr (std::is_same_v<Type, AudioEngine>) {
-            // Compatibility with old AudioEngine setting being a string
-            return CanonicalizeEnum(value_);
        } else if constexpr (std::is_floating_point_v<Type>) {
            return fmt::format("{:f}", value_);
        } else if constexpr (std::is_enum_v<Type>) {
@ -207,7 +211,7 @@ public:

    [[nodiscard]] std::string Canonicalize() const override final {
        if constexpr (std::is_enum_v<Type>) {
-            return CanonicalizeEnum(this->GetValue());
+            return std::string{CanonicalizeEnum(this->GetValue())};
        } else {
            return ToString(this->GetValue());
        }
@ -288,41 +292,32 @@ public:
     * @param other_setting_ A second Setting to associate to this one in metadata
     */
    template <typename T = BasicSetting>
-    explicit SwitchableSetting(Linkage& linkage, const Type& default_val, const std::string& name,
-                               Category category_, u32 specialization_ = Specialization::Default,
-                               bool save_ = true, bool runtime_modifiable_ = false,
-                               typename std::enable_if<!ranged, T*>::type other_setting_ = nullptr)
-        : Setting<Type, false>{
-              linkage, default_val,         name,          category_, specialization_,
-              save_,   runtime_modifiable_, other_setting_} {
+    explicit SwitchableSetting(Linkage& linkage, const Type& default_val, const std::string& name, Category category_, u32 specialization_ = Specialization::Default, bool save_ = true, bool runtime_modifiable_ = false, T* other_setting_ = nullptr) requires(!ranged)
+        : Setting<Type, false>{ linkage, default_val, name, category_, specialization_, save_, runtime_modifiable_, other_setting_} {
        linkage.restore_functions.emplace_back([this]() { this->SetGlobal(true); });
    }
    virtual ~SwitchableSetting() = default;

-    /**
-     * Sets a default value, minimum value, maximum value, and label.
-     *
-     * @param linkage Setting registry
-     * @param default_val Initial value of the setting, and default value of the setting
-     * @param min_val Sets the minimum allowed value of the setting
-     * @param max_val Sets the maximum allowed value of the setting
-     * @param name Label for the setting
-     * @param category_ Category of the setting AKA INI group
-     * @param specialization_ Suggestion for how frontend implementations represent this in a config
-     * @param save_ Suggests that this should or should not be saved to a frontend config file
-     * @param runtime_modifiable_ Suggests whether this is modifiable while a guest is loaded
-     * @param other_setting_ A second Setting to associate to this one in metadata
-     */
+    /// @brief Sets a default value, minimum value, maximum value, and label.
+    /// @param linkage Setting registry
+    /// @param default_val Initial value of the setting, and default value of the setting
+    /// @param min_val Sets the minimum allowed value of the setting
+    /// @param max_val Sets the maximum allowed value of the setting
+    /// @param name Label for the setting
+    /// @param category_ Category of the setting AKA INI group
+    /// @param specialization_ Suggestion for how frontend implementations represent this in a config
+    /// @param save_ Suggests that this should or should not be saved to a frontend config file
+    /// @param runtime_modifiable_ Suggests whether this is modifiable while a guest is loaded
+    /// @param other_setting_ A second Setting to associate to this one in metadata
    template <typename T = BasicSetting>
-    explicit SwitchableSetting(Linkage& linkage, const Type& default_val, const Type& min_val,
-                               const Type& max_val, const std::string& name, Category category_,
-                               u32 specialization_ = Specialization::Default, bool save_ = true,
-                               bool runtime_modifiable_ = false,
-                               typename std::enable_if<ranged, T*>::type other_setting_ = nullptr)
-        : Setting<Type, true>{linkage,         default_val, min_val,
-                              max_val,         name,        category_,
-                              specialization_, save_,       runtime_modifiable_,
-                              other_setting_} {
+    explicit SwitchableSetting(Linkage& linkage, const Type& default_val, const Type& min_val, const Type& max_val, const std::string& name, Category category_, u32 specialization_ = Specialization::Default, bool save_ = true, bool runtime_modifiable_ = false, T* other_setting_ = nullptr) requires(ranged)
+        : Setting<Type, true>{linkage, default_val, min_val, max_val, name, category_, specialization_, save_, runtime_modifiable_, other_setting_} {
+        linkage.restore_functions.emplace_back([this]() { this->SetGlobal(true); });
+    }
+
+    template <typename T = BasicSetting>
+    explicit SwitchableSetting(Linkage& linkage, const Type& default_val, const std::string& name, Category category_, u32 specialization_ = Specialization::Default, bool save_ = true, bool runtime_modifiable_ = false, T* other_setting_ = nullptr) requires(ranged)
+        : Setting<Type, true>{linkage, default_val, EnumMetadata<Type>::GetFirst(), EnumMetadata<Type>::GetLast(), name, category_, specialization_, save_, runtime_modifiable_, other_setting_} {
        linkage.restore_functions.emplace_back([this]() { this->SetGlobal(true); });
    }

--- a/src/core/hle/service/am/applet.h
+++ b/src/core/hle/service/am/applet.h
@ -8,6 +8,7 @@

 #include <deque>
 #include <mutex>
+#include <stack>

 #include "common/math_util.h"
 #include "core/hle/service/apm/apm_controller.h"
@ -23,6 +24,7 @@
 #include "core/hle/service/am/hid_registration.h"
 #include "core/hle/service/am/lifecycle_manager.h"
 #include "core/hle/service/am/process_holder.h"
+#include "core/hle/service/am/service/storage.h"

 namespace Service::AM {

@ -97,6 +99,9 @@ struct Applet {
    std::deque<std::vector<u8>> preselected_user_launch_parameter{};
    std::deque<std::vector<u8>> friend_invitation_storage_channel{};

+    // Context Stack
+    std::stack<SharedPointer<IStorage>> context_stack{};
+
    // Caller applet
    std::weak_ptr<Applet> caller_applet{};
    std::shared_ptr<AppletDataBroker> caller_applet_broker{};
--- a/src/core/hle/service/am/service/process_winding_controller.cpp
+++ b/src/core/hle/service/am/service/process_winding_controller.cpp
@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@ -15,12 +18,12 @@ IProcessWindingController::IProcessWindingController(Core::System& system_,
    static const FunctionInfo functions[] = {
        {0, D<&IProcessWindingController::GetLaunchReason>, "GetLaunchReason"},
        {11, D<&IProcessWindingController::OpenCallingLibraryApplet>, "OpenCallingLibraryApplet"},
-        {21, nullptr, "PushContext"},
-        {22, nullptr, "PopContext"},
-        {23, nullptr, "CancelWindingReservation"},
-        {30, nullptr, "WindAndDoReserved"},
-        {40, nullptr, "ReserveToStartAndWaitAndUnwindThis"},
-        {41, nullptr, "ReserveToStartAndWait"},
+        {21, D<&IProcessWindingController::PushContext>, "PushContext"},
+        {22, D<&IProcessWindingController::PopContext>, "PopContext"},
+        {23, D<&IProcessWindingController::CancelWindingReservation>, "CancelWindingReservation"},
+        {30, D<&IProcessWindingController::WindAndDoReserved>, "WindAndDoReserved"},
+        {40, D<&IProcessWindingController::ReserveToStartAndWaitAndUnwindThis>, "ReserveToStartAndWaitAndUnwindThis"},
+        {41, D<&IProcessWindingController::ReserveToStartAndWait>, "ReserveToStartAndWait"},
    };
    // clang-format on

@ -51,4 +54,43 @@ Result IProcessWindingController::OpenCallingLibraryApplet(
    R_SUCCEED();
 }

+Result IProcessWindingController::PushContext(SharedPointer<IStorage> context) {
+    LOG_INFO(Service_AM, "called");
+    m_applet->context_stack.push(context);
+    R_SUCCEED();
+}
+
+Result IProcessWindingController::PopContext(Out<SharedPointer<IStorage>> out_context) {
+    LOG_INFO(Service_AM, "called");
+
+    if (m_applet->context_stack.empty()) {
+        LOG_ERROR(Service_AM, "Context stack is empty");
+        R_THROW(ResultUnknown);
+    }
+
+    *out_context = m_applet->context_stack.top();
+    m_applet->context_stack.pop();
+    R_SUCCEED();
+}
+
+Result IProcessWindingController::CancelWindingReservation() {
+    LOG_WARNING(Service_AM, "STUBBED");
+    R_SUCCEED();
+}
+
+Result IProcessWindingController::WindAndDoReserved() {
+    LOG_WARNING(Service_AM, "STUBBED");
+    R_SUCCEED();
+}
+
+Result IProcessWindingController::ReserveToStartAndWaitAndUnwindThis() {
+    LOG_WARNING(Service_AM, "STUBBED");
+    R_SUCCEED();
+}
+
+Result IProcessWindingController::ReserveToStartAndWait() {
+    LOG_WARNING(Service_AM, "STUBBED");
+    R_SUCCEED();
+}
+
 } // namespace Service::AM
--- a/src/core/hle/service/am/service/process_winding_controller.h
+++ b/src/core/hle/service/am/service/process_winding_controller.h
@ -1,8 +1,12 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

 #pragma once

+#include "core/hle/service/am/service/storage.h"
 #include "core/hle/service/am/am_types.h"
 #include "core/hle/service/cmif_types.h"
 #include "core/hle/service/service.h"
@ -21,6 +25,12 @@ private:
    Result GetLaunchReason(Out<AppletProcessLaunchReason> out_launch_reason);
    Result OpenCallingLibraryApplet(
        Out<SharedPointer<ILibraryAppletAccessor>> out_calling_library_applet);
+    Result PushContext(SharedPointer<IStorage> in_context);
+    Result PopContext(Out<SharedPointer<IStorage>> out_context);
+    Result CancelWindingReservation();
+    Result WindAndDoReserved();
+    Result ReserveToStartAndWaitAndUnwindThis();
+    Result ReserveToStartAndWait();

    const std::shared_ptr<Applet> m_applet;
 };
--- a/src/core/hle/service/am/service/self_controller.cpp
+++ b/src/core/hle/service/am/service/self_controller.cpp
@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@ -67,6 +70,7 @@ ISelfController::ISelfController(Core::System& system_, std::shared_ptr<Applet>
        {110, nullptr, "SetApplicationAlbumUserData"},
        {120, D<&ISelfController::SaveCurrentScreenshot>, "SaveCurrentScreenshot"},
        {130, D<&ISelfController::SetRecordVolumeMuted>, "SetRecordVolumeMuted"},
+        {230, D<&ISelfController::Unknown230>, "Unknown230"},
        {1000, nullptr, "GetDebugStorageChannel"},
    };
    // clang-format on
@ -404,4 +408,12 @@ Result ISelfController::SetRecordVolumeMuted(bool muted) {
    R_SUCCEED();
 }

+Result ISelfController::Unknown230(u32 in_val, Out<u16> out_val) {
+    LOG_WARNING(Service_AM, "(STUBBED) called, in_val={}", in_val);
+
+    *out_val = 0;
+
+    R_SUCCEED();
+}
+
 } // namespace Service::AM
--- a/src/core/hle/service/am/service/self_controller.h
+++ b/src/core/hle/service/am/service/self_controller.h
@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@ -63,6 +66,7 @@ private:
    Result SetAlbumImageTakenNotificationEnabled(bool enabled);
    Result SaveCurrentScreenshot(Capture::AlbumReportOption album_report_option);
    Result SetRecordVolumeMuted(bool muted);
+    Result Unknown230(u32 in_val, Out<u16> out_val);

    Kernel::KProcess* const m_process;
    const std::shared_ptr<Applet> m_applet;
--- a/src/dynarmic/tests/CMakeLists.txt
+++ b/src/dynarmic/tests/CMakeLists.txt
@ -135,6 +135,8 @@ 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)

-target_compile_options(dynarmic_tests PRIVATE -mavx2)
+if ("x86_64" IN_LIST ARCHITECTURE)
+    target_compile_options(dynarmic_tests PRIVATE -mavx2)
+endif()

 add_test(dynarmic_tests dynarmic_tests --durations yes)
--- a/src/qt_common/shared_translation.cpp
+++ b/src/qt_common/shared_translation.cpp
@ -62,22 +62,20 @@ std::unique_ptr<TranslationMap> InitializeTranslations(QObject* parent)
        Settings,
        use_multi_core,
        tr("Multicore CPU Emulation"),
-        tr("This option increases CPU emulation thread use from 1 to the Switch’s maximum of 4.\n"
-           "This is mainly a debug option and shouldn’t be disabled."));
+        tr("This option increases CPU emulation thread use from 1 to the maximum of 4.\n"
+           "This is mainly a debug option and shouldn't be disabled."));
    INSERT(
        Settings,
        memory_layout_mode,
        tr("Memory Layout"),
-        tr("Increases the amount of emulated RAM from the stock 4GB of the retail Switch to the "
-           "developer kit's 8/6GB.\nIt’s doesn’t improve stability or performance and is intended "
-           "to let big texture mods fit in emulated RAM.\nEnabling it will increase memory "
-           "use. It is not recommended to enable unless a specific game with a texture mod needs "
-           "it."));
+        tr("Increases the amount of emulated RAM from 4GB of the board to the "
+           "devkit 8/6GB.\nDoesn't affect performance/stability but may allow HD texture "
+           "mods to load."));
    INSERT(Settings, use_speed_limit, QString(), QString());
    INSERT(Settings,
           speed_limit,
           tr("Limit Speed Percent"),
-           tr("Controls the game's maximum rendering speed, but it’s up to each game if it runs "
+           tr("Controls the game's maximum rendering speed, but it's up to each game if it runs "
              "faster or not.\n200% for a 30 FPS game is 60 FPS, and for a "
              "60 FPS game it will be 120 FPS.\nDisabling it means unlocking the framerate to the "
              "maximum your PC can reach."));
@ -86,15 +84,13 @@ std::unique_ptr<TranslationMap> InitializeTranslations(QObject* parent)
           tr("Synchronize Core Speed"),
           tr("Synchronizes CPU core speed with the game's maximum rendering speed to boost FPS "
              "without affecting game speed (animations, physics, etc.).\n"
-              "Compatibility varies by game; many (especially older ones) may not respond well.\n"
              "Can help reduce stuttering at lower framerates."));

    // Cpu
    INSERT(Settings,
           cpu_accuracy,
           tr("Accuracy:"),
-           tr("This setting controls the accuracy of the emulated CPU.\nDon't change this unless "
-              "you know what you are doing."));
+           tr("Change the accuracy of the emulated CPU (for debugging only)."));
    INSERT(Settings, cpu_backend, tr("Backend:"), QString());

    INSERT(Settings, use_fast_cpu_time, QString(), QString());
@ -110,7 +106,7 @@ std::unique_ptr<TranslationMap> InitializeTranslations(QObject* parent)
           cpu_ticks,
           tr("Custom CPU Ticks"),
           tr("Set a custom value of CPU ticks. Higher values can increase performance, but may "
-              "also cause the game to freeze. A range of 77–21000 is recommended."));
+              "cause deadlocks. A range of 77-21000 is recommended."));
    INSERT(Settings, cpu_backend, tr("Backend:"), QString());

    // Cpu Debug
@ -144,8 +140,7 @@ std::unique_ptr<TranslationMap> InitializeTranslations(QObject* parent)
           cpuopt_unsafe_fastmem_check,
           tr("Disable address space checks"),
           tr("This option improves speed by eliminating a safety check before every memory "
-              "read/write in guest.\nDisabling it may allow a game to read/write the emulator's "
-              "memory."));
+              "operation.\nDisabling it may allow arbitrary code execution."));
    INSERT(
        Settings,
        cpuopt_unsafe_ignore_global_monitor,
@ -159,36 +154,31 @@ std::unique_ptr<TranslationMap> InitializeTranslations(QObject* parent)
        Settings,
        renderer_backend,
        tr("API:"),
-        tr("Switches between the available graphics APIs.\nVulkan is recommended in most cases."));
+        tr("Changes the output graphics API.\nVulkan is recommended."));
    INSERT(Settings,
           vulkan_device,
           tr("Device:"),
-           tr("This setting selects the GPU to use with the Vulkan backend."));
+           tr("This setting selects the GPU to use (Vulkan only)."));
    INSERT(Settings,
           shader_backend,
           tr("Shader Backend:"),
-           tr("The shader backend to use for the OpenGL renderer.\nGLSL is the fastest in "
-              "performance and the best in rendering accuracy.\n"
-              "GLASM is a deprecated NVIDIA-only backend that offers much better shader building "
-              "performance at the cost of FPS and rendering accuracy.\n"
-              "SPIR-V compiles the fastest, but yields poor results on most GPU drivers."));
+           tr("The shader backend to use with OpenGL.\nGLSL is recommended."));
    INSERT(Settings,
           resolution_setup,
           tr("Resolution:"),
-           tr("Forces the game to render at a different resolution.\nHigher resolutions require "
-              "much more VRAM and bandwidth.\n"
-              "Options lower than 1X can cause rendering issues."));
+           tr("Forces to render at a different resolution.\n"
+              "Higher resolutions require more VRAM and bandwidth.\n"
+              "Options lower than 1X can cause artifacts."));
    INSERT(Settings, scaling_filter, tr("Window Adapting Filter:"), QString());
    INSERT(Settings,
           fsr_sharpening_slider,
           tr("FSR Sharpness:"),
-           tr("Determines how sharpened the image will look while using FSR’s dynamic contrast."));
+           tr("Determines how sharpened the image will look using FSR's dynamic contrast."));
    INSERT(Settings,
           anti_aliasing,
           tr("Anti-Aliasing Method:"),
-           tr("The anti-aliasing method to use.\nSMAA offers the best quality.\nFXAA has a "
-              "lower performance impact and can produce a better and more stable picture under "
-              "very low resolutions."));
+           tr("The anti-aliasing method to use.\nSMAA offers the best quality.\nFXAA "
+              "can produce a more stable picture in lower resolutions."));
    INSERT(Settings,
           fullscreen_mode,
           tr("Fullscreen Mode:"),
@ -199,18 +189,17 @@ std::unique_ptr<TranslationMap> InitializeTranslations(QObject* parent)
    INSERT(Settings,
           aspect_ratio,
           tr("Aspect Ratio:"),
-           tr("Stretches the game to fit the specified aspect ratio.\nSwitch games only support "
-              "16:9, so custom game mods are required to get other ratios.\nAlso controls the "
+           tr("Stretches the renderer to fit the specified aspect ratio.\nMost games only support "
+              "16:9, so modifications are required to get other ratios.\nAlso controls the "
              "aspect ratio of captured screenshots."));
    INSERT(Settings,
           use_disk_shader_cache,
-           tr("Use disk pipeline cache"),
+           tr("Use persistent pipeline cache"),
           tr("Allows saving shaders to storage for faster loading on following game "
-              "boots.\nDisabling "
-              "it is only intended for debugging."));
+              "boots.\nDisabling it is only intended for debugging."));
    INSERT(Settings,
           optimize_spirv_output,
-           tr("Optimize SPIRV output shader"),
+           tr("Optimize SPIRV output"),
           tr("Runs an additional optimization pass over generated SPIRV shaders.\n"
              "Will increase time required for shader compilation.\nMay slightly improve "
              "performance.\nThis feature is experimental."));
@ -229,37 +218,35 @@ std::unique_ptr<TranslationMap> InitializeTranslations(QObject* parent)
           accelerate_astc,
           tr("ASTC Decoding Method:"),
           tr("This option controls how ASTC textures should be decoded.\n"
-              "CPU: Use the CPU for decoding, slowest but safest method.\n"
-              "GPU: Use the GPU's compute shaders to decode ASTC textures, recommended for most "
-              "games and users.\n"
-              "CPU Asynchronously: Use the CPU to decode ASTC textures as they arrive. Completely "
-              "eliminates ASTC decoding\nstuttering at the cost of rendering issues while the "
-              "texture is being decoded."));
+              "CPU: Use the CPU for decoding.\n"
+              "GPU: Use the GPU's compute shaders to decode ASTC textures (recommended).\n"
+              "CPU Asynchronously: Use the CPU to decode ASTC textures on demand. Eliminates"
+              "ASTC decoding\nstuttering but may present artifacts."));
    INSERT(
        Settings,
        astc_recompression,
        tr("ASTC Recompression Method:"),
-        tr("Almost all desktop and laptop dedicated GPUs lack support for ASTC textures, forcing "
-           "the emulator to decompress to an intermediate format any card supports, RGBA8.\n"
-           "This option recompresses RGBA8 to either the BC1 or BC3 format, saving VRAM but "
-           "negatively affecting image quality."));
+        tr("Most GPUs lack support for ASTC textures and must decompress to an"
+            "intermediate format: RGBA8.\n"
+            "BC1/BC3: The intermediate format will be recompressed to BC1 or BC3 format,\n"
+            " saving VRAM but degrading image quality."));
    INSERT(Settings,
           vram_usage_mode,
           tr("VRAM Usage Mode:"),
-           tr("Selects whether the emulator should prefer to conserve memory or make maximum usage of available video memory for performance.\nAggressive mode may severely impact the performance of other applications such as recording software."));
+           tr("Selects whether the emulator should prefer to conserve memory or make maximum usage of available video memory for performance.\nAggressive mode may impact performance of other applications such as recording software."));
    INSERT(Settings,
           skip_cpu_inner_invalidation,
           tr("Skip CPU Inner Invalidation"),
-           tr("Skips certain CPU-side cache invalidations during memory updates, reducing CPU usage and "
-              "improving it's performance. This may cause glitches or crashes on some games."));
+           tr("Skips certain cache invalidations during memory updates, reducing CPU usage and "
+              "improving latency. This may cause soft-crashes."));
    INSERT(
        Settings,
        vsync_mode,
        tr("VSync Mode:"),
        tr("FIFO (VSync) does not drop frames or exhibit tearing but is limited by the screen "
-           "refresh rate.\nFIFO Relaxed is similar to FIFO but allows tearing as it recovers from "
-           "a slow down.\nMailbox can have lower latency than FIFO and does not tear but may drop "
-           "frames.\nImmediate (no synchronization) just presents whatever is available and can "
+           "refresh rate.\nFIFO Relaxed allows tearing as it recovers from a slow down.\n"
+           "Mailbox can have lower latency than FIFO and does not tear but may drop "
+           "frames.\nImmediate (no synchronization) presents whatever is available and can "
           "exhibit tearing."));
    INSERT(Settings, bg_red, QString(), QString());
    INSERT(Settings, bg_green, QString(), QString());
@ -267,7 +254,7 @@ std::unique_ptr<TranslationMap> InitializeTranslations(QObject* parent)

    // Renderer (Advanced Graphics)
    INSERT(Settings, sync_memory_operations, tr("Sync Memory Operations"),
-           tr("Ensures data consistency between compute and memory operations.\nThis option should fix issues in some games, but may also reduce performance in some cases.\nUnreal Engine 4 games often see the most significant changes thereof."));
+           tr("Ensures data consistency between compute and memory operations.\nThis option fixes issues in games, but may degrade performance.\nUnreal Engine 4 games often see the most significant changes thereof."));
    INSERT(Settings,
           async_presentation,
           tr("Enable asynchronous presentation (Vulkan only)"),
@ -281,8 +268,7 @@ std::unique_ptr<TranslationMap> InitializeTranslations(QObject* parent)
    INSERT(Settings,
           max_anisotropy,
           tr("Anisotropic Filtering:"),
-           tr("Controls the quality of texture rendering at oblique angles.\nIt’s a light setting "
-              "and safe to set at 16x on most GPUs."));
+           tr("Controls the quality of texture rendering at oblique angles.\nSafe to set at 16x on most GPUs."));
    INSERT(Settings,
           gpu_accuracy,
           tr("GPU Accuracy:"),
@ -292,11 +278,11 @@ std::unique_ptr<TranslationMap> InitializeTranslations(QObject* parent)
    INSERT(Settings,
           dma_accuracy,
           tr("DMA Accuracy:"),
-           tr("Controls the DMA precision accuracy. Safe precision can fix issues in some games, but it can also impact performance in some cases.\nIf unsure, leave this on Default."));
+           tr("Controls the DMA precision accuracy. Safe precision fixes issues in some games but may degrade performance."));
    INSERT(Settings,
           use_asynchronous_shaders,
-           tr("Use asynchronous shader building (Hack)"),
-           tr("Enables asynchronous shader compilation, which may reduce shader stutter."));
+           tr("Enable asynchronous shader compilation (Hack)"),
+           tr("May reduce shader stutter."));
    INSERT(Settings, use_fast_gpu_time, QString(), QString());
    INSERT(Settings,
           fast_gpu_time,
@ -314,8 +300,8 @@ std::unique_ptr<TranslationMap> InitializeTranslations(QObject* parent)
        Settings,
        enable_compute_pipelines,
        tr("Enable Compute Pipelines (Intel Vulkan Only)"),
-        tr("Enable compute pipelines, required by some games.\nThis setting only exists for Intel "
-           "proprietary drivers, and may crash if enabled.\nCompute pipelines are always enabled "
+        tr("Required by some games.\nThis setting only exists for Intel "
+           "proprietary drivers and may crash if enabled.\nCompute pipelines are always enabled "
           "on all other drivers."));
    INSERT(
        Settings,
@ -343,12 +329,12 @@ std::unique_ptr<TranslationMap> InitializeTranslations(QObject* parent)
    INSERT(Settings,
           dyna_state,
           tr("Extended Dynamic State"),
-           tr("Controls the number of features that can be used in Extended Dynamic State.\nHigher numbers allow for more features and can increase performance, but may cause issues with some drivers and vendors.\nThe default value may vary depending on your system and hardware capabilities.\nThis value can be changed until stability and a better visual quality are achieved."));
+           tr("Controls the number of features that can be used in Extended Dynamic State.\nHigher numbers allow for more features and can increase performance, but may cause issues.\nThe default value is per-system."));

    INSERT(Settings,
           provoking_vertex,
           tr("Provoking Vertex"),
-           tr("Improves lighting and vertex handling in certain games.\n"
+           tr("Improves lighting and vertex handling in some games.\n"
              "Only Vulkan 1.0+ devices support this extension."));

    INSERT(Settings,
@ -363,8 +349,8 @@ std::unique_ptr<TranslationMap> InitializeTranslations(QObject* parent)
           sample_shading_fraction,
           tr("Sample Shading"),
           tr("Allows the fragment shader to execute per sample in a multi-sampled fragment "
-              "instead once per fragment. Improves graphics quality at the cost of some performance.\n"
-              "Higher values improve quality more but also reduce performance to a greater extent."));
+              "instead of once per fragment. Improves graphics quality at the cost of performance.\n"
+              "Higher values improve quality but degrade performance."));

    // Renderer (Debug)

@ -372,31 +358,30 @@ std::unique_ptr<TranslationMap> InitializeTranslations(QObject* parent)
    INSERT(Settings,
           rng_seed,
           tr("RNG Seed"),
-           tr("Controls the seed of the random number generator.\nMainly used for speedrunning "
-              "purposes."));
+           tr("Controls the seed of the random number generator.\nMainly used for speedrunning."));
    INSERT(Settings, rng_seed_enabled, QString(), QString());
-    INSERT(Settings, device_name, tr("Device Name"), tr("The name of the emulated Switch."));
+    INSERT(Settings, device_name, tr("Device Name"), tr("The name of the console."));
    INSERT(Settings,
           custom_rtc,
           tr("Custom RTC Date:"),
-           tr("This option allows to change the emulated clock of the Switch.\n"
+           tr("This option allows to change the clock of the console.\n"
              "Can be used to manipulate time in games."));
    INSERT(Settings, custom_rtc_enabled, QString(), QString());
    INSERT(Settings,
           custom_rtc_offset,
           QStringLiteral(" "),
-           QStringLiteral("The number of seconds from the current unix time"));
+           tr("The number of seconds from the current unix time"));
    INSERT(Settings,
           language_index,
           tr("Language:"),
-           tr("Note: this can be overridden when region setting is auto-select"));
-    INSERT(Settings, region_index, tr("Region:"), tr("The region of the emulated Switch."));
-    INSERT(Settings, time_zone_index, tr("Time Zone:"), tr("The time zone of the emulated Switch."));
+           tr("This option can be overridden when region setting is auto-select"));
+    INSERT(Settings, region_index, tr("Region:"), tr("The region of the console."));
+    INSERT(Settings, time_zone_index, tr("Time Zone:"), tr("The time zone of the console."));
    INSERT(Settings, sound_index, tr("Sound Output Mode:"), QString());
    INSERT(Settings,
           use_docked_mode,
           tr("Console Mode:"),
-           tr("Selects if the console is emulated in Docked or Handheld mode.\nGames will change "
+           tr("Selects if the console is in Docked or Handheld mode.\nGames will change "
              "their resolution, details and supported controllers and depending on this setting.\n"
              "Setting to Handheld can help improve performance for low end systems."));
    INSERT(Settings, current_user, QString(), QString());
@ -418,27 +403,26 @@ std::unique_ptr<TranslationMap> InitializeTranslations(QObject* parent)
    // Ui General
    INSERT(UISettings,
           select_user_on_boot,
-           tr("Prompt for user on game boot"),
-           tr("Ask to select a user profile on each boot, useful if multiple people use Eden on "
-              "the same PC."));
+           tr("Prompt for user profile on boot"),
+           tr("Useful if multiple people use the same PC."));
    INSERT(UISettings,
           pause_when_in_background,
-           tr("Pause emulation when in background"),
-           tr("This setting pauses Eden when focusing other windows."));
+           tr("Pause when not in focus"),
+           tr("Pauses emulation when focusing on other windows."));
    INSERT(UISettings,
           confirm_before_stopping,
           tr("Confirm before stopping emulation"),
-           tr("This setting overrides game prompts asking to confirm stopping the game.\nEnabling "
+           tr("Overrides prompts asking to confirm stopping the emulation.\nEnabling "
              "it bypasses such prompts and directly exits the emulation."));
    INSERT(UISettings,
           hide_mouse,
           tr("Hide mouse on inactivity"),
-           tr("This setting hides the mouse after 2.5s of inactivity."));
+           tr("Hides the mouse after 2.5s of inactivity."));
    INSERT(UISettings,
           controller_applet_disabled,
           tr("Disable controller applet"),
-           tr("Forcibly disables the use of the controller applet by guests.\nWhen a guest "
-              "attempts to open the controller applet, it is immediately closed."));
+           tr("Forcibly disables the use of the controller applet in emulated programs.\n"
+                "When a program attempts to open the controller applet, it is immediately closed."));
    INSERT(UISettings,
           check_for_updates,
           tr("Check for updates"),
@ -570,12 +554,16 @@ std::unique_ptr<ComboboxTranslationMap> ComboboxEnumeration(QObject* parent)
                              PAIR(ScalingFilter, NearestNeighbor, tr("Nearest Neighbor")),
                              PAIR(ScalingFilter, Bilinear, tr("Bilinear")),
                              PAIR(ScalingFilter, Bicubic, tr("Bicubic")),
+                              PAIR(ScalingFilter, ZeroTangent, tr("Zero-Tangent")),
+                              PAIR(ScalingFilter, BSpline, tr("B-Spline")),
+                              PAIR(ScalingFilter, Mitchell, tr("Mitchell")),
                              PAIR(ScalingFilter, Spline1, tr("Spline-1")),
                              PAIR(ScalingFilter, Gaussian, tr("Gaussian")),
                              PAIR(ScalingFilter, Lanczos, tr("Lanczos")),
                              PAIR(ScalingFilter, ScaleForce, tr("ScaleForce")),
                              PAIR(ScalingFilter, Fsr, tr("AMD FidelityFX™️ Super Resolution")),
                              PAIR(ScalingFilter, Area, tr("Area")),
+                              PAIR(ScalingFilter, Mmpx, tr("MMPX")),
                          }});
    translations->insert({Settings::EnumMetadata<Settings::AntiAliasing>::Index(),
                          {
--- a/src/qt_common/shared_translation.h
+++ b/src/qt_common/shared_translation.h
@ -38,6 +38,9 @@ static const std::map<Settings::ScalingFilter, QString> scaling_filter_texts_map
    {Settings::ScalingFilter::Bilinear,
     QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Bilinear"))},
    {Settings::ScalingFilter::Bicubic, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Bicubic"))},
+    {Settings::ScalingFilter::ZeroTangent, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Zero-Tangent"))},
+    {Settings::ScalingFilter::BSpline, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "B-Spline"))},
+    {Settings::ScalingFilter::Mitchell, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Mitchell"))},
     {Settings::ScalingFilter::Spline1,
     QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Spline-1"))},
    {Settings::ScalingFilter::Gaussian,
@ -48,6 +51,7 @@ static const std::map<Settings::ScalingFilter, QString> scaling_filter_texts_map
     QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "ScaleForce"))},
    {Settings::ScalingFilter::Fsr, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "FSR"))},
    {Settings::ScalingFilter::Area, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "Area"))},
+    {Settings::ScalingFilter::Mmpx, QStringLiteral(QT_TRANSLATE_NOOP("GMainWindow", "MMPX"))},
 };

 static const std::map<Settings::ConsoleMode, QString> use_docked_mode_texts_map = {
--- a/src/video_core/host_shaders/CMakeLists.txt
+++ b/src/video_core/host_shaders/CMakeLists.txt
@ -44,9 +44,13 @@ set(SHADER_FILES
    pitch_unswizzle.comp
    present_area.frag
    present_bicubic.frag
+    present_zero_tangent.frag
+    present_bspline.frag
+    present_mitchell.frag
    present_gaussian.frag
    present_lanczos.frag
    present_spline1.frag
+    present_mmpx.frag
    queries_prefix_scan_sum.comp
    queries_prefix_scan_sum_nosubgroups.comp
    resolve_conditional_render.comp
--- a/src/video_core/host_shaders/present_bicubic.frag
+++ b/src/video_core/host_shaders/present_bicubic.frag
@ -1,56 +1,37 @@
+// 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
-
 #version 460 core
-
-
 layout (location = 0) in vec2 frag_tex_coord;
-
 layout (location = 0) out vec4 color;
-
 layout (binding = 0) uniform sampler2D color_texture;
-
-vec4 cubic(float v) {
-    vec4 n = vec4(1.0, 2.0, 3.0, 4.0) - v;
-    vec4 s = n * n * n;
-    float x = s.x;
-    float y = s.y - 4.0 * s.x;
-    float z = s.z - 4.0 * s.y + 6.0 * s.x;
-    float w = 6.0 - x - y - z;
-    return vec4(x, y, z, w) * (1.0 / 6.0);
+vec4 cubic(float x) {
+    float x2 = x * x;
+    float x3 = x2 * x;
+    return vec4(1.0, x, x2, x3) * transpose(mat4x4(
+         0.0,   2.0,  0.0,  0.0,
+        -1.0,   0.0,  1.0,  0.0,
+         2.0,  -5.0,  4.0, -1.0,
+        -1.0,   3.0, -3.0,  1.0
+    ) * (1.0 / 2.0));
 }
-
-vec4 textureBicubic( sampler2D textureSampler, vec2 texCoords ) {
-
-    vec2 texSize = textureSize(textureSampler, 0);
-    vec2 invTexSize = 1.0 / texSize;
-
-    texCoords = texCoords * texSize - 0.5;
-
-    vec2 fxy = fract(texCoords);
-    texCoords -= fxy;
-
-    vec4 xcubic = cubic(fxy.x);
-    vec4 ycubic = cubic(fxy.y);
-
-    vec4 c = texCoords.xxyy + vec2(-0.5, +1.5).xyxy;
-
-    vec4 s = vec4(xcubic.xz + xcubic.yw, ycubic.xz + ycubic.yw);
-    vec4 offset = c + vec4(xcubic.yw, ycubic.yw) / s;
-
-    offset *= invTexSize.xxyy;
-
-    vec4 sample0 = texture(textureSampler, offset.xz);
-    vec4 sample1 = texture(textureSampler, offset.yz);
-    vec4 sample2 = texture(textureSampler, offset.xw);
-    vec4 sample3 = texture(textureSampler, offset.yw);
-
-    float sx = s.x / (s.x + s.y);
-    float sy = s.z / (s.z + s.w);
-
-    return mix(mix(sample3, sample2, sx), mix(sample1, sample0, sx), sy);
+vec4 textureBicubic(sampler2D samp, vec2 uv) {
+    vec2 tex_size = vec2(textureSize(samp, 0));
+    vec2 cc_tex = uv * tex_size - 0.5f;
+    vec2 fex = cc_tex - floor(cc_tex);
+    vec4 xcubic = cubic(fex.x);
+    vec4 ycubic = cubic(fex.y);
+    vec4 c = floor(cc_tex).xxyy + vec2(-0.5f, 1.5f).xyxy;
+    vec4 z = vec4(xcubic.yw, ycubic.yw);
+    vec4 s = vec4(xcubic.xz, ycubic.xz) + z;
+    vec4 offset = (c + z / s) * (1.0f / tex_size).xxyy;
+    vec2 n = vec2(s.x / (s.x + s.y), s.z / (s.z + s.w));
+    return mix(
+        mix(texture(samp, offset.yw), texture(samp, offset.xw), n.x),
+        mix(texture(samp, offset.yz), texture(samp, offset.xz), n.x),
+    n.y);
 }
-
 void main() {
    color = textureBicubic(color_texture, frag_tex_coord);
 }
--- a/src/video_core/host_shaders/present_bspline.frag
+++ b/src/video_core/host_shaders/present_bspline.frag
@ -0,0 +1,35 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+#version 460 core
+layout (location = 0) in vec2 frag_tex_coord;
+layout (location = 0) out vec4 color;
+layout (binding = 0) uniform sampler2D color_texture;
+vec4 cubic(float x) {
+    float x2 = x * x;
+    float x3 = x2 * x;
+    return vec4(1.0, x, x2, x3) * transpose(mat4x4(
+         1.0,   4.0,  1.0,  0.0,
+        -3.0,   0.0,  3.0,  0.0,
+         3.0,  -6.0,  3.0,  0.0,
+        -1.0,   3.0, -3.0,  1.0
+    ) * (1.0 / 6.0));
+}
+vec4 textureBicubic(sampler2D samp, vec2 uv) {
+    vec2 tex_size = vec2(textureSize(samp, 0));
+    vec2 cc_tex = uv * tex_size - 0.5f;
+    vec2 fex = cc_tex - floor(cc_tex);
+    vec4 xcubic = cubic(fex.x);
+    vec4 ycubic = cubic(fex.y);
+    vec4 c = floor(cc_tex).xxyy + vec2(-0.5f, 1.5f).xyxy;
+    vec4 z = vec4(xcubic.yw, ycubic.yw);
+    vec4 s = vec4(xcubic.xz, ycubic.xz) + z;
+    vec4 offset = (c + z / s) * (1.0f / tex_size).xxyy;
+    vec2 n = vec2(s.x / (s.x + s.y), s.z / (s.z + s.w));
+    return mix(
+        mix(texture(samp, offset.yw), texture(samp, offset.xw), n.x),
+        mix(texture(samp, offset.yz), texture(samp, offset.xz), n.x),
+    n.y);
+}
+void main() {
+    color = textureBicubic(color_texture, frag_tex_coord);
+}
--- a/src/video_core/host_shaders/present_mitchell.frag
+++ b/src/video_core/host_shaders/present_mitchell.frag
@ -0,0 +1,35 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+#version 460 core
+layout (location = 0) in vec2 frag_tex_coord;
+layout (location = 0) out vec4 color;
+layout (binding = 0) uniform sampler2D color_texture;
+vec4 cubic(float x) {
+    float x2 = x * x;
+    float x3 = x2 * x;
+    return vec4(1.0, x, x2, x3) * transpose(mat4x4(
+         1.0,  16.0,   1.0,  0.0,
+        -9.0,   0.0,   9.0,  0.0,
+        15.0, -36.0,  27.0, -6.0,
+        -7.0,  21.0, -21.0,  7.0
+    ) * (1.0 / 18.0));
+}
+vec4 textureBicubic(sampler2D samp, vec2 uv) {
+    vec2 tex_size = vec2(textureSize(samp, 0));
+    vec2 cc_tex = uv * tex_size - 0.5f;
+    vec2 fex = cc_tex - floor(cc_tex);
+    vec4 xcubic = cubic(fex.x);
+    vec4 ycubic = cubic(fex.y);
+    vec4 c = floor(cc_tex).xxyy + vec2(-0.5f, 1.5f).xyxy;
+    vec4 z = vec4(xcubic.yw, ycubic.yw);
+    vec4 s = vec4(xcubic.xz, ycubic.xz) + z;
+    vec4 offset = (c + z / s) * (1.0f / tex_size).xxyy;
+    vec2 n = vec2(s.x / (s.x + s.y), s.z / (s.z + s.w));
+    return mix(
+        mix(texture(samp, offset.yw), texture(samp, offset.xw), n.x),
+        mix(texture(samp, offset.yz), texture(samp, offset.xz), n.x),
+    n.y);
+}
+void main() {
+    color = textureBicubic(color_texture, frag_tex_coord);
+}
--- a/src/video_core/host_shaders/present_mmpx.frag
+++ b/src/video_core/host_shaders/present_mmpx.frag
@ -0,0 +1,131 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+// Copyright 2023 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#version 460 core
+layout(location = 0) in vec2 tex_coord;
+layout(location = 0) out vec4 frag_color;
+layout(binding = 0) uniform sampler2D tex;
+
+#define src(x, y) texture(tex, coord + vec2(x, y) * 1.0 / source_size)
+
+float luma(vec4 col) {
+    return dot(col.rgb, vec3(0.2126, 0.7152, 0.0722)) * (1.0 - col.a);
+}
+
+bool same(vec4 B, vec4 A0) {
+    return all(equal(B, A0));
+}
+
+bool notsame(vec4 B, vec4 A0) {
+    return any(notEqual(B, A0));
+}
+
+bool all_eq2(vec4 B, vec4 A0, vec4 A1) {
+    return (same(B,A0) && same(B,A1));
+}
+
+bool all_eq3(vec4 B, vec4 A0, vec4 A1, vec4 A2) {
+    return (same(B,A0) && same(B,A1) && same(B,A2));
+}
+
+bool all_eq4(vec4 B, vec4 A0, vec4 A1, vec4 A2, vec4 A3) {
+    return (same(B,A0) && same(B,A1) && same(B,A2) && same(B,A3));
+}
+
+bool any_eq3(vec4 B, vec4 A0, vec4 A1, vec4 A2) {
+    return (same(B,A0) || same(B,A1) || same(B,A2));
+}
+
+bool none_eq2(vec4 B, vec4 A0, vec4 A1) {
+    return (notsame(B,A0) && notsame(B,A1));
+}
+
+bool none_eq4(vec4 B, vec4 A0, vec4 A1, vec4 A2, vec4 A3) {
+    return (notsame(B,A0) && notsame(B,A1) && notsame(B,A2) && notsame(B,A3));
+}
+
+void main()
+{
+    vec2 source_size = vec2(textureSize(tex, 0));
+    vec2 pos = fract(tex_coord * source_size) - vec2(0.5, 0.5);
+    vec2 coord = tex_coord - pos / source_size;
+
+    vec4 E = src(0.0,0.0);
+
+    vec4 A = src(-1.0,-1.0);
+    vec4 B = src(0.0,-1.0);
+    vec4 C = src(1.0,-1.0);
+
+    vec4 D = src(-1.0,0.0);
+    vec4 F = src(1.0,0.0);
+
+    vec4 G = src(-1.0,1.0);
+    vec4 H = src(0.0,1.0);
+    vec4 I = src(1.0,1.0);
+
+    vec4 J = E;
+    vec4 K = E;
+    vec4 L = E;
+    vec4 M = E;
+
+    frag_color = E;
+
+    if(same(E,A) && same(E,B) && same(E,C) && same(E,D) && same(E,F) && same(E,G) && same(E,H) && same(E,I)) return;
+
+    vec4 P  = src(0.0,2.0);
+    vec4 Q  = src(-2.0,0.0);
+    vec4 R  = src(2.0,0.0);
+    vec4 S  = src(0.0,2.0);
+
+    float Bl = luma(B);
+    float Dl = luma(D);
+    float El = luma(E);
+    float Fl = luma(F);
+    float Hl = luma(H);
+
+    if (((same(D,B) && notsame(D,H) && notsame(D,F))) && ((El>=Dl) || same(E,A)) && any_eq3(E,A,C,G) && ((El<Dl) || notsame(A,D) || notsame(E,P) || notsame(E,Q))) J=mix(D, J, 0.5);
+    if (((same(B,F) && notsame(B,D) && notsame(B,H))) && ((El>=Bl) || same(E,C)) && any_eq3(E,A,C,I) && ((El<Bl) || notsame(C,B) || notsame(E,P) || notsame(E,R))) K=mix(B, K, 0.5);
+    if (((same(H,D) && notsame(H,F) && notsame(H,B))) && ((El>=Hl) || same(E,G)) && any_eq3(E,A,G,I) && ((El<Hl) || notsame(G,H) || notsame(E,S) || notsame(E,Q))) L=mix(H, L, 0.5);
+    if (((same(F,H) && notsame(F,B) && notsame(F,D))) && ((El>=Fl) || same(E,I)) && any_eq3(E,C,G,I) && ((El<Fl) || notsame(I,H) || notsame(E,R) || notsame(E,S))) M=mix(F, M, 0.5);
+
+    if ((notsame(E,F) && all_eq4(E,C,I,D,Q) && all_eq2(F,B,H)) && notsame(F,src(3.0,0.0))) {M=mix(M, F, 0.5); K=mix(K, M, 0.5);};
+    if ((notsame(E,D) && all_eq4(E,A,G,F,R) && all_eq2(D,B,H)) && notsame(D,src(-3.0,0.0))) {L=mix(L, D, 0.5); J=mix(J, L, 0.5);};
+    if ((notsame(E,H) && all_eq4(E,G,I,B,P) && all_eq2(H,D,F)) && notsame(H,src(0.0,3.0))) {M=mix(M, H, 0.5); L=mix(L, M, 0.5);};
+    if ((notsame(E,B) && all_eq4(E,A,C,H,S) && all_eq2(B,D,F)) && notsame(B,src(0.0,-3.0))) {K=mix(K, B, 0.5); J=mix(J, K, 0.5);};
+
+    if ((Bl<El) && all_eq4(E,G,H,I,S) && none_eq4(E,A,D,C,F)) {K=mix(K, B, 0.5); J=mix(J, K, 0.5);}
+    if ((Hl<El) && all_eq4(E,A,B,C,P) && none_eq4(E,D,G,I,F)) {M=mix(M, H, 0.5); L=mix(L, M, 0.5);}
+    if ((Fl<El) && all_eq4(E,A,D,G,Q) && none_eq4(E,B,C,I,H)) {M=mix(M, F, 0.5); K=mix(K, M, 0.5);}
+    if ((Dl<El) && all_eq4(E,C,F,I,R) && none_eq4(E,B,A,G,H)) {L=mix(L, D, 0.5); J=mix(J, L, 0.5);}
+
+    if (notsame(H,B)) {
+        if (notsame(H,A) && notsame(H,E) && notsame(H,C)) {
+            if (all_eq3(H,G,F,R) && none_eq2(H,D,src(2.0,-1.0))) L=mix(M, L, 0.5);
+            if (all_eq3(H,I,D,Q) && none_eq2(H,F,src(-2.0,-1.0))) M=mix(L, M, 0.5);
+        }
+
+        if (notsame(B,I) && notsame(B,G) && notsame(B,E)) {
+            if (all_eq3(B,A,F,R) && none_eq2(B,D,src(2.0,1.0))) J=mix(K, L, 0.5);
+            if (all_eq3(B,C,D,Q) && none_eq2(B,F,src(-2.0,1.0))) K=mix(J, K, 0.5);
+        }
+    }
+
+    if (notsame(F,D)) {
+        if (notsame(D,I) && notsame(D,E) && notsame(D,C)) {
+            if (all_eq3(D,A,H,S) && none_eq2(D,B,src(1.0,2.0))) J=mix(L, J, 0.5);
+            if (all_eq3(D,G,B,P) && none_eq2(D,H,src(1.0,2.0))) L=mix(J, L, 0.5);
+        }
+
+        if (notsame(F,E) && notsame(F,A) && notsame(F,G)) {
+            if (all_eq3(F,C,H,S) && none_eq2(F,B,src(-1.0,2.0))) K=mix(M, K, 0.5);
+            if (all_eq3(F,I,B,P) && none_eq2(F,H,src(-1.0,-2.0))) M=mix(K, M, 0.5);
+        }
+    }
+
+    vec2 a = fract(tex_coord * source_size);
+    vec4 colour = (a.x < 0.5) ? (a.y < 0.5 ? J : L) : (a.y < 0.5 ? K : M);
+    frag_color = colour;
+}
--- a/src/video_core/host_shaders/present_zero_tangent.frag
+++ b/src/video_core/host_shaders/present_zero_tangent.frag
@ -0,0 +1,35 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+#version 460 core
+layout (location = 0) in vec2 frag_tex_coord;
+layout (location = 0) out vec4 color;
+layout (binding = 0) uniform sampler2D color_texture;
+vec4 cubic(float x) {
+    float x2 = x * x;
+    float x3 = x2 * x;
+    return vec4(1.0, x, x2, x3) * transpose(mat4x4(
+         0.0,   2.0,  0.0,  0.0,
+        -2.0,   0.0,  2.0,  0.0,
+         4.0,  -4.0,  2.0, -2.0,
+        -2.0,   2.0, -2.0,  1.0
+    ) * (1.0 / 2.0));
+}
+vec4 textureBicubic(sampler2D samp, vec2 uv) {
+    vec2 tex_size = vec2(textureSize(samp, 0));
+    vec2 cc_tex = uv * tex_size - 0.5f;
+    vec2 fex = cc_tex - floor(cc_tex);
+    vec4 xcubic = cubic(fex.x);
+    vec4 ycubic = cubic(fex.y);
+    vec4 c = floor(cc_tex).xxyy + vec2(-0.5f, 1.5f).xyxy;
+    vec4 z = vec4(xcubic.yw, ycubic.yw);
+    vec4 s = vec4(xcubic.xz, ycubic.xz) + z;
+    vec4 offset = (c + z / s) * (1.0f / tex_size).xxyy;
+    vec2 n = vec2(s.x / (s.x + s.y), s.z / (s.z + s.w));
+    return mix(
+        mix(texture(samp, offset.yw), texture(samp, offset.xw), n.x),
+        mix(texture(samp, offset.yz), texture(samp, offset.xz), n.x),
+    n.y);
+}
+void main() {
+    color = textureBicubic(color_texture, frag_tex_coord);
+}
--- a/src/video_core/renderer_opengl/gl_blit_screen.cpp
+++ b/src/video_core/renderer_opengl/gl_blit_screen.cpp
@ -8,6 +8,7 @@
 // SPDX-License-Identifier: GPL-2.0-or-later

 #include "common/settings.h"
+#include "common/settings_enums.h"
 #include "video_core/present.h"
 #include "video_core/renderer_opengl/gl_blit_screen.h"
 #include "video_core/renderer_opengl/gl_state_tracker.h"
@ -86,6 +87,15 @@ void BlitScreen::CreateWindowAdapt() {
    case Settings::ScalingFilter::Bicubic:
        window_adapt = MakeBicubic(device);
        break;
+    case Settings::ScalingFilter::ZeroTangent:
+        window_adapt = MakeZeroTangent(device);
+        break;
+    case Settings::ScalingFilter::BSpline:
+        window_adapt = MakeBSpline(device);
+        break;
+    case Settings::ScalingFilter::Mitchell:
+        window_adapt = MakeMitchell(device);
+        break;
    case Settings::ScalingFilter::Gaussian:
        window_adapt = MakeGaussian(device);
        break;
@ -101,6 +111,9 @@ void BlitScreen::CreateWindowAdapt() {
    case Settings::ScalingFilter::Area:
        window_adapt = MakeArea(device);
        break;
+    case Settings::ScalingFilter::Mmpx:
+        window_adapt = MakeMmpx(device);
+        break;
    case Settings::ScalingFilter::Fsr:
    case Settings::ScalingFilter::Bilinear:
    default:
--- a/src/video_core/renderer_opengl/present/filters.cpp
+++ b/src/video_core/renderer_opengl/present/filters.cpp
@ -14,6 +14,10 @@
 #include "video_core/host_shaders/present_gaussian_frag.h"
 #include "video_core/host_shaders/present_lanczos_frag.h"
 #include "video_core/host_shaders/present_spline1_frag.h"
+#include "video_core/host_shaders/present_mitchell_frag.h"
+#include "video_core/host_shaders/present_bspline_frag.h"
+#include "video_core/host_shaders/present_zero_tangent_frag.h"
+#include "video_core/host_shaders/present_mmpx_frag.h"
 #include "video_core/renderer_opengl/present/filters.h"
 #include "video_core/renderer_opengl/present/util.h"

@ -39,6 +43,21 @@ std::unique_ptr<WindowAdaptPass> MakeBicubic(const Device& device) {
                                             HostShaders::PRESENT_BICUBIC_FRAG);
 }

+std::unique_ptr<WindowAdaptPass> MakeMitchell(const Device& device) {
+    return std::make_unique<WindowAdaptPass>(device, CreateBilinearSampler(),
+                                             HostShaders::PRESENT_MITCHELL_FRAG);
+}
+
+std::unique_ptr<WindowAdaptPass> MakeZeroTangent(const Device& device) {
+    return std::make_unique<WindowAdaptPass>(device, CreateBilinearSampler(),
+                                             HostShaders::PRESENT_ZERO_TANGENT_FRAG);
+}
+
+std::unique_ptr<WindowAdaptPass> MakeBSpline(const Device& device) {
+    return std::make_unique<WindowAdaptPass>(device, CreateBilinearSampler(),
+                                             HostShaders::PRESENT_BSPLINE_FRAG);
+}
+
 std::unique_ptr<WindowAdaptPass> MakeGaussian(const Device& device) {
    return std::make_unique<WindowAdaptPass>(device, CreateBilinearSampler(),
                                             HostShaders::PRESENT_GAUSSIAN_FRAG);
@ -60,4 +79,9 @@ std::unique_ptr<WindowAdaptPass> MakeArea(const Device& device) {
                                             HostShaders::PRESENT_AREA_FRAG);
 }

+std::unique_ptr<WindowAdaptPass> MakeMmpx(const Device& device) {
+    return std::make_unique<WindowAdaptPass>(device, CreateNearestNeighborSampler(),
+                                             HostShaders::PRESENT_MMPX_FRAG);
+}
+
 } // namespace OpenGL
--- a/src/video_core/renderer_opengl/present/filters.h
+++ b/src/video_core/renderer_opengl/present/filters.h
@ -17,10 +17,14 @@ namespace OpenGL {
 std::unique_ptr<WindowAdaptPass> MakeNearestNeighbor(const Device& device);
 std::unique_ptr<WindowAdaptPass> MakeBilinear(const Device& device);
 std::unique_ptr<WindowAdaptPass> MakeBicubic(const Device& device);
+std::unique_ptr<WindowAdaptPass> MakeZeroTangent(const Device& device);
+std::unique_ptr<WindowAdaptPass> MakeMitchell(const Device& device);
+std::unique_ptr<WindowAdaptPass> MakeBSpline(const Device& device);
 std::unique_ptr<WindowAdaptPass> MakeGaussian(const Device& device);
 std::unique_ptr<WindowAdaptPass> MakeSpline1(const Device& device);
 std::unique_ptr<WindowAdaptPass> MakeLanczos(const Device& device);
 std::unique_ptr<WindowAdaptPass> MakeScaleForce(const Device& device);
 std::unique_ptr<WindowAdaptPass> MakeArea(const Device& device);
+std::unique_ptr<WindowAdaptPass> MakeMmpx(const Device& device);

 } // namespace OpenGL
--- a/src/video_core/renderer_vulkan/present/filters.cpp
+++ b/src/video_core/renderer_vulkan/present/filters.cpp
@ -7,6 +7,8 @@
 // SPDX-FileCopyrightText: Copyright 2024 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

+#include <vulkan/vulkan_core.h>
+#include "common/assert.h"
 #include "common/common_types.h"

 #include "video_core/host_shaders/present_area_frag_spv.h"
@ -14,6 +16,10 @@
 #include "video_core/host_shaders/present_gaussian_frag_spv.h"
 #include "video_core/host_shaders/present_lanczos_frag_spv.h"
 #include "video_core/host_shaders/present_spline1_frag_spv.h"
+#include "video_core/host_shaders/present_mitchell_frag_spv.h"
+#include "video_core/host_shaders/present_bspline_frag_spv.h"
+#include "video_core/host_shaders/present_zero_tangent_frag_spv.h"
+#include "video_core/host_shaders/present_mmpx_frag_spv.h"
 #include "video_core/host_shaders/vulkan_present_frag_spv.h"
 #include "video_core/host_shaders/vulkan_present_scaleforce_fp16_frag_spv.h"
 #include "video_core/host_shaders/vulkan_present_scaleforce_fp32_frag_spv.h"
@ -52,13 +58,28 @@ std::unique_ptr<WindowAdaptPass> MakeSpline1(const Device& device, VkFormat fram
                                             BuildShader(device, PRESENT_SPLINE1_FRAG_SPV));
 }

-std::unique_ptr<WindowAdaptPass> MakeBicubic(const Device& device, VkFormat frame_format) {
+std::unique_ptr<WindowAdaptPass> MakeBicubic(const Device& device, VkFormat frame_format, VkCubicFilterWeightsQCOM qcom_weights) {
    // No need for handrolled shader -- if the VK impl can do it for us ;)
-    if (device.IsExtFilterCubicSupported())
-        return std::make_unique<WindowAdaptPass>(device, frame_format, CreateCubicSampler(device),
-                                                 BuildShader(device, VULKAN_PRESENT_FRAG_SPV));
-    return std::make_unique<WindowAdaptPass>(device, frame_format, CreateBilinearSampler(device),
-                                                BuildShader(device, PRESENT_BICUBIC_FRAG_SPV));
+    // Catmull-Rom is default bicubic for all implementations...
+    if (device.IsExtFilterCubicSupported() && (device.IsQcomFilterCubicWeightsSupported() || qcom_weights == VK_CUBIC_FILTER_WEIGHTS_CATMULL_ROM_QCOM)) {
+        return std::make_unique<WindowAdaptPass>(device, frame_format, CreateCubicSampler(device,
+            qcom_weights), BuildShader(device, VULKAN_PRESENT_FRAG_SPV));
+    } else {
+        return std::make_unique<WindowAdaptPass>(device, frame_format, CreateBilinearSampler(device), [&](){
+            switch (qcom_weights) {
+            case VK_CUBIC_FILTER_WEIGHTS_CATMULL_ROM_QCOM:
+                return BuildShader(device, PRESENT_BICUBIC_FRAG_SPV);
+            case VK_CUBIC_FILTER_WEIGHTS_ZERO_TANGENT_CARDINAL_QCOM:
+                return BuildShader(device, PRESENT_ZERO_TANGENT_FRAG_SPV);
+            case VK_CUBIC_FILTER_WEIGHTS_B_SPLINE_QCOM:
+                return BuildShader(device, PRESENT_BSPLINE_FRAG_SPV);
+            case VK_CUBIC_FILTER_WEIGHTS_MITCHELL_NETRAVALI_QCOM:
+                return BuildShader(device, PRESENT_MITCHELL_FRAG_SPV);
+            default:
+                UNREACHABLE();
+            }
+        }());
+    }
 }

 std::unique_ptr<WindowAdaptPass> MakeGaussian(const Device& device, VkFormat frame_format) {
@ -81,4 +102,9 @@ std::unique_ptr<WindowAdaptPass> MakeArea(const Device& device, VkFormat frame_f
                                             BuildShader(device, PRESENT_AREA_FRAG_SPV));
 }

+std::unique_ptr<WindowAdaptPass> MakeMmpx(const Device& device, VkFormat frame_format) {
+    return std::make_unique<WindowAdaptPass>(device, frame_format, CreateNearestNeighborSampler(device),
+                                             BuildShader(device, PRESENT_MMPX_FRAG_SPV));
+}
+
 } // namespace Vulkan
--- a/src/video_core/renderer_vulkan/present/filters.h
+++ b/src/video_core/renderer_vulkan/present/filters.h
@ -17,11 +17,12 @@ class MemoryAllocator;

 std::unique_ptr<WindowAdaptPass> MakeNearestNeighbor(const Device& device, VkFormat frame_format);
 std::unique_ptr<WindowAdaptPass> MakeBilinear(const Device& device, VkFormat frame_format);
-std::unique_ptr<WindowAdaptPass> MakeBicubic(const Device& device, VkFormat frame_format);
+std::unique_ptr<WindowAdaptPass> MakeBicubic(const Device& device, VkFormat frame_format, VkCubicFilterWeightsQCOM qcom_weights);
 std::unique_ptr<WindowAdaptPass> MakeSpline1(const Device& device, VkFormat frame_format);
 std::unique_ptr<WindowAdaptPass> MakeGaussian(const Device& device, VkFormat frame_format);
 std::unique_ptr<WindowAdaptPass> MakeLanczos(const Device& device, VkFormat frame_format);
 std::unique_ptr<WindowAdaptPass> MakeScaleForce(const Device& device, VkFormat frame_format);
 std::unique_ptr<WindowAdaptPass> MakeArea(const Device& device, VkFormat frame_format);
+std::unique_ptr<WindowAdaptPass> MakeMmpx(const Device& device, VkFormat frame_format);

 } // namespace Vulkan
--- a/src/video_core/renderer_vulkan/present/util.cpp
+++ b/src/video_core/renderer_vulkan/present/util.cpp
@ -624,8 +624,8 @@ vk::Sampler CreateNearestNeighborSampler(const Device& device) {
    return device.GetLogical().CreateSampler(ci_nn);
 }

-vk::Sampler CreateCubicSampler(const Device& device) {
-    const VkSamplerCreateInfo ci_nn{
+vk::Sampler CreateCubicSampler(const Device& device, VkCubicFilterWeightsQCOM qcom_weights) {
+    VkSamplerCreateInfo ci_nn{
        .sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
        .pNext = nullptr,
        .flags = 0,
@ -645,7 +645,14 @@ vk::Sampler CreateCubicSampler(const Device& device) {
        .borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK,
        .unnormalizedCoordinates = VK_FALSE,
    };
-
+    const VkSamplerCubicWeightsCreateInfoQCOM ci_qcom_nn{
+        .sType = VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM,
+        .pNext = nullptr,
+        .cubicWeights = qcom_weights
+    };
+    // If not specified, assume Catmull-Rom
+    if (qcom_weights != VK_CUBIC_FILTER_WEIGHTS_CATMULL_ROM_QCOM)
+        ci_nn.pNext = &ci_qcom_nn;
    return device.GetLogical().CreateSampler(ci_nn);
 }

--- a/src/video_core/renderer_vulkan/present/util.h
+++ b/src/video_core/renderer_vulkan/present/util.h
@ -57,7 +57,7 @@ VkWriteDescriptorSet CreateWriteDescriptorSet(std::vector<VkDescriptorImageInfo>
                                              VkDescriptorSet set, u32 binding);
 vk::Sampler CreateBilinearSampler(const Device& device);
 vk::Sampler CreateNearestNeighborSampler(const Device& device);
-vk::Sampler CreateCubicSampler(const Device& device);
+vk::Sampler CreateCubicSampler(const Device& device, VkCubicFilterWeightsQCOM qcom_weights);

 void BeginRenderPass(vk::CommandBuffer& cmdbuf, VkRenderPass render_pass, VkFramebuffer framebuffer,
                     VkExtent2D extent);
--- a/src/video_core/renderer_vulkan/vk_blit_screen.cpp
+++ b/src/video_core/renderer_vulkan/vk_blit_screen.cpp
@ -7,6 +7,7 @@
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

+#include <vulkan/vulkan_core.h>
 #include "video_core/framebuffer_config.h"
 #include "video_core/present.h"
 #include "video_core/renderer_vulkan/present/filters.h"
@ -41,7 +42,16 @@ void BlitScreen::SetWindowAdaptPass() {
        window_adapt = MakeNearestNeighbor(device, swapchain_view_format);
        break;
    case Settings::ScalingFilter::Bicubic:
-        window_adapt = MakeBicubic(device, swapchain_view_format);
+        window_adapt = MakeBicubic(device, swapchain_view_format, VK_CUBIC_FILTER_WEIGHTS_CATMULL_ROM_QCOM);
+        break;
+    case Settings::ScalingFilter::ZeroTangent:
+        window_adapt = MakeBicubic(device, swapchain_view_format, VK_CUBIC_FILTER_WEIGHTS_ZERO_TANGENT_CARDINAL_QCOM);
+        break;
+    case Settings::ScalingFilter::BSpline:
+        window_adapt = MakeBicubic(device, swapchain_view_format, VK_CUBIC_FILTER_WEIGHTS_B_SPLINE_QCOM);
+        break;
+    case Settings::ScalingFilter::Mitchell:
+        window_adapt = MakeBicubic(device, swapchain_view_format, VK_CUBIC_FILTER_WEIGHTS_MITCHELL_NETRAVALI_QCOM);
        break;
    case Settings::ScalingFilter::Spline1:
        window_adapt = MakeSpline1(device, swapchain_view_format);
@ -58,6 +68,9 @@ void BlitScreen::SetWindowAdaptPass() {
    case Settings::ScalingFilter::Area:
        window_adapt = MakeArea(device, swapchain_view_format);
        break;
+    case Settings::ScalingFilter::Mmpx:
+        window_adapt = MakeMmpx(device, swapchain_view_format);
+        break;
    case Settings::ScalingFilter::Fsr:
    case Settings::ScalingFilter::Bilinear:
    default:
--- a/src/video_core/vulkan_common/vulkan_device.h
+++ b/src/video_core/vulkan_common/vulkan_device.h
@ -89,7 +89,8 @@ VK_DEFINE_HANDLE(VmaAllocator)
    EXTENSION(NV, VIEWPORT_ARRAY2, viewport_array2)                                                \
    EXTENSION(NV, VIEWPORT_SWIZZLE, viewport_swizzle)                                              \
    EXTENSION(EXT, DESCRIPTOR_INDEXING, descriptor_indexing)                                       \
-    EXTENSION(EXT, FILTER_CUBIC, filter_cubic)
+    EXTENSION(EXT, FILTER_CUBIC, filter_cubic)                                                     \
+    EXTENSION(QCOM, FILTER_CUBIC_WEIGHTS, filter_cubic_weights)

 // Define extensions which must be supported.
 #define FOR_EACH_VK_MANDATORY_EXTENSION(EXTENSION_NAME)                                            \
@ -558,6 +559,11 @@ public:
        return extensions.filter_cubic;
    }

+    /// Returns true if the device supports VK_QCOM_filter_cubic_weights
+    bool IsQcomFilterCubicWeightsSupported() const {
+        return extensions.filter_cubic_weights;
+    }
+
    /// Returns true if the device supports VK_EXT_line_rasterization.
    bool IsExtLineRasterizationSupported() const {
        return extensions.line_rasterization;
--- a/src/yuzu/Info.plist
+++ b/src/yuzu/Info.plist
@ -45,9 +45,31 @@ SPDX-License-Identifier: GPL-2.0-or-later
    <true/>
    <key>NSHumanReadableCopyright</key>
    <string></string>
+    <!-- Fixed -->
+    <key>LSApplicationCategoryType</key>
+    <string>public.app-category.games</string>
+    <key>CFBundleDocumentTypes</key>
+    <array>
+        <dict>
+            <key>CFBundleTypeExtensions</key>
+            <array>
+                <string>nsp</string>
+                <string>xci</string>
+                <string>nro</string>
+            </array>
+            <key>CFBundleTypeName</key>
+            <string>Switch File</string>
+            <key>CFBundleTypeRole</key>
+            <string>Viewer</string>
+            <key>LSHandlerRank</key>
+            <string>Default</string>
+        </dict>
+    </array>
    <key>NSPrincipalClass</key>
    <string>NSApplication</string>
    <key>NSHighResolutionCapable</key>
    <string>True</string>
+    <key>UIDesignRequiresCompatibility</key>
+    <true/> <!-- https://bugreports.qt.io/browse/QTBUG-138942 -->
 </dict>
 </plist>
--- a/src/yuzu/configuration/configure_audio.cpp
+++ b/src/yuzu/configuration/configure_audio.cpp
@ -270,10 +270,8 @@ void ConfigureAudio::UpdateAudioDevices(int sink_index) {
 void ConfigureAudio::InitializeAudioSinkComboBox() {
    sink_combo_box->clear();
    sink_combo_box->addItem(QString::fromUtf8(AudioCore::Sink::auto_device_name));
-
-    for (const auto& id : AudioCore::Sink::GetSinkIDs()) {
-        sink_combo_box->addItem(QString::fromStdString(Settings::CanonicalizeEnum(id)));
-    }
+    for (const auto& id : AudioCore::Sink::GetSinkIDs())
+        sink_combo_box->addItem(QString::fromStdString(std::string{Settings::CanonicalizeEnum(id)}));
 }

 void ConfigureAudio::RetranslateUI() {
--- a/src/yuzu/configuration/configure_profile_manager.cpp
+++ b/src/yuzu/configuration/configure_profile_manager.cpp
@ -373,13 +373,13 @@ bool ConfigureProfileManager::LoadAvatarData() {
    const auto romfs = nca->GetRomFS();
    if (!romfs) {
        QMessageBox::warning(this, tr("Error loading archive"),
-                             tr("Archive does not contain romfs. It is probably corrupt."));
+                             tr("Could not locate RomFS. Your file or decryption keys may be corrupted."));
        return false;
    }
    const auto extracted = FileSys::ExtractRomFS(romfs);
    if (!extracted) {
        QMessageBox::warning(this, tr("Error extracting archive"),
-                             tr("Archive could not be extracted. It is probably corrupt."));
+                             tr("Could not extract RomFS. Your file or decryption keys may be corrupted."));
        return false;
    }
    const auto chara_dir = extracted->GetSubdirectory("chara");
--- a/src/yuzu/configuration/shared_widget.h
+++ b/src/yuzu/configuration/shared_widget.h
@ -13,6 +13,7 @@
 #include <QString>
 #include <QStringLiteral>
 #include <QWidget>
+#include <QObject>
 #include <qobjectdefs.h>
 #include "qt_common/shared_translation.h"

--- a/src/yuzu/game_list.h
+++ b/src/yuzu/game_list.h
@ -58,11 +58,11 @@ class GameList : public QWidget {
 public:
    enum {
        COLUMN_NAME,
-        COLUMN_COMPATIBILITY,
-        COLUMN_ADD_ONS,
        COLUMN_FILE_TYPE,
        COLUMN_SIZE,
        COLUMN_PLAY_TIME,
+        COLUMN_ADD_ONS,
+        COLUMN_COMPATIBILITY,
        COLUMN_COUNT, // Number of columns
    };

--- a/src/yuzu/game_list_worker.cpp
+++ b/src/yuzu/game_list_worker.cpp
@ -204,36 +204,24 @@ QList<QStandardItem*> MakeGameListEntry(const std::string& path,
                                        const PlayTime::PlayTimeManager& play_time_manager,
                                        const FileSys::PatchManager& patch)
 {
-    const auto it = FindMatchingCompatibilityEntry(compatibility_list, program_id);
+    auto const it = FindMatchingCompatibilityEntry(compatibility_list, program_id);
+    // The game list uses 99 as compatibility number for untested games
+    QString compatibility = it != compatibility_list.end() ? it->second.first : QStringLiteral("99");

-    // The game list uses this as compatibility number for untested games
-    QString compatibility{QStringLiteral("99")};
-    if (it != compatibility_list.end()) {
-        compatibility = it->second.first;
-    }
+    auto const file_type = loader.GetFileType();
+    auto const file_type_string = QString::fromStdString(Loader::GetFileTypeString(file_type));

-    const auto file_type = loader.GetFileType();
-    const auto file_type_string = QString::fromStdString(Loader::GetFileTypeString(file_type));
-
-    QList<QStandardItem*> list{
-        new GameListItemPath(FormatGameName(path), icon, QString::fromStdString(name),
-                             file_type_string, program_id),
-        new GameListItemCompat(compatibility),
+    QString patch_versions = GetGameListCachedObject(fmt::format("{:016X}", patch.GetTitleID()), "pv.txt", [&patch, &loader] {
+        return FormatPatchNameVersions(patch, loader, loader.IsRomFSUpdatable());
+    });
+    return QList<QStandardItem*>{
+        new GameListItemPath(FormatGameName(path), icon, QString::fromStdString(name), file_type_string, program_id),
        new GameListItem(file_type_string),
        new GameListItemSize(size),
        new GameListItemPlayTime(play_time_manager.GetPlayTime(program_id)),
+        new GameListItem(patch_versions),
+        new GameListItemCompat(compatibility),
    };
-
-    QString patch_versions;
-
-    patch_versions = GetGameListCachedObject(
-        fmt::format("{:016X}", patch.GetTitleID()), "pv.txt", [&patch, &loader] {
-            return FormatPatchNameVersions(patch, loader, loader.IsRomFSUpdatable());
-        });
-
-    list.insert(2, new GameListItem(patch_versions));
-
-    return list;
 }
 } // Anonymous namespace
Author	SHA1	Message	Date
lizzie	36fae75437	add MMPX filter All checks were successful eden-license / license-header (pull_request) Successful in 22s Details Signed-off-by: lizzie <lizzie@eden-emu.dev>	2025-09-29 17:56:14 +00:00
lizzie	e8d45d294a	better logic Signed-off-by: lizzie <lizzie@eden-emu.dev>	2025-09-29 17:55:52 +00:00
lizzie	d8d1ccbe62	fix vk Signed-off-by: lizzie <lizzie@eden-emu.dev>	2025-09-29 17:55:52 +00:00
lizzie	1290f7dca3	fix ogl Signed-off-by: lizzie <lizzie@eden-emu.dev>	2025-09-29 17:55:52 +00:00
lizzie	4a1e0e27ab	[vk, ogl] VK_QCOM ZTC, Bspline, Mitchell filter weights Signed-off-by: lizzie <lizzie@eden-emu.dev>	2025-09-29 17:55:51 +00:00
lizzie	85b5e650cc	[dist, docs] Clearer wording for settings, guidelines for new settings (#2570 ) Signed-off-by: lizzie <lizzie@eden-emu.dev> Reviewed-on: #2570 Reviewed-by: MaranBr <maranbr@eden-emu.dev> Reviewed-by: crueter <crueter@eden-emu.dev> Co-authored-by: lizzie <lizzie@eden-emu.dev> Co-committed-by: lizzie <lizzie@eden-emu.dev>	2025-09-29 19:41:01 +02:00
lizzie	324ace3cd6	[macos] associate .XCI/NSP file extensions (#2617 ) Signed-off-by: lizzie <lizzie@eden-emu.dev> Reviewed-on: #2617 Reviewed-by: crueter <crueter@eden-emu.dev> Reviewed-by: MaranBr <maranbr@eden-emu.dev> Co-authored-by: lizzie <lizzie@eden-emu.dev> Co-committed-by: lizzie <lizzie@eden-emu.dev>	2025-09-29 18:43:13 +02:00
lizzie	33f93ad003	[macos, qt] workaround upstream rendering bug (#2616 ) See https://bugreports.qt.io/browse/QTBUG-138942 Signed-off-by: lizzie <lizzie@eden-emu.dev> Reviewed-on: #2616 Reviewed-by: crueter <crueter@eden-emu.dev> Reviewed-by: MaranBr <maranbr@eden-emu.dev> Co-authored-by: lizzie <lizzie@eden-emu.dev> Co-committed-by: lizzie <lizzie@eden-emu.dev>	2025-09-29 18:42:51 +02:00
lizzie	9f423a24b8	[linux] fix aarch64 builds (again) + fix with slightly outdated qt (#2612 ) Fixes issues building on aarch64 linux with a slightly outdated system qt; also fixes linker selection process Signed-off-by: lizzie <lizzie@eden-emu.dev> Reviewed-on: #2612 Reviewed-by: crueter <crueter@eden-emu.dev> Reviewed-by: MaranBr <maranbr@eden-emu.dev> Co-authored-by: lizzie <lizzie@eden-emu.dev> Co-committed-by: lizzie <lizzie@eden-emu.dev>	2025-09-29 18:42:28 +02:00
Caio Oliveira	50ceb9a43a	[.ci] install-msvc: fix installation on MSVC (#2611 ) * changed from Build Tools to Community (congrats Microsoft very cool) * add spining to show it didnt stopped installing Signed-off-by: Caio Oliveira <caiooliveirafarias0@gmail.com> Reviewed-on: #2611 Reviewed-by: crueter <crueter@eden-emu.dev> Reviewed-by: MaranBr <maranbr@eden-emu.dev> Co-authored-by: Caio Oliveira <caiooliveirafarias0@gmail.com> Co-committed-by: Caio Oliveira <caiooliveirafarias0@gmail.com>	2025-09-29 18:42:04 +02:00
lizzie	ecb811ad04	[qt] move addons row to rightmost side (#2610 ) This is because the rightmost row is "extended" to the rest of the table, and add-ons have long names, play time doesn't need that much space. Signed-off-by: lizzie <lizzie@eden-emu.dev> Reviewed-on: #2610 Reviewed-by: crueter <crueter@eden-emu.dev> Reviewed-by: MaranBr <maranbr@eden-emu.dev> Co-authored-by: lizzie <lizzie@eden-emu.dev> Co-committed-by: lizzie <lizzie@eden-emu.dev>	2025-09-29 18:41:28 +02:00
lizzie	bf302d7917	[common] No need to specify min/max for settings; fix crash when OOB value is given for some settings (#2609 ) This fixes issues when migrating settings that refer to invalid filters/scales. For example if we had 5 filters, but we set filter=6, the program would crash. This also makes so specifying min/max manually isn't needed (but can still be set for cases like NCE). Signed-off-by: lizzie <lizzie@eden-emu.dev> Reviewed-on: #2609 Reviewed-by: crueter <crueter@eden-emu.dev> Reviewed-by: MaranBr <maranbr@eden-emu.dev> Co-authored-by: lizzie <lizzie@eden-emu.dev> Co-committed-by: lizzie <lizzie@eden-emu.dev>	2025-09-29 18:40:29 +02:00
unknown	d19a7c3782	[service] unstub process winding (#2590 ) It's used on FW19+ and FW20+ but since all 20+ applets stuck on HID, you still can't boot into applets. Should fix: Bioshock Infinite on FW19 Reviewed-on: #2590 Reviewed-by: Shinmegumi <shinmegumi@eden-emu.dev> Reviewed-by: MaranBr <maranbr@eden-emu.dev> Co-authored-by: unknown <sahyno1996@gmail.com> Co-committed-by: unknown <sahyno1996@gmail.com>	2025-09-28 18:43:01 +02:00