[shader_recompiler] use reusable stable_vector<> instead of object pools

Signed-off-by: lizzie <lizzie@eden-emu.dev>
2026-09-03 11:13:54 +00:00 · 2026-09-01 10:11:21 +00:00
46 changed files with 925 additions and 783 deletions
@@ -63,6 +63,3 @@ artifacts
 /install*
 vulkansdk*.exe
 *.tar.zst
-
-# Build-time generated external sources
-externals/generated
@@ -214,6 +214,8 @@ if(MSVC)
 endif()

 # TODO(crueter): Cleanup, each dep that has a bundled option should allow to choose between bundled, external, system
+cmake_dependent_option(YUZU_USE_BUNDLED_SDL3 "Download bundled SDL3 build" "${MSVC}" "NOT ANDROID" OFF)
+
 option(ENABLE_CUBEB "Enables the cubeb audio backend" ON)

 set(EXT_DEFAULT OFF)
@@ -221,8 +223,6 @@ if (MSVC OR ANDROID)
    set(EXT_DEFAULT ON)
 endif()

-option(YUZU_USE_BUNDLED_SDL3 "Download bundled SDL3 build" ${EXT_DEFAULT})
-
 # ffmpeg
 option(YUZU_USE_BUNDLED_FFMPEG "Download bundled FFmpeg" ${EXT_DEFAULT})
 cmake_dependent_option(YUZU_USE_EXTERNAL_FFMPEG "Build FFmpeg from external source" "${SOLARIS}" "NOT WIN32 AND NOT ANDROID" OFF)
@@ -238,7 +238,7 @@ option(YUZU_USE_BUNDLED_SIRIT "Download bundled sirit" ${BUNDLED_SIRIT_DEFAULT})
 # FreeBSD 15+ has libusb, versions below should disable it
 cmake_dependent_option(ENABLE_LIBUSB "Enable the use of LibUSB" ON "WIN32 OR LINUX OR FREEBSD OR APPLE" OFF)

-cmake_dependent_option(ENABLE_OPENGL "Enable OpenGL" ON "NOT (WIN32 AND ARCHITECTURE_arm64) AND NOT APPLE AND NOT ANDROID" OFF)
+cmake_dependent_option(ENABLE_OPENGL "Enable OpenGL" ON "NOT (WIN32 AND ARCHITECTURE_arm64) AND NOT APPLE" OFF)
 mark_as_advanced(FORCE ENABLE_OPENGL)

 option(ENABLE_WEB_SERVICE "Enable web services (telemetry, etc.)" ON)
@@ -22,9 +22,9 @@ Eden is free, open-source, copyleft software, licensed under the terms of the [G

 - No LLM or AI usage, *period*, for patches, pull requests, issues, comments, debugging, brainstorming, etc.
  - For details on why, see the [detailed AI policy](docs/policies/AI.md).
- Usage of any form of profanity or otherwise unsavory language is prohibited.
+- Usage of any form of profanity or otherwise unsavory language is generally discouraged.
  - This is primarily because it rarely helps to actually understand what's going on.
-  - Remember that your comments should be focused and actually address what's happening.
+  - Remember that your comments should be focused and actually address what's happening. With very few exceptions, expletives are actively detrimental at best.
 - New code must follow the same general style as the surrounding codebase. Exceptions may be granted in certain cases.
 - Maintainers reserve the right to change your patches and pull requests at will. We will try to avoid this.
  - You should generally respect all decisions made by the [code owners](docs/CODEOWNERS) in your particular subsystem.
@@ -186,6 +186,12 @@
        "repo": "eden-emulator/oaknut",
        "version": "v2.0.3"
    },
