more changes might have overlooked something

src/android/app/src/main/java/org/yuzu/yuzu_emu/overlay/InputOverlay.kt

@@ -1039,7 +1039,7 @@ class InputOverlay(context: Context, attrs: AttributeSet?) :
             scale /= 100f
 
             // Apply individual scale
-            scale *= overlayControlData.individualScale.let { if (it > 0f) it else 1f }
+            scale *= overlayControlData.individualScale
 
             // Initialize the InputOverlayDrawableButton.
             val defaultStateBitmap = getBitmap(context, defaultResId, scale)
@@ -1114,7 +1114,7 @@ class InputOverlay(context: Context, attrs: AttributeSet?) :
 
             // Apply individual scale
             if (dpadData != null) {
-                scale *= dpadData.individualScale.let { if (it > 0f) it else 1f }
+                scale *= dpadData.individualScale
             }
 
             // Initialize the InputOverlayDrawableDpad.
@@ -1191,7 +1191,7 @@ class InputOverlay(context: Context, attrs: AttributeSet?) :
             scale /= 100f
 
             // Apply individual scale
-            scale *= overlayControlData.individualScale.let { if (it > 0f) it else 1f }
+            scale *= overlayControlData.individualScale
 
             // Initialize the InputOverlayDrawableJoystick.
             val bitmapOuter = getBitmap(context, resOuter, scale)

src/audio_core/common/feature_support.h

