add svg

.gitea/workflows/build-appimage.yml

@@ -1,159 +0,0 @@
-name: Build Linux AppImage
-
-on:
-  push:
-    branches:
-      - '*'
-  pull_request:
-    branches:
-      - '*'
-  release:
-    types: [created, published]
-
-jobs:
-  build-appimage:
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-          submodules: recursive
-
-      - name: Install dependencies
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y \
-            build-essential \
-            cmake \
-            ninja-build \
-            pkg-config \
-            git \
-            curl \
-            zip \
-            unzip \
-            xvfb \
-            qt6-base-dev \
-            qt6-base-private-dev \
-            qt6-svg-dev \
-            qt6-multimedia-dev \
-            qt6-tools-dev \
-            libglew-dev \
-            libglfw3-dev \
-            libopus-dev \
-            libssl-dev \
-            libudev-dev \
-            libavcodec-dev \
-            libavformat-dev \
-            libswscale-dev \
-            libavfilter-dev \
-            libfmt-dev \
-            libgl1-mesa-dev \
-            libxrandr-dev \
-            libxi-dev \
-            libxcursor-dev \
-            libxinerama-dev \
-            libsamplerate-dev \
-            libasound2-dev \
-            libpulse-dev \
-            libsndio-dev \
-            nlohmann-json3-dev \
-            libboost-context-dev \
-            libboost-filesystem-dev \
-            libzstd-dev \
-            liblz4-dev \
-            libsdl2-dev \
-            catch2 \
-            libvulkan-dev \
-            glslang-tools \
-            spirv-tools \
-            zsync \
-            wget
-
-      - name: Clean build directory
-        run: rm -rf build
-
-      - name: Build Eden
-        run: |
-          export TARGET=appimage
-          export USE_MULTIMEDIA=false
-          .ci/linux/build.sh amd64
-        env:
-          NPROC: 2
-
-      - name: Package AppImage
-        run: |
-          export USE_MULTIMEDIA=false
-          .ci/linux/package.sh amd64
-
-      - name: Get version info
-        id: version
-        run: |
-          VERSION=$(git describe --tags --abbrev=0 2>/dev/null || echo "dev")
-          COMMIT=$(git rev-parse --short HEAD)
-          echo "version=${VERSION}" >> $GITHUB_OUTPUT
-          echo "commit=${COMMIT}" >> $GITHUB_OUTPUT
-          echo "date=$(date +'%Y-%m-%d')" >> $GITHUB_OUTPUT
-
-      - name: Upload AppImage artifact
-        uses: actions/upload-artifact@v3
-        with:
-          name: jdlo-eden-linux
-          path: |
-            Eden-*.AppImage
-            Eden-*.AppImage.zsync
-          retention-days: 30
-          if-no-files-found: error
-
-      - name: Create release info
-        run: |
-          echo "# Build Information" > build-info.txt
-          echo "Version: ${{ steps.version.outputs.version }}" >> build-info.txt
-          echo "Commit: ${{ steps.version.outputs.commit }}" >> build-info.txt
-          echo "Build Date: ${{ steps.version.outputs.date }}" >> build-info.txt
-          echo "Architecture: amd64-v3" >> build-info.txt
-          echo "Multimedia: disabled" >> build-info.txt
-          ls -lh Eden-*.AppImage >> build-info.txt
-          cat build-info.txt
-
-      - name: Upload build info
-        uses: actions/upload-artifact@v3
-        with:
-          name: build-info
-          path: build-info.txt
-          retention-days: 30
-
-      - name: Prepare release files
-        if: github.event_name == 'release'
-        id: prepare
-        run: |
-          # Find and rename files to simpler names
-          APPIMAGE_FILE=$(ls Eden-*.AppImage | head -n 1)
-          ZSYNC_FILE=$(ls Eden-*.AppImage.zsync | head -n 1)
-
-          cp "$APPIMAGE_FILE" jdlo-eden.AppImage
-          cp "$ZSYNC_FILE" jdlo-eden.AppImage.zsync
-
-          # Generate MD5 hash
-          MD5_HASH=$(md5sum "jdlo-eden.AppImage" | awk '{print $1}')
-
-          # Create release body with MD5 info
-          cat > release-body.md <<EOF
-          Thanks @arknost for the Linux version
-
-          \`jdlo-eden.AppImage\` MD5: \`$MD5_HASH\`
-          EOF
-
-          cat release-body.md
-          echo "md5_hash=$MD5_HASH" >> $GITHUB_OUTPUT
-
-      - name: Upload files to Release
-        if: github.event_name == 'release'
-        uses: akkuman/gitea-release-action@v1
-        with:
-          files: |-
-            jdlo-eden.AppImage
-            jdlo-eden.AppImage.zsync
-          body_path: release-body.md
-          token: ${{ secrets.GITHUB_TOKEN }}

CMakeLists.txt

@@ -158,7 +158,7 @@ set(YUZU_QT_MIRROR "" CACHE STRING "What mirror to use for downloading the bundl
 option(ENABLE_CUBEB "Enables the cubeb audio backend" ON)
 
 set(EXT_DEFAULT OFF)
-if (MSVC OR ANDROID OR APPLE)
+if (MSVC OR ANDROID)
     set(EXT_DEFAULT ON)
 endif()
 option(YUZU_USE_CPM "Use CPM to fetch system dependencies (fmt, boost, etc) if needed. Externals will still be fetched." ${EXT_DEFAULT})
@@ -425,7 +425,7 @@ if (YUZU_USE_CPM)
     endif()
 
     # fmt
-    AddJsonPackage(NAME fmt BUNDLED_PACKAGE ON)
+    AddJsonPackage(fmt)
 
     # lz4
     AddJsonPackage(lz4)
@@ -530,9 +530,7 @@ if (APPLE)
     # Umbrella framework for everything GUI-related
     find_library(COCOA_LIBRARY Cocoa REQUIRED)
     find_library(IOKIT_LIBRARY IOKit REQUIRED)
-    find_library(COREVIDEO_LIBRARY CoreVideo REQUIRED)
-    find_library(VIDEOTOOLBOX_LIBRARY VideoToolbox REQUIRED)
-    set(PLATFORM_LIBRARIES ${COCOA_LIBRARY} ${IOKIT_LIBRARY} ${COREVIDEO_LIBRARY} ${VIDEOTOOLBOX_LIBRARY})
+    set(PLATFORM_LIBRARIES ${COCOA_LIBRARY} ${IOKIT_LIBRARY} ${COREVIDEO_LIBRARY})
 elseif (WIN32)
     # Target Windows 10
     add_compile_definitions(_WIN32_WINNT=0x0A00 WINVER=0x0A00)
@@ -565,7 +563,7 @@ find_package(VulkanUtilityLibraries)
 find_package(SimpleIni)
 find_package(SPIRV-Tools)
 find_package(sirit)
-find_package(gamemode)
+find_package(gamemode) 
 
 if (ARCHITECTURE_x86 OR ARCHITECTURE_x86_64)
     find_package(xbyak)

cpmfile.json

@@ -96,8 +96,8 @@
         "package": "VVL",
         "repo": "KhronosGroup/Vulkan-ValidationLayers",
         "tag": "vulkan-sdk-%VERSION%",
-        "git_version": "1.4.335.0",
+        "git_version": "1.4.328.1",
         "artifact": "android-binaries-%VERSION%.zip",
-        "hash": "48167c4a17736301bd08f9290f41830443e1f18cce8ad867fc6f289b49e18b40e93c9850b377951af82f51b5b6d7313aa6a884fc5df79f5ce3df82696c1c1244"
+        "hash": "5ec895a453cb7c2f156830b9766953a0c2bd44dea99e6a3dac4160305041ccd3e87534b4ce0bd102392178d2a8eca48411856298f9395e60117cdfe89f72137e"
     }
 }

docs/README.md

@@ -13,3 +13,4 @@ This contains documentation created by developers. This contains build instructi
 - **[The NVIDIA SM86 (Maxwell) GPU](./NvidiaGpu.md)**
 - **[User Handbook](./user)**
 - **[Release Policy](./ReleasePolicy.md)**
+- **[Dynarmic](./dynarmic)**

docs/dynarmic/Design.md

@@ -343,3 +343,279 @@ SetTerm(IR::Term::If{cond, term_then, term_else})
 
 This terminal instruction conditionally executes one terminal or another depending
 on the run-time state of the ARM flags.
+
+# Register Allocation (x64 Backend)
+
+`HostLoc`s contain values. A `HostLoc` ("host value location") is either a host CPU register or a host spill location.
+
+Values once set cannot be changed. Values can however be moved by the register allocator between `HostLoc`s. This is
+handled by the register allocator itself and code that uses the register allocator need not and should not move values
+between registers.
+
+The register allocator is based on three concepts: `Use`, `Def` and `Scratch`.
+
+* `Use`: The use of a value.
+* `Define`: The definition of a value, this is the only time when a value is set.
+* `Scratch`: Allocate a register that can be freely modified as one wishes.
+
+Note that `Use`ing a value decrements its `use_count` by one. When the `use_count` reaches zero the value is discarded and no longer exists.
+
+The member functions on `RegAlloc` are just a combination of the above concepts.
+
+The following registers are reserved for internal use and should NOT participate in register allocation:
+- `%xmm0`, `%xmm1`, `%xmm2`: Used as scratch in exclusive memory access.
+- `%rsp`: Stack pointer.
+- `%r15`: JIT pointer
+- `%r14`: Page table pointer.
+- `%r13`: Fastmem pointer.
+
+The layout convenes `%r15` as the JIT state pointer - while it may be tempting to turn it into a synthetic pointer, keeping an entire register (out of 12 available) is preferable over inlining a directly computed immediate.
+
+Do NEVER modify `%r15`, we must make it clear that this register is "immutable" for the entirety of the JIT block duration.
+
+### `Scratch`
+
+```c++
+Xbyak::Reg64 ScratchGpr(HostLocList desired_locations = any_gpr);
+Xbyak::Xmm ScratchXmm(HostLocList desired_locations = any_xmm);
+```
+
+At runtime, allocate one of the registers in `desired_locations`. You are free to modify the register. The register is discarded at the end of the allocation scope.
+
+### Pure `Use`
+
+```c++
+Xbyak::Reg64 UseGpr(Argument& arg);
+Xbyak::Xmm UseXmm(Argument& arg);
+OpArg UseOpArg(Argument& arg);
+void Use(Argument& arg, HostLoc host_loc);
+```
+
+At runtime, the value corresponding to `arg` will be placed a register. The actual register is determined by
+which one of the above functions is called. `UseGpr` places it in an unused GPR, `UseXmm` places it
+in an unused XMM register, `UseOpArg` might be in a register or might be a memory location, and `Use` allows
+you to specify a specific register (GPR or XMM) to use.
+
+This register **must not** have it's value changed.
+
+### `UseScratch`
+
+```c++
+Xbyak::Reg64 UseScratchGpr(Argument& arg);
+Xbyak::Xmm UseScratchXmm(Argument& arg);
+void UseScratch(Argument& arg, HostLoc host_loc);
+```
+
+At runtime, the value corresponding to `arg` will be placed a register. The actual register is determined by
+which one of the above functions is called. `UseScratchGpr` places it in an unused GPR, `UseScratchXmm` places it
+in an unused XMM register, and `UseScratch` allows you to specify a specific register (GPR or XMM) to use.
+
+The return value is the register allocated to you.
+
+You are free to modify the value in the register. The register is discarded at the end of the allocation scope.
+
+### `Define` as register
+
+A `Define` is the defintion of a value. This is the only time when a value may be set.
+
+```c++
+void DefineValue(IR::Inst* inst, const Xbyak::Reg& reg);
+```
+
+By calling `DefineValue`, you are stating that you wish to define the value for `inst`, and you have written the
+value to the specified register `reg`.
+
+### `Define`ing as an alias of a different value
+
+Adding a `Define` to an existing value.
+
+```c++
+void DefineValue(IR::Inst* inst, Argument& arg);
+```
+
+You are declaring that the value for `inst` is the same as the value for `arg`. No host machine instructions are
+emitted.
+
+## When to use each?
+
+* Prefer `Use` to `UseScratch` where possible.
+* Prefer the `OpArg` variants where possible.
+* Prefer to **not** use the specific `HostLoc` variants where possible.
+
+# Return Stack Buffer Optimization (x64 Backend)
+
+One of the optimizations that dynarmic does is block-linking. Block-linking is done when
+the destination address of a jump is available at JIT-time. Instead of returning to the
+dispatcher at the end of a block we can perform block-linking: just jump directly to the
+next block. This is beneficial because returning to the dispatcher can often be quite
+expensive.
+
+What should we do in cases when we can't predict the destination address? The eponymous
+example is when executing a return statement at the end of a function; the return address
+is not statically known at compile time.
+
+We deal with this by using a return stack buffer: When we execute a call instruction,
+we push our prediction onto the RSB. When we execute a return instruction, we pop a
+prediction off the RSB. If the prediction is a hit, we immediately jump to the relevant
+compiled block. Otherwise, we return to the dispatcher.
+
+This is the essential idea behind this optimization.
+
+## `UniqueHash`
+
+One complication dynarmic has is that a compiled block is not uniquely identifiable by
+the PC alone, but bits in the FPSCR and CPSR are also relevant. We resolve this by
+computing a 64-bit `UniqueHash` that is guaranteed to uniquely identify a block.
+
+```c++
+u64 LocationDescriptor::UniqueHash() const {
+    // This value MUST BE UNIQUE.
+    // This calculation has to match up with EmitX64::EmitTerminalPopRSBHint
+    u64 pc_u64 = u64(arm_pc) << 32;
+    u64 fpscr_u64 = u64(fpscr.Value());
+    u64 t_u64 = cpsr.T() ? 1 : 0;
+    u64 e_u64 = cpsr.E() ? 2 : 0;
+    return pc_u64 | fpscr_u64 | t_u64 | e_u64;
+}
+```
+
+## Our implementation isn't actually a stack
+
+Dynarmic's RSB isn't actually a stack. It was implemented as a ring buffer because
+that showed better performance in tests.
+
+### RSB Structure
+
+The RSB is implemented as a ring buffer. `rsb_ptr` is the index of the insertion
+point. Each element in `rsb_location_descriptors` is a `UniqueHash` and they
+each correspond to an element in `rsb_codeptrs`. `rsb_codeptrs` contains the
+host addresses for the corresponding the compiled blocks.
+
+`RSBSize` was chosen by performance testing. Note that this is bigger than the
+size of the real RSB in hardware (which has 3 entries). Larger RSBs than 8
+showed degraded performance.
+
+```c++
+struct JitState {
+    // ...
+
+    static constexpr size_t RSBSize = 8; // MUST be a power of 2.
+    u32 rsb_ptr = 0;
+    std::array<u64, RSBSize> rsb_location_descriptors;
+    std::array<u64, RSBSize> rsb_codeptrs;
+    void ResetRSB();
+
+    // ...
+};
+```
+
+### RSB Push
+
+We insert our prediction at the insertion point iff the RSB doesn't already
+contain a prediction with the same `UniqueHash`.
+
+```c++
+void EmitX64::EmitPushRSB(IR::Block&, IR::Inst* inst) {
+    using namespace Xbyak::util;
+
+    ASSERT(inst->GetArg(0).IsImmediate());
+    u64 imm64 = inst->GetArg(0).GetU64();
+
+    Xbyak::Reg64 code_ptr_reg = reg_alloc.ScratchGpr(code, {HostLoc::RCX});
+    Xbyak::Reg64 loc_desc_reg = reg_alloc.ScratchGpr(code);
+    Xbyak::Reg32 index_reg = reg_alloc.ScratchGpr(code).cvt32();
+    u64 code_ptr = unique_hash_to_code_ptr.find(imm64) != unique_hash_to_code_ptr.end()
+                    ? u64(unique_hash_to_code_ptr[imm64])
+                    : u64(code->GetReturnFromRunCodeAddress());
+
+    code->mov(index_reg, dword[code.ABI_JIT_PTR + offsetof(JitState, rsb_ptr)]);
+    code->add(index_reg, 1);
+    code->and_(index_reg, u32(JitState::RSBSize - 1));
+
+    code->mov(loc_desc_reg, u64(imm64));
+    CodePtr patch_location = code->getCurr<CodePtr>();
+    patch_unique_hash_locations[imm64].emplace_back(patch_location);
+    code->mov(code_ptr_reg, u64(code_ptr)); // This line has to match up with EmitX64::Patch.
+    code->EnsurePatchLocationSize(patch_location, 10);
+
+    Xbyak::Label label;
+    for (size_t i = 0; i < JitState::RSBSize; ++i) {
+        code->cmp(loc_desc_reg, qword[code.ABI_JIT_PTR + offsetof(JitState, rsb_location_descriptors) + i * sizeof(u64)]);
+        code->je(label, code->T_SHORT);
+    }
+
+    code->mov(dword[code.ABI_JIT_PTR + offsetof(JitState, rsb_ptr)], index_reg);
+    code->mov(qword[code.ABI_JIT_PTR + index_reg.cvt64() * 8 + offsetof(JitState, rsb_location_descriptors)], loc_desc_reg);
+    code->mov(qword[code.ABI_JIT_PTR + index_reg.cvt64() * 8 + offsetof(JitState, rsb_codeptrs)], code_ptr_reg);
+    code->L(label);
+}
+```
+
+In pseudocode:
+
+```c++
+    for (i := 0 .. RSBSize-1)
+        if (rsb_location_descriptors[i] == imm64)
+        goto label;
+    rsb_ptr++;
+    rsb_ptr %= RSBSize;
+    rsb_location_desciptors[rsb_ptr] = imm64; //< The UniqueHash
+    rsb_codeptr[rsb_ptr] = /* codeptr corresponding to the UniqueHash */;
+label:
+```
+
+## RSB Pop
+
+To check if a predicition is in the RSB, we linearly scan the RSB.
+
+```c++
+void EmitX64::EmitTerminalPopRSBHint(IR::Term::PopRSBHint, IR::LocationDescriptor initial_location) {
+    using namespace Xbyak::util;
+
+    // This calculation has to match up with IREmitter::PushRSB
+    code->mov(ecx, MJitStateReg(Arm::Reg::PC));
+    code->shl(rcx, 32);
+    code->mov(ebx, dword[code.ABI_JIT_PTR + offsetof(JitState, FPSCR_mode)]);
+    code->or_(ebx, dword[code.ABI_JIT_PTR + offsetof(JitState, CPSR_et)]);
+    code->or_(rbx, rcx);
+
+    code->mov(rax, u64(code->GetReturnFromRunCodeAddress()));
+    for (size_t i = 0; i < JitState::RSBSize; ++i) {
+        code->cmp(rbx, qword[code.ABI_JIT_PTR + offsetof(JitState, rsb_location_descriptors) + i * sizeof(u64)]);
+        code->cmove(rax, qword[code.ABI_JIT_PTR + offsetof(JitState, rsb_codeptrs) + i * sizeof(u64)]);
+    }
+
+    code->jmp(rax);
+}
+```
+
+In pseudocode:
+
+```c++
+rbx := ComputeUniqueHash()
+rax := ReturnToDispatch
+for (i := 0 .. RSBSize-1)
+    if (rbx == rsb_location_descriptors[i])
+        rax = rsb_codeptrs[i]
+goto rax
+```
+
+# Fast memory (Fastmem)
+
+The main way of accessing memory in JITed programs is via an invoked function, say "Read()" and "Write()". On our translator, such functions usually take a sizable amounts of code space (push + call + pop). Trash the i-cache (due to an indirect call) and overall make code emission more bloated.
+
+The solution? Delegate invalid accesses to a dedicated arena, similar to a swap. The main idea behind such mechanism is to allow the OS to transmit page faults from invalid accesses into the JIT translator directly, bypassing address space calls, while this sacrifices i-cache coherency, it allows for smaller code-size and "faster" throguhput.
+
+Many kernels however, do not support fast signal dispatching (Solaris, OpenBSD, FreeBSD). Only Linux and Windows support relatively "fast" signal dispatching. Hence this feature is better suited for them only.
+
+![Host to guest translation](./HostToGuest.svg)
+
+![Fastmem translation](./Fastmem.svg)
+
+In x86_64 for example, when a page fault occurs, the CPU will transmit via control registers and the stack (see `IRETQ`) the appropriate arguments for a page fault handler, the OS then will transform that into something that can be sent into userspace.
+
+Most modern OSes implement kernel-page-table-isolation, which means a set of system calls will invoke a context switch (not often used syscalls), whereas others are handled by the same process address space (the smaller kernel portion, often used syscalls) without needing a context switch. This effect can be negated on systems with PCID (up to 4096 unique IDs).
+
+Signal dispatching takes a performance hit from reloading `%cr3` - but Linux does something more clever to avoid reloads:  VDSO will take care of the entire thing in the same address space. Making dispatching as costly as an indirect call - without the hazards of increased code size.
+
+The main downside from this is the constant i-cache trashing and pipeline hazards introduced by the VDSO signal handlers. However on most benchmarks fastmem does perform faster than without (Linux only). This also abuses the fact of continous address space emulation by using an arena - which can then be potentially transparently mapped into a hugepage, reducing TLB walk times.

docs/dynarmic/README.md

@@ -49,7 +49,7 @@ Important API Changes in v6.x Series
 Documentation
 -------------
 
-Design documentation can be found at [docs/Design.md](docs/Design.md).
+Design documentation can be found at [./Design.md](./Design.md).
 
 
 Usage Example

externals/cpmfile.json

@@ -119,10 +119,10 @@
         "package": "VulkanUtilityLibraries",
         "repo": "scripts/VulkanUtilityHeaders",
         "tag": "%VERSION%",
-        "git_version": "1.4.335",
+        "git_version": "1.4.328",
         "artifact": "VulkanUtilityHeaders.tar.zst",
         "git_host": "git.crueter.xyz",
-        "hash": "16dac0e6586702580c4279e4cd37ffe3cf909c93eb31b5069da7af36436d47b270a9cbaac953bb66c22ed12ed67ffa096688599267f307dfb62be1bc09f79833"
+        "hash": "9922217b39faf73cd4fc1510f2fdba14a49aa5c0d77f9ee24ee0512cef16b234d0cabc83c1fec861fa5df1d43e7f086ca9b6501753899119f39c5ca530cb0dae"
     },
     "spirv-tools": {
         "package": "SPIRV-Tools",

externals/ffmpeg/CMakeLists.txt

@@ -217,6 +217,7 @@ else()
                 --disable-ffmpeg
                 --disable-ffprobe
                 --disable-network
+                --disable-postproc
                 --disable-swresample
                 --enable-decoder=h264
                 --enable-decoder=vp8

externals/ffmpeg/cpmfile.json

@@ -1,16 +1,16 @@
 {
     "ffmpeg": {
         "repo": "FFmpeg/FFmpeg",
-        "tag": "n6.1",
+        "sha": "5e56937b74",
+        "hash": "9ab0457dcd6ce6359b5053c1662f57910d332f68ca0cca9d4134d858464840917027374de3d97e0863c3a7daaea2fe4f4cd17d1c6d8e7f740f4ad91e71c2932b",
         "bundled": true
     },
     "ffmpeg-ci": {
         "ci": true,
         "package": "FFmpeg",
         "name": "ffmpeg",
-        "repo": "FFmpeg/FFmpeg",
-        "tag": "n6.1",
-        "version": "6.1",
+        "repo": "crueter-ci/FFmpeg",
+        "version": "8.0.1-5e56937b74",
         "min_version": "4.1"
     }
-}
+}

src/android/app/build.gradle.kts

@@ -39,6 +39,7 @@ android {
 
     buildFeatures {
         viewBinding = true
+        buildConfig = true
     }
 
     compileOptions {

src/android/gradle.properties

@@ -14,8 +14,6 @@ android.useAndroidX=true
 # Kotlin code style for this project: "official" or "obsolete":
 kotlin.code.style=official
 kotlin.parallel.tasks.in.project=true
-android.defaults.buildfeatures.buildconfig=true
-
 # Android Gradle plugin 8.0.2
 android.suppressUnsupportedCompileSdk=34
 android.native.buildOutput=verbose

src/common/announce_multiplayer_room.h

@@ -34,8 +34,8 @@ struct Member {
 struct RoomInformation {
     std::string name;          ///< Name of the server
     std::string description;   ///< Server description
-    u32 member_slots{};        ///< Maximum number of members in this room
-    u16 port{};                ///< The port of this room
+    u32 member_slots;          ///< Maximum number of members in this room
+    u16 port;                  ///< The port of this room
     GameInfo preferred_game;   ///< Game to advertise that you want to play
     std::string host_username; ///< Forum username of the host
 };
@@ -46,8 +46,8 @@ struct Room {
     std::string id;
     std::string verify_uid; ///< UID used for verification
     std::string ip;
-    u32 net_version{};
-    bool has_password = false;
+    u32 net_version;
+    bool has_password;
 
     std::vector<Member> members;
 };

src/core/CMakeLists.txt

@@ -17,6 +17,8 @@ add_library(core STATIC
     constants.h
     core.cpp
     core.h
+    game_settings.cpp
+    game_settings.h
     core_timing.cpp
     core_timing.h
     cpu_manager.cpp
@@ -43,11 +45,7 @@ add_library(core STATIC
     device_memory.cpp
     device_memory.h
     device_memory_manager.h
-    device_memory.h
-    device_memory_manager.h
     device_memory_manager.inc
-    internal_network/legacy_online.cpp
-    internal_network/legacy_online.h
     file_sys/bis_factory.cpp
     file_sys/bis_factory.h
     file_sys/card_image.cpp

src/core/core.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 #include <array>
@@ -49,7 +49,6 @@
 #include "core/hle/service/services.h"
 #include "core/hle/service/set/system_settings_server.h"
 #include "core/hle/service/sm/sm.h"
-#include "core/internal_network/legacy_online.h"
 #include "core/internal_network/network.h"
 #include "core/loader/loader.h"
 #include "core/memory.h"
@@ -138,14 +137,6 @@ struct System::Impl {
         kernel.SetMulticore(is_multicore);
         cpu_manager.SetMulticore(is_multicore);
         cpu_manager.SetAsyncGpu(is_async_gpu);
-        cpu_manager.SetMulticore(is_multicore);
-        cpu_manager.SetAsyncGpu(is_async_gpu);
-
-        // Start Legacy Online Service (UDP port 6000 + HTTP port 8080 for mobile app)
-        if (!legacy_online) {
-            legacy_online = std::make_unique<Network::LegacyOnlineService>();
-            legacy_online->Start();
-        }
     }
 
     void ReinitializeIfNecessary(System& system) {
@@ -302,48 +293,6 @@ struct System::Impl {
         return SystemResultStatus::Success;
     }
 
-
-    void LoadOverrides(u64 programId) const {
-        std::string vendor = gpu_core->Renderer().GetDeviceVendor();
-        LOG_INFO(Core, "GPU Vendor: {}", vendor);
-
-        // Reset all per-game flags
-        Settings::values.use_squashed_iterated_blend = false;
-
-        // Insert PC overrides here
-
-    #ifdef ANDROID
-        // Example on how to set a setting based on the program ID and vendor
-        if (programId == 0x010028600EBDA000 && vendor == "Mali") { // Mario 3d World
-          // Settings::values.example = true;
-        }
-
-        // Example array of program IDs
-        const std::array<u64, 10> example_array = {
-                //0xprogramId
-                0x0004000000033400, // Game 1
-                0x0004000000033500 // Game 2
-                // And so on
-        };
-
-        for (auto id : example_array) {
-            if (programId == id) {
-             // Settings::values.example = true;
-                break;
-            }
-        }
-
-    #endif
-
-        // Ninja Gaiden Ragebound
-        constexpr u64 ngr = 0x0100781020710000ULL;
-
-        if (programId == ngr) {
-            LOG_INFO(Core, "Enabling game specifc override: use_squashed_iterated_blend");
-            Settings::values.use_squashed_iterated_blend = true;
-        }
-    }
-
     SystemResultStatus Load(System& system, Frontend::EmuWindow& emu_window,
                             const std::string& filepath,
                             Service::AM::FrontendAppletParameters& params) {
@@ -429,7 +378,8 @@ struct System::Impl {
             LOG_ERROR(Core, "Failed to find program id for ROM");
         }
 
-        LoadOverrides(program_id);
+
+        GameSettings::LoadOverrides(program_id, gpu_core->Renderer());
         if (auto room_member = Network::GetRoomMember().lock()) {
             Network::GameInfo game_info;
             game_info.name = name;
@@ -478,12 +428,6 @@ struct System::Impl {
         stop_event = {};
         Network::RestartSocketOperations();
 
-        if (legacy_online) {
-             // Keep legacy_online running for the emulator's lifetime
-             // legacy_online->Stop();
-             // legacy_online.reset();
-        }
-
         if (auto room_member = Network::GetRoomMember().lock()) {
             Network::GameInfo game_info{};
             room_member->SendGameInfo(game_info);
@@ -573,9 +517,6 @@ struct System::Impl {
     /// Network instance
     Network::NetworkInstance network_instance;
 
-    /// Legacy Online Service
-    std::unique_ptr<Network::LegacyOnlineService> legacy_online;
-
     /// Debugger
     std::unique_ptr<Core::Debugger> debugger;
 

src/core/file_sys/savedata_factory.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
@@ -11,8 +11,6 @@
 #include "core/core.h"
 #include "core/file_sys/savedata_factory.h"
 #include "core/file_sys/vfs/vfs.h"
-#include "core/file_sys/sdmc_factory.h"
-#include "core/hle/service/filesystem/filesystem.h"
 
 namespace FileSys {
 
@@ -57,114 +55,39 @@ std::string GetFutureSaveDataPath(SaveDataSpaceId space_id, SaveDataType type, u
 
 } // Anonymous namespace
 
-VirtualDir SaveDataFactory::Open(SaveDataSpaceId space, const SaveDataAttribute& meta) const {
-    u64 target_program_id = meta.program_id;
-    // CRITICAL FIX: If the game requests Cache/Temp with ProgramID 0 (generic),
-    // we MUST redirect it to the actual running TitleID, otherwise it looks in '.../0000000000000000'.
-    if ((meta.type == SaveDataType::Cache || meta.type == SaveDataType::Temporary) && target_program_id == 0) {
-        target_program_id = system.GetApplicationProcessProgramID();
-        LOG_INFO(Service_FS, "Redirecting generic Cache request (ID 0) to active TitleID: {:016X}", target_program_id);
-    }
+SaveDataFactory::SaveDataFactory(Core::System& system_, ProgramId program_id_,
+                                 VirtualDir save_directory_)
+    : system{system_}, program_id{program_id_}, dir{std::move(save_directory_)} {
+    // Delete all temporary storages
+    // On hardware, it is expected that temporary storage be empty at first use.
+    dir->DeleteSubdirectoryRecursive("temp");
+}
 
-    const auto save_directory = GetFullPath(program_id, dir, space, meta.type, target_program_id,
+SaveDataFactory::~SaveDataFactory() = default;
+
+VirtualDir SaveDataFactory::Create(SaveDataSpaceId space, const SaveDataAttribute& meta) const {
+    const auto save_directory = GetFullPath(program_id, dir, space, meta.type, meta.program_id,
+                                            meta.user_id, meta.system_save_data_id);
+
+    return dir->CreateDirectoryRelative(save_directory);
+}
+
+VirtualDir SaveDataFactory::Open(SaveDataSpaceId space, const SaveDataAttribute& meta) const {
+
+    const auto save_directory = GetFullPath(program_id, dir, space, meta.type, meta.program_id,
                                             meta.user_id, meta.system_save_data_id);
 
     auto out = dir->GetDirectoryRelative(save_directory);
 
-    if (out == nullptr) {
-        LOG_WARNING(Service_FS, "Cache/Save path NOT FOUND: '{}'. Auto-create={}", save_directory, auto_create);
-    } else {
-        LOG_INFO(Service_FS, "Cache/Save path FOUND: '{}'", save_directory);
-    }
-
     if (out == nullptr && (ShouldSaveDataBeAutomaticallyCreated(space, meta) && auto_create)) {
-        LOG_INFO(Service_FS, "Auto-creating save directory...");
         return Create(space, meta);
     }
 
-    if (out != nullptr) {
-        // Some emulators (Ryujinx) or even different firmware versions may rely on the commit
-        // directories /0 or /1 being present for cache or save data.
-        // We prioritizing /1 as it usually implies a newer commit if both exist,
-        // but /0 is what's commonly used by Ryujinx for cache.
-
-        // Ryujinx behavior: If 0 exists and 1 does not, copy 0 to 1.
-        auto dir_0 = out->GetSubdirectory("0");
-        auto dir_1 = out->GetSubdirectory("1");
-
-        if (dir_0) LOG_INFO(Service_FS, "Found subdirectory '0' in save path.");
-        if (dir_1) LOG_INFO(Service_FS, "Found subdirectory '1' in save path.");
-
-        if (dir_0 != nullptr && dir_1 == nullptr) {
-            // User requested removal of auto-copy 0->1 logic.
-            // We simply don't create/copy '1' if it's missing. We rely on fallback to '0'.
-            LOG_INFO(Service_FS, "Ryujinx structure detected: '0' exists, '1' missing. Skipping copy (User Request).");
-            // VfsRawCopyD(dir_0, dir_1); // REMOVED
-        }
-
-        // Check for 'Addressables' and 'Addressables2' and delete 'json.cache' if present.
-        // This is a specific workaround for games (e.g. Just Dance) that freeze if they find old cache metadata.
-        // We force them to regenerate it.
-        const auto CleanCache = [](VirtualDir root) {
-            if (root == nullptr) return;
-            const char* subdirs[] = {"Addressables", "Addressables2"};
-            for (const char* subdir_name : subdirs) {
-                auto subdir = root->GetSubdirectory(subdir_name);
-                if (subdir != nullptr) {
-                    if (subdir->DeleteFile("json.cache")) {
-                        LOG_INFO(Service_FS, "Deleted stale 'json.cache' in '{}'", subdir_name);
-                    }
-                }
-            }
-        };
-
-        VirtualDir commit_root = nullptr;
-        if (dir_1 != nullptr) {
-            LOG_INFO(Service_FS, "Using subdirectory '1' as Commit Root.");
-            commit_root = dir_1;
-        } else if (dir_0 != nullptr) {
-            LOG_INFO(Service_FS, "Using subdirectory '0' as Commit Root.");
-            commit_root = dir_0;
-        } else {
-            LOG_INFO(Service_FS, "No '0' or '1' subdirectories found. Using parent folder as Commit Root.");
-            commit_root = out;
-        }
-
-        CleanCache(commit_root);
-
-        // Implement SD_Cache.XXXX logic for Cache Storage
-        if (meta.type == SaveDataType::Cache) {
-            const std::string sd_cache_name = fmt::format("SD_Cache.{:04X}", meta.index);
-            auto sd_cache_dir = commit_root->GetSubdirectory(sd_cache_name);
-            if (sd_cache_dir != nullptr) {
-                LOG_INFO(Service_FS, "Found SD_Cache directory: '{}'", sd_cache_name);
-                return sd_cache_dir;
-            } else if (auto_create) {
-                LOG_INFO(Service_FS, "Auto-creating SD_Cache directory: '{}'", sd_cache_name);
-                return commit_root->CreateSubdirectory(sd_cache_name);
-            } else {
-                LOG_WARNING(Service_FS, "SD_Cache directory '{}' not found in commit root.", sd_cache_name);
-                // Fallback? Or return nullptr?
-                // If the user strictly wants SD_Cache, we should probably return nullptr if not found/created.
-                // But for now, returning the commit_root might be safer for legacy compatibility IF SD_Cache isn't strictly enforced for existing saves?
-                // User said "SD_Cache now represents which CacheStorage it will be". This implies correct behavior is to use SD_Cache.
-                // If we return commit_root, it's CacheStorage_0 (conceptually) or just "everything".
-                // Let's assume we return nullptr if not found, to trigger creation logic or error.
-                return nullptr;
-            }
-        }
-
-        return commit_root;
-    }
-
     return out;
 }
 
 VirtualDir SaveDataFactory::GetSaveDataSpaceDirectory(SaveDataSpaceId space) const {
-    const auto path = GetSaveDataSpaceIdPath(space);
-    // Ensure the directory exists, otherwise FindAllSaves fails.
-    return GetOrCreateDirectoryRelative(dir, path);
-    // return dir->GetDirectoryRelative(GetSaveDataSpaceIdPath(space));
+    return dir->GetDirectoryRelative(GetSaveDataSpaceIdPath(space));
 }
 
 std::string SaveDataFactory::GetSaveDataSpaceIdPath(SaveDataSpaceId space) {
@@ -173,12 +96,12 @@ std::string SaveDataFactory::GetSaveDataSpaceIdPath(SaveDataSpaceId space) {
         return "/system/";
     case SaveDataSpaceId::User:
     case SaveDataSpaceId::SdUser:
-    case SaveDataSpaceId::Temporary: // Map into User so we can find the save/ folder
         return "/user/";
+    case SaveDataSpaceId::Temporary:
+        return "/temp/";
     default:
-        // ASSERT_MSG(false, "Unrecognized SaveDataSpaceId: {:02X}", static_cast<u8>(space));
-        LOG_WARNING(Service_FS, "Unrecognized SaveDataSpaceId: {:02X}, defaulting to /user/", static_cast<u8>(space));
-        return "/user/";
+        ASSERT_MSG(false, "Unrecognized SaveDataSpaceId: {:02X}", static_cast<u8>(space));
+        return "/unrecognized/"; ///< To prevent corruption when ignoring asserts.
     }
 }
 
@@ -214,9 +137,8 @@ std::string SaveDataFactory::GetFullPath(ProgramId program_id, VirtualDir dir,
         return fmt::format("{}save/{:016X}/{:016X}{:016X}/{:016X}", out, 0, user_id[1], user_id[0],
                            title_id);
     case SaveDataType::Temporary:
-        // Unified Cache/Temporary Path: Always use save/cache/{TitleID}
-        // This simplifies user instructions and avoids UUID/Permission issues.
-        return fmt::format("{}save/cache/{:016X}", out, title_id);
+        return fmt::format("{}{:016X}/{:016X}{:016X}/{:016X}", out, 0, user_id[1], user_id[0],
+                           title_id);
     case SaveDataType::Cache:
         return fmt::format("{}save/cache/{:016X}", out, title_id);
     default:
@@ -225,40 +147,6 @@ std::string SaveDataFactory::GetFullPath(ProgramId program_id, VirtualDir dir,
     }
 }
 
-SaveDataFactory::SaveDataFactory(Core::System& system_, ProgramId program_id_,
-                                 VirtualDir save_directory_)
-    : system{system_}, program_id{program_id_}, dir{std::move(save_directory_)} {
-    // Delete all temporary storages
-    // On hardware, it is expected that temporary storage be empty at first use.
-    dir->DeleteSubdirectoryRecursive("temp");
-}
-
-SaveDataFactory::~SaveDataFactory() = default;
-
-VirtualDir SaveDataFactory::Create(SaveDataSpaceId space, const SaveDataAttribute& meta) const {
-    const auto save_directory = GetFullPath(program_id, dir, space, meta.type, meta.program_id,
-                                            meta.user_id, meta.system_save_data_id);
-
-    auto created_dir = dir->CreateDirectoryRelative(save_directory);
-
-    // For Cache storage, enforce the new hierarchy: .../1/SD_Cache.XXXX
-    if (meta.type == SaveDataType::Cache && created_dir != nullptr) {
-        // Ensure commit directory '1' exists
-        auto commit_dir = created_dir->GetSubdirectory("1");
-        if (commit_dir == nullptr) {
-             commit_dir = created_dir->CreateSubdirectory("1");
-        }
-
-        if (commit_dir != nullptr) {
-             // Create SD_Cache.XXXX
-             const std::string sd_cache_name = fmt::format("SD_Cache.{:04X}", meta.index);
-             return commit_dir->CreateSubdirectory(sd_cache_name);
-        }
-    }
-
-    return created_dir;
-}
-
 std::string SaveDataFactory::GetUserGameSaveDataRoot(u128 user_id, bool future) {
     if (future) {
         Common::UUID uuid;

src/core/frontend/applets/cabinet.h

@@ -21,7 +21,7 @@ namespace Core::Frontend {
 struct CabinetParameters {
     Service::NFP::TagInfo tag_info;
     Service::NFP::RegisterInfo register_info;
-    Service::NFP::CabinetMode mode{};
+    Service::NFP::CabinetMode mode;
 };
 
 using CabinetCallback = std::function<void(bool, const std::string&)>;

src/core/frontend/applets/software_keyboard.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -23,9 +20,9 @@ struct KeyboardInitializeParameters {
     std::u16string initial_text;
     char16_t left_optional_symbol_key;
     char16_t right_optional_symbol_key;
-    u32 max_text_length{};
-    u32 min_text_length{};
-    s32 initial_cursor_position{};
+    u32 max_text_length;
+    u32 min_text_length;
+    s32 initial_cursor_position;
     Service::AM::Frontend::SwkbdType type;
     Service::AM::Frontend::SwkbdPasswordMode password_mode;
     Service::AM::Frontend::SwkbdTextDrawType text_draw_type;
@@ -37,12 +34,12 @@ struct KeyboardInitializeParameters {
 };
 
 struct InlineAppearParameters {
-    u32 max_text_length{};
-    u32 min_text_length{};
-    f32 key_top_scale_x{};
-    f32 key_top_scale_y{};
-    f32 key_top_translate_x{};
-    f32 key_top_translate_y{};
+    u32 max_text_length;
+    u32 min_text_length;
+    f32 key_top_scale_x;
+    f32 key_top_scale_y;
+    f32 key_top_translate_x;
+    f32 key_top_translate_y;
     Service::AM::Frontend::SwkbdType type;
     Service::AM::Frontend::SwkbdKeyDisableFlags key_disable_flags;
     bool key_top_as_floating;
@@ -53,7 +50,7 @@ struct InlineAppearParameters {
 
 struct InlineTextParameters {
     std::u16string input_text;
-    s32 cursor_position{};
+    s32 cursor_position;
 };
 
 class SoftwareKeyboardApplet : public Applet {

src/core/hle/service/filesystem/filesystem.cpp

@@ -686,16 +686,6 @@ void FileSystemController::CreateFactories(FileSys::VfsFilesystem& vfs, bool ove
     using EdenPath = Common::FS::EdenPath;
     const auto sdmc_dir_path = Common::FS::GetEdenPath(EdenPath::SDMCDir);
     const auto sdmc_load_dir_path = sdmc_dir_path / "atmosphere/contents";
-
-    // If the NAND user save location doesn't exist but the SDMC contains
-    // Nintendo/save (common portable save structure), create a host-side
-    // symlink so the emulator will see those saves under the expected NAND path.
-    // This helps users who placed saves under `<eden>/user/sdmc/Nintendo/save/...`.
-    // SDMC to NAND sync logic REMOVED as per user request.
-    // The emulator will no longer attempt to symlink or copy "Nintendo/save" or "SD_Cache.0000"
-    // from SDMC to the NAND user save directory.
-    // Users must ensure their save/cache structure is valid within the NAND directory itself
-    // if that is what they intend to use, or rely on the game creating it.
     const auto rw_mode = FileSys::OpenMode::ReadWrite;
 
     auto nand_directory =

src/core/hle/service/filesystem/fsp/fs_i_save_data_info_reader.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
@@ -14,7 +14,7 @@ namespace Service::FileSystem {
 
 ISaveDataInfoReader::ISaveDataInfoReader(Core::System& system_,
                                          std::shared_ptr<SaveDataController> save_data_controller_,
-                                         FileSys::SaveDataSpaceId space, bool cache_only)
+                                         FileSys::SaveDataSpaceId space)
     : ServiceFramework{system_, "ISaveDataInfoReader"}, save_data_controller{
                                                             save_data_controller_} {
     static const FunctionInfo functions[] = {
@@ -22,7 +22,7 @@ ISaveDataInfoReader::ISaveDataInfoReader(Core::System& system_,
     };
     RegisterHandlers(functions);
 
-    FindAllSaves(space, cache_only);
+    FindAllSaves(space);
 }
 
 ISaveDataInfoReader::~ISaveDataInfoReader() = default;
@@ -63,7 +63,7 @@ Result ISaveDataInfoReader::ReadSaveDataInfo(
     R_SUCCEED();
 }
 
-void ISaveDataInfoReader::FindAllSaves(FileSys::SaveDataSpaceId space, bool cache_only) {
+void ISaveDataInfoReader::FindAllSaves(FileSys::SaveDataSpaceId space) {
     FileSys::VirtualDir save_root{};
     const auto result = save_data_controller->OpenSaveDataSpace(&save_root, space);
 
@@ -74,12 +74,8 @@ void ISaveDataInfoReader::FindAllSaves(FileSys::SaveDataSpaceId space, bool cach
 
     for (const auto& type : save_root->GetSubdirectories()) {
         if (type->GetName() == "save") {
-            if (cache_only) {
-                FindCacheSaves(space, type);
-            } else {
-                FindNormalSaves(space, type);
-            }
-        } else if (space == FileSys::SaveDataSpaceId::Temporary && !cache_only) {
+            FindNormalSaves(space, type);
+        } else if (space == FileSys::SaveDataSpaceId::Temporary) {
             FindTemporaryStorageSaves(space, type);
         }
     }
@@ -88,11 +84,6 @@ void ISaveDataInfoReader::FindAllSaves(FileSys::SaveDataSpaceId space, bool cach
 void ISaveDataInfoReader::FindNormalSaves(FileSys::SaveDataSpaceId space,
                                           const FileSys::VirtualDir& type) {
     for (const auto& save_id : type->GetSubdirectories()) {
-        // Skip cache directory in normal scans
-        if (save_id->GetName() == "cache") {
-            continue;
-        }
-
         for (const auto& user_id : save_id->GetSubdirectories()) {
             // Skip non user id subdirectories
             if (user_id->GetName().size() != 0x20) {
@@ -141,96 +132,6 @@ void ISaveDataInfoReader::FindNormalSaves(FileSys::SaveDataSpaceId space,
     }
 }
 
-void ISaveDataInfoReader::FindCacheSaves(FileSys::SaveDataSpaceId space,
-                                         const FileSys::VirtualDir& type) {
-    const auto cache_dir = type->GetSubdirectory("cache");
-    if (cache_dir == nullptr) {
-        return;
-    }
-
-    for (const auto& title_id_dir : cache_dir->GetSubdirectories()) {
-        const auto title_id = stoull_be(title_id_dir->GetName());
-        // Simple validation: TitleID should be non-zero
-        if (title_id == 0) {
-            continue;
-        }
-
-        // Determine commit root (priority to "1", then "0", then self)
-        auto commit_root = title_id_dir->GetSubdirectory("1");
-        if (commit_root == nullptr) {
-            commit_root = title_id_dir->GetSubdirectory("0");
-        }
-        // If neither exists, we might fall back to title_id_dir itself if users put SD_Cache directly there,
-        // but based on SaveDataFactory we expect it inside 0 or 1.
-        if (commit_root == nullptr) {
-            // Check if SD_Cache exists directly in title_dir (legacy/fallback)
-             bool has_sd_cache_root = false;
-             for (const auto& sub : title_id_dir->GetSubdirectories()) {
-                 if (sub->GetName().find("SD_Cache.") == 0) {
-                     has_sd_cache_root = true;
-                     break;
-                 }
-             }
-             if (has_sd_cache_root) {
-                 commit_root = title_id_dir;
-             } else {
-                 continue; // No valid storage found
-             }
-        }
-
-        bool found_any = false;
-        for (const auto& sd_cache_dir : commit_root->GetSubdirectories()) {
-            const std::string& name = sd_cache_dir->GetName();
-            if (name.find("SD_Cache.") == 0) {
-                // Parse index from "SD_Cache.XXXX" (hexadecimal)
-                u64 index = 0;
-                try {
-                    if (name.size() > 9) {
-                         index = std::stoull(name.substr(9), nullptr, 16); // Base 16 for hex
-                    }
-                } catch(...) {
-                    continue;
-                }
-
-                info.emplace_back(SaveDataInfo{
-                    0,
-                    space,
-                    FileSys::SaveDataType::Cache,
-                    {}, // padding 0x6
-                    {}, // user_id (empty array match)
-                    0, // save_id
-                    title_id,
-                    sd_cache_dir->GetSize(),
-                    static_cast<u16>(index), // Correct index with cast
-                    FileSys::SaveDataRank::Primary,
-                    {}, // padding 0x25
-                });
-                found_any = true;
-            }
-        }
-
-        // Fallback for legacy "flat" cache if no SD_Cache folders found?
-        // If the user specific structure IS enforced, maybe we don't fallback.
-        // But if they have existing cache without the folder, it is effectively index 0.
-        if (!found_any) {
-             // Treat the entire commit_root as index 0 (Legacy behavior)
-             info.emplace_back(SaveDataInfo{
-                0,
-                space,
-                FileSys::SaveDataType::Cache,
-                {}, // padding 0x6
-                {}, // user_id (empty array match)
-                0, // save_id
-                title_id,
-                commit_root->GetSize(),
-                0, // index 0
-                FileSys::SaveDataRank::Primary,
-                {}, // padding 0x25
-            });
-        }
-    }
-}
-
 void ISaveDataInfoReader::FindTemporaryStorageSaves(FileSys::SaveDataSpaceId space,
                                                     const FileSys::VirtualDir& type) {
     for (const auto& user_id : type->GetSubdirectories()) {

src/core/hle/service/filesystem/fsp/fs_i_save_data_info_reader.h

@@ -16,7 +16,7 @@ class ISaveDataInfoReader final : public ServiceFramework<ISaveDataInfoReader> {
 public:
     explicit ISaveDataInfoReader(Core::System& system_,
                                  std::shared_ptr<SaveDataController> save_data_controller_,
-                                 FileSys::SaveDataSpaceId space, bool cache_only = false);
+                                 FileSys::SaveDataSpaceId space);
     ~ISaveDataInfoReader() override;
 
     struct SaveDataInfo {
@@ -38,9 +38,8 @@ public:
                             OutArray<SaveDataInfo, BufferAttr_HipcMapAlias> out_entries);
 
 private:
-    void FindAllSaves(FileSys::SaveDataSpaceId space, bool cache_only);
+    void FindAllSaves(FileSys::SaveDataSpaceId space);
     void FindNormalSaves(FileSys::SaveDataSpaceId space, const FileSys::VirtualDir& type);
-    void FindCacheSaves(FileSys::SaveDataSpaceId space, const FileSys::VirtualDir& type);
     void FindTemporaryStorageSaves(FileSys::SaveDataSpaceId space, const FileSys::VirtualDir& type);
 
     std::shared_ptr<SaveDataController> save_data_controller;

src/core/hle/service/filesystem/fsp/fsp_srv.cpp

@@ -353,10 +353,10 @@ Result FSP_SRV::OpenSaveDataInfoReaderBySaveDataSpaceId(
 
 Result FSP_SRV::OpenSaveDataInfoReaderOnlyCacheStorage(
     OutInterface<ISaveDataInfoReader> out_interface) {
-    LOG_DEBUG(Service_FS, "called");
+    LOG_WARNING(Service_FS, "(STUBBED) called");
 
     *out_interface = std::make_shared<ISaveDataInfoReader>(system, save_data_controller,
-                                                           FileSys::SaveDataSpaceId::User, true);
+                                                           FileSys::SaveDataSpaceId::Temporary);
 
     R_SUCCEED();
 }

src/core/hle/service/hle_ipc.cpp

@@ -42,16 +42,8 @@ bool SessionRequestManager::HasSessionRequestHandler(const HLERequestContext& co
         const auto& message_header = context.GetDomainMessageHeader();
         const auto object_id = message_header.object_id;
 
-        // Some games send magic numbers in the object_id field, which indicates
-        // this is not actually a proper domain request
-        const u32 sfci_magic = Common::MakeMagic('S', 'F', 'C', 'I');
-        const u32 sfco_magic = Common::MakeMagic('S', 'F', 'C', 'O');
-        if (object_id == sfci_magic || object_id == sfco_magic) {
-            // This is not a domain request, treat it as a regular session request
-            return session_handler != nullptr;
-        }
-
         if (object_id > DomainHandlerCount()) {
+            LOG_CRITICAL(IPC, "object_id {} is too big!", object_id);
             return false;
         }
         return !DomainHandler(object_id - 1).expired();
@@ -99,18 +91,7 @@ Result SessionRequestManager::HandleDomainSyncRequest(Kernel::KServerSession* se
 
     // If there is a DomainMessageHeader, then this is CommandType "Request"
     const auto& domain_message_header = context.GetDomainMessageHeader();
-    const u32 object_id = domain_message_header.object_id;
-
-    // Some games send magic numbers in the object_id field
-    const u32 sfci_magic = Common::MakeMagic('S', 'F', 'C', 'I');
-    const u32 sfco_magic = Common::MakeMagic('S', 'F', 'C', 'O');
-    if (object_id == sfci_magic || object_id == sfco_magic) {
-        // This is not a domain request, handle as regular session request
-        LOG_DEBUG(IPC, "Detected magic number 0x{:08X} in object_id, treating as regular session request. Command={}",
-                  object_id, context.GetCommand());
-        return session_handler->HandleSyncRequest(*server_session, context);
-    }
-
+    const u32 object_id{domain_message_header.object_id};
     switch (domain_message_header.command) {
     case IPC::DomainMessageHeader::CommandType::SendMessage:
         if (object_id > this->DomainHandlerCount()) {
@@ -219,17 +200,7 @@ void HLERequestContext::ParseCommandBuffer(u32_le* src_cmdbuf, bool incoming) {
             // If this is an incoming message, only CommandType "Request" has a domain header
             // All outgoing domain messages have the domain header, if only incoming has it
             if (incoming || domain_message_header) {
-                // Check if the next value is actually a magic number (SFCI/SFCO)
-                // Some games send these in the object_id field, indicating this is not a domain request
-                const u32 possible_object_id = src_cmdbuf[rp.GetCurrentOffset() + 1]; // object_id is second field
-                const u32 sfci_magic = Common::MakeMagic('S', 'F', 'C', 'I');
-                const u32 sfco_magic = Common::MakeMagic('S', 'F', 'C', 'O');
-
-                if (possible_object_id != sfci_magic && possible_object_id != sfco_magic) {
-                    // This is a proper domain request
-                    domain_message_header = rp.PopRaw<IPC::DomainMessageHeader>();
-                }
-                // If it's a magic number, skip reading the domain header entirely
+                domain_message_header = rp.PopRaw<IPC::DomainMessageHeader>();
             } else {
                 if (GetManager()->IsDomain()) {
                     LOG_WARNING(IPC, "Domain request has no DomainMessageHeader!");
@@ -249,15 +220,9 @@ void HLERequestContext::ParseCommandBuffer(u32_le* src_cmdbuf, bool incoming) {
         }
 
         if (incoming) {
-            // Only check magic if we have a valid data payload header
-            // When domain header is skipped (SFCI in object_id), the structure is different
-            if (domain_message_header) {
-                ASSERT(data_payload_header->magic == Common::MakeMagic('S', 'F', 'C', 'I'));
-            }
+            ASSERT(data_payload_header->magic == Common::MakeMagic('S', 'F', 'C', 'I'));
         } else {
-            if (domain_message_header) {
-                ASSERT(data_payload_header->magic == Common::MakeMagic('S', 'F', 'C', 'O'));
-            }
+            ASSERT(data_payload_header->magic == Common::MakeMagic('S', 'F', 'C', 'O'));
         }
     }
 

src/core/hle/service/nfc/nfc_types.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
@@ -82,7 +79,7 @@ using DeviceHandle = u64;
 
 // This is nn::nfc::TagInfo
 struct TagInfo {
-    UniqueSerialNumber uuid{};
+    UniqueSerialNumber uuid;
     u8 uuid_length;
     INSERT_PADDING_BYTES(0x15);
     NfcProtocol protocol;

src/core/hle/service/nfp/nfp_types.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
@@ -318,7 +315,7 @@ static_assert(sizeof(ModelInfo) == 0x40, "ModelInfo is an invalid size");
 // This is nn::nfp::RegisterInfo
 struct RegisterInfo {
     Service::Mii::CharInfo mii_char_info;
-    WriteDate creation_date{};
+    WriteDate creation_date;
     AmiiboName amiibo_name;
     u8 font_region;
     INSERT_PADDING_BYTES(0x7A);

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

@@ -164,7 +164,7 @@ IPlatformServiceManager::IPlatformServiceManager(Core::System& system_, const ch
     // Rebuild shared fonts from data ncas or synthesize
 
     impl->shared_font = std::make_shared<Kernel::PhysicalMemory>(SHARED_FONT_MEM_SIZE);
-    for (auto& font : SHARED_FONTS) {
+    for (auto font : SHARED_FONTS) {
         FileSys::VirtualFile romfs;
         const auto nca =
             nand->GetEntry(static_cast<u64>(font.first), FileSys::ContentRecordType::Data);
@@ -261,7 +261,7 @@ Result IPlatformServiceManager::GetSharedFontInOrderOfPriority(
                                     out_font_sizes.size(), impl->shared_font_regions.size()});
 
     for (size_t i = 0; i < max_size; i++) {
-        auto& region = impl->GetSharedFontRegion(i);
+        auto region = impl->GetSharedFontRegion(i);
 
         out_font_codes[i] = static_cast<u32>(i);
         out_font_offsets[i] = region.offset;

src/core/hle/service/nvdrv/devices/nvhost_nvdec.cpp

@@ -66,9 +66,7 @@ NvResult nvhost_nvdec::Ioctl3(DeviceFD fd, Ioctl command, std::span<const u8> in
 
 void nvhost_nvdec::OnOpen(NvCore::SessionId session_id, DeviceFD fd) {
     LOG_INFO(Service_NVDRV, "NVDEC video stream started");
-    if (!system.GetNVDECActive()) {
-        system.SetNVDECActive(true);
-    }
+    system.SetNVDECActive(true);
     sessions[fd] = session_id;
     host1x.StartDevice(fd, Tegra::Host1x::ChannelType::NvDec, channel_syncpoint);
 }

src/core/hle/service/sockets/bsd.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
@@ -22,9 +22,6 @@
 #include "core/internal_network/sockets.h"
 #include "network/network.h"
 #include <common/settings.h>
-#include "common/fs/file.h"
-#include "common/fs/path_util.h"
-#include "common/string_util.h"
 
 using Common::Expected;
 using Common::Unexpected;
@@ -318,15 +315,7 @@ void BSD::Fcntl(HLERequestContext& ctx) {
     const u32 cmd = rp.Pop<u32>();
     const s32 arg = rp.Pop<s32>();
 
-    // Log with more detail to understand non-blocking configuration
-    if (cmd == 4) { // SETFL
-        bool is_nonblock = (arg & 0x800) != 0; // O_NONBLOCK
-        LOG_INFO(Service, "Fcntl SETFL fd={} arg={} (non-blocking={})", fd, arg, is_nonblock);
-    } else if (cmd == 3) { // GETFL
-        LOG_INFO(Service, "Fcntl GETFL fd={}", fd);
-    } else {
-        LOG_INFO(Service, "Fcntl fd={} cmd={} arg={}", fd, cmd, arg);
-    }
+    LOG_DEBUG(Service, "called. fd={} cmd={} arg={}", fd, cmd, arg);
 
     const auto [ret, bsd_errno] = FcntlImpl(fd, static_cast<FcntlCmd>(cmd), arg);
 
@@ -813,40 +802,33 @@ Errno BSD::SetSockOptImpl(s32 fd, u32 level, OptName optname, std::span<const u8
 
     switch (optname) {
     case OptName::REUSEADDR:
-        LOG_INFO(Service, "SetSockOpt fd={} REUSEADDR={}", fd, value);
         if (value != 0 && value != 1) {
             LOG_WARNING(Service, "Invalid REUSEADDR value: {}", value);
             return Errno::INVAL;
         }
         return Translate(socket->SetReuseAddr(value != 0));
     case OptName::KEEPALIVE:
-        LOG_INFO(Service, "SetSockOpt fd={} KEEPALIVE={}", fd, value);
         if (value != 0 && value != 1) {
             LOG_WARNING(Service, "Invalid KEEPALIVE value: {}", value);
             return Errno::INVAL;
         }
         return Translate(socket->SetKeepAlive(value != 0));
     case OptName::BROADCAST:
-        LOG_INFO(Service, "SetSockOpt fd={} BROADCAST={}", fd, value);
         if (value != 0 && value != 1) {
             LOG_WARNING(Service, "Invalid BROADCAST value: {}", value);
             return Errno::INVAL;
         }
         return Translate(socket->SetBroadcast(value != 0));
     case OptName::SNDBUF:
-        LOG_INFO(Service, "SetSockOpt fd={} SNDBUF={}", fd, value);
         return Translate(socket->SetSndBuf(value));
     case OptName::RCVBUF:
-        LOG_INFO(Service, "SetSockOpt fd={} RCVBUF={}", fd, value);
         return Translate(socket->SetRcvBuf(value));
     case OptName::SNDTIMEO:
-        LOG_INFO(Service, "SetSockOpt fd={} SNDTIMEO={}", fd, value);
         return Translate(socket->SetSndTimeo(value));
     case OptName::RCVTIMEO:
-        LOG_INFO(Service, "SetSockOpt fd={} RCVTIMEO={}", fd, value);
         return Translate(socket->SetRcvTimeo(value));
     case OptName::NOSIGPIPE:
-        LOG_INFO(Service, "SetSockOpt fd={} NOSIGPIPE={}", fd, value);
+        LOG_WARNING(Service, "(STUBBED) setting NOSIGPIPE to {}", value);
         return Errno::SUCCESS;
     default:
         LOG_WARNING(Service, "(STUBBED) Unimplemented optname={} (0x{:x}), returning INVAL",
@@ -937,134 +919,12 @@ std::pair<s32, Errno> BSD::RecvFromImpl(s32 fd, u32 flags, std::vector<u8>& mess
     return {ret, bsd_errno};
 }
 
-    std::pair<s32, Errno> BSD::SendImpl(s32 fd, u32 flags, std::span<const u8> message) {
-        if (!IsFileDescriptorValid(fd)) {
-            return {-1, Errno::BADF};
-        }
-
-        const size_t original_size = message.size();
-
-        // Inspect for Authorization header to inject custom token (HTTP/Localhost support)
-        const std::string_view data_view(reinterpret_cast<const char*>(message.data()),
-                                         message.size());
-
-        // Optimized check: only look if it looks like an HTTP request with auth
-        // We do a case-insensitive search for the specific header pattern
-        std::string request_str(data_view);
-        std::string request_lower = Common::ToLower(request_str);
-
-        size_t auth_pos = request_lower.find("authorization: switch t=");
-
-        if (auth_pos != std::string::npos) {
-            LOG_INFO(Service,
-                     "BSDJ: Found 'Authorization: switch t=' in SendImpl. Injecting custom auth.");
-
-            const auto auth_file_path =
-                Common::FS::GetEdenPath(Common::FS::EdenPath::EdenDir) / "jdlo_auth.ini";
-            Common::FS::IOFile auth_file(auth_file_path, Common::FS::FileAccessMode::Read,
-                                         Common::FS::FileType::TextFile);
-
-            if (auth_file.IsOpen()) {
-                std::vector<u8> file_content_vec(auth_file.GetSize());
-                if (auth_file.Read(file_content_vec) == file_content_vec.size()) {
-                    std::string encoded_content(file_content_vec.begin(), file_content_vec.end());
-
-                    // Simple Base64 Decoder
-                    auto DecodeBase64 = [](std::string_view input) -> std::string {
-                        static const int T[256] = {
-                            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-                            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-                            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63,
-                            52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1,
-                            -1, 0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14,
-                            15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1,
-                            -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
-                            41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1};
-
-                        std::string out;
-                        int val = 0, valb = -8;
-                        for (unsigned char c : input) {
-                            if (T[c] == -1)
-                                break;
-                            val = (val << 6) + T[c];
-                            valb += 6;
-                            if (valb >= 0) {
-                                out.push_back(char((val >> valb) & 0xFF));
-                                valb -= 8;
-                            }
-                        }
-                        return out;
-                    };
-
-                    // Decode the INI content
-                    std::string file_content = DecodeBase64(encoded_content);
-
-                    // Find TickedId
-                    std::string auth_token;
-                    static constexpr std::string_view KeyName = "TickedId=";
-                    size_t key_pos = file_content.find(KeyName);
-
-                    if (key_pos != std::string::npos) {
-                        size_t value_start = key_pos + KeyName.size();
-                        size_t value_end = file_content.find_first_of("\r\n", value_start);
-                        if (value_end == std::string::npos) {
-                            value_end = file_content.size();
-                        }
-                        auth_token = file_content.substr(value_start, value_end - value_start);
-                    }
-
-                    if (!auth_token.empty()) {
-                        // Ensure the token has the correct prefix "uplaypc_v1 t="
-                        if (auth_token.find("uplaypc_v1 t=") == std::string::npos) {
-                            auth_token = "uplaypc_v1 t=" + auth_token;
-                        }
-
-                        // Find end of the line
-                        size_t end_pos = request_str.find("\r\n", auth_pos);
-                        if (end_pos != std::string::npos) {
-                            bool is_header_start = (auth_pos == 0) || (request_str[auth_pos - 1] == '\n');
-
-                            if (is_header_start) {
-                                LOG_INFO(Service, "BSDJ: Injecting token (TickedId): {}...",
-                                         auth_token.substr(0, 20));
-
-                                std::string new_header = "Authorization: " + auth_token;
-                                request_str.replace(auth_pos, end_pos - auth_pos, new_header);
-
-                                // Send the MODIFIED message
-                                std::span<const u8> new_message(
-                                    reinterpret_cast<const u8*>(request_str.data()),
-                                    request_str.size());
-                                auto result = Translate(
-                                    file_descriptors[fd]->socket->Send(new_message, flags));
-                                LOG_CRITICAL(
-                                    Service,
-                                    "SendImpl (Modified) real_sent={} original_size={} errno={}",
-                                    result.first, original_size, static_cast<int>(result.second));
-
-                                // Mask the return size: If we successfully sent the larger buffer,
-                                // tell the guest we sent exactly what they asked for.
-                                if (result.first > 0 && result.second == Errno::SUCCESS) {
-                                    // Return original size to prevent guest confusion
-                                    return {static_cast<s32>(original_size), Errno::SUCCESS};
-                                }
-                                return result;
-                            }
-                        }
-                    }
-                }
-            } else {
-                // LOG_WARNING(Service, "jdlo_auth.ini not found");
-            }
-        }
-
-        LOG_CRITICAL(Service, "SendImpl called: fd={}, size={} bytes, flags={}", fd, message.size(),
-                     flags);
-        auto result = Translate(file_descriptors[fd]->socket->Send(message, flags));
-        LOG_CRITICAL(Service, "SendImpl result: sent={} bytes, errno={}", result.first,
-                     static_cast<int>(result.second));
-        return result;
+std::pair<s32, Errno> BSD::SendImpl(s32 fd, u32 flags, std::span<const u8> message) {
+    if (!IsFileDescriptorValid(fd)) {
+        return {-1, Errno::BADF};
     }
+    return Translate(file_descriptors[fd]->socket->Send(message, flags));
+}
 
 std::pair<s32, Errno> BSD::SendToImpl(s32 fd, u32 flags, std::span<const u8> message,
                                       std::span<const u8> addr) {

src/core/hle/service/sockets/nsd.cpp

@@ -60,29 +60,12 @@ NSD::NSD(Core::System& system_, const char* name) : ServiceFramework{system_, na
     RegisterHandlers(functions);
 }
 
-
-static const std::vector<std::pair<std::string, std::string>> redirectionRules = {
-    {"public-ubiservices.com", "jdlo.ovosimpatico.com"},
-    {"public-ubiservices.ubi.com", "jdlo.ovosimpatico.com"},
-};
-
-static std::string GetRedirectedHost(const std::string& host) {
-    for (const auto& rule : redirectionRules) {
-        if (host.find(rule.first) != std::string::npos) {
-            LOG_INFO(Service, "Redirecting NSD host '{}' to '{}'", host, rule.second);
-            return rule.second;
-        }
-    }
-    return host;
-}
-
 static std::string ResolveImpl(const std::string& fqdn_in) {
     // The real implementation makes various substitutions.
     // For now we just return the string as-is, which is good enough when not
     // connecting to real Nintendo servers.
     LOG_WARNING(Service, "(STUBBED) called, fqdn_in={}", fqdn_in);
-
-    return GetRedirectedHost(fqdn_in);
+    return fqdn_in;
 }
 
 static Result ResolveCommon(const std::string& fqdn_in, std::array<char, 0x100>& fqdn_out) {

src/core/hle/service/sockets/sfdnsres.cpp

@@ -29,13 +29,13 @@ SFDNSRES::SFDNSRES(Core::System& system_) : ServiceFramework{system_, "sfdnsres"
         {4, nullptr, "GetHostStringErrorRequest"},
         {5, &SFDNSRES::GetGaiStringErrorRequest, "GetGaiStringErrorRequest"},
         {6, &SFDNSRES::GetAddrInfoRequest, "GetAddrInfoRequest"},
-        {7, &SFDNSRES::GetNameInfoRequest, "GetNameInfoRequest"},
-        {8, &SFDNSRES::RequestCancelHandleRequest, "RequestCancelHandleRequest"},
+        {7, nullptr, "GetNameInfoRequest"},
+        {8, nullptr, "RequestCancelHandleRequest"},
         {9, nullptr, "CancelRequest"},
         {10, &SFDNSRES::GetHostByNameRequestWithOptions, "GetHostByNameRequestWithOptions"},
         {11, nullptr, "GetHostByAddrRequestWithOptions"},
         {12, &SFDNSRES::GetAddrInfoRequestWithOptions, "GetAddrInfoRequestWithOptions"},
-        {13, &SFDNSRES::GetNameInfoRequestWithOptions, "GetNameInfoRequestWithOptions"},
+        {13, nullptr, "GetNameInfoRequestWithOptions"},
         {14, &SFDNSRES::ResolverSetOptionRequest, "ResolverSetOptionRequest"},
         {15, nullptr, "ResolverGetOptionRequest"},
     };
@@ -66,21 +66,6 @@ static bool IsBlockedHost(const std::string& host) {
         [&host](const std::string& domain) { return host.find(domain) != std::string::npos; });
 }
 
-static const std::vector<std::pair<std::string, std::string>> redirectionRules = {
-    {"public-ubiservices.com", "jdlo.ovosimpatico.com"},
-    {"public-ubiservices.ubi.com", "jdlo.ovosimpatico.com"},
-};
-
-static std::string GetRedirectedHost(const std::string& host) {
-    for (const auto& rule : redirectionRules) {
-        if (host.find(rule.first) != std::string::npos) {
-            LOG_INFO(Service, "Redirecting host '{}' to '{}'", host, rule.second);
-            return rule.second;
-        }
-    }
-    return host;
-}
-
 static NetDbError GetAddrInfoErrorToNetDbError(GetAddrInfoError result) {
     // These combinations have been verified on console (but are not
     // exhaustive).
@@ -178,8 +163,7 @@ static std::pair<u32, GetAddrInfoError> GetHostByNameRequestImpl(HLERequestConte
         parameters.use_nsd_resolve, parameters.cancel_handle, parameters.process_id);
 
     const auto host_buffer = ctx.ReadBuffer(0);
-    std::string host = Common::StringFromBuffer(host_buffer);
-    host = GetRedirectedHost(host);
+    const std::string host = Common::StringFromBuffer(host_buffer);
     // For now, ignore options, which are in input buffer 1 for GetHostByNameRequestWithOptions.
 
     // Prevent resolution of Nintendo servers
@@ -297,8 +281,7 @@ static std::pair<u32, GetAddrInfoError> GetAddrInfoRequestImpl(HLERequestContext
     // before looking up.
 
     const auto host_buffer = ctx.ReadBuffer(0);
-    std::string host = Common::StringFromBuffer(host_buffer);
-    host = GetRedirectedHost(host);
+    const std::string host = Common::StringFromBuffer(host_buffer);
 
     // Prevent resolution of Nintendo servers
     if (IsBlockedHost(host)) {
@@ -381,120 +364,6 @@ void SFDNSRES::GetAddrInfoRequestWithOptions(HLERequestContext& ctx) {
     });
 }
 
-
-void SFDNSRES::GetNameInfoRequest(HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto addr_in = rp.PopRaw<SockAddrIn>();
-    const u32 flags = rp.Pop<u32>();
-    const u32 cancel_handle = rp.Pop<u32>();
-    const u64 process_id = rp.Pop<u64>();
-
-    LOG_DEBUG(Service, "called. flags={}, cancel_handle={}, process_id={}", flags, cancel_handle,
-              process_id);
-
-    struct OutputParameters {
-        u32 data_size;
-        GetAddrInfoError gai_error;
-        NetDbError netdb_error;
-        Errno bsd_errno;
-    };
-    static_assert(sizeof(OutputParameters) == 0x10);
-
-    const auto res = Network::GetNameInfo(Translate(addr_in));
-    if (res.second != 0) {
-        const auto network_error = Network::TranslateGetAddrInfoErrorFromNative(res.second);
-        const auto service_error = Translate(network_error);
-        IPC::ResponseBuilder rb{ctx, 6};
-        rb.Push(ResultSuccess);
-        rb.PushRaw(OutputParameters{
-            .data_size = 0,
-            .gai_error = service_error,
-            .netdb_error = GetAddrInfoErrorToNetDbError(service_error),
-            .bsd_errno = GetAddrInfoErrorToErrno(service_error),
-        });
-        return;
-    }
-
-    const std::string& host = res.first;
-    const u32 data_size = static_cast<u32>(host.size() + 1);
-
-    ctx.WriteBuffer(host.data(), data_size, 0);
-
-    IPC::ResponseBuilder rb{ctx, 6};
-    rb.Push(ResultSuccess);
-    rb.PushRaw(OutputParameters{
-        .data_size = data_size,
-        .gai_error = GetAddrInfoError::SUCCESS,
-        .netdb_error = NetDbError::Success,
-        .bsd_errno = Errno::SUCCESS,
-    });
-}
-
-void SFDNSRES::GetNameInfoRequestWithOptions(HLERequestContext& ctx) {
-    struct InputParameters {
-        u32 flags;
-        u32 interface_index;
-        u64 process_id;
-        u32 padding; // 0x14 + 4 = 0x18? No. 0x14 aligned to 8 bytes?
-        // Wait, sizeof(InputParameters) == 0x14.
-    };
-    // Derived from partial snippets:
-    // u32 flags, u32 interface_index, u64 process_id.
-    // 4 + 4 + 8 = 16 bytes (0x10).
-    // The previous prompt had static_assert size 0x14.
-    // Maybe a u32 padding?
-
-    // Let's rely on standard layout.
-    // I will use manual popping for safety if struct definition is unknown.
-
-    IPC::RequestParser rp{ctx};
-    const auto addr_in = rp.PopRaw<SockAddrIn>();
-    const u32 flags = rp.Pop<u32>();
-    const u32 interface_index = rp.Pop<u32>();
-    const u64 process_id = rp.Pop<u64>();
-    (void)flags;
-    (void)interface_index;
-    (void)process_id;
-    // If there was padding, it might be implicitly popped or ignored.
-
-    struct OutputParameters {
-        u32 data_size;
-        GetAddrInfoError gai_error;
-        NetDbError netdb_error;
-        Errno bsd_errno;
-    };
-    static_assert(sizeof(OutputParameters) == 0x10);
-
-    const auto res = Network::GetNameInfo(Translate(addr_in));
-    if (res.second != 0) {
-        const auto network_error = Network::TranslateGetAddrInfoErrorFromNative(res.second);
-        const auto service_error = Translate(network_error);
-        IPC::ResponseBuilder rb{ctx, 6};
-        rb.Push(ResultSuccess);
-        rb.PushRaw(OutputParameters{
-            .data_size = 0,
-            .gai_error = service_error,
-            .netdb_error = GetAddrInfoErrorToNetDbError(service_error),
-            .bsd_errno = GetAddrInfoErrorToErrno(service_error),
-        });
-        return;
-    }
-
-    const std::string& host = res.first;
-    const u32 data_size = static_cast<u32>(host.size() + 1);
-
-    ctx.WriteBuffer(host.data(), data_size, 0);
-
-    IPC::ResponseBuilder rb{ctx, 6};
-    rb.Push(ResultSuccess);
-    rb.PushRaw(OutputParameters{
-        .data_size = data_size,
-        .gai_error = GetAddrInfoError::SUCCESS,
-        .netdb_error = NetDbError::Success,
-        .bsd_errno = Errno::SUCCESS,
-    });
-}
-
 void SFDNSRES::ResolverSetOptionRequest(HLERequestContext& ctx) {
     LOG_WARNING(Service, "(STUBBED) called");
 
@@ -503,24 +372,4 @@ void SFDNSRES::ResolverSetOptionRequest(HLERequestContext& ctx) {
     rb.Push(ResultSuccess);
     rb.Push<s32>(0); // bsd errno
 }
-
-void SFDNSRES::RequestCancelHandleRequest(HLERequestContext& ctx) {
-    // This is just a stub for now.
-    // In a real implementation this would likely cancel a pending request represented by the handle.
-    LOG_WARNING(Service, "(STUBBED) called");
-
-    struct InputParameters {
-        u32 cancel_handle;
-    };
-    IPC::RequestParser rp{ctx};
-    auto input = rp.PopRaw<InputParameters>();
-
-    LOG_DEBUG(Service, "cancel_handle={}", input.cancel_handle);
-
-    IPC::ResponseBuilder rb{ctx, 4};
-    rb.Push(ResultSuccess);
-    rb.Push<u32>(0); // cancel_handle (response seems to echo it or return a new one? usually just an error code or unrelated)
-                     // Actually based on typical patterns, it probably returns an error code (bsd_errno).
-    rb.Push<s32>(0); // bsd_errno
-}
 } // namespace Service::Sockets

src/core/hle/service/sockets/sfdnsres.h

@@ -22,10 +22,7 @@ private:
     void GetHostByNameRequestWithOptions(HLERequestContext& ctx);
     void GetAddrInfoRequest(HLERequestContext& ctx);
     void GetAddrInfoRequestWithOptions(HLERequestContext& ctx);
-    void GetNameInfoRequest(HLERequestContext& ctx);
-    void GetNameInfoRequestWithOptions(HLERequestContext& ctx);
     void ResolverSetOptionRequest(HLERequestContext& ctx);
-    void RequestCancelHandleRequest(HLERequestContext& ctx);
 };
 
 } // namespace Service::Sockets

src/core/hle/service/sockets/sockets.h

@@ -16,12 +16,10 @@ enum class Errno : u32 {
     SUCCESS = 0,
     BADF = 9,
     AGAIN = 11,
-    ACCES = 13,
     INVAL = 22,
     MFILE = 24,
     PIPE = 32,
     MSGSIZE = 90,
-    ADDRINUSE = 98,
     CONNABORTED = 103,
     CONNRESET = 104,
     NOTCONN = 107,

src/core/hle/service/sockets/sockets_translate.cpp

@@ -37,10 +37,6 @@ Errno Translate(Network::Errno value) {
         return Errno::CONNRESET;
     case Network::Errno::INPROGRESS:
         return Errno::INPROGRESS;
-    case Network::Errno::ACCES:
-        return Errno::ACCES;
-    case Network::Errno::ADDRINUSE:
-        return Errno::ADDRINUSE;
     default:
         UNIMPLEMENTED_MSG("Unimplemented errno={}", value);
         return Errno::SUCCESS;
@@ -265,9 +261,7 @@ PollEvents Translate(Network::PollEvents flags) {
 Network::SockAddrIn Translate(SockAddrIn value) {
     // Note: 6 is incorrect, but can be passed by homebrew (because libnx sets
     // sin_len to 6 when deserializing getaddrinfo results).
-    if (value.len != 0 && value.len != sizeof(value) && value.len != 6) {
-        LOG_WARNING(Service, "Unexpected SockAddrIn length={}", value.len);
-    }
+    ASSERT(value.len == 0 || value.len == sizeof(value) || value.len == 6);
 
     return {
         .family = Translate(static_cast<Domain>(value.family)),

src/core/hle/service/ssl/ssl.cpp

@@ -117,20 +117,15 @@ public:
         RegisterHandlers(functions);
 
         shared_data->connection_count++;
-        LOG_CRITICAL(Service_SSL, "ISslConnection created! Total connections: {}", shared_data->connection_count);
     }
 
     ~ISslConnection() {
         shared_data->connection_count--;
         if (fd_to_close.has_value()) {
             const s32 fd = *fd_to_close;
-            if (do_not_close_socket) {
-                // If we aren't supposed to close the socket, but we have an fd_to_close,
-                // that means the configuration changed after we took ownership.
-                // This is weird but we should probably honor the flag.
-                // However, the original valid logic seemed to imply we duped the socket
-                // and should close our dup... but let's stick to what the flag says.
-                LOG_INFO(Service_SSL, "do_not_close_socket is true, skipping close of fd {}", fd);
+            if (!do_not_close_socket) {
+                LOG_ERROR(Service_SSL,
+                          "do_not_close_socket was changed after setting socket; is this right?");
             } else {
                 auto bsd = system.ServiceManager().GetService<Service::Sockets::BSD>("bsd:u");
                 if (bsd) {
@@ -274,17 +269,16 @@ private:
     }
 
     Result PendingImpl(s32* out_pending) {
-        ASSERT_OR_EXECUTE(did_handshake, { return ResultInternalError; });
-        return backend->Pending(out_pending);
+        LOG_WARNING(Service_SSL, "(STUBBED) called.");
+        *out_pending = 0;
+        return ResultSuccess;
     }
 
     void SetSocketDescriptor(HLERequestContext& ctx) {
         IPC::RequestParser rp{ctx};
         const s32 in_fd = rp.Pop<s32>();
-        LOG_CRITICAL(Service_SSL, "SetSocketDescriptor called with fd={}", in_fd);
         s32 out_fd{-1};
         const Result res = SetSocketDescriptorImpl(&out_fd, in_fd);
-        LOG_CRITICAL(Service_SSL, "SetSocketDescriptor result: res={}, out_fd={}", res.raw, out_fd);
         IPC::ResponseBuilder rb{ctx, 3};
         rb.Push(res);
         rb.Push<s32>(out_fd);
@@ -314,9 +308,7 @@ private:
     }
 
     void DoHandshake(HLERequestContext& ctx) {
-        LOG_INFO(Service_SSL, "DoHandshake called, socket={}", socket != nullptr);
         const Result res = DoHandshakeImpl();
-        LOG_INFO(Service_SSL, "DoHandshake result: {}, did_handshake={}", res.raw, did_handshake);
         IPC::ResponseBuilder rb{ctx, 2};
         rb.Push(res);
     }

src/core/hle/service/ssl/ssl_backend.h

@@ -38,7 +38,6 @@ public:
     virtual Result Read(size_t* out_size, std::span<u8> data) = 0;
     virtual Result Write(size_t* out_size, std::span<const u8> data) = 0;
     virtual Result GetServerCerts(std::vector<std::vector<u8>>* out_certs) = 0;
-    virtual Result Pending(s32* out_pending) = 0;
 };
 
 Result CreateSSLConnectionBackend(std::unique_ptr<SSLConnectionBackend>* out_backend);

src/core/hle/service/ssl/ssl_backend_openssl.cpp

@@ -12,7 +12,6 @@
 #include <openssl/x509.h>
 
 #include "common/fs/file.h"
-#include "common/fs/path_util.h"
 #include "common/hex_util.h"
 #include "common/string_util.h"
 
@@ -49,32 +48,28 @@ bool OneTimeInitBIO();
 #ifdef YUZU_BUNDLED_OPENSSL
 // This is ported from httplib
 struct scope_exit {
-    explicit scope_exit(std::function<void(void)> &&f)
-        : exit_function(std::move(f)), execute_on_destruction{true} {}
+  explicit scope_exit(std::function<void(void)> &&f)
+      : exit_function(std::move(f)), execute_on_destruction{true} {}
 
-    scope_exit(scope_exit &&rhs) noexcept
-        : exit_function(std::move(rhs.exit_function)),
-          execute_on_destruction{rhs.execute_on_destruction} {
-        rhs.release();
-    }
+  scope_exit(scope_exit &&rhs) noexcept
+      : exit_function(std::move(rhs.exit_function)),
+        execute_on_destruction{rhs.execute_on_destruction} {
+    rhs.release();
+  }
 
-    ~scope_exit() {
-        if (execute_on_destruction) {
-            this->exit_function();
-        }
-    }
+  ~scope_exit() {
+    if (execute_on_destruction) { this->exit_function(); }
+  }
 
-    void release() {
-        this->execute_on_destruction = false;
-    }
+  void release() { this->execute_on_destruction = false; }
 
 private:
-    scope_exit(const scope_exit &) = delete;
-    void operator=(const scope_exit &) = delete;
-    scope_exit &operator=(scope_exit &&) = delete;
+  scope_exit(const scope_exit &) = delete;
+  void operator=(const scope_exit &) = delete;
+  scope_exit &operator=(scope_exit &&) = delete;
 
-    std::function<void(void)> exit_function;
-    bool execute_on_destruction;
+  std::function<void(void)> exit_function;
+  bool execute_on_destruction;
 };
 
 inline X509_STORE *CreateCaCertStore(const char *ca_cert,
@@ -120,22 +115,6 @@ inline void LoadCaCertStore(SSL_CTX* ctx, const char* ca_cert, std::size_t size)
 }
 #endif
 
-
-static const std::vector<std::pair<std::string, std::string>> redirectionRules = {
-    {"public-ubiservices.com", "jdlo.ovosimpatico.com"},
-    {"public-ubiservices.ubi.com", "jdlo.ovosimpatico.com"},
-};
-
-static std::string GetRedirectedHost(const std::string& host) {
-    for (const auto& rule : redirectionRules) {
-        if (host.find(rule.first) != std::string::npos) {
-            LOG_INFO(Service_SSL, "Redirecting SSL host '{}' to '{}'", host, rule.second);
-            return rule.second;
-        }
-    }
-    return host;
-}
-
 } // namespace
 
 class SSLConnectionBackendOpenSSL final : public SSLConnectionBackend {
@@ -178,8 +157,7 @@ public:
         socket = std::move(socket_in);
     }
 
-    Result SetHostName(const std::string& hostname_in) override {
-        const std::string hostname = GetRedirectedHost(hostname_in);
+    Result SetHostName(const std::string& hostname) override {
         if (!SSL_set1_host(ssl, hostname.c_str())) { // hostname for verification
             LOG_ERROR(Service_SSL, "SSL_set1_host({}) failed", hostname);
             return CheckOpenSSLErrors();
@@ -217,123 +195,6 @@ public:
     }
 
     Result Write(size_t* out_size, std::span<const u8> data) override {
-        const size_t original_size = data.size();
-        const std::string_view data_view(reinterpret_cast<const char*>(data.data()), data.size());
-
-        // Log all POST requests for debugging
-        if (data_view.size() > 5 && data_view.substr(0, 5) == "POST ") {
-             LOG_INFO(Service_SSL, "Intercepted POST request. Length: {}. Preview: {}", data.size(), data_view.substr(0, std::min(data_view.size(), size_t(200))));
-        }
-
-        std::string request_str(data_view);
-        std::string request_lower = Common::ToLower(request_str);
-
-        // Look for the specific authorization header value we want to replace: "switch t="
-        // We match "authorization: switch t=" case-insensitively
-        size_t auth_pos = request_lower.find("authorization: switch t=");
-
-        if (auth_pos != std::string::npos) {
-            LOG_INFO(Service_SSL, "Found 'Authorization: switch t=' header. Injecting custom auth.");
-
-            const auto auth_file_path = Common::FS::GetEdenPath(Common::FS::EdenPath::EdenDir) / "jdlo_auth.ini";
-            Common::FS::IOFile auth_file(auth_file_path, Common::FS::FileAccessMode::Read, Common::FS::FileType::TextFile);
-            if (auth_file.IsOpen()) {
-                std::vector<u8> file_content_vec(auth_file.GetSize());
-                if (auth_file.Read(file_content_vec) == file_content_vec.size()) {
-                    std::string encoded_content(file_content_vec.begin(), file_content_vec.end());
-
-                    // Simple Base64 Decoder
-                    auto DecodeBase64 = [](std::string_view input) -> std::string {
-                        static const int T[256] = {
-                            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-                            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-                            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63,
-                            52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1,
-                            -1, 0,  1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14,
-                            15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1,
-                            -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
-                            41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1};
-
-                        std::string out;
-                        int val = 0, valb = -8;
-                        for (unsigned char c : input) {
-                            if (T[c] == -1)
-                                break;
-                            val = (val << 6) + T[c];
-                            valb += 6;
-                            if (valb >= 0) {
-                                out.push_back(char((val >> valb) & 0xFF));
-                                valb -= 8;
-                            }
-                        }
-                        return out;
-                    };
-
-                    // Decode the INI content
-                    std::string file_content = DecodeBase64(encoded_content);
-
-                    // Find TickedId
-                    std::string auth_token;
-                    static constexpr std::string_view KeyName = "TickedId=";
-                    size_t key_pos = file_content.find(KeyName);
-
-                    if (key_pos != std::string::npos) {
-                        size_t value_start = key_pos + KeyName.size();
-                        size_t value_end = file_content.find_first_of("\r\n", value_start);
-                        if (value_end == std::string::npos) {
-                            value_end = file_content.size();
-                        }
-                        auth_token = file_content.substr(value_start, value_end - value_start);
-                    } else {
-                        // Fallback: If not found, maybe it wasn't base64 or format is different?
-                        // Try using raw content if decode failed to produce readable key?
-                        // Actually, let's just stick to the decoded content.
-                    }
-
-                    if (!auth_token.empty()) {
-                        // Ensure the token has the correct prefix "uplaypc_v1 t="
-                        if (auth_token.find("uplaypc_v1 t=") == std::string::npos) {
-                            auth_token = "uplaypc_v1 t=" + auth_token;
-                        }
-
-                        LOG_INFO(Service_SSL,
-                                 "Injecting custom Authorization from jdlo_auth.ini (decoded "
-                                 "TickedId): {}...",
-                                 auth_token.substr(0, 20));
-
-                        // Find existing Authorization header position case-insensitively
-                        size_t header_pos = request_lower.find("\r\nauthorization: ");
-
-                        if (header_pos != std::string::npos) {
-                            size_t end_pos = request_str.find("\r\n", header_pos + 2);
-                            if (end_pos != std::string::npos) {
-                                LOG_INFO(Service_SSL, "Replacing existing Authorization header.");
-                                request_str.replace(header_pos, end_pos - header_pos,
-                                                    "\r\nAuthorization: " + auth_token);
-                            }
-                        } else {
-                            LOG_INFO(Service_SSL, "Appending new Authorization header.");
-                            size_t body_pos = request_str.find("\r\n\r\n");
-                            if (body_pos != std::string::npos) {
-                                request_str.insert(body_pos, "\r\nAuthorization: " + auth_token);
-                            }
-                        }
-
-                        const int ret = SSL_write_ex(ssl, request_str.data(), request_str.size(), out_size);
-                        if (ret == 1) { // Success
-                            *out_size = original_size;
-                        }
-                        return HandleReturn("SSL_write_ex", out_size, ret);
-                    }
-                } else {
-                    LOG_ERROR(Service_SSL, "Failed to read jdlo_auth.ini content");
-                }
-            } else {
-                LOG_WARNING(Service_SSL, "jdlo_auth.ini not found at {}",
-                            Common::FS::PathToUTF8String(auth_file_path));
-            }
-        }
-
         const int ret = SSL_write_ex(ssl, data.data(), data.size(), out_size);
         return HandleReturn("SSL_write_ex", out_size, ret);
     }
@@ -386,28 +247,6 @@ public:
         return ResultSuccess;
     }
 
-    Result Pending(s32* out_pending) override {
-        if (!ssl) {
-            return ResultInternalError;
-        }
-        int pending = SSL_pending(ssl);
-        if (pending > 0) {
-            *out_pending = pending;
-            return ResultSuccess;
-        }
-
-        Network::PollFD poll_fd{socket.get(), Network::PollEvents::In, Network::PollEvents::In};
-        std::vector<Network::PollFD> poll_fds{poll_fd};
-        auto [count, err] = Network::Poll(poll_fds, 0);
-        if (count > 0 && (poll_fds[0].revents & Network::PollEvents::In) != Network::PollEvents{}) {
-            *out_pending = 1;
-        } else {
-            *out_pending = 0;
-        }
-        return ResultSuccess;
-    }
-
-
     ~SSLConnectionBackendOpenSSL() {
         // this is null-tolerant:
         SSL_free(ssl);

src/core/hle/service/ssl/ssl_backend_schannel.cpp

@@ -489,27 +489,6 @@ public:
         return ResultSuccess;
     }
 
-    Result Pending(s32* out_pending) override {
-        *out_pending = static_cast<s32>(cleartext_read_buf.size());
-        if (*out_pending > 0) {
-            return ResultSuccess;
-        }
-
-        if (!ciphertext_read_buf.empty()) {
-            *out_pending = 1;
-            return ResultSuccess;
-        }
-
-        Network::PollFD poll_fd{socket.get(), Network::PollEvents::In, Network::PollEvents::In};
-        std::vector<Network::PollFD> poll_fds{poll_fd};
-        auto [count, err] = Network::Poll(poll_fds, 0);
-        if (count > 0 && (poll_fds[0].revents & Network::PollEvents::In) != Network::PollEvents{}) {
-            *out_pending = 1;
-        }
-        return ResultSuccess;
-    }
-
-
     ~SSLConnectionBackendSchannel() {
         if (handshake_state != HandshakeState::Initial) {
             DeleteSecurityContext(&ctxt);

src/core/hle/service/ssl/ssl_backend_securetransport.cpp

@@ -149,26 +149,6 @@ public:
         return ResultSuccess;
     }
 
-    Result Pending(s32* out_pending) override {
-        size_t bufferSize = 0;
-        OSStatus status = SSLGetBufferedReadSize(context, &bufferSize);
-        if (status == 0 && bufferSize > 0) {
-            *out_pending = static_cast<s32>(bufferSize);
-            return ResultSuccess;
-        }
-
-        Network::PollFD poll_fd{socket.get(), Network::PollEvents::In, Network::PollEvents::In};
-        std::vector<Network::PollFD> poll_fds{poll_fd};
-        auto [count, err] = Network::Poll(poll_fds, 0);
-        if (count > 0 && (poll_fds[0].revents & Network::PollEvents::In) != Network::PollEvents{}) {
-            *out_pending = 1;
-        } else {
-            *out_pending = 0;
-        }
-        return ResultSuccess;
-    }
-
-
     static OSStatus ReadCallback(SSLConnectionRef connection, void* data, size_t* dataLength) {
         return ReadOrWriteCallback(connection, data, dataLength, true);
     }

src/core/internal_network/emu_net_state.cpp

@@ -7,7 +7,7 @@
 #include "core/internal_network/network_interface.h"
 
 #ifdef _WIN32
-
+#define NOMINMAX
 #include <windows.h>
 #include <wlanapi.h>
 #ifdef _MSC_VER

src/core/internal_network/legacy_online.cpp

@@ -1,701 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#include "core/internal_network/legacy_online.h"
-
-#include <cstring>
-#include <iostream>
-#include <sstream>
-#include <regex>
-#include <iomanip>
-
-#ifdef _WIN32
-#include <winsock2.h>
-#include <ws2tcpip.h>
-#else
-#include <arpa/inet.h>
-#include <netinet/in.h>
-#include <sys/socket.h>
-#include <unistd.h>
-#endif
-
-// For SHA1 and Base64
-#include "common/logging/log.h"
-
-namespace Network {
-
-// Simple SHA1 implementation for WebSocket handshake
-namespace {
-
-class SHA1 {
-public:
-    SHA1() { reset(); }
-
-    void update(const uint8_t* data, size_t len) {
-        while (len--) {
-            buffer[buffer_size++] = *data++;
-            if (buffer_size == 64) {
-                process_block();
-                buffer_size = 0;
-            }
-            total_bits += 8;
-        }
-    }
-
-    void update(const std::string& str) {
-        update(reinterpret_cast<const uint8_t*>(str.data()), str.size());
-    }
-
-    std::array<uint8_t, 20> finalize() {
-        // Padding
-        buffer[buffer_size++] = 0x80;
-        while (buffer_size != 56) {
-            if (buffer_size == 64) {
-                process_block();
-                buffer_size = 0;
-            }
-            buffer[buffer_size++] = 0;
-        }
-
-        // Append length in bits
-        for (int i = 7; i >= 0; --i) {
-            buffer[buffer_size++] = static_cast<uint8_t>(total_bits >> (i * 8));
-        }
-        process_block();
-
-        std::array<uint8_t, 20> result;
-        for (int i = 0; i < 5; ++i) {
-            result[i*4+0] = static_cast<uint8_t>(h[i] >> 24);
-            result[i*4+1] = static_cast<uint8_t>(h[i] >> 16);
-            result[i*4+2] = static_cast<uint8_t>(h[i] >> 8);
-            result[i*4+3] = static_cast<uint8_t>(h[i]);
-        }
-        return result;
-    }
-
-private:
-    void reset() {
-        h[0] = 0x67452301;
-        h[1] = 0xEFCDAB89;
-        h[2] = 0x98BADCFE;
-        h[3] = 0x10325476;
-        h[4] = 0xC3D2E1F0;
-        buffer_size = 0;
-        total_bits = 0;
-    }
-
-    void process_block() {
-        uint32_t w[80];
-        for (int i = 0; i < 16; ++i) {
-            w[i] = (buffer[i*4+0] << 24) | (buffer[i*4+1] << 16) |
-                   (buffer[i*4+2] << 8) | buffer[i*4+3];
-        }
-        for (int i = 16; i < 80; ++i) {
-            uint32_t t = w[i-3] ^ w[i-8] ^ w[i-14] ^ w[i-16];
-            w[i] = (t << 1) | (t >> 31);
-        }
-
-        uint32_t a = h[0], b = h[1], c = h[2], d = h[3], e = h[4];
-
-        for (int i = 0; i < 80; ++i) {
-            uint32_t f, k;
-            if (i < 20) {
-                f = (b & c) | ((~b) & d);
-                k = 0x5A827999;
-            } else if (i < 40) {
-                f = b ^ c ^ d;
-                k = 0x6ED9EBA1;
-            } else if (i < 60) {
-                f = (b & c) | (b & d) | (c & d);
-                k = 0x8F1BBCDC;
-            } else {
-                f = b ^ c ^ d;
-                k = 0xCA62C1D6;
-            }
-
-            uint32_t temp = ((a << 5) | (a >> 27)) + f + e + k + w[i];
-            e = d;
-            d = c;
-            c = (b << 30) | (b >> 2);
-            b = a;
-            a = temp;
-        }
-
-        h[0] += a;
-        h[1] += b;
-        h[2] += c;
-        h[3] += d;
-        h[4] += e;
-    }
-
-    uint32_t h[5];
-    uint8_t buffer[64];
-    size_t buffer_size;
-    uint64_t total_bits;
-};
-
-std::string base64_encode(const uint8_t* data, size_t len) {
-    static const char* chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-    std::string result;
-    result.reserve((len + 2) / 3 * 4);
-
-    for (size_t i = 0; i < len; i += 3) {
-        uint32_t n = static_cast<uint32_t>(data[i]) << 16;
-        if (i + 1 < len) n |= static_cast<uint32_t>(data[i + 1]) << 8;
-        if (i + 2 < len) n |= static_cast<uint32_t>(data[i + 2]);
-
-        result += chars[(n >> 18) & 0x3F];
-        result += chars[(n >> 12) & 0x3F];
-        result += (i + 1 < len) ? chars[(n >> 6) & 0x3F] : '=';
-        result += (i + 2 < len) ? chars[n & 0x3F] : '=';
-    }
-    return result;
-}
-
-std::string compute_websocket_accept(const std::string& key) {
-    // WebSocket magic GUID
-    const std::string magic = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
-    std::string combined = key + magic;
-
-    SHA1 sha1;
-    sha1.update(combined);
-    auto hash = sha1.finalize();
-
-    return base64_encode(hash.data(), hash.size());
-}
-
-} // anonymous namespace
-
-LegacyOnlineService::LegacyOnlineService() {
-#ifdef _WIN32
-    WSADATA wsa_data;
-    if (WSAStartup(MAKEWORD(2, 2), &wsa_data) != 0) {
-        LOG_ERROR(Network, "WSAStartup failed with error: {}", WSAGetLastError());
-        winsock_initialized = false;
-    } else {
-        winsock_initialized = true;
-    }
-#endif
-}
-
-LegacyOnlineService::~LegacyOnlineService() {
-    Stop();
-#ifdef _WIN32
-    if (winsock_initialized) {
-        WSACleanup();
-    }
-#endif
-}
-
-void LegacyOnlineService::Start() {
-    if (is_running) {
-        return;
-    }
-
-#ifdef _WIN32
-    if (!winsock_initialized) {
-        LOG_ERROR(Network, "Cannot start Legacy Online Service: Winsock not initialized");
-        return;
-    }
-#endif
-
-    is_running = true;
-    udp_worker_thread = std::thread(&LegacyOnlineService::UdpServerLoop, this);
-    http_worker_thread = std::thread(&LegacyOnlineService::HttpServerLoop, this);
-}
-
-void LegacyOnlineService::Stop() {
-    if (!is_running) {
-        return;
-    }
-
-    is_running = false;
-
-    if (udp_socket_fd != ~0ULL) {
-#ifdef _WIN32
-        closesocket(static_cast<SOCKET>(udp_socket_fd));
-#else
-        close(static_cast<int>(udp_socket_fd));
-#endif
-        udp_socket_fd = ~0ULL;
-    }
-
-    if (http_socket_fd != ~0ULL) {
-#ifdef _WIN32
-        closesocket(static_cast<SOCKET>(http_socket_fd));
-#else
-        close(static_cast<int>(http_socket_fd));
-#endif
-        http_socket_fd = ~0ULL;
-    }
-
-    if (udp_worker_thread.joinable()) {
-        udp_worker_thread.join();
-    }
-    if (http_worker_thread.joinable()) {
-        http_worker_thread.join();
-    }
-}
-
-void LegacyOnlineService::UdpServerLoop() {
-    LOG_INFO(Network, "Starting Legacy Online UDP Server on port {}", UDP_PORT);
-
-    auto s = socket(AF_INET, SOCK_DGRAM, 0);
-#ifdef _WIN32
-    if (s == INVALID_SOCKET) {
-#else
-    if (s == -1) {
-#endif
-        LOG_ERROR(Network, "Failed to create UDP socket");
-        return;
-    }
-    udp_socket_fd = static_cast<uintptr_t>(s);
-
-    int opt = 1;
-#ifdef _WIN32
-    setsockopt(static_cast<SOCKET>(udp_socket_fd), SOL_SOCKET, SO_REUSEADDR, (const char*)&opt, sizeof(opt));
-#else
-    setsockopt(static_cast<int>(udp_socket_fd), SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
-#endif
-
-    sockaddr_in server_addr{};
-    server_addr.sin_family = AF_INET;
-    server_addr.sin_addr.s_addr = INADDR_ANY;
-    server_addr.sin_port = htons(UDP_PORT);
-
-    int res = -1;
-#ifdef _WIN32
-    res = bind(static_cast<SOCKET>(udp_socket_fd), (sockaddr*)&server_addr, sizeof(server_addr));
-#else
-    res = bind(static_cast<int>(udp_socket_fd), (sockaddr*)&server_addr, sizeof(server_addr));
-#endif
-
-    if (res < 0) {
-#ifdef _WIN32
-        LOG_ERROR(Network, "Failed to bind UDP to port {}: {}", UDP_PORT, WSAGetLastError());
-        closesocket(static_cast<SOCKET>(udp_socket_fd));
-#else
-        LOG_ERROR(Network, "Failed to bind UDP to port {}: {}", UDP_PORT, strerror(errno));
-        close(static_cast<int>(udp_socket_fd));
-#endif
-        udp_socket_fd = ~0ULL;
-        return;
-    }
-
-    LOG_INFO(Network, "Legacy Online UDP Server waiting for messages...");
-
-    char buffer[2048];
-    while (is_running) {
-        sockaddr_in client_addr{};
-#ifdef _WIN32
-        int client_len = sizeof(client_addr);
-        int len = recvfrom(static_cast<SOCKET>(udp_socket_fd), buffer, sizeof(buffer), 0, (sockaddr*)&client_addr, &client_len);
-#else
-        socklen_t client_len = sizeof(client_addr);
-        ssize_t len = recvfrom(static_cast<int>(udp_socket_fd), buffer, sizeof(buffer), 0, (sockaddr*)&client_addr, &client_len);
-#endif
-
-        if (!is_running) break;
-
-        if (len > 0) {
-            const char* ack_msg = "ACK";
-#ifdef _WIN32
-            sendto(static_cast<SOCKET>(udp_socket_fd), ack_msg, static_cast<int>(strlen(ack_msg)), 0, (sockaddr*)&client_addr, client_len);
-#else
-            sendto(static_cast<int>(udp_socket_fd), ack_msg, strlen(ack_msg), 0, (sockaddr*)&client_addr, client_len);
-#endif
-        } else {
-            break;
-        }
-    }
-
-#ifdef _WIN32
-    if (udp_socket_fd != ~0ULL) closesocket(static_cast<SOCKET>(udp_socket_fd));
-#else
-    if (udp_socket_fd != ~0ULL) close(static_cast<int>(udp_socket_fd));
-#endif
-    udp_socket_fd = ~0ULL;
-    LOG_INFO(Network, "Legacy Online UDP Server stopped");
-}
-
-void LegacyOnlineService::HttpServerLoop() {
-    LOG_INFO(Network, "Starting Mobile App HTTP/WebSocket Server on port {}", HTTP_PORT);
-
-    auto s = socket(AF_INET, SOCK_STREAM, 0);
-#ifdef _WIN32
-    if (s == INVALID_SOCKET) {
-#else
-    if (s == -1) {
-#endif
-        LOG_ERROR(Network, "Failed to create HTTP socket");
-        return;
-    }
-    http_socket_fd = static_cast<uintptr_t>(s);
-
-    int opt = 1;
-#ifdef _WIN32
-    setsockopt(static_cast<SOCKET>(http_socket_fd), SOL_SOCKET, SO_REUSEADDR, (const char*)&opt, sizeof(opt));
-#else
-    setsockopt(static_cast<int>(http_socket_fd), SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
-#endif
-
-    sockaddr_in server_addr{};
-    server_addr.sin_family = AF_INET;
-    server_addr.sin_addr.s_addr = INADDR_ANY;
-    server_addr.sin_port = htons(HTTP_PORT);
-
-    int res = -1;
-#ifdef _WIN32
-    res = bind(static_cast<SOCKET>(http_socket_fd), (sockaddr*)&server_addr, sizeof(server_addr));
-#else
-    res = bind(static_cast<int>(http_socket_fd), (sockaddr*)&server_addr, sizeof(server_addr));
-#endif
-
-    if (res < 0) {
-#ifdef _WIN32
-        LOG_ERROR(Network, "Failed to bind HTTP to port {}: {}", HTTP_PORT, WSAGetLastError());
-        closesocket(static_cast<SOCKET>(http_socket_fd));
-#else
-        LOG_ERROR(Network, "Failed to bind HTTP to port {}: {}", HTTP_PORT, strerror(errno));
-        close(static_cast<int>(http_socket_fd));
-#endif
-        http_socket_fd = ~0ULL;
-        return;
-    }
-
-#ifdef _WIN32
-    res = listen(static_cast<SOCKET>(http_socket_fd), 10);
-#else
-    res = listen(static_cast<int>(http_socket_fd), 10);
-#endif
-
-    if (res < 0) {
-#ifdef _WIN32
-        LOG_ERROR(Network, "Failed to listen on HTTP port {}: {}", HTTP_PORT, WSAGetLastError());
-        closesocket(static_cast<SOCKET>(http_socket_fd));
-#else
-        LOG_ERROR(Network, "Failed to listen on HTTP port {}: {}", HTTP_PORT, strerror(errno));
-        close(static_cast<int>(http_socket_fd));
-#endif
-        http_socket_fd = ~0ULL;
-        return;
-    }
-
-    LOG_INFO(Network, "Mobile App HTTP/WebSocket Server listening on port {}...", HTTP_PORT);
-
-    while (is_running) {
-        sockaddr_in client_addr{};
-#ifdef _WIN32
-        int client_len = sizeof(client_addr);
-        SOCKET client_fd = accept(static_cast<SOCKET>(http_socket_fd), (sockaddr*)&client_addr, &client_len);
-        if (client_fd == INVALID_SOCKET) {
-#else
-        socklen_t client_len = sizeof(client_addr);
-        int client_fd = accept(static_cast<int>(http_socket_fd), (sockaddr*)&client_addr, &client_len);
-        if (client_fd == -1) {
-#endif
-            if (!is_running) break;
-            continue;
-        }
-
-        char client_ip[INET_ADDRSTRLEN];
-        inet_ntop(AF_INET, &client_addr.sin_addr, client_ip, sizeof(client_ip));
-        LOG_INFO(Network, "HTTP/WebSocket connection from {}:{}", client_ip, ntohs(client_addr.sin_port));
-
-        // Read HTTP request
-        char buffer[4096];
-        memset(buffer, 0, sizeof(buffer));
-#ifdef _WIN32
-        int bytes_read = recv(client_fd, buffer, sizeof(buffer) - 1, 0);
-#else
-        ssize_t bytes_read = recv(client_fd, buffer, sizeof(buffer) - 1, 0);
-#endif
-
-        if (bytes_read > 0) {
-            std::string request(buffer, bytes_read);
-            LOG_INFO(Network, "Request:\n{}", request);
-
-            // Check if this is a WebSocket upgrade request
-            bool is_websocket = request.find("Upgrade: websocket") != std::string::npos;
-
-            if (is_websocket) {
-                // Extract Sec-WebSocket-Key
-                std::string ws_key;
-                std::regex key_regex("Sec-WebSocket-Key: ([^\r\n]+)");
-                std::smatch match;
-                if (std::regex_search(request, match, key_regex)) {
-                    ws_key = match[1].str();
-                }
-
-                // Extract Sec-WebSocket-Protocol
-                std::string ws_protocol;
-                std::regex protocol_regex("Sec-WebSocket-Protocol: ([^\r\n]+)");
-                if (std::regex_search(request, match, protocol_regex)) {
-                    ws_protocol = match[1].str();
-                }
-
-                LOG_INFO(Network, "WebSocket upgrade request - Key: {}, Protocol: {}", ws_key, ws_protocol);
-
-                // Compute accept key
-                std::string accept_key = compute_websocket_accept(ws_key);
-                LOG_INFO(Network, "WebSocket Accept Key: {}", accept_key);
-
-                // Build WebSocket handshake response
-                std::ostringstream ws_response;
-                ws_response << "HTTP/1.1 101 Switching Protocols\r\n";
-                ws_response << "Upgrade: websocket\r\n";
-                ws_response << "Connection: Upgrade\r\n";
-                ws_response << "Sec-WebSocket-Accept: " << accept_key << "\r\n";
-                if (!ws_protocol.empty()) {
-                    ws_response << "Sec-WebSocket-Protocol: " << ws_protocol << "\r\n";
-                }
-                ws_response << "\r\n";
-
-                std::string response_str = ws_response.str();
-#ifdef _WIN32
-                send(client_fd, response_str.c_str(), static_cast<int>(response_str.size()), 0);
-#else
-                send(client_fd, response_str.c_str(), response_str.size(), 0);
-#endif
-                LOG_INFO(Network, "WebSocket handshake completed! Response:\n{}", response_str);
-
-                // Now handle WebSocket messages
-                LOG_INFO(Network, "Mobile app WebSocket connected! Entering message loop...");
-
-                while (is_running) {
-                    memset(buffer, 0, sizeof(buffer));
-#ifdef _WIN32
-                    bytes_read = recv(client_fd, buffer, sizeof(buffer), 0);
-#else
-                    bytes_read = recv(client_fd, buffer, sizeof(buffer), 0);
-#endif
-                    if (bytes_read <= 0) {
-                        LOG_INFO(Network, "WebSocket connection closed");
-                        break;
-                    }
-
-                    // Parse WebSocket frame
-                    uint8_t* frame = reinterpret_cast<uint8_t*>(buffer);
-                    uint8_t opcode = frame[0] & 0x0F;
-                    bool masked = (frame[1] & 0x80) != 0;
-                    uint64_t payload_len = frame[1] & 0x7F;
-
-                    size_t header_len = 2;
-                    if (payload_len == 126) {
-                        payload_len = (frame[2] << 8) | frame[3];
-                        header_len = 4;
-                    } else if (payload_len == 127) {
-                        header_len = 10;
-                        payload_len = 0;
-                        for (int i = 0; i < 8; ++i) {
-                            payload_len = (payload_len << 8) | frame[2 + i];
-                        }
-                    }
-
-                    uint8_t mask_key[4] = {0};
-                    if (masked) {
-                        memcpy(mask_key, frame + header_len, 4);
-                        header_len += 4;
-                    }
-
-                    // Unmask payload
-                    std::string payload;
-                    for (size_t i = 0; i < payload_len && (header_len + i) < static_cast<size_t>(bytes_read); ++i) {
-                        char c = frame[header_len + i];
-                        if (masked) {
-                            c ^= mask_key[i % 4];
-                        }
-                        payload += c;
-                    }
-
-                    // LOG_INFO(Network, "WebSocket message (opcode={}): {}", opcode, payload);
-
-                    // Handle different opcodes
-                    if (opcode == 0x08) {
-                        // Close frame
-                        // LOG_INFO(Network, "WebSocket close frame received");
-                        break;
-                    } else if (opcode == 0x09) {
-                        // Ping - send pong. Theoretically should echo payload, but empty pong is usually fine.
-                        // LOG_INFO(Network, "WebSocket PING received. Responding with PONG.");
-                        uint8_t pong[2] = {0x8A, 0x00};
-#ifdef _WIN32
-                        send(client_fd, reinterpret_cast<char*>(pong), 2, 0);
-#else
-                        send(client_fd, pong, 2, 0);
-#endif
-                    } else if (opcode == 0x0A) {
-                        // Pong (keep-alive response from client)
-                        // LOG_INFO(Network, "WebSocket PONG received from client.");
-                    } else if (opcode == 0x01 || opcode == 0x02) {
-                        // Text or Binary frame - process Just Dance protocol
-                        std::string response;
-
-                        // Check message type and respond appropriately
-                        // Protocol flow based on JoyDance:
-                        // 1. Phone -> Console: JD_PhoneDataCmdHandshakeHello
-                        // 2. Console -> Phone: JD_PhoneDataCmdHandshakeContinue (with phoneID)
-                        // 3. Phone -> Console: JD_PhoneDataCmdSync (with phoneID)
-                        // 4. Console -> Phone: JD_PhoneDataCmdSyncEnd (with phoneID)
-                        // 5. Connected!
-
-                        if (payload.find("JD_PhoneDataCmdHandshakeHello") != std::string::npos) {
-                            // Step 2: Respond with HandshakeContinue
-                            // PROTOCOL FIX: No "root" wrapper. Authenticated ID=1 (Int).
-                            // CRITICAL: App sent Freq=0. Providing configuration values.
-                            // CLEANUP: Removed extra status fields to prevent parsing errors.
-                            response = R"({"__class":"JD_PhoneDataCmdHandshakeContinue","phoneID":1,"accelAcquisitionFreqHz":50,"accelAcquisitionLatency":40,"accelMaxRange":8})";
-                            // LOG_INFO(Network, "Sending HandshakeContinue (id=1, cfg=50Hz)");
-
-                            // Send HandshakeContinue
-                            std::vector<uint8_t> ws_frame;
-                            ws_frame.push_back(0x81);
-                            ws_frame.push_back(static_cast<uint8_t>(response.size()));
-                            for (char c : response) {
-                                ws_frame.push_back(static_cast<uint8_t>(c));
-                            }
- #ifdef _WIN32
-                            send(client_fd, reinterpret_cast<char*>(ws_frame.data()), static_cast<int>(ws_frame.size()), 0);
-#else
-                            send(client_fd, ws_frame.data(), ws_frame.size(), 0);
-#endif
-                            // LOG_INFO(Network, "WebSocket response sent: {}", response);
-
-                            // Removed proactive commands to verify if app accepts HandshakeContinue and sends Sync
-                            response.clear();
-
-                        } else if (payload.find("JD_PhoneDataCmdSync") != std::string::npos) {
-                            // Step 4: Respond with SyncEnd (NO ROOT)
-                            // Using phoneID 1 (Int)
-                            response = R"({"__class":"JD_PhoneDataCmdSyncEnd","phoneID":1,"status":"ok"})";
-                            // LOG_INFO(Network, "Sending SyncEnd (id=1, no root) - Connection complete!");
-
-                            // Send SyncEnd
-                            std::vector<uint8_t> ws_frame;
-                            ws_frame.push_back(0x81);
-                            ws_frame.push_back(static_cast<uint8_t>(response.size()));
-                            for (char c : response) {
-                                ws_frame.push_back(static_cast<uint8_t>(c));
-                            }
- #ifdef _WIN32
-                            send(client_fd, reinterpret_cast<char*>(ws_frame.data()), static_cast<int>(ws_frame.size()), 0);
-#else
-                            send(client_fd, ws_frame.data(), ws_frame.size(), 0);
-#endif
-
-                            // Step 5: Send Activation Commands immediately to authorize input and accel
-                            // 5a. Enable Input
-                            std::string cmd1 = R"({"__class":"InputSetup_ConsoleCommandData","isEnabled":1,"inputSetup":{"isEnabled":1}})";
-                             std::vector<uint8_t> f1; f1.push_back(0x81); f1.push_back(static_cast<uint8_t>(cmd1.size())); for(char c:cmd1) f1.push_back(static_cast<uint8_t>(c));
-#ifdef _WIN32
-                            send(client_fd, reinterpret_cast<char*>(f1.data()), static_cast<int>(f1.size()), 0);
-#else
-                            send(client_fd, f1.data(), f1.size(), 0);
-#endif
-
-                            // 5b. Enable Accelerometer
-                            std::string cmd2 = R"({"__class":"JD_EnableAccelValuesSending_ConsoleCommandData","isEnabled":1})";
-                            std::vector<uint8_t> f2; f2.push_back(0x81); f2.push_back(static_cast<uint8_t>(cmd2.size())); for(char c:cmd2) f2.push_back(static_cast<uint8_t>(c));
-#ifdef _WIN32
-                            send(client_fd, reinterpret_cast<char*>(f2.data()), static_cast<int>(f2.size()), 0);
-#else
-                            send(client_fd, f2.data(), f2.size(), 0);
-#endif
-
-                            // 5c. UI Setup (optional but good for safety)
-                            std::string cmd3 = R"({"__class":"JD_PhoneUiSetupData","isPopup":0,"inputSetup":{"isEnabled":1}})";
-                            std::vector<uint8_t> f3; f3.push_back(0x81); f3.push_back(static_cast<uint8_t>(cmd3.size())); for(char c:cmd3) f3.push_back(static_cast<uint8_t>(c));
-#ifdef _WIN32
-                            send(client_fd, reinterpret_cast<char*>(f3.data()), static_cast<int>(f3.size()), 0);
-#else
-                            send(client_fd, f3.data(), f3.size(), 0);
-#endif
-
-                            // LOG_INFO(Network, "Sent Activation Commands (Input, Accel, UI)");
-                            response.clear();
-                        } else if (payload.find("JD_PhoneScoringData") != std::string::npos) {
-                            // Accelerometer/scoring data - no response needed
-                            // LOG_DEBUG(Network, "Received phone scoring data");
-                            continue;
-                        } else if (payload.find("JD_Input_PhoneCommandData") != std::string::npos) {
-                            // Button input from phone - no response needed
-                            // LOG_INFO(Network, "Received phone input command");
-                            continue;
-                        } else if (payload.find("JD_Pause_PhoneCommandData") != std::string::npos) {
-                            // Pause command from phone
-                            // LOG_INFO(Network, "Received pause command from phone");
-                            continue;
-                        } else if (payload.find("JD_Custom_PhoneCommandData") != std::string::npos) {
-                            // Custom shortcut command
-                            // LOG_INFO(Network, "Received custom command from phone");
-                            continue;
-                        } else if (payload.find("JD_CancelKeyboard_PhoneCommandData") != std::string::npos) {
-                            // Keyboard cancelled
-                            // LOG_INFO(Network, "Phone cancelled keyboard");
-                            continue;
-                        } else {
-                            // Unknown message - log but don't respond
-                            // LOG_INFO(Network, "Unknown phone message type");
-                            continue;
-                        }
-
-                        if (!response.empty()) {
-                            // Build WebSocket frame
-                            std::vector<uint8_t> ws_frame;
-                            ws_frame.push_back(0x81); // Text frame, FIN
-                            if (response.size() < 126) {
-                                ws_frame.push_back(static_cast<uint8_t>(response.size()));
-                            } else if (response.size() < 65536) {
-                                ws_frame.push_back(126);
-                                ws_frame.push_back(static_cast<uint8_t>((response.size() >> 8) & 0xFF));
-                                ws_frame.push_back(static_cast<uint8_t>(response.size() & 0xFF));
-                            }
-                            for (char c : response) {
-                                ws_frame.push_back(static_cast<uint8_t>(c));
-                            }
-#ifdef _WIN32
-                            send(client_fd, reinterpret_cast<char*>(ws_frame.data()), static_cast<int>(ws_frame.size()), 0);
-#else
-                            send(client_fd, ws_frame.data(), ws_frame.size(), 0);
-#endif
-                            LOG_INFO(Network, "WebSocket response sent: {}", response);
-                        }
-                    }
-                }
-            } else {
-                // Regular HTTP request
-                std::string response_body = R"({"status":"ok","message":"Eden Mobile Bridge"})";
-                std::ostringstream http_response;
-                http_response << "HTTP/1.1 200 OK\r\n";
-                http_response << "Content-Type: application/json\r\n";
-                http_response << "Content-Length: " << response_body.size() << "\r\n";
-                http_response << "Connection: close\r\n";
-                http_response << "\r\n";
-                http_response << response_body;
-
-                std::string response_str = http_response.str();
-#ifdef _WIN32
-                send(client_fd, response_str.c_str(), static_cast<int>(response_str.size()), 0);
-#else
-                send(client_fd, response_str.c_str(), response_str.size(), 0);
-#endif
-            }
-        }
-
-#ifdef _WIN32
-        closesocket(client_fd);
-#else
-        close(client_fd);
-#endif
-    }
-
-#ifdef _WIN32
-    if (http_socket_fd != ~0ULL) closesocket(static_cast<SOCKET>(http_socket_fd));
-#else
-    if (http_socket_fd != ~0ULL) close(static_cast<int>(http_socket_fd));
-#endif
-    http_socket_fd = ~0ULL;
-    LOG_INFO(Network, "Mobile App HTTP/WebSocket Server stopped");
-}
-
-} // namespace Network

src/core/internal_network/legacy_online.h

@@ -1,36 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
-#pragma once
-
-#include <atomic>
-#include <cstdint>
-#include <memory>
-#include <thread>
-
-namespace Network {
-
-class LegacyOnlineService {
-public:
-    LegacyOnlineService();
-    ~LegacyOnlineService();
-
-    void Start();
-    void Stop();
-
-private:
-    void UdpServerLoop();
-    void HttpServerLoop();
-
-    std::atomic_bool is_running{false};
-    std::thread udp_worker_thread;
-    std::thread http_worker_thread;
-    uintptr_t udp_socket_fd{~0ULL};
-    uintptr_t http_socket_fd{~0ULL};
-    bool winsock_initialized{false};
-
-    static constexpr int UDP_PORT = 6000;
-    static constexpr int HTTP_PORT = 8080;
-};
-
-} // namespace Network

src/core/internal_network/network.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
@@ -75,8 +75,6 @@ SOCKET GetInterruptSocket() {
     return interrupt_socket;
 }
 
-} // namespace
-
 sockaddr TranslateFromSockAddrIn(SockAddrIn input) {
     sockaddr_in result;
 
@@ -85,7 +83,6 @@ sockaddr TranslateFromSockAddrIn(SockAddrIn input) {
 #endif
 
     switch (static_cast<Domain>(input.family)) {
-    case Domain::Unspecified:
     case Domain::INET:
         result.sin_family = AF_INET;
         break;
@@ -108,8 +105,6 @@ sockaddr TranslateFromSockAddrIn(SockAddrIn input) {
     return addr;
 }
 
-namespace {
-
 LINGER MakeLinger(bool enable, u32 linger_value) {
     ASSERT(linger_value <= (std::numeric_limits<u_short>::max)());
 
@@ -129,7 +124,6 @@ Errno TranslateNativeError(int e, CallType call_type = CallType::Other) {
     case 0:
         return Errno::SUCCESS;
     case WSAEBADF:
-    case WSAENOTSOCK:
         return Errno::BADF;
     case WSAEINVAL:
         return Errno::INVAL;
@@ -163,10 +157,6 @@ Errno TranslateNativeError(int e, CallType call_type = CallType::Other) {
         return Errno::TIMEDOUT;
     case WSAEINPROGRESS:
         return Errno::INPROGRESS;
-    case WSAEACCES:
-        return Errno::ACCES;
-    case WSAEADDRINUSE:
-        return Errno::ADDRINUSE;
     default:
         UNIMPLEMENTED_MSG("Unimplemented errno={}", e);
         return Errno::OTHER;
@@ -222,8 +212,6 @@ SOCKET GetInterruptSocket() {
     return interrupt_pipe_fd[0];
 }
 
-} // namespace
-
 sockaddr TranslateFromSockAddrIn(SockAddrIn input) {
     sockaddr_in result;
 
@@ -246,8 +234,6 @@ sockaddr TranslateFromSockAddrIn(SockAddrIn input) {
     return addr;
 }
 
-namespace {
-
 int WSAPoll(WSAPOLLFD* fds, ULONG nfds, int timeout) {
     return poll(fds, static_cast<nfds_t>(nfds), timeout);
 }
@@ -334,8 +320,6 @@ Errno GetAndLogLastError(CallType call_type = CallType::Other) {
     return err;
 }
 
-} // namespace
-
 GetAddrInfoError TranslateGetAddrInfoErrorFromNative(int gai_err) {
     switch (gai_err) {
     case 0:
@@ -389,8 +373,6 @@ GetAddrInfoError TranslateGetAddrInfoErrorFromNative(int gai_err) {
     }
 }
 
-namespace {
-
 Domain TranslateDomainFromNative(int domain) {
     switch (domain) {
     case 0:
@@ -625,8 +607,6 @@ Common::Expected<std::vector<AddrInfo>, GetAddrInfoError> GetAddressInfo(
     return ret;
 }
 
-
-
 std::pair<s32, Errno> Poll(std::vector<PollFD>& pollfds, s32 timeout) {
     const size_t num = pollfds.size();
 
@@ -704,10 +684,6 @@ Errno Socket::Initialize(Domain domain, Type type, Protocol protocol) {
     fd = socket(TranslateDomainToNative(domain), TranslateTypeToNative(type),
                 TranslateProtocolToNative(protocol));
     if (fd != INVALID_SOCKET) {
-        // Enable SO_REUSEADDR to allow port reuse after socket close
-        // This prevents "Address already in use" errors when rebinding
-        int reuse = 1;
-        setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, reinterpret_cast<const char*>(&reuse), sizeof(reuse));
         return Errno::SUCCESS;
     }
 
@@ -825,35 +801,6 @@ std::pair<s32, Errno> Socket::Recv(int flags, std::span<u8> message) {
     ASSERT(flags == 0);
     ASSERT(message.size() < static_cast<size_t>((std::numeric_limits<int>::max)()));
 
-    // If socket is blocking, use poll with interrupt socket to avoid infinite blocking
-    if (!is_non_blocking) {
-        std::vector<WSAPOLLFD> host_pollfds{
-            WSAPOLLFD{fd, POLLIN, 0},
-            WSAPOLLFD{GetInterruptSocket(), POLLIN, 0},
-        };
-
-        // Poll with a longer timeout (30 seconds) to wait for data
-        const int pollres = WSAPoll(host_pollfds.data(), static_cast<ULONG>(host_pollfds.size()), 30000);
-
-        if (host_pollfds[1].revents != 0) {
-            // Interrupt signaled, return EAGAIN
-            return {-1, Errno::AGAIN};
-        }
-
-        if (pollres == 0) {
-            // Timeout - return AGAIN so the game can retry
-            LOG_DEBUG(Network, "Recv poll timeout after 30 seconds, returning EAGAIN");
-            return {-1, Errno::AGAIN};
-        }
-
-        if (pollres < 0) {
-            return {-1, GetAndLogLastError()};
-        }
-
-        // Data is available, proceed with recv
-        LOG_INFO(Network, "Recv poll detected data available!");
-    }
-
     const auto result =
         recv(fd, reinterpret_cast<char*>(message.data()), static_cast<int>(message.size()), 0);
     if (result != SOCKET_ERROR) {
@@ -867,35 +814,6 @@ std::pair<s32, Errno> Socket::RecvFrom(int flags, std::span<u8> message, SockAdd
     ASSERT(flags == 0);
     ASSERT(message.size() < static_cast<size_t>((std::numeric_limits<int>::max)()));
 
-    // If socket is blocking, use poll with interrupt socket to avoid infinite blocking
-    if (!is_non_blocking) {
-        std::vector<WSAPOLLFD> host_pollfds{
-            WSAPOLLFD{fd, POLLIN, 0},
-            WSAPOLLFD{GetInterruptSocket(), POLLIN, 0},
-        };
-
-        // Poll with a short timeout (5ms) to emulate Switch non-blocking/interruptible behavior
-        // This prevents the game from freezing when waiting for UDP packets on the main thread
-        const int pollres = WSAPoll(host_pollfds.data(), static_cast<ULONG>(host_pollfds.size()), 5);
-
-        if (host_pollfds[1].revents != 0) {
-            // Interrupt signaled, return EAGAIN
-            return {-1, Errno::AGAIN};
-        }
-
-        if (pollres == 0) {
-            // Timeout - return AGAIN so the game can continue its loop (rendering, input, etc.)
-            return {-1, Errno::AGAIN};
-        }
-
-        if (pollres < 0) {
-            return {-1, GetAndLogLastError()};
-        }
-
-        // Data is available, proceed with recvfrom
-        LOG_INFO(Network, "RecvFrom poll detected data available!");
-    }
-
     sockaddr_in addr_in{};
     socklen_t addrlen = sizeof(addr_in);
     socklen_t* const p_addrlen = addr ? &addrlen : nullptr;
@@ -906,10 +824,6 @@ std::pair<s32, Errno> Socket::RecvFrom(int flags, std::span<u8> message, SockAdd
     if (result != SOCKET_ERROR) {
         if (addr) {
             *addr = TranslateToSockAddrIn(addr_in, addrlen);
-            LOG_INFO(Network, "RecvFrom received {} bytes from {}:{}",
-                     result, IPv4AddressToString(addr->ip), addr->portno);
-        } else {
-            LOG_INFO(Network, "RecvFrom received {} bytes", result);
         }
         return {static_cast<s32>(result), Errno::SUCCESS};
     }
@@ -945,66 +859,20 @@ std::pair<s32, Errno> Socket::SendTo(u32 flags, std::span<const u8> message,
     if (addr) {
         host_addr_in = TranslateFromSockAddrIn(*addr);
         to = &host_addr_in;
-        LOG_INFO(Network, "SendTo sending {} bytes to {}:{}",
-                 message.size(), IPv4AddressToString(addr->ip), addr->portno);
-    } else {
-        LOG_INFO(Network, "SendTo sending {} bytes (no addr)", message.size());
-    }
-
-    // Log packet content for debugging mobile app connection
-    if (message.size() > 0 && message.size() <= 200) {
-        std::string hex_dump;
-        std::string ascii_dump;
-        for (size_t i = 0; i < message.size(); ++i) {
-            char hex[4];
-            snprintf(hex, sizeof(hex), "%02X ", message[i]);
-            hex_dump += hex;
-            // Build ASCII representation
-            if (message[i] >= 32 && message[i] < 127) {
-                ascii_dump += static_cast<char>(message[i]);
-            } else {
-                ascii_dump += '.';
-            }
-        }
-        LOG_INFO(Network, "SendTo packet HEX: {}", hex_dump);
-        LOG_INFO(Network, "SendTo packet ASCII: {}", ascii_dump);
-    } else if (message.size() > 200) {
-        // Log first 200 bytes for large packets
-        std::string hex_dump;
-        std::string ascii_dump;
-        for (size_t i = 0; i < 200; ++i) {
-            char hex[4];
-            snprintf(hex, sizeof(hex), "%02X ", message[i]);
-            hex_dump += hex;
-            if (message[i] >= 32 && message[i] < 127) {
-                ascii_dump += static_cast<char>(message[i]);
-            } else {
-                ascii_dump += '.';
-            }
-        }
-        LOG_INFO(Network, "SendTo packet HEX (first 200): {}", hex_dump);
-        LOG_INFO(Network, "SendTo packet ASCII (first 200): {}", ascii_dump);
     }
 
     const auto result = sendto(fd, reinterpret_cast<const char*>(message.data()),
                                static_cast<int>(message.size()), 0, to, to_len);
     if (result != SOCKET_ERROR) {
-        LOG_INFO(Network, "SendTo success: sent {} bytes", result);
         return {static_cast<s32>(result), Errno::SUCCESS};
     }
 
-    LOG_ERROR(Network, "SendTo failed!");
     return {-1, GetAndLogLastError(CallType::Send)};
 }
 
 Errno Socket::Close() {
-    if (fd == INVALID_SOCKET) {
-        return Errno::SUCCESS;
-    }
     [[maybe_unused]] const int result = closesocket(fd);
-    if (result != 0) {
-        GetAndLogLastError();
-    }
+    ASSERT(result == 0);
     fd = INVALID_SOCKET;
 
     return Errno::SUCCESS;

src/core/internal_network/network.h

@@ -48,8 +48,6 @@ enum class Errno {
     TIMEDOUT,
     MSGSIZE,
     INPROGRESS,
-    ACCES,
-    ADDRINUSE,
     OTHER,
 };
 
@@ -124,33 +122,8 @@ std::optional<IPv4Address> GetHostIPv4Address();
 std::string IPv4AddressToString(IPv4Address ip_addr);
 u32 IPv4AddressToInteger(IPv4Address ip_addr);
 
-#ifdef _WIN32
-#include <ws2tcpip.h>
-#else
-#include <netdb.h>
-#endif
-
 // named to avoid name collision with Windows macro
 Common::Expected<std::vector<AddrInfo>, GetAddrInfoError> GetAddressInfo(
     const std::string& host, const std::optional<std::string>& service);
 
-sockaddr TranslateFromSockAddrIn(SockAddrIn input);
-
-inline std::pair<std::string, int> GetNameInfo(const SockAddrIn& addr) {
-    sockaddr sa = TranslateFromSockAddrIn(addr);
-    sockaddr_in addr_in{};
-    std::memcpy(&addr_in, &sa, sizeof(sockaddr_in));
-
-    char host[1025]; // NI_MAXHOST
-    int err = getnameinfo(reinterpret_cast<const sockaddr*>(&addr_in), sizeof(addr_in), host, sizeof(host), nullptr, 0, 0);
-
-    if (err != 0) {
-        return {std::string{}, err};
-    }
-
-    return {std::string(host), 0};
-}
-
-GetAddrInfoError TranslateGetAddrInfoErrorFromNative(int err);
-
 } // namespace Network

src/dynarmic/CMakeLists.txt

@@ -107,7 +107,7 @@ else()
 endif()
 
 find_package(Boost 1.57 REQUIRED)
-# find_package(fmt 8 CONFIG)
+find_package(fmt 8 CONFIG)
 
 # Pull in externals CMakeLists for libs where available
 add_subdirectory(externals)

src/dynarmic/docs/FastMemory.md

@@ -1,19 +0,0 @@
-# Fast memory (Fastmem)
-
-The main way of accessing memory in JITed programs is via an invoked function, say "Read()" and "Write()". On our translator, such functions usually take a sizable amounts of code space (push + call + pop). Trash the i-cache (due to an indirect call) and overall make code emission more bloated.
-
-The solution? Delegate invalid accesses to a dedicated arena, similar to a swap. The main idea behind such mechanism is to allow the OS to transmit page faults from invalid accesses into the JIT translator directly, bypassing address space calls, while this sacrifices i-cache coherency, it allows for smaller code-size and "faster" throguhput.
-
-Many kernels however, do not support fast signal dispatching (Solaris, OpenBSD, FreeBSD). Only Linux and Windows support relatively "fast" signal dispatching. Hence this feature is better suited for them only.
-
-![Host to guest translation](./HostToGuest.svg)
-
-![Fastmem translation](./Fastmem.svg)
-
-In x86_64 for example, when a page fault occurs, the CPU will transmit via control registers and the stack (see `IRETQ`) the appropriate arguments for a page fault handler, the OS then will transform that into something that can be sent into userspace.
-
-Most modern OSes implement kernel-page-table-isolation, which means a set of system calls will invoke a context switch (not often used syscalls), whereas others are handled by the same process address space (the smaller kernel portion, often used syscalls) without needing a context switch. This effect can be negated on systems with PCID (up to 4096 unique IDs).
-
-Signal dispatching takes a performance hit from reloading `%cr3` - but Linux does something more clever to avoid reloads:  VDSO will take care of the entire thing in the same address space. Making dispatching as costly as an indirect call - without the hazards of increased code size.
-
-The main downside from this is the constant i-cache trashing and pipeline hazards introduced by the VDSO signal handlers. However on most benchmarks fastmem does perform faster than without (Linux only). This also abuses the fact of continous address space emulation by using an arena - which can then be potentially transparently mapped into a hugepage, reducing TLB walk times.

src/dynarmic/docs/RegisterAllocator.md

@@ -1,97 +0,0 @@
-# Register Allocation (x64 Backend)
-
-`HostLoc`s contain values. A `HostLoc` ("host value location") is either a host CPU register or a host spill location.
-
-Values once set cannot be changed. Values can however be moved by the register allocator between `HostLoc`s. This is
-handled by the register allocator itself and code that uses the register allocator need not and should not move values
-between registers.
-
-The register allocator is based on three concepts: `Use`, `Def` and `Scratch`.
-
-* `Use`: The use of a value.
-* `Define`: The definition of a value, this is the only time when a value is set.
-* `Scratch`: Allocate a register that can be freely modified as one wishes.
-
-Note that `Use`ing a value decrements its `use_count` by one. When the `use_count` reaches zero the value is discarded and no longer exists.
-
-The member functions on `RegAlloc` are just a combination of the above concepts.
-
-The following registers are reserved for internal use and should NOT participate in register allocation:
-- `%xmm0`, `%xmm1`, `%xmm2`: Used as scratch in exclusive memory access.
-- `%rsp`: Stack pointer.
-- `%r15`: JIT pointer
-- `%r14`: Page table pointer.
-- `%r13`: Fastmem pointer.
-
-The layout convenes `%r15` as the JIT state pointer - while it may be tempting to turn it into a synthetic pointer, keeping an entire register (out of 12 available) is preferable over inlining a directly computed immediate.
-
-Do NEVER modify `%r15`, we must make it clear that this register is "immutable" for the entirety of the JIT block duration.
-
-### `Scratch`
-
-```c++
-Xbyak::Reg64 ScratchGpr(HostLocList desired_locations = any_gpr);
-Xbyak::Xmm ScratchXmm(HostLocList desired_locations = any_xmm);
-```
-
-At runtime, allocate one of the registers in `desired_locations`. You are free to modify the register. The register is discarded at the end of the allocation scope.
-
-### Pure `Use`
-
-```c++
-Xbyak::Reg64 UseGpr(Argument& arg);
-Xbyak::Xmm UseXmm(Argument& arg);
-OpArg UseOpArg(Argument& arg);
-void Use(Argument& arg, HostLoc host_loc);
-```
-
-At runtime, the value corresponding to `arg` will be placed a register. The actual register is determined by
-which one of the above functions is called. `UseGpr` places it in an unused GPR, `UseXmm` places it
-in an unused XMM register, `UseOpArg` might be in a register or might be a memory location, and `Use` allows
-you to specify a specific register (GPR or XMM) to use.
-
-This register **must not** have it's value changed.
-
-### `UseScratch`
-
-```c++
-Xbyak::Reg64 UseScratchGpr(Argument& arg);
-Xbyak::Xmm UseScratchXmm(Argument& arg);
-void UseScratch(Argument& arg, HostLoc host_loc);
-```
-
-At runtime, the value corresponding to `arg` will be placed a register. The actual register is determined by
-which one of the above functions is called. `UseScratchGpr` places it in an unused GPR, `UseScratchXmm` places it
-in an unused XMM register, and `UseScratch` allows you to specify a specific register (GPR or XMM) to use.
-
-The return value is the register allocated to you.
-
-You are free to modify the value in the register. The register is discarded at the end of the allocation scope.
-
-### `Define` as register
-
-A `Define` is the defintion of a value. This is the only time when a value may be set.
-
-```c++
-void DefineValue(IR::Inst* inst, const Xbyak::Reg& reg);
-```
-
-By calling `DefineValue`, you are stating that you wish to define the value for `inst`, and you have written the
-value to the specified register `reg`.
-
-### `Define`ing as an alias of a different value
-
-Adding a `Define` to an existing value.
-
-```c++
-void DefineValue(IR::Inst* inst, Argument& arg);
-```
-
-You are declaring that the value for `inst` is the same as the value for `arg`. No host machine instructions are
-emitted.
-
-## When to use each?
-
-* Prefer `Use` to `UseScratch` where possible.
-* Prefer the `OpArg` variants where possible.
-* Prefer to **not** use the specific `HostLoc` variants where possible.

src/dynarmic/docs/ReturnStackBufferOptimization.md

@@ -1,157 +0,0 @@
-# Return Stack Buffer Optimization (x64 Backend)
-
-One of the optimizations that dynarmic does is block-linking. Block-linking is done when
-the destination address of a jump is available at JIT-time. Instead of returning to the
-dispatcher at the end of a block we can perform block-linking: just jump directly to the
-next block. This is beneficial because returning to the dispatcher can often be quite
-expensive.
-
-What should we do in cases when we can't predict the destination address? The eponymous
-example is when executing a return statement at the end of a function; the return address
-is not statically known at compile time.
-
-We deal with this by using a return stack buffer: When we execute a call instruction,
-we push our prediction onto the RSB. When we execute a return instruction, we pop a
-prediction off the RSB. If the prediction is a hit, we immediately jump to the relevant
-compiled block. Otherwise, we return to the dispatcher.
-
-This is the essential idea behind this optimization.
-
-## `UniqueHash`
-
-One complication dynarmic has is that a compiled block is not uniquely identifiable by
-the PC alone, but bits in the FPSCR and CPSR are also relevant. We resolve this by
-computing a 64-bit `UniqueHash` that is guaranteed to uniquely identify a block.
-
-```c++
-u64 LocationDescriptor::UniqueHash() const {
-    // This value MUST BE UNIQUE.
-    // This calculation has to match up with EmitX64::EmitTerminalPopRSBHint
-    u64 pc_u64 = u64(arm_pc) << 32;
-    u64 fpscr_u64 = u64(fpscr.Value());
-    u64 t_u64 = cpsr.T() ? 1 : 0;
-    u64 e_u64 = cpsr.E() ? 2 : 0;
-    return pc_u64 | fpscr_u64 | t_u64 | e_u64;
-}
-```
-
-## Our implementation isn't actually a stack
-
-Dynarmic's RSB isn't actually a stack. It was implemented as a ring buffer because
-that showed better performance in tests.
-
-### RSB Structure
-
-The RSB is implemented as a ring buffer. `rsb_ptr` is the index of the insertion
-point. Each element in `rsb_location_descriptors` is a `UniqueHash` and they
-each correspond to an element in `rsb_codeptrs`. `rsb_codeptrs` contains the
-host addresses for the corresponding the compiled blocks.
-
-`RSBSize` was chosen by performance testing. Note that this is bigger than the
-size of the real RSB in hardware (which has 3 entries). Larger RSBs than 8
-showed degraded performance.
-
-```c++
-struct JitState {
-    // ...
-
-    static constexpr size_t RSBSize = 8; // MUST be a power of 2.
-    u32 rsb_ptr = 0;
-    std::array<u64, RSBSize> rsb_location_descriptors;
-    std::array<u64, RSBSize> rsb_codeptrs;
-    void ResetRSB();
-
-    // ...
-};
-```
-
-### RSB Push
-
-We insert our prediction at the insertion point iff the RSB doesn't already
-contain a prediction with the same `UniqueHash`.
-
-```c++
-void EmitX64::EmitPushRSB(IR::Block&, IR::Inst* inst) {
-    using namespace Xbyak::util;
-
-    ASSERT(inst->GetArg(0).IsImmediate());
-    u64 imm64 = inst->GetArg(0).GetU64();
-
-    Xbyak::Reg64 code_ptr_reg = reg_alloc.ScratchGpr(code, {HostLoc::RCX});
-    Xbyak::Reg64 loc_desc_reg = reg_alloc.ScratchGpr(code);
-    Xbyak::Reg32 index_reg = reg_alloc.ScratchGpr(code).cvt32();
-    u64 code_ptr = unique_hash_to_code_ptr.find(imm64) != unique_hash_to_code_ptr.end()
-                    ? u64(unique_hash_to_code_ptr[imm64])
-                    : u64(code->GetReturnFromRunCodeAddress());
-
-    code->mov(index_reg, dword[code.ABI_JIT_PTR + offsetof(JitState, rsb_ptr)]);
-    code->add(index_reg, 1);
-    code->and_(index_reg, u32(JitState::RSBSize - 1));
-
-    code->mov(loc_desc_reg, u64(imm64));
-    CodePtr patch_location = code->getCurr<CodePtr>();
-    patch_unique_hash_locations[imm64].emplace_back(patch_location);
-    code->mov(code_ptr_reg, u64(code_ptr)); // This line has to match up with EmitX64::Patch.
-    code->EnsurePatchLocationSize(patch_location, 10);
-
-    Xbyak::Label label;
-    for (size_t i = 0; i < JitState::RSBSize; ++i) {
-        code->cmp(loc_desc_reg, qword[code.ABI_JIT_PTR + offsetof(JitState, rsb_location_descriptors) + i * sizeof(u64)]);
-        code->je(label, code->T_SHORT);
-    }
-
-    code->mov(dword[code.ABI_JIT_PTR + offsetof(JitState, rsb_ptr)], index_reg);
-    code->mov(qword[code.ABI_JIT_PTR + index_reg.cvt64() * 8 + offsetof(JitState, rsb_location_descriptors)], loc_desc_reg);
-    code->mov(qword[code.ABI_JIT_PTR + index_reg.cvt64() * 8 + offsetof(JitState, rsb_codeptrs)], code_ptr_reg);
-    code->L(label);
-}
-```
-
-In pseudocode:
-
-```c++
-    for (i := 0 .. RSBSize-1)
-        if (rsb_location_descriptors[i] == imm64)
-        goto label;
-    rsb_ptr++;
-    rsb_ptr %= RSBSize;
-    rsb_location_desciptors[rsb_ptr] = imm64; //< The UniqueHash
-    rsb_codeptr[rsb_ptr] = /* codeptr corresponding to the UniqueHash */;
-label:
-```
-
-## RSB Pop
-
-To check if a predicition is in the RSB, we linearly scan the RSB.
-
-```c++
-void EmitX64::EmitTerminalPopRSBHint(IR::Term::PopRSBHint, IR::LocationDescriptor initial_location) {
-    using namespace Xbyak::util;
-
-    // This calculation has to match up with IREmitter::PushRSB
-    code->mov(ecx, MJitStateReg(Arm::Reg::PC));
-    code->shl(rcx, 32);
-    code->mov(ebx, dword[code.ABI_JIT_PTR + offsetof(JitState, FPSCR_mode)]);
-    code->or_(ebx, dword[code.ABI_JIT_PTR + offsetof(JitState, CPSR_et)]);
-    code->or_(rbx, rcx);
-
-    code->mov(rax, u64(code->GetReturnFromRunCodeAddress()));
-    for (size_t i = 0; i < JitState::RSBSize; ++i) {
-        code->cmp(rbx, qword[code.ABI_JIT_PTR + offsetof(JitState, rsb_location_descriptors) + i * sizeof(u64)]);
-        code->cmove(rax, qword[code.ABI_JIT_PTR + offsetof(JitState, rsb_codeptrs) + i * sizeof(u64)]);
-    }
-
-    code->jmp(rax);
-}
-```
-
-In pseudocode:
-
-```c++
-rbx := ComputeUniqueHash()
-rax := ReturnToDispatch
-for (i := 0 .. RSBSize-1)
-    if (rbx == rsb_location_descriptors[i])
-        rax = rsb_codeptrs[i]
-goto rax
-```

src/dynarmic/tests/A32/testenv.h

@@ -97,15 +97,15 @@ public:
         MemoryWrite32(vaddr + 4, static_cast<u32>(value >> 32));
     }
 
-    void InterpreterFallback(u32 /*pc*/, size_t /*num_instructions*/) override {
+    void InterpreterFallback(u32 pc, size_t num_instructions) override {
         UNREACHABLE(); //ASSERT(false && "InterpreterFallback({:08x} && {}) code = {:08x}", pc, num_instructions, *MemoryReadCode(pc));
     }
 
-    void CallSVC(std::uint32_t /*swi*/) override {
+    void CallSVC(std::uint32_t swi) override {
         UNREACHABLE(); //ASSERT(false && "CallSVC({})", swi);
     }
 
-    void ExceptionRaised(u32 /*pc*/, Dynarmic::A32::Exception /*exception*/) override {
+    void ExceptionRaised(u32 pc, Dynarmic::A32::Exception /*exception*/) override {
         UNREACHABLE(); //ASSERT(false && "ExceptionRaised({:08x}) code = {:08x}", pc, *MemoryReadCode(pc));
     }
 
@@ -190,15 +190,15 @@ public:
         return true;
     }
 
-    void InterpreterFallback(std::uint32_t /*pc*/, size_t /*num_instructions*/) override {
+    void InterpreterFallback(std::uint32_t pc, size_t num_instructions) override {
         UNREACHABLE(); //ASSERT(false && "InterpreterFallback({:016x} && {})", pc, num_instructions);
     }
 
-    void CallSVC(std::uint32_t /*swi*/) override {
+    void CallSVC(std::uint32_t swi) override {
         UNREACHABLE(); //ASSERT(false && "CallSVC({})", swi);
     }
 
-    void ExceptionRaised(std::uint32_t /*pc*/, Dynarmic::A32::Exception) override {
+    void ExceptionRaised(std::uint32_t pc, Dynarmic::A32::Exception) override {
         UNREACHABLE(); //ASSERT(false && "ExceptionRaised({:016x})", pc);
     }
 

src/dynarmic/tests/A64/testenv.h

@@ -105,15 +105,15 @@ public:
         return true;
     }
 
-    void InterpreterFallback(u64 /*pc*/, size_t /*num_instructions*/) override {
+    void InterpreterFallback(u64 pc, size_t num_instructions) override {
         UNREACHABLE(); // ASSERT(false&& "InterpreterFallback({:016x} && {})", pc, num_instructions);
     }
 
-    void CallSVC(std::uint32_t /*swi*/) override {
+    void CallSVC(std::uint32_t swi) override {
         UNREACHABLE(); //ASSERT(false && "CallSVC({})", swi);
     }
 
-    void ExceptionRaised(u64 /*pc*/, Dynarmic::A64::Exception /*exception*/) override {
+    void ExceptionRaised(u64 pc, Dynarmic::A64::Exception /*exception*/) override {
         UNREACHABLE(); //ASSERT(false && "ExceptionRaised({:016x})", pc);
     }
 
@@ -208,15 +208,15 @@ public:
         return true;
     }
 
-    void InterpreterFallback(u64 /*pc*/, size_t /*num_instructions*/) override {
+    void InterpreterFallback(u64 pc, size_t num_instructions) override {
         ASSERT(ignore_invalid_insn && "InterpreterFallback");
     }
 
-    void CallSVC(std::uint32_t /*swi*/) override {
+    void CallSVC(std::uint32_t swi) override {
         UNREACHABLE(); //ASSERT(false && "CallSVC({})", swi);
     }
 
-    void ExceptionRaised(u64 /*pc*/, Dynarmic::A64::Exception) override {
+    void ExceptionRaised(u64 pc, Dynarmic::A64::Exception) override {
         UNREACHABLE(); //ASSERT(false && "ExceptionRaised({:016x})", pc);
     }
 

src/frontend_common/play_time_manager.h

@@ -48,7 +48,7 @@ private:
     void Save();
 
     PlayTimeDatabase database;
-    u64 running_program_id{};
+    u64 running_program_id;
     std::jthread play_time_thread;
 };
 

src/input_common/helpers/joycon_protocol/poller.cpp

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 

src/network/room_member.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2017 Citra Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -56,7 +53,7 @@ struct ChatEntry {
 
 /// Represents a system status message.
 struct StatusMessageEntry {
-    StatusMessageTypes type{}; ///< Type of the message
+    StatusMessageTypes type; ///< Type of the message
     /// Subject of the message. i.e. the user who is joining/leaving/being banned, etc.
     std::string nickname;
     std::string username;

src/shader_recompiler/backend/glsl/emit_glsl_context_get_set.cpp

@@ -446,12 +446,10 @@ void EmitIsHelperInvocation(EmitContext& ctx, IR::Inst& inst) {
 
 void EmitSR_WScaleFactorXY(EmitContext& ctx, IR::Inst& inst) {
     LOG_WARNING(Shader, "(STUBBED) called");
-    ctx.AddU32("{}=0x3c003c00u;", inst);
 }
 
 void EmitSR_WScaleFactorZ(EmitContext& ctx, IR::Inst& inst) {
     LOG_WARNING(Shader, "(STUBBED) called");
-    ctx.AddU32("{}=0x3f800000u;", inst);
 }
 
 void EmitYDirection(EmitContext& ctx, IR::Inst& inst) {

src/shader_recompiler/backend/glsl/var_alloc.cpp

@@ -58,9 +58,6 @@ std::string FormatFloat(std::string_view value, IR::Type type) {
         if (value == "nan") {
             return "utof(0x7fc00000)";
         }
-        if (value == "-nan") {
-            return "utof(0xffc00000)";
-        }
         if (value == "inf") {
             return "utof(0x7f800000)";
         }

src/video_core/buffer_cache/buffer_cache.h

@@ -7,6 +7,7 @@
 #pragma once
 
 #include <algorithm>
+#include <cstring>
 #include <memory>
 #include <numeric>
 
@@ -15,6 +16,8 @@
 #include "video_core/guest_memory.h"
 #include "video_core/host1x/gpu_device_memory_manager.h"
 #include "video_core/texture_cache/util.h"
+#include "video_core/polygon_mode_utils.h"
+#include "video_core/renderer_vulkan/line_loop_utils.h"
 
 namespace VideoCommon {
 
@@ -353,14 +356,37 @@ void BufferCache<P>::UpdateComputeBuffers() {
 
 template <class P>
 void BufferCache<P>::BindHostGeometryBuffers(bool is_indexed) {
+    const auto& draw_state = maxwell3d->draw_manager->GetDrawState();
     if (is_indexed) {
         BindHostIndexBuffer();
-    } else if constexpr (!HAS_FULL_INDEX_AND_PRIMITIVE_SUPPORT) {
-        const auto& draw_state = maxwell3d->draw_manager->GetDrawState();
-        if (draw_state.topology == Maxwell::PrimitiveTopology::Quads ||
-            draw_state.topology == Maxwell::PrimitiveTopology::QuadStrip) {
-            runtime.BindQuadIndexBuffer(draw_state.topology, draw_state.vertex_buffer.first,
-                                        draw_state.vertex_buffer.count);
+    } else {
+        if constexpr (!P::IS_OPENGL) {
+            const auto polygon_mode = VideoCore::EffectivePolygonMode(maxwell3d->regs);
+            if (draw_state.topology == Maxwell::PrimitiveTopology::Polygon &&
+                polygon_mode == Maxwell::PolygonMode::Line && draw_state.vertex_buffer.count > 1) {
+                const u32 vertex_count = draw_state.vertex_buffer.count;
+                const u32 generated_count = vertex_count + 1;
+                const bool use_u16 = vertex_count <= 0x10000;
+                const u32 element_size = use_u16 ? sizeof(u16) : sizeof(u32);
+                auto staging = runtime.UploadStagingBuffer(
+                    static_cast<size_t>(generated_count) * element_size);
+                std::span<u8> dst_span{staging.mapped_span.data(),
+                                       generated_count * static_cast<size_t>(element_size)};
+                Vulkan::LineLoop::GenerateSequentialWithClosureRaw(dst_span, element_size);
+                const auto synthetic_format = use_u16 ? Maxwell::IndexFormat::UnsignedShort
+                                                      : Maxwell::IndexFormat::UnsignedInt;
+                runtime.BindIndexBuffer(draw_state.topology, synthetic_format,
+                                        draw_state.vertex_buffer.first, generated_count,
+                                        staging.buffer, static_cast<u32>(staging.offset),
+                                        generated_count * element_size);
+            }
+        }
+        if constexpr (!HAS_FULL_INDEX_AND_PRIMITIVE_SUPPORT) {
+            if (draw_state.topology == Maxwell::PrimitiveTopology::Quads ||
+                draw_state.topology == Maxwell::PrimitiveTopology::QuadStrip) {
+                runtime.BindQuadIndexBuffer(draw_state.topology, draw_state.vertex_buffer.first,
+                                            draw_state.vertex_buffer.count);
+            }
         }
     }
     BindHostVertexBuffers();
@@ -689,6 +715,44 @@ void BufferCache<P>::BindHostIndexBuffer() {
     const u32 offset = buffer.Offset(channel_state->index_buffer.device_addr);
     const u32 size = channel_state->index_buffer.size;
     const auto& draw_state = maxwell3d->draw_manager->GetDrawState();
+    if constexpr (!P::IS_OPENGL) {
+        const auto polygon_mode = VideoCore::EffectivePolygonMode(maxwell3d->regs);
+        const bool polygon_line =
+            draw_state.topology == Maxwell::PrimitiveTopology::Polygon &&
+            polygon_mode == Maxwell::PolygonMode::Line;
+        if (polygon_line && draw_state.index_buffer.count > 1) {
+            const u32 element_size = draw_state.index_buffer.FormatSizeInBytes();
+            const size_t src_bytes = static_cast<size_t>(draw_state.index_buffer.count) * element_size;
+            const size_t total_bytes = src_bytes + element_size;
+            auto staging = runtime.UploadStagingBuffer(total_bytes);
+            std::span<u8> dst_span{staging.mapped_span.data(), total_bytes};
+            std::span<const u8> src_span;
+            if (!draw_state.inline_index_draw_indexes.empty()) {
+                const u8* const src =
+                    draw_state.inline_index_draw_indexes.data() +
+                    static_cast<size_t>(draw_state.index_buffer.first) * element_size;
+                src_span = {src, src_bytes};
+            } else if (const u8* const cpu_base =
+                           device_memory.GetPointer<u8>(channel_state->index_buffer.device_addr)) {
+                const u8* const src = cpu_base +
+                                      static_cast<size_t>(draw_state.index_buffer.first) * element_size;
+                src_span = {src, src_bytes};
+            } else {
+                const DAddr src_addr =
+                    channel_state->index_buffer.device_addr +
+                    static_cast<DAddr>(draw_state.index_buffer.first) * element_size;
+                device_memory.ReadBlockUnsafe(src_addr, dst_span.data(), src_bytes);
+                src_span = {dst_span.data(), src_bytes};
+            }
+            Vulkan::LineLoop::CopyWithClosureRaw(dst_span, src_span, element_size);
+            buffer.MarkUsage(offset, size);
+            runtime.BindIndexBuffer(draw_state.topology, draw_state.index_buffer.format,
+                                    draw_state.index_buffer.first, draw_state.index_buffer.count + 1,
+                                    staging.buffer, static_cast<u32>(staging.offset),
+                                    static_cast<u32>(total_bytes));
+            return;
+        }
+    }
     if (!draw_state.inline_index_draw_indexes.empty()) [[unlikely]] {
         if constexpr (USE_MEMORY_MAPS_FOR_UPLOADS) {
             auto upload_staging = runtime.UploadStagingBuffer(size);
@@ -1705,26 +1769,21 @@ Binding BufferCache<P>::StorageBufferBinding(GPUVAddr ssbo_addr, u32 cbuf_index,
         return NULL_BINDING;
     }
 
-    // xbzk: New size logic. Fixes MCI.
-    // If ever the * comment below prove wrong, the 'if' block may be removed.
     const auto size = [&]() {
         const bool is_nvn_cbuf = cbuf_index == 0;
+        // The NVN driver buffer (index 0) is known to pack the SSBO address followed by its size.
         if (is_nvn_cbuf) {
-            // * The NVN driver buffer (index 0) is known to pack the SSBO address followed by its size.
-            const u64 next_qword = gpu_memory->Read<u64>(ssbo_addr + 8);
-            const u32 upper_32 = static_cast<u32>(next_qword >> 32);
-            // Hardware-based detection: GPU addresses have non-zero upper bits
-            if (upper_32 == 0) {
-                // This is a size field, not a GPU address
-                return static_cast<u32>(next_qword);  // Return lower_32
+            const u32 ssbo_size = gpu_memory->Read<u32>(ssbo_addr + 8);
+            if (ssbo_size != 0) {
+                return ssbo_size;
             }
         }
-        // Fall through: either not NVN cbuf (Doom Eternal & +), or NVN but ssbo_addr+8 is a GPU address (MCI)
+        // Other titles (notably Doom Eternal) may use STG/LDG on buffer addresses in custom defined
+        // cbufs, which do not store the sizes adjacent to the addresses, so use the fully
+        // mapped buffer size for now.
         const u32 memory_layout_size = static_cast<u32>(gpu_memory->GetMemoryLayoutSize(gpu_addr));
-        // Cap at 8MB to prevent allocator overflow from misinterpreted addresses
         return (std::min)(memory_layout_size, static_cast<u32>(8_MiB));
     }();
-
     // Alignment only applies to the offset of the buffer
     const u32 alignment = runtime.GetStorageBufferAlignment();
     const GPUVAddr aligned_gpu_addr = Common::AlignDown(gpu_addr, alignment);

src/video_core/control/scheduler.cpp

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
@@ -20,7 +17,7 @@ void Scheduler::Push(s32 channel, CommandList&& entries) {
     std::unique_lock lk(scheduling_guard);
     auto it = channels.find(channel);
     ASSERT(it != channels.end());
-    auto& channel_state = it->second;
+    auto channel_state = it->second;
     gpu.BindChannel(channel_state->bind_id);
     channel_state->dma_pusher->Push(std::move(entries));
     channel_state->dma_pusher->DispatchCalls();

src/video_core/fence_manager.h

@@ -81,8 +81,7 @@ public:
         if constexpr (can_async_check) {
             guard.lock();
         }
-        // if ((Settings::IsGPULevelLow() || Settings::IsGPULevelMedium()) && !should_flush) {
-        if (false) {
+        if (Settings::IsGPULevelLow() || (Settings::IsGPULevelMedium() && !should_flush)) {
             func();
         } else {
             uncommitted_operations.emplace_back(std::move(func));

src/video_core/host1x/ffmpeg/ffmpeg.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
@@ -8,7 +8,6 @@
 #include "common/logging/log.h"
 #include "common/scope_exit.h"
 #include "common/settings.h"
-#include <thread>
 #include "core/memory.h"
 #include "video_core/host1x/ffmpeg/ffmpeg.h"
 #include "video_core/memory_manager.h"

src/video_core/host1x/vic.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
@@ -7,9 +7,6 @@
 #include <array>
 #include <tuple>
 #include <stdint.h>
-#include <thread>
-#include <vector>
-
 
 extern "C" {
 #if defined(__GNUC__) || defined(__clang__)
@@ -110,19 +107,9 @@ void Vic::Execute() {
     auto output_height{config.output_surface_config.out_surface_height + 1};
     output_surface.resize_destructive(output_width * output_height);
 
-    // Initialize the surface with the appropriate black pixel
-    Pixel black_pixel{};
-    if (config.output_surface_config.out_pixel_format == VideoPixelFormat::Y8__V8U8_N420) {
-        // Y=0, U=512, V=512 (10-bit), A=0
-        black_pixel = {0, 512, 512, 0};
-    } else {
-        // R=0, G=0, B=0, A=0
-        black_pixel = {0, 0, 0, 0};
-    }
-    std::fill(output_surface.begin(), output_surface.end(), black_pixel);
-
     if (Settings::values.nvdec_emulation.GetValue() == Settings::NvdecEmulation::Off) [[unlikely]] {
-
+        // Fill the frame with black, as otherwise they can have random data and be very glitchy.
+        std::fill(output_surface.begin(), output_surface.end(), Pixel{});
     } else {
         for (size_t i = 0; i < config.slot_structs.size(); i++) {
             auto& slot_config{config.slot_structs[i]};
@@ -135,18 +122,7 @@ void Vic::Execute() {
                 nvdec_id = frame_queue.VicFindNvdecFdFromOffset(luma_offset);
             }
 
-            auto frame = frame_queue.GetFrame(nvdec_id, luma_offset);
-            if (!frame) {
-                // We might've failed to find the frame, or the nvdec id is stale/wrong.
-                // Try to find the nvdec id again.
-                const s32 new_id = frame_queue.VicFindNvdecFdFromOffset(luma_offset);
-                if (new_id != -1) {
-                    nvdec_id = new_id;
-                    frame = frame_queue.GetFrame(nvdec_id, luma_offset);
-                }
-            }
-
-            if (frame) {
+            if (auto frame = frame_queue.GetFrame(nvdec_id, luma_offset); frame) {
                 if (frame.get()) {
                     switch (frame->GetPixelFormat()) {
                     case AV_PIX_FMT_YUV420P:
@@ -215,44 +191,20 @@ void Vic::ReadProgressiveY8__V8U8_N420(const SlotStruct& slot, std::span<const P
 
     const auto alpha{u16(slot.config.planar_alpha.Value())};
     for (s32 y = 0; y < in_luma_height; y++) {
-        const u8* luma_ptr = luma_buffer + y * in_luma_stride;
-        const u8* chroma_u_ptr = chroma_u_buffer + (y / 2) * in_chroma_stride;
-        // For planar, V buffer is separate. For NV12, it is not used directly in the same way.
-        const u8* chroma_v_ptr = planar ? (chroma_v_buffer + (y / 2) * in_chroma_stride) : nullptr;
-
-        Pixel* dst_ptr = &slot_surface[y * out_luma_stride];
-
-        for (s32 x = 0; x < in_luma_width; x += 2) {
-            u16 u_val, v_val;
-
-            if (planar) {
-                // YUV420P: U and V are in separate planes.
-                // 1 UV pair for 2 horizontal pixels.
-                u_val = u16(chroma_u_ptr[x / 2] << 2);
-                v_val = u16(chroma_v_ptr[x / 2] << 2);
+        const auto src_luma{y * in_luma_stride};
+        const auto src_chroma{(y / 2) * in_chroma_stride};
+        const auto dst{y * out_luma_stride};
+        for (s32 x = 0; x < in_luma_width; x++) {
+            slot_surface[dst + x].r = u16(luma_buffer[src_luma + x] << 2);
+            // Chroma samples are duplicated horizontally and vertically.
+            if(planar) {
+                slot_surface[dst + x].g = u16(chroma_u_buffer[src_chroma + x / 2] << 2);
+                slot_surface[dst + x].b = u16(chroma_v_buffer[src_chroma + x / 2] << 2);
             } else {
-                // NV12: UV are interleaved in the second plane.
-                // U is at even byte, V is at odd byte.
-                // x is even (0, 2, 4...), so x corresponds to the byte offset in the interleaved buffer.
-                u_val = u16(chroma_u_ptr[x] << 2);
-                v_val = u16(chroma_u_ptr[x + 1] << 2);
+                slot_surface[dst + x].g = u16(chroma_u_buffer[src_chroma + (x & ~1) + 0] << 2);
+                slot_surface[dst + x].b = u16(chroma_u_buffer[src_chroma + (x & ~1) + 1] << 2);
             }
-
-            // Pixel 1 (Even x)
-            dst_ptr[0].r = u16(luma_ptr[x] << 2);
-            dst_ptr[0].g = u_val;
-            dst_ptr[0].b = v_val;
-            dst_ptr[0].a = alpha;
-
-            // Pixel 2 (Odd x), check boundary
-            if (x + 1 < in_luma_width) {
-                dst_ptr[1].r = u16(luma_ptr[x + 1] << 2);
-                dst_ptr[1].g = u_val;
-                dst_ptr[1].b = v_val;
-                dst_ptr[1].a = alpha;
-            }
-
-            dst_ptr += 2;
+            slot_surface[dst + x].a = alpha;
         }
     }
 }

src/video_core/polygon_mode_utils.h

@@ -0,0 +1,46 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include "video_core/engines/maxwell_3d.h"
+
+namespace VideoCore {
+
+inline Tegra::Engines::Maxwell3D::Regs::PolygonMode EffectivePolygonMode(
+    const Tegra::Engines::Maxwell3D::Regs& regs) {
+    using Maxwell = Tegra::Engines::Maxwell3D::Regs;
+
+    const bool cull_enabled = regs.gl_cull_test_enabled != 0;
+    const auto cull_face = regs.gl_cull_face;
+    const bool cull_front = cull_enabled && (cull_face == Maxwell::CullFace::Front ||
+                                             cull_face == Maxwell::CullFace::FrontAndBack);
+    const bool cull_back = cull_enabled && (cull_face == Maxwell::CullFace::Back ||
+                                            cull_face == Maxwell::CullFace::FrontAndBack);
+
+    const bool render_front = !cull_front;
+    const bool render_back = !cull_back;
+
+    const auto front_mode = regs.polygon_mode_front;
+    const auto back_mode = regs.polygon_mode_back;
+
+    if (render_front && render_back && front_mode != back_mode) {
+        if (front_mode == Maxwell::PolygonMode::Line || back_mode == Maxwell::PolygonMode::Line) {
+            return Maxwell::PolygonMode::Line;
+        }
+        if (front_mode == Maxwell::PolygonMode::Point || back_mode == Maxwell::PolygonMode::Point) {
+            return Maxwell::PolygonMode::Point;
+        }
+    }
+
+    if (render_front) {
+        return front_mode;
+    }
+    if (render_back) {
+        return back_mode;
+    }
+    return front_mode;
+}
+
+} // namespace VideoCore
+

src/video_core/renderer_opengl/gl_shader_util.cpp

@@ -33,8 +33,6 @@ static OGLProgram LinkSeparableProgram(GLuint shader) {
     glGetProgramInfoLog(program.handle, log_length, nullptr, log.data());
     if (link_status == GL_FALSE) {
         LOG_ERROR(Render_OpenGL, "{}", log);
-        glDeleteProgram(program.handle);
-        program.handle = 0;
     } else {
         LOG_WARNING(Render_OpenGL, "{}", log);
     }

src/video_core/renderer_opengl/present/window_adapt_pass.cpp

@@ -116,14 +116,9 @@ void WindowAdaptPass::DrawToFramebuffer(ProgramManager& program_manager, std::li
         glBindTextureUnit(0, textures[i]);
         glProgramUniformMatrix3x2fv(vert.handle, ModelViewMatrixLocation, 1, GL_FALSE,
                                     matrices[i].data());
-        if (frag.handle != 0) {
-            const GLint screen_size_loc = glGetUniformLocation(frag.handle, "screen_size");
-            if (screen_size_loc != -1) {
-                glProgramUniform2ui(frag.handle, screen_size_loc,
-                                    static_cast<GLuint>(layout.screen.GetWidth()),
-                                    static_cast<GLuint>(layout.screen.GetHeight()));
-            }
-        }
+        glProgramUniform2ui(frag.handle, ScreenSizeLocation,
+                            static_cast<GLuint>(layout.screen.GetWidth()),
+                            static_cast<GLuint>(layout.screen.GetHeight()));
         glNamedBufferSubData(vertex_buffer.handle, 0, sizeof(vertices[i]), std::data(vertices[i]));
         glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
     }

src/video_core/renderer_vulkan/fixed_pipeline_state.cpp

@@ -15,6 +15,7 @@
 #include "video_core/engines/draw_manager.h"
 #include "video_core/renderer_vulkan/fixed_pipeline_state.h"
 #include "video_core/renderer_vulkan/vk_state_tracker.h"
+#include "video_core/polygon_mode_utils.h"
 
 namespace Vulkan {
 namespace {
@@ -65,7 +66,7 @@ void FixedPipelineState::Refresh(Tegra::Engines::Maxwell3D& maxwell3d, DynamicFe
     dynamic_vertex_input.Assign(features.has_dynamic_vertex_input ? 1 : 0);
     xfb_enabled.Assign(regs.transform_feedback_enabled != 0);
     ndc_minus_one_to_one.Assign(regs.depth_mode == Maxwell::DepthMode::MinusOneToOne ? 1 : 0);
-    polygon_mode.Assign(PackPolygonMode(regs.polygon_mode_front));
+    polygon_mode.Assign(PackPolygonMode(VideoCore::EffectivePolygonMode(regs)));
     tessellation_primitive.Assign(static_cast<u32>(regs.tessellation.params.domain_type.Value()));
     tessellation_spacing.Assign(static_cast<u32>(regs.tessellation.params.spacing.Value()));
     tessellation_clockwise.Assign(regs.tessellation.params.output_primitives.Value() ==

src/video_core/renderer_vulkan/line_loop_utils.h

@@ -0,0 +1,68 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include <algorithm>
+#include <cstring>
+#include <span>
+
+#include "common/assert.h"
+#include "common/common_types.h"
+
+namespace Vulkan::LineLoop {
+
+inline void CopyWithClosureRaw(std::span<u8> dst, std::span<const u8> src, size_t element_size) {
+    ASSERT_MSG(dst.size() == src.size() + element_size, "Invalid line loop copy sizes");
+    if (src.empty()) {
+        if (!dst.empty()) {
+            std::fill(dst.begin(), dst.end(), u8{0});
+        }
+        return;
+    }
+    std::memcpy(dst.data(), src.data(), src.size());
+    std::memcpy(dst.data() + src.size(), src.data(), element_size);
+}
+
+inline void GenerateSequentialWithClosureRaw(std::span<u8> dst, size_t element_size,
+                                             u64 start_value = 0) {
+    if (dst.empty()) {
+        return;
+    }
+    const size_t last = dst.size() - element_size;
+    size_t offset = 0;
+    u64 value = start_value;
+    while (offset < last) {
+        std::memcpy(dst.data() + offset, &value, element_size);
+        offset += element_size;
+        ++value;
+    }
+    std::memcpy(dst.data() + offset, &start_value, element_size);
+}
+
+template <typename T>
+inline void CopyWithClosure(std::span<T> dst, std::span<const T> src) {
+    ASSERT_MSG(dst.size() == src.size() + 1, "Invalid destination size for line loop copy");
+    if (src.empty()) {
+        if (!dst.empty()) {
+            dst.front() = {};
+        }
+        return;
+    }
+    std::copy(src.begin(), src.end(), dst.begin());
+    dst.back() = src.front();
+}
+
+template <typename T>
+inline void GenerateSequentialWithClosure(std::span<T> dst, T start_value = {}) {
+    if (dst.empty()) {
+        return;
+    }
+    const size_t last = dst.size() - 1;
+    for (size_t i = 0; i < last; ++i) {
+        dst[i] = static_cast<T>(start_value + static_cast<T>(i));
+    }
+    dst.back() = start_value;
+}
+
+} // namespace Vulkan::LineLoop

src/video_core/renderer_vulkan/maxwell_to_vk.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -323,44 +326,9 @@ VkShaderStageFlagBits ShaderStage(Shader::Stage stage) {
 }
 
 VkPrimitiveTopology PrimitiveTopology([[maybe_unused]] const Device& device,
-                                      Maxwell::PrimitiveTopology topology) {
-    switch (topology) {
-    case Maxwell::PrimitiveTopology::Points:
-        return VK_PRIMITIVE_TOPOLOGY_POINT_LIST;
-    case Maxwell::PrimitiveTopology::Lines:
-        return VK_PRIMITIVE_TOPOLOGY_LINE_LIST;
-    case Maxwell::PrimitiveTopology::LineLoop:
-        return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
-    case Maxwell::PrimitiveTopology::LineStrip:
-        return VK_PRIMITIVE_TOPOLOGY_LINE_STRIP;
-    case Maxwell::PrimitiveTopology::Triangles:
-        return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
-    case Maxwell::PrimitiveTopology::TriangleStrip:
-        return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP;
-    case Maxwell::PrimitiveTopology::TriangleFan:
-        return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN;
-    case Maxwell::PrimitiveTopology::LinesAdjacency:
-        return VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY;
-    case Maxwell::PrimitiveTopology::LineStripAdjacency:
-        return VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY;
-    case Maxwell::PrimitiveTopology::TrianglesAdjacency:
-        return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY;
-    case Maxwell::PrimitiveTopology::TriangleStripAdjacency:
-        return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY;
-    case Maxwell::PrimitiveTopology::Quads:
-    case Maxwell::PrimitiveTopology::QuadStrip:
-        // TODO: Use VK_PRIMITIVE_TOPOLOGY_QUAD_LIST_EXT/VK_PRIMITIVE_TOPOLOGY_QUAD_STRIP_EXT
-        // whenever it releases
-        return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
-    case Maxwell::PrimitiveTopology::Patches:
-        return VK_PRIMITIVE_TOPOLOGY_PATCH_LIST;
-    case Maxwell::PrimitiveTopology::Polygon:
-        LOG_WARNING(Render_Vulkan, "Draw mode is Polygon with a polygon mode of lines should be a "
-                                   "single body and not a bunch of triangles.");
-        return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN;
-    }
-    UNIMPLEMENTED_MSG("Unimplemented topology={}", topology);
-    return {};
+                                      Maxwell::PrimitiveTopology topology,
+                                      Maxwell::PolygonMode polygon_mode) {
+    return detail::PrimitiveTopologyNoDevice(topology, polygon_mode);
 }
 
 VkFormat VertexFormat(const Device& device, Maxwell::VertexAttribute::Type type,

src/video_core/renderer_vulkan/maxwell_to_vk.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -15,6 +18,52 @@ namespace Vulkan::MaxwellToVK {
 using Maxwell = Tegra::Engines::Maxwell3D::Regs;
 using PixelFormat = VideoCore::Surface::PixelFormat;
 
+namespace detail {
+constexpr VkPrimitiveTopology PrimitiveTopologyNoDevice(Maxwell::PrimitiveTopology topology,
+                                                        Maxwell::PolygonMode polygon_mode) {
+    switch (topology) {
+    case Maxwell::PrimitiveTopology::Points:
+        return VK_PRIMITIVE_TOPOLOGY_POINT_LIST;
+    case Maxwell::PrimitiveTopology::Lines:
+        return VK_PRIMITIVE_TOPOLOGY_LINE_LIST;
+    case Maxwell::PrimitiveTopology::LineLoop:
+        return VK_PRIMITIVE_TOPOLOGY_LINE_STRIP;
+    case Maxwell::PrimitiveTopology::LineStrip:
+        return VK_PRIMITIVE_TOPOLOGY_LINE_STRIP;
+    case Maxwell::PrimitiveTopology::Triangles:
+        return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
+    case Maxwell::PrimitiveTopology::TriangleStrip:
+        return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP;
+    case Maxwell::PrimitiveTopology::TriangleFan:
+        return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN;
+    case Maxwell::PrimitiveTopology::LinesAdjacency:
+        return VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY;
+    case Maxwell::PrimitiveTopology::LineStripAdjacency:
+        return VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY;
+    case Maxwell::PrimitiveTopology::TrianglesAdjacency:
+        return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY;
+    case Maxwell::PrimitiveTopology::TriangleStripAdjacency:
+        return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY;
+    case Maxwell::PrimitiveTopology::Quads:
+    case Maxwell::PrimitiveTopology::QuadStrip:
+        return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
+    case Maxwell::PrimitiveTopology::Patches:
+        return VK_PRIMITIVE_TOPOLOGY_PATCH_LIST;
+    case Maxwell::PrimitiveTopology::Polygon:
+        switch (polygon_mode) {
+        case Maxwell::PolygonMode::Fill:
+            return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN;
+        case Maxwell::PolygonMode::Line:
+            return VK_PRIMITIVE_TOPOLOGY_LINE_STRIP;
+        case Maxwell::PolygonMode::Point:
+            return VK_PRIMITIVE_TOPOLOGY_POINT_LIST;
+        }
+        break;
+    }
+    return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
+}
+} // namespace detail
+
 namespace Sampler {
 
 VkFilter Filter(Tegra::Texture::TextureFilter filter);
@@ -46,7 +95,8 @@ struct FormatInfo {
 
 VkShaderStageFlagBits ShaderStage(Shader::Stage stage);
 
-VkPrimitiveTopology PrimitiveTopology(const Device& device, Maxwell::PrimitiveTopology topology);
+VkPrimitiveTopology PrimitiveTopology(const Device& device, Maxwell::PrimitiveTopology topology,
+                                      Maxwell::PolygonMode polygon_mode);
 
 VkFormat VertexFormat(const Device& device, Maxwell::VertexAttribute::Type type,
                       Maxwell::VertexAttribute::Size size);

src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp

@@ -7,6 +7,7 @@
 #include <algorithm>
 #include <iostream>
 #include <span>
+#include <string_view>
 
 #include <boost/container/small_vector.hpp>
 #include <boost/container/static_vector.hpp>
@@ -22,6 +23,7 @@
 #include "video_core/renderer_vulkan/vk_scheduler.h"
 #include "video_core/renderer_vulkan/vk_texture_cache.h"
 #include "video_core/renderer_vulkan/vk_update_descriptor.h"
+#include "video_core/polygon_mode_utils.h"
 #include "video_core/shader_notify.h"
 #include "video_core/texture_cache/texture_cache.h"
 #include "video_core/vulkan_common/vulkan_device.h"
@@ -614,7 +616,10 @@ void GraphicsPipeline::MakePipeline(VkRenderPass render_pass) {
         vertex_input_ci.pNext = &input_divisor_ci;
     }
     const bool has_tess_stages = spv_modules[1] || spv_modules[2];
-    auto input_assembly_topology = MaxwellToVK::PrimitiveTopology(device, key.state.topology);
+    const auto polygon_mode =
+        FixedPipelineState::UnpackPolygonMode(key.state.polygon_mode.Value());
+    auto input_assembly_topology =
+        MaxwellToVK::PrimitiveTopology(device, key.state.topology, polygon_mode);
     if (input_assembly_topology == VK_PRIMITIVE_TOPOLOGY_PATCH_LIST) {
         if (!has_tess_stages) {
             LOG_WARNING(Render_Vulkan, "Patch topology used without tessellation, using points");
@@ -629,6 +634,33 @@ void GraphicsPipeline::MakePipeline(VkRenderPass render_pass) {
             input_assembly_topology = VK_PRIMITIVE_TOPOLOGY_PATCH_LIST;
         }
     }
+    if (key.state.topology == Maxwell::PrimitiveTopology::Polygon) {
+        const auto polygon_mode_name = [polygon_mode]() -> std::string_view {
+            switch (polygon_mode) {
+            case Maxwell::PolygonMode::Fill:
+                return "Fill";
+            case Maxwell::PolygonMode::Line:
+                return "Line";
+            case Maxwell::PolygonMode::Point:
+                return "Point";
+            }
+            return "Unknown";
+        }();
+        const auto vk_topology_name = [input_assembly_topology]() -> std::string_view {
+            switch (input_assembly_topology) {
+            case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN:
+                return "TriangleFan";
+            case VK_PRIMITIVE_TOPOLOGY_LINE_STRIP:
+                return "LineStrip";
+            case VK_PRIMITIVE_TOPOLOGY_POINT_LIST:
+                return "PointList";
+            default:
+                return "Unexpected";
+            }
+        }();
+        LOG_DEBUG(Render_Vulkan, "Polygon primitive in {} mode mapped to {}", polygon_mode_name,
+                  vk_topology_name);
+    }
     const VkPipelineInputAssemblyStateCreateInfo input_assembly_ci{
         .sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,
         .pNext = nullptr,

src/video_core/renderer_vulkan/vk_rasterizer.cpp

@@ -37,6 +37,7 @@
 #include "video_core/renderer_vulkan/vk_update_descriptor.h"
 #include "video_core/shader_cache.h"
 #include "video_core/texture_cache/texture_cache_base.h"
+#include "video_core/polygon_mode_utils.h"
 #include "video_core/vulkan_common/vulkan_device.h"
 #include "video_core/vulkan_common/vulkan_wrapper.h"
 
@@ -108,7 +109,7 @@ VkViewport GetViewportState(const Device& device, const Maxwell& regs, size_t in
 
 VkRect2D GetScissorState(const Maxwell& regs, size_t index, u32 up_scale = 1, u32 down_shift = 0) {
     const auto& src = regs.scissor_test[index];
-    VkRect2D scissor{};
+    VkRect2D scissor;
     const auto scale_up = [&](s32 value) -> s32 {
         if (value == 0) {
             return 0U;
@@ -148,7 +149,8 @@ VkRect2D GetScissorState(const Maxwell& regs, size_t index, u32 up_scale = 1, u3
     return scissor;
 }
 
-DrawParams MakeDrawParams(const MaxwellDrawState& draw_state, u32 num_instances, bool is_indexed) {
+DrawParams MakeDrawParams(const MaxwellDrawState& draw_state, u32 num_instances, bool is_indexed,
+                          Maxwell::PolygonMode polygon_mode) {
     DrawParams params{
         .base_instance = draw_state.base_instance,
         .num_instances = num_instances,
@@ -168,6 +170,21 @@ DrawParams MakeDrawParams(const MaxwellDrawState& draw_state, u32 num_instances,
         params.base_vertex = 0;
         params.is_indexed = true;
     }
+    const bool polygon_line =
+        draw_state.topology == Maxwell::PrimitiveTopology::Polygon &&
+        polygon_mode == Maxwell::PolygonMode::Line;
+    if (polygon_line) {
+        if (params.is_indexed) {
+            if (draw_state.index_buffer.count > 1) {
+                params.num_vertices = draw_state.index_buffer.count + 1;
+            }
+        } else if (draw_state.vertex_buffer.count > 1) {
+            params.num_vertices = draw_state.vertex_buffer.count + 1;
+            params.is_indexed = true;
+            params.first_index = 0;
+            params.base_vertex = draw_state.vertex_buffer.first;
+        }
+    }
     return params;
 }
 } // Anonymous namespace
@@ -233,7 +250,8 @@ void RasterizerVulkan::Draw(bool is_indexed, u32 instance_count) {
     PrepareDraw(is_indexed, [this, is_indexed, instance_count] {
         const auto& draw_state = maxwell3d->draw_manager->GetDrawState();
         const u32 num_instances{instance_count};
-        const DrawParams draw_params{MakeDrawParams(draw_state, num_instances, is_indexed)};
+        const auto polygon_mode = VideoCore::EffectivePolygonMode(maxwell3d->regs);
+        const DrawParams draw_params{MakeDrawParams(draw_state, num_instances, is_indexed, polygon_mode)};
         scheduler.Record([draw_params](vk::CommandBuffer cmdbuf) {
             if (draw_params.is_indexed) {
                 cmdbuf.DrawIndexed(draw_params.num_vertices, draw_params.num_instances,
@@ -374,7 +392,7 @@ void RasterizerVulkan::Clear(u32 layer_count) {
     }
     UpdateViewportsState(regs);
 
-    VkRect2D default_scissor{};
+    VkRect2D default_scissor;
     default_scissor.offset.x = 0;
     default_scissor.offset.y = 0;
     default_scissor.extent.width = (std::numeric_limits<s32>::max)();

src/video_core/shader_environment.cpp

@@ -277,10 +277,7 @@ std::optional<u64> GenericEnvironment::TryFindSize() {
 Tegra::Texture::TICEntry GenericEnvironment::ReadTextureInfo(GPUVAddr tic_addr, u32 tic_limit,
                                                              bool via_header_index, u32 raw) {
     const auto handle{Tegra::Texture::TexturePair(raw, via_header_index)};
-    if (handle.first > tic_limit) {
-        LOG_WARNING(Shader, "Texture ID {} is out of bounds (limit {})", handle.first, tic_limit);
-        return {};
-    }
+    ASSERT(handle.first <= tic_limit);
     const GPUVAddr descriptor_addr{tic_addr + handle.first * sizeof(Tegra::Texture::TICEntry)};
     Tegra::Texture::TICEntry entry;
     gpu_memory->ReadBlock(descriptor_addr, &entry, sizeof(entry));

src/yuzu/configuration/configure_input.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: 2016 Citra Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -74,11 +71,11 @@ private:
 
     std::unique_ptr<InputProfiles> profiles;
 
-    std::array<ConfigureInputPlayer*, 8> player_controllers{};
-    std::array<QWidget*, 8> player_tabs{};
+    std::array<ConfigureInputPlayer*, 8> player_controllers;
+    std::array<QWidget*, 8> player_tabs;
     // Checkboxes representing the "Connected Controllers".
-    std::array<QCheckBox*, 8> connected_controller_checkboxes{};
-    ConfigureInputAdvanced* advanced = nullptr;
+    std::array<QCheckBox*, 8> connected_controller_checkboxes;
+    ConfigureInputAdvanced* advanced;
 
     Core::System& system;
 };

src/yuzu/configuration/configure_input_player_widget.cpp

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -692,10 +689,10 @@ void PlayerControlPreview::DrawHandheldController(QPainter& p, const QPointF cen
     {
         // Draw joysticks
         using namespace Settings::NativeAnalog;
-        const auto& l_stick = QPointF(stick_values[LStick].x.value, stick_values[LStick].y.value);
-        const auto& l_button = button_values[Settings::NativeButton::LStick];
-        const auto& r_stick = QPointF(stick_values[RStick].x.value, stick_values[RStick].y.value);
-        const auto& r_button = button_values[Settings::NativeButton::RStick];
+        const auto l_stick = QPointF(stick_values[LStick].x.value, stick_values[LStick].y.value);
+        const auto l_button = button_values[Settings::NativeButton::LStick];
+        const auto r_stick = QPointF(stick_values[RStick].x.value, stick_values[RStick].y.value);
+        const auto r_button = button_values[Settings::NativeButton::RStick];
 
         DrawJoystick(p, center + QPointF(-171, -41) + (l_stick * 4), 1.0f, l_button);
         DrawJoystick(p, center + QPointF(171, 8) + (r_stick * 4), 1.0f, r_button);

src/yuzu/configuration/configure_input_player_widget.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -217,7 +214,7 @@ private:
 
     bool mapping_active{};
     int blink_counter{};
-    int callback_key{};
+    int callback_key;
     QColor button_color{};
     ColorMapping colors{};
     Core::HID::LedPattern led_pattern{0, 0, 0, 0};

src/yuzu/main_window.cpp

@@ -1495,7 +1495,7 @@ void MainWindow::OnAppFocusStateChanged(Qt::ApplicationState state) {
             (state & (Qt::ApplicationHidden | Qt::ApplicationInactive))) {
             auto_paused = true;
             OnPauseGame();
-        } else if (!emu_thread->IsRunning() && auto_paused && (state & Qt::ApplicationActive)) {
+        } else if (!emu_thread->IsRunning() && auto_paused && state == Qt::ApplicationActive) {
             auto_paused = false;
             OnStartGame();
         }
@@ -1505,7 +1505,7 @@ void MainWindow::OnAppFocusStateChanged(Qt::ApplicationState state) {
             (state & (Qt::ApplicationHidden | Qt::ApplicationInactive))) {
             Settings::values.audio_muted = true;
             auto_muted = true;
-        } else if (auto_muted && (state & Qt::ApplicationActive)) {
+        } else if (auto_muted && state == Qt::ApplicationActive) {
             Settings::values.audio_muted = false;
             auto_muted = false;
         }

src/yuzu/main_window.h

@@ -482,13 +482,13 @@ private:
 
     MultiplayerState* multiplayer_state = nullptr;
 
-    GRenderWindow* render_window = nullptr;
-    GameList* game_list = nullptr;
-    LoadingScreen* loading_screen = nullptr;
+    GRenderWindow* render_window;
+    GameList* game_list;
+    LoadingScreen* loading_screen;
     QTimer shutdown_timer;
     OverlayDialog* shutdown_dialog{};
 
-    GameListPlaceholder* game_list_placeholder = nullptr;
+    GameListPlaceholder* game_list_placeholder;
 
     std::vector<VkDeviceInfo::Record> vk_device_records;
 
@@ -531,7 +531,7 @@ private:
     QString startup_icon_theme;
 
     // Debugger panes
-    ControllerDialog* controller_dialog = nullptr;
+    ControllerDialog* controller_dialog;
 
     QAction* actions_recent_files[max_recent_files_item];
 
@@ -543,7 +543,7 @@ private:
     QTranslator translator;
 
     // Install progress dialog
-    QProgressDialog* install_progress = nullptr;
+    QProgressDialog* install_progress;
 
     // Last game booted, used for multi-process apps
     QString last_filename_booted;

src/yuzu/multiplayer/lobby_p.h

@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2017 Citra Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -178,7 +175,7 @@ public:
 private:
     QString username;
     QString nickname;
-    u64 title_id{};
+    u64 title_id;
     QString game_name;
 };
 

tools/windows/install-vulkan-sdk.ps1

@@ -14,7 +14,7 @@ try {
     Exit 1
 }
 
-$VulkanSDKVer = "1.4.335.0"
+$VulkanSDKVer = "1.4.328.1"
 $VULKAN_SDK = "C:/VulkanSDK/$VulkanSDKVer"
 $ExeFile = "vulkansdk-windows-X64-$VulkanSDKVer.exe"
 $Uri = "https://sdk.lunarg.com/sdk/download/$VulkanSDKVer/windows/$ExeFile"

tools/windows/install-vulkan-sdk.sh

@@ -2,7 +2,7 @@
 # SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 # SPDX-License-Identifier: GPL-3.0-or-later
 
-: "${VULKAN_SDK_VER:=1.4.335.0}"
+: "${VULKAN_SDK_VER:=1.4.328.1}"
 : "${VULKAN_ROOT:=C:/VulkanSDK/$VULKAN_SDK_VER}"
 EXE_FILE="vulkansdk-windows-X64-$VULKAN_SDK_VER.exe"
 URI="https://sdk.lunarg.com/sdk/download/$VULKAN_SDK_VER/windows/$EXE_FILE"