+    "oboe": {
+        "bundled": true,
+        "hash": "ce4011afe7345370d4ead3b891cd69a5ef224b129535783586c0ca75051d303ed446e6c7f10bde8da31fff58d6e307f1732a3ffd03b249f9ef1fd48fd4132715",
+        "repo": "google/oboe",
+        "version": "1.10.0"
+    },
    "openssl": {
        "hash": "29002ce50cb95a4f4f1d0e9d3f684401fbd4eac34203dc2eef3b6334af5d44aa46bf788b63a6f5c139c383eafb7269ae87a58a9a3ad5912903b9773e545ccc0a",
        "min_version": "3.0.0",
@@ -239,6 +239,6 @@ find ./*/ -name "*.dll" | while read -r dll; do deps "$dll"; done

 ## RedoxOS

-Package installs randomly hang at times, you may need to restart it about 3-5 times to complete. Always do `sudo pkg update` or it will hang. Try installing each package individually.
+The package install may randomly hang at times, in which case it has to be restarted. ALWAYS do a `sudo pkg update` or the chances of it hanging will be close to 90%. If "multiple" installs fail at once, try installing 1 by 1 the packages.

-When CMake invokes certain file syscalls - most of the time it causes crashes, and corruptions on the address space. Reboot if there's a freeze over 5 minutes.
+When CMake invokes certain file syscalls - it may sometimes cause crashes or corruptions on the (kernel?) address space - so reboot the system if there is a "hang" in CMake.
@@ -38,7 +38,7 @@ Pull requests are only to be merged by core developers when properly tested and

 - The level of namespacing is generally left to the committer's choice.
 - However, we never recommend going more than two levels *except* in `hle`, in which case you may go as many as four levels depending on the specificity of your changes.
- Occasionally, up to two additional namespaces may be provided for more clarity.
+- Ocassionally, up to two additional namespaces may be provided for more clarity.
  - Changes that affect the entire project (sans CMake changes) should be namespaced as `meta`.
 - Maintainers are permitted to change namespaces at will.
 - Commits within PRs are not required to be namespaced, but it is highly recommended.
@@ -51,8 +51,8 @@ When adding new settings, use `tr("Setting:")` if the setting is meant to be a f
 - Debug settings must never be turned on by default.
 - Provide reasonable bounds (for example, a setting controlling the amount of VRAM should never be 0).
 - The description of the setting must be short and concise, if the setting "does a lot of things" consider splitting the setting into multiple if possible.
- Try to avoid excessive/redundant explanations "recommended for most users and games" can just be "(recommended)".
- Try to not write "slow/fast" options unless it clearly degrades/increases performance for a given case, as most options may modify behavior that result in different metrics across different systems. If for example the option is an "accuracy" option, writing "High" is sufficient to imply "Slow". No need to write "High (Slow)".
+- Try to avoid excessive/redundant explainations "recommended for most users and games" can just be "(recommended)".
+- Try to not write "slow/fast" options unless it clearly degrades/increases performance for a given case, as most options may modify behaviour that result in different metrics accross different systems. If for example the option is an "accuracy" option, writing "High" is sufficient to imply "Slow". No need to write "High (Slow)".

 Some examples:

@@ -91,7 +91,7 @@ You may additionally need the `Qt Extension Pack` extension if building Qt.

 # Build speedup

-If you have an HDD, use ramdisk (build in RAM); you need about 4GB for a `RelWithDebInfo` build:
+If you have an HDD, use ramdisk (build in RAM), approximately you need 4GB for a full build with debug symbols:

 ```sh
 mkdir /tmp/ramdisk
@@ -76,7 +76,7 @@ The following options are desktop only.

 - `ENABLE_LIBUSB` (ON) Enable the use of the libusb input backend (HIGHLY RECOMMENDED)
 - `ENABLE_OPENGL` (ON) Enable the OpenGL graphics backend
-  - Unavailable on Windows/ARM64 and on Android
+  - Unavailable on Windows/ARM64
  - You probably shouldn't turn this off.

 ### Qt
@@ -3,9 +3,9 @@
 > [!WARNING]
 > This guide is intended for developers ONLY. If you're looking for configuring the emulator itself, read **[the user handbook](./user/README.md)**.

-Settings have their own dedicated subsystem. Toggles can be added to gate features and fixes, as not all of them apply to every game.
+Settings on the emulator are very important, toggles and such can be used to guard and/or add branches to paths where some games may crash while others won't, and viceversa.

-However, this process can be tedious for those unfamiliar; this document serves as an outline for the settings subsystem.
+However, this process can be tedious for those unfamiliar; this document serves as an outline/documentation for the settings subsystem.

 ## Index

@@ -12,7 +12,7 @@ AMD64, aka x86_64, is the most tested and supported architecture for desktop tar

 ### Caveats

-AMD64 systems are almost always limited by the CPU. For example, a Zen 5/RX 6600 system will often hit max CPU usage before the GPU ever reaches 70% usage, with minimal exceptions (that tend to pop up only at >200fps). JIT is slow.
+AMD64 systems are almost always limited by the CPU. For example, a Zen 5/RX 6600 system will often hit max CPU usage before the GPU ever reaches 70% usage, with minimal exceptions (that tend to pop up only at >200fps). JIT is slow!

 Computers on Linux will almost always run Eden strictly better than an equivalent machine on Windows. This is largely due to the way the Linux kernel handles memory management (and the lack of Microsoft spyware).

@@ -24,7 +24,7 @@ ARM64, aka aarch64, is the only supported architecture for Android, with limited

 ### Caveats

-NCE (Native Code Execution) is currently only available on Android and (experimentally) Linux. Support for macOS is in the works, but Windows is extremely unlikely to ever happen (if you want it -- submit patches). Generally, if NCE is available, you should pretty much always use it due to the massive performance hit JIT has.
+NCE (Native Code Execution) is currently only available on Android and (experimentally) Linux. Support for macOS is in the works, but Windows is extremely unlikely to ever happen (if you want it--submit patches!). Generally, if NCE is available, you should pretty much always use it due to the massive performance hit JIT has.

 When NCE is enabled, do note that the GPU will almost always be the limiting factor. This is especially the case for Android, as well as desktops that lack dedicated GPUs; Adreno, Mali, PowerVR, etc. GPUs are generally significantly weaker relative to their respective CPUs.

@@ -44,7 +44,7 @@ Only Fedora/riscv64 has been tested, but in theory, every riscv64 distribution t

 ## Other

-Other architectures, such as SPARC, MIPS, PowerPC, Loong, and all 32-bit architectures are completely unsupported, as there is no JIT backend or emitter thereof. If you want support for it -- submit patches.
+Other architectures, such as SPARC, MIPS, PowerPC, Loong, and all 32-bit architectures are completely unsupported, as there is no JIT backend or emitter thereof. If you want support for it -- submit patches!

 IA-64 (Itanium) support is completely unknown. Existing amd64 packages will not run on IA-64 (assuming you can even find a supported Windows/Linux distribution)

@@ -106,14 +106,14 @@ Qualcomm Snapdragon SoCs are generally the most well supported.
  * A good base to compare to is the Snapdragon 865--e.g. [Tensor vs SD865](https://archive.is/M1P58)
  * Some benchmarks may be misleading due to thermal throttling OR RAM requirements.
    - For example, a Pixel 6a (Tensor G1) performs about 1/3 as well as an 865 due to its lack of RAM and poor thermals.
-  * Remember--always use a cooler if you can, and you MUST have *at least* 8GB of RAM.
+  * Remember--always use a cooler if you can, and you MUST have *at least* 8GB of RAM!
 - If you're not sure what SoC you have, check [GSMArena](https://www.gsmarena.com) - e.g. [Pixel 9 Pro](https://archive.ph/91VhA)

 Custom ROMs are recommended, *as long as* you know what you're doing.
 - For most devices, [LineageOS](https://lineageos.org/) is preferred.
 - [CalyxOS](https://calyxos.org/) is available as well.
 - For Google Pixel devices ONLY... and [soon another OEM](https://archive.ph/cPpMd)... [GrapheneOS](https://grapheneos.org/) is highly recommended.
-  * As of October 5, 2025, the Pixel 10 line is unsupported, however, [it will be](https://archive.is/viAUl) in the very near future.
+  * As of October 5, 2025, the Pixel 10 line is unsupported, however, [it will be](https://archive.is/viAUl) in the very near future!
  * Keep checking the [FAQ page](https://grapheneos.org/faq#supported-devices) for news.
 - Custom ROMs will likely be exclusively recommended in the future due to Google's upcoming [draconian](https://archive.is/hGIjZ), [anti-privacy, anti-user](https://archive.is/mc1CJ) verification requirements.

@@ -136,50 +136,49 @@ if(ENABLE_CUBEB)
    endif()
 endif()

-if (NOT YUZU_USE_BUNDLED_SDL3)
-    if (NOT WIN32)
-        # Yuzu itself needs: Atomic Audio Events Joystick Haptic Sensor Threads Timers
-        # Since 2.0.18 Atomic+Threads required for HIDAPI/libusb (see https://github.com/libsdl-org/SDL/issues/5095)
-        # Yuzu-cmd also needs: Video (depends on Loadso/Dlopen)
-        # CPUinfo also required for SDL Audio, at least until 2.28.0 (see https://github.com/libsdl-org/SDL/issues/7809)
-        set(SDL_UNUSED_SUBSYSTEMS
-            File Filesystem
-            Locale Power Render)
-        foreach(_SUB ${SDL_UNUSED_SUBSYSTEMS})
-          string(TOUPPER ${_SUB} _OPT)
-          set(SDL_${_OPT} OFF)
-        endforeach()
+if (NOT ANDROID)
+    if (NOT YUZU_USE_BUNDLED_SDL3)
+        if (NOT WIN32)
+            # Yuzu itself needs: Atomic Audio Events Joystick Haptic Sensor Threads Timers
+            # Since 2.0.18 Atomic+Threads required for HIDAPI/libusb (see https://github.com/libsdl-org/SDL/issues/5095)
+            # Yuzu-cmd also needs: Video (depends on Loadso/Dlopen)
+            # CPUinfo also required for SDL Audio, at least until 2.28.0 (see https://github.com/libsdl-org/SDL/issues/7809)
+            set(SDL_UNUSED_SUBSYSTEMS
+                File Filesystem
+                Locale Power Render)
+            foreach(_SUB ${SDL_UNUSED_SUBSYSTEMS})
+              string(TOUPPER ${_SUB} _OPT)
+              set(SDL_${_OPT} OFF)
+            endforeach()

-        set(HIDAPI ON)
-    endif()
+            set(HIDAPI ON)
+        endif()

-    if (APPLE)
-        set(SDL_FILE ON)
-    endif()
+        if (APPLE)
+            set(SDL_FILE ON)
+        endif()

-    AddJsonPackage(sdl3)
-else()
-    message(STATUS "Using bundled SDL3")
-    AddJsonPackage(sdl3-ci)
-
-    # copy sdl java sources for consumption by Gradle
-    if (ANDROID)
-        file(COPY ${SDL3_SOURCE_DIR}/java DESTINATION ${CMAKE_CURRENT_SOURCE_DIR}/generated/sdl)
-    endif()
-endif()
-
-# Normalize SDL3 link target across package variants.
-# Some SDL3 packages export only SDL3::SDL3-shared or SDL3::SDL3-static.
-if (NOT TARGET SDL3::SDL3)
-    if (TARGET SDL3::SDL3-shared)
-        add_library(SDL3::SDL3 ALIAS SDL3::SDL3-shared)
-    elseif (TARGET SDL3::SDL3-static)
-        add_library(SDL3::SDL3 ALIAS SDL3::SDL3-static)
+        AddJsonPackage(sdl3)
    else()
-        message(FATAL_ERROR "SDL3 package found, but no usable SDL3 target was exported")
+        message(STATUS "Using bundled SDL3")
+        AddJsonPackage(sdl3-ci)
+    endif()
+
+    # Normalize SDL3 link target across package variants.
+    # Some SDL3 packages export only SDL3::SDL3-shared or SDL3::SDL3-static.
+    if (NOT TARGET SDL3::SDL3)
+        if (TARGET SDL3::SDL3-shared)
+            add_library(SDL3::SDL3 ALIAS SDL3::SDL3-shared)
+        elseif (TARGET SDL3::SDL3-static)
+            add_library(SDL3::SDL3 ALIAS SDL3::SDL3-static)
+        else()
+            message(FATAL_ERROR "SDL3 package found, but no usable SDL3 target was exported")
+        endif()
    endif()
 endif()

+set(BUILD_SHARED_LIBS OFF)
+
 # SPIRV Headers
 AddJsonPackage(spirv-headers)

@@ -386,6 +385,13 @@ if (YUZU_CRASH_DUMPS AND NOT TARGET libbreakpad_client)
    endif()
 endif()

+# oboe
+if (ANDROID)
+    AddJsonPackage(oboe)
+
+    add_library(oboe::oboe ALIAS oboe)
+endif()
+
 if (APPLE)
    # moltenvk
    if (NOT YUZU_USE_BUNDLED_MOLTENVK)
@@ -272,13 +272,6 @@ android {
        resValue("string", "app_name_suffixed", "$currentName$suffix")
        resValue("string", "app_name", "Eden$suffix")
    }
-
-    sourceSets {
-        named("main") {
-            java.srcDir("${edenDir}/externals/generated/sdl/java")
-            kotlin.srcDir("${edenDir}/externals/generated/sdl/java")
-        }
-    }
 }

 idea {
@@ -9,9 +9,6 @@
 -keep class org.ini4j.spi.IniBuilder
 -keep class org.ini4j.spi.IniFormatter

-keep class org.libsdl.app.** { *; }
-keepclassmembers class org.libsdl.app.** { *; }
-
 # Suppress warnings for R8
 -dontwarn org.bouncycastle.jsse.BCSSLParameters
 -dontwarn org.bouncycastle.jsse.BCSSLSocket
@@ -16,7 +16,6 @@ import android.widget.TextView
 import androidx.annotation.Keep
 import androidx.core.net.toUri
 import com.google.android.material.dialog.MaterialAlertDialogBuilder
-import org.libsdl.app.SDL
 import java.lang.ref.WeakReference
 import org.yuzu.yuzu_emu.activities.EmulationActivity
 import org.yuzu.yuzu_emu.fragments.CoreErrorDialogFragment
@@ -53,8 +52,6 @@ object NativeLibrary {
    init {
        try {
            System.loadLibrary("yuzu-android")
-            SDL.setupJNI()
-            initJvm()
        } catch (ex: UnsatisfiedLinkError) {
            error("[NativeLibrary] $ex")
        }
@@ -370,7 +367,6 @@ object NativeLibrary {
        NetPlayManager.clearChat()
    }

-    external fun initJvm()
    external fun initMultiplayer()

    @Keep
@@ -22,7 +22,7 @@ add_library(yuzu-android SHARED
 set_property(TARGET yuzu-android PROPERTY IMPORTED_LOCATION ${FFmpeg_LIBRARY_DIR})

 target_link_libraries(yuzu-android PRIVATE audio_core common core input_common frontend_common video_core)
-target_link_libraries(yuzu-android PRIVATE android camera2ndk EGL glad jnigraphics log GLESv2)
+target_link_libraries(yuzu-android PRIVATE android camera2ndk EGL glad jnigraphics log)
 if (ARCHITECTURE_arm64)
    target_link_libraries(yuzu-android PRIVATE adrenotools)
 endif()
@@ -1730,15 +1730,6 @@ jint Java_org_yuzu_yuzu_1emu_NativeLibrary_loadAmiibo(JNIEnv* env, jobject jobj,
    return static_cast<jint>(info);
 }

-extern "C" JNIEXPORT void JNICALL
-Java_org_yuzu_yuzu_1emu_NativeLibrary_initJvm(JNIEnv *env, jclass clazz) {
-    JavaVM *vm;
-    if (env->GetJavaVM(&vm) != JNI_OK)
-        return;
-
-    Common::Android::Initialize(vm, env);
-}
-
 JNIEXPORT void JNICALL
 Java_org_yuzu_yuzu_1emu_NativeLibrary_initMultiplayer(
        JNIEnv* env, [[maybe_unused]] jobject obj) {
@@ -800,6 +800,7 @@
    <string name="theme_mode_dark">تاریک</string>

    <!-- Audio output engines -->
+    <string name="oboe">oboe</string>
    <string name="cubeb">cubeb</string>

    <!-- Anisotropic filtering options -->
@@ -465,13 +465,13 @@

    <string-array name="outputEngineEntries">
        <item>@string/auto</item>
-        <item>@string/sdl3</item>
+        <item>@string/oboe</item>
        <item>@string/cubeb</item>
        <item>@string/string_null</item>
    </string-array>
    <integer-array name="outputEngineValues">
        <item>0</item>
-        <item>2</item>
+        <item>4</item>
        <item>1</item>
        <item>3</item>
    </integer-array>
@@ -1240,7 +1240,7 @@
    <string name="theme_mode_dark">Dark</string>

    <!-- Audio output engines -->
-    <string name="sdl3" translatable="false">SDL3</string>
+    <string name="oboe" translatable="false">oboe</string>
    <string name="cubeb" translatable="false">cubeb</string>

    <!-- Anisotropic filtering options -->
@@ -238,11 +238,20 @@ if (ENABLE_CUBEB)
    target_compile_definitions(audio_core PRIVATE HAVE_CUBEB=1)
 endif()

-target_sources(audio_core PRIVATE
-    sink/sdl3_sink.cpp
-    sink/sdl3_sink.h)
+if(ANDROID)
+    target_sources(audio_core PRIVATE
+        sink/oboe_sink.cpp
+        sink/oboe_sink.h)

-target_link_libraries(audio_core PRIVATE SDL3::SDL3)
-target_compile_definitions(audio_core PRIVATE HAVE_SDL3)
+    target_link_libraries(audio_core PRIVATE oboe)
+    target_compile_definitions(audio_core PUBLIC HAVE_OBOE)
+else()
+    target_sources(audio_core PRIVATE
+        sink/sdl3_sink.cpp
+        sink/sdl3_sink.h)
+
+    target_link_libraries(audio_core PRIVATE SDL3::SDL3)
+    target_compile_definitions(audio_core PRIVATE HAVE_SDL3)
+endif()

 create_target_directory_groups(audio_core)
@@ -0,0 +1,230 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <span>
+#include <vector>
+
+#include <oboe/Oboe.h>
+
+#include "audio_core/common/common.h"
+#include "audio_core/sink/oboe_sink.h"
+#include "audio_core/sink/sink_stream.h"
+#include "common/logging.h"
+#include "common/scope_exit.h"
+#include "core/core.h"
+
+namespace AudioCore::Sink {
+
+class OboeSinkStream final : public SinkStream,
+                             public oboe::AudioStreamDataCallback,
+                             public oboe::AudioStreamErrorCallback {
+public:
+    explicit OboeSinkStream(Core::System& system_, StreamType type_, const std::string& name_,
+                            u32 system_channels_)
+        : SinkStream(system_, type_) {
+        name = name_;
+        system_channels = system_channels_;
+
+        this->OpenStream();
+    }
+
+    ~OboeSinkStream() override {
+        LOG_INFO(Audio_Sink, "Destroyed Oboe stream");
+    }
+
+    void Finalize() override {
+        this->Stop();
+        m_stream.reset();
+    }
+
+    void Start(bool resume = false) override {
+        if (!m_stream || !paused) {
+            return;
+        }
+
+        paused = false;
+
+        if (m_stream->start() != oboe::Result::OK) {
+            LOG_CRITICAL(Audio_Sink, "Error starting Oboe stream");
+        }
+    }
+
+    void Stop() override {
+        if (!m_stream || paused) {
+            return;
+        }
+
+        this->SignalPause();
+
+        if (m_stream->stop() != oboe::Result::OK) {
+            LOG_CRITICAL(Audio_Sink, "Error stopping Oboe stream");
+        }
+    }
+
+public:
+    static s32 QueryChannelCount(oboe::Direction direction) {
+        std::shared_ptr<oboe::AudioStream> temp_stream;
+        oboe::AudioStreamBuilder builder;
+
+        const auto result = ConfigureBuilder(builder, direction)->openStream(temp_stream);
+        if (result == oboe::Result::OK) {
+            return temp_stream->getChannelCount() >= 6 ? 6 : 2;
+        }
+
+        LOG_ERROR(Audio_Sink, "Failed to open {} stream. Using default channel count 2",
+                  direction == oboe::Direction::Output ? "output" : "input");
+        return 2;
+    }
+
+protected:
+    oboe::DataCallbackResult onAudioReady(oboe::AudioStream*, void* audio_data,
+                                          s32 num_buffer_frames) override {
+        const size_t num_channels = this->GetDeviceChannels();
+        const size_t frame_size = num_channels;
+        const size_t num_frames = static_cast<size_t>(num_buffer_frames);
+
+        if (type == StreamType::In) {
+            std::span<const s16> input_buffer{reinterpret_cast<const s16*>(audio_data),
+                                              num_frames * frame_size};
+            this->ProcessAudioIn(input_buffer, num_frames);
+        } else {
+            std::span<s16> output_buffer{reinterpret_cast<s16*>(audio_data),
+                                         num_frames * frame_size};
+            this->ProcessAudioOutAndRender(output_buffer, num_frames);
+        }
+
+        return oboe::DataCallbackResult::Continue;
+    }
+
+    void onErrorAfterClose(oboe::AudioStream*, oboe::Result) override {
+        LOG_INFO(Audio_Sink, "Audio stream closed, reinitializing");
+
+        if (this->OpenStream()) {
+            m_stream->start();
+        }
+    }
+
+private:
+    static oboe::AudioStreamBuilder* ConfigureBuilder(oboe::AudioStreamBuilder& builder,
+                                                      oboe::Direction direction) {
+        // TODO: investigate callback delay issues when using AAudio
+        return builder.setPerformanceMode(oboe::PerformanceMode::LowLatency)
+            ->setAudioApi(oboe::AudioApi::OpenSLES)
+            ->setDirection(direction)
+            ->setSampleRate(TargetSampleRate)
+            ->setSampleRateConversionQuality(oboe::SampleRateConversionQuality::High)
+            ->setFormat(oboe::AudioFormat::I16)
+            ->setFormatConversionAllowed(true)
+            ->setUsage(oboe::Usage::Game)
+            ->setBufferCapacityInFrames(TargetSampleCount * 2);
+    }
+
+    bool OpenStream() {
+        const auto direction = [&]() {
+            switch (type) {
+            case StreamType::In:
+                return oboe::Direction::Input;
+            case StreamType::Out:
+            case StreamType::Render:
+                return oboe::Direction::Output;
+            default:
+                ASSERT(false);
+                return oboe::Direction::Output;
+            }
+        }();
+
+        const auto expected_channels = QueryChannelCount(direction);
+        const auto expected_mask = [&]() {
+            switch (expected_channels) {
+            case 1:
+                return oboe::ChannelMask::Mono;
+            case 2:
+                return oboe::ChannelMask::Stereo;
+            case 6:
+                return oboe::ChannelMask::CM5Point1;
+            default:
+                ASSERT(false);
+                return oboe::ChannelMask::Unspecified;
+            }
+        }();
+
+        oboe::AudioStreamBuilder builder;
+        const auto result = ConfigureBuilder(builder, direction)
+                                ->setChannelCount(expected_channels)
+                                ->setChannelMask(expected_mask)
+                                ->setChannelConversionAllowed(true)
+                                ->setDataCallback(this)
+                                ->setErrorCallback(this)
+                                ->openStream(m_stream);
+        ASSERT(result == oboe::Result::OK);
+        return result == oboe::Result::OK && this->SetStreamProperties();
+    }
+
+    bool SetStreamProperties() {
+        ASSERT(m_stream);
+
+        m_stream->setBufferSizeInFrames(TargetSampleCount * 2);
+        device_channels = m_stream->getChannelCount();
+
+        const auto sample_rate = m_stream->getSampleRate();
+        const auto buffer_capacity = m_stream->getBufferCapacityInFrames();
+        const auto stream_backend =
+            m_stream->getAudioApi() == oboe::AudioApi::AAudio ? "AAudio" : "OpenSLES";
+
+        LOG_INFO(Audio_Sink, "Opened Oboe {} stream with {} channels sample rate {} capacity {}",
+                 stream_backend, device_channels, sample_rate, buffer_capacity);
+
+        return true;
+    }
+
+    std::shared_ptr<oboe::AudioStream> m_stream{};
+};
+
+OboeSink::OboeSink() {
+    // TODO: This is not generally knowable
+    // The channel count is distinct based on direction and can change
+    device_channels = OboeSinkStream::QueryChannelCount(oboe::Direction::Output);
+}
+
+OboeSink::~OboeSink() = default;
+
+SinkStream* OboeSink::AcquireSinkStream(Core::System& system, u32 system_channels,
+                                        const std::string& name, StreamType type) {
+    SinkStreamPtr& stream = sink_streams.emplace_back(
+        std::make_unique<OboeSinkStream>(system, type, name, system_channels));
+
+    return stream.get();
+}
+
+void OboeSink::CloseStream(SinkStream* to_remove) {
+    sink_streams.remove_if([&](auto& stream) { return stream.get() == to_remove; });
+}
+
+void OboeSink::CloseStreams() {
+    sink_streams.clear();
+}
+
+f32 OboeSink::GetDeviceVolume() const {
+    if (sink_streams.empty()) {
+        return 1.0f;
+    }
+
+    return sink_streams.front()->GetDeviceVolume();
+}
+
+void OboeSink::SetDeviceVolume(f32 volume) {
+    for (auto& stream : sink_streams) {
+        stream->SetDeviceVolume(volume);
+    }
+}
+
+void OboeSink::SetSystemVolume(f32 volume) {
+    for (auto& stream : sink_streams) {
+        stream->SetSystemVolume(volume);
+    }
+}
+
+} // namespace AudioCore::Sink
@@ -0,0 +1,75 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <list>
+#include <string>
+
+#include "audio_core/sink/sink.h"
+
+namespace Core {
+class System;
+}
+
+namespace AudioCore::Sink {
+class SinkStream;
+
+class OboeSink final : public Sink {
+public:
+    explicit OboeSink();
+    ~OboeSink() override;
+
+    /**
+     * Create a new sink stream.
+     *
+     * @param system          - Core system.
+     * @param system_channels - Number of channels the audio system expects.
+     *                          May differ from the device's channel count.
+     * @param name            - Name of this stream.
+     * @param type            - Type of this stream, render/in/out.
+     *
+     * @return A pointer to the created SinkStream
+     */
+    SinkStream* AcquireSinkStream(Core::System& system, u32 system_channels,
+                                  const std::string& name, StreamType type) override;
+
+    /**
+     * Close a given stream.
+     *
+     * @param stream - The stream to close.
+     */
+    void CloseStream(SinkStream* stream) override;
+
+    /**
+     * Close all streams.
+     */
+    void CloseStreams() override;
+
+    /**
+     * Get the device volume. Set from calls to the IAudioDevice service.
+     *
+     * @return Volume of the device.
+     */
+    f32 GetDeviceVolume() const override;
+
+    /**
+     * Set the device volume. Set from calls to the IAudioDevice service.
+     *
+     * @param volume - New volume of the device.
+     */
+    void SetDeviceVolume(f32 volume) override;
+
+    /**
+     * Set the system volume. Comes from the audio system using this stream.
+     *
+     * @param volume - New volume of the system.
+     */
+    void SetSystemVolume(f32 volume) override;
+
+private:
+    /// List of streams managed by this sink
+    std::list<SinkStreamPtr> sink_streams{};
+};
+
+} // namespace AudioCore::Sink
@@ -10,6 +10,9 @@
 #include <vector>

 #include "audio_core/sink/sink_details.h"
+#ifdef HAVE_OBOE
+#include "audio_core/sink/oboe_sink.h"
+#endif
 #ifdef HAVE_CUBEB
 #include "audio_core/sink/cubeb_sink.h"
 #endif
@@ -40,8 +43,24 @@ struct SinkDetails {
    /// SuitableFn is_suitable; // REVERTED FOR LatencyFn latency ABOVE - DIABLO 3 FIX
 };

