diff --git a/src/audio_core/audio_event.cpp b/src/audio_core/audio_event.cpp
index afd69e7842..c23ef09900 100644
--- a/src/audio_core/audio_event.cpp
+++ b/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 {
 
diff --git a/src/audio_core/common/feature_support.h b/src/audio_core/common/feature_support.h
index 91d6991416..39d50746b8 100644
--- a/src/audio_core/common/feature_support.h
+++ b/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;
diff --git a/src/audio_core/renderer/command/effect/i3dl2_reverb.cpp b/src/audio_core/renderer/command/effect/i3dl2_reverb.cpp
index be5e36d2ae..6c3dd7986a 100644
--- a/src/audio_core/renderer/command/effect/i3dl2_reverb.cpp
+++ b/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 {
 
diff --git a/src/audio_core/renderer/command/effect/reverb.cpp b/src/audio_core/renderer/command/effect/reverb.cpp
index 46b85b8945..cc61cd6ad6 100644
--- a/src/audio_core/renderer/command/effect/reverb.cpp
+++ b/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 {
 
diff --git a/src/audio_core/renderer/mix/mix_context.cpp b/src/audio_core/renderer/mix/mix_context.cpp
index 9333a29492..0253556eb8 100644
--- a/src/audio_core/renderer/mix/mix_context.cpp
+++ b/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 {
 
diff --git a/src/audio_core/renderer/voice/voice_context.cpp b/src/audio_core/renderer/voice/voice_context.cpp
index c9b4d57fdb..c3644e38b2 100644
--- a/src/audio_core/renderer/voice/voice_context.cpp
+++ b/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 {
 
diff --git a/src/common/fs/fs_util.cpp b/src/common/fs/fs_util.cpp
index 847fedec54..813a713c3b 100644
--- a/src/common/fs/fs_util.cpp
+++ b/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 {
 
diff --git a/src/common/polyfill_ranges.h b/src/common/polyfill_ranges.h
new file mode 100644
index 0000000000..512dbcbcb7
--- /dev/null
+++ b/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
diff --git a/src/common/slot_vector.h b/src/common/slot_vector.h
index 01c65306c8..3fabec9852 100644
--- a/src/common/slot_vector.h
+++ b/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 {
 
diff --git a/src/core/file_sys/content_archive.cpp b/src/core/file_sys/content_archive.cpp
index edd25644ac..6c413c2dfb 100644
--- a/src/core/file_sys/content_archive.cpp
+++ b/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"
diff --git a/src/core/hle/kernel/k_thread_local_page.h b/src/core/hle/kernel/k_thread_local_page.h
index 2d438ceb1f..813f32a7ef 100644
--- a/src/core/hle/kernel/k_thread_local_page.h
+++ b/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"
diff --git a/src/core/hle/service/acc/acc.cpp b/src/core/hle/service/acc/acc.cpp
index e8ccd483ab..73f54f89b2 100644
--- a/src/core/hle/service/acc/acc.cpp
+++ b/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) {
diff --git a/src/core/hle/service/acc/profile_manager.cpp b/src/core/hle/service/acc/profile_manager.cpp
index a4394046fa..71bf89f43f 100644
--- a/src/core/hle/service/acc/profile_manager.cpp
+++ b/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"
diff --git a/src/core/internal_network/network_interface.cpp b/src/core/internal_network/network_interface.cpp
index 7be9434afe..ae9755113a 100644
--- a/src/core/internal_network/network_interface.cpp
+++ b/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"
diff --git a/src/dynarmic/CMakeLists.txt b/src/dynarmic/CMakeLists.txt
index 6b3308fb54..331f42afba 100644
--- a/src/dynarmic/CMakeLists.txt
+++ b/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)
diff --git a/src/hid_core/frontend/emulated_controller.cpp b/src/hid_core/frontend/emulated_controller.cpp
index 0ddab89da3..e2925c0265 100644
--- a/src/hid_core/frontend/emulated_controller.cpp
+++ b/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);
diff --git a/src/hid_core/frontend/emulated_controller.h b/src/hid_core/frontend/emulated_controller.h
index 677b363157..17ad6069e0 100644
--- a/src/hid_core/frontend/emulated_controller.h
+++ b/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;
 
diff --git a/src/input_common/drivers/joycon.cpp b/src/input_common/drivers/joycon.cpp
index fb2d75e384..43f3d6078e 100644
--- a/src/input_common/drivers/joycon.cpp
+++ b/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"
diff --git a/src/qt_common/shared_translation.cpp b/src/qt_common/shared_translation.cpp
index 98a55e1fcf..4254253c2f 100644
--- a/src/qt_common/shared_translation.cpp
+++ b/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,
diff --git a/src/shader_recompiler/frontend/ir/opcodes.h b/src/shader_recompiler/frontend/ir/opcodes.h
index 3d6a3539bb..3376daf128 100644
--- a/src/shader_recompiler/frontend/ir/opcodes.h
+++ b/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 {
diff --git a/src/shader_recompiler/frontend/maxwell/control_flow.cpp b/src/shader_recompiler/frontend/maxwell/control_flow.cpp
index 7dabfbf16e..a2ad56cc49 100644
--- a/src/shader_recompiler/frontend/maxwell/control_flow.cpp
+++ b/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"
diff --git a/src/shader_recompiler/frontend/maxwell/decode.cpp b/src/shader_recompiler/frontend/maxwell/decode.cpp
index 601dcfdfa8..5afe8cbb14 100644
--- a/src/shader_recompiler/frontend/maxwell/decode.cpp
+++ b/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"
diff --git a/src/shader_recompiler/frontend/maxwell/structured_control_flow.cpp b/src/shader_recompiler/frontend/maxwell/structured_control_flow.cpp
index b5e1e70b4c..3c18f49982 100644
--- a/src/shader_recompiler/frontend/maxwell/structured_control_flow.cpp
+++ b/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"
diff --git a/src/video_core/engines/maxwell_dma.cpp b/src/video_core/engines/maxwell_dma.cpp
index 1a8a7c8dce..73a62db37d 100644
--- a/src/video_core/engines/maxwell_dma.cpp
+++ b/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"
diff --git a/src/video_core/renderer_opengl/gl_device.cpp b/src/video_core/renderer_opengl/gl_device.cpp
index f3d884f0eb..3cb7529a64 100644
--- a/src/video_core/renderer_opengl/gl_device.cpp
+++ b/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"
diff --git a/src/video_core/renderer_vulkan/fixed_pipeline_state.cpp b/src/video_core/renderer_vulkan/fixed_pipeline_state.cpp
index 7cb8acec89..39f4fc6993 100644
--- a/src/video_core/renderer_vulkan/fixed_pipeline_state.cpp
+++ b/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"
diff --git a/src/video_core/renderer_vulkan/present/smaa.cpp b/src/video_core/renderer_vulkan/present/smaa.cpp
index 686112f2f0..39645fd1d7 100644
--- a/src/video_core/renderer_vulkan/present/smaa.cpp
+++ b/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"
diff --git a/src/video_core/renderer_vulkan/present/util.cpp b/src/video_core/renderer_vulkan/present/util.cpp
index 0b1a89eec0..07b6a41c5c 100644
--- a/src/video_core/renderer_vulkan/present/util.cpp
+++ b/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 {
diff --git a/src/video_core/renderer_vulkan/renderer_vulkan.cpp b/src/video_core/renderer_vulkan/renderer_vulkan.cpp
index 6f3a0e4cd1..a91fba6725 100644
--- a/src/video_core/renderer_vulkan/renderer_vulkan.cpp
+++ b/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"
diff --git a/src/video_core/renderer_vulkan/vk_descriptor_pool.cpp b/src/video_core/renderer_vulkan/vk_descriptor_pool.cpp
index 3af9758a31..ecd955675b 100644
--- a/src/video_core/renderer_vulkan/vk_descriptor_pool.cpp
+++ b/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"
diff --git a/src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp b/src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp
index 745389213e..f5594450c2 100644
--- a/src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp
+++ b/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()) {
diff --git a/src/video_core/renderer_vulkan/vk_master_semaphore.cpp b/src/video_core/renderer_vulkan/vk_master_semaphore.cpp
index 6761127582..4e5a2ff049 100644
--- a/src/video_core/renderer_vulkan/vk_master_semaphore.cpp
+++ b/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"
diff --git a/src/video_core/renderer_vulkan/vk_swapchain.cpp b/src/video_core/renderer_vulkan/vk_swapchain.cpp
index 3b35e28c05..5a60ca5b26 100644
--- a/src/video_core/renderer_vulkan/vk_swapchain.cpp
+++ b/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"
diff --git a/src/video_core/shader_cache.h b/src/video_core/shader_cache.h
index 18b5df3bbc..fd9bf2562e 100644
--- a/src/video_core/shader_cache.h
+++ b/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"
diff --git a/src/video_core/shader_environment.cpp b/src/video_core/shader_environment.cpp
index 28357bf10b..82af6ae1cb 100644
--- a/src/video_core/shader_environment.cpp
+++ b/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"
diff --git a/src/video_core/texture_cache/formatter.cpp b/src/video_core/texture_cache/formatter.cpp
index 6e89864f45..b48afee0c5 100644
--- a/src/video_core/texture_cache/formatter.cpp
+++ b/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"
diff --git a/src/video_core/texture_cache/texture_cache_base.h b/src/video_core/texture_cache/texture_cache_base.h
index f7d22afde2..6210d63940 100644
--- a/src/video_core/texture_cache/texture_cache_base.h
+++ b/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"
diff --git a/src/video_core/textures/astc.cpp b/src/video_core/textures/astc.cpp
index b7b5f5bd4a..9574593b18 100644
--- a/src/video_core/textures/astc.cpp
+++ b/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"
 
diff --git a/src/video_core/transform_feedback.cpp b/src/video_core/transform_feedback.cpp
index a8f9da9853..f1e20b9290 100644
--- a/src/video_core/transform_feedback.cpp
+++ b/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"
 
diff --git a/src/video_core/vulkan_common/vulkan_device.cpp b/src/video_core/vulkan_common/vulkan_device.cpp
index 0e0bec2ce3..41917a1b90 100644
--- a/src/video_core/vulkan_common/vulkan_device.cpp
+++ b/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"
diff --git a/src/video_core/vulkan_common/vulkan_instance.cpp b/src/video_core/vulkan_common/vulkan_instance.cpp
index 1948e0030a..180657a75a 100644
--- a/src/video_core/vulkan_common/vulkan_instance.cpp
+++ b/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"
diff --git a/src/video_core/vulkan_common/vulkan_memory_allocator.cpp b/src/video_core/vulkan_common/vulkan_memory_allocator.cpp
index f0309117bf..119b4be1c8 100644
--- a/src/video_core/vulkan_common/vulkan_memory_allocator.cpp
+++ b/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"