@@ -16,7 +16,7 @@
 #include <ranges>
 
 namespace AudioCore {
-constexpr u32 CurrentRevision = 15;
+constexpr u32 CurrentRevision = 16;
 
 enum class SupportTags {
     CommandProcessingTimeEstimatorVersion4,
@@ -47,10 +47,6 @@ enum class SupportTags {
     DelayChannelMappingChange,
     ReverbChannelMappingChange,
     I3dl2ReverbChannelMappingChange,
-    SplitterPrevVolumeReset,
-    SplitterBiquadFilterParameter,
-    SplitterDestinationV2b,
-    VoiceInParameterV2,
 
     // Not a real tag, just here to get the count.
     Size
@@ -95,10 +91,6 @@ constexpr bool CheckFeatureSupported(SupportTags tag, u32 user_revision) {
             {SupportTags::DelayChannelMappingChange, 11},
             {SupportTags::ReverbChannelMappingChange, 11},
             {SupportTags::I3dl2ReverbChannelMappingChange, 11},
-            {SupportTags::SplitterBiquadFilterParameter, 12},
-            {SupportTags::SplitterPrevVolumeReset, 13},
-            {SupportTags::SplitterDestinationV2b, 15},
-            {SupportTags::VoiceInParameterV2, 15},
         }};
 
     const auto& feature =

src/audio_core/renderer/behavior/behavior_info.cpp

@@ -193,20 +193,4 @@ bool BehaviorInfo::IsI3dl2ReverbChannelMappingChanged() const {
     return CheckFeatureSupported(SupportTags::I3dl2ReverbChannelMappingChange, user_revision);
 }
 
-bool BehaviorInfo::IsSplitterPrevVolumeResetSupported() const {
-    return CheckFeatureSupported(SupportTags::SplitterPrevVolumeReset, user_revision);
-}
-
-bool BehaviorInfo::IsSplitterDestinationV2bSupported() const {
-    return CheckFeatureSupported(SupportTags::SplitterDestinationV2b, user_revision);
-}
-
-bool BehaviorInfo::IsVoiceInParameterV2Supported() const {
-    return CheckFeatureSupported(SupportTags::VoiceInParameterV2, user_revision);
-}
-
-bool BehaviorInfo::IsBiquadFilterParameterForSplitterEnabled() const {
-    return CheckFeatureSupported(SupportTags::SplitterBiquadFilterParameter, user_revision);
-}
-
 } // namespace AudioCore::Renderer

src/audio_core/renderer/behavior/behavior_info.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -364,38 +361,6 @@ public:
      */
     bool IsI3dl2ReverbChannelMappingChanged() const;
 
-    /**
-     * Check if explicit previous mix volume reset is supported for splitters.
-     * This allows splitters to explicitly reset their previous mix volumes instead of
-     * doing so implicitly on first use.
-     *
-     * @return True if supported, otherwise false.
-     */
-    bool IsSplitterPrevVolumeResetSupported() const;
-
-    /**
-     * Check if splitter destination v2b parameter format is supported (revision 15+).
-     * This uses the extended parameter format with biquad filter fields.
-     *
-     * @return True if supported, otherwise false.
-     */
-    bool IsSplitterDestinationV2bSupported() const;
-
-    /**
-     * Check if voice input parameter v2 format is supported (revision 15+).
-     * This uses the extended parameter format with float biquad filters.
-     *
-     * @return True if supported, otherwise false.
-     */
-    bool IsVoiceInParameterV2Supported() const;
-
-    /**
-     * Check if splitter destinations can carry biquad filter parameters (revision 12+).
-     *
-     * @return True if supported, otherwise false.
-     */
-    bool IsBiquadFilterParameterForSplitterEnabled() const;
-
     /// Host version
     u32 process_revision;
     /// User version

src/audio_core/renderer/behavior/info_updater.cpp

@@ -64,6 +64,8 @@ Result InfoUpdater::UpdateVoices(VoiceContext& voice_context,
     const PoolMapper pool_mapper(process_handle, memory_pools, memory_pool_count,
                                  behaviour.IsMemoryForceMappingEnabled());
     const auto voice_count{voice_context.GetCount()};
+    std::span<const VoiceInfo::InParameter> in_params{
+        reinterpret_cast<const VoiceInfo::InParameter*>(input), voice_count};
     std::span<VoiceInfo::OutStatus> out_params{reinterpret_cast<VoiceInfo::OutStatus*>(output),
                                                voice_count};
 
@@ -74,104 +76,8 @@ Result InfoUpdater::UpdateVoices(VoiceContext& voice_context,
 
     u32 new_voice_count{0};
 
-    // Two input formats exist: legacy (0x170) and v2 with float biquad (0x188).
-    const bool use_v2 = behaviour.IsVoiceInParameterV2Supported();
-    const u32 in_stride = use_v2 ? 0x188u : static_cast<u32>(sizeof(VoiceInfo::InParameter));
-
     for (u32 i = 0; i < voice_count; i++) {
-        VoiceInfo::InParameter local_in{};
+        const auto& in_param{in_params[i]};
-        std::array<VoiceInfo::BiquadFilterParameter2, MaxBiquadFilters> float_biquads{};
-
-        if (!use_v2) {
-            const auto* in_param_ptr = reinterpret_cast<const VoiceInfo::InParameter*>(
-                input + i * sizeof(VoiceInfo::InParameter));
-            local_in = *in_param_ptr;
-        } else {
-            struct VoiceInParameterV2 {
-                u32 id;
-                u32 node_id;
-                bool is_new;
-                bool in_use;
-                PlayState play_state;
-                SampleFormat sample_format;
-                u32 sample_rate;
-                u32 priority;
-                u32 sort_order;
-                u32 channel_count;
-                f32 pitch;
-                f32 volume;
-                // Two BiquadFilterParameter2 (0x18 each) -> ignored/converted
-                struct BiquadV2 {
-                    bool enable;
-                    u8 r1;
-                    u8 r2;
-                    u8 r3;
-                    std::array<f32, 3> b;
-                    std::array<f32, 2> a;
-                } biquads[2];
-                u32 wave_buffer_count;
-                u32 wave_buffer_index;
-                u32 reserved1;
-                u64 src_data_address;
-                u64 src_data_size;
-                s32 mix_id;
-                u32 splitter_id;
-                std::array<VoiceInfo::WaveBufferInternal, MaxWaveBuffers> wavebuffers;
-                std::array<u32, MaxChannels> channel_resource_ids;
-                bool clear_voice_drop;
-                u8 flush_wave_buffer_count;
-                u16 reserved2;
-                VoiceInfo::Flags flags;
-                SrcQuality src_quality;
-                u32 external_ctx;
-                u32 external_ctx_size;
-                u32 reserved3[2];
-            };
-            const auto* vin = reinterpret_cast<const VoiceInParameterV2*>(input + i * in_stride);
-            local_in.id = vin->id;
-            local_in.node_id = vin->node_id;
-            local_in.is_new = vin->is_new;
-            local_in.in_use = vin->in_use;
-            local_in.play_state = vin->play_state;
-            local_in.sample_format = vin->sample_format;
-            local_in.sample_rate = vin->sample_rate;
-            local_in.priority = static_cast<s32>(vin->priority);
-            local_in.sort_order = static_cast<s32>(vin->sort_order);
-            local_in.channel_count = vin->channel_count;
-            local_in.pitch = vin->pitch;
-            local_in.volume = vin->volume;
-
-            // For REV15+, we keep float coefficients separate and only convert for compatibility
-            for (size_t filter_idx = 0; filter_idx < MaxBiquadFilters; filter_idx++) {
-                const auto& src = vin->biquads[filter_idx];
-                auto& dst = local_in.biquads[filter_idx];
-                dst.enabled = src.enable;
-                // Convert float coefficients to fixed-point Q2.14 for legacy path
-                dst.b[0] = static_cast<s16>(std::clamp(src.b[0] * 16384.0f, -32768.0f, 32767.0f));
-                dst.b[1] = static_cast<s16>(std::clamp(src.b[1] * 16384.0f, -32768.0f, 32767.0f));
-                dst.b[2] = static_cast<s16>(std::clamp(src.b[2] * 16384.0f, -32768.0f, 32767.0f));
-                dst.a[0] = static_cast<s16>(std::clamp(src.a[0] * 16384.0f, -32768.0f, 32767.0f));
-                dst.a[1] = static_cast<s16>(std::clamp(src.a[1] * 16384.0f, -32768.0f, 32767.0f));
-
-                // Also store the native float version
-                float_biquads[filter_idx].enabled = src.enable;
-                float_biquads[filter_idx].numerator = src.b;
-                float_biquads[filter_idx].denominator = src.a;
-            }
-            local_in.wave_buffer_count = vin->wave_buffer_count;
-            local_in.wave_buffer_index = static_cast<u16>(vin->wave_buffer_index);
-            local_in.src_data_address = static_cast<CpuAddr>(vin->src_data_address);
-            local_in.src_data_size = vin->src_data_size;
-            local_in.mix_id = static_cast<u32>(vin->mix_id);
-            local_in.splitter_id = vin->splitter_id;
-            local_in.wave_buffer_internal = vin->wavebuffers;
-            local_in.channel_resource_ids = vin->channel_resource_ids;
-            local_in.clear_voice_drop = vin->clear_voice_drop;
-            local_in.flush_buffer_count = vin->flush_wave_buffer_count;
-            local_in.flags = vin->flags;
-            local_in.src_quality = vin->src_quality;
-        }
-        const auto& in_param = local_in;
         std::array<VoiceState*, MaxChannels> voice_states{};
 
         if (!in_param.in_use) {
@@ -195,14 +101,6 @@ Result InfoUpdater::UpdateVoices(VoiceContext& voice_context,
         BehaviorInfo::ErrorInfo update_error{};
         voice_info.UpdateParameters(update_error, in_param, pool_mapper, behaviour);
 
-        // For REV15+, store the native float biquad coefficients
-        if (use_v2) {
-            voice_info.use_float_biquads = true;
-            voice_info.biquads_float = float_biquads;
-        } else {
-            voice_info.use_float_biquads = false;
-        }
-
         if (!update_error.error_code.IsSuccess()) {
             behaviour.AppendError(update_error);
         }
@@ -223,7 +121,7 @@ Result InfoUpdater::UpdateVoices(VoiceContext& voice_context,
         new_voice_count += in_param.channel_count;
     }
 
-    auto consumed_input_size{voice_count * in_stride};
+    auto consumed_input_size{voice_count * static_cast<u32>(sizeof(VoiceInfo::InParameter))};
     auto consumed_output_size{voice_count * static_cast<u32>(sizeof(VoiceInfo::OutStatus))};
     if (consumed_input_size != in_header->voices_size) {
         LOG_ERROR(Service_Audio, "Consumed an incorrect voices size, header size={}, consumed={}",
@@ -359,31 +257,18 @@ Result InfoUpdater::UpdateMixes(MixContext& mix_context, const u32 mix_buffer_co
                                 EffectContext& effect_context, SplitterContext& splitter_context) {
     s32 mix_count{0};
     u32 consumed_input_size{0};
-    u32 input_mix_size{0};
 
     if (behaviour.IsMixInParameterDirtyOnlyUpdateSupported()) {
         auto in_dirty_params{reinterpret_cast<const MixInfo::InDirtyParameter*>(input)};
         mix_count = in_dirty_params->count;
-
-        // Validate against expected header size to ensure structure is correct
-        if (mix_count < 0 || mix_count > 0x100) {
-            LOG_ERROR(
-                Service_Audio,
-                "Invalid mix count from dirty parameter: count={}, magic=0x{:X}, expected_size={}",
-                mix_count, in_dirty_params->magic, in_header->mix_size);
-            return Service::Audio::ResultInvalidUpdateInfo;
-        }
-
-        consumed_input_size += static_cast<u32>(sizeof(MixInfo::InDirtyParameter));
         input += sizeof(MixInfo::InDirtyParameter);
+        consumed_input_size = static_cast<u32>(sizeof(MixInfo::InDirtyParameter) +
+                                               mix_count * sizeof(MixInfo::InParameter));
     } else {
         mix_count = mix_context.GetCount();
+        consumed_input_size = static_cast<u32>(mix_count * sizeof(MixInfo::InParameter));
     }
 
-    input_mix_size = static_cast<u32>(mix_count * sizeof(MixInfo::InParameter));
-    consumed_input_size += input_mix_size;
-
-
     if (mix_buffer_count == 0) {
         return Service::Audio::ResultInvalidUpdateInfo;
     }

src/audio_core/renderer/command/command_buffer.cpp

@@ -237,13 +237,6 @@ void CommandBuffer::GenerateBiquadFilterCommand(const s32 node_id, VoiceInfo& vo
 
     cmd.biquad = voice_info.biquads[biquad_index];
 
-    if (voice_info.use_float_biquads) {
-        cmd.biquad_float = voice_info.biquads_float[biquad_index];
-        cmd.use_float_coefficients = true;
-    } else {
-        cmd.use_float_coefficients = false;
-    }
-
     cmd.state = memory_pool->Translate(CpuAddr(voice_state.biquad_states[biquad_index].data()),
                                        MaxBiquadFilters * sizeof(VoiceState::BiquadFilterState));
 
@@ -270,9 +263,6 @@ void CommandBuffer::GenerateBiquadFilterCommand(const s32 node_id, EffectInfoBas
     cmd.biquad.b = parameter.b;
     cmd.biquad.a = parameter.a;
 
-    // Effects use legacy fixed-point format
-    cmd.use_float_coefficients = false;
-
     cmd.state = memory_pool->Translate(CpuAddr(state),
                                        MaxBiquadFilters * sizeof(VoiceState::BiquadFilterState));
 
@@ -668,13 +658,6 @@ void CommandBuffer::GenerateMultitapBiquadFilterCommand(const s32 node_id, Voice
     cmd.output = buffer_count + channel;
     cmd.biquads = voice_info.biquads;
 
-    if (voice_info.use_float_biquads) {
-        cmd.biquads_float = voice_info.biquads_float;
-        cmd.use_float_coefficients = true;
-    } else {
-        cmd.use_float_coefficients = false;
-    }
-
     cmd.states[0] =
         memory_pool->Translate(CpuAddr(voice_state.biquad_states[0].data()),
                                MaxBiquadFilters * sizeof(VoiceState::BiquadFilterState));

src/audio_core/renderer/command/effect/biquad_filter.cpp

@@ -51,40 +51,6 @@ void ApplyBiquadFilterFloat(std::span<s32> output, std::span<const s32> input,
     state.s3 = Common::BitCast<s64>(s[3]);
 }
 
-/**
- * Biquad filter float implementation with native float coefficients.
- */
-void ApplyBiquadFilterFloat2(std::span<s32> output, std::span<const s32> input,
-                             std::array<f32, 3>& b, std::array<f32, 2>& a,
-                             VoiceState::BiquadFilterState& state, const u32 sample_count) {
-    constexpr f64 min{std::numeric_limits<s32>::min()};
-    constexpr f64 max{std::numeric_limits<s32>::max()};
-
-    std::array<f64, 3> b_double{static_cast<f64>(b[0]), static_cast<f64>(b[1]),
-                                static_cast<f64>(b[2])};
-    std::array<f64, 2> a_double{static_cast<f64>(a[0]), static_cast<f64>(a[1])};
-    std::array<f64, 4> s{Common::BitCast<f64>(state.s0), Common::BitCast<f64>(state.s1),
-                         Common::BitCast<f64>(state.s2), Common::BitCast<f64>(state.s3)};
-
-    for (u32 i = 0; i < sample_count; i++) {
-        f64 in_sample{static_cast<f64>(input[i])};
-        auto sample{in_sample * b_double[0] + s[0] * b_double[1] + s[1] * b_double[2] +
-                    s[2] * a_double[0] + s[3] * a_double[1]};
-
-        output[i] = static_cast<s32>(std::clamp(sample, min, max));
-
-        s[1] = s[0];
-        s[0] = in_sample;
-        s[3] = s[2];
-        s[2] = sample;
-    }
-
-    state.s0 = Common::BitCast<s64>(s[0]);
-    state.s1 = Common::BitCast<s64>(s[1]);
-    state.s2 = Common::BitCast<s64>(s[2]);
-    state.s3 = Common::BitCast<s64>(s[3]);
-}
-
 /**
  * Biquad filter s32 implementation.
  *
@@ -132,14 +98,8 @@ void BiquadFilterCommand::Process(const AudioRenderer::CommandListProcessor& pro
         processor.mix_buffers.subspan(output * processor.sample_count, processor.sample_count)};
 
     if (use_float_processing) {
-        // REV15+: Use native float coefficients if available
-        if (use_float_coefficients) {
-            ApplyBiquadFilterFloat2(output_buffer, input_buffer, biquad_float.numerator,
-                                    biquad_float.denominator, *state_, processor.sample_count);
-        } else {
         ApplyBiquadFilterFloat(output_buffer, input_buffer, biquad.b, biquad.a, *state_,
                                processor.sample_count);
-        }
     } else {
         ApplyBiquadFilterInt(output_buffer, input_buffer, biquad.b, biquad.a, *state_,
                              processor.sample_count);

src/audio_core/renderer/command/effect/biquad_filter.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -53,16 +50,12 @@ struct BiquadFilterCommand : ICommand {
     s16 output;
     /// Input parameters for biquad
     VoiceInfo::BiquadFilterParameter biquad;
-    /// Input parameters for biquad (REV15+ native float)
-    VoiceInfo::BiquadFilterParameter2 biquad_float;
     /// Biquad state, updated each call
     CpuAddr state;
     /// If true, reset the state
     bool needs_init;
     /// If true, use float processing rather than int
     bool use_float_processing;
-    /// If true, use native float coefficients (REV15+)
-    bool use_float_coefficients;
 };
 
 /**
@@ -79,18 +72,4 @@ void ApplyBiquadFilterFloat(std::span<s32> output, std::span<const s32> input,
                             std::array<s16, 3>& b, std::array<s16, 2>& a,
                             VoiceState::BiquadFilterState& state, const u32 sample_count);
 
-/**
- * Biquad filter float implementation with native float coefficients (SDK REV15+).
- *
- * @param output       - Output container for filtered samples.
- * @param input        - Input container for samples to be filtered.
- * @param b            - Feedforward coefficients (float).
- * @param a            - Feedback coefficients (float).
- * @param state        - State to track previous samples.
- * @param sample_count - Number of samples to process.
- */
-void ApplyBiquadFilterFloat2(std::span<s32> output, std::span<const s32> input,
-                             std::array<f32, 3>& b, std::array<f32, 2>& a,
-                             VoiceState::BiquadFilterState& state, const u32 sample_count);
-
 } // namespace AudioCore::Renderer

src/audio_core/renderer/command/effect/multi_tap_biquad_filter.cpp

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -36,16 +33,10 @@ void MultiTapBiquadFilterCommand::Process(const AudioRenderer::CommandListProces
             *state = {};
         }
 
-        // REV15+: Use native float coefficients if available
-        if (use_float_coefficients) {
-            ApplyBiquadFilterFloat2(output_buffer, input_buffer, biquads_float[i].numerator,
-                                    biquads_float[i].denominator, *state, processor.sample_count);
-        } else {
         ApplyBiquadFilterFloat(output_buffer, input_buffer, biquads[i].b, biquads[i].a, *state,
                                processor.sample_count);
     }
 }
-}
 
 bool MultiTapBiquadFilterCommand::Verify(const AudioRenderer::CommandListProcessor& processor) {
     return true;

src/audio_core/renderer/command/effect/multi_tap_biquad_filter.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -52,16 +49,12 @@ struct MultiTapBiquadFilterCommand : ICommand {
     s16 output;
     /// Biquad parameters
     std::array<VoiceInfo::BiquadFilterParameter, MaxBiquadFilters> biquads;
-    /// Biquad parameters (REV15+ native float)
-    std::array<VoiceInfo::BiquadFilterParameter2, MaxBiquadFilters> biquads_float;
     /// Biquad states, updated each call
     std::array<CpuAddr, MaxBiquadFilters> states;
     /// If each biquad needs initialisation
     std::array<bool, MaxBiquadFilters> needs_init;
     /// Number of active biquads
     u8 filter_tap_count;
-    /// If true, use native float coefficients (REV15+)
-    bool use_float_coefficients;
 };
 
 } // namespace AudioCore::Renderer

src/audio_core/renderer/splitter/splitter_context.cpp

@@ -35,16 +35,12 @@ SplitterDestinationData& SplitterContext::GetData(const u32 index) {
 
 void SplitterContext::Setup(std::span<SplitterInfo> splitter_infos_, const u32 splitter_info_count_,
                             SplitterDestinationData* splitter_destinations_,
-                            const u32 destination_count_, const bool splitter_bug_fixed_,
+                            const u32 destination_count_, const bool splitter_bug_fixed_) {
-                            const BehaviorInfo& behavior) {
     splitter_infos = splitter_infos_;
     info_count = splitter_info_count_;
     splitter_destinations = splitter_destinations_;
     destinations_count = destination_count_;
     splitter_bug_fixed = splitter_bug_fixed_;
-    splitter_prev_volume_reset_supported = behavior.IsSplitterPrevVolumeResetSupported();
-    splitter_biquad_param_supported = behavior.IsBiquadFilterParameterForSplitterEnabled();
-    splitter_float_coeff_supported = behavior.IsSplitterDestinationV2bSupported();
 }
 
 bool SplitterContext::UsingSplitter() const {
@@ -88,7 +84,7 @@ bool SplitterContext::Initialize(const BehaviorInfo& behavior,
         }
 
         Setup(splitter_infos, params.splitter_infos, splitter_destinations,
-              params.splitter_destinations, behavior.IsSplitterBugFixed(), behavior);
+              params.splitter_destinations, behavior.IsSplitterBugFixed());
     }
     return true;
 }
@@ -141,104 +137,19 @@ u32 SplitterContext::UpdateInfo(const u8* input, u32 offset, const u32 splitter_
 
 u32 SplitterContext::UpdateData(const u8* input, u32 offset, const u32 count) {
     for (u32 i = 0; i < count; i++) {
-        // Version selection based on feature flags:
+        auto data_header{
-        // - REV12: integer biquad params (Version2a)
+            reinterpret_cast<const SplitterDestinationData::InParameter*>(input + offset)};
-        // - REV15: float coeff/biquad v2b
-        // - older: no biquad fields
-        if (!splitter_biquad_param_supported) {
-            const auto* data_header =
-                reinterpret_cast<const SplitterDestinationData::InParameter*>(input + offset);
 
         if (data_header->magic != GetSplitterSendDataMagic()) {
             continue;
         }
+
         if (data_header->id < 0 || data_header->id > destinations_count) {
             continue;
         }
 
-            auto modified_params = *data_header;
+        splitter_destinations[data_header->id].Update(*data_header);
-            if (!splitter_prev_volume_reset_supported) {
-                modified_params.reset_prev_volume = false;
-            }
-            splitter_destinations[data_header->id].Update(modified_params);
         offset += sizeof(SplitterDestinationData::InParameter);
-        } else if (!splitter_float_coeff_supported) {
-            // Version 2a: struct contains legacy fixed-point biquad filter fields (REV12+)
-            const auto* data_header_v2a =
-                reinterpret_cast<const SplitterDestinationData::InParameterVersion2a*>(input +
-                                                                                       offset);
-
-            if (data_header_v2a->magic != GetSplitterSendDataMagic()) {
-                continue;
-            }
-            if (data_header_v2a->id < 0 || data_header_v2a->id > destinations_count) {
-                continue;
-            }
-
-            // Map common fields to the base format
-            SplitterDestinationData::InParameter mapped{};
-            mapped.magic = data_header_v2a->magic;
-            mapped.id = data_header_v2a->id;
-            mapped.mix_volumes = data_header_v2a->mix_volumes;
-            mapped.mix_id = data_header_v2a->mix_id;
-            mapped.in_use = data_header_v2a->in_use;
-            mapped.reset_prev_volume =
-                splitter_prev_volume_reset_supported ? data_header_v2a->reset_prev_volume : false;
-
-            auto& destination = splitter_destinations[data_header_v2a->id];
-            destination.Update(mapped);
-
-            // Convert legacy fixed-point biquad params into float representation
-            auto biquad_filters = destination.GetBiquadFilters();
-            for (size_t filter_idx = 0; filter_idx < MaxBiquadFilters; filter_idx++) {
-                const auto& legacy = data_header_v2a->biquad_filters[filter_idx];
-                auto& out = biquad_filters[filter_idx];
-                out.enabled = legacy.enabled;
-                // s16 fixed-point scale: use Q14 like voices (b and a are s16, 1.0 ~= 1<<14)
-                constexpr float scale = 1.0f / static_cast<float>(1 << 14);
-                out.numerator[0] = static_cast<float>(legacy.b[0]) * scale;
-                out.numerator[1] = static_cast<float>(legacy.b[1]) * scale;
-                out.numerator[2] = static_cast<float>(legacy.b[2]) * scale;
-                out.denominator[0] = static_cast<float>(legacy.a[0]) * scale;
-                out.denominator[1] = static_cast<float>(legacy.a[1]) * scale;
-            }
-
-            offset += static_cast<u32>(sizeof(SplitterDestinationData::InParameterVersion2a));
-        } else {
-            // Version 2b: struct contains extra biquad filter fields with float coeffs
-            const auto* data_header_v2b =
-                reinterpret_cast<const SplitterDestinationData::InParameterVersion2b*>(input +
-                                                                                       offset);
-
-            if (data_header_v2b->magic != GetSplitterSendDataMagic()) {
-                continue;
-            }
-            if (data_header_v2b->id < 0 || data_header_v2b->id > destinations_count) {
-                continue;
-            }
-
-            // Map common fields to the old format
-            SplitterDestinationData::InParameter mapped{};
-            mapped.magic = data_header_v2b->magic;
-            mapped.id = data_header_v2b->id;
-            mapped.mix_volumes = data_header_v2b->mix_volumes;
-            mapped.mix_id = data_header_v2b->mix_id;
-            mapped.in_use = data_header_v2b->in_use;
-            mapped.reset_prev_volume =
-                splitter_prev_volume_reset_supported ? data_header_v2b->reset_prev_volume : false;
-
-            // Store biquad filters from V2b (REV15+)
-            auto& destination = splitter_destinations[data_header_v2b->id];
-            destination.Update(mapped);
-
-            // Copy biquad filter parameters
-            auto biquad_filters = destination.GetBiquadFilters();
-            for (size_t filter_idx = 0; filter_idx < MaxBiquadFilters; filter_idx++) {
-                biquad_filters[filter_idx] = data_header_v2b->biquad_filters[filter_idx];
-            }
-
-            offset += static_cast<u32>(sizeof(SplitterDestinationData::InParameterVersion2b));
-        }
     }
 
     return offset;

src/audio_core/renderer/splitter/splitter_context.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -171,11 +168,10 @@ private:
      * @param splitter_destinations - Workbuffer for splitter destinations.
      * @param destination_count     - Number of destinations in the workbuffer.
      * @param splitter_bug_fixed    - Is the splitter bug fixed?
-     * @param behavior               - Behavior info for feature support.
      */
     void Setup(std::span<SplitterInfo> splitter_infos, u32 splitter_info_count,
                SplitterDestinationData* splitter_destinations, u32 destination_count,
-               bool splitter_bug_fixed, const BehaviorInfo& behavior);
+               bool splitter_bug_fixed);
 
     /// Workbuffer for splitters
     std::span<SplitterInfo> splitter_infos{};
@@ -187,12 +183,6 @@ private:
     s32 destinations_count{};
     /// Is the splitter bug fixed?
     bool splitter_bug_fixed{};
-    /// Is explicit previous mix volume reset supported?
-    bool splitter_prev_volume_reset_supported{};
-    /// Is biquad filter parameter for splitter (REV12) supported?
-    bool splitter_biquad_param_supported{};
-    /// Is float coefficient/biquad filter v2b parameter supported?
-    bool splitter_float_coeff_supported{};
 };
 
 } // namespace Renderer

src/audio_core/renderer/splitter/splitter_destinations_data.cpp

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -87,14 +84,4 @@ void SplitterDestinationData::SetNext(SplitterDestinationData* next_) {
     next = next_;
 }
 
-std::span<SplitterDestinationData::BiquadFilterParameter2>
-SplitterDestinationData::GetBiquadFilters() {
-    return biquad_filters;
-}
-
-std::span<const SplitterDestinationData::BiquadFilterParameter2>
-SplitterDestinationData::GetBiquadFilters() const {
-    return biquad_filters;
-}
-
 } // namespace AudioCore::Renderer

src/audio_core/renderer/splitter/splitter_destinations_data.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -19,72 +16,16 @@ namespace AudioCore::Renderer {
  */
 class SplitterDestinationData {
 public:
-    /**
-     * Biquad filter parameter with float coefficients (SDK REV15+).
-     * Defined here to avoid circular dependency with VoiceInfo.
-     */
-    struct BiquadFilterParameter2 {
-        /* 0x00 */ bool enabled;
-        /* 0x01 */ u8 reserved1;
-        /* 0x02 */ u8 reserved2;
-        /* 0x03 */ u8 reserved3;
-        /* 0x04 */ std::array<f32, 3> numerator;   // b0, b1, b2
-        /* 0x10 */ std::array<f32, 2> denominator; // a1, a2 (a0 = 1)
-    };
-    static_assert(sizeof(BiquadFilterParameter2) == 0x18,
-                  "BiquadFilterParameter2 has the wrong size!");
-
-    /**
-     * Legacy biquad filter parameter with fixed-point coefficients (SDK REV12+ for splitters).
-     * Matches the old voice biquad format.
-     */
-    struct BiquadFilterParameterLegacy {
-        /* 0x00 */ bool enabled;
-        /* 0x02 */ std::array<s16, 3> b; // numerator
-        /* 0x08 */ std::array<s16, 2> a; // denominator (a0 = 1)
-    };
-    static_assert(sizeof(BiquadFilterParameterLegacy) == 0xC,
-                  "BiquadFilterParameterLegacy has the wrong size!");
-
     struct InParameter {
         /* 0x00 */ u32 magic; // 'SNDD'
         /* 0x04 */ s32 id;
         /* 0x08 */ std::array<f32, MaxMixBuffers> mix_volumes;
         /* 0x68 */ u32 mix_id;
         /* 0x6C */ bool in_use;
-        /* 0x6D */ bool reset_prev_volume;
     };
     static_assert(sizeof(InParameter) == 0x70,
                   "SplitterDestinationData::InParameter has the wrong size!");
 
-    struct InParameterVersion2a {
-        /* 0x00 */ u32 magic; // 'SNDD'
-        /* 0x04 */ s32 id;
-        /* 0x08 */ std::array<f32, MaxMixBuffers> mix_volumes;
-        /* 0x68 */ u32 mix_id;
-        /* 0x6C */ std::array<SplitterDestinationData::BiquadFilterParameterLegacy, MaxBiquadFilters>
-            biquad_filters;
-        /* 0x84 */ bool in_use;
-        /* 0x85 */ bool reset_prev_volume; // only effective if supported
-        /* 0x86 */ u8 reserved[10];
-    };
-    static_assert(sizeof(InParameterVersion2a) == 0x90,
-                  "SplitterDestinationData::InParameterVersion2a has the wrong size!");
-
-    struct InParameterVersion2b {
-        /* 0x00 */ u32 magic; // 'SNDD'
-        /* 0x04 */ s32 id;
-        /* 0x08 */ std::array<f32, MaxMixBuffers> mix_volumes;
-        /* 0x68 */ u32 mix_id;
-        /* 0x6C */ std::array<SplitterDestinationData::BiquadFilterParameter2, MaxBiquadFilters>
-            biquad_filters;
-        /* 0x9C */ bool in_use;
-        /* 0x9D */ bool reset_prev_volume;
-        /* 0x9E */ u8 reserved[10];
-    };
-    static_assert(sizeof(InParameterVersion2b) == 0xA8,
-                  "SplitterDestinationData::InParameterVersion2b has the wrong size!");
-
     SplitterDestinationData(s32 id);
 
     /**
@@ -137,7 +78,7 @@ public:
     f32 GetMixVolumePrev(u32 index) const;
 
     /**
-     * Get the previous mix volumes for all mix buffers.
+     * Get the previous mix volumes for all mix buffers in this destination.
      *
      * @return Span of previous mix buffer volumes.
      */
@@ -174,20 +115,6 @@ public:
      */
     void SetNext(SplitterDestinationData* next);
 
-    /**
-     * Get biquad filter parameters for this destination (REV15+ or mapped from REV12).
-     *
-     * @return Span of biquad filter parameters.
-     */
-    std::span<BiquadFilterParameter2> GetBiquadFilters();
-
-    /**
-     * Get const biquad filter parameters for this destination (REV15+ or mapped from REV12).
-     *
-     * @return Const span of biquad filter parameters.
-     */
-    std::span<const BiquadFilterParameter2> GetBiquadFilters() const;
-
 private:
     /// Id of this destination
     const s32 id;
@@ -197,8 +124,6 @@ private:
     std::array<f32, MaxMixBuffers> mix_volumes{0.0f};
     /// Previous mix volumes
     std::array<f32, MaxMixBuffers> prev_mix_volumes{0.0f};
-    /// Biquad filter parameters (REV15+ or mapped from REV12)
-    std::array<BiquadFilterParameter2, MaxBiquadFilters> biquad_filters{};
     /// Next destination in the mix chain
     SplitterDestinationData* next{};
     /// Is this destination in use?

src/audio_core/renderer/voice/voice_info.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -138,17 +135,6 @@ public:
     static_assert(sizeof(BiquadFilterParameter) == 0xC,
                   "VoiceInfo::BiquadFilterParameter has the wrong size!");
 
-    struct BiquadFilterParameter2 {
-        /* 0x00 */ bool enabled;
-        /* 0x01 */ u8 reserved1;
-        /* 0x02 */ u8 reserved2;
-        /* 0x03 */ u8 reserved3;
-        /* 0x04 */ std::array<f32, 3> numerator;   // b0, b1, b2
-        /* 0x10 */ std::array<f32, 2> denominator; // a1, a2 (a0 = 1)
-    };
-    static_assert(sizeof(BiquadFilterParameter2) == 0x18,
-                  "VoiceInfo::BiquadFilterParameter2 has the wrong size!");
-
     struct InParameter {
         /* 0x000 */ u32 id;
         /* 0x004 */ u32 node_id;
@@ -182,43 +168,6 @@ public:
     };
     static_assert(sizeof(InParameter) == 0x170, "VoiceInfo::InParameter has the wrong size!");
 
-    struct InParameter2 {
-        /* 0x000 */ u32 id;
-        /* 0x004 */ u32 node_id;
-        /* 0x008 */ bool is_new;
-        /* 0x009 */ bool in_use;
-        /* 0x00A */ PlayState play_state;
-        /* 0x00B */ SampleFormat sample_format;
-        /* 0x00C */ u32 sample_rate;
-        /* 0x010 */ s32 priority;
-        /* 0x014 */ s32 sort_order;
-        /* 0x018 */ u32 channel_count;
-        /* 0x01C */ f32 pitch;
-        /* 0x020 */ f32 volume;
-        /* 0x024 */ std::array<BiquadFilterParameter2, MaxBiquadFilters> biquads;
-        /* 0x054 */ u32 wave_buffer_count;
-        /* 0x058 */ u32 wave_buffer_index;
-        /* 0x05C */ u32 reserved1;
-        /* 0x060 */ CpuAddr src_data_address;
-        /* 0x068 */ u64 src_data_size;
-        /* 0x070 */ u32 mix_id;
-        /* 0x074 */ u32 splitter_id;
-        /* 0x078 */ std::array<WaveBufferInternal, MaxWaveBuffers> wave_buffer_internal;
-        /* 0x158 */ std::array<s32, MaxChannels> channel_resource_ids;
-        /* 0x170 */ bool clear_voice_drop;
-        /* 0x171 */ u8 flush_buffer_count;
-        /* 0x172 */ u16 reserved2;
-        /* 0x174 */ Flags flags;
-        /* 0x175 */ u8 reserved3;
-        /* 0x176 */ SrcQuality src_quality;
-        /* 0x177 */ u8 reserved4;
-        /* 0x178 */ u32 external_context;
-        /* 0x17C */ u32 external_context_size;
-        /* 0x180 */ u32 reserved5;
-        /* 0x184 */ u32 reserved6;
-    };
-    static_assert(sizeof(InParameter2) == 0x188, "VoiceInfo::InParameter2 has the wrong size!");
-
     struct OutStatus {
         /* 0x00 */ u64 played_sample_count;
         /* 0x08 */ u32 wave_buffers_consumed;
@@ -400,10 +349,6 @@ public:
     f32 prev_volume{};
     /// Biquad filters for generating filter commands on this voice
     std::array<BiquadFilterParameter, MaxBiquadFilters> biquads{};
-    /// Float biquad filters for REV15+ (native float coefficients)
-    std::array<BiquadFilterParameter2, MaxBiquadFilters> biquads_float{};
-    /// Use float biquad coefficients (REV15+)
-    bool use_float_biquads{};
     /// Number of active wavebuffers
     u32 wave_buffer_count{};
     /// Current playing wavebuffer index

src/core/device_memory_manager.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -109,6 +112,9 @@ public:
 
     void ReadBlock(DAddr address, void* dest_pointer, size_t size);
     void ReadBlockUnsafe(DAddr address, void* dest_pointer, size_t size);
+#ifdef YUZU_DEBUG
+    bool ReadBlockFastChecked(DAddr address, void* dest_pointer, size_t size);
+#endif
     void WriteBlock(DAddr address, const void* src_pointer, size_t size);
     void WriteBlockUnsafe(DAddr address, const void* src_pointer, size_t size);
 

src/core/device_memory_manager.inc

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -467,6 +470,29 @@ void DeviceMemoryManager<Traits>::ReadBlockUnsafe(DAddr address, void* dest_poin
         });
 }
 
+#ifdef YUZU_DEBUG
+template <typename Traits>
+bool DeviceMemoryManager<Traits>::ReadBlockFastChecked(DAddr address, void* dest_pointer,
+                                                       size_t size) {
+    bool success = true;
+    WalkBlock(
+        address, size,
+        [&](size_t copy_amount, DAddr current_vaddr) {
+            LOG_CRITICAL(Render, "DeviceMemory OOB/unmapped: addr=0x{:x} size={}", current_vaddr,
+                         size);
+            std::memset(dest_pointer, 0, copy_amount);
+            success = false;
+        },
+        [&](size_t copy_amount, const u8* const src_ptr) {
+            std::memcpy(dest_pointer, src_ptr, copy_amount);
+        },
+        [&](const std::size_t copy_amount) {
+            dest_pointer = static_cast<u8*>(dest_pointer) + copy_amount;
+        });
+    return success;
+}
+#endif
+
 template <typename Traits>
 void DeviceMemoryManager<Traits>::WriteBlockUnsafe(DAddr address, const void* src_pointer,
                                                    size_t size) {

src/core/hle/service/acc/profile_manager.cpp

@@ -509,9 +509,6 @@ std::vector<std::string> ProfileManager::FindOrphanedProfiles()
         good_uuids.emplace_back(uuid_string);
     }
 
-    // used for acnh, etc
-    good_uuids.emplace_back("00000000000000000000000000000000");
-
     // TODO: fetch save_id programmatically
     const auto path = Common::FS::GetEdenPath(Common::FS::EdenPath::NANDDir)
                       / "user/save/0000000000000000";

src/core/hle/service/am/frontend/applet_web_browser.cpp

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -71,6 +68,42 @@ std::string ResolveURL(const std::string& url) {
     return url.substr(0, index) + "lp1" + url.substr(index + 1);
 }
 
+WebArgInputTLVMap ReadWebArgs(const std::vector<u8>& web_arg, WebArgHeader& web_arg_header) {
+    std::memcpy(&web_arg_header, web_arg.data(), sizeof(WebArgHeader));
+
+    if (web_arg.size() == sizeof(WebArgHeader)) {
+        return {};
+    }
+
+    WebArgInputTLVMap input_tlv_map;
+
+    u64 current_offset = sizeof(WebArgHeader);
+
+    for (std::size_t i = 0; i < web_arg_header.total_tlv_entries; ++i) {
+        if (web_arg.size() < current_offset + sizeof(WebArgInputTLV)) {
+            return input_tlv_map;
+        }
+
+        WebArgInputTLV input_tlv;
+        std::memcpy(&input_tlv, web_arg.data() + current_offset, sizeof(WebArgInputTLV));
+
+        current_offset += sizeof(WebArgInputTLV);
+
+        if (web_arg.size() < current_offset + input_tlv.arg_data_size) {
+            return input_tlv_map;
+        }
+
+        std::vector<u8> data(input_tlv.arg_data_size);
+        std::memcpy(data.data(), web_arg.data() + current_offset, input_tlv.arg_data_size);
+
+        current_offset += input_tlv.arg_data_size;
+
+        input_tlv_map.insert_or_assign(input_tlv.input_tlv_type, std::move(data));
+    }
+
+    return input_tlv_map;
+}
+
 FileSys::VirtualFile GetOfflineRomFS(Core::System& system, u64 title_id,
                                      FileSys::ContentRecordType nca_type) {
     if (nca_type == FileSys::ContentRecordType::Data) {
@@ -111,43 +144,6 @@ FileSys::VirtualFile GetOfflineRomFS(Core::System& system, u64 title_id,
     }
 }
 
-#ifdef YUZU_USE_QT_WEB_ENGINE
-WebArgInputTLVMap ReadWebArgs(const std::vector<u8>& web_arg, WebArgHeader& web_arg_header) {
-    std::memcpy(&web_arg_header, web_arg.data(), sizeof(WebArgHeader));
-
-    if (web_arg.size() == sizeof(WebArgHeader)) {
-        return {};
-    }
-
-    WebArgInputTLVMap input_tlv_map;
-
-    u64 current_offset = sizeof(WebArgHeader);
-
-    for (std::size_t i = 0; i < web_arg_header.total_tlv_entries; ++i) {
-        if (web_arg.size() < current_offset + sizeof(WebArgInputTLV)) {
-            return input_tlv_map;
-        }
-
-        WebArgInputTLV input_tlv;
-        std::memcpy(&input_tlv, web_arg.data() + current_offset, sizeof(WebArgInputTLV));
-
-        current_offset += sizeof(WebArgInputTLV);
-
-        if (web_arg.size() < current_offset + input_tlv.arg_data_size) {
-            return input_tlv_map;
-        }
-
-        std::vector<u8> data(input_tlv.arg_data_size);
-        std::memcpy(data.data(), web_arg.data() + current_offset, input_tlv.arg_data_size);
-
-        current_offset += input_tlv.arg_data_size;
-
-        input_tlv_map.insert_or_assign(input_tlv.input_tlv_type, std::move(data));
-    }
-
-    return input_tlv_map;
-}
-
 void ExtractSharedFonts(Core::System& system) {
     static constexpr std::array<const char*, 7> DECRYPTED_SHARED_FONTS{
         "FontStandard.ttf",
@@ -225,7 +221,6 @@ void ExtractSharedFonts(Core::System& system) {
         FileSys::VfsRawCopy(decrypted_font, out_file);
     }
 }
-#endif
 
 } // namespace
 
@@ -237,7 +232,6 @@ WebBrowser::WebBrowser(Core::System& system_, std::shared_ptr<Applet> applet_,
 WebBrowser::~WebBrowser() = default;
 
 void WebBrowser::Initialize() {
-#ifdef YUZU_USE_QT_WEB_ENGINE
     FrontendApplet::Initialize();
 
     LOG_INFO(Service_AM, "Initializing Web Browser Applet.");
@@ -290,7 +284,6 @@ void WebBrowser::Initialize() {
         ASSERT_MSG(false, "Invalid ShimKind={}", web_arg_header.shim_kind);
         break;
     }
-#endif
 }
 
 Result WebBrowser::GetStatus() const {
@@ -302,7 +295,6 @@ void WebBrowser::ExecuteInteractive() {
 }
 
 void WebBrowser::Execute() {
-#ifdef YUZU_USE_QT_WEB_ENGINE
     switch (web_arg_header.shim_kind) {
     case ShimKind::Shop:
         ExecuteShop();
@@ -330,10 +322,6 @@ void WebBrowser::Execute() {
         WebBrowserExit(WebExitReason::EndButtonPressed);
         break;
     }
-#else
-    LOG_INFO(Service_AM, "Web Browser Applet disabled, skipping.");
-    WebBrowserExit(WebExitReason::EndButtonPressed);
-#endif
 }
 
 void WebBrowser::ExtractOfflineRomFS() {

src/core/hle/service/am/service/library_applet_creator.cpp

@@ -1,6 +1,3 @@
-// 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
 
@@ -178,7 +175,6 @@ ILibraryAppletCreator::ILibraryAppletCreator(Core::System& system_, std::shared_
         {0, D<&ILibraryAppletCreator::CreateLibraryApplet>, "CreateLibraryApplet"},
         {1, nullptr, "TerminateAllLibraryApplets"},
         {2, nullptr, "AreAnyLibraryAppletsLeft"},
-        {3, D<&ILibraryAppletCreator::CreateLibraryAppletEx>, "CreateLibraryAppletEx"},
         {10, D<&ILibraryAppletCreator::CreateStorage>, "CreateStorage"},
         {11, D<&ILibraryAppletCreator::CreateTransferMemoryStorage>, "CreateTransferMemoryStorage"},
         {12, D<&ILibraryAppletCreator::CreateHandleStorage>, "CreateHandleStorage"},
@@ -214,32 +210,6 @@ Result ILibraryAppletCreator::CreateLibraryApplet(
     R_SUCCEED();
 }
 
-Result ILibraryAppletCreator::CreateLibraryAppletEx(
-    Out<SharedPointer<ILibraryAppletAccessor>> out_library_applet_accessor, AppletId applet_id,
-    LibraryAppletMode library_applet_mode, u64 thread_id) {
-    LOG_DEBUG(Service_AM, "called with applet_id={} applet_mode={} thread_id={}", applet_id,
-              library_applet_mode, thread_id);
-
-    std::shared_ptr<ILibraryAppletAccessor> library_applet;
-    if (ShouldCreateGuestApplet(applet_id)) {
-        library_applet =
-            CreateGuestApplet(system, m_window_system, m_applet, applet_id, library_applet_mode);
-    }
-    if (!library_applet) {
-        library_applet =
-            CreateFrontendApplet(system, m_window_system, m_applet, applet_id, library_applet_mode);
-    }
-    if (!library_applet) {
-        LOG_ERROR(Service_AM, "Applet doesn't exist! applet_id={}", applet_id);
-        R_THROW(ResultUnknown);
-    }
-
-    // Applet is created, can now be launched.
-    m_applet->library_applet_launchable_event.Signal();
-    *out_library_applet_accessor = library_applet;
-    R_SUCCEED();
-}
-
 Result ILibraryAppletCreator::CreateStorage(Out<SharedPointer<IStorage>> out_storage, s64 size) {
     LOG_DEBUG(Service_AM, "called, size={}", size);
 

src/core/hle/service/am/service/library_applet_creator.h

@@ -1,6 +1,3 @@
-// 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
 
@@ -27,9 +24,6 @@ private:
     Result CreateLibraryApplet(
         Out<SharedPointer<ILibraryAppletAccessor>> out_library_applet_accessor, AppletId applet_id,
         LibraryAppletMode library_applet_mode);
-    Result CreateLibraryAppletEx(
-        Out<SharedPointer<ILibraryAppletAccessor>> out_library_applet_accessor, AppletId applet_id,
-        LibraryAppletMode library_applet_mode, u64 thread_id);
     Result CreateStorage(Out<SharedPointer<IStorage>> out_storage, s64 size);
     Result CreateTransferMemoryStorage(
         Out<SharedPointer<IStorage>> out_storage, bool is_writable, s64 size,

src/core/hle/service/ns/application_manager_interface.cpp

@@ -128,7 +128,6 @@ IApplicationManagerInterface::IApplicationManagerInterface(Core::System& system_
         {406, nullptr, "GetApplicationControlProperty"},
         {407, nullptr, "ListApplicationTitle"},
         {408, nullptr, "ListApplicationIcon"},
-        {419, D<&IApplicationManagerInterface::RequestDownloadApplicationControlDataInBackground>, "RequestDownloadApplicationControlDataInBackground"},
         {502, nullptr, "RequestCheckGameCardRegistration"},
         {503, nullptr, "RequestGameCardRegistrationGoldPoint"},
         {504, nullptr, "RequestRegisterGameCard"},
@@ -211,7 +210,6 @@ IApplicationManagerInterface::IApplicationManagerInterface(Core::System& system_
         {1703, nullptr, "GetApplicationViewDownloadErrorContext"},
         {1704, D<&IApplicationManagerInterface::GetApplicationViewWithPromotionInfo>, "GetApplicationViewWithPromotionInfo"},
         {1705, nullptr, "IsPatchAutoDeletableApplication"},
-        {1706, D<&IApplicationManagerInterface::Unknown1706>, "Unknown1706"},
         {1800, nullptr, "IsNotificationSetupCompleted"},
         {1801, nullptr, "GetLastNotificationInfoCount"},
         {1802, nullptr, "ListLastNotificationInfo"},
@@ -311,7 +309,6 @@ IApplicationManagerInterface::IApplicationManagerInterface(Core::System& system_
         {4022, D<&IApplicationManagerInterface::Unknown4022>, "Unknown4022"},
         {4023, D<&IApplicationManagerInterface::Unknown4023>, "Unknown4023"},
         {4088, D<&IApplicationManagerInterface::Unknown4022>, "Unknown4088"},
-        {4053, D<&IApplicationManagerInterface::Unknown4053>, "Unknown4053"},
         {9999, nullptr, "GetApplicationCertificate"},
     };
     // clang-format on
@@ -529,37 +526,6 @@ Result IApplicationManagerInterface::GetApplicationTerminateResult(Out<Result> o
     R_SUCCEED();
 }
 
-Result IApplicationManagerInterface::RequestDownloadApplicationControlDataInBackground(
-    u64 unk, u64 application_id) {
-    LOG_WARNING(Service_NS, "(STUBBED), app={:016X} unk={}", application_id, unk);
-    R_SUCCEED();
-}
-
-Result IApplicationManagerInterface::Unknown1706(
-    OutBuffer<BufferAttr_HipcAutoSelect> out_buffer_58,
-    InBuffer<BufferAttr_HipcMapAlias> in_buffer_8) {
-    LOG_WARNING(Service_NS, "(STUBBED) Unknown1706 called: out_size={} in_size={}",
-                out_buffer_58.size(), in_buffer_8.size());
-
-    if (out_buffer_58.size() < 0x58 || in_buffer_8.size() < 0x8) {
-        R_THROW(ResultUnknown);
-    }
-
-    u64 application_id = 0;
-    std::memcpy(&application_id, in_buffer_8.data(), sizeof(u64));
-
-    ApplicationView view{};
-    view.application_id = application_id;
-    view.unk = 0x70000;
-    view.flags = 0x401f17;
-
-    std::memset(out_buffer_58.data(), 0, out_buffer_58.size());
-    std::memcpy(out_buffer_58.data(), &view, sizeof(ApplicationView));
-
-
-    R_SUCCEED();
-}
-
 Result IApplicationManagerInterface::Unknown4022(
     OutCopyHandle<Kernel::KReadableEvent> out_event) {
     LOG_WARNING(Service_NS, "(STUBBED) called");
@@ -573,9 +539,4 @@ Result IApplicationManagerInterface::Unknown4023(Out<u64> out_result) {
     R_SUCCEED();
 }
 
-Result IApplicationManagerInterface::Unknown4053() {
-    LOG_WARNING(Service_NS, "(STUBBED) called.");
-    R_SUCCEED();
-}
-
 } // namespace Service::NS

src/core/hle/service/ns/application_manager_interface.h

@@ -55,12 +55,6 @@ public:
     Result GetApplicationTerminateResult(Out<Result> out_result, u64 application_id);
     Result Unknown4022(OutCopyHandle<Kernel::KReadableEvent> out_event);
     Result Unknown4023(Out<u64> out_result);
-    Result Unknown4053();
-
-    Result RequestDownloadApplicationControlDataInBackground(u64 unk,
-                                                             u64 application_id);
-    Result Unknown1706(OutBuffer<BufferAttr_HipcAutoSelect> out_buffer_58,
-                       InBuffer<BufferAttr_HipcMapAlias> in_buffer_8);
 
 private:
     KernelHelpers::ServiceContext service_context;

src/core/hle/service/ns/ns_types.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -86,9 +83,8 @@ static_assert(sizeof(PromotionInfo) == 0x20, "PromotionInfo has incorrect size."
 struct ApplicationViewWithPromotionInfo {
     ApplicationView view;    ///< \ref NsApplicationView
     PromotionInfo promotion; ///< \ref NsPromotionInfo
-    std::array<u8, 0x8> padding{};  ///< Extra padding for newer HOS versions
 };
-static_assert(sizeof(ApplicationViewWithPromotionInfo) == 0x78,
+static_assert(sizeof(ApplicationViewWithPromotionInfo) == 0x70,
               "ApplicationViewWithPromotionInfo has incorrect size.");
 
 struct ApplicationOccupiedSizeEntity {
@@ -117,10 +113,4 @@ struct Uid {
 };
 static_assert(sizeof(Uid) == 0x10, "Uid has incorrect size.");
 
-struct ApplicationDisplayData {
-    std::array<char, 0x200> application_name;
-    std::array<char, 0x100> developer_name;
-};
-static_assert(sizeof(ApplicationDisplayData) == 0x300, "ApplicationDisplayData has incorrect size.");
-
 } // namespace Service::NS

src/core/hle/service/ns/read_only_application_control_data_interface.cpp

@@ -1,6 +1,3 @@
-// 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
 
@@ -10,7 +7,6 @@
 #include "core/file_sys/vfs/vfs.h"
 #include "core/hle/service/cmif_serialization.h"
 #include "core/hle/service/ns/language.h"
-#include "core/hle/service/ns/ns_types.h"
 #include "core/hle/service/ns/ns_results.h"
 #include "core/hle/service/ns/read_only_application_control_data_interface.h"
 #include "core/hle/service/set/settings_server.h"
@@ -27,7 +23,6 @@ IReadOnlyApplicationControlDataInterface::IReadOnlyApplicationControlDataInterfa
         {2, D<&IReadOnlyApplicationControlDataInterface::ConvertApplicationLanguageToLanguageCode>, "ConvertApplicationLanguageToLanguageCode"},
         {3, nullptr, "ConvertLanguageCodeToApplicationLanguage"},
         {4, nullptr, "SelectApplicationDesiredLanguage"},
-        {5, D<&IReadOnlyApplicationControlDataInterface::GetApplicationDisplayData>, "GetApplicationDisplayData"},
     };
     // clang-format on
 
@@ -124,33 +119,4 @@ Result IReadOnlyApplicationControlDataInterface::ConvertApplicationLanguageToLan
     R_SUCCEED();
 }
 
-Result IReadOnlyApplicationControlDataInterface::GetApplicationDisplayData(
-    OutBuffer<BufferAttr_HipcMapAlias> out_buffer, Out<u64> out_size, u64 language_code,
-    u64 application_id) {
-    LOG_INFO(Service_NS, "called with application_id={:016X}, language_code={:016X}",
-             application_id, language_code);
-
-    constexpr u64 payload_size = sizeof(ApplicationDisplayData);
-
-    if (out_buffer.size() < payload_size) {
-        LOG_ERROR(Service_NS, "output buffer is too small! (actual={}, expected_min={})",
-                  out_buffer.size(), payload_size);
-        R_THROW(ResultUnknown);
-    }
-
-    const FileSys::PatchManager pm{application_id, system.GetFileSystemController(),
-                                   system.GetContentProvider()};
-    const auto control = pm.GetControlMetadata();
-
-    ApplicationDisplayData display_data{};
-
-    std::memset(display_data.application_name.data(), 0, display_data.application_name.size());
-    std::memset(display_data.developer_name.data(), 0, display_data.developer_name.size());
-
-    std::memcpy(out_buffer.data(), &display_data, payload_size);
-    *out_size = payload_size;
-
-    R_SUCCEED();
-}
-
 } // namespace Service::NS

src/core/hle/service/ns/read_only_application_control_data_interface.h

@@ -1,15 +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/cmif_types.h"
-#include "core/hle/service/service.h"
 #include "core/hle/service/ns/language.h"
 #include "core/hle/service/ns/ns_types.h"
+#include "core/hle/service/service.h"
 
 namespace Service::NS {
 
@@ -19,6 +16,7 @@ public:
     explicit IReadOnlyApplicationControlDataInterface(Core::System& system_);
     ~IReadOnlyApplicationControlDataInterface() override;
 
+public:
     Result GetApplicationControlData(OutBuffer<BufferAttr_HipcMapAlias> out_buffer,
                                      Out<u32> out_actual_size,
                                      ApplicationControlSource application_control_source,
@@ -27,10 +25,6 @@ public:
                                          u32 supported_languages);
     Result ConvertApplicationLanguageToLanguageCode(Out<u64> out_language_code,
                                                     ApplicationLanguage application_language);
-
-    Result GetApplicationDisplayData(OutBuffer<BufferAttr_HipcMapAlias> out_buffer,
-                                     Out<u64> out_size, u64 language_code,
-                                     u64 application_id);
 };
 
 } // namespace Service::NS

src/core/hle/service/ns/read_only_application_record_interface.cpp

@@ -1,13 +1,8 @@
-// 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
 
 #include "core/hle/service/cmif_serialization.h"
 #include "core/hle/service/ns/read_only_application_record_interface.h"
-#include "core/hle/service/ns/ns_types.h"
-#include "core/hle/service/ns/application_manager_interface.h"
 
 namespace Service::NS {
 
@@ -18,8 +13,6 @@ IReadOnlyApplicationRecordInterface::IReadOnlyApplicationRecordInterface(Core::S
         {1, nullptr, "NotifyApplicationFailure"},
         {2, D<&IReadOnlyApplicationRecordInterface::IsDataCorruptedResult>,
          "IsDataCorruptedResult"},
-        {3, D<&IReadOnlyApplicationRecordInterface::ListApplicationRecord>,
-         "ListApplicationRecord"},
     };
     // clang-format on
 
@@ -42,14 +35,4 @@ Result IReadOnlyApplicationRecordInterface::IsDataCorruptedResult(
     R_SUCCEED();
 }
 
-Result IReadOnlyApplicationRecordInterface::ListApplicationRecord(
-    OutArray<ApplicationRecord, BufferAttr_HipcMapAlias> out_records, Out<s32> out_count,
-    s32 entry_offset) {
-    LOG_DEBUG(Service_NS, "delegating to IApplicationManagerInterface::ListApplicationRecord, offset={} limit={}",
-              entry_offset, out_records.size());
-
-    R_RETURN(IApplicationManagerInterface(system).ListApplicationRecord(out_records, out_count,
-                                                                        entry_offset));
-}
-
 } // namespace Service::NS

src/core/hle/service/ns/read_only_application_record_interface.h

@@ -1,6 +1,3 @@
-// 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
 
@@ -8,7 +5,6 @@
 
 #include "core/hle/service/cmif_types.h"
 #include "core/hle/service/service.h"
-#include "core/hle/service/ns/ns_types.h"
 
 namespace Service::NS {
 
@@ -21,9 +17,6 @@ public:
 private:
     Result HasApplicationRecord(Out<bool> out_has_application_record, u64 program_id);
     Result IsDataCorruptedResult(Out<bool> out_is_data_corrupted_result, Result result);
-    Result ListApplicationRecord(
-        OutArray<ApplicationRecord, BufferAttr_HipcMapAlias> out_records, Out<s32> out_count,
-        s32 entry_offset);
 };
 
 } // namespace Service::NS

src/core/hle/service/pctl/parental_control_service.cpp

@@ -38,7 +38,6 @@ IParentalControlService::IParentalControlService(Core::System& system_, Capabili
         {1016, nullptr, "ConfirmShowNewsPermission"},
         {1017, D<&IParentalControlService::EndFreeCommunication>, "EndFreeCommunication"},
         {1018, D<&IParentalControlService::IsFreeCommunicationAvailable>, "IsFreeCommunicationAvailable"},
-        {1019, D<&IParentalControlService::ConfirmLaunchApplicationPermission>, "ConfirmLaunchApplicationPermission"},
         {1031, D<&IParentalControlService::IsRestrictionEnabled>, "IsRestrictionEnabled"},
         {1032, D<&IParentalControlService::GetSafetyLevel>, "GetSafetyLevel"},
         {1033, nullptr, "SetSafetyLevel"},

src/hid_core/resources/npad/npad_types.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
@@ -162,17 +159,6 @@ struct NpadGcTriggerState {
 };
 static_assert(sizeof(NpadGcTriggerState) == 0x10, "NpadGcTriggerState is an invalid size");
 
-// This is nn::hid::NpadCondition (global controller condition structure)
-struct NpadCondition {
-    u32 _00{};
-    u32 is_initialized{1};
-    u32 hold_type{static_cast<u32>(NpadJoyHoldType::Horizontal)};
-    u32 is_valid{1};
-};
-static_assert(sizeof(NpadCondition) == 0x10, "NpadCondition is an invalid size");
-
-
-
 // This is nn::hid::NpadSystemProperties
 struct NPadSystemProperties {
     union {

src/hid_core/resources/ring_lifo.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -47,7 +44,8 @@ struct Lifo {
             buffer_count++;
         }
         buffer_tail = GetNextEntryIndex();
-        entries[buffer_tail].sampling_number = new_state.sampling_number << 1;
+        const auto& previous_entry = ReadPreviousEntry();
+        entries[buffer_tail].sampling_number = previous_entry.sampling_number + 1;
         entries[buffer_tail].state = new_state;
     }
 };

src/hid_core/resources/shared_memory_format.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
@@ -204,9 +201,7 @@ static_assert(sizeof(ConsoleSixAxisSensorSharedMemoryFormat) == 0x20,
 
 // This is nn::hid::detail::SharedMemoryFormat
 struct SharedMemoryFormat {
-    void Initialize() {
+    void Initialize() {}
-        npad_condition = NpadCondition{};
-    }
 
     DebugPadSharedMemoryFormat debug_pad;
     TouchScreenSharedMemoryFormat touch_screen;
@@ -223,9 +218,7 @@ struct SharedMemoryFormat {
     ConsoleSixAxisSensorSharedMemoryFormat console;
     INSERT_PADDING_BYTES(0x19E0);
     MouseSharedMemoryFormat debug_mouse;
-    INSERT_PADDING_BYTES(0x200);
+    INSERT_PADDING_BYTES(0x2000);
-    NpadCondition npad_condition;
-    INSERT_PADDING_BYTES(0x1DF0);
 };
 static_assert(offsetof(SharedMemoryFormat, debug_pad) == 0x0, "debug_pad has wrong offset");
 static_assert(offsetof(SharedMemoryFormat, touch_screen) == 0x400, "touch_screen has wrong offset");
@@ -243,8 +236,6 @@ static_assert(offsetof(SharedMemoryFormat, npad) == 0x9A00, "npad has wrong offs
 static_assert(offsetof(SharedMemoryFormat, gesture) == 0x3BA00, "gesture has wrong offset");
 static_assert(offsetof(SharedMemoryFormat, console) == 0x3C200, "console has wrong offset");
 static_assert(offsetof(SharedMemoryFormat, debug_mouse) == 0x3DC00, "debug_mouse has wrong offset");
-static_assert(offsetof(SharedMemoryFormat, npad_condition) == 0x3E200,
-              "npad_condition has wrong offset");
 static_assert(sizeof(SharedMemoryFormat) == 0x40000, "SharedMemoryFormat is an invalid size");
 
 } // namespace Service::HID

src/qt_common/CMakeLists.txt

@@ -45,10 +45,6 @@ if (NOT APPLE AND ENABLE_OPENGL)
     target_compile_definitions(qt_common PUBLIC HAS_OPENGL)
 endif()
 
-if (UNIX AND NOT APPLE)
+if (NOT WIN32)
-    if (TARGET Qt6::GuiPrivate)
-        target_link_libraries(qt_common PRIVATE Qt6::GuiPrivate)
-    else()
     target_include_directories(qt_common PRIVATE ${Qt6Gui_PRIVATE_INCLUDE_DIRS})
 endif()
-endif()

src/shader_recompiler/backend/spirv/spirv_emit_context.cpp

@@ -98,12 +98,46 @@ Id ImageType(EmitContext& ctx, const ImageDescriptor& desc, Id sampled_type) {
     throw InvalidArgument("Invalid texture type {}", desc.type);
 }
 
+
+bool IsFragmentStage(const EmitContext& ctx) {
+    return ctx.stage == Stage::Fragment;
+}
+
+bool IsUserVaryingInput(bool is_builtin, bool has_location) {
+    return !is_builtin && has_location;
+}
+
+bool IsIntegerOrBoolType(EmitContext& ctx, Id type) {
+    return ctx.IsIntegerOrBoolType(type);
+}
+
+bool RequiresFlatDecoration(EmitContext& ctx, Id type, spv::StorageClass storage_class,
+                            bool is_builtin, bool has_location) {
+    if (!IsFragmentStage(ctx)) {
+        return false;
+    }
+    if (storage_class != spv::StorageClass::Input) {
+        return false;
+    }
+    if (!IsUserVaryingInput(is_builtin, has_location)) {
+        return false;
+    }
+    return IsIntegerOrBoolType(ctx, type);
+}
+
 Id DefineVariable(EmitContext& ctx, Id type, std::optional<spv::BuiltIn> builtin,
-                  spv::StorageClass storage_class, std::optional<Id> initializer = std::nullopt) {
+                  spv::StorageClass storage_class, std::optional<Id> initializer = std::nullopt,
+                  bool has_location = false) {
     const Id pointer_type{ctx.TypePointer(storage_class, type)};
     const Id id{ctx.AddGlobalVariable(pointer_type, storage_class, initializer)};
-    if (builtin) {
+    const bool is_builtin{builtin.has_value()};
-        ctx.Decorate(id, spv::Decoration::BuiltIn, *builtin);
+    if (is_builtin) {
+        ctx.DecorateUnique(id, spv::Decoration::BuiltIn, static_cast<u32>(*builtin));
+    }
+    // Flat only for integer/bool user varyings in fragment input; never for BuiltIns; dedupe avoids
+    // multiple identical decorations.
+    if (RequiresFlatDecoration(ctx, type, storage_class, is_builtin, has_location)) {
+        ctx.DecorateUnique(id, spv::Decoration::Flat);
     }
     ctx.interfaces.push_back(id);
     return id;
@@ -126,7 +160,8 @@ u32 NumVertices(InputTopology input_topology) {
 }
 
 Id DefineInput(EmitContext& ctx, Id type, bool per_invocation,
-               std::optional<spv::BuiltIn> builtin = std::nullopt) {
+               std::optional<spv::BuiltIn> builtin = std::nullopt,
+               bool has_location = false) {
     switch (ctx.stage) {
     case Stage::TessellationControl:
     case Stage::TessellationEval:
@@ -143,7 +178,7 @@ Id DefineInput(EmitContext& ctx, Id type, bool per_invocation,
     default:
         break;
     }
-    return DefineVariable(ctx, type, builtin, spv::StorageClass::Input);
+    return DefineVariable(ctx, type, builtin, spv::StorageClass::Input, std::nullopt, has_location);
 }
 
 Id DefineOutput(EmitContext& ctx, Id type, std::optional<u32> invocations,
@@ -170,7 +205,7 @@ void DefineGenericOutput(EmitContext& ctx, size_t index, std::optional<u32> invo
         const u32 num_components{xfb_varying ? xfb_varying->components : remainder};
 
         const Id id{DefineOutput(ctx, ctx.F32[num_components], invocations)};
-        ctx.Decorate(id, spv::Decoration::Location, static_cast<u32>(index));
+        ctx.DecorateUnique(id, spv::Decoration::Location, static_cast<u32>(index));
         if (element > 0) {
             ctx.Decorate(id, spv::Decoration::Component, element);
         }
@@ -445,6 +480,94 @@ Id DescType(EmitContext& ctx, Id sampled_type, Id pointer_type, u32 count) {
 }
 } // Anonymous namespace
 
+Id EmitContext::TypeArray(Id element_type, Id length) {
+    const Id array_type{Sirit::Module::TypeArray(element_type, length)};
+    array_element_types[array_type] = element_type;
+    type_integer_or_bool_cache[array_type] = IsIntegerOrBoolType(element_type);
+    return array_type;
+}
+
+Id EmitContext::TypeStruct(Id member) {
+    const std::array<Id, 1> members{member};
+    return TypeStruct(std::span<const Id>(members));
+}
+
+Id EmitContext::TypeStruct(std::span<const Id> members) {
+    const Id struct_type{Sirit::Module::TypeStruct(members)};
+    struct_member_types[struct_type] = std::vector<Id>(members.begin(), members.end());
+    const bool has_integer_member{
+        std::any_of(members.begin(), members.end(),
+                    [this](Id member_type) { return IsIntegerOrBoolType(member_type); })};
+    type_integer_or_bool_cache[struct_type] = has_integer_member;
+    return struct_type;
+}
+
+Id EmitContext::TypeVector(Id element_type, u32 components) {
+    const Id vector_type{
+        Sirit::Module::TypeVector(element_type, static_cast<int>(components))};
+    type_integer_or_bool_cache[vector_type] = IsIntegerOrBoolType(element_type);
+    return vector_type;
+}
+
+bool EmitContext::HasDecoration(Id id, spv::Decoration decoration,
+                                std::optional<u32> literal) const {
+    const auto list_it{decorations.find(id)};
+    if (list_it == decorations.end()) {
+        return false;
+    }
+    const auto& records{list_it->second};
+    return std::any_of(records.begin(), records.end(), [&](const DecorationRecord& record) {
+        if (record.decoration != decoration) {
+            return false;
+        }
+        if (!literal.has_value()) {
+            return true;
+        }
+        return record.literal.has_value() && record.literal.value() == literal.value();
+    });
+}
+
+void EmitContext::DecorateUnique(Id id, spv::Decoration decoration,
+                                 std::optional<u32> literal) {
+    if (decoration == spv::Decoration::Flat || decoration == spv::Decoration::NoPerspective) {
+        // SPIR-V only allows non-default interpolation decorations on user-defined inputs.
+        ASSERT_MSG(!HasDecoration(id, spv::Decoration::BuiltIn),
+                   "Interpolation decoration applied to a BuiltIn");
+    }
+    if (HasDecoration(id, decoration, literal)) {
+        return;
+    }
+    decorations[id].emplace_back(DecorationRecord{decoration, literal});
+    if (literal.has_value()) {
+        Sirit::Module::Decorate(id, decoration, literal.value());
+    } else {
+        Sirit::Module::Decorate(id, decoration);
+    }
+}
+
+bool EmitContext::IsIntegerOrBoolType(Id type) {
+    if (const auto it = type_integer_or_bool_cache.find(type);
+        it != type_integer_or_bool_cache.end()) {
+        return it->second;
+    }
+    if (const auto array_it = array_element_types.find(type); array_it != array_element_types.end()) {
+        const bool result{IsIntegerOrBoolType(array_it->second)};
+        type_integer_or_bool_cache[type] = result;
+        return result;
+    }
+    if (const auto struct_it = struct_member_types.find(type);
+        struct_it != struct_member_types.end()) {
+        const bool result{std::any_of(struct_it->second.begin(), struct_it->second.end(),
+                                      [this](Id member_type) {
+                                          return IsIntegerOrBoolType(member_type);
+                                      })};
+        type_integer_or_bool_cache[type] = result;
+        return result;
+    }
+    type_integer_or_bool_cache[type] = false;
+    return false;
+}
+
 void VectorTypes::Define(Sirit::Module& sirit_ctx, Id base_type, std::string_view name) {
     defs[0] = sirit_ctx.Name(base_type, name);
 
@@ -532,11 +655,24 @@ Id EmitContext::BitOffset16(const IR::Value& offset) {
 void EmitContext::DefineCommonTypes(const Info& info) {
     void_id = TypeVoid();
 
+    const auto mark_vector_type = [this](VectorTypes& vectors, bool is_integer_or_bool) {
+        for (size_t components = 1; components <= 4; ++components) {
+            const Id type{vectors[components]};
+            if (type.value != 0) {
+                type_integer_or_bool_cache[type] = is_integer_or_bool;
+            }
+        }
+    };
+
     U1 = Name(TypeBool(), "u1");
+    type_integer_or_bool_cache[U1] = true;
 
     F32.Define(*this, TypeFloat(32), "f32");
+    mark_vector_type(F32, false);
     U32.Define(*this, TypeInt(32, false), "u32");
+    mark_vector_type(U32, true);
     S32.Define(*this, TypeInt(32, true), "s32");
+    mark_vector_type(S32, true);
 
     private_u32 = Name(TypePointer(spv::StorageClass::Private, U32[1]), "private_u32");
 
@@ -551,23 +687,30 @@ void EmitContext::DefineCommonTypes(const Info& info) {
         AddCapability(spv::Capability::Int8);
         U8 = Name(TypeInt(8, false), "u8");
         S8 = Name(TypeInt(8, true), "s8");
+        type_integer_or_bool_cache[U8] = true;
+        type_integer_or_bool_cache[S8] = true;
     }
     if (info.uses_int16 && profile.support_int16) {
         AddCapability(spv::Capability::Int16);
         U16 = Name(TypeInt(16, false), "u16");
         S16 = Name(TypeInt(16, true), "s16");
+        type_integer_or_bool_cache[U16] = true;
+        type_integer_or_bool_cache[S16] = true;
     }
     if (info.uses_int64 && profile.support_int64) {
         AddCapability(spv::Capability::Int64);
         U64 = Name(TypeInt(64, false), "u64");
+        type_integer_or_bool_cache[U64] = true;
     }
     if (info.uses_fp16) {
         AddCapability(spv::Capability::Float16);
         F16.Define(*this, TypeFloat(16), "f16");
+        mark_vector_type(F16, false);
     }
     if (info.uses_fp64) {
         AddCapability(spv::Capability::Float64);
         F64.Define(*this, TypeFloat(64), "f64");
+        mark_vector_type(F64, false);
     }
 }
 
@@ -1072,7 +1215,7 @@ void EmitContext::DefineRescalingInputUniformConstant() {
     const Id pointer_type{TypePointer(spv::StorageClass::UniformConstant, F32[4])};
     rescaling_uniform_constant =
         AddGlobalVariable(pointer_type, spv::StorageClass::UniformConstant);
-    Decorate(rescaling_uniform_constant, spv::Decoration::Location, 0u);
+    DecorateUnique(rescaling_uniform_constant, spv::Decoration::Location, 0u);
 
     if (profile.supported_spirv >= 0x00010400) {
         interfaces.push_back(rescaling_uniform_constant);
@@ -1449,7 +1592,6 @@ void EmitContext::DefineInputs(const IR::Program& program) {
         AddCapability(spv::Capability::GroupNonUniform);
         subgroup_local_invocation_id =
             DefineInput(*this, U32[1], false, spv::BuiltIn::SubgroupLocalInvocationId);
-        Decorate(subgroup_local_invocation_id, spv::Decoration::Flat);
     }
     if (info.uses_fswzadd) {
         const Id f32_one{Const(1.0f)};
@@ -1465,7 +1607,6 @@ void EmitContext::DefineInputs(const IR::Program& program) {
     if (loads[IR::Attribute::Layer]) {
         AddCapability(spv::Capability::Geometry);
         layer = DefineInput(*this, U32[1], false, spv::BuiltIn::Layer);
-        Decorate(layer, spv::Decoration::Flat);
     }
     if (loads.AnyComponent(IR::Attribute::PositionX)) {
         const bool is_fragment{stage == Stage::Fragment};
@@ -1541,8 +1682,8 @@ void EmitContext::DefineInputs(const IR::Program& program) {
             continue;
         }
         const Id type{GetAttributeType(*this, input_type)};
-        const Id id{DefineInput(*this, type, true)};
+        const Id id{DefineInput(*this, type, true, std::nullopt, true)};
-        Decorate(id, spv::Decoration::Location, static_cast<u32>(index));
+        DecorateUnique(id, spv::Decoration::Location, static_cast<u32>(index));
         Name(id, fmt::format("in_attr{}", index));
         input_generics[index] = GetAttributeInfo(*this, input_type, id);
 
@@ -1552,16 +1693,20 @@ void EmitContext::DefineInputs(const IR::Program& program) {
         if (stage != Stage::Fragment) {
             continue;
         }
+        if (RequiresFlatDecoration(*this, type, spv::StorageClass::Input, false, true)) {
+            ASSERT_MSG(HasDecoration(id, spv::Decoration::Flat),
+                       "Flat decoration missing on integer/bool user varying input");
+            continue;
+        }
         switch (info.interpolation[index]) {
         case Interpolation::Smooth:
-            // Default
+            // Default interpolation per SPIR-V spec; no decoration emitted.
-            // Decorate(id, spv::Decoration::Smooth);
             break;
         case Interpolation::NoPerspective:
-            Decorate(id, spv::Decoration::NoPerspective);
+            DecorateUnique(id, spv::Decoration::NoPerspective);
             break;
         case Interpolation::Flat:
-            Decorate(id, spv::Decoration::Flat);
+            DecorateUnique(id, spv::Decoration::Flat);
             break;
         }
     }
@@ -1570,9 +1715,9 @@ void EmitContext::DefineInputs(const IR::Program& program) {
             if (!info.uses_patches[index]) {
                 continue;
             }
-            const Id id{DefineInput(*this, F32[4], false)};
+            const Id id{DefineInput(*this, F32[4], false, std::nullopt, true)};
             Decorate(id, spv::Decoration::Patch);
-            Decorate(id, spv::Decoration::Location, static_cast<u32>(index));
+            DecorateUnique(id, spv::Decoration::Location, static_cast<u32>(index));
             patches[index] = id;
         }
     }
@@ -1649,7 +1794,7 @@ void EmitContext::DefineOutputs(const IR::Program& program) {
             }
             const Id id{DefineOutput(*this, F32[4], std::nullopt)};
             Decorate(id, spv::Decoration::Patch);
-            Decorate(id, spv::Decoration::Location, static_cast<u32>(index));
+            DecorateUnique(id, spv::Decoration::Location, static_cast<u32>(index));
             patches[index] = id;
         }
         break;
@@ -1659,17 +1804,19 @@ void EmitContext::DefineOutputs(const IR::Program& program) {
                 continue;
             }
             frag_color[index] = DefineOutput(*this, F32[4], std::nullopt);
-            Decorate(frag_color[index], spv::Decoration::Location, index);
+            DecorateUnique(frag_color[index], spv::Decoration::Location, index);
             Name(frag_color[index], fmt::format("frag_color{}", index));
         }
         if (info.stores_frag_depth) {
             frag_depth = DefineOutput(*this, F32[1], std::nullopt);
-            Decorate(frag_depth, spv::Decoration::BuiltIn, spv::BuiltIn::FragDepth);
+            DecorateUnique(frag_depth, spv::Decoration::BuiltIn,
+                           static_cast<u32>(spv::BuiltIn::FragDepth));
         }
         if (info.stores_sample_mask) {
             const Id array_type{TypeArray(U32[1], Const(1U))};
             sample_mask = DefineOutput(*this, array_type, std::nullopt);
-            Decorate(sample_mask, spv::Decoration::BuiltIn, spv::BuiltIn::SampleMask);
+            DecorateUnique(sample_mask, spv::Decoration::BuiltIn,
+                           static_cast<u32>(spv::BuiltIn::SampleMask));
         }
         break;
     default:
@@ -1678,3 +1825,4 @@ void EmitContext::DefineOutputs(const IR::Program& program) {
 }
 
 } // namespace Shader::Backend::SPIRV
+

src/shader_recompiler/backend/spirv/spirv_emit_context.h

@@ -4,6 +4,11 @@
 #pragma once
 
 #include <array>
+#include <bitset>
+#include <optional>
+#include <span>
+#include <unordered_map>
+#include <vector>
 
 #include <sirit/sirit.h>
 
@@ -19,6 +24,23 @@ static std::bitset<8> clip_distance_written;
 
 using Sirit::Id;
 
+struct DecorationRecord {
+    spv::Decoration decoration;
+    std::optional<u32> literal;
+};
+
+struct IdHash {
+    std::size_t operator()(const Id& id) const noexcept {
+        return std::hash<u32>{}(id.value);
+    }
+};
+
+struct IdEqual {
+    bool operator()(const Id& lhs, const Id& rhs) const noexcept {
+        return lhs.value == rhs.value;
+    }
+};
+
 class VectorTypes {
 public:
     void Define(Sirit::Module& sirit_ctx, Id base_type, std::string_view name);
@@ -204,6 +226,23 @@ public:
         return Constant(F32[1], value);
     }
 
+    Id TypeArray(Id element_type, Id length);
+    Id TypeStruct(Id member);
+    Id TypeStruct(std::span<const Id> members);
+    Id TypeVector(Id element_type, u32 components);
+
+    template <typename... Members>
+    Id TypeStruct(Id first, Members... rest) {
+        const std::array<Id, sizeof...(rest) + 1> members{first, rest...};
+        return TypeStruct(std::span<const Id>(members));
+    }
+
+    [[nodiscard]] bool HasDecoration(Id id, spv::Decoration decoration,
+                                     std::optional<u32> literal = std::nullopt) const;
+    void DecorateUnique(Id id, spv::Decoration decoration,
+                        std::optional<u32> literal = std::nullopt);
+    bool IsIntegerOrBoolType(Id type);
+
     const Profile& profile;
     const RuntimeInfo& runtime_info;
     Stage stage{};
@@ -361,6 +400,11 @@ public:
     Id load_const_func_u32x2{};
     Id load_const_func_u32x4{};
 
+    std::unordered_map<Id, std::vector<DecorationRecord>, IdHash, IdEqual> decorations;
+    std::unordered_map<Id, bool, IdHash, IdEqual> type_integer_or_bool_cache;
+    std::unordered_map<Id, Id, IdHash, IdEqual> array_element_types;
+    std::unordered_map<Id, std::vector<Id>, IdHash, IdEqual> struct_member_types;
+
 private:
     void DefineCommonTypes(const Info& info);
     void DefineCommonConstants();

src/video_core/buffer_cache/buffer_cache.h

@@ -386,7 +386,8 @@ void BufferCache<P>::BindHostComputeBuffers() {
 template <class P>
 void BufferCache<P>::SetUniformBuffersState(const std::array<u32, NUM_STAGES>& mask,
                                             const UniformBufferSizes* sizes) {
-    if (channel_state->enabled_uniform_buffer_masks != mask) {
+    const bool mask_changed = channel_state->enabled_uniform_buffer_masks != mask;
+    if (mask_changed) {
         channel_state->fast_bound_uniform_buffers.fill(0);
         if constexpr (HAS_PERSISTENT_UNIFORM_BUFFER_BINDINGS) {
             channel_state->dirty_uniform_buffers.fill(~u32{0});
@@ -817,7 +818,18 @@ void BufferCache<P>::BindHostGraphicsUniformBuffer(size_t stage, u32 index, u32
         channel_state->uniform_buffer_binding_sizes[stage][binding_index] = size;
         // Stream buffer path to avoid stalling on non-Nvidia drivers or Vulkan
         const std::span<u8> span = runtime.BindMappedUniformBuffer(stage, binding_index, size);
+#ifdef YUZU_DEBUG
+        ASSERT(binding_index < NUM_GRAPHICS_UNIFORM_BUFFERS);
+        ASSERT(span.size() >= size && "UBO stream span too small");
+        if (!device_memory.ReadBlockFastChecked(device_addr, span.data(), size)) {
+            LOG_CRITICAL(Render, "DeviceMemory OOB/unmapped: addr=0x{:x} size={}", device_addr, size);
+            channel_state->fast_bound_uniform_buffers[stage] &= ~(1u << binding_index);
+            ASSERT(false);
+            return;
+        }
+#else
         device_memory.ReadBlockUnsafe(device_addr, span.data(), size);
+#endif
         return;
     }
     // Classic cached path
@@ -826,7 +838,8 @@ void BufferCache<P>::BindHostGraphicsUniformBuffer(size_t stage, u32 index, u32
     }
     // Skip binding if it's not needed and if the bound buffer is not the fast version
     // This exists to avoid instances where the fast buffer is bound and a GPU write happens
-    needs_bind |= HasFastUniformBufferBound(stage, binding_index);
+    const bool was_fast_bound = HasFastUniformBufferBound(stage, binding_index);
+    needs_bind |= was_fast_bound;
     if constexpr (HAS_PERSISTENT_UNIFORM_BUFFER_BINDINGS) {
         needs_bind |= channel_state->uniform_buffer_binding_sizes[stage][binding_index] != size;
     }

src/video_core/buffer_cache/buffer_cache_base.h

@@ -53,7 +53,6 @@ constexpr u32 NUM_COMPUTE_UNIFORM_BUFFERS = 8;
 constexpr u32 NUM_STORAGE_BUFFERS = 16;
 constexpr u32 NUM_TEXTURE_BUFFERS = 32;
 constexpr u32 NUM_STAGES = 5;
-
 static_assert(NUM_GRAPHICS_UNIFORM_BUFFERS <= 32, "fast bitmask must fit u32");
 
 using UniformBufferSizes = std::array<std::array<u32, NUM_GRAPHICS_UNIFORM_BUFFERS>, NUM_STAGES>;

src/video_core/renderer_vulkan/vk_buffer_cache.cpp

@@ -337,11 +337,6 @@ BufferCacheRuntime::BufferCacheRuntime(const Device& device_, MemoryAllocator& m
         uint8_pass = std::make_unique<Uint8Pass>(device, scheduler, descriptor_pool, staging_pool,
                                                  compute_pass_descriptor_queue);
     }
-    const u32 ubo_align = static_cast<u32>(
-            device.GetUniformBufferAlignment() //check if the device has it
-    );
-    // add the ability to change the size in settings in future
-    uniform_ring.Init(device, memory_allocator, 8 * 1024 * 1024 /* 8 MiB */, ubo_align ? ubo_align : 256);
     quad_array_index_buffer = std::make_shared<QuadArrayIndexBuffer>(device_, memory_allocator_,
                                                                      scheduler_, staging_pool_);
     quad_strip_index_buffer = std::make_shared<QuadStripIndexBuffer>(device_, memory_allocator_,
@@ -360,42 +355,6 @@ void BufferCacheRuntime::FreeDeferredStagingBuffer(StagingBufferRef& ref) {
     staging_pool.FreeDeferred(ref);
 }
 
-void BufferCacheRuntime::UniformRing::Init(const Device& device,
-                                           MemoryAllocator& alloc,
-                                           u64 bytes, u32 alignment) {
-    for (size_t i = 0; i < NUM_FRAMES; ++i) {
-        VkBufferCreateInfo ci{
-            .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
-            .pNext = nullptr,
-            .flags = 0,
-            .size  = bytes,
-            .usage = VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
-            .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
-            .queueFamilyIndexCount = 0,
-            .pQueueFamilyIndices = nullptr,
-        };
-        buffers[i] = alloc.CreateBuffer(ci, MemoryUsage::Upload);
-        mapped[i] = buffers[i].Mapped().data();
-    }
-    size   = bytes;
-    align  = alignment ? alignment : 256;
-    head   = 0;
-    current_frame = 0;
-}
-
-std::span<u8> BufferCacheRuntime::UniformRing::Alloc(u32 bytes, u32& out_offset) {
-    const u64 aligned = Common::AlignUp(head, static_cast<u64>(align));
-    u64 end = aligned + bytes;
-
-    if (end > size) {
-       return {}; // Fallback to staging pool
-    }
-
-    out_offset = static_cast<u32>(aligned);
-    head = end;
-    return {mapped[current_frame] + out_offset, bytes};
-}
-
 u64 BufferCacheRuntime::GetDeviceLocalMemory() const {
     return device.GetDeviceLocalMemory();
 }
@@ -416,7 +375,6 @@ void BufferCacheRuntime::TickFrame(Common::SlotVector<Buffer>& slot_buffers) noe
     for (auto it = slot_buffers.begin(); it != slot_buffers.end(); it++) {
         it->ResetUsageTracking();
     }
-    uniform_ring.BeginFrame();
 }
 
 void BufferCacheRuntime::Finish() {

src/video_core/renderer_vulkan/vk_buffer_cache.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -127,15 +124,8 @@ public:
 
     void BindTransformFeedbackBuffers(VideoCommon::HostBindings<Buffer>& bindings);
 
-    std::span<u8> BindMappedUniformBuffer([[maybe_unused]] size_t /*stage*/,
+    std::span<u8> BindMappedUniformBuffer([[maybe_unused]] size_t stage,
-                                          [[maybe_unused]] u32 /*binding_index*/,
+                                          [[maybe_unused]] u32 binding_index, u32 size) {
-                                          u32 size) {
-        u32 offset = 0;
-        if (auto span = uniform_ring.Alloc(size, offset); !span.empty()) {
-            BindBuffer(*uniform_ring.buffers[uniform_ring.current_frame], offset, size);
-            return span;
-        }
-        // Fallback for giant requests
         const StagingBufferRef ref = staging_pool.Request(size, MemoryUsage::Upload);
         BindBuffer(ref.buffer, static_cast<u32>(ref.offset), size);
         return ref.mapped_span;
@@ -163,24 +153,6 @@ private:
     void ReserveNullBuffer();
     vk::Buffer CreateNullBuffer();
 
-    struct UniformRing {
-        static constexpr size_t NUM_FRAMES = 3;
-        std::array<vk::Buffer, NUM_FRAMES> buffers{};
-        std::array<u8*, NUM_FRAMES> mapped{};
-        u64 size = 0;
-        u64 head = 0;
-        u32 align = 256;
-        size_t current_frame = 0;
-
-        void Init(const Device& device, MemoryAllocator& alloc, u64 bytes, u32 alignment);
-        void BeginFrame() {
-            current_frame = (current_frame + 1) % NUM_FRAMES;
-            head = 0;
-        }
-        std::span<u8> Alloc(u32 bytes, u32& out_offset);
-    };
-    UniformRing uniform_ring;
-
     const Device& device;
     MemoryAllocator& memory_allocator;
     Scheduler& scheduler;

src/video_core/renderer_vulkan/vk_staging_buffer_pool.cpp

@@ -25,35 +25,48 @@ namespace {
 
 using namespace Common::Literals;
 
-// Maximum potential alignment of a Vulkan buffer
+// Minimum alignment we want to enforce for the streaming ring
-constexpr VkDeviceSize MAX_ALIGNMENT = 256;
+constexpr VkDeviceSize MIN_STREAM_ALIGNMENT = 256;
 // Stream buffer size in bytes
 constexpr VkDeviceSize MAX_STREAM_BUFFER_SIZE = 128_MiB;
 
-size_t GetStreamBufferSize(const Device& device) {
+size_t GetStreamBufferSize(const Device& device, VkDeviceSize alignment) {
     VkDeviceSize size{0};
     if (device.HasDebuggingToolAttached()) {
-        ForEachDeviceLocalHostVisibleHeap(device, [&size](size_t index, VkMemoryHeap& heap) {
+        bool found_heap = false;
+        ForEachDeviceLocalHostVisibleHeap(device, [&size, &found_heap](size_t /*index*/, VkMemoryHeap& heap) {
             size = (std::max)(size, heap.size);
+            found_heap = true;
         });
+        // If no suitable heap was found fall back to the default cap to avoid creating a zero-sized stream buffer.
+        if (!found_heap) {
+            size = MAX_STREAM_BUFFER_SIZE;
+        } else if (size <= 256_MiB) {
             // If rebar is not supported, cut the max heap size to 40%. This will allow 2 captures to be
             // loaded at the same time in RenderDoc. If rebar is supported, this shouldn't be an issue
             // as the heap will be much larger.
-        if (size <= 256_MiB) {
             size = size * 40 / 100;
         }
     } else {
         size = MAX_STREAM_BUFFER_SIZE;
     }
-    return (std::min)(Common::AlignUp(size, MAX_ALIGNMENT), MAX_STREAM_BUFFER_SIZE);
+
+    // Clamp to the configured maximum, align up for safety, and ensure a sane minimum so
+    // region_size (stream_buffer_size / NUM_SYNCS) never becomes zero.
+    const VkDeviceSize aligned =
+        (std::min)(Common::AlignUp(size, alignment), MAX_STREAM_BUFFER_SIZE);
+    const VkDeviceSize min_size = alignment * StagingBufferPool::NUM_SYNCS;
+    return static_cast<size_t>((std::max)(aligned, min_size));
 }
 } // Anonymous namespace
 
 StagingBufferPool::StagingBufferPool(const Device& device_, MemoryAllocator& memory_allocator_,
                                      Scheduler& scheduler_)
     : device{device_}, memory_allocator{memory_allocator_}, scheduler{scheduler_},
-      stream_buffer_size{GetStreamBufferSize(device)}, region_size{stream_buffer_size /
+      stream_alignment{std::max<VkDeviceSize>(device_.GetUniformBufferAlignment(),
-                                                                   StagingBufferPool::NUM_SYNCS} {
+                                              MIN_STREAM_ALIGNMENT)},
+      stream_buffer_size{GetStreamBufferSize(device_, stream_alignment)},
+      region_size{stream_buffer_size / StagingBufferPool::NUM_SYNCS} {
     VkBufferCreateInfo stream_ci = {
         .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
         .pNext = nullptr,
@@ -106,31 +119,54 @@ void StagingBufferPool::TickFrame() {
 }
 
 StagingBufferRef StagingBufferPool::GetStreamBuffer(size_t size) {
-    if (AreRegionsActive(Region(free_iterator) + 1,
+    const size_t alignment = static_cast<size_t>(stream_alignment);
-                         (std::min)(Region(iterator + size) + 1, NUM_SYNCS))) {
+    const size_t aligned_size = Common::AlignUp(size, alignment);
+    const bool wraps = iterator + size >= stream_buffer_size;
+    const size_t new_iterator =
+        wraps ? aligned_size : Common::AlignUp(iterator + size, alignment);
+    const size_t begin_region = wraps ? 0 : Region(iterator);
+    const size_t last_byte = new_iterator == 0 ? 0 : new_iterator - 1;
+    const size_t end_region = (std::min)(Region(last_byte) + 1, NUM_SYNCS);
+    const size_t guard_begin = (std::min)(Region(free_iterator) + 1, NUM_SYNCS);
+
+    if (!wraps) {
+        if (guard_begin < end_region && AreRegionsActive(guard_begin, end_region)) {
             // Avoid waiting for the previous usages to be free
             return GetStagingBuffer(size, MemoryUsage::Upload);
         }
+    } else if (guard_begin < NUM_SYNCS && AreRegionsActive(guard_begin, NUM_SYNCS)) {
+        // Avoid waiting for the previous usages to be free
+        return GetStagingBuffer(size, MemoryUsage::Upload);
+    }
+
     const u64 current_tick = scheduler.CurrentTick();
     std::fill(sync_ticks.begin() + Region(used_iterator), sync_ticks.begin() + Region(iterator),
               current_tick);
     used_iterator = iterator;
-    free_iterator = (std::max)(free_iterator, iterator + size);
 
-    if (iterator + size >= stream_buffer_size) {
+    if (wraps) {
         std::fill(sync_ticks.begin() + Region(used_iterator), sync_ticks.begin() + NUM_SYNCS,
                   current_tick);
         used_iterator = 0;
         iterator = 0;
-        free_iterator = size;
+        free_iterator = aligned_size;
-
+        const size_t head_last_byte = aligned_size == 0 ? 0 : aligned_size - 1;
-        if (AreRegionsActive(0, Region(size) + 1)) {
+        const size_t head_end_region = (std::min)(Region(head_last_byte) + 1, NUM_SYNCS);
+        if (AreRegionsActive(0, head_end_region)) {
             // Avoid waiting for the previous usages to be free
             return GetStagingBuffer(size, MemoryUsage::Upload);
         }
     }
-    const size_t offset = iterator;
+
-    iterator = Common::AlignUp(iterator + size, MAX_ALIGNMENT);
+    std::fill(sync_ticks.begin() + begin_region, sync_ticks.begin() + end_region, current_tick);
+
+    const size_t offset = wraps ? 0 : iterator;
+    iterator = new_iterator;
+
+    if (!wraps) {
+        free_iterator = (std::max)(free_iterator, offset + aligned_size);
+    }
+
     return StagingBufferRef{
         .buffer = *stream_buffer,
         .offset = static_cast<VkDeviceSize>(offset),

src/video_core/renderer_vulkan/vk_staging_buffer_pool.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
@@ -102,6 +105,7 @@ private:
     MemoryAllocator& memory_allocator;
     Scheduler& scheduler;
 
+    VkDeviceSize stream_alignment;
     vk::Buffer stream_buffer;
     std::span<u8> stream_pointer;
     VkDeviceSize stream_buffer_size;

src/yuzu/CMakeLists.txt

@@ -393,8 +393,16 @@ target_link_libraries(yuzu PRIVATE common core input_common frontend_common netw
 target_link_libraries(yuzu PRIVATE Boost::headers glad Qt6::Widgets)
 target_link_libraries(yuzu PRIVATE ${PLATFORM_LIBRARIES} Threads::Threads)
 
+if (NOT WIN32)
+    target_include_directories(yuzu PRIVATE ${Qt6Gui_PRIVATE_INCLUDE_DIRS})
+endif()
+
 if (UNIX AND NOT APPLE)
     target_link_libraries(yuzu PRIVATE Qt6::DBus)
+
+    if (TARGET Qt6::GuiPrivate)
+        target_link_libraries(yuzu PRIVATE Qt6::GuiPrivate)
+    endif()
 endif()
 
 target_compile_definitions(yuzu PRIVATE

src/yuzu/configuration/configure_debug.cpp

@@ -83,7 +83,8 @@ void ConfigureDebug::SetConfiguration() {
 #ifdef YUZU_USE_QT_WEB_ENGINE
     ui->disable_web_applet->setChecked(UISettings::values.disable_web_applet.GetValue());
 #else
-    ui->disable_web_applet->setVisible(false);
+    ui->disable_web_applet->setEnabled(false);
+    ui->disable_web_applet->setText(tr("Web applet not compiled"));
 #endif
 }