Fix License headers

a bank could be (incorrectly) considered a superset if it had enough image buffer descriptors but not enough storage image descriptors, causing the allocator to pick a bank that can’t actually satisfy VK_DESCRIPTOR_TYPE_STORAGE_IMAGE demand resulting in sham allocations and creation of new pools.
Note to testers,
please look for any regressions in terms of visuals and most importantly please test the performance and ram usage.

src/audio_core/audio_event.cpp

@@ -1,12 +1,9 @@
-// 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
 
 #include "audio_core/audio_event.h"
 #include "common/assert.h"
-#include <ranges>
+#include "common/polyfill_ranges.h"
 
 namespace AudioCore {
 

src/audio_core/common/feature_support.h

@@ -13,7 +13,7 @@
 #include "common/assert.h"
 #include "common/common_funcs.h"
 #include "common/common_types.h"
-#include <ranges>
+#include "common/polyfill_ranges.h"
 
 namespace AudioCore {
 constexpr u32 CurrentRevision = 16;

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

@@ -8,7 +8,7 @@
 
 #include "audio_core/adsp/apps/audio_renderer/command_list_processor.h"
 #include "audio_core/renderer/command/effect/i3dl2_reverb.h"
-#include <ranges>
+#include "common/polyfill_ranges.h"
 
 namespace AudioCore::Renderer {
 

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

@@ -9,7 +9,7 @@
 
 #include "audio_core/adsp/apps/audio_renderer/command_list_processor.h"
 #include "audio_core/renderer/command/effect/reverb.h"
-#include <ranges>
+#include "common/polyfill_ranges.h"
 
 namespace AudioCore::Renderer {
 

src/audio_core/renderer/mix/mix_context.cpp

@@ -8,7 +8,7 @@
 
 #include "audio_core/renderer/mix/mix_context.h"
 #include "audio_core/renderer/splitter/splitter_context.h"
-#include <ranges>
+#include "common/polyfill_ranges.h"
 
 namespace AudioCore::Renderer {
 

src/audio_core/renderer/voice/voice_context.cpp

@@ -1,13 +1,10 @@
-// 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
 
 #include <ranges>
 
 #include "audio_core/renderer/voice/voice_context.h"
-#include <ranges>
+#include "common/polyfill_ranges.h"
 
 namespace AudioCore::Renderer {
 

src/common/fs/fs_util.cpp

@@ -1,13 +1,10 @@
-// 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
 
 #include <algorithm>
 
 #include "common/fs/fs_util.h"
-#include <ranges>
+#include "common/polyfill_ranges.h"
 
 namespace Common::FS {
 

src/common/polyfill_ranges.h

@@ -0,0 +1,530 @@
+// SPDX-FileCopyrightText: 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+//
+// TODO: remove this file when ranges are supported by all compilation targets
+//
+
+#pragma once
+
+#include <algorithm>
+#include <utility>
+#include <version>
+
+#ifndef __cpp_lib_ranges
+
+namespace std {
+namespace ranges {
+
+template <typename T>
+concept range = requires(T& t) {
+                    begin(t);
+                    end(t);
+                };
+
+template <typename T>
+concept input_range = range<T>;
+
+template <typename T>
+concept output_range = range<T>;
+
+template <range R>
+using range_difference_t = ptrdiff_t;
+
+//
+// find, find_if, find_if_not
+//
+
+struct find_fn {
+    template <typename Iterator, typename T, typename Proj = std::identity>
+    constexpr Iterator operator()(Iterator first, Iterator last, const T& value,
+                                  Proj proj = {}) const {
+        for (; first != last; ++first) {
+            if (std::invoke(proj, *first) == value) {
+                return first;
+            }
+        }
+        return first;
+    }
+
+    template <ranges::input_range R, typename T, typename Proj = std::identity>
+    constexpr ranges::iterator_t<R> operator()(R&& r, const T& value, Proj proj = {}) const {
+        return operator()(ranges::begin(r), ranges::end(r), value, std::ref(proj));
+    }
+};
+
+struct find_if_fn {
+    template <typename Iterator, typename Proj = std::identity, typename Pred>
+    constexpr Iterator operator()(Iterator first, Iterator last, Pred pred, Proj proj = {}) const {
+        for (; first != last; ++first) {
+            if (std::invoke(pred, std::invoke(proj, *first))) {
+                return first;
+            }
+        }
+        return first;
+    }
+
+    template <ranges::input_range R, typename Proj = std::identity, typename Pred>
+    constexpr ranges::iterator_t<R> operator()(R&& r, Pred pred, Proj proj = {}) const {
+        return operator()(ranges::begin(r), ranges::end(r), std::ref(pred), std::ref(proj));
+    }
+};
+
+struct find_if_not_fn {
+    template <typename Iterator, typename Proj = std::identity, typename Pred>
+    constexpr Iterator operator()(Iterator first, Iterator last, Pred pred, Proj proj = {}) const {
+        for (; first != last; ++first) {
+            if (!std::invoke(pred, std::invoke(proj, *first))) {
+                return first;
+            }
+        }
+        return first;
+    }
+
+    template <ranges::input_range R, typename Proj = std::identity, typename Pred>
+    constexpr ranges::iterator_t<R> operator()(R&& r, Pred pred, Proj proj = {}) const {
+        return operator()(ranges::begin(r), ranges::end(r), std::ref(pred), std::ref(proj));
+    }
+};
+
+inline constexpr find_fn find;
+inline constexpr find_if_fn find_if;
+inline constexpr find_if_not_fn find_if_not;
+
+//
+// any_of, all_of, none_of
+//
+
+struct all_of_fn {
+    template <typename Iterator, typename Proj = std::identity, typename Pred>
+    constexpr bool operator()(Iterator first, Iterator last, Pred pred, Proj proj = {}) const {
+        return ranges::find_if_not(first, last, std::ref(pred), std::ref(proj)) == last;
+    }
+
+    template <ranges::input_range R, typename Proj = std::identity, typename Pred>
+    constexpr bool operator()(R&& r, Pred pred, Proj proj = {}) const {
+        return operator()(ranges::begin(r), ranges::end(r), std::ref(pred), std::ref(proj));
+    }
+};
+
+struct any_of_fn {
+    template <typename Iterator, typename Proj = std::identity, typename Pred>
+    constexpr bool operator()(Iterator first, Iterator last, Pred pred, Proj proj = {}) const {
+        return ranges::find_if(first, last, std::ref(pred), std::ref(proj)) != last;
+    }
+
+    template <ranges::input_range R, typename Proj = std::identity, typename Pred>
+    constexpr bool operator()(R&& r, Pred pred, Proj proj = {}) const {
+        return operator()(ranges::begin(r), ranges::end(r), std::ref(pred), std::ref(proj));
+    }
+};
+
+struct none_of_fn {
+    template <typename Iterator, typename Proj = std::identity, typename Pred>
+    constexpr bool operator()(Iterator first, Iterator last, Pred pred, Proj proj = {}) const {
+        return ranges::find_if(first, last, std::ref(pred), std::ref(proj)) == last;
+    }
+
+    template <ranges::input_range R, typename Proj = std::identity, typename Pred>
+    constexpr bool operator()(R&& r, Pred pred, Proj proj = {}) const {
+        return operator()(ranges::begin(r), ranges::end(r), std::ref(pred), std::ref(proj));
+    }
+};
+
+inline constexpr any_of_fn any_of;
+inline constexpr all_of_fn all_of;
+inline constexpr none_of_fn none_of;
+
+//
+// count, count_if
+//
+
+struct count_fn {
+    template <typename Iterator, typename T, typename Proj = std::identity>
+    constexpr ptrdiff_t operator()(Iterator first, Iterator last, const T& value,
+                                   Proj proj = {}) const {
+        ptrdiff_t counter = 0;
+        for (; first != last; ++first)
+            if (std::invoke(proj, *first) == value)
+                ++counter;
+        return counter;
+    }
+
+    template <ranges::input_range R, typename T, typename Proj = std::identity>
+    constexpr ptrdiff_t operator()(R&& r, const T& value, Proj proj = {}) const {
+        return operator()(ranges::begin(r), ranges::end(r), value, std::ref(proj));
+    }
+};
+
+struct count_if_fn {
+    template <typename Iterator, typename Proj = std::identity, typename Pred>
+    constexpr ptrdiff_t operator()(Iterator first, Iterator last, Pred pred, Proj proj = {}) const {
+        ptrdiff_t counter = 0;
+        for (; first != last; ++first)
+            if (std::invoke(pred, std::invoke(proj, *first)))
+                ++counter;
+        return counter;
+    }
+
+    template <ranges::input_range R, typename Proj = std::identity, typename Pred>
+    constexpr ptrdiff_t operator()(R&& r, Pred pred, Proj proj = {}) const {
+        return operator()(ranges::begin(r), ranges::end(r), std::ref(pred), std::ref(proj));
+    }
+};
+
+inline constexpr count_fn count;
+inline constexpr count_if_fn count_if;
+
+//
+// transform
+//
+
+struct transform_fn {
+    template <typename InputIterator, typename OutputIterator, typename F,
+              typename Proj = std::identity>
+    constexpr void operator()(InputIterator first1, InputIterator last1, OutputIterator result,
+                              F op, Proj proj = {}) const {
+        for (; first1 != last1; ++first1, (void)++result) {
+            *result = std::invoke(op, std::invoke(proj, *first1));
+        }
+    }
+
+    template <ranges::input_range R, typename OutputIterator, typename F,
+              typename Proj = std::identity>
+    constexpr void operator()(R&& r, OutputIterator result, F op, Proj proj = {}) const {
+        return operator()(ranges::begin(r), ranges::end(r), result, std::ref(op), std::ref(proj));
+    }
+};
+
+inline constexpr transform_fn transform;
+
+//
+// sort
+//
+
+struct sort_fn {
+    template <typename Iterator, typename Comp = ranges::less, typename Proj = std::identity>
+    constexpr void operator()(Iterator first, Iterator last, Comp comp = {}, Proj proj = {}) const {
+        if (first == last)
+            return;
+
+        Iterator last_iter = ranges::next(first, last);
+        std::sort(first, last_iter,
+                  [&](auto& lhs, auto& rhs) { return comp(proj(lhs), proj(rhs)); });
+    }
+
+    template <ranges::input_range R, typename Comp = ranges::less, typename Proj = std::identity>
+    constexpr void operator()(R&& r, Comp comp = {}, Proj proj = {}) const {
+        return operator()(ranges::begin(r), ranges::end(r), std::move(comp), std::move(proj));
+    }
+};
+
+inline constexpr sort_fn sort;
+
+//
+// fill
+//
+
+struct fill_fn {
+    template <typename T, typename OutputIterator>
+    constexpr OutputIterator operator()(OutputIterator first, OutputIterator last,
+                                        const T& value) const {
+        while (first != last) {
+            *first++ = value;
+        }
+
+        return first;
+    }
+
+    template <typename T, ranges::output_range R>
+    constexpr ranges::iterator_t<R> operator()(R&& r, const T& value) const {
+        return operator()(ranges::begin(r), ranges::end(r), value);
+    }
+};
+
+inline constexpr fill_fn fill;
+
+//
+// for_each
+//
+
+struct for_each_fn {
+    template <typename Iterator, typename Proj = std::identity, typename Fun>
+    constexpr void operator()(Iterator first, Iterator last, Fun f, Proj proj = {}) const {
+        for (; first != last; ++first) {
+            std::invoke(f, std::invoke(proj, *first));
+        }
+    }
+
+    template <ranges::input_range R, typename Proj = std::identity, typename Fun>
+    constexpr void operator()(R&& r, Fun f, Proj proj = {}) const {
+        return operator()(ranges::begin(r), ranges::end(r), std::move(f), std::ref(proj));
+    }
+};
+
+inline constexpr for_each_fn for_each;
+
+//
+// min_element, max_element
+//
+
+struct min_element_fn {
+    template <typename Iterator, typename Proj = std::identity, typename Comp = ranges::less>
+    constexpr Iterator operator()(Iterator first, Iterator last, Comp comp = {},
+                                  Proj proj = {}) const {
+        if (first == last) {
+            return last;
+        }
+
+        auto smallest = first;
+        ++first;
+        for (; first != last; ++first) {
+            if (!std::invoke(comp, std::invoke(proj, *smallest), std::invoke(proj, *first))) {
+                smallest = first;
+            }
+        }
+        return smallest;
+    }
+
+    template <ranges::input_range R, typename Proj = std::identity, typename Comp = ranges::less>
+    constexpr ranges::iterator_t<R> operator()(R&& r, Comp comp = {}, Proj proj = {}) const {
+        return operator()(ranges::begin(r), ranges::end(r), std::ref(comp), std::ref(proj));
+    }
+};
+
+struct max_element_fn {
+    template <typename Iterator, typename Proj = std::identity, typename Comp = ranges::less>
+    constexpr Iterator operator()(Iterator first, Iterator last, Comp comp = {},
+                                  Proj proj = {}) const {
+        if (first == last) {
+            return last;
+        }
+
+        auto largest = first;
+        ++first;
+        for (; first != last; ++first) {
+            if (std::invoke(comp, std::invoke(proj, *largest), std::invoke(proj, *first))) {
+                largest = first;
+            }
+        }
+        return largest;
+    }
+
+    template <ranges::input_range R, typename Proj = std::identity, typename Comp = ranges::less>
+    constexpr ranges::iterator_t<R> operator()(R&& r, Comp comp = {}, Proj proj = {}) const {
+        return operator()(ranges::begin(r), ranges::end(r), std::ref(comp), std::ref(proj));
+    }
+};
+
+inline constexpr min_element_fn min_element;
+inline constexpr max_element_fn max_element;
+
+//
+// replace, replace_if
+//
+
+struct replace_fn {
+    template <typename Iterator, typename T1, typename T2, typename Proj = std::identity>
+    constexpr Iterator operator()(Iterator first, Iterator last, const T1& old_value,
+                                  const T2& new_value, Proj proj = {}) const {
+        for (; first != last; ++first) {
+            if (old_value == std::invoke(proj, *first)) {
+                *first = new_value;
+            }
+        }
+        return first;
+    }
+
+    template <ranges::input_range R, typename T1, typename T2, typename Proj = std::identity>
+    constexpr ranges::iterator_t<R> operator()(R&& r, const T1& old_value, const T2& new_value,
+                                               Proj proj = {}) const {
+        return operator()(ranges::begin(r), ranges::end(r), old_value, new_value, std::move(proj));
+    }
+};
+
+struct replace_if_fn {
+    template <typename Iterator, typename T, typename Proj = std::identity, typename Pred>
+    constexpr Iterator operator()(Iterator first, Iterator last, Pred pred, const T& new_value,
+                                  Proj proj = {}) const {
+        for (; first != last; ++first) {
+            if (!!std::invoke(pred, std::invoke(proj, *first))) {
+                *first = new_value;
+            }
+        }
+        return std::move(first);
+    }
+
+    template <ranges::input_range R, typename T, typename Proj = std::identity, typename Pred>
+    constexpr ranges::iterator_t<R> operator()(R&& r, Pred pred, const T& new_value,
+                                               Proj proj = {}) const {
+        return operator()(ranges::begin(r), ranges::end(r), std::move(pred), new_value,
+                          std::move(proj));
+    }
+};
+
+inline constexpr replace_fn replace;
+inline constexpr replace_if_fn replace_if;
+
+//
+// copy, copy_if
+//
+
+struct copy_fn {
+    template <typename InputIterator, typename OutputIterator>
+    constexpr void operator()(InputIterator first, InputIterator last,
+                              OutputIterator result) const {
+        for (; first != last; ++first, (void)++result) {
+            *result = *first;
+        }
+    }
+
+    template <ranges::input_range R, typename OutputIterator>
+    constexpr void operator()(R&& r, OutputIterator result) const {
+        return operator()(ranges::begin(r), ranges::end(r), std::move(result));
+    }
+};
+
+struct copy_if_fn {
+    template <typename InputIterator, typename OutputIterator, typename Proj = std::identity,
+              typename Pred>
+    constexpr void operator()(InputIterator first, InputIterator last, OutputIterator result,
+                              Pred pred, Proj proj = {}) const {
+        for (; first != last; ++first) {
+            if (std::invoke(pred, std::invoke(proj, *first))) {
+                *result = *first;
+                ++result;
+            }
+        }
+    }
+
+    template <ranges::input_range R, typename OutputIterator, typename Proj = std::identity,
+              typename Pred>
+    constexpr void operator()(R&& r, OutputIterator result, Pred pred, Proj proj = {}) const {
+        return operator()(ranges::begin(r), ranges::end(r), std::move(result), std::ref(pred),
+                          std::ref(proj));
+    }
+};
+
+inline constexpr copy_fn copy;
+inline constexpr copy_if_fn copy_if;
+
+//
+// generate
+//
+
+struct generate_fn {
+    template <typename Iterator, typename F>
+    constexpr Iterator operator()(Iterator first, Iterator last, F gen) const {
+        for (; first != last; *first = std::invoke(gen), ++first)
+            ;
+        return first;
+    }
+
+    template <typename R, std::copy_constructible F>
+        requires std::invocable<F&> && ranges::output_range<R>
+    constexpr ranges::iterator_t<R> operator()(R&& r, F gen) const {
+        return operator()(ranges::begin(r), ranges::end(r), std::move(gen));
+    }
+};
+
+inline constexpr generate_fn generate;
+
+//
+// lower_bound, upper_bound
+//
+
+struct lower_bound_fn {
+    template <typename Iterator, typename T, typename Proj = std::identity,
+              typename Comp = ranges::less>
+    constexpr Iterator operator()(Iterator first, Iterator last, const T& value, Comp comp = {},
+                                  Proj proj = {}) const {
+        Iterator it;
+        std::ptrdiff_t _count, _step;
+        _count = std::distance(first, last);
+
+        while (_count > 0) {
+            it = first;
+            _step = _count / 2;
+            ranges::advance(it, _step, last);
+            if (comp(std::invoke(proj, *it), value)) {
+                first = ++it;
+                _count -= _step + 1;
+            } else {
+                _count = _step;
+            }
+        }
+        return first;
+    }
+
+    template <ranges::input_range R, typename T, typename Proj = std::identity,
+              typename Comp = ranges::less>
+    constexpr ranges::iterator_t<R> operator()(R&& r, const T& value, Comp comp = {},
+                                               Proj proj = {}) const {
+        return operator()(ranges::begin(r), ranges::end(r), value, std::ref(comp), std::ref(proj));
+    }
+};
+
+struct upper_bound_fn {
+    template <typename Iterator, typename T, typename Proj = std::identity,
+              typename Comp = ranges::less>
+    constexpr Iterator operator()(Iterator first, Iterator last, const T& value, Comp comp = {},
+                                  Proj proj = {}) const {
+        Iterator it;
+        std::ptrdiff_t _count, _step;
+        _count = std::distance(first, last);
+
+        while (_count > 0) {
+            it = first;
+            _step = _count / 2;
+            ranges::advance(it, _step, last);
+            if (!comp(value, std::invoke(proj, *it))) {
+                first = ++it;
+                _count -= _step + 1;
+            } else {
+                _count = _step;
+            }
+        }
+        return first;
+    }
+
+    template <ranges::input_range R, typename T, typename Proj = std::identity,
+              typename Comp = ranges::less>
+    constexpr ranges::iterator_t<R> operator()(R&& r, const T& value, Comp comp = {},
+                                               Proj proj = {}) const {
+        return operator()(ranges::begin(r), ranges::end(r), value, std::ref(comp), std::ref(proj));
+    }
+};
+
+inline constexpr lower_bound_fn lower_bound;
+inline constexpr upper_bound_fn upper_bound;
+
+//
+// adjacent_find
+//
+
+struct adjacent_find_fn {
+    template <typename Iterator, typename Proj = std::identity, typename Pred = ranges::equal_to>
+    constexpr Iterator operator()(Iterator first, Iterator last, Pred pred = {},
+                                  Proj proj = {}) const {
+        if (first == last)
+            return first;
+        auto _next = ranges::next(first);
+        for (; _next != last; ++_next, ++first)
+            if (std::invoke(pred, std::invoke(proj, *first), std::invoke(proj, *_next)))
+                return first;
+        return _next;
+    }
+
+    template <ranges::input_range R, typename Proj = std::identity,
+              typename Pred = ranges::equal_to>
+    constexpr ranges::iterator_t<R> operator()(R&& r, Pred pred = {}, Proj proj = {}) const {
+        return operator()(ranges::begin(r), ranges::end(r), std::ref(pred), std::ref(proj));
+    }
+};
+
+inline constexpr adjacent_find_fn adjacent_find;
+
+} // namespace ranges
+} // namespace std
+
+#endif

src/common/slot_vector.h

@@ -15,7 +15,7 @@
 
 #include "common/assert.h"
 #include "common/common_types.h"
-#include <ranges>
+#include "common/polyfill_ranges.h"
 
 namespace Common {
 

src/core/file_sys/content_archive.cpp

@@ -10,7 +10,7 @@
 #include <utility>
 
 #include "common/logging/log.h"
-#include <ranges>
+#include "common/polyfill_ranges.h"
 #include "core/crypto/aes_util.h"
 #include "core/crypto/ctr_encryption_layer.h"
 #include "core/crypto/key_manager.h"

src/core/hle/kernel/k_thread_local_page.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
 
@@ -13,7 +10,7 @@
 #include "common/assert.h"
 #include "common/common_types.h"
 #include "common/intrusive_red_black_tree.h"
-#include <ranges>
+#include "common/polyfill_ranges.h"
 #include "core/hle/kernel/memory_types.h"
 #include "core/hle/kernel/slab_helpers.h"
 #include "core/hle/result.h"

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

@@ -11,7 +11,7 @@
 #include "common/fs/file.h"
 #include "common/fs/path_util.h"
 #include "common/logging/log.h"
-#include <ranges>
+#include "common/polyfill_ranges.h"
 #include "common/stb.h"
 #include "common/string_util.h"
 #include "common/swap.h"
@@ -647,8 +647,7 @@ public:
             {0, &IManagerForApplication::CheckAvailability, "CheckAvailability"},
             {1, &IManagerForApplication::GetAccountId, "GetAccountId"},
             {2, &IManagerForApplication::EnsureIdTokenCacheAsync, "EnsureIdTokenCacheAsync"},
-            {3, &IManagerForApplication::LoadIdTokenCacheDeprecated, "LoadIdTokenCache"},
-            {4, &IManagerForApplication::LoadIdTokenCache, "LoadIdTokenCache"},
+            {3, &IManagerForApplication::LoadIdTokenCache, "LoadIdTokenCache"},
             {130, &IManagerForApplication::GetNintendoAccountUserResourceCacheForApplication, "GetNintendoAccountUserResourceCacheForApplication"},
             {136, &IManagerForApplication::GetNintendoAccountUserResourceCacheForApplication, "GetNintendoAccountUserResourceCache"}, // 19.0.0+
             {150, nullptr, "CreateAuthorizationRequest"},
@@ -684,23 +683,10 @@ private:
         rb.PushIpcInterface(ensure_token_id);
     }
 
-    void LoadIdTokenCacheDeprecated(HLERequestContext& ctx) {
-        LOG_WARNING(Service_ACC, "(STUBBED) called");
-
-        ensure_token_id->LoadIdTokenCache(ctx);
-    }
-
     void LoadIdTokenCache(HLERequestContext& ctx) {
         LOG_WARNING(Service_ACC, "(STUBBED) called");
 
-        std::vector<u8> token_data(0x100);
-        std::fill(token_data.begin(), token_data.end(), u8(0));
-
-        ctx.WriteBuffer(token_data, 0);
-
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(ResultSuccess);
-        rb.Push(static_cast<u32>(token_data.size()));
+        ensure_token_id->LoadIdTokenCache(ctx);
     }
 
     void GetNintendoAccountUserResourceCacheForApplication(HLERequestContext& ctx) {

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

@@ -12,7 +12,7 @@
 #include "common/fs/file.h"
 #include "common/fs/fs.h"
 #include "common/fs/path_util.h"
-#include <ranges>
+#include "common/polyfill_ranges.h"
 #include "common/settings.h"
 #include "common/string_util.h"
 #include "core/hle/service/acc/profile_manager.h"

src/core/internal_network/network_interface.cpp

@@ -9,7 +9,7 @@
 #include "common/bit_cast.h"
 #include "common/common_types.h"
 #include "common/logging/log.h"
-#include <ranges>
+#include "common/polyfill_ranges.h"
 #include "common/settings.h"
 #include "common/string_util.h"
 #include "core/internal_network/emu_net_state.h"

src/dynarmic/CMakeLists.txt

@@ -18,7 +18,11 @@ endif()
 # Dynarmic project options
 option(DYNARMIC_ENABLE_CPU_FEATURE_DETECTION "Turning this off causes dynarmic to assume the host CPU doesn't support anything later than SSE3" ON)
 
-option(DYNARMIC_ENABLE_NO_EXECUTE_SUPPORT "Enables support for systems that require W^X" ${PLATFORM_OPENBSD})
+if (PLATFORM_OPENBSD)
+    option(DYNARMIC_ENABLE_NO_EXECUTE_SUPPORT "Enables support for systems that require W^X" ON)
+else()
+    option(DYNARMIC_ENABLE_NO_EXECUTE_SUPPORT "Enables support for systems that require W^X" OFF)
+endif()
 
 option(DYNARMIC_FATAL_ERRORS "Errors are fatal" OFF)
 option(DYNARMIC_IGNORE_ASSERTS "Ignore asserts" OFF)

src/hid_core/frontend/emulated_controller.cpp

@@ -8,7 +8,7 @@
 #include <chrono>
 #include <common/scope_exit.h>
 
-#include <ranges>
+#include "common/polyfill_ranges.h"
 #include "common/thread.h"
 #include "hid_core/frontend/emulated_controller.h"
 #include "hid_core/frontend/input_converter.h"
@@ -577,7 +577,7 @@ void EmulatedController::UnloadInput() {
 }
 
 void EmulatedController::EnableConfiguration() {
-    std::unique_lock lock1{connect_mutex}, lock2{npad_mutex};
+    std::scoped_lock lock{connect_mutex, npad_mutex};
     is_configuring = true;
     tmp_is_connected = is_connected;
     tmp_npad_type = npad_type;
@@ -614,19 +614,19 @@ void EmulatedController::DisableConfiguration() {
 }
 
 void EmulatedController::EnableSystemButtons() {
-    std::unique_lock lock{mutex};
+    std::scoped_lock lock{mutex};
     system_buttons_enabled = true;
 }
 
 void EmulatedController::DisableSystemButtons() {
-    std::unique_lock lock{mutex};
+    std::scoped_lock lock{mutex};
     system_buttons_enabled = false;
     controller.home_button_state.raw = 0;
     controller.capture_button_state.raw = 0;
 }
 
 void EmulatedController::ResetSystemButtons() {
-    std::unique_lock lock{mutex};
+    std::scoped_lock lock{mutex};
     controller.home_button_state.home.Assign(false);
     controller.capture_button_state.capture.Assign(false);
 }
@@ -937,7 +937,7 @@ void EmulatedController::SetStick(const Common::Input::CallbackStatus& callback,
     auto trigger_guard = SCOPE_GUARD {
         TriggerOnChange(ControllerTriggerType::Stick, !is_configuring);
     };
-    std::unique_lock lock{mutex};
+    std::scoped_lock lock{mutex};
     const auto stick_value = TransformToStick(callback);
 
     // Only read stick values that have the same uuid or are over the threshold to avoid flapping
@@ -994,7 +994,7 @@ void EmulatedController::SetTrigger(const Common::Input::CallbackStatus& callbac
     auto trigger_guard = SCOPE_GUARD {
         TriggerOnChange(ControllerTriggerType::Trigger, !is_configuring);
     };
-    std::unique_lock lock{mutex};
+    std::scoped_lock lock{mutex};
     const auto trigger_value = TransformToTrigger(callback);
 
     // Only read trigger values that have the same uuid or are pressed once
@@ -1042,7 +1042,7 @@ void EmulatedController::SetMotion(const Common::Input::CallbackStatus& callback
     SCOPE_EXIT {
         TriggerOnChange(ControllerTriggerType::Motion, !is_configuring);
     };
-    std::unique_lock lock{mutex};
+    std::scoped_lock lock{mutex};
     auto& raw_status = controller.motion_values[index].raw_status;
     auto& emulated = controller.motion_values[index].emulated;
 
@@ -1078,7 +1078,7 @@ void EmulatedController::SetColors(const Common::Input::CallbackStatus& callback
     auto trigger_guard = SCOPE_GUARD {
         TriggerOnChange(ControllerTriggerType::Color, !is_configuring);
     };
-    std::unique_lock lock{mutex};
+    std::scoped_lock lock{mutex};
     controller.color_values[index] = TransformToColor(callback);
 
     if (is_configuring) {
@@ -1129,7 +1129,7 @@ void EmulatedController::SetBattery(const Common::Input::CallbackStatus& callbac
     SCOPE_EXIT {
         TriggerOnChange(ControllerTriggerType::Battery, !is_configuring);
     };
-    std::unique_lock lock{mutex};
+    std::scoped_lock lock{mutex};
     controller.battery_values[index] = TransformToBattery(callback);
 
     if (is_configuring) {
@@ -1194,7 +1194,7 @@ void EmulatedController::SetCamera(const Common::Input::CallbackStatus& callback
     SCOPE_EXIT {
         TriggerOnChange(ControllerTriggerType::IrSensor, !is_configuring);
     };
-    std::unique_lock lock{mutex};
+    std::scoped_lock lock{mutex};
     controller.camera_values = TransformToCamera(callback);
 
     if (is_configuring) {
@@ -1211,7 +1211,7 @@ void EmulatedController::SetRingAnalog(const Common::Input::CallbackStatus& call
     SCOPE_EXIT {
         TriggerOnChange(ControllerTriggerType::RingController, !is_configuring);
     };
-    std::unique_lock lock{mutex};
+    std::scoped_lock lock{mutex};
     const auto force_value = TransformToStick(callback);
 
     controller.ring_analog_value = force_value.x;
@@ -1227,7 +1227,7 @@ void EmulatedController::SetNfc(const Common::Input::CallbackStatus& callback) {
     SCOPE_EXIT {
         TriggerOnChange(ControllerTriggerType::Nfc, !is_configuring);
     };
-    std::unique_lock lock{mutex};
+    std::scoped_lock lock{mutex};
     controller.nfc_values = TransformToNfc(callback);
 
     if (is_configuring) {
@@ -1662,7 +1662,7 @@ void EmulatedController::SetSupportedNpadStyleTag(NpadStyleTag supported_styles)
 }
 
 bool EmulatedController::IsControllerFullkey(bool use_temporary_value) const {
-    std::unique_lock lock{mutex};
+    std::scoped_lock lock{mutex};
     const auto type = is_configuring && use_temporary_value ? tmp_npad_type : npad_type;
     switch (type) {
     case NpadStyleIndex::Fullkey:
@@ -1678,7 +1678,7 @@ bool EmulatedController::IsControllerFullkey(bool use_temporary_value) const {
 }
 
 bool EmulatedController::IsControllerSupported(bool use_temporary_value) const {
-    std::unique_lock lock{mutex};
+    std::scoped_lock lock{mutex};
     const auto type = is_configuring && use_temporary_value ? tmp_npad_type : npad_type;
     switch (type) {
     case NpadStyleIndex::Fullkey:
@@ -1718,7 +1718,7 @@ void EmulatedController::Connect(bool use_temporary_value) {
     auto trigger_guard = SCOPE_GUARD {
         TriggerOnChange(ControllerTriggerType::Connected, !is_configuring);
     };
-    std::unique_lock lock1{connect_mutex}, lock2{mutex};
+    std::scoped_lock lock{connect_mutex, mutex};
     if (is_configuring) {
         tmp_is_connected = true;
         return;
@@ -1735,7 +1735,7 @@ void EmulatedController::Disconnect() {
     auto trigger_guard = SCOPE_GUARD {
         TriggerOnChange(ControllerTriggerType::Disconnected, !is_configuring);
     };
-    std::unique_lock lock1{connect_mutex}, lock2{mutex};
+    std::scoped_lock lock{connect_mutex, mutex};
     if (is_configuring) {
         tmp_is_connected = false;
         return;
@@ -1749,21 +1749,23 @@ void EmulatedController::Disconnect() {
 }
 
 bool EmulatedController::IsConnected(bool get_temporary_value) const {
-    std::shared_lock lock{connect_mutex};
-    if (get_temporary_value && is_configuring)
+    std::scoped_lock lock{connect_mutex};
+    if (get_temporary_value && is_configuring) {
         return tmp_is_connected;
+    }
     return is_connected;
 }
 
 NpadIdType EmulatedController::GetNpadIdType() const {
-    std::shared_lock lock{mutex};
+    std::scoped_lock lock{mutex};
     return npad_id_type;
 }
 
 NpadStyleIndex EmulatedController::GetNpadStyleIndex(bool get_temporary_value) const {
-    std::shared_lock lock{npad_mutex};
-    if (get_temporary_value && is_configuring)
+    std::scoped_lock lock{npad_mutex};
+    if (get_temporary_value && is_configuring) {
         return tmp_npad_type;
+    }
     return npad_type;
 }
 
@@ -1771,7 +1773,7 @@ void EmulatedController::SetNpadStyleIndex(NpadStyleIndex npad_type_) {
     auto trigger_guard = SCOPE_GUARD {
         TriggerOnChange(ControllerTriggerType::Type, !is_configuring);
     };
-    std::unique_lock lock1{mutex}, lock2{npad_mutex};
+    std::scoped_lock lock{mutex, npad_mutex};
 
     if (is_configuring) {
         if (tmp_npad_type == npad_type_) {
@@ -1817,37 +1819,37 @@ LedPattern EmulatedController::GetLedPattern() const {
 }
 
 ButtonValues EmulatedController::GetButtonsValues() const {
-    std::unique_lock lock{mutex};
+    std::scoped_lock lock{mutex};
     return controller.button_values;
 }
 
 SticksValues EmulatedController::GetSticksValues() const {
-    std::unique_lock lock{mutex};
+    std::scoped_lock lock{mutex};
     return controller.stick_values;
 }
 
 TriggerValues EmulatedController::GetTriggersValues() const {
-    std::unique_lock lock{mutex};
+    std::scoped_lock lock{mutex};
     return controller.trigger_values;
 }
 
 ControllerMotionValues EmulatedController::GetMotionValues() const {
-    std::unique_lock lock{mutex};
+    std::scoped_lock lock{mutex};
     return controller.motion_values;
 }
 
 ColorValues EmulatedController::GetColorsValues() const {
-    std::unique_lock lock{mutex};
+    std::scoped_lock lock{mutex};
     return controller.color_values;
 }
 
 BatteryValues EmulatedController::GetBatteryValues() const {
-    std::unique_lock lock{mutex};
+    std::scoped_lock lock{mutex};
     return controller.battery_values;
 }
 
 CameraValues EmulatedController::GetCameraValues() const {
-    std::unique_lock lock{mutex};
+    std::scoped_lock lock{mutex};
     return controller.camera_values;
 }
 
@@ -1856,7 +1858,7 @@ RingAnalogValue EmulatedController::GetRingSensorValues() const {
 }
 
 HomeButtonState EmulatedController::GetHomeButtons() const {
-    std::unique_lock lock{mutex};
+    std::scoped_lock lock{mutex};
     if (is_configuring) {
         return {};
     }
@@ -1864,7 +1866,7 @@ HomeButtonState EmulatedController::GetHomeButtons() const {
 }
 
 CaptureButtonState EmulatedController::GetCaptureButtons() const {
-    std::unique_lock lock{mutex};
+    std::scoped_lock lock{mutex};
     if (is_configuring) {
         return {};
     }
@@ -1872,7 +1874,7 @@ CaptureButtonState EmulatedController::GetCaptureButtons() const {
 }
 
 NpadButtonState EmulatedController::GetNpadButtons() const {
-    std::unique_lock lock{mutex};
+    std::scoped_lock lock{mutex};
     if (is_configuring) {
         return {};
     }
@@ -1880,7 +1882,7 @@ NpadButtonState EmulatedController::GetNpadButtons() const {
 }
 
 DebugPadButton EmulatedController::GetDebugPadButtons() const {
-    std::unique_lock lock{mutex};
+    std::scoped_lock lock{mutex};
     if (is_configuring) {
         return {};
     }
@@ -1888,7 +1890,7 @@ DebugPadButton EmulatedController::GetDebugPadButtons() const {
 }
 
 AnalogSticks EmulatedController::GetSticks() const {
-    std::unique_lock lock{mutex};
+    std::scoped_lock lock{mutex};
 
     if (is_configuring) {
         return {};
@@ -1898,7 +1900,7 @@ AnalogSticks EmulatedController::GetSticks() const {
 }
 
 NpadGcTriggerState EmulatedController::GetTriggers() const {
-    std::unique_lock lock{mutex};
+    std::scoped_lock lock{mutex};
     if (is_configuring) {
         return {};
     }
@@ -1911,17 +1913,17 @@ MotionState EmulatedController::GetMotions() const {
 }
 
 ControllerColors EmulatedController::GetColors() const {
-    std::unique_lock lock{mutex};
+    std::scoped_lock lock{mutex};
     return controller.colors_state;
 }
 
 BatteryLevelState EmulatedController::GetBattery() const {
-    std::unique_lock lock{mutex};
+    std::scoped_lock lock{mutex};
     return controller.battery_state;
 }
 
 const CameraState& EmulatedController::GetCamera() const {
-    std::unique_lock lock{mutex};
+    std::scoped_lock lock{mutex};
     return controller.camera_state;
 }
 
@@ -1930,7 +1932,7 @@ RingSensorForce EmulatedController::GetRingSensorForce() const {
 }
 
 const NfcState& EmulatedController::GetNfc() const {
-    std::unique_lock lock{mutex};
+    std::scoped_lock lock{mutex};
     return controller.nfc_state;
 }
 
@@ -1944,7 +1946,7 @@ NpadColor EmulatedController::GetNpadColor(u32 color) {
 }
 
 void EmulatedController::TriggerOnChange(ControllerTriggerType type, bool is_npad_service_update) {
-    std::unique_lock lock{callback_mutex};
+    std::scoped_lock lock{callback_mutex};
     for (const auto& poller_pair : callback_list) {
         const ControllerUpdateCallback& poller = poller_pair.second;
         if (!is_npad_service_update && poller.is_npad_service) {
@@ -1957,13 +1959,13 @@ void EmulatedController::TriggerOnChange(ControllerTriggerType type, bool is_npa
 }
 
 int EmulatedController::SetCallback(ControllerUpdateCallback update_callback) {
-    std::unique_lock lock{callback_mutex};
+    std::scoped_lock lock{callback_mutex};
     callback_list.insert_or_assign(last_callback_key, std::move(update_callback));
     return last_callback_key++;
 }
 
 void EmulatedController::DeleteCallback(int key) {
-    std::unique_lock lock{callback_mutex};
+    std::scoped_lock lock{callback_mutex};
     const auto& iterator = callback_list.find(key);
     if (iterator == callback_list.end()) {
         LOG_ERROR(Input, "Tried to delete non-existent callback {}", key);

src/hid_core/frontend/emulated_controller.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
 
@@ -10,7 +7,6 @@
 #include <functional>
 #include <memory>
 #include <mutex>
-#include <shared_mutex>
 #include <unordered_map>
 #include <vector>
 
@@ -630,10 +626,10 @@ private:
     StickDevices virtual_stick_devices;
     ControllerMotionDevices virtual_motion_devices;
 
-    mutable std::shared_mutex mutex;
-    mutable std::shared_mutex callback_mutex;
-    mutable std::shared_mutex npad_mutex;
-    mutable std::shared_mutex connect_mutex;
+    mutable std::mutex mutex;
+    mutable std::mutex callback_mutex;
+    mutable std::mutex npad_mutex;
+    mutable std::mutex connect_mutex;
     std::unordered_map<int, ControllerUpdateCallback> callback_list;
     int last_callback_key = 0;
 

src/input_common/drivers/joycon.cpp

@@ -1,13 +1,10 @@
-// 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
 
 #include <fmt/ranges.h>
 
 #include "common/param_package.h"
-#include <ranges>
+#include "common/polyfill_ranges.h"
 #include "common/polyfill_thread.h"
 #include "common/settings.h"
 #include "common/thread.h"

src/qt_common/shared_translation.cpp

@@ -296,7 +296,9 @@ std::unique_ptr<TranslationMap> InitializeTranslations(QObject* parent)
     INSERT(Settings,
            use_asynchronous_shaders,
            tr("Use asynchronous shader building (Hack)"),
-           tr("Enables asynchronous shader compilation, which may reduce shader stutter."));
+           tr("Enables asynchronous shader compilation, which may reduce shader stutter.\nThis "
+              "feature "
+              "is experimental."));
     INSERT(Settings, use_fast_gpu_time, QString(), QString());
     INSERT(Settings,
            fast_gpu_time,

src/shader_recompiler/frontend/ir/opcodes.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
 
@@ -11,7 +8,7 @@
 
 #include <fmt/ranges.h>
 
-#include <ranges>
+#include "common/polyfill_ranges.h"
 #include "shader_recompiler/frontend/ir/type.h"
 
 namespace Shader::IR {

src/shader_recompiler/frontend/maxwell/control_flow.cpp

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -12,7 +9,7 @@
 
 #include <fmt/ranges.h>
 
-#include <ranges>
+#include "common/polyfill_ranges.h"
 #include "shader_recompiler/exception.h"
 #include "shader_recompiler/frontend/maxwell/control_flow.h"
 #include "shader_recompiler/frontend/maxwell/decode.h"

src/shader_recompiler/frontend/maxwell/decode.cpp

@@ -9,7 +9,7 @@
 #include <memory>
 
 #include "common/common_types.h"
-#include <ranges>
+#include "common/polyfill_ranges.h"
 #include "shader_recompiler/exception.h"
 #include "shader_recompiler/frontend/maxwell/decode.h"
 #include "shader_recompiler/frontend/maxwell/opcodes.h"

src/shader_recompiler/frontend/maxwell/structured_control_flow.cpp

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -15,7 +12,7 @@
 
 #include <boost/intrusive/list.hpp>
 
-#include <ranges>
+#include "common/polyfill_ranges.h"
 #include "shader_recompiler/environment.h"
 #include "shader_recompiler/frontend/ir/basic_block.h"
 #include "shader_recompiler/frontend/ir/ir_emitter.h"

src/video_core/engines/maxwell_dma.cpp

@@ -7,7 +7,7 @@
 #include "common/algorithm.h"
 #include "common/assert.h"
 #include "common/logging/log.h"
-#include <ranges>
+#include "common/polyfill_ranges.h"
 #include "common/settings.h"
 #include "core/core.h"
 #include "video_core/engines/maxwell_3d.h"

src/video_core/renderer_opengl/gl_device.cpp

@@ -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
 
@@ -17,7 +14,7 @@
 
 #include "common/literals.h"
 #include "common/logging/log.h"
-#include <ranges>
+#include "common/polyfill_ranges.h"
 #include "common/settings.h"
 #include "shader_recompiler/stage.h"
 #include "video_core/renderer_opengl/gl_device.h"

src/video_core/renderer_vulkan/fixed_pipeline_state.cpp

@@ -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
 
@@ -10,7 +7,7 @@
 #include "common/bit_cast.h"
 #include "common/cityhash.h"
 #include "common/common_types.h"
-#include <ranges>
+#include "common/polyfill_ranges.h"
 #include "video_core/engines/draw_manager.h"
 #include "video_core/renderer_vulkan/fixed_pipeline_state.h"
 #include "video_core/renderer_vulkan/vk_state_tracker.h"

src/video_core/renderer_vulkan/present/smaa.cpp

@@ -1,13 +1,10 @@
-// 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
 
 #include <list>
 
 #include "common/assert.h"
-#include <ranges>
+#include "common/polyfill_ranges.h"
 
 #include "video_core/renderer_vulkan/present/smaa.h"
 #include "video_core/renderer_vulkan/present/util.h"

src/video_core/renderer_vulkan/present/util.cpp

@@ -5,7 +5,7 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "common/assert.h"
-#include <ranges>
+#include "common/polyfill_ranges.h"
 #include "video_core/renderer_vulkan/present/util.h"
 
 namespace Vulkan {

src/video_core/renderer_vulkan/renderer_vulkan.cpp

@@ -15,7 +15,7 @@
 #include <fmt/ranges.h>
 
 #include "common/logging/log.h"
-#include <ranges>
+#include "common/polyfill_ranges.h"
 #include "common/scope_exit.h"
 #include "common/settings.h"
 #include "core/core_timing.h"

src/video_core/renderer_vulkan/vk_descriptor_pool.cpp

@@ -10,7 +10,7 @@
 #include <vector>
 
 #include "common/common_types.h"
-#include <ranges>
+#include "common/polyfill_ranges.h"
 #include "video_core/renderer_vulkan/vk_descriptor_pool.h"
 #include "video_core/renderer_vulkan/vk_resource_pool.h"
 #include "video_core/renderer_vulkan/vk_scheduler.h"

src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp

@@ -896,6 +896,11 @@ void GraphicsPipeline::MakePipeline(VkRenderPass render_pass) {
                 .pName = "main",
                 .pSpecializationInfo = nullptr,
             });
+        /*
+        if (program[stage]->entries.uses_warps && device.IsGuestWarpSizeSupported(stage_ci.stage)) {
+            stage_ci.pNext = &subgroup_size_ci;
+        }
+        */
     }
     VkPipelineCreateFlags flags{};
     if (device.IsKhrPipelineExecutablePropertiesEnabled() && Settings::values.renderer_debug.GetValue()) {

src/video_core/renderer_vulkan/vk_master_semaphore.cpp

@@ -6,7 +6,7 @@
 
 #include <thread>
 
-#include <ranges>
+#include "common/polyfill_ranges.h"
 #include "common/settings.h"
 #include "video_core/renderer_vulkan/vk_master_semaphore.h"
 #include "video_core/vulkan_common/vulkan_device.h"

src/video_core/renderer_vulkan/vk_swapchain.cpp

@@ -10,7 +10,7 @@
 #include <vector>
 
 #include "common/logging/log.h"
-#include <ranges>
+#include "common/polyfill_ranges.h"
 #include "common/settings.h"
 #include "core/core.h"
 #include "video_core/renderer_vulkan/vk_scheduler.h"

src/video_core/shader_cache.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -15,7 +12,7 @@
 #include <vector>
 
 #include "common/common_types.h"
-#include <ranges>
+#include "common/polyfill_ranges.h"
 #include "video_core/control/channel_state_cache.h"
 #include "video_core/host1x/gpu_device_memory_manager.h"
 #include "video_core/rasterizer_interface.h"

src/video_core/shader_environment.cpp

@@ -18,7 +18,7 @@
 #include "common/fs/fs.h"
 #include "common/fs/path_util.h"
 #include "common/logging/log.h"
-#include <ranges>
+#include "common/polyfill_ranges.h"
 #include "shader_recompiler/environment.h"
 #include "video_core/engines/kepler_compute.h"
 #include "video_core/memory_manager.h"

src/video_core/texture_cache/formatter.cpp

@@ -7,7 +7,7 @@
 #include <algorithm>
 #include <string>
 
-#include <ranges>
+#include "common/polyfill_ranges.h"
 #include "video_core/texture_cache/formatter.h"
 #include "video_core/texture_cache/image_base.h"
 #include "video_core/texture_cache/image_info.h"

src/video_core/texture_cache/texture_cache_base.h

@@ -22,7 +22,7 @@
 #include "common/hash.h"
 #include "common/literals.h"
 #include "common/lru_cache.h"
-#include <ranges>
+#include "common/polyfill_ranges.h"
 #include "common/scratch_buffer.h"
 #include "common/slot_vector.h"
 #include "common/thread_worker.h"

src/video_core/textures/astc.cpp

@@ -18,7 +18,7 @@
 
 #include "common/alignment.h"
 #include "common/common_types.h"
-#include <ranges>
+#include "common/polyfill_ranges.h"
 #include "video_core/textures/astc.h"
 #include "video_core/textures/workers.h"
 

src/video_core/transform_feedback.cpp

@@ -10,7 +10,7 @@
 
 #include "common/alignment.h"
 #include "common/assert.h"
-#include <ranges>
+#include "common/polyfill_ranges.h"
 #include "shader_recompiler/shader_info.h"
 #include "video_core/transform_feedback.h"
 

src/video_core/vulkan_common/vulkan_device.cpp

@@ -15,7 +15,7 @@
 
 #include "common/assert.h"
 #include "common/literals.h"
-#include <ranges>
+#include "common/polyfill_ranges.h"
 #include "common/settings.h"
 #include "video_core/vulkan_common/nsight_aftermath_tracker.h"
 #include "video_core/vulkan_common/vma.h"

src/video_core/vulkan_common/vulkan_instance.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
 
@@ -12,7 +9,7 @@
 #include "common/common_types.h"
 #include "common/dynamic_library.h"
 #include "common/logging/log.h"
-#include <ranges>
+#include "common/polyfill_ranges.h"
 #include "core/frontend/emu_window.h"
 #include "video_core/vulkan_common/vulkan_instance.h"
 #include "video_core/vulkan_common/vulkan_wrapper.h"

src/video_core/vulkan_common/vulkan_memory_allocator.cpp

@@ -17,7 +17,7 @@
 #include "common/common_types.h"
 #include "common/literals.h"
 #include "common/logging/log.h"
-#include <ranges>
+#include "common/polyfill_ranges.h"
 #include "video_core/vulkan_common/vma.h"
 #include "video_core/vulkan_common/vulkan_device.h"
 #include "video_core/vulkan_common/vulkan_memory_allocator.h"