+// NOTE TO PROBABLY FIX LATER FOR ANDROID - the return value "0u" for the first HAVE_OBOE
+// section below was just copied from the null section so there's a somewhat valid value
+// being returned, since the previous "true" value probably isn't compatible with the
+// previous EA-3833 code. (HAVE_OBOE was introduced in a later release.) Eventually need
+// to change "0u" for something else directly from the oboe_sink.cpp functions.
+
 // sink_details is ordered in terms of desirability, with the best choice at the top.
 constexpr SinkDetails sink_details[] = {
+#ifdef HAVE_OBOE
+    SinkDetails{
+        Settings::AudioEngine::Oboe,
+        [](std::string_view device_id) -> std::unique_ptr<Sink> {
+            return std::make_unique<OboeSink>();
+        },
+        [](bool capture) { return std::vector<std::string>{"Default"}; },
+        []() { return 0u; },
+    },
+#endif
 #ifdef HAVE_CUBEB
    SinkDetails{
        Settings::AudioEngine::Cubeb,
@@ -1,7 +1,7 @@
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later

 #include "android_common.h"
@@ -51,7 +51,7 @@ jstring ToJString(JNIEnv* env, std::u16string_view str) {
 }

 double GetJDouble(JNIEnv* env, jobject jdouble) {
-    return env->CallDoubleMethod(jdouble, GetDoubleValueMethod());
+    return env->GetDoubleField(jdouble, GetDoubleValueField());
 }

 jobject ToJDouble(JNIEnv* env, double value) {
@@ -59,7 +59,7 @@ jobject ToJDouble(JNIEnv* env, double value) {
 }

 s32 GetJInteger(JNIEnv* env, jobject jinteger) {
-    return env->CallIntMethod(jinteger, GetIntegerValueMethod());
+    return env->GetIntField(jinteger, GetIntegerValueField());
 }

 jobject ToJInteger(JNIEnv* env, s32 value) {
@@ -67,7 +67,7 @@ jobject ToJInteger(JNIEnv* env, s32 value) {
 }

 bool GetJBoolean(JNIEnv* env, jobject jboolean) {
-    return env->CallBooleanMethod(jboolean, GetBooleanValueMethod());
+    return env->GetBooleanField(jboolean, GetBooleanValueField());
 }

 jobject ToJBoolean(JNIEnv* env, bool value) {
@@ -63,15 +63,15 @@ static jfieldID s_patch_title_id_field;

 static jclass s_double_class;
 static jmethodID s_double_constructor;
-static jmethodID s_double_value_method;
+static jfieldID s_double_value_field;

 static jclass s_integer_class;
 static jmethodID s_integer_constructor;
-static jmethodID s_integer_value_method;
+static jfieldID s_integer_value_field;

 static jclass s_boolean_class;
 static jmethodID s_boolean_constructor;
-static jmethodID s_boolean_value_method;
+static jfieldID s_boolean_value_field;

 static jclass s_player_input_class;
 static jmethodID s_player_input_constructor;
@@ -103,6 +103,7 @@ static jmethodID s_clear_chat;
 static constexpr jint JNI_VERSION = JNI_VERSION_1_6;

 namespace Common::Android {
+
    JNIEnv *GetEnvForThread() {
        thread_local static struct OwnedEnv {
            OwnedEnv() {
@@ -298,8 +299,8 @@ namespace Common::Android {
        return s_double_constructor;
    }

-    jmethodID GetDoubleValueMethod() {
-        return s_double_value_method;
+    jfieldID GetDoubleValueField() {
+        return s_double_value_field;
    }

    jclass GetIntegerClass() {
@@ -310,8 +311,8 @@ namespace Common::Android {
        return s_integer_constructor;
    }

-    jmethodID GetIntegerValueMethod() {
-        return s_integer_value_method;
+    jfieldID GetIntegerValueField() {
+        return s_integer_value_field;
    }

    jclass GetBooleanClass() {
@@ -322,8 +323,8 @@ namespace Common::Android {
        return s_boolean_constructor;
    }

-    jmethodID GetBooleanValueMethod() {
-        return s_boolean_value_method;
+    jfieldID GetBooleanValueField() {
+        return s_boolean_value_field;
    }

    jclass GetPlayerInputClass() {
@@ -428,6 +429,188 @@ namespace Common::Android {

    jint InitFFmpegOnLoad(JavaVM *vm);

+    jint JNI_OnLoad(JavaVM *vm, void *reserved) {
+        s_java_vm = vm;
+        InitFFmpegOnLoad(vm);
+
+        JNIEnv *env;
+        if (vm->GetEnv(reinterpret_cast<void **>(&env), JNI_VERSION) != JNI_OK)
+            return JNI_ERR;
+
+        // Initialize Java classes
+        const jclass native_library_class = env->FindClass("org/yuzu/yuzu_emu/NativeLibrary");
+        s_native_library_class = reinterpret_cast<jclass>(env->NewGlobalRef(native_library_class));
+        s_disk_cache_progress_class = reinterpret_cast<jclass>(env->NewGlobalRef(
+                env->FindClass("org/yuzu/yuzu_emu/disk_shader_cache/DiskShaderCacheProgress")));
+        s_load_callback_stage_class = reinterpret_cast<jclass>(env->NewGlobalRef(env->FindClass(
+                "org/yuzu/yuzu_emu/disk_shader_cache/DiskShaderCacheProgress$LoadCallbackStage")));
+
+        const jclass game_dir_class = env->FindClass("org/yuzu/yuzu_emu/model/GameDir");
+        s_game_dir_class = reinterpret_cast<jclass>(env->NewGlobalRef(game_dir_class));
+        s_game_dir_constructor = env->GetMethodID(game_dir_class, "<init>",
+                                                  "(Ljava/lang/String;Z)V");
+        env->DeleteLocalRef(game_dir_class);
+
+        // Initialize methods
+        s_exit_emulation_activity =
+                env->GetStaticMethodID(s_native_library_class, "exitEmulationActivity", "(I)V");
+        s_disk_cache_load_progress =
+                env->GetStaticMethodID(s_disk_cache_progress_class, "loadProgress", "(III)V");
+        s_copy_to_storage = env->GetStaticMethodID(s_native_library_class, "copyFileToStorage",
+                                                   "(Ljava/lang/String;Ljava/lang/String;)Z");
+        s_file_exists = env->GetStaticMethodID(s_native_library_class, "exists",
+                                               "(Ljava/lang/String;)Z");
+        s_file_extension = env->GetStaticMethodID(s_native_library_class, "getFileExtension",
+                                               "(Ljava/lang/String;)Ljava/lang/String;");
+        s_on_emulation_started =
+                env->GetStaticMethodID(s_native_library_class, "onEmulationStarted", "()V");
+        s_on_emulation_stopped =
+                env->GetStaticMethodID(s_native_library_class, "onEmulationStopped", "(I)V");
+        s_on_program_changed =
+                env->GetStaticMethodID(s_native_library_class, "onProgramChanged", "(I)V");
+
+        const jclass game_class = env->FindClass("org/yuzu/yuzu_emu/model/Game");
+        s_game_class = reinterpret_cast<jclass>(env->NewGlobalRef(game_class));
+        s_game_constructor = env->GetMethodID(game_class, "<init>",
+                                              "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/"
+                                              "String;Ljava/lang/String;Ljava/lang/String;Z)V");
+        s_game_title_field = env->GetFieldID(game_class, "title", "Ljava/lang/String;");
+        s_game_path_field = env->GetFieldID(game_class, "path", "Ljava/lang/String;");
+        s_game_program_id_field = env->GetFieldID(game_class, "programId", "Ljava/lang/String;");
+        s_game_developer_field = env->GetFieldID(game_class, "developer", "Ljava/lang/String;");
+        s_game_version_field = env->GetFieldID(game_class, "version", "Ljava/lang/String;");
+        s_game_is_homebrew_field = env->GetFieldID(game_class, "isHomebrew", "Z");
+        env->DeleteLocalRef(game_class);
+
+        const jclass string_class = env->FindClass("java/lang/String");
+        s_string_class = reinterpret_cast<jclass>(env->NewGlobalRef(string_class));
+        env->DeleteLocalRef(string_class);
+
+        const jclass pair_class = env->FindClass("kotlin/Pair");
+        s_pair_class = reinterpret_cast<jclass>(env->NewGlobalRef(pair_class));
+        s_pair_constructor =
+                env->GetMethodID(pair_class, "<init>", "(Ljava/lang/Object;Ljava/lang/Object;)V");
+        s_pair_first_field = env->GetFieldID(pair_class, "first", "Ljava/lang/Object;");
+        s_pair_second_field = env->GetFieldID(pair_class, "second", "Ljava/lang/Object;");
+        env->DeleteLocalRef(pair_class);
+
+        const jclass overlay_control_data_class =
+                env->FindClass("org/yuzu/yuzu_emu/overlay/model/OverlayControlData");
+        s_overlay_control_data_class =
+                reinterpret_cast<jclass>(env->NewGlobalRef(overlay_control_data_class));
+        s_overlay_control_data_constructor =
+                env->GetMethodID(overlay_control_data_class, "<init>",
+                                 "(Ljava/lang/String;ZLkotlin/Pair;Lkotlin/Pair;Lkotlin/Pair;F)V");
+        s_overlay_control_data_id_field =
+                env->GetFieldID(overlay_control_data_class, "id", "Ljava/lang/String;");
+        s_overlay_control_data_enabled_field =
+                env->GetFieldID(overlay_control_data_class, "enabled", "Z");
+        s_overlay_control_data_landscape_position_field =
+                env->GetFieldID(overlay_control_data_class, "landscapePosition", "Lkotlin/Pair;");
+        s_overlay_control_data_portrait_position_field =
+                env->GetFieldID(overlay_control_data_class, "portraitPosition", "Lkotlin/Pair;");
+        s_overlay_control_data_foldable_position_field =
+                env->GetFieldID(overlay_control_data_class, "foldablePosition", "Lkotlin/Pair;");
+        s_overlay_control_data_individual_scale_field =
+                env->GetFieldID(overlay_control_data_class, "individualScale", "F");
+        env->DeleteLocalRef(overlay_control_data_class);
+
+        const jclass patch_class = env->FindClass("org/yuzu/yuzu_emu/model/Patch");
+        s_patch_class = reinterpret_cast<jclass>(env->NewGlobalRef(patch_class));
+        s_patch_constructor = env->GetMethodID(
+                patch_class, "<init>",
+                "(ZLjava/lang/String;Ljava/lang/String;ILjava/lang/String;Ljava/lang/String;JI)V");
+        s_patch_enabled_field = env->GetFieldID(patch_class, "enabled", "Z");
+        s_patch_name_field = env->GetFieldID(patch_class, "name", "Ljava/lang/String;");
+        s_patch_version_field = env->GetFieldID(patch_class, "version", "Ljava/lang/String;");
+        s_patch_type_field = env->GetFieldID(patch_class, "type", "I");
+        s_patch_program_id_field = env->GetFieldID(patch_class, "programId", "Ljava/lang/String;");
+        s_patch_title_id_field = env->GetFieldID(patch_class, "titleId", "Ljava/lang/String;");
+        env->DeleteLocalRef(patch_class);
+
+        const jclass double_class = env->FindClass("java/lang/Double");
+        s_double_class = reinterpret_cast<jclass>(env->NewGlobalRef(double_class));
+        s_double_constructor = env->GetMethodID(double_class, "<init>", "(D)V");
+        s_double_value_field = env->GetFieldID(double_class, "value", "D");
+        env->DeleteLocalRef(double_class);
+
+        const jclass int_class = env->FindClass("java/lang/Integer");
+        s_integer_class = reinterpret_cast<jclass>(env->NewGlobalRef(int_class));
+        s_integer_constructor = env->GetMethodID(int_class, "<init>", "(I)V");
+        s_integer_value_field = env->GetFieldID(int_class, "value", "I");
+        env->DeleteLocalRef(int_class);
+
+        const jclass boolean_class = env->FindClass("java/lang/Boolean");
+        s_boolean_class = reinterpret_cast<jclass>(env->NewGlobalRef(boolean_class));
+        s_boolean_constructor = env->GetMethodID(boolean_class, "<init>", "(Z)V");
+        s_boolean_value_field = env->GetFieldID(boolean_class, "value", "Z");
+        env->DeleteLocalRef(boolean_class);
+
+        const jclass player_input_class =
+                env->FindClass("org/yuzu/yuzu_emu/features/input/model/PlayerInput");
+        s_player_input_class = reinterpret_cast<jclass>(env->NewGlobalRef(player_input_class));
+        s_player_input_constructor = env->GetMethodID(
+                player_input_class, "<init>",
+                "(Z[Ljava/lang/String;[Ljava/lang/String;[Ljava/lang/String;ZIJJJJLjava/lang/String;Z)V");
+        s_player_input_connected_field = env->GetFieldID(player_input_class, "connected", "Z");
+        s_player_input_buttons_field =
+                env->GetFieldID(player_input_class, "buttons", "[Ljava/lang/String;");
+        s_player_input_analogs_field =
+                env->GetFieldID(player_input_class, "analogs", "[Ljava/lang/String;");
+        s_player_input_motions_field =
+                env->GetFieldID(player_input_class, "motions", "[Ljava/lang/String;");
+        s_player_input_vibration_enabled_field =
+                env->GetFieldID(player_input_class, "vibrationEnabled", "Z");
+        s_player_input_vibration_strength_field =
+                env->GetFieldID(player_input_class, "vibrationStrength", "I");
+        s_player_input_body_color_left_field =
+                env->GetFieldID(player_input_class, "bodyColorLeft", "J");
+        s_player_input_body_color_right_field =
+                env->GetFieldID(player_input_class, "bodyColorRight", "J");
+        s_player_input_button_color_left_field =
+                env->GetFieldID(player_input_class, "buttonColorLeft", "J");
+        s_player_input_button_color_right_field =
+                env->GetFieldID(player_input_class, "buttonColorRight", "J");
+        s_player_input_profile_name_field =
+                env->GetFieldID(player_input_class, "profileName", "Ljava/lang/String;");
+        s_player_input_use_system_vibrator_field =
+                env->GetFieldID(player_input_class, "useSystemVibrator", "Z");
+        env->DeleteLocalRef(player_input_class);
+
+        const jclass yuzu_input_device_interface =
+                env->FindClass("org/yuzu/yuzu_emu/features/input/YuzuInputDevice");
+        s_yuzu_input_device_interface =
+                reinterpret_cast<jclass>(env->NewGlobalRef(yuzu_input_device_interface));
+        s_yuzu_input_device_get_name =
+                env->GetMethodID(yuzu_input_device_interface, "getName", "()Ljava/lang/String;");
+        s_yuzu_input_device_get_guid =
+                env->GetMethodID(yuzu_input_device_interface, "getGUID", "()Ljava/lang/String;");
+        s_yuzu_input_device_get_port = env->GetMethodID(yuzu_input_device_interface, "getPort",
+                                                        "()I");
+        s_yuzu_input_device_get_supports_vibration =
+                env->GetMethodID(yuzu_input_device_interface, "getSupportsVibration", "()Z");
+        s_yuzu_input_device_vibrate = env->GetMethodID(yuzu_input_device_interface, "vibrate",
+                                                       "(F)V");
+        s_yuzu_input_device_get_axes =
+                env->GetMethodID(yuzu_input_device_interface, "getAxes", "()[Ljava/lang/Integer;");
+        s_yuzu_input_device_has_keys =
+                env->GetMethodID(yuzu_input_device_interface, "hasKeys", "([I)[Z");
+        env->DeleteLocalRef(yuzu_input_device_interface);
+        s_add_netplay_message = env->GetStaticMethodID(s_native_library_class, "addNetPlayMessage",
+                                                       "(ILjava/lang/String;)V");
+        s_clear_chat = env->GetStaticMethodID(s_native_library_class, "clearChat", "()V");
+
+
+        // Initialize Android Storage
+        Common::FS::Android::RegisterCallbacks(env, s_native_library_class);
+
+        // Initialize applets
+        Common::Android::SoftwareKeyboard::InitJNI(env);
+        Common::Android::WebBrowser::InitJNI(env);
+
+        return JNI_VERSION;
+    }
+
    void JNI_OnUnload(JavaVM *vm, void *reserved) {
        JNIEnv *env;
        if (vm->GetEnv(reinterpret_cast<void **>(&env), JNI_VERSION) != JNI_OK) {
@@ -462,183 +645,4 @@ namespace Common::Android {
    }
 #endif

-void Initialize(JavaVM* vm, JNIEnv *env) {
-    s_java_vm = vm;
-    InitFFmpegOnLoad(vm);
-
-    if (env->ExceptionCheck()) {
-        env->ExceptionClear();
-    }
-
-    // Initialize Java classes
-    const jclass native_library_class = env->FindClass("org/yuzu/yuzu_emu/NativeLibrary");
-    s_native_library_class = reinterpret_cast<jclass>(env->NewGlobalRef(native_library_class));
-    s_disk_cache_progress_class = reinterpret_cast<jclass>(env->NewGlobalRef(
-        env->FindClass("org/yuzu/yuzu_emu/disk_shader_cache/DiskShaderCacheProgress")));
-    s_load_callback_stage_class = reinterpret_cast<jclass>(env->NewGlobalRef(env->FindClass(
-        "org/yuzu/yuzu_emu/disk_shader_cache/DiskShaderCacheProgress$LoadCallbackStage")));
-
-    const jclass game_dir_class = env->FindClass("org/yuzu/yuzu_emu/model/GameDir");
-    s_game_dir_class = reinterpret_cast<jclass>(env->NewGlobalRef(game_dir_class));
-    s_game_dir_constructor = env->GetMethodID(game_dir_class, "<init>",
-                                              "(Ljava/lang/String;Z)V");
-    env->DeleteLocalRef(game_dir_class);
-
-    // Initialize methods
-    s_exit_emulation_activity =
-        env->GetStaticMethodID(s_native_library_class, "exitEmulationActivity", "(I)V");
-    s_disk_cache_load_progress =
-        env->GetStaticMethodID(s_disk_cache_progress_class, "loadProgress", "(III)V");
-    s_copy_to_storage = env->GetStaticMethodID(s_native_library_class, "copyFileToStorage",
-                                               "(Ljava/lang/String;Ljava/lang/String;)Z");
-    s_file_exists = env->GetStaticMethodID(s_native_library_class, "exists",
-                                           "(Ljava/lang/String;)Z");
-    s_file_extension = env->GetStaticMethodID(s_native_library_class, "getFileExtension",
-                                              "(Ljava/lang/String;)Ljava/lang/String;");
-    s_on_emulation_started =
-        env->GetStaticMethodID(s_native_library_class, "onEmulationStarted", "()V");
-    s_on_emulation_stopped =
-        env->GetStaticMethodID(s_native_library_class, "onEmulationStopped", "(I)V");
-    s_on_program_changed =
-        env->GetStaticMethodID(s_native_library_class, "onProgramChanged", "(I)V");
-
-    const jclass game_class = env->FindClass("org/yuzu/yuzu_emu/model/Game");
-    s_game_class = reinterpret_cast<jclass>(env->NewGlobalRef(game_class));
-    s_game_constructor = env->GetMethodID(game_class, "<init>",
-                                          "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/"
-                                          "String;Ljava/lang/String;Ljava/lang/String;Z)V");
-    s_game_title_field = env->GetFieldID(game_class, "title", "Ljava/lang/String;");
-    s_game_path_field = env->GetFieldID(game_class, "path", "Ljava/lang/String;");
-    s_game_program_id_field = env->GetFieldID(game_class, "programId", "Ljava/lang/String;");
-    s_game_developer_field = env->GetFieldID(game_class, "developer", "Ljava/lang/String;");
-    s_game_version_field = env->GetFieldID(game_class, "version", "Ljava/lang/String;");
-    s_game_is_homebrew_field = env->GetFieldID(game_class, "isHomebrew", "Z");
-    env->DeleteLocalRef(game_class);
-
-    const jclass string_class = env->FindClass("java/lang/String");
-    s_string_class = reinterpret_cast<jclass>(env->NewGlobalRef(string_class));
-    env->DeleteLocalRef(string_class);
-
-    const jclass pair_class = env->FindClass("kotlin/Pair");
-    s_pair_class = reinterpret_cast<jclass>(env->NewGlobalRef(pair_class));
-    s_pair_constructor =
-        env->GetMethodID(pair_class, "<init>", "(Ljava/lang/Object;Ljava/lang/Object;)V");
-    s_pair_first_field = env->GetFieldID(pair_class, "first", "Ljava/lang/Object;");
-    s_pair_second_field = env->GetFieldID(pair_class, "second", "Ljava/lang/Object;");
-    env->DeleteLocalRef(pair_class);
-
-    const jclass overlay_control_data_class =
-        env->FindClass("org/yuzu/yuzu_emu/overlay/model/OverlayControlData");
-    s_overlay_control_data_class =
-        reinterpret_cast<jclass>(env->NewGlobalRef(overlay_control_data_class));
-    s_overlay_control_data_constructor =
-        env->GetMethodID(overlay_control_data_class, "<init>",
-                         "(Ljava/lang/String;ZLkotlin/Pair;Lkotlin/Pair;Lkotlin/Pair;F)V");
-    s_overlay_control_data_id_field =
-        env->GetFieldID(overlay_control_data_class, "id", "Ljava/lang/String;");
-    s_overlay_control_data_enabled_field =
-        env->GetFieldID(overlay_control_data_class, "enabled", "Z");
-    s_overlay_control_data_landscape_position_field =
-        env->GetFieldID(overlay_control_data_class, "landscapePosition", "Lkotlin/Pair;");
-    s_overlay_control_data_portrait_position_field =
-        env->GetFieldID(overlay_control_data_class, "portraitPosition", "Lkotlin/Pair;");
-    s_overlay_control_data_foldable_position_field =
-        env->GetFieldID(overlay_control_data_class, "foldablePosition", "Lkotlin/Pair;");
-    s_overlay_control_data_individual_scale_field =
-        env->GetFieldID(overlay_control_data_class, "individualScale", "F");
-    env->DeleteLocalRef(overlay_control_data_class);
-
-    const jclass patch_class = env->FindClass("org/yuzu/yuzu_emu/model/Patch");
-    s_patch_class = reinterpret_cast<jclass>(env->NewGlobalRef(patch_class));
-    s_patch_constructor = env->GetMethodID(
-        patch_class, "<init>",
-        "(ZLjava/lang/String;Ljava/lang/String;ILjava/lang/String;Ljava/lang/String;JI)V");
-    s_patch_enabled_field = env->GetFieldID(patch_class, "enabled", "Z");
-    s_patch_name_field = env->GetFieldID(patch_class, "name", "Ljava/lang/String;");
-    s_patch_version_field = env->GetFieldID(patch_class, "version", "Ljava/lang/String;");
-    s_patch_type_field = env->GetFieldID(patch_class, "type", "I");
-    s_patch_program_id_field = env->GetFieldID(patch_class, "programId", "Ljava/lang/String;");
-    s_patch_title_id_field = env->GetFieldID(patch_class, "titleId", "Ljava/lang/String;");
-    env->DeleteLocalRef(patch_class);
-
-    const jclass double_class = env->FindClass("java/lang/Double");
-    s_double_class = reinterpret_cast<jclass>(env->NewGlobalRef(double_class));
-    s_double_constructor = env->GetMethodID(double_class, "<init>", "(D)V");
-    s_double_value_method = env->GetMethodID(double_class, "doubleValue", "()D");
-    env->DeleteLocalRef(double_class);
-
-    const jclass int_class = env->FindClass("java/lang/Integer");
-    s_integer_class = reinterpret_cast<jclass>(env->NewGlobalRef(int_class));
-    s_integer_constructor = env->GetMethodID(int_class, "<init>", "(I)V");
-    s_integer_value_method = env->GetMethodID(int_class, "intValue", "()I");
-    env->DeleteLocalRef(int_class);
-
-    const jclass boolean_class = env->FindClass("java/lang/Boolean");
-    s_boolean_class = reinterpret_cast<jclass>(env->NewGlobalRef(boolean_class));
-    s_boolean_constructor = env->GetMethodID(boolean_class, "<init>", "(Z)V");
-    s_boolean_value_method = env->GetMethodID(boolean_class, "booleanValue", "()Z");
-    env->DeleteLocalRef(boolean_class);
-
-    const jclass player_input_class =
-        env->FindClass("org/yuzu/yuzu_emu/features/input/model/PlayerInput");
-    s_player_input_class = reinterpret_cast<jclass>(env->NewGlobalRef(player_input_class));
-    s_player_input_constructor = env->GetMethodID(
-        player_input_class, "<init>",
-        "(Z[Ljava/lang/String;[Ljava/lang/String;[Ljava/lang/String;ZIJJJJLjava/lang/String;Z)V");
-    s_player_input_connected_field = env->GetFieldID(player_input_class, "connected", "Z");
-    s_player_input_buttons_field =
-        env->GetFieldID(player_input_class, "buttons", "[Ljava/lang/String;");
-    s_player_input_analogs_field =
-        env->GetFieldID(player_input_class, "analogs", "[Ljava/lang/String;");
-    s_player_input_motions_field =
-        env->GetFieldID(player_input_class, "motions", "[Ljava/lang/String;");
-    s_player_input_vibration_enabled_field =
-        env->GetFieldID(player_input_class, "vibrationEnabled", "Z");
-    s_player_input_vibration_strength_field =
-        env->GetFieldID(player_input_class, "vibrationStrength", "I");
-    s_player_input_body_color_left_field =
-        env->GetFieldID(player_input_class, "bodyColorLeft", "J");
-    s_player_input_body_color_right_field =
-        env->GetFieldID(player_input_class, "bodyColorRight", "J");
-    s_player_input_button_color_left_field =
-        env->GetFieldID(player_input_class, "buttonColorLeft", "J");
-    s_player_input_button_color_right_field =
-        env->GetFieldID(player_input_class, "buttonColorRight", "J");
-    s_player_input_profile_name_field =
-        env->GetFieldID(player_input_class, "profileName", "Ljava/lang/String;");
-    s_player_input_use_system_vibrator_field =
-        env->GetFieldID(player_input_class, "useSystemVibrator", "Z");
-    env->DeleteLocalRef(player_input_class);
-
-    const jclass yuzu_input_device_interface =
-        env->FindClass("org/yuzu/yuzu_emu/features/input/YuzuInputDevice");
-    s_yuzu_input_device_interface =
-        reinterpret_cast<jclass>(env->NewGlobalRef(yuzu_input_device_interface));
-    s_yuzu_input_device_get_name =
-        env->GetMethodID(yuzu_input_device_interface, "getName", "()Ljava/lang/String;");
-    s_yuzu_input_device_get_guid =
-        env->GetMethodID(yuzu_input_device_interface, "getGUID", "()Ljava/lang/String;");
-    s_yuzu_input_device_get_port = env->GetMethodID(yuzu_input_device_interface, "getPort",
-                                                    "()I");
-    s_yuzu_input_device_get_supports_vibration =
-        env->GetMethodID(yuzu_input_device_interface, "getSupportsVibration", "()Z");
-    s_yuzu_input_device_vibrate = env->GetMethodID(yuzu_input_device_interface, "vibrate",
-                                                   "(F)V");
-    s_yuzu_input_device_get_axes =
-        env->GetMethodID(yuzu_input_device_interface, "getAxes", "()[Ljava/lang/Integer;");
-    s_yuzu_input_device_has_keys =
-        env->GetMethodID(yuzu_input_device_interface, "hasKeys", "([I)[Z");
-    env->DeleteLocalRef(yuzu_input_device_interface);
-    s_add_netplay_message = env->GetStaticMethodID(s_native_library_class, "addNetPlayMessage",
-                                                   "(ILjava/lang/String;)V");
-    s_clear_chat = env->GetStaticMethodID(s_native_library_class, "clearChat", "()V");
-
-    // Initialize Android Storage
-    Common::FS::Android::RegisterCallbacks(env, s_native_library_class);
-
-    // Initialize applets
-    Common::Android::SoftwareKeyboard::InitJNI(env);
-    Common::Android::WebBrowser::InitJNI(env);
-}
-
 } // namespace Common::Android
@@ -11,7 +11,6 @@

 namespace Common::Android {

-void Initialize(JavaVM* vm, JNIEnv *env);
 JNIEnv* GetEnvForThread();

 /**
@@ -81,15 +80,15 @@ jfieldID GetPatchTitleIdField();

 jclass GetDoubleClass();
 jmethodID GetDoubleConstructor();
-jmethodID GetDoubleValueMethod();
+jfieldID GetDoubleValueField();

 jclass GetIntegerClass();
 jmethodID GetIntegerConstructor();
-jmethodID GetIntegerValueMethod();
+jfieldID GetIntegerValueField();

 jclass GetBooleanClass();
 jmethodID GetBooleanConstructor();
-jmethodID GetBooleanValueMethod();
+jfieldID GetBooleanValueField();

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

 ENUM(AudioMode, Mono, Stereo, Surround);
@@ -358,7 +358,7 @@ private:

        ConnectionState(boost::asio::ip::tcp::socket&& client_socket_, async_pipe signal_pipe_, Kernel::KernelCore& kernel)
            : client_socket{std::move(client_socket_)}
-            , signal_pipe{std::move(signal_pipe_)}
+            , signal_pipe{signal_pipe_}
            , active_thread{kernel, nullptr}
        {}

@@ -1021,9 +1021,6 @@ Result KProcess::Run(KernelCore& kernel, s32 priority, size_t stack_size) {

    // Suspend for debug, if we should.
    if (kernel.System().DebuggerEnabled()) {
-        LOG_INFO(Debug_GDBStub,
-                 "GDB stub enabled; suspending guest process until a debugger continues execution on port {}",
-                 Settings::values.gdbstub_port.GetValue());
        main_thread->RequestSuspend(kernel, SuspendType::Debug);
    }

@@ -114,7 +114,7 @@ std::set<s32> Android::GetDeviceAxes(JNIEnv* env, jobject& j_device) const {
    std::set<s32> axes;
    for (int i = 0; i < env->GetArrayLength(j_axes); ++i) {
        jobject axis = env->GetObjectArrayElement(j_axes, i);
-        axes.insert(env->CallIntMethod(axis, Common::Android::GetIntegerValueMethod()));
+        axes.insert(env->GetIntField(axis, Common::Android::GetIntegerValueField()));
    }
    return axes;
 }
@@ -234,13 +234,12 @@ add_library(shader_recompiler STATIC
    ir_opt/texture_pass.cpp
    ir_opt/vendor_workaround_pass.cpp
    ir_opt/verification_pass.cpp
-    object_pool.h
    profile.h
    program_header.h
    runtime_info.h
    shader_info.h
    varying_state.h
-
+    shader_pool.h
 )

 target_link_libraries(shader_recompiler PUBLIC common fmt::fmt sirit::sirit)
@@ -14,7 +14,7 @@

 namespace Shader::IR {

-Block::Block(ObjectPool<Inst>& inst_pool_) : inst_pool{&inst_pool_} {}
+Block::Block(boost::container::stable_vector<Inst>& inst_pool_) : inst_pool{&inst_pool_} {}

 Block::~Block() = default;

@@ -23,13 +23,12 @@ void Block::AppendNewInst(Opcode op, std::initializer_list<Value> args) {
 }

 Block::iterator Block::PrependNewInst(iterator insertion_point, const Inst& base_inst) {
-    Inst* const inst{inst_pool->Create(base_inst)};
+    Inst* const inst{&inst_pool->emplace_back(base_inst)};
    return instructions.insert(insertion_point, *inst);
 }

-Block::iterator Block::PrependNewInst(iterator insertion_point, Opcode op,
-                                      std::initializer_list<Value> args, u32 flags) {
-    Inst* const inst{inst_pool->Create(op, flags)};
+Block::iterator Block::PrependNewInst(iterator insertion_point, Opcode op, std::initializer_list<Value> args, u32 flags) {
+    Inst* const inst{&inst_pool->emplace_back(op, flags)};
    const auto result_it{instructions.insert(insertion_point, *inst)};

    if (inst->NumArgs() != args.size()) {
@@ -53,12 +52,10 @@ void Block::AddBranch(Block* block) {
    block->imm_predecessors.push_back(this);
 }

-static std::string BlockToIndex(const std::map<const Block*, size_t>& block_to_index,
-                                Block* block) {
-    if (const auto it{block_to_index.find(block)}; it != block_to_index.end()) {
+static std::string BlockToIndex(const std::map<const Block*, size_t>& block_to_index, Block* block) {
+    if (const auto it{block_to_index.find(block)}; it != block_to_index.end())
        return fmt::format("{{Block ${}}}", it->second);
-    }
-    return fmt::format("$<unknown block {:016x}>", reinterpret_cast<u64>(block));
+    return fmt::format("$<unknown block {:016x}>", u64(block));
 }

 static size_t InstIndex(std::map<const Inst*, size_t>& inst_to_index, size_t& inst_index,
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later

 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
@@ -13,11 +13,11 @@
 #include <bit>
 #include <numeric>
 #include <boost/intrusive/list.hpp>
+#include <boost/container/stable_vector.hpp>

 #include "common/common_types.h"
 #include "shader_recompiler/frontend/ir/condition.h"
 #include "shader_recompiler/frontend/ir/value.h"
-#include "shader_recompiler/object_pool.h"

 namespace Shader::IR {

@@ -30,7 +30,7 @@ public:
    using reverse_iterator = InstructionList::reverse_iterator;
    using const_reverse_iterator = InstructionList::const_reverse_iterator;

-    explicit Block(ObjectPool<Inst>& inst_pool_);
+    explicit Block(boost::container::stable_vector<Inst>& inst_pool_);
    ~Block();

    Block(const Block&) = delete;
@@ -170,7 +170,7 @@ public:

 private:
    /// Memory pool for instruction list
-    ObjectPool<Inst>* inst_pool;
+    boost::container::stable_vector<Inst>* inst_pool;

    /// List of instructions in this block
    InstructionList instructions;
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later

 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
@@ -174,11 +174,10 @@ bool Block::Contains(Location pc) const noexcept {
    return pc >= begin && pc < end;
 }

-Function::Function(ObjectPool<Block>& block_pool, Location start_address)
-    : entrypoint{start_address} {
+Function::Function(boost::container::stable_vector<Block>& block_pool, Location start_address) : entrypoint{start_address} {
    Label& label{labels.emplace_back()};
    label.address = start_address;
-    label.block = block_pool.Create(Block{});
+    label.block = &block_pool.emplace_back(Block{});
    label.block->begin = start_address;
    label.block->end = start_address;
    label.block->end_class = EndClass::Branch;
@@ -187,12 +186,13 @@ Function::Function(ObjectPool<Block>& block_pool, Location start_address)
    label.block->branch_false = nullptr;
 }

-CFG::CFG(Environment& env_, ObjectPool<Block>& block_pool_, Location start_address,
-         bool exits_to_dispatcher_)
-    : env{env_}, block_pool{block_pool_}, program_start{start_address}, exits_to_dispatcher{
-                                                                            exits_to_dispatcher_} {
+CFG::CFG(Environment& env_, boost::container::stable_vector<Block>& block_pool_, Location start_address, bool exits_to_dispatcher_)
+    : env{env_}
+    , block_pool{block_pool_}
+    , program_start{start_address}
+    , exits_to_dispatcher{exits_to_dispatcher_} {
    if (exits_to_dispatcher) {
-        dispatch_block = block_pool.Create(Block{});
+        dispatch_block = &block_pool.emplace_back(Block{});
        dispatch_block->begin = {};
        dispatch_block->end = {};
        dispatch_block->end_class = EndClass::Exit;
@@ -371,7 +371,7 @@ void CFG::AnalyzeCondInst(Block* block, FunctionId function_id, Location pc,
        return;
    }
    // Create a virtual block and a conditional block
-    Block* const conditional_block{block_pool.Create()};
+    Block* const conditional_block{&block_pool.emplace_back()};
    Block virtual_block{};
    virtual_block.begin = block->begin.Virtual();
    virtual_block.end = block->begin.Virtual();
@@ -546,7 +546,7 @@ Block* CFG::AddLabel(Block* block, Stack stack, Location pc, FunctionId function
    if (label_it != function.labels.end()) {
        return label_it->block;
    }
-    Block* const new_block{block_pool.Create()};
+    Block* const new_block{&block_pool.emplace_back()};
    new_block->begin = pc;
    new_block->end = pc;
    new_block->end_class = EndClass::Branch;
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 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

@@ -9,6 +12,7 @@
 #include <vector>

 #include <boost/container/small_vector.hpp>
+#include <boost/container/stable_vector.hpp>
 #include <boost/intrusive/set.hpp>

 #include "shader_recompiler/environment.h"
@@ -17,7 +21,6 @@
 #include "shader_recompiler/frontend/maxwell/instruction.h"
 #include "shader_recompiler/frontend/maxwell/location.h"
 #include "shader_recompiler/frontend/maxwell/opcodes.h"
-#include "shader_recompiler/object_pool.h"

 namespace Shader::Maxwell::Flow {

@@ -96,7 +99,7 @@ struct Label {
 };

 struct Function {
-    explicit Function(ObjectPool<Block>& block_pool, Location start_address);
+    explicit Function(boost::container::stable_vector<Block>& block_pool, Location start_address);

    Location entrypoint;
    boost::container::small_vector<Label, 16> labels;
@@ -110,8 +113,7 @@ class CFG {
    };

 public:
-    explicit CFG(Environment& env, ObjectPool<Block>& block_pool, Location start_address,
-                 bool exits_to_dispatcher = false);
+    explicit CFG(Environment& env, boost::container::stable_vector<Block>& block_pool, Location start_address, bool exits_to_dispatcher = false);

    CFG& operator=(const CFG&) = delete;
    CFG(const CFG&) = delete;
@@ -138,27 +140,20 @@ private:
    /// Inspect already visited blocks.
    /// Return true when the block has already been visited
    bool InspectVisitedBlocks(FunctionId function_id, const Label& label);
-
    AnalysisState AnalyzeInst(Block* block, FunctionId function_id, Location pc);
-
-    void AnalyzeCondInst(Block* block, FunctionId function_id, Location pc, EndClass insn_end_class,
-                         IR::Condition cond);
+    void AnalyzeCondInst(Block* block, FunctionId function_id, Location pc, EndClass insn_end_class, IR::Condition cond);

    /// Return true when the branch instruction is confirmed to be a branch
-    bool AnalyzeBranch(Block* block, FunctionId function_id, Location pc, Instruction inst,
-                       Opcode opcode);
-
-    void AnalyzeBRA(Block* block, FunctionId function_id, Location pc, Instruction inst,
-                    bool is_absolute);
-    AnalysisState AnalyzeBRX(Block* block, Location pc, Instruction inst, bool is_absolute,
-                             FunctionId function_id);
+    bool AnalyzeBranch(Block* block, FunctionId function_id, Location pc, Instruction inst, Opcode opcode);
+    void AnalyzeBRA(Block* block, FunctionId function_id, Location pc, Instruction inst, bool is_absolute);
+    AnalysisState AnalyzeBRX(Block* block, Location pc, Instruction inst, bool is_absolute, FunctionId function_id);
    AnalysisState AnalyzeEXIT(Block* block, FunctionId function_id, Location pc, Instruction inst);

    /// Return the branch target block id
    Block* AddLabel(Block* block, Stack stack, Location pc, FunctionId function_id);

    Environment& env;
-    ObjectPool<Block>& block_pool;
+    boost::container::stable_vector<Block>& block_pool;
    boost::container::small_vector<Function, 1> functions;
    Location program_start;
    bool exits_to_dispatcher{};
@@ -13,143 +13,19 @@

 #include <fmt/ranges.h>

-#include <boost/intrusive/list.hpp>
-
 #include <ranges>
+#include "shader_recompiler/shader_pool.h"
 #include "shader_recompiler/environment.h"
 #include "shader_recompiler/frontend/ir/basic_block.h"
 #include "shader_recompiler/frontend/ir/ir_emitter.h"
 #include "shader_recompiler/frontend/maxwell/structured_control_flow.h"
 #include "shader_recompiler/frontend/maxwell/translate/translate.h"
+#include "shader_recompiler/frontend/maxwell/translate_program.h"
+#include "shader_recompiler/frontend/maxwell/control_flow.h"
 #include "shader_recompiler/host_translate_info.h"
-#include "shader_recompiler/object_pool.h"

 namespace Shader::Maxwell {
 namespace {
-struct Statement;
-
-// Use normal_link because we are not guaranteed to destroy the tree in order
-using ListBaseHook =
-    boost::intrusive::list_base_hook<boost::intrusive::link_mode<boost::intrusive::normal_link>>;
-
-using Tree = boost::intrusive::list<Statement,
-                                    // Allow using Statement without a definition
-                                    boost::intrusive::base_hook<ListBaseHook>,
-                                    // Avoid linear complexity on splice, size is never called
-                                    boost::intrusive::constant_time_size<false>>;
-using Node = Tree::iterator;
-
-enum class StatementType {
-    Code,
-    Goto,
-    Label,
-    If,
-    Loop,
-    Break,
-    Return,
-    Kill,
-    Unreachable,
-    Function,
-    Identity,
-    Not,
-    Or,
-    SetVariable,
-    SetIndirectBranchVariable,
-    Variable,
-    IndirectBranchCond,
-};
-
-bool HasChildren(StatementType type) {
-    switch (type) {
-    case StatementType::If:
-    case StatementType::Loop:
-    case StatementType::Function:
-        return true;
-    default:
-        return false;
-    }
-}
-
-struct Goto {};
-struct Label {};
-struct If {};
-struct Loop {};
-struct Break {};
-struct Return {};
-struct Kill {};
-struct Unreachable {};
-struct FunctionTag {};
-struct Identity {};
-struct Not {};
-struct Or {};
-struct SetVariable {};
-struct SetIndirectBranchVariable {};
-struct Variable {};
-struct IndirectBranchCond {};
-
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 26495) // Always initialize a member variable, expected in Statement
-#endif
-struct Statement : ListBaseHook {
-    Statement(const Flow::Block* block_, Statement* up_)
-        : block{block_}, up{up_}, type{StatementType::Code} {}
-    Statement(Goto, Statement* cond_, Node label_, Statement* up_)
-        : label{label_}, cond{cond_}, up{up_}, type{StatementType::Goto} {}
-    Statement(Label, u32 id_, Statement* up_) : id{id_}, up{up_}, type{StatementType::Label} {}
-    Statement(If, Statement* cond_, Tree&& children_, Statement* up_)
-        : children{std::move(children_)}, cond{cond_}, up{up_}, type{StatementType::If} {}
-    Statement(Loop, Statement* cond_, Tree&& children_, Statement* up_)
-        : children{std::move(children_)}, cond{cond_}, up{up_}, type{StatementType::Loop} {}
-    Statement(Break, Statement* cond_, Statement* up_)
-        : cond{cond_}, up{up_}, type{StatementType::Break} {}
-    Statement(Return, Statement* up_) : up{up_}, type{StatementType::Return} {}
-    Statement(Kill, Statement* up_) : up{up_}, type{StatementType::Kill} {}
-    Statement(Unreachable, Statement* up_) : up{up_}, type{StatementType::Unreachable} {}
-    Statement(FunctionTag) : children{}, type{StatementType::Function} {}
-    Statement(Identity, IR::Condition cond_, Statement* up_)
-        : guest_cond{cond_}, up{up_}, type{StatementType::Identity} {}
-    Statement(Not, Statement* op_, Statement* up_) : op{op_}, up{up_}, type{StatementType::Not} {}
-    Statement(Or, Statement* op_a_, Statement* op_b_, Statement* up_)
-        : op_a{op_a_}, op_b{op_b_}, up{up_}, type{StatementType::Or} {}
-    Statement(SetVariable, u32 id_, Statement* op_, Statement* up_)
-        : op{op_}, id{id_}, up{up_}, type{StatementType::SetVariable} {}
-    Statement(SetIndirectBranchVariable, IR::Reg branch_reg_, s32 branch_offset_, Statement* up_)
-        : branch_offset{branch_offset_},
-          branch_reg{branch_reg_}, up{up_}, type{StatementType::SetIndirectBranchVariable} {}
-    Statement(Variable, u32 id_, Statement* up_)
-        : id{id_}, up{up_}, type{StatementType::Variable} {}
-    Statement(IndirectBranchCond, u32 location_, Statement* up_)
-        : location{location_}, up{up_}, type{StatementType::IndirectBranchCond} {}
-
-    ~Statement() {
-        if (HasChildren(type)) {
-            std::destroy_at(&children);
-        }
-    }
-
-    union {
-        const Flow::Block* block;
-        Node label;
-        Tree children;
-        IR::Condition guest_cond;
-        Statement* op;
-        Statement* op_a;
-        u32 location;
-        s32 branch_offset;
-    };
-    union {
-        Statement* cond;
-        Statement* op_b;
-        u32 id;
-        IR::Reg branch_reg;
-    };
-    Statement* up{};
-    StatementType type;
-};
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif

 std::string DumpExpr(const Statement* stmt) {
    switch (stmt->type) {
@@ -314,7 +190,9 @@ bool NeedsLift(Node goto_stmt, Node label_stmt) noexcept {

 class GotoPass {
 public:
-    explicit GotoPass(Flow::CFG& cfg, ObjectPool<Statement>& stmt_pool) : pool{stmt_pool} {
+    explicit GotoPass(Flow::CFG& cfg, ShaderPools& pools_)
+        : pools{pools_}
+    {
        std::vector gotos{BuildTree(cfg)};
        const auto end{gotos.rend()};
        for (auto goto_stmt = gotos.rbegin(); goto_stmt != end; ++goto_stmt) {
@@ -385,16 +263,14 @@ private:
        return gotos;
    }

-    void BuildTree(Flow::CFG& cfg, Flow::Function& function, u32& label_id,
-                   std::vector<Node>& gotos, Node function_insert_point,
-                   std::optional<Node> return_label) {
-        Statement* const false_stmt{pool.Create(Identity{}, IR::Condition{false}, &root_stmt)};
+    void BuildTree(Flow::CFG& cfg, Flow::Function& function, u32& label_id, std::vector<Node>& gotos, Node function_insert_point, std::optional<Node> return_label) {
+        Statement* const false_stmt{&pools.stmt.emplace_back(Identity{}, IR::Condition{false}, &root_stmt)};
        Tree& root{root_stmt.children};
        ::Common::unordered_map<Flow::Block*, Node> local_labels;
        local_labels.reserve(function.blocks.size());

        for (Flow::Block& block : function.blocks) {
-            Statement* const label{pool.Create(Label{}, label_id, &root_stmt)};
+            Statement* const label{&pools.stmt.emplace_back(Label{}, label_id, &root_stmt)};
            const Node label_it{root.insert(function_insert_point, *label)};
            local_labels.emplace(&block, label_it);
            ++label_id;
@@ -406,46 +282,39 @@ private:

            // Reset goto variables before the first block and after its respective label
            const auto make_reset_variable{[&]() -> Statement& {
-                return *pool.Create(SetVariable{}, label->id, false_stmt, &root_stmt);
+                return pools.stmt.emplace_back(SetVariable{}, label->id, false_stmt, &root_stmt);
            }};
            root.push_front(make_reset_variable());
            root.insert(ip, make_reset_variable());
-            root.insert(ip, *pool.Create(&block, &root_stmt));
+            root.insert(ip, pools.stmt.emplace_back(&block, &root_stmt));

            switch (block.end_class) {
            case Flow::EndClass::Branch: {
-                Statement* const always_cond{
-                    pool.Create(Identity{}, IR::Condition{true}, &root_stmt)};
+                Statement* const always_cond{&pools.stmt.emplace_back(Identity{}, IR::Condition{true}, &root_stmt)};
                if (block.cond == IR::Condition{true}) {
                    const Node true_label{local_labels.at(block.branch_true)};
-                    gotos.push_back(
-                        root.insert(ip, *pool.Create(Goto{}, always_cond, true_label, &root_stmt)));
+                    gotos.push_back(root.insert(ip, pools.stmt.emplace_back(Goto{}, always_cond, true_label, &root_stmt)));
                } else if (block.cond == IR::Condition{false}) {
                    const Node false_label{local_labels.at(block.branch_false)};
-                    gotos.push_back(root.insert(
-                        ip, *pool.Create(Goto{}, always_cond, false_label, &root_stmt)));
+                    gotos.push_back(root.insert(ip, pools.stmt.emplace_back(Goto{}, always_cond, false_label, &root_stmt)));
                } else {
                    const Node true_label{local_labels.at(block.branch_true)};
                    const Node false_label{local_labels.at(block.branch_false)};
-                    Statement* const true_cond{pool.Create(Identity{}, block.cond, &root_stmt)};
-                    gotos.push_back(
-                        root.insert(ip, *pool.Create(Goto{}, true_cond, true_label, &root_stmt)));
-                    gotos.push_back(root.insert(
-                        ip, *pool.Create(Goto{}, always_cond, false_label, &root_stmt)));
+                    Statement* const true_cond{&pools.stmt.emplace_back(Identity{}, block.cond, &root_stmt)};
+                    gotos.push_back(root.insert(ip, pools.stmt.emplace_back(Goto{}, true_cond, true_label, &root_stmt)));
+                    gotos.push_back(root.insert(ip, pools.stmt.emplace_back(Goto{}, always_cond, false_label, &root_stmt)));
                }
                break;
            }
            case Flow::EndClass::IndirectBranch:
-                root.insert(ip, *pool.Create(SetIndirectBranchVariable{}, block.branch_reg,
-                                             block.branch_offset, &root_stmt));
+                root.insert(ip, pools.stmt.emplace_back(SetIndirectBranchVariable{}, block.branch_reg, block.branch_offset, &root_stmt));
                for (const Flow::IndirectBranch& indirect : block.indirect_branches) {
                    const Node indirect_label{local_labels.at(indirect.block)};
-                    Statement* cond{
-                        pool.Create(IndirectBranchCond{}, indirect.address, &root_stmt)};
-                    Statement* goto_stmt{pool.Create(Goto{}, cond, indirect_label, &root_stmt)};
+                    Statement* cond{&pools.stmt.emplace_back(IndirectBranchCond{}, indirect.address, &root_stmt)};
+                    Statement* goto_stmt{&pools.stmt.emplace_back(Goto{}, cond, indirect_label, &root_stmt)};
                    gotos.push_back(root.insert(ip, *goto_stmt));
                }
-                root.insert(ip, *pool.Create(Unreachable{}, &root_stmt));
+                root.insert(ip, pools.stmt.emplace_back(Unreachable{}, &root_stmt));
                break;
            case Flow::EndClass::Call: {
                Flow::Function& call{cfg.Functions()[block.function_call]};
@@ -454,16 +323,16 @@ private:
                break;
            }
            case Flow::EndClass::Exit:
-                root.insert(ip, *pool.Create(Return{}, &root_stmt));
+                root.insert(ip, pools.stmt.emplace_back(Return{}, &root_stmt));
                break;
            case Flow::EndClass::Return: {
-                Statement* const always_cond{pool.Create(Identity{}, block.cond, &root_stmt)};
-                auto goto_stmt{pool.Create(Goto{}, always_cond, return_label.value(), &root_stmt)};
+                Statement* const always_cond{&pools.stmt.emplace_back(Identity{}, block.cond, &root_stmt)};
+                auto goto_stmt{&pools.stmt.emplace_back(Goto{}, always_cond, return_label.value(), &root_stmt)};
                gotos.push_back(root.insert(ip, *goto_stmt));
                break;
            }
            case Flow::EndClass::Kill:
-                root.insert(ip, *pool.Create(Kill{}, &root_stmt));
+                root.insert(ip, pools.stmt.emplace_back(Kill{}, &root_stmt));
                break;
            }
        }
@@ -479,8 +348,8 @@ private:
        Tree& body{goto_stmt->up->children};
        Tree if_body;
        if_body.splice(if_body.begin(), body, std::next(goto_stmt), label_stmt);
-        Statement* const cond{pool.Create(Not{}, goto_stmt->cond, &root_stmt)};
-        Statement* const if_stmt{pool.Create(If{}, cond, std::move(if_body), goto_stmt->up)};
+        Statement* const cond{&pools.stmt.emplace_back(Not{}, goto_stmt->cond, &root_stmt)};
+        Statement* const if_stmt{&pools.stmt.emplace_back(If{}, cond, std::move(if_body), goto_stmt->up)};
        UpdateTreeUp(if_stmt);
        body.insert(goto_stmt, *if_stmt);
        body.erase(goto_stmt);
@@ -491,7 +360,7 @@ private:
        Tree loop_body;
        loop_body.splice(loop_body.begin(), body, label_stmt, goto_stmt);
        Statement* const cond{goto_stmt->cond};
-        Statement* const loop{pool.Create(Loop{}, cond, std::move(loop_body), goto_stmt->up)};
+        Statement* const loop{&pools.stmt.emplace_back(Loop{}, cond, std::move(loop_body), goto_stmt->up)};
        UpdateTreeUp(loop);
        body.insert(goto_stmt, *loop);
        body.erase(goto_stmt);
@@ -516,15 +385,15 @@ private:
        const u32 label_id{label->id};

        Statement* const goto_cond{goto_stmt->cond};
-        Statement* const set_var{pool.Create(SetVariable{}, label_id, goto_cond, parent)};
+        Statement* const set_var{&pools.stmt.emplace_back(SetVariable{}, label_id, goto_cond, parent)};
        body.insert(goto_stmt, *set_var);

        Tree if_body;
        if_body.splice(if_body.begin(), body, std::next(goto_stmt), label_nested_stmt);
-        Statement* const variable{pool.Create(Variable{}, label_id, &root_stmt)};
-        Statement* const neg_var{pool.Create(Not{}, variable, &root_stmt)};
+        Statement* const variable{&pools.stmt.emplace_back(Variable{}, label_id, &root_stmt)};
+        Statement* const neg_var{&pools.stmt.emplace_back(Not{}, variable, &root_stmt)};
        if (!if_body.empty()) {
-            Statement* const if_stmt{pool.Create(If{}, neg_var, std::move(if_body), parent)};
+            Statement* const if_stmt{&pools.stmt.emplace_back(If{}, neg_var, std::move(if_body), parent)};
            UpdateTreeUp(if_stmt);
            body.insert(goto_stmt, *if_stmt);
        }
@@ -533,8 +402,7 @@ private:
        switch (label_nested_stmt->type) {
        case StatementType::If:
            // Update nested if condition
-            label_nested_stmt->cond =
-                pool.Create(Or{}, variable, label_nested_stmt->cond, &root_stmt);
+            label_nested_stmt->cond = &pools.stmt.emplace_back(Or{}, variable, label_nested_stmt->cond, &root_stmt);
            break;
        case StatementType::Loop:
            break;
@@ -542,7 +410,7 @@ private:
            throw LogicError("Invalid inward movement");
        }
        Tree& nested_tree{label_nested_stmt->children};
-        Statement* const new_goto{pool.Create(Goto{}, variable, label, &*label_nested_stmt)};
+        Statement* const new_goto{&pools.stmt.emplace_back(Goto{}, variable, label, &*label_nested_stmt)};
        return nested_tree.insert(nested_tree.begin(), *new_goto);
    }

@@ -556,16 +424,16 @@ private:
        Tree loop_body;
        loop_body.splice(loop_body.begin(), body, label_nested_stmt, goto_stmt);
        SanitizeNoBreaks(loop_body);
-        Statement* const variable{pool.Create(Variable{}, label_id, &root_stmt)};
-        Statement* const loop_stmt{pool.Create(Loop{}, variable, std::move(loop_body), parent)};
+        Statement* const variable{&pools.stmt.emplace_back(Variable{}, label_id, &root_stmt)};
+        Statement* const loop_stmt{&pools.stmt.emplace_back(Loop{}, variable, std::move(loop_body), parent)};
        UpdateTreeUp(loop_stmt);
        body.insert(goto_stmt, *loop_stmt);

-        Statement* const new_goto{pool.Create(Goto{}, variable, label, loop_stmt)};
+        Statement* const new_goto{&pools.stmt.emplace_back(Goto{}, variable, label, loop_stmt)};
        loop_stmt->children.push_front(*new_goto);
        const Node new_goto_node{loop_stmt->children.begin()};

-        Statement* const set_var{pool.Create(SetVariable{}, label_id, goto_stmt->cond, loop_stmt)};
+        Statement* const set_var{&pools.stmt.emplace_back(SetVariable{}, label_id, goto_stmt->cond, loop_stmt)};
        loop_stmt->children.push_back(*set_var);

        body.erase(goto_stmt);
@@ -577,22 +445,22 @@ private:
        Tree& body{parent->children};
        const u32 label_id{goto_stmt->label->id};
        Statement* const goto_cond{goto_stmt->cond};
-        Statement* const set_goto_var{pool.Create(SetVariable{}, label_id, goto_cond, &*parent)};
+        Statement* const set_goto_var{&pools.stmt.emplace_back(SetVariable{}, label_id, goto_cond, &*parent)};
        body.insert(goto_stmt, *set_goto_var);

        Tree if_body;
        if_body.splice(if_body.begin(), body, std::next(goto_stmt), body.end());
        if_body.pop_front();
-        Statement* const cond{pool.Create(Variable{}, label_id, &root_stmt)};
-        Statement* const neg_cond{pool.Create(Not{}, cond, &root_stmt)};
-        Statement* const if_stmt{pool.Create(If{}, neg_cond, std::move(if_body), &*parent)};
+        Statement* const cond{&pools.stmt.emplace_back(Variable{}, label_id, &root_stmt)};
+        Statement* const neg_cond{&pools.stmt.emplace_back(Not{}, cond, &root_stmt)};
+        Statement* const if_stmt{&pools.stmt.emplace_back(If{}, neg_cond, std::move(if_body), &*parent)};
        UpdateTreeUp(if_stmt);
        body.insert(goto_stmt, *if_stmt);

        body.erase(goto_stmt);

-        Statement* const new_cond{pool.Create(Variable{}, label_id, &root_stmt)};
-        Statement* const new_goto{pool.Create(Goto{}, new_cond, goto_stmt->label, parent->up)};
+        Statement* const new_cond{&pools.stmt.emplace_back(Variable{}, label_id, &root_stmt)};
+        Statement* const new_goto{&pools.stmt.emplace_back(Goto{}, new_cond, goto_stmt->label, parent->up)};
        Tree& parent_tree{parent->up->children};
        return parent_tree.insert(std::next(parent), *new_goto);
    }
@@ -602,21 +470,21 @@ private:
        Tree& body{parent->children};
        const u32 label_id{goto_stmt->label->id};
        Statement* const goto_cond{goto_stmt->cond};
-        Statement* const set_goto_var{pool.Create(SetVariable{}, label_id, goto_cond, parent)};
-        Statement* const cond{pool.Create(Variable{}, label_id, &root_stmt)};
-        Statement* const break_stmt{pool.Create(Break{}, cond, parent)};
+        Statement* const set_goto_var{&pools.stmt.emplace_back(SetVariable{}, label_id, goto_cond, parent)};
+        Statement* const cond{&pools.stmt.emplace_back(Variable{}, label_id, &root_stmt)};
+        Statement* const break_stmt{&pools.stmt.emplace_back(Break{}, cond, parent)};
        body.insert(goto_stmt, *set_goto_var);
        body.insert(goto_stmt, *break_stmt);
        body.erase(goto_stmt);

        const Node loop{Tree::s_iterator_to(*goto_stmt->up)};
-        Statement* const new_goto_cond{pool.Create(Variable{}, label_id, &root_stmt)};
-        Statement* const new_goto{pool.Create(Goto{}, new_goto_cond, goto_stmt->label, loop->up)};
+        Statement* const new_goto_cond{&pools.stmt.emplace_back(Variable{}, label_id, &root_stmt)};
+        Statement* const new_goto{&pools.stmt.emplace_back(Goto{}, new_goto_cond, goto_stmt->label, loop->up)};
        Tree& parent_tree{loop->up->children};
        return parent_tree.insert(std::next(loop), *new_goto);
    }

-    ObjectPool<Statement>& pool;
+    ShaderPools& pools;
    Statement root_stmt{FunctionTag{}};
 };

@@ -652,11 +520,11 @@ private:

 class TranslatePass {
 public:
-    TranslatePass(ObjectPool<IR::Inst>& inst_pool_, ObjectPool<IR::Block>& block_pool_,
-                  ObjectPool<Statement>& stmt_pool_, Environment& env_, Statement& root_stmt,
-                  IR::AbstractSyntaxList& syntax_list_, const HostTranslateInfo& host_info)
-        : stmt_pool{stmt_pool_}, inst_pool{inst_pool_}, block_pool{block_pool_}, env{env_},
-          syntax_list{syntax_list_} {
+    TranslatePass(ShaderPools& pools_, Environment& env_, Statement& root_stmt, IR::AbstractSyntaxList& syntax_list_, const HostTranslateInfo& host_info)
+        : pools{pools_}
+        , env{env_}
+        , syntax_list{syntax_list_}
+    {
        Visit(root_stmt, nullptr, nullptr);

        IR::Block& first_block{*syntax_list.front().data.block};
@@ -674,7 +542,7 @@ private:
            if (current_block) {
                return;
            }
-            current_block = block_pool.Create(inst_pool);
+            current_block = &pools.block.emplace_back(pools.inst);
            auto& node{syntax_list.emplace_back()};
            node.type = IR::AbstractSyntaxNode::Type::Block;
            node.data.block = current_block;
@@ -740,7 +608,7 @@ private:
                break;
            }
            case StatementType::Loop: {
-                IR::Block* const loop_header_block{block_pool.Create(inst_pool)};
+                IR::Block* const loop_header_block{&pools.block.emplace_back(pools.inst)};
                if (current_block) {
                    current_block->AddBranch(loop_header_block);
                }
@@ -748,7 +616,7 @@ private:
                header_node.type = IR::AbstractSyntaxNode::Type::Block;
                header_node.data.block = loop_header_block;

-                IR::Block* const continue_block{block_pool.Create(inst_pool)};
+                IR::Block* const continue_block{&pools.block.emplace_back(pools.inst)};
                IR::Block* const merge_block{MergeBlock(parent, stmt)};

                const size_t loop_node_index{syntax_list.size()};
@@ -814,7 +682,7 @@ private:
            }
            case StatementType::Return: {
                ensure_block();
-                IR::Block* return_block{block_pool.Create(inst_pool)};
+                IR::Block* return_block{&pools.block.emplace_back(pools.inst)};
                IR::IREmitter{*return_block}.Epilogue();
                current_block->AddBranch(return_block);

@@ -862,10 +730,10 @@ private:
        Statement* merge_stmt{TryFindForwardBlock(stmt)};
        if (!merge_stmt) {
            // Create a merge block we can visit later
-            merge_stmt = stmt_pool.Create(&dummy_flow_block, &parent);
+            merge_stmt = &pools.stmt.emplace_back(&dummy_flow_block, &parent);
            parent.children.insert(std::next(Tree::s_iterator_to(stmt)), *merge_stmt);
        }
-        return block_pool.Create(inst_pool);
+        return &pools.block.emplace_back(pools.inst);
    }

    void DemoteCombinationPass() {
@@ -973,9 +841,7 @@ private:
        asl.insert(next_it_2, demote_if_node);
    }

-    ObjectPool<Statement>& stmt_pool;
-    ObjectPool<IR::Inst>& inst_pool;
-    ObjectPool<IR::Block>& block_pool;
+    ShaderPools& pools;
    Environment& env;
    IR::AbstractSyntaxList& syntax_list;
    bool uses_demote_to_helper{};
@@ -983,15 +849,12 @@ private:
 };
 } // Anonymous namespace

-IR::AbstractSyntaxList BuildASL(ObjectPool<IR::Inst>& inst_pool, ObjectPool<IR::Block>& block_pool,
-                                Environment& env, Flow::CFG& cfg,
-                                const HostTranslateInfo& host_info) {
-    ObjectPool<Statement> stmt_pool{64};
-    GotoPass goto_pass{cfg, stmt_pool};
+IR::AbstractSyntaxList BuildASL(ShaderPools& pools, Environment& env, Flow::CFG& cfg, const HostTranslateInfo& host_info) {
+    GotoPass goto_pass{cfg, pools};
    Statement& root{goto_pass.RootStatement()};
    IR::AbstractSyntaxList syntax_list;
-    TranslatePass{inst_pool, block_pool, stmt_pool, env, root, syntax_list, host_info};
-    stmt_pool.ReleaseContents();
+    TranslatePass pass{pools, env, root, syntax_list, host_info};
+    pools.stmt.clear();
    return syntax_list;
 }

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 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

@@ -8,15 +11,13 @@
 #include "shader_recompiler/frontend/ir/basic_block.h"
 #include "shader_recompiler/frontend/ir/value.h"
 #include "shader_recompiler/frontend/maxwell/control_flow.h"
-#include "shader_recompiler/object_pool.h"

 namespace Shader {
 struct HostTranslateInfo;
 namespace Maxwell {

-[[nodiscard]] IR::AbstractSyntaxList BuildASL(ObjectPool<IR::Inst>& inst_pool,
-                                              ObjectPool<IR::Block>& block_pool, Environment& env,
-                                              Flow::CFG& cfg, const HostTranslateInfo& host_info);
+struct ShaderPools;
+[[nodiscard]] IR::AbstractSyntaxList BuildASL(ShaderPools& pools, Environment& env, Flow::CFG& cfg, const HostTranslateInfo& host_info);

 } // namespace Maxwell
 } // namespace Shader
@@ -10,6 +10,7 @@
 #include <queue>

 #include "common/settings.h"
+#include "shader_recompiler/shader_pool.h"
 #include "shader_recompiler/exception.h"
 #include "shader_recompiler/frontend/ir/basic_block.h"
 #include "shader_recompiler/frontend/ir/ir_emitter.h"
@@ -234,13 +235,12 @@ void LowerGeometryPassthrough(const IR::Program& program, const HostTranslateInf

 } // Anonymous namespace

-IR::Program TranslateProgram(ObjectPool<IR::Inst>& inst_pool, ObjectPool<IR::Block>& block_pool,
-                             Environment& env, Flow::CFG& cfg, const HostTranslateInfo& host_info) {
+IR::Program TranslateProgram(ShaderPools& pools, Environment& env, Flow::CFG& cfg, const HostTranslateInfo& host_info) {
    HostTranslateInfo normalized_host_info{host_info};
    normalized_host_info.ApplyDescriptorLimitPolicy();

    IR::Program program;
-    program.syntax_list = BuildASL(inst_pool, block_pool, env, cfg, normalized_host_info);
+    program.syntax_list = BuildASL(pools, env, cfg, host_info);
    program.blocks = GenerateBlocks(program.syntax_list);
    program.post_order_blocks = PostOrder(program.syntax_list.front());
    program.stage = env.ShaderStage();
@@ -410,11 +410,7 @@ void ConvertLegacyToGeneric(IR::Program& program, const Shader::RuntimeInfo& run
    }
 }

-IR::Program GenerateGeometryPassthrough(ObjectPool<IR::Inst>& inst_pool,
-                                        ObjectPool<IR::Block>& block_pool,
-                                        const HostTranslateInfo& host_info,
-                                        IR::Program& source_program,
-                                        Shader::OutputTopology output_topology) {
+IR::Program GenerateGeometryPassthrough(ShaderPools& pools, const HostTranslateInfo& host_info, IR::Program& source_program, Shader::OutputTopology output_topology) {
    IR::Program program;
    program.stage = Stage::Geometry;
    program.output_topology = output_topology;
@@ -426,16 +422,15 @@ IR::Program GenerateGeometryPassthrough(ObjectPool<IR::Inst>& inst_pool,
    program.info.stores.Set(IR::Attribute::Layer, true);
    program.info.stores.Set(source_program.info.emulated_layer, false);

-    IR::Block* current_block = block_pool.Create(inst_pool);
+    IR::Block* current_block = &pools.block.emplace_back(pools.inst);
    auto& node{program.syntax_list.emplace_back()};
    node.type = IR::AbstractSyntaxNode::Type::Block;
    node.data.block = current_block;

    IR::IREmitter ir{*current_block};
-    EmitGeometryPassthrough(ir, program, program.info.stores, true,
-                            source_program.info.emulated_layer);
+    EmitGeometryPassthrough(ir, program, program.info.stores, true, source_program.info.emulated_layer);

-    IR::Block* return_block{block_pool.Create(inst_pool)};
+    IR::Block* return_block{&pools.block.emplace_back(pools.inst)};
    IR::IREmitter{*return_block}.Epilogue();
    current_block->AddBranch(return_block);

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 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

@@ -7,7 +10,7 @@
 #include "shader_recompiler/frontend/ir/basic_block.h"
 #include "shader_recompiler/frontend/ir/program.h"
 #include "shader_recompiler/frontend/maxwell/control_flow.h"
-#include "shader_recompiler/object_pool.h"
+#include "shader_recompiler/frontend/maxwell/structured_control_flow.h"
 #include "shader_recompiler/runtime_info.h"

 namespace Shader {
@@ -16,22 +19,17 @@ struct HostTranslateInfo;

 namespace Shader::Maxwell {

-[[nodiscard]] IR::Program TranslateProgram(ObjectPool<IR::Inst>& inst_pool,
-                                           ObjectPool<IR::Block>& block_pool, Environment& env,
-                                           Flow::CFG& cfg, const HostTranslateInfo& host_info);
+struct ShaderPools;

-[[nodiscard]] IR::Program MergeDualVertexPrograms(IR::Program& vertex_a, IR::Program& vertex_b,
-                                                  Environment& env_vertex_b);
+[[nodiscard]] IR::Program TranslateProgram(ShaderPools& pools, Environment& env, Flow::CFG& cfg, const HostTranslateInfo& host_info);
+
+[[nodiscard]] IR::Program MergeDualVertexPrograms(IR::Program& vertex_a, IR::Program& vertex_b, Environment& env_vertex_b);

 void ConvertLegacyToGeneric(IR::Program& program, const RuntimeInfo& runtime_info);

 // Maxwell v1 and older Nvidia cards don't support setting gl_Layer from non-geometry stages.
 // This creates a workaround by setting the layer as a generic output and creating a
 // passthrough geometry shader that reads the generic and sets the layer.
-[[nodiscard]] IR::Program GenerateGeometryPassthrough(ObjectPool<IR::Inst>& inst_pool,
-                                                      ObjectPool<IR::Block>& block_pool,
-                                                      const HostTranslateInfo& host_info,
-                                                      IR::Program& source_program,
-                                                      Shader::OutputTopology output_topology);
+[[nodiscard]] IR::Program GenerateGeometryPassthrough(ShaderPools& pools, const HostTranslateInfo& host_info, IR::Program& source_program, Shader::OutputTopology output_topology);

 } // namespace Shader::Maxwell
@@ -1,106 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <memory>
-#include <type_traits>
-#include <utility>
-
-namespace Shader {
-
-template <typename T>
-    requires std::is_destructible_v<T>
-class ObjectPool {
-public:
-    explicit ObjectPool(size_t chunk_size = 8192) : new_chunk_size{chunk_size} {
-        node = &chunks.emplace_back(new_chunk_size);
-    }
-
-    template <typename... Args>
-        requires std::is_constructible_v<T, Args...>
-    [[nodiscard]] T* Create(Args&&... args) {
-        return std::construct_at(Memory(), std::forward<Args>(args)...);
-    }
-
-    void ReleaseContents() {
-        if (chunks.empty()) {
-            return;
-        }
-        Chunk& root{chunks.front()};
-        if (root.used_objects == root.num_objects) {
-            // Root chunk has been filled, squash allocations into it
-            const size_t total_objects{root.num_objects + new_chunk_size * (chunks.size() - 1)};
-            chunks.clear();
-            chunks.emplace_back(total_objects);
-        } else {
-            root.Release();
-            chunks.resize(1);
-        }
-        chunks.shrink_to_fit();
-        node = &chunks.front();
-    }
-
-private:
-    struct NonTrivialDummy {
-        NonTrivialDummy() noexcept {}
-    };
-
-    union Storage {
-        Storage() noexcept {}
-        ~Storage() noexcept {}
-
-        NonTrivialDummy dummy{};
-        T object;
-    };
-
-    struct Chunk {
-        explicit Chunk() = default;
-        explicit Chunk(size_t size)
-            : num_objects{size}, storage{std::make_unique<Storage[]>(size)} {}
-
-        Chunk& operator=(Chunk&& rhs) noexcept {
-            Release();
-            used_objects = std::exchange(rhs.used_objects, 0);
-            num_objects = std::exchange(rhs.num_objects, 0);
-            storage = std::move(rhs.storage);
-            return *this;
-        }
-
-        Chunk(Chunk&& rhs) noexcept
-            : used_objects{std::exchange(rhs.used_objects, 0)},
-              num_objects{std::exchange(rhs.num_objects, 0)}, storage{std::move(rhs.storage)} {}
-
-        ~Chunk() {
-            Release();
-        }
-
-        void Release() {
-            std::destroy_n(storage.get(), used_objects);
-            used_objects = 0;
-        }
-
-        size_t used_objects{};
-        size_t num_objects{};
-        std::unique_ptr<Storage[]> storage;
-    };
-
-    [[nodiscard]] T* Memory() {
-        Chunk* const chunk{FreeChunk()};
-        return &chunk->storage[chunk->used_objects++].object;
-    }
-
-    [[nodiscard]] Chunk* FreeChunk() {
-        if (node->used_objects != node->num_objects) {
-            return node;
-        }
-        node = &chunks.emplace_back(new_chunk_size);
-        return node;
-    }
-
-    Chunk* node{};
-    std::vector<Chunk> chunks;
-    size_t new_chunk_size{};
-};
-
-} // namespace Shader
@@ -0,0 +1,134 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include <boost/container/stable_vector.hpp>
+#include <boost/intrusive/list.hpp>
+#include "shader_recompiler/frontend/maxwell/control_flow.h"
+
+namespace Shader::Maxwell {
+
+struct Statement;
+
+// Use normal_link because we are not guaranteed to destroy the tree in order
+using ListBaseHook = boost::intrusive::list_base_hook<boost::intrusive::link_mode<boost::intrusive::normal_link>>;
+using Tree = boost::intrusive::list<Statement,
+    // Allow using Statement without a definition
+    boost::intrusive::base_hook<ListBaseHook>,
+    // Avoid linear complexity on splice, size is never called
+    boost::intrusive::constant_time_size<false>>;
+using Node = Tree::iterator;
+
+enum class StatementType {
+    Code,
+    Goto,
+    Label,
+    If,
+    Loop,
+    Break,
+    Return,
+    Kill,
+    Unreachable,
+    Function,
+    Identity,
+    Not,
+    Or,
+    SetVariable,
+    SetIndirectBranchVariable,
+    Variable,
+    IndirectBranchCond,
+};
+
+[[nodiscard]] inline bool HasChildren(StatementType type) {
+    switch (type) {
+    case StatementType::If:
+    case StatementType::Loop:
+    case StatementType::Function:
+        return true;
+    default:
+        return false;
+    }
+}
+
+struct Goto {};
+struct Label {};
+struct If {};
+struct Loop {};
+struct Break {};
+struct Return {};
+struct Kill {};
+struct Unreachable {};
+struct FunctionTag {};
+struct Identity {};
+struct Not {};
+struct Or {};
+struct SetVariable {};
+struct SetIndirectBranchVariable {};
+struct Variable {};
+struct IndirectBranchCond {};
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 26495) // Always initialize a member variable, expected in Statement
+#endif
+struct Statement : ListBaseHook {
+    Statement(const Flow::Block* block_, Statement* up_) : block{block_}, up{up_}, type{StatementType::Code} {}
+    Statement(Goto, Statement* cond_, Node label_, Statement* up_) : label{label_}, cond{cond_}, up{up_}, type{StatementType::Goto} {}
+    Statement(Label, u32 id_, Statement* up_) : id{id_}, up{up_}, type{StatementType::Label} {}
+    Statement(If, Statement* cond_, Tree&& children_, Statement* up_) : children{std::move(children_)}, cond{cond_}, up{up_}, type{StatementType::If} {}
+    Statement(Loop, Statement* cond_, Tree&& children_, Statement* up_) : children{std::move(children_)}, cond{cond_}, up{up_}, type{StatementType::Loop} {}
+    Statement(Break, Statement* cond_, Statement* up_) : cond{cond_}, up{up_}, type{StatementType::Break} {}
+    Statement(Return, Statement* up_) : up{up_}, type{StatementType::Return} {}
+    Statement(Kill, Statement* up_) : up{up_}, type{StatementType::Kill} {}
+    Statement(Unreachable, Statement* up_) : up{up_}, type{StatementType::Unreachable} {}
+    Statement(FunctionTag) : children{}, type{StatementType::Function} {}
+    Statement(Identity, IR::Condition cond_, Statement* up_) : guest_cond{cond_}, up{up_}, type{StatementType::Identity} {}
+    Statement(Not, Statement* op_, Statement* up_) : op{op_}, up{up_}, type{StatementType::Not} {}
+    Statement(Or, Statement* op_a_, Statement* op_b_, Statement* up_) : op_a{op_a_}, op_b{op_b_}, up{up_}, type{StatementType::Or} {}
+    Statement(SetVariable, u32 id_, Statement* op_, Statement* up_) : op{op_}, id{id_}, up{up_}, type{StatementType::SetVariable} {}
+    Statement(SetIndirectBranchVariable, IR::Reg branch_reg_, s32 branch_offset_, Statement* up_) : branch_offset{branch_offset_}, branch_reg{branch_reg_}, up{up_}, type{StatementType::SetIndirectBranchVariable} {}
+    Statement(Variable, u32 id_, Statement* up_) : id{id_}, up{up_}, type{StatementType::Variable} {}
+    Statement(IndirectBranchCond, u32 location_, Statement* up_) : location{location_}, up{up_}, type{StatementType::IndirectBranchCond} {}
+    ~Statement() {
+        if (HasChildren(type)) {
+            std::destroy_at(&children);
+        }
+    }
+    union {
+        const Flow::Block* block;
+        Node label;
+        Tree children;
+        IR::Condition guest_cond;
+        Statement* op;
+        Statement* op_a;
+        u32 location;
+        s32 branch_offset;
+    };
+    union {
+        Statement* cond;
+        Statement* op_b;
+        u32 id;
+        IR::Reg branch_reg;
+    };
+    Statement* up{};
+    StatementType type;
+};
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+struct ShaderPools {
+    void clear() {
+        flow_block.clear();
+        block.clear();
+        inst.clear();
+        stmt.clear();
+    }
+    boost::container::stable_vector<Shader::IR::Inst> inst{};
+    boost::container::stable_vector<Shader::IR::Block> block{};
+    boost::container::stable_vector<Shader::Maxwell::Flow::Block> flow_block{};
+    boost::container::stable_vector<Shader::Maxwell::Statement> stmt;
+};
+
+}
@@ -43,7 +43,6 @@ using Shader::Backend::GLASM::EmitGLASM;
 using Shader::Backend::GLSL::EmitGLSL;
 using Shader::Backend::SPIRV::EmitSPIRV;
 using Shader::Maxwell::ConvertLegacyToGeneric;
-using Shader::Maxwell::GenerateGeometryPassthrough;
 using Shader::Maxwell::MergeDualVertexPrograms;
 using Shader::Maxwell::TranslateProgram;
 using VideoCommon::ComputeEnvironment;
@@ -317,7 +316,7 @@ void ShaderCache::LoadDiskResources(u64 title_id, std::stop_token stop_loading,
        ComputePipelineKey key;
        file.read(reinterpret_cast<char*>(&key), sizeof(key));
        queue_work([this, key, env_ = std::move(env), &state, &callback](Context* ctx) mutable {
-            ctx->pools.ReleaseContents();
+            ctx->pools.clear();
            auto pipeline{CreateComputePipeline(ctx->pools, key, env_, true)};
            std::scoped_lock lock{state.mutex};
            if (pipeline) {
@@ -338,7 +337,7 @@ void ShaderCache::LoadDiskResources(u64 title_id, std::stop_token stop_loading,
            for (auto& env : envs_) {
                env_ptrs.push_back(&env);
            }
-            ctx->pools.ReleaseContents();
+            ctx->pools.clear();
            auto pipeline{CreateGraphicsPipeline(ctx->pools, key, MakeSpan(env_ptrs), false, true)};
            std::scoped_lock lock{state.mutex};
            if (pipeline) {
@@ -448,9 +447,8 @@ std::unique_ptr<GraphicsPipeline> ShaderCache::CreateGraphicsPipeline() {
    GraphicsEnvironments environments;
    GetGraphicsEnvironments(environments, graphics_key.unique_hashes);

-    main_pools.ReleaseContents();
-    auto pipeline{CreateGraphicsPipeline(main_pools, graphics_key, environments.Span(),
-                                         use_asynchronous_shaders)};
+    main_pools.clear();
+    auto pipeline{CreateGraphicsPipeline(main_pools, graphics_key, environments.Span(), use_asynchronous_shaders)};
    if (!pipeline || shader_cache_filename.empty()) {
        return pipeline;
    }
@@ -464,10 +462,7 @@ std::unique_ptr<GraphicsPipeline> ShaderCache::CreateGraphicsPipeline() {
    return pipeline;
 }

-std::unique_ptr<GraphicsPipeline> ShaderCache::CreateGraphicsPipeline(
-    ShaderContext::ShaderPools& pools, const GraphicsPipelineKey& key,
-    std::span<Shader::Environment* const> envs, bool use_shader_workers,
-    bool force_context_flush) try {
+std::unique_ptr<GraphicsPipeline> ShaderCache::CreateGraphicsPipeline(Shader::Maxwell::ShaderPools& pools, const GraphicsPipelineKey& key, std::span<Shader::Environment* const> envs, bool use_shader_workers, bool force_context_flush) try {
    auto hash = key.Hash();
    LOG_INFO(Render_OpenGL, "{:#016x}", hash);
    size_t env_index{};
@@ -480,12 +475,10 @@ std::unique_ptr<GraphicsPipeline> ShaderCache::CreateGraphicsPipeline(
    Shader::IR::Program* layer_source_program{};

    for (size_t index = 0; index < Maxwell::MaxShaderProgram; ++index) {
-        const bool is_emulated_stage = layer_source_program != nullptr
-            && index == u32(Maxwell::ShaderType::Geometry);
+        const bool is_emulated_stage = layer_source_program != nullptr && index == u32(Maxwell::ShaderType::Geometry);
        if (key.unique_hashes[index] == 0 && is_emulated_stage) {
            auto topology = MaxwellToOutputTopology(key.gs_input_topology);
-            programs[index] = GenerateGeometryPassthrough(pools.inst, pools.block, host_info,
-                                                          *layer_source_program, topology);
+            programs[index] = Shader::Maxwell::GenerateGeometryPassthrough(pools, host_info, *layer_source_program, topology);
            continue;
        }
        if (key.unique_hashes[index] == 0) {
@@ -503,13 +496,13 @@ std::unique_ptr<GraphicsPipeline> ShaderCache::CreateGraphicsPipeline(

        if (!uses_vertex_a || index != 1) {
            // Normal path
-            programs[index] = TranslateProgram(pools.inst, pools.block, env, cfg, host_info);
+            programs[index] = TranslateProgram(pools, env, cfg, host_info);

            total_storage_buffers += Shader::NumDescriptors(programs[index].info.storage_buffers_descriptors);
        } else {
            // VertexB path when VertexA is present.
            auto& program_va{programs[0]};
-            auto program_vb{TranslateProgram(pools.inst, pools.block, env, cfg, host_info)};
+            auto program_vb{TranslateProgram(pools, env, cfg, host_info)};
            total_storage_buffers += Shader::NumDescriptors(program_vb.info.storage_buffers_descriptors);
            programs[index] = MergeDualVertexPrograms(program_va, program_vb, env);
        }
@@ -576,7 +569,7 @@ std::unique_ptr<ComputePipeline> ShaderCache::CreateComputePipeline(
    ComputeEnvironment env{*kepler_compute, *gpu_memory, program_base, qmd.program_start};
    env.SetCachedSize(shader->size_bytes);

-    main_pools.ReleaseContents();
+    main_pools.clear();
    auto pipeline{CreateComputePipeline(main_pools, key, env)};
    if (!pipeline || shader_cache_filename.empty()) {
        return pipeline;
@@ -586,9 +579,7 @@ std::unique_ptr<ComputePipeline> ShaderCache::CreateComputePipeline(
    return pipeline;
 }

-std::unique_ptr<ComputePipeline> ShaderCache::CreateComputePipeline(
-    ShaderContext::ShaderPools& pools, const ComputePipelineKey& key, Shader::Environment& env,
-    bool force_context_flush) try {
+std::unique_ptr<ComputePipeline> ShaderCache::CreateComputePipeline(Shader::Maxwell::ShaderPools& pools, const ComputePipelineKey& key, Shader::Environment& env, bool force_context_flush) try {
    auto hash = key.Hash();
    LOG_INFO(Render_OpenGL, "{:#016x}", hash);

@@ -598,7 +589,7 @@ std::unique_ptr<ComputePipeline> ShaderCache::CreateComputePipeline(
        env.Dump(hash, key.unique_hash);
    }

-    auto program{TranslateProgram(pools.inst, pools.block, env, cfg, host_info)};
+    auto program{TranslateProgram(pools, env, cfg, host_info)};
    const u32 num_storage_buffers{Shader::NumDescriptors(program.info.storage_buffers_descriptors)};
    Shader::RuntimeInfo info;
    info.glasm_use_storage_buffers = num_storage_buffers <= device.GetMaxGLASMStorageBufferBlocks();
@@ -12,6 +12,7 @@
 #include "common/common_types.h"
 #include "common/thread_worker.h"
 #include "shader_recompiler/host_translate_info.h"
+#include "shader_recompiler/shader_pool.h"
 #include "shader_recompiler/profile.h"
 #include "video_core/renderer_opengl/gl_compute_pipeline.h"
 #include "video_core/renderer_opengl/gl_graphics_pipeline.h"
@@ -51,20 +52,9 @@ private:
    [[nodiscard]] GraphicsPipeline* BuiltPipeline(GraphicsPipeline* pipeline) const noexcept;

    std::unique_ptr<GraphicsPipeline> CreateGraphicsPipeline();
-
-    std::unique_ptr<GraphicsPipeline> CreateGraphicsPipeline(
-        ShaderContext::ShaderPools& pools, const GraphicsPipelineKey& key,
-        std::span<Shader::Environment* const> envs, bool use_shader_workers,
-        bool force_context_flush = false);
-
-    std::unique_ptr<ComputePipeline> CreateComputePipeline(const ComputePipelineKey& key,
-                                                           const VideoCommon::ShaderInfo* shader);
-
-    std::unique_ptr<ComputePipeline> CreateComputePipeline(ShaderContext::ShaderPools& pools,
-                                                           const ComputePipelineKey& key,
-                                                           Shader::Environment& env,
-                                                           bool force_context_flush = false);
-
+    std::unique_ptr<GraphicsPipeline> CreateGraphicsPipeline(Shader::Maxwell::ShaderPools& pools, const GraphicsPipelineKey& key, std::span<Shader::Environment* const> envs, bool use_shader_workers, bool force_context_flush = false);
+    std::unique_ptr<ComputePipeline> CreateComputePipeline(const ComputePipelineKey& key, const VideoCommon::ShaderInfo* shader);
+    std::unique_ptr<ComputePipeline> CreateComputePipeline(Shader::Maxwell::ShaderPools& pools, const ComputePipelineKey& key, Shader::Environment& env, bool force_context_flush = false);
    std::unique_ptr<ShaderWorker> CreateWorkers() const;

    Core::Frontend::EmuWindow& emu_window;
@@ -80,7 +70,7 @@ private:
    GraphicsPipelineKey graphics_key{};
    GraphicsPipeline* current_pipeline{};

-    ShaderContext::ShaderPools main_pools;
+    Shader::Maxwell::ShaderPools main_pools;
    ::Common::unordered_map<GraphicsPipelineKey, std::unique_ptr<GraphicsPipeline>> graphics_cache;
    ::Common::unordered_map<ComputePipelineKey, std::unique_ptr<ComputePipeline>> compute_cache;

@@ -1,33 +1,26 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

 #pragma once

+#include <boost/container/stable_vector.hpp>
 #include "core/frontend/emu_window.h"
 #include "core/frontend/graphics_context.h"
 #include "shader_recompiler/frontend/ir/basic_block.h"
 #include "shader_recompiler/frontend/maxwell/control_flow.h"
+#include "shader_recompiler/frontend/maxwell/structured_control_flow.h"
+#include "shader_recompiler/frontend/maxwell/translate_program.h"

 namespace OpenGL::ShaderContext {
-struct ShaderPools {
-    void ReleaseContents() {
-        flow_block.ReleaseContents();
-        block.ReleaseContents();
-        inst.ReleaseContents();
-    }
-
-    Shader::ObjectPool<Shader::IR::Inst> inst{8192};
-    Shader::ObjectPool<Shader::IR::Block> block{32};
-    Shader::ObjectPool<Shader::Maxwell::Flow::Block> flow_block{32};
-};

 struct Context {
-    explicit Context(Core::Frontend::EmuWindow& emu_window)
-        : gl_context{emu_window.CreateSharedContext()}, scoped{*gl_context} {}
-
+    explicit Context(Core::Frontend::EmuWindow& emu_window) : gl_context{emu_window.CreateSharedContext()}, scoped{*gl_context} {}
    std::unique_ptr<Core::Frontend::GraphicsContext> gl_context;
    Core::Frontend::GraphicsContext::Scoped scoped;
-    ShaderPools pools;
+    Shader::Maxwell::ShaderPools pools;
 };

 } // namespace OpenGL::ShaderContext
@@ -52,15 +52,6 @@
 namespace Vulkan {

 namespace {
-using Shader::Backend::SPIRV::EmitSPIRV;
-using Shader::Maxwell::ConvertLegacyToGeneric;
-using Shader::Maxwell::GenerateGeometryPassthrough;
-using Shader::Maxwell::MergeDualVertexPrograms;
-using Shader::Maxwell::TranslateProgram;
-using VideoCommon::ComputeEnvironment;
-using VideoCommon::FileEnvironment;
-using VideoCommon::GenericEnvironment;
-using VideoCommon::GraphicsEnvironment;

 constexpr u32 CACHE_VERSION = 18;
 constexpr size_t VULKAN_CACHE_FLUSH_PIPELINES = 128;
@@ -627,12 +618,12 @@ void PipelineCache::LoadDiskResources(u64 title_id, std::stop_token stop_loading
    if (device.IsKhrPipelineExecutablePropertiesEnabled()) {
        state.statistics = std::make_unique<PipelineStatistics>(device);
    }
-    const auto load_compute{[&](std::ifstream& file, FileEnvironment env) {
+    const auto load_compute{[&](std::ifstream& file, VideoCommon::FileEnvironment env) {
        ComputePipelineCacheKey key;
        file.read(reinterpret_cast<char*>(&key), sizeof(key));

        workers.QueueWork([this, key, env_ = std::move(env), &state, &callback]() mutable {
-            ShaderPools pools;
+            Shader::Maxwell::ShaderPools pools;
            auto pipeline{CreateComputePipeline(pools, key, env_, state.statistics.get(), false)};
            std::scoped_lock lock{state.mutex};
            if (pipeline) {
@@ -645,7 +636,7 @@ void PipelineCache::LoadDiskResources(u64 title_id, std::stop_token stop_loading
        });
        ++state.total;
    }};
-    const auto load_graphics{[&](std::ifstream& file, std::vector<FileEnvironment> envs) {
+    const auto load_graphics{[&](std::ifstream& file, std::vector<VideoCommon::FileEnvironment> envs) {
        GraphicsPipelineCacheKey key;
        file.read(reinterpret_cast<char*>(&key), sizeof(key));

@@ -678,7 +669,7 @@ void PipelineCache::LoadDiskResources(u64 title_id, std::stop_token stop_loading
        }

        workers.QueueWork([this, key, envs_ = std::move(envs), &state, &callback]() mutable {
-            ShaderPools pools;
+            Shader::Maxwell::ShaderPools pools;
            boost::container::static_vector<Shader::Environment*, 5> env_ptrs;
            for (auto& env : envs_) {
                env_ptrs.push_back(&env);
@@ -785,10 +776,7 @@ GraphicsPipeline* PipelineCache::BuiltPipeline(GraphicsPipeline* pipeline) const
    return nullptr;
 }

-std::unique_ptr<GraphicsPipeline> PipelineCache::CreateGraphicsPipeline(
-    ShaderPools& pools, const GraphicsPipelineCacheKey& key,
-    std::span<Shader::Environment* const> envs, PipelineStatistics* statistics,
-    bool build_in_parallel) try {
+std::unique_ptr<GraphicsPipeline> PipelineCache::CreateGraphicsPipeline(Shader::Maxwell::ShaderPools& pools, const GraphicsPipelineCacheKey& key, std::span<Shader::Environment* const> envs, PipelineStatistics* statistics, bool build_in_parallel) try {
    auto hash = key.Hash();
    LOG_DEBUG(Render_Vulkan, "{:#016x}", hash);
    size_t env_index{0};
@@ -800,12 +788,10 @@ std::unique_ptr<GraphicsPipeline> PipelineCache::CreateGraphicsPipeline(
    Shader::IR::Program* layer_source_program{};

    for (size_t index = 0; index < Maxwell::MaxShaderProgram; ++index) {
-        const bool is_emulated_stage = layer_source_program != nullptr &&
-                                       index == static_cast<u32>(Maxwell::ShaderType::Geometry);
+        const bool is_emulated_stage = layer_source_program != nullptr && index == u32(Maxwell::ShaderType::Geometry);
        if (key.unique_hashes[index] == 0 && is_emulated_stage) {
            auto topology = MaxwellToOutputTopology(key.state.topology);
-            programs[index] = GenerateGeometryPassthrough(pools.inst, pools.block, host_info,
-                                                          *layer_source_program, topology);
+            programs[index] = Shader::Maxwell::GenerateGeometryPassthrough(pools, host_info, *layer_source_program, topology);
            continue;
        }
        if (key.unique_hashes[index] == 0) {
@@ -814,16 +800,16 @@ std::unique_ptr<GraphicsPipeline> PipelineCache::CreateGraphicsPipeline(
        Shader::Environment& env{*envs[env_index]};
        ++env_index;

-        const u32 cfg_offset{static_cast<u32>(env.StartAddress() + sizeof(Shader::ProgramHeader))};
+        const u32 cfg_offset{u32(env.StartAddress() + sizeof(Shader::ProgramHeader))};
        Shader::Maxwell::Flow::CFG cfg(env, pools.flow_block, cfg_offset, index == 0);
        if (!uses_vertex_a || index != 1) {
            // Normal path
-            programs[index] = TranslateProgram(pools.inst, pools.block, env, cfg, host_info);
+            programs[index] = Shader::Maxwell::TranslateProgram(pools, env, cfg, host_info);
        } else {
            // VertexB path when VertexA is present.
            auto& program_va{programs[0]};
-            auto program_vb{TranslateProgram(pools.inst, pools.block, env, cfg, host_info)};
-            programs[index] = MergeDualVertexPrograms(program_va, program_vb, env);
+            auto program_vb{Shader::Maxwell::TranslateProgram(pools, env, cfg, host_info)};
+            programs[index] = Shader::Maxwell::MergeDualVertexPrograms(program_va, program_vb, env);
        }

        if (Settings::values.dump_guest_shaders) {
@@ -853,8 +839,8 @@ std::unique_ptr<GraphicsPipeline> PipelineCache::CreateGraphicsPipeline(
        infos[stage_index] = &program.info;

        const auto runtime_info{MakeRuntimeInfo(programs, key, program, previous_stage, device)};
-        ConvertLegacyToGeneric(program, runtime_info);
-        const std::vector<u32> code{EmitSPIRV(profile, runtime_info, program, binding)};
+        Shader::Maxwell::ConvertLegacyToGeneric(program, runtime_info);
+        const std::vector<u32> code{Shader::Backend::SPIRV::EmitSPIRV(profile, runtime_info, program, binding)};
        device.SaveShader(code);
        modules[stage_index] = BuildShader(device, code);

@@ -910,14 +896,14 @@ std::unique_ptr<GraphicsPipeline> PipelineCache::CreateGraphicsPipeline() {
    GraphicsEnvironments environments;
    GetGraphicsEnvironments(environments, graphics_key.unique_hashes);

-    main_pools.ReleaseContents();
+    main_pools.clear();
    auto pipeline{
        CreateGraphicsPipeline(main_pools, graphics_key, environments.Span(), nullptr, true)};
    if (!pipeline || pipeline_cache_filename.empty()) {
        return pipeline;
    }
    serialization_thread.QueueWork([this, key = graphics_key, envs = std::move(environments.envs)] {
-        boost::container::static_vector<const GenericEnvironment*, Maxwell::MaxShaderProgram>
+        boost::container::static_vector<const VideoCommon::GenericEnvironment*, Maxwell::MaxShaderProgram>
            env_ptrs;
        for (size_t index = 0; index < Maxwell::MaxShaderProgram; ++index) {
            if (key.unique_hashes[index] != 0) {
@@ -934,25 +920,23 @@ std::unique_ptr<ComputePipeline> PipelineCache::CreateComputePipeline(
    const ComputePipelineCacheKey& key, const ShaderInfo* shader) {
    const GPUVAddr program_base{kepler_compute->regs.code_loc.Address()};
    const auto& qmd{kepler_compute->launch_description};
-    ComputeEnvironment env{*kepler_compute, *gpu_memory, program_base, qmd.program_start};
+    VideoCommon::ComputeEnvironment env{*kepler_compute, *gpu_memory, program_base, qmd.program_start};
    env.SetCachedSize(shader->size_bytes);

-    main_pools.ReleaseContents();
+    main_pools.clear();
    auto pipeline{CreateComputePipeline(main_pools, key, env, nullptr, true)};
    if (!pipeline || pipeline_cache_filename.empty()) {
        return pipeline;
    }
    serialization_thread.QueueWork([this, key, env_ = std::move(env)] {
-        SerializePipeline(key, std::array<const GenericEnvironment*, 1>{&env_},
+        SerializePipeline(key, std::array<const VideoCommon::GenericEnvironment*, 1>{&env_},
                          pipeline_cache_filename, CACHE_VERSION);
    });
    QueueVulkanPipelineCacheFlush();
    return pipeline;
 }

-std::unique_ptr<ComputePipeline> PipelineCache::CreateComputePipeline(
-    ShaderPools& pools, const ComputePipelineCacheKey& key, Shader::Environment& env,
-    PipelineStatistics* statistics, bool build_in_parallel) try {
+std::unique_ptr<ComputePipeline> PipelineCache::CreateComputePipeline(Shader::Maxwell::ShaderPools& pools, const ComputePipelineCacheKey& key, Shader::Environment& env, PipelineStatistics* statistics, bool build_in_parallel) try {
    auto hash = key.Hash();
    if (device.HasBrokenCompute()) {
        LOG_ERROR(Render_Vulkan, "Skipping {:#016x}", hash);
@@ -968,11 +952,9 @@ std::unique_ptr<ComputePipeline> PipelineCache::CreateComputePipeline(
        env.Dump(hash, key.unique_hash);
    }

-    auto program{TranslateProgram(pools.inst, pools.block, env, cfg, host_info)};
+    auto program{Shader::Maxwell::TranslateProgram(pools, env, cfg, host_info)};
    const VkDriverIdKHR driver_id = device.GetDriverID();
-    const bool needs_shared_mem_clamp =
-        driver_id == VK_DRIVER_ID_QUALCOMM_PROPRIETARY ||
-        driver_id == VK_DRIVER_ID_ARM_PROPRIETARY;
+    const bool needs_shared_mem_clamp = driver_id == VK_DRIVER_ID_QUALCOMM_PROPRIETARY || driver_id == VK_DRIVER_ID_ARM_PROPRIETARY;
    const u32 max_shared_memory = device.GetMaxComputeSharedMemorySize();
    if (needs_shared_mem_clamp && program.shared_memory_size > max_shared_memory) {
        LOG_WARNING(Render_Vulkan,
@@ -982,7 +964,7 @@ std::unique_ptr<ComputePipeline> PipelineCache::CreateComputePipeline(
                    max_shared_memory / 1024);
        program.shared_memory_size = max_shared_memory;
    }
-    const std::vector<u32> code{EmitSPIRV(profile, program)};
+    const std::vector<u32> code{Shader::Backend::SPIRV::EmitSPIRV(profile, program)};
    device.SaveShader(code);
    vk::ShaderModule spv_module{BuildShader(device, code)};

@@ -15,15 +15,18 @@
 #include <type_traits>
 #include "common/container/unordered_map.h"
 #include <vector>
+#include <boost/container/stable_vector.hpp>

 #include "common/common_types.h"
 #include "common/thread_worker.h"
 #include "shader_recompiler/frontend/ir/basic_block.h"
 #include "shader_recompiler/frontend/ir/value.h"
 #include "shader_recompiler/frontend/maxwell/control_flow.h"
+#include "shader_recompiler/frontend/maxwell/structured_control_flow.h"
+#include "shader_recompiler/frontend/maxwell/translate_program.h"
 #include "shader_recompiler/host_translate_info.h"
-#include "shader_recompiler/object_pool.h"
 #include "shader_recompiler/profile.h"
+#include "shader_recompiler/shader_pool.h"
 #include "video_core/engines/maxwell_3d.h"
 #include "video_core/host1x/gpu_device_memory_manager.h"
 #include "video_core/renderer_vulkan/fixed_pipeline_state.h"
@@ -90,18 +93,6 @@ class Scheduler;

 using VideoCommon::ShaderInfo;

-struct ShaderPools {
-    void ReleaseContents() {
-        flow_block.ReleaseContents();
-        block.ReleaseContents();
-        inst.ReleaseContents();
-    }
-
-    Shader::ObjectPool<Shader::IR::Inst> inst{8192};
-    Shader::ObjectPool<Shader::IR::Block> block{32};
-    Shader::ObjectPool<Shader::Maxwell::Flow::Block> flow_block{32};
-};
-
 class PipelineCache : public VideoCommon::ShaderCache {
 public:
    explicit PipelineCache(Tegra::MaxwellDeviceMemoryManager& device_memory_, const Device& device,
@@ -127,14 +118,14 @@ private:
    std::unique_ptr<GraphicsPipeline> CreateGraphicsPipeline();

    std::unique_ptr<GraphicsPipeline> CreateGraphicsPipeline(
-        ShaderPools& pools, const GraphicsPipelineCacheKey& key,
+        Shader::Maxwell::ShaderPools& pools, const GraphicsPipelineCacheKey& key,
        std::span<Shader::Environment* const> envs, PipelineStatistics* statistics,
        bool build_in_parallel);

    std::unique_ptr<ComputePipeline> CreateComputePipeline(const ComputePipelineCacheKey& key,
                                                           const ShaderInfo* shader);

-    std::unique_ptr<ComputePipeline> CreateComputePipeline(ShaderPools& pools,
+    std::unique_ptr<ComputePipeline> CreateComputePipeline(Shader::Maxwell::ShaderPools& pools,
                                                           const ComputePipelineCacheKey& key,
                                                           Shader::Environment& env,
                                                           PipelineStatistics* statistics,
@@ -166,7 +157,7 @@ private:
    ::Common::unordered_map<ComputePipelineCacheKey, std::unique_ptr<ComputePipeline>> compute_cache;
    ::Common::unordered_map<GraphicsPipelineCacheKey, std::unique_ptr<GraphicsPipeline>> graphics_cache;

-    ShaderPools main_pools;
+    Shader::Maxwell::ShaderPools main_pools;

    Shader::Profile profile;
    Shader::HostTranslateInfo host_info;
@@ -11,7 +11,6 @@

 #include "common/assert.h"
 #include "shader_recompiler/frontend/maxwell/control_flow.h"
-#include "shader_recompiler/object_pool.h"
 #include "video_core/control/channel_state.h"
 #include "video_core/dirty_flags.h"
 #include "video_core/engines/kepler_compute.h"
@@ -236,7 +235,7 @@ const ShaderInfo* ShaderCache::MakeShaderInfo(GenericEnvironment& env, VAddr cpu
    } else {
        // Slow path, not really hit on commercial games
        // Build a control flow graph to get the real shader size
-        Shader::ObjectPool<Shader::Maxwell::Flow::Block> flow_block;
+        boost::container::stable_vector<Shader::Maxwell::Flow::Block> flow_block;
        Shader::Maxwell::Flow::CFG cfg{env, flow_block, env.StartAddress()};
        info->unique_hash = env.CalculateHash();
        info->size_bytes = env.ReadSizeBytes();