Decrement nvmap reference count on surface flinger prealloc (#5753 )

Signal friends completion event and stub CheckBlockedUserListAvailability (#5743 )
Fix audio renderer compressor effect (#5742 )
2023-10-02 22:13:29 +00:00 · 2023-09-29 13:24:44 +02:00 · 2023-09-29 10:48:49 +00:00 · 2023-09-28 00:15:45 +02:00 · 2023-09-27 19:21:26 +02:00 · 2023-09-27 19:03:41 +02:00
248 changed files with 9279 additions and 1050 deletions
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@ -135,9 +135,13 @@ jobs:
        id: git_short_hash
        run: echo "result=$(git rev-parse --short "${{ github.sha }}")" >> $GITHUB_OUTPUT

-      - name: Publish macOS
+      - name: Publish macOS Ryujinx.Ava
        run: |
-          ./distribution/macos/create_macos_build.sh . publish_tmp publish_ava ./distribution/macos/entitlements.xml "${{ env.RYUJINX_BASE_VERSION }}" "${{ steps.git_short_hash.outputs.result }}" "${{ matrix.configuration }}" "-p:ExtraDefineConstants=DISABLE_UPDATER"
+          ./distribution/macos/create_macos_build_ava.sh . publish_tmp_ava publish_ava ./distribution/macos/entitlements.xml "${{ env.RYUJINX_BASE_VERSION }}" "${{ steps.git_short_hash.outputs.result }}" "${{ matrix.configuration }}" "-p:ExtraDefineConstants=DISABLE_UPDATER"
+
+      - name: Publish macOS Ryujinx.Headless.SDL2
+        run: |
+          ./distribution/macos/create_macos_build_headless.sh . publish_tmp_headless publish_headless ./distribution/macos/entitlements.xml "${{ env.RYUJINX_BASE_VERSION }}" "${{ steps.git_short_hash.outputs.result }}" "${{ matrix.configuration }}" "-p:ExtraDefineConstants=DISABLE_UPDATER"

      - name: Upload Ryujinx.Ava artifact
        uses: actions/upload-artifact@v3
@ -145,3 +149,10 @@ jobs:
          name: ava-ryujinx-${{ matrix.configuration }}-${{ env.RYUJINX_BASE_VERSION }}+${{ steps.git_short_hash.outputs.result }}-macos_universal
          path: "publish_ava/*.tar.gz"
        if: github.event_name == 'pull_request'
+
+      - name: Upload Ryujinx.Headless.SDL2 artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: sdl2-ryujinx-headless-${{ matrix.configuration }}-${{ env.RYUJINX_BASE_VERSION }}+${{ steps.git_short_hash.outputs.result }}-macos_universal
+          path: "publish_headless/*.tar.gz"
+        if: github.event_name == 'pull_request'
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@ -188,15 +188,19 @@ jobs:
          sed -r --in-place 's/\%\%RYUJINX_TARGET_RELEASE_CHANNEL_REPO\%\%/${{ env.RYUJINX_TARGET_RELEASE_CHANNEL_REPO }}/g;' src/Ryujinx.Common/ReleaseInformation.cs
        shell: bash

-      - name: Publish macOS
+      - name: Publish macOS Ryujinx.Ava
        run: |
-          ./distribution/macos/create_macos_build.sh . publish_tmp publish_ava ./distribution/macos/entitlements.xml "${{ steps.version_info.outputs.build_version }}" "${{ steps.version_info.outputs.git_short_hash }}" Release
+          ./distribution/macos/create_macos_build_ava.sh . publish_tmp_ava publish_ava ./distribution/macos/entitlements.xml "${{ steps.version_info.outputs.build_version }}" "${{ steps.version_info.outputs.git_short_hash }}" Release
+          
+      - name: Publish macOS Ryujinx.Headless.SDL2
+        run: |
+          ./distribution/macos/create_macos_build_headless.sh . publish_tmp_headless publish_headless ./distribution/macos/entitlements.xml "${{ steps.version_info.outputs.build_version }}" "${{ steps.version_info.outputs.git_short_hash }}" Release

      - name: Pushing new release
        uses: ncipollo/release-action@v1
        with:
          name: ${{ steps.version_info.outputs.build_version }}
-          artifacts: "publish_ava/*.tar.gz"
+          artifacts: "publish_ava/*.tar.gz, publish_headless/*.tar.gz"
          tag: ${{ steps.version_info.outputs.build_version }}
          body: "For more information about this release please check out the official [Changelog](https://github.com/Ryujinx/Ryujinx/wiki/Changelog)."
          omitBodyDuringUpdate: true
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@ -0,0 +1,147 @@
+# Contribution to Ryujinx
+
+You can contribute to Ryujinx with PRs, testing of PRs and issues. Contributing code and other implementations is greatly appreciated alongside simply filing issues for problems you encounter.
+Please read the entire document before continuing as it can potentially save everyone involved a significant amount of time.
+
+# Quick Links
+
+* [Code Style Documentation](docs/coding-guidelines/coding-style.md)
+* [Pull Request Guidelines](docs/workflow/pr-guide.md)
+
+## Reporting Issues
+
+We always welcome bug reports, feature proposals and overall feedback. Here are a few tips on how you can make reporting your issue as effective as possible.
+
+### Identify Where to Report
+
+The Ryujinx codebase is distributed across multiple repositories in the [Ryujinx organization](https://github.com/Ryujinx). Depending on the feedback you might want to file the issue on a different repo. Here are a few common repos:
+
+* [Ryujinx/Ryujinx](https://github.com/Ryujinx/Ryujinx) Ryujinx core project files.
+* [Ryujinx/Ryujinx-Games-List](https://github.com/Ryujinx/Ryujinx-Games-List) Ryujinx game compatibility list.
+* [Ryujinx/Ryujinx-Website](https://github.com/Ryujinx/Ryujinx-Website) Ryujinx website source code.
+* [Ryujinx/Ryujinx-Ldn-Website](https://github.com/Ryujinx/Ryujinx-Ldn-Website) Ryujinx LDN website source code.
+
+### Finding Existing Issues
+
+Before filing a new issue, please search our [open issues](https://github.com/Ryujinx/Ryujinx/issues) to check if it already exists.
+
+If you do find an existing issue, please include your own feedback in the discussion. Do consider upvoting (👍 reaction) the original post, as this helps us prioritize popular issues in our backlog.
+
+### Writing a Good Feature Request
+
+Please review any feature requests already opened to both check it has not already been suggested, and to familiarize yourself with the format. When ready to submit a proposal, please use the [Feature Request issue template](https://github.com/Ryujinx/Ryujinx/issues/new?assignees=&labels=&projects=&template=feature_request.yml&title=%5BFeature+Request%5D).
+
+### Writing a Good Bug Report
+
+Good bug reports make it easier for maintainers to verify and root cause the underlying problem. The better a bug report, the faster the problem will be resolved. 
+Ideally, a bug report should contain the following information:
+
+* A high-level description of the problem.
+* A _minimal reproduction_, i.e. the smallest time commitment/configuration required to reproduce the wrong behavior. This can be in the form of a small homebrew application, or by providing a save file and reproduction steps for a specific game.
+* A description of the _expected behavior_, contrasted with the _actual behavior_ observed.
+* Information on the environment: OS/distro, CPU, GPU (including driver), RAM etc.
+* A Ryujinx log file of the run instance where the issue occurred. Log files can be found in `[Executable Folder]/Logs` and are named chronologically.
+* Additional information, e.g. is it a regression from previous versions? Are there any known workarounds?
+
+When ready to submit a bug report, please use the [Bug Report issue template](https://github.com/Ryujinx/Ryujinx/issues/new?assignees=&labels=bug&projects=&template=bug_report.yml&title=%5BBug%5D).
+
+## Contributing Changes
+
+Project maintainers will merge changes that both improve the project and meet our standards for code quality.
+
+The [Pull Request Guide](docs/workflow/pr-guide.md) and [License](https://github.com/Ryujinx/Ryujinx/blob/master/LICENSE.txt) docs define additional guidance.
+
+### DOs and DON'Ts
+
+Please do:
+
+* **DO** follow our [coding style](docs/coding-guidelines/coding-style.md) (C# code-specific).
+* **DO** give priority to the current style of the project or file you're changing even if it diverges from the general guidelines.
+* **DO** keep the discussions focused. When a new or related topic comes up
+  it's often better to create new issue than to side track the discussion.
+* **DO** clearly state on an issue that you are going to take on implementing it.
+* **DO** blog and tweet (or whatever) about your contributions, frequently!
+
+Please do not:
+
+* **DON'T** make PRs for style changes.
+* **DON'T** surprise us with big pull requests. Instead, file an issue and talk with us on Discord to start
+  a discussion so we can agree on a direction before you invest a large amount
+  of time.
+* **DON'T** commit code that you didn't write. If you find code that you think is a good fit to add to Ryujinx, file an issue or talk to us on Discord to start a discussion before proceeding.
+* **DON'T** submit PRs that alter licensing related files or headers. If you believe there's a problem with them, file an issue and we'll be happy to discuss it.
+
+### Suggested Workflow
+
+We use and recommend the following workflow:
+
+1. Create or find an issue for your work.
+    - You can skip this step for trivial changes.
+    - Get agreement from the team and the community that your proposed change is a good one if it is of significant size or changes core functionality.
+    - Clearly state that you are going to take on implementing it, if that's the case. You can request that the issue be assigned to you. Note: The issue filer and the implementer don't have to be the same person.
+2. Create a personal fork of the repository on GitHub (if you don't already have one).
+3. In your fork, create a branch off of main (`git checkout -b mybranch`).
+    - Branches are useful since they isolate your changes from incoming changes from upstream. They also enable you to create multiple PRs from the same fork.
+4. Make and commit your changes to your branch.
+    - [Build Instructions](https://github.com/Ryujinx/Ryujinx#building) explains how to build and test.
+    - Commit messages should be clear statements of action and intent.
+6. Build the repository with your changes.
+    - Make sure that the builds are clean.
+    - Make sure that `dotnet format` has been run and any corrections tested and committed.
+7. Create a pull request (PR) against the Ryujinx/Ryujinx repository's **main** branch.
+    - State in the description what issue or improvement your change is addressing.
+    - Check if all the Continuous Integration checks are passing. Refer to [Actions](https://github.com/Ryujinx/Ryujinx/actions) to check for outstanding errors.
+8. Wait for feedback or approval of your changes from the [core development team](https://github.com/orgs/Ryujinx/teams/developers)
+    - Details about the pull request [review procedure](docs/workflow/ci/pr-guide.md).
+9. When the team members have signed off, and all checks are green, your PR will be merged.
+    - The next official build will automatically include your change.
+    - You can delete the branch you used for making the change.
+
+### Good First Issues
+
+The team marks the most straightforward issues as [good first issues](https://github.com/Ryujinx/Ryujinx/issues?q=is%3Aopen+is%3Aissue+label%3A%22good+first+issue%22). This set of issues is the place to start if you are interested in contributing but new to the codebase.
+
+### Commit Messages
+
+Please format commit messages as follows (based on [A Note About Git Commit Messages](http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html)):
+
+```
+Summarize change in 50 characters or less
+
+Provide more detail after the first line. Leave one blank line below the
+summary and wrap all lines at 72 characters or less.
+
+If the change fixes an issue, leave another blank line after the final
+paragraph and indicate which issue is fixed in the specific format
+below.
+
+Fix #42
+```
+
+Also do your best to factor commits appropriately, not too large with unrelated things in the same commit, and not too small with the same small change applied N times in N different commits.
+
+### PR - CI Process
+
+The [Ryujinx continuous integration](https://github.com/Ryujinx/Ryujinx/actions) (CI) system will automatically perform the required builds and run tests (including the ones you are expected to run) for PRs. Builds and test runs must be clean or have bugs properly filed against flaky/unexpected failures that are unrelated to your change.
+
+If the CI build fails for any reason, the PR actions tab should be consulted for further information on the failure. There are a few usual suspects for such a failure:
+* `dotnet format` has not been run on the PR and has outstanding stylistic issues.
+* There is an error within the PR that fails a test or errors the compiler.
+* Random failure of the workflow can occasionally result in a CI failure. In this scenario a maintainer will manually restart the job.
+
+### PR Feedback
+
+Ryujinx team and community members will provide feedback on your change. Community feedback is highly valued. You may see the absence of team feedback if the community has already provided good review feedback.
+
+Two Ryujinx team members must review and approve every PR prior to merge. They will often reply with "LGTM, see nit". That means that the PR will be merged once the feedback is resolved. "LGTM" == "looks good to me".
+
+There are lots of thoughts and [approaches](https://github.com/antlr/antlr4-cpp/blob/master/CONTRIBUTING.md#emoji) for how to efficiently discuss changes. It is best to be clear and explicit with your feedback. Please be patient with people who might not understand the finer details about your approach to feedback.
+
+#### Copying Changes from Other Projects
+
+Ryujinx uses some implementations and frameworks from other projects. The following rules must be followed for PRs that include changes from another project:
+
+- The license of the file is [permissive](https://en.wikipedia.org/wiki/Permissive_free_software_licence).
+- The license of the file is left in-tact.
+- The contribution is correctly attributed in the [3rd party notices](https://github.com/Ryujinx/Ryujinx/blob/master/distribution/legal/THIRDPARTY.md) file in the repository, as needed.
+
--- a/Directory.Packages.props
+++ b/Directory.Packages.props
@ -3,25 +3,25 @@
    <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
  </PropertyGroup>
  <ItemGroup>
-    <PackageVersion Include="Avalonia" Version="11.0.3" />
-    <PackageVersion Include="Avalonia.Controls.DataGrid" Version="11.0.3" />
-    <PackageVersion Include="Avalonia.Desktop" Version="11.0.3" />
-    <PackageVersion Include="Avalonia.Diagnostics" Version="11.0.3" />
-    <PackageVersion Include="Avalonia.Markup.Xaml.Loader" Version="11.0.3" />
-    <PackageVersion Include="Avalonia.Svg" Version="11.0.0" />
-    <PackageVersion Include="Avalonia.Svg.Skia" Version="11.0.0" />
+    <PackageVersion Include="Avalonia" Version="11.0.4" />
+    <PackageVersion Include="Avalonia.Controls.DataGrid" Version="11.0.4" />
+    <PackageVersion Include="Avalonia.Desktop" Version="11.0.4" />
+    <PackageVersion Include="Avalonia.Diagnostics" Version="11.0.4" />
+    <PackageVersion Include="Avalonia.Markup.Xaml.Loader" Version="11.0.4" />
+    <PackageVersion Include="Avalonia.Svg" Version="11.0.0.2" />
+    <PackageVersion Include="Avalonia.Svg.Skia" Version="11.0.0.2" />
    <PackageVersion Include="CommandLineParser" Version="2.9.1" />
    <PackageVersion Include="Concentus" Version="1.1.7" />
    <PackageVersion Include="DiscordRichPresence" Version="1.2.1.24" />
    <PackageVersion Include="DynamicData" Version="7.14.2" />
-    <PackageVersion Include="FluentAvaloniaUI" Version="2.0.1" />
+    <PackageVersion Include="FluentAvaloniaUI" Version="2.0.4" />
    <PackageVersion Include="GtkSharp.Dependencies" Version="1.1.1" />
    <PackageVersion Include="GtkSharp.Dependencies.osx" Version="0.0.5" />
    <PackageVersion Include="jp2masa.Avalonia.Flexbox" Version="0.3.0-beta.4" />
    <PackageVersion Include="LibHac" Version="0.18.0" />
    <PackageVersion Include="Microsoft.CodeAnalysis.Analyzers" Version="3.3.4" />
    <PackageVersion Include="Microsoft.CodeAnalysis.CSharp" Version="4.6.0" />
-    <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="17.6.3" />
+    <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
    <PackageVersion Include="Microsoft.IO.RecyclableMemoryStream" Version="2.3.2" />
    <PackageVersion Include="MsgPack.Cli" Version="1.0.1" />
    <PackageVersion Include="NUnit" Version="3.13.3" />
@ -44,9 +44,9 @@
    <PackageVersion Include="SixLabors.ImageSharp.Drawing" Version="1.0.0-beta11" />
    <PackageVersion Include="SPB" Version="0.0.4-build28" />
    <PackageVersion Include="System.Drawing.Common" Version="7.0.0" />
-    <PackageVersion Include="System.IdentityModel.Tokens.Jwt" Version="6.31.0" />
+    <PackageVersion Include="System.IdentityModel.Tokens.Jwt" Version="7.0.0" />
    <PackageVersion Include="System.IO.Hashing" Version="7.0.0" />
    <PackageVersion Include="System.Management" Version="7.0.2" />
    <PackageVersion Include="UnicornEngine.Unicorn" Version="2.0.2-rc1-fb78016" />
  </ItemGroup>
-</Project>
+</Project>
--- a/distribution/macos/create_macos_build_ava.sh
+++ b/distribution/macos/create_macos_build_ava.sh
--- a/distribution/macos/create_macos_build_headless.sh
+++ b/distribution/macos/create_macos_build_headless.sh
@ -0,0 +1,111 @@
+#!/bin/bash
+
+set -e
+
+if [ "$#" -lt 7 ]; then
+    echo "usage <BASE_DIR> <TEMP_DIRECTORY> <OUTPUT_DIRECTORY> <ENTITLEMENTS_FILE_PATH> <VERSION> <SOURCE_REVISION_ID> <CONFIGURATION> <EXTRA_ARGS>"
+    exit 1
+fi
+
+mkdir -p "$1"
+mkdir -p "$2"
+mkdir -p "$3"
+
+BASE_DIR=$(readlink -f "$1")
+TEMP_DIRECTORY=$(readlink -f "$2")
+OUTPUT_DIRECTORY=$(readlink -f "$3")
+ENTITLEMENTS_FILE_PATH=$(readlink -f "$4")
+VERSION=$5
+SOURCE_REVISION_ID=$6
+CONFIGURATION=$7
+EXTRA_ARGS=$8
+
+if [ "$VERSION" == "1.1.0" ];
+then
+  RELEASE_TAR_FILE_NAME=sdl2-ryujinx-headless-$CONFIGURATION-$VERSION+$SOURCE_REVISION_ID-macos_universal.tar
+else
+  RELEASE_TAR_FILE_NAME=sdl2-ryujinx-headless-$VERSION-macos_universal.tar
+fi
+
+ARM64_OUTPUT="$TEMP_DIRECTORY/publish_arm64"
+X64_OUTPUT="$TEMP_DIRECTORY/publish_x64"
+UNIVERSAL_OUTPUT="$OUTPUT_DIRECTORY/publish"
+EXECUTABLE_SUB_PATH=Ryujinx.Headless.SDL2
+
+rm -rf "$TEMP_DIRECTORY"
+mkdir -p "$TEMP_DIRECTORY"
+
+DOTNET_COMMON_ARGS=(-p:DebugType=embedded -p:Version="$VERSION" -p:SourceRevisionId="$SOURCE_REVISION_ID" --self-contained true $EXTRA_ARGS)
+
+dotnet restore
+dotnet build -c "$CONFIGURATION" src/Ryujinx.Headless.SDL2
+dotnet publish -c "$CONFIGURATION" -r osx-arm64 -o "$TEMP_DIRECTORY/publish_arm64" "${DOTNET_COMMON_ARGS[@]}" src/Ryujinx.Headless.SDL2
+dotnet publish -c "$CONFIGURATION" -r osx-x64 -o "$TEMP_DIRECTORY/publish_x64" "${DOTNET_COMMON_ARGS[@]}" src/Ryujinx.Headless.SDL2
+
+# Get rid of the support library for ARMeilleure for x64 (that's only for arm64)
+rm -rf "$TEMP_DIRECTORY/publish_x64/libarmeilleure-jitsupport.dylib"
+
+# Get rid of libsoundio from arm64 builds as we don't have a arm64 variant
+# TODO: remove this once done
+rm -rf "$TEMP_DIRECTORY/publish_arm64/libsoundio.dylib"
+
+rm -rf "$OUTPUT_DIRECTORY"
+mkdir -p "$OUTPUT_DIRECTORY"
+
+# Let's copy one of the two different outputs and remove the executable
+cp -R "$ARM64_OUTPUT/" "$UNIVERSAL_OUTPUT"
+rm "$UNIVERSAL_OUTPUT/$EXECUTABLE_SUB_PATH"
+
+# Make it libraries universal
+python3 "$BASE_DIR/distribution/macos/construct_universal_dylib.py" "$ARM64_OUTPUT" "$X64_OUTPUT" "$UNIVERSAL_OUTPUT" "**/*.dylib"
+
+if ! [ -x "$(command -v lipo)" ];
+then
+    if ! [ -x "$(command -v llvm-lipo-14)" ];
+    then
+        LIPO=llvm-lipo
+    else
+        LIPO=llvm-lipo-14
+    fi
+else
+    LIPO=lipo
+fi
+
+# Make the executable universal
+$LIPO "$ARM64_OUTPUT/$EXECUTABLE_SUB_PATH" "$X64_OUTPUT/$EXECUTABLE_SUB_PATH" -output "$UNIVERSAL_OUTPUT/$EXECUTABLE_SUB_PATH" -create
+
+# Now sign it
+if ! [ -x "$(command -v codesign)" ];
+then
+    if ! [ -x "$(command -v rcodesign)" ];
+    then
+        echo "Cannot find rcodesign on your system, please install rcodesign."
+        exit 1
+    fi
+
+    # NOTE: Currently require https://github.com/indygreg/apple-platform-rs/pull/44 to work on other OSes.
+    # cargo install --git "https://github.com/marysaka/apple-platform-rs" --branch "fix/adhoc-app-bundle" apple-codesign --bin "rcodesign"
+    echo "Using rcodesign for ad-hoc signing"
+    for FILE in "$UNIVERSAL_OUTPUT"/*; do
+        if [[ $(file "$FILE") == *"Mach-O"* ]]; then
+            rcodesign sign --entitlements-xml-path "$ENTITLEMENTS_FILE_PATH" "$FILE"
+        fi
+    done  
+else
+    echo "Using codesign for ad-hoc signing"
+    for FILE in "$UNIVERSAL_OUTPUT"/*; do
+        if [[ $(file "$FILE") == *"Mach-O"* ]]; then
+            codesign --entitlements "$ENTITLEMENTS_FILE_PATH" -f --deep -s - "$FILE"
+        fi
+    done    
+fi
+
+echo "Creating archive"
+pushd "$OUTPUT_DIRECTORY"
+tar --exclude "publish/Ryujinx.Headless.SDL2" -cvf "$RELEASE_TAR_FILE_NAME" publish 1> /dev/null
+python3 "$BASE_DIR/distribution/misc/add_tar_exec.py" "$RELEASE_TAR_FILE_NAME" "publish/Ryujinx.Headless.SDL2" "publish/Ryujinx.Headless.SDL2"
+gzip -9 < "$RELEASE_TAR_FILE_NAME" > "$RELEASE_TAR_FILE_NAME.gz"
+rm "$RELEASE_TAR_FILE_NAME"
+popd
+
+echo "Done"
--- a/docs/README.md
+++ b/docs/README.md
@ -0,0 +1,40 @@
+# Documents Index
+
+This repo includes several documents that explain both high-level and low-level concepts about Ryujinx and its functions. These are very useful for contributors, to get context that can be very difficult to acquire from just reading code.
+
+Intro to Ryujinx
+==================
+
+Ryujinx is an open-source Nintendo Switch emulator, created by gdkchan, written in C#. 
+* The CPU emulator, ARMeilleure, emulates an ARMv8 CPU and currently has support for most 64-bit ARMv8 and some of the ARMv7 (and older) instructions.
+* The GPU emulator emulates the Switch's Maxwell GPU using either the OpenGL (version 4.5 minimum), Vulkan, or Metal (via MoltenVK) APIs through a custom build of OpenTK or Silk.NET respectively.
+* Audio output is entirely supported via C# wrappers for SDL2, with OpenAL & libsoundio as fallbacks.
+
+Getting Started
+===============
+
+- [Installing the .NET SDK](https://dotnet.microsoft.com/download)
+- [Official .NET Docs](https://docs.microsoft.com/dotnet/core/)
+
+Contributing (Building, testing, benchmarking, profiling, etc.)
+===============
+
+If you want to contribute a code change to this repo, start here.
+
+- [Contributor Guide](../CONTRIBUTING.md)
+
+Coding Guidelines
+=================
+
+- [C# coding style](coding-guidelines/coding-style.md)
+- [Service Implementation Guidelines - WIP](https://gist.github.com/gdkchan/84ba88cd50efbe58d1babfaa7cd7c455)
+
+Project Docs
+=================
+
+To be added. Many project files will contain basic XML docs for key functions and classes in the meantime.
+
+Other Information
+=================
+
+- N/A
--- a/docs/coding-guidelines/coding-style.md
+++ b/docs/coding-guidelines/coding-style.md
@ -0,0 +1,116 @@
+# C# Coding Style
+
+The general rule we follow is "use Visual Studio defaults". 
+Using an IDE that supports the `.editorconfig` standard will make this much simpler.
+
+1. We use [Allman style](http://en.wikipedia.org/wiki/Indent_style#Allman_style) braces, where each brace begins on a new line. A single line statement block can go without braces but the block must be properly indented on its own line and must not be nested in other statement blocks that use braces (See rule 18 for more details). One exception is that a `using` statement is permitted to be nested within another `using` statement by starting on the following line at the same indentation level, even if the nested `using` contains a controlled block.
+2. We use four spaces of indentation (no tabs).
+3. We use `_camelCase` for internal and private fields and use `readonly` where possible. Prefix internal and private instance fields with `_`, static fields with `s_` and thread static fields with `t_`. When used on static fields, `readonly` should come after `static` (e.g. `static readonly` not `readonly static`).  Public fields should be used sparingly and should use PascalCasing with no prefix when used.
+4. We avoid `this.` unless absolutely necessary.
+5. We always specify the visibility, even if it's the default (e.g.
+   `private string _foo` not `string _foo`). Visibility should be the first modifier (e.g.
+   `public abstract` not `abstract public`).
+6. Namespace imports should be specified at the top of the file, *outside* of `namespace` declarations.
+7. Avoid more than one empty line at any time. For example, do not have two
+   blank lines between members of a type.
+8. Avoid spurious free spaces.
+   For example avoid `if (someVar == 0)...`, where the dots mark the spurious free spaces.
+   Consider enabling "View White Space (Ctrl+R, Ctrl+W)" or "Edit -> Advanced -> View White Space" if using Visual Studio to aid detection.
+9. If a file happens to differ in style from these guidelines (e.g. private members are named `m_member`
+   rather than `_member`), the existing style in that file takes precedence.
+10. We only use `var` when the type is explicitly named on the right-hand side, typically due to either `new` or an explicit cast, e.g. `var stream = new FileStream(...)` not `var stream = OpenStandardInput()`.
+    - Similarly, target-typed `new()` can only be used when the type is explicitly named on the left-hand side, in a variable definition statement or a field definition statement. e.g. `FileStream stream = new(...);`, but not `stream = new(...);` (where the type was specified on a previous line).
+11. We use language keywords instead of BCL types (e.g. `int, string, float` instead of `Int32, String, Single`, etc) for both type references as well as method calls (e.g. `int.Parse` instead of `Int32.Parse`). See issue [#13976](https://github.com/dotnet/runtime/issues/13976) for examples.
+12. We use PascalCasing to name all our constant local variables and fields. The only exception is for interop code where the constant value should exactly match the name and value of the code you are calling via interop.
+13. We use PascalCasing for all method names, including local functions.
+14. We use ```nameof(...)``` instead of ```"..."``` whenever possible and relevant.
+15. Fields should be specified at the top within type declarations.
+16. When including non-ASCII characters in the source code use Unicode escape sequences (\uXXXX) instead of literal characters. Literal non-ASCII characters occasionally get garbled by a tool or editor.
+17. When using labels (for goto), indent the label one less than the current indentation.
+18. When using a single-statement if, we follow these conventions:
+    - Never use single-line form (for example: `if (source == null) throw new ArgumentNullException("source");`)
+    - Using braces is always accepted, and required if any block of an `if`/`else if`/.../`else` compound statement uses braces or if a single statement body spans multiple lines.
+    - Braces may be omitted only if the body of *every* block associated with an `if`/`else if`/.../`else` compound statement is placed on a single line.
+19. Make all internal and private types static or sealed unless derivation from them is required.  As with any implementation detail, they can be changed if/when derivation is required in the future.
+20. XML docs should be used when writing interfaces or when a class/method is deemed sufficient in scope or complexity.
+21. So-called [Magic Numbers](https://en.wikipedia.org/wiki/Magic_number_(programming)) should be defined as named constants before use (for example `for (int i = 56; i < 68; i++)` could read `for (int i = _currentAge; i < _retireAge; i++)`). 
+    This may be ignored for trivial or syntactically common statements.
+
+An [EditorConfig](https://editorconfig.org "EditorConfig homepage") file (`.editorconfig`) has been provided at the root of the runtime repository, enabling C# auto-formatting conforming to the above guidelines.
+
+### Example File:
+
+``ShaderCache.cs:``
+
+```C#
+using Ryujinx.Common.Configuration;
+using Ryujinx.Common.Logging;
+using Ryujinx.Graphics.GAL;
+using Ryujinx.Graphics.Gpu.Engine.Threed;
+using Ryujinx.Graphics.Gpu.Engine.Types;
+using Ryujinx.Graphics.Gpu.Image;
+using Ryujinx.Graphics.Gpu.Memory;
+using Ryujinx.Graphics.Gpu.Shader.DiskCache;
+using Ryujinx.Graphics.Shader;
+using Ryujinx.Graphics.Shader.Translation;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading;
+
+namespace Ryujinx.Graphics.Gpu.Shader
+{
+    /// <summary>
+    /// Memory cache of shader code.
+    /// </summary>
+    class ShaderCache : IDisposable
+    {
+        /// <summary>
+        /// Default flags used on the shader translation process.
+        /// </summary>
+        public const TranslationFlags DefaultFlags = TranslationFlags.DebugMode;
+
+        private readonly struct TranslatedShader
+        {
+            public readonly CachedShaderStage Shader;
+            public readonly ShaderProgram Program;
+
+            public TranslatedShader(CachedShaderStage shader, ShaderProgram program)
+            {
+                Shader = shader;
+                Program = program;
+            }
+        }
+        ...
+
+        /// <summary>
+        /// Processes the queue of shaders that must save their binaries to the disk cache.
+        /// </summary>
+        public void ProcessShaderCacheQueue()
+        {
+            // Check to see if the binaries for previously compiled shaders are ready, and save them out.
+
+            while (_programsToSaveQueue.TryPeek(out ProgramToSave programToSave))
+            {
+                ProgramLinkStatus result = programToSave.HostProgram.CheckProgramLink(false);
+
+                if (result != ProgramLinkStatus.Incomplete)
+                {
+                    if (result == ProgramLinkStatus.Success)
+                    {
+                        _cacheWriter.AddShader(programToSave.CachedProgram, programToSave.BinaryCode ?? programToSave.HostProgram.GetBinary());
+                    }
+
+                    _programsToSaveQueue.Dequeue();
+                }
+                else
+                {
+                    break;
+                }
+            }
+        }
+    }
+}
+```
+
+For other languages, our current best guidance is consistency. When editing files, keep new code and changes consistent with the style in the files. For new files, it should conform to the style for that component. If there is a completely new component, anything that is reasonably broadly accepted is fine.
--- a/docs/workflow/pr-guide.md
+++ b/docs/workflow/pr-guide.md
@ -0,0 +1,56 @@
+# Pull Request Guide
+
+## Contributing Rules
+
+All contributions to Ryujinx/Ryujinx repository are made via pull requests (PRs) rather than through direct commits. The pull requests are reviewed and merged by the maintainers after a review and at least two approvals from the core development team.
+
+To merge pull requests, you must have write permissions in the repository.
+
+## Quick Code Review Rules
+
+* Do not mix unrelated changes in one pull request. For example, a code style change should never be mixed with a bug fix.
+* All changes should follow the existing code style. You can read more about our code style at [docs/coding-guidelines](../coding-guidelines/coding-style.md).
+* Adding external dependencies is to be avoided unless not doing so would introduce _significant_ complexity. Any dependency addition should be justified and discussed before merge.
+* Use Draft pull requests for changes you are still working on but want early CI loop feedback. When you think your changes are ready for review, [change the status](https://help.github.com/en/github/collaborating-with-issues-and-pull-requests/changing-the-stage-of-a-pull-request) of your pull request.
+* Rebase your changes when required or directly requested. Changes should always be commited on top of the upstream branch, not the other way around.
+* If you are asked to make changes during the review process do them as a new commit.
+* Only resolve GitHub conversations with reviewers once they have been addressed with a commit, or via a mutual agreement.
+
+## Pull Request Ownership
+
+Every pull request will have automatically have labels and reviewers assigned. The label not only indicates the code segment which the change touches but also the area reviewers to be assigned.
+
+If during the code review process a merge conflict occurs, the PR author is responsible for its resolution. Help will be provided if necessary although GitHub makes this easier by allowing simple conflict resolution using the [conflict-editor](https://help.github.com/en/github/collaborating-with-issues-and-pull-requests/resolving-a-merge-conflict-on-github).
+
+## Pull Request Builds
+
+When submitting a PR to the `Ryujinx/Ryujinx` repository, various builds will run validating many areas to ensure we keep developer productivity and product quality high. These various workflows can be tracked in the [Actions](https://github.com/Ryujinx/Ryujinx/actions) tab of the repository. If the job continues to completion, the build artifacts will be uploaded and posted as a comment in the PR discussion.
+
+## Review Turnaround Times
+
+Ryujinx is a project that is maintained by volunteers on a completely free-time basis. As such we cannot guarantee any particular timeframe for pull request review and approval. Weeks to months are common for larger (>500 line) PRs but there are some additional best practises to avoid review purgatory.
+
+* Make the reviewers life easier wherever possible. Make use of descriptive commit names, code comments and XML docs where applicable.
+* If there is disagreement on feedback then always lean on the side of the development team and community over any personal opinion.
+* We're human. We miss things. We forget things. If there has been radio silence on your changes for a substantial period of time then do not hesitate to reach out directly either with something simple like "bump" on GitHub or a directly on Discord.
+
+To re-iterate, make the review as easy for us as possible, respond promptly and be comfortable to interact directly with us for anything else.
+
+## Merging Pull Requests
+
+Anyone with write access can merge a pull request manually when the following conditions have been met:
+
+* The PR has been approved by two reviewers and any other objections are addressed.
+    * You can request follow up reviews from the original reviewers if they requested changes.
+* The PR successfully builds and passes all tests in the Continuous Integration (CI) system. In case of failures, refer to the [Actions](https://github.com/Ryujinx/Ryujinx/actions) tab of your PR.
+
+Typically, PRs are merged as one commit (squash merges). It creates a simpler history than a Merge Commit. "Special circumstances" are rare, and typically mean that there are a series of cleanly separated changes that will be too hard to understand if squashed together, or for some reason we want to preserve the ability to dissect them.
+
+## Blocking Pull Request Merging
+
+If for whatever reason you would like to move your pull request back to an in-progress status to avoid merging it in the current form, you can turn the PR into a draft PR by selecting the option under the reviewers section. Alternatively, you can do that by adding [WIP] prefix to the pull request title.
+
+## Old Pull Request Policy
+
+From time to time we will review older PRs and check them for relevance. If we find the PR is inactive or no longer applies, we will close it. As the PR owner, you can simply reopen it if you feel your closed PR needs our attention.
+
--- a/src/ARMeilleure/Translation/IntervalTree.cs
+++ b/src/ARMeilleure/Translation/IntervalTree.cs
@ -189,7 +189,7 @@ namespace ARMeilleure.Translation
            {
                if (start.CompareTo(node.End) < 0)
                {
-                    if (overlaps.Length >= overlapCount)
+                    if (overlaps.Length <= overlapCount)
                    {
                        Array.Resize(ref overlaps, overlapCount + ArrayGrowthSize);
                    }
--- a/src/Ryujinx.Audio/Renderer/Dsp/Command/AuxiliaryBufferCommand.cs
+++ b/src/Ryujinx.Audio/Renderer/Dsp/Command/AuxiliaryBufferCommand.cs
@ -31,9 +31,18 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command

        public bool IsEffectEnabled { get; }

-        public AuxiliaryBufferCommand(uint bufferOffset, byte inputBufferOffset, byte outputBufferOffset,
-                          ref AuxiliaryBufferAddresses sendBufferInfo, bool isEnabled, uint countMax,
-                          CpuAddress outputBuffer, CpuAddress inputBuffer, uint updateCount, uint writeOffset, int nodeId)
+        public AuxiliaryBufferCommand(
+            uint bufferOffset,
+            byte inputBufferOffset,
+            byte outputBufferOffset,
+            ref AuxiliaryBufferAddresses sendBufferInfo,
+            bool isEnabled,
+            uint countMax,
+            CpuAddress outputBuffer,
+            CpuAddress inputBuffer,
+            uint updateCount,
+            uint writeOffset,
+            int nodeId)
        {
            Enabled = true;
            NodeId = nodeId;
--- a/src/Ryujinx.Audio/Renderer/Dsp/Command/BiquadFilterCommand.cs
+++ b/src/Ryujinx.Audio/Renderer/Dsp/Command/BiquadFilterCommand.cs
@ -21,7 +21,14 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command

        private BiquadFilterParameter _parameter;

-        public BiquadFilterCommand(int baseIndex, ref BiquadFilterParameter filter, Memory<BiquadFilterState> biquadFilterStateMemory, int inputBufferOffset, int outputBufferOffset, bool needInitialization, int nodeId)
+        public BiquadFilterCommand(
+            int baseIndex,
+            ref BiquadFilterParameter filter,
+            Memory<BiquadFilterState> biquadFilterStateMemory,
+            int inputBufferOffset,
+            int outputBufferOffset,
+            bool needInitialization,
+            int nodeId)
        {
            _parameter = filter;
            BiquadFilterState = biquadFilterStateMemory;
--- a/src/Ryujinx.Audio/Renderer/Dsp/Command/CommandList.cs
+++ b/src/Ryujinx.Audio/Renderer/Dsp/Command/CommandList.cs
@ -77,7 +77,7 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public unsafe void ClearBuffer(int index)
        {
-            Unsafe.InitBlock((void*)GetBufferPointer(index), 0, SampleCount);
+            Unsafe.InitBlock((void*)GetBufferPointer(index), 0, SampleCount * sizeof(float));
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
@ -89,7 +89,7 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public unsafe void CopyBuffer(int outputBufferIndex, int inputBufferIndex)
        {
-            Unsafe.CopyBlock((void*)GetBufferPointer(outputBufferIndex), (void*)GetBufferPointer(inputBufferIndex), SampleCount);
+            Unsafe.CopyBlock((void*)GetBufferPointer(outputBufferIndex), (void*)GetBufferPointer(inputBufferIndex), SampleCount * sizeof(float));
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
--- a/src/Ryujinx.Audio/Renderer/Dsp/Command/CompressorCommand.cs
+++ b/src/Ryujinx.Audio/Renderer/Dsp/Command/CompressorCommand.cs
@ -94,18 +94,18 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command

                    float newMean = inputMovingAverage.Update(FloatingPointHelper.MeanSquare(channelInput), _parameter.InputGain);
                    float y = FloatingPointHelper.Log10(newMean) * 10.0f;
-                    float z = 0.0f;
+                    float z = 1.0f;

-                    bool unknown10OutOfRange = false;
+                    bool unknown10OutOfRange = y >= state.Unknown10;

                    if (newMean < 1.0e-10f)
                    {
-                        z = 1.0f;
+                        y = -100.0f;

-                        unknown10OutOfRange = state.Unknown10 < -100.0f;
+                        unknown10OutOfRange = state.Unknown10 <= -100.0f;
                    }

-                    if (y >= state.Unknown10 || unknown10OutOfRange)
+                    if (unknown10OutOfRange)
                    {
                        float tmpGain;

@ -118,7 +118,7 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
                            tmpGain = (y - state.Unknown10) * ((y - state.Unknown10) * -state.CompressorGainReduction);
                        }

-                        z = FloatingPointHelper.DecibelToLinearExtended(tmpGain);
+                        z = FloatingPointHelper.DecibelToLinear(tmpGain);
                    }

                    float unknown4New = z;
--- a/src/Ryujinx.Audio/Renderer/Dsp/Command/DelayCommand.cs
+++ b/src/Ryujinx.Audio/Renderer/Dsp/Command/DelayCommand.cs
@ -88,7 +88,7 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
            float outGain = FixedPointHelper.ToFloat(Parameter.OutGain, FixedPointPrecision);

            Matrix2x2 delayFeedback = new(delayFeedbackBaseGain, delayFeedbackCrossGain,
-                                                    delayFeedbackCrossGain, delayFeedbackBaseGain);
+                                          delayFeedbackCrossGain, delayFeedbackBaseGain);

            for (int i = 0; i < sampleCount; i++)
            {
@ -125,9 +125,9 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
            float outGain = FixedPointHelper.ToFloat(Parameter.OutGain, FixedPointPrecision);

            Matrix4x4 delayFeedback = new(delayFeedbackBaseGain, delayFeedbackCrossGain, delayFeedbackCrossGain, 0.0f,
-                                                    delayFeedbackCrossGain, delayFeedbackBaseGain, 0.0f, delayFeedbackCrossGain,
-                                                    delayFeedbackCrossGain, 0.0f, delayFeedbackBaseGain, delayFeedbackCrossGain,
-                                                    0.0f, delayFeedbackCrossGain, delayFeedbackCrossGain, delayFeedbackBaseGain);
+                                          delayFeedbackCrossGain, delayFeedbackBaseGain, 0.0f, delayFeedbackCrossGain,
+                                          delayFeedbackCrossGain, 0.0f, delayFeedbackBaseGain, delayFeedbackCrossGain,
+                                          0.0f, delayFeedbackCrossGain, delayFeedbackCrossGain, delayFeedbackBaseGain);


            for (int i = 0; i < sampleCount; i++)
@ -172,11 +172,11 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
            float outGain = FixedPointHelper.ToFloat(Parameter.OutGain, FixedPointPrecision);

            Matrix6x6 delayFeedback = new(delayFeedbackBaseGain, 0.0f, delayFeedbackCrossGain, 0.0f, delayFeedbackCrossGain, 0.0f,
-                                                    0.0f, delayFeedbackBaseGain, delayFeedbackCrossGain, 0.0f, 0.0f, delayFeedbackCrossGain,
-                                                    delayFeedbackCrossGain, delayFeedbackCrossGain, delayFeedbackBaseGain, 0.0f, 0.0f, 0.0f,
-                                                    0.0f, 0.0f, 0.0f, feedbackGain, 0.0f, 0.0f,
-                                                    delayFeedbackCrossGain, 0.0f, 0.0f, 0.0f, delayFeedbackBaseGain, delayFeedbackCrossGain,
-                                                    0.0f, delayFeedbackCrossGain, 0.0f, 0.0f, delayFeedbackCrossGain, delayFeedbackBaseGain);
+                                          0.0f, delayFeedbackBaseGain, delayFeedbackCrossGain, 0.0f, 0.0f, delayFeedbackCrossGain,
+                                          delayFeedbackCrossGain, delayFeedbackCrossGain, delayFeedbackBaseGain, 0.0f, 0.0f, 0.0f,
+                                          0.0f, 0.0f, 0.0f, feedbackGain, 0.0f, 0.0f,
+                                          delayFeedbackCrossGain, 0.0f, 0.0f, 0.0f, delayFeedbackBaseGain, delayFeedbackCrossGain,
+                                          0.0f, delayFeedbackCrossGain, 0.0f, 0.0f, delayFeedbackCrossGain, delayFeedbackBaseGain);

            for (int i = 0; i < sampleCount; i++)
            {
--- a/src/Ryujinx.Audio/Renderer/Dsp/Command/LimiterCommandVersion2.cs
+++ b/src/Ryujinx.Audio/Renderer/Dsp/Command/LimiterCommandVersion2.cs
@ -28,7 +28,14 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command

        private LimiterParameter _parameter;

-        public LimiterCommandVersion2(uint bufferOffset, LimiterParameter parameter, Memory<LimiterState> state, Memory<EffectResultState> resultState, bool isEnabled, ulong workBuffer, int nodeId)
+        public LimiterCommandVersion2(
+            uint bufferOffset,
+            LimiterParameter parameter,
+            Memory<LimiterState> state,
+            Memory<EffectResultState> resultState,
+            bool isEnabled,
+            ulong workBuffer,
+            int nodeId)
        {
            Enabled = true;
            NodeId = nodeId;
--- a/src/Ryujinx.Audio/Renderer/Dsp/Command/ReverbCommand.cs
+++ b/src/Ryujinx.Audio/Renderer/Dsp/Command/ReverbCommand.cs
@ -79,53 +79,57 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private void ProcessReverbMono(ref ReverbState state, ReadOnlySpan<IntPtr> outputBuffers, ReadOnlySpan<IntPtr> inputBuffers, uint sampleCount)
        {
-            ProcessReverbGeneric(ref state,
-                     outputBuffers,
-                     inputBuffers,
-                     sampleCount,
-                     _outputEarlyIndicesTableMono,
-                     _targetEarlyDelayLineIndicesTableMono,
-                     _targetOutputFeedbackIndicesTableMono,
-                     _outputIndicesTableMono);
+            ProcessReverbGeneric(
+                ref state,
+                outputBuffers,
+                inputBuffers,
+                sampleCount,
+                _outputEarlyIndicesTableMono,
+                _targetEarlyDelayLineIndicesTableMono,
+                _targetOutputFeedbackIndicesTableMono,
+                _outputIndicesTableMono);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private void ProcessReverbStereo(ref ReverbState state, ReadOnlySpan<IntPtr> outputBuffers, ReadOnlySpan<IntPtr> inputBuffers, uint sampleCount)
        {
-            ProcessReverbGeneric(ref state,
-                     outputBuffers,
-                     inputBuffers,
-                     sampleCount,
-                     _outputEarlyIndicesTableStereo,
-                     _targetEarlyDelayLineIndicesTableStereo,
-                     _targetOutputFeedbackIndicesTableStereo,
-                     _outputIndicesTableStereo);
+            ProcessReverbGeneric(
+                ref state,
+                outputBuffers,
+                inputBuffers,
+                sampleCount,
+                _outputEarlyIndicesTableStereo,
+                _targetEarlyDelayLineIndicesTableStereo,
+                _targetOutputFeedbackIndicesTableStereo,
+                _outputIndicesTableStereo);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private void ProcessReverbQuadraphonic(ref ReverbState state, ReadOnlySpan<IntPtr> outputBuffers, ReadOnlySpan<IntPtr> inputBuffers, uint sampleCount)
        {
-            ProcessReverbGeneric(ref state,
-                     outputBuffers,
-                     inputBuffers,
-                     sampleCount,
-                     _outputEarlyIndicesTableQuadraphonic,
-                     _targetEarlyDelayLineIndicesTableQuadraphonic,
-                     _targetOutputFeedbackIndicesTableQuadraphonic,
-                     _outputIndicesTableQuadraphonic);
+            ProcessReverbGeneric(
+                ref state,
+                outputBuffers,
+                inputBuffers,
+                sampleCount,
+                _outputEarlyIndicesTableQuadraphonic,
+                _targetEarlyDelayLineIndicesTableQuadraphonic,
+                _targetOutputFeedbackIndicesTableQuadraphonic,
+                _outputIndicesTableQuadraphonic);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private void ProcessReverbSurround(ref ReverbState state, ReadOnlySpan<IntPtr> outputBuffers, ReadOnlySpan<IntPtr> inputBuffers, uint sampleCount)
        {
-            ProcessReverbGeneric(ref state,
-                     outputBuffers,
-                     inputBuffers,
-                     sampleCount,
-                     _outputEarlyIndicesTableSurround,
-                     _targetEarlyDelayLineIndicesTableSurround,
-                     _targetOutputFeedbackIndicesTableSurround,
-                     _outputIndicesTableSurround);
+            ProcessReverbGeneric(
+                ref state,
+                outputBuffers,
+                inputBuffers,
+                sampleCount,
+                _outputEarlyIndicesTableSurround,
+                _targetEarlyDelayLineIndicesTableSurround,
+                _targetOutputFeedbackIndicesTableSurround,
+                _outputIndicesTableSurround);
        }

        private unsafe void ProcessReverbGeneric(ref ReverbState state, ReadOnlySpan<IntPtr> outputBuffers, ReadOnlySpan<IntPtr> inputBuffers, uint sampleCount, ReadOnlySpan<int> outputEarlyIndicesTable, ReadOnlySpan<int> targetEarlyDelayLineIndicesTable, ReadOnlySpan<int> targetOutputFeedbackIndicesTable, ReadOnlySpan<int> outputIndicesTable)
--- a/src/Ryujinx.Audio/Renderer/Dsp/FloatingPointHelper.cs
+++ b/src/Ryujinx.Audio/Renderer/Dsp/FloatingPointHelper.cs
@ -52,7 +52,7 @@ namespace Ryujinx.Audio.Renderer.Dsp
        {
            // NOTE: Nintendo uses an approximation of log10, we don't.
            // As such, we support the same ranges as Nintendo to avoid unexpected behaviours.
-            return MathF.Pow(10, MathF.Max(x, 1.0e-10f));
+            return MathF.Log10(MathF.Max(x, 1.0e-10f));
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
@ -62,7 +62,8 @@ namespace Ryujinx.Audio.Renderer.Dsp

            foreach (float input in inputs)
            {
-                res += (input * input);
+                float normInput = input * (1f / 32768f);
+                res += normInput * normInput;
            }

            res /= inputs.Length;
@ -81,19 +82,6 @@ namespace Ryujinx.Audio.Renderer.Dsp
            return MathF.Pow(10.0f, db / 20.0f);
        }

-        /// <summary>
-        /// Map decibel to linear in [0, 2] range.
-        /// </summary>
-        /// <param name="db">The decibel value to convert</param>
-        /// <returns>Converted linear value in [0, 2] range</returns>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static float DecibelToLinearExtended(float db)
-        {
-            float tmp = MathF.Log2(DecibelToLinear(db));
-
-            return MathF.Truncate(tmp) + MathF.Pow(2.0f, tmp - MathF.Truncate(tmp));
-        }
-
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static float DegreesToRadians(float degrees)
        {
--- a/src/Ryujinx.Audio/Renderer/Dsp/State/CompressorState.cs
+++ b/src/Ryujinx.Audio/Renderer/Dsp/State/CompressorState.cs
@ -3,7 +3,7 @@ using Ryujinx.Audio.Renderer.Parameter.Effect;

 namespace Ryujinx.Audio.Renderer.Dsp.State
 {
-    public class CompressorState
+    public struct CompressorState
    {
        public ExponentialMovingAverage InputMovingAverage;
        public float Unknown4;
@ -45,7 +45,7 @@ namespace Ryujinx.Audio.Renderer.Dsp.State
            CompressorGainReduction = (1.0f - ratio) / Constants.ChannelCountMax;
            Unknown10 = threshold - 1.5f;
            Unknown14 = threshold + 1.5f;
-            OutputGain = FloatingPointHelper.DecibelToLinearExtended(parameter.OutputGain + makeupGain);
+            OutputGain = FloatingPointHelper.DecibelToLinear(parameter.OutputGain + makeupGain);
        }
    }
 }
--- a/src/Ryujinx.Audio/Renderer/Dsp/State/DelayState.cs
+++ b/src/Ryujinx.Audio/Renderer/Dsp/State/DelayState.cs
@ -4,7 +4,7 @@ using System.Runtime.CompilerServices;

 namespace Ryujinx.Audio.Renderer.Dsp.State
 {
-    public class DelayState
+    public struct DelayState
    {
        public DelayLine[] DelayLines { get; }
        public float[] LowPassZ { get; set; }
@ -53,7 +53,7 @@ namespace Ryujinx.Audio.Renderer.Dsp.State
            LowPassBaseGain = 1.0f - LowPassFeedbackGain;
        }

-        public void UpdateLowPassFilter(ref float tempRawRef, uint channelCount)
+        public readonly void UpdateLowPassFilter(ref float tempRawRef, uint channelCount)
        {
            for (int i = 0; i < channelCount; i++)
            {
--- a/src/Ryujinx.Audio/Renderer/Dsp/State/LimiterState.cs
+++ b/src/Ryujinx.Audio/Renderer/Dsp/State/LimiterState.cs
@ -4,7 +4,7 @@ using System;

 namespace Ryujinx.Audio.Renderer.Dsp.State
 {
-    public class LimiterState
+    public struct LimiterState
    {
        public ExponentialMovingAverage[] DetectorAverage;
        public ExponentialMovingAverage[] CompressionGainAverage;
--- a/src/Ryujinx.Audio/Renderer/Dsp/State/Reverb3dState.cs
+++ b/src/Ryujinx.Audio/Renderer/Dsp/State/Reverb3dState.cs
@ -4,7 +4,7 @@ using System;

 namespace Ryujinx.Audio.Renderer.Dsp.State
 {
-    public class Reverb3dState
+    public struct Reverb3dState
    {
        private readonly float[] _fdnDelayMinTimes = new float[4] { 5.0f, 6.0f, 13.0f, 14.0f };
        private readonly float[] _fdnDelayMaxTimes = new float[4] { 45.704f, 82.782f, 149.94f, 271.58f };
--- a/src/Ryujinx.Audio/Renderer/Dsp/State/ReverbState.cs
+++ b/src/Ryujinx.Audio/Renderer/Dsp/State/ReverbState.cs
@ -5,7 +5,7 @@ using System;

 namespace Ryujinx.Audio.Renderer.Dsp.State
 {
-    public class ReverbState
+    public struct ReverbState
    {
        private static readonly float[] _fdnDelayTimes = new float[20]
        {
@ -54,7 +54,7 @@ namespace Ryujinx.Audio.Renderer.Dsp.State
            // Room
            0.70f, 0.68f, 0.70f, 0.68f, 0.70f, 0.68f, 0.70f, 0.68f, 0.68f, 0.68f,
            // Chamber
-            0.70f, 0.68f, 0.70f, 0.68f, 0.70f, 0.68f, 0.68f, 0.68f, 0.68f, 0.68f, 
+            0.70f, 0.68f, 0.70f, 0.68f, 0.70f, 0.68f, 0.68f, 0.68f, 0.68f, 0.68f,
            // Hall
            0.50f, 0.70f, 0.70f, 0.68f, 0.50f, 0.68f, 0.68f, 0.70f, 0.68f, 0.00f,
            // Cathedral
--- a/src/Ryujinx.Ava/App.axaml.cs
+++ b/src/Ryujinx.Ava/App.axaml.cs
@ -104,7 +104,7 @@ namespace Ryujinx.Ava
                {
                    "Light" => ThemeVariant.Light,
                    "Dark" => ThemeVariant.Dark,
-                    _ => ThemeVariant.Default
+                    _ => ThemeVariant.Default,
                };

                if (enableCustomTheme)
--- a/src/Ryujinx.Ava/AppHost.cs
+++ b/src/Ryujinx.Ava/AppHost.cs
@ -3,7 +3,6 @@ using Avalonia;
 using Avalonia.Controls;
 using Avalonia.Controls.ApplicationLifetimes;
 using Avalonia.Input;
-using Avalonia.Rendering;
 using Avalonia.Threading;
 using LibHac.Tools.FsSystem;
 using Ryujinx.Audio.Backends.Dummy;
@ -21,6 +20,7 @@ using Ryujinx.Ava.UI.ViewModels;
 using Ryujinx.Ava.UI.Windows;
 using Ryujinx.Common;
 using Ryujinx.Common.Configuration;
+using Ryujinx.Common.Configuration.Multiplayer;
 using Ryujinx.Common.Logging;
 using Ryujinx.Common.SystemInterop;
 using Ryujinx.Graphics.GAL;
@ -191,6 +191,7 @@ namespace Ryujinx.Ava
            ConfigurationState.Instance.Graphics.EnableColorSpacePassthrough.Event += UpdateColorSpacePassthrough;

            ConfigurationState.Instance.Multiplayer.LanInterfaceId.Event += UpdateLanInterfaceIdState;
+            ConfigurationState.Instance.Multiplayer.Mode.Event += UpdateMultiplayerModeState;

            _gpuCancellationTokenSource = new CancellationTokenSource();
            _gpuDoneEvent = new ManualResetEvent(false);
@ -412,6 +413,11 @@ namespace Ryujinx.Ava
            Device.Configuration.MultiplayerLanInterfaceId = e.NewValue;
        }

+        private void UpdateMultiplayerModeState(object sender, ReactiveEventArgs<MultiplayerMode> e)
+        {
+            Device.Configuration.MultiplayerMode = e.NewValue;
+        }
+
        public void Stop()
        {
            _isActive = false;
@ -782,7 +788,8 @@ namespace Ryujinx.Ava
                                                     ConfigurationState.Instance.Graphics.AspectRatio,
                                                     ConfigurationState.Instance.System.AudioVolume,
                                                     ConfigurationState.Instance.System.UseHypervisor,
-                                                     ConfigurationState.Instance.Multiplayer.LanInterfaceId.Value);
+                                                     ConfigurationState.Instance.Multiplayer.LanInterfaceId.Value,
+                                                     ConfigurationState.Instance.Multiplayer.Mode);

            Device = new Switch(configuration);
        }
--- a/src/Ryujinx.Ava/Assets/Locales/en_US.json
+++ b/src/Ryujinx.Ava/Assets/Locales/en_US.json
@ -652,5 +652,8 @@
  "NetworkInterfaceDefault": "Default",
  "PackagingShaders": "Packaging Shaders",
  "AboutChangelogButton": "View Changelog on GitHub",
-  "AboutChangelogButtonTooltipMessage": "Click to open the changelog for this version in your default browser."
-}
+  "AboutChangelogButtonTooltipMessage": "Click to open the changelog for this version in your default browser.",
+  "SettingsTabNetworkMultiplayer": "Multiplayer",
+  "MultiplayerMode": "Mode:",
+  "MultiplayerModeTooltip": "Change multiplayer mode"
+}
--- a/src/Ryujinx.Ava/Common/ApplicationHelper.cs
+++ b/src/Ryujinx.Ava/Common/ApplicationHelper.cs
@ -15,7 +15,6 @@ using LibHac.Tools.FsSystem.NcaUtils;
 using Ryujinx.Ava.Common.Locale;
 using Ryujinx.Ava.UI.Controls;
 using Ryujinx.Ava.UI.Helpers;
-using Ryujinx.Ava.UI.Windows;
 using Ryujinx.Common.Logging;
 using Ryujinx.HLE.FileSystem;
 using Ryujinx.HLE.HOS.Services.Account.Acc;
@ -36,11 +35,9 @@ namespace Ryujinx.Ava.Common
        private static HorizonClient _horizonClient;
        private static AccountManager _accountManager;
        private static VirtualFileSystem _virtualFileSystem;
-        private static StyleableWindow _owner;

-        public static void Initialize(VirtualFileSystem virtualFileSystem, AccountManager accountManager, HorizonClient horizonClient, StyleableWindow owner)
+        public static void Initialize(VirtualFileSystem virtualFileSystem, AccountManager accountManager, HorizonClient horizonClient)
        {
-            _owner = owner;
            _virtualFileSystem = virtualFileSystem;
            _horizonClient = horizonClient;
            _accountManager = accountManager;
@ -148,7 +145,7 @@ namespace Ryujinx.Ava.Common
            var result = await storageProvider.OpenFolderPickerAsync(new FolderPickerOpenOptions
            {
                Title = LocaleManager.Instance[LocaleKeys.FolderDialogExtractTitle],
-                AllowMultiple = false
+                AllowMultiple = false,
            });

            if (result.Count == 0)
--- a/src/Ryujinx.Ava/Common/Locale/LocaleExtension.cs
+++ b/src/Ryujinx.Ava/Common/Locale/LocaleExtension.cs
@ -1,6 +1,7 @@
-using Avalonia.Data;
+using Avalonia.Data.Core;
 using Avalonia.Markup.Xaml;
 using Avalonia.Markup.Xaml.MarkupExtensions;
+using Avalonia.Markup.Xaml.MarkupExtensions.CompiledBindings;
 using System;

 namespace Ryujinx.Ava.Common.Locale
@ -18,11 +19,20 @@ namespace Ryujinx.Ava.Common.Locale
        {
            LocaleKeys keyToUse = Key;

-            ReflectionBindingExtension binding = new($"[{keyToUse}]")
-            {
-                Mode = BindingMode.OneWay,
-                Source = LocaleManager.Instance,
-            };
+            var builder = new CompiledBindingPathBuilder();
+
+            builder.SetRawSource(LocaleManager.Instance)
+                .Property(new ClrPropertyInfo("Item",
+                obj => (LocaleManager.Instance[keyToUse]),
+                null,
+                typeof(string)), (weakRef, iPropInfo) =>
+                {
+                    return PropertyInfoAccessorFactory.CreateInpcPropertyAccessor(weakRef, iPropInfo);
+                });
+
+            var path = builder.Build();
+
+            var binding = new CompiledBindingExtension(path);

            return binding.ProvideValue(serviceProvider);
        }
--- a/src/Ryujinx.Ava/Input/AvaloniaKeyboardDriver.cs
+++ b/src/Ryujinx.Ava/Input/AvaloniaKeyboardDriver.cs
@ -1,6 +1,5 @@
 using Avalonia.Controls;
 using Avalonia.Input;
-using Avalonia.Interactivity;
 using Ryujinx.Ava.Common.Locale;
 using Ryujinx.Input;
 using System;
--- a/src/Ryujinx.Ava/Modules/Updater/Updater.cs
+++ b/src/Ryujinx.Ava/Modules/Updater/Updater.cs
@ -82,12 +82,9 @@ namespace Ryujinx.Modules
            {
                Logger.Error?.Print(LogClass.Application, "Failed to convert the current Ryujinx version!");

-                Dispatcher.UIThread.Post(async () =>
-                {
-                    await ContentDialogHelper.CreateWarningDialog(
-                        LocaleManager.Instance[LocaleKeys.DialogUpdaterConvertFailedMessage],
-                        LocaleManager.Instance[LocaleKeys.DialogUpdaterCancelUpdateMessage]);
-                });
+                await ContentDialogHelper.CreateWarningDialog(
+                    LocaleManager.Instance[LocaleKeys.DialogUpdaterConvertFailedMessage],
+                    LocaleManager.Instance[LocaleKeys.DialogUpdaterCancelUpdateMessage]);

                _running = false;

@ -114,10 +111,9 @@ namespace Ryujinx.Modules
                        {
                            if (showVersionUpToDate)
                            {
-                                Dispatcher.UIThread.Post(async () =>
-                                {
-                                    await ContentDialogHelper.CreateUpdaterInfoDialog(LocaleManager.Instance[LocaleKeys.DialogUpdaterAlreadyOnLatestVersionMessage], "");
-                                });
+                                await ContentDialogHelper.CreateUpdaterInfoDialog(
+                                    LocaleManager.Instance[LocaleKeys.DialogUpdaterAlreadyOnLatestVersionMessage],
+                                    "");
                            }

                            _running = false;
@ -134,10 +130,9 @@ namespace Ryujinx.Modules
                {
                    if (showVersionUpToDate)
                    {
-                        Dispatcher.UIThread.Post(async () =>
-                        {
-                            await ContentDialogHelper.CreateUpdaterInfoDialog(LocaleManager.Instance[LocaleKeys.DialogUpdaterAlreadyOnLatestVersionMessage], "");
-                        });
+                        await ContentDialogHelper.CreateUpdaterInfoDialog(
+                            LocaleManager.Instance[LocaleKeys.DialogUpdaterAlreadyOnLatestVersionMessage],
+                            "");
                    }

                    _running = false;
@ -149,10 +144,8 @@ namespace Ryujinx.Modules
            {
                Logger.Error?.Print(LogClass.Application, exception.Message);

-                Dispatcher.UIThread.Post(async () =>
-                {
-                    await ContentDialogHelper.CreateErrorDialog(LocaleManager.Instance[LocaleKeys.DialogUpdaterFailedToGetVersionMessage]);
-                });
+                await ContentDialogHelper.CreateErrorDialog(
+                    LocaleManager.Instance[LocaleKeys.DialogUpdaterFailedToGetVersionMessage]);

                _running = false;

@ -167,12 +160,9 @@ namespace Ryujinx.Modules
            {
                Logger.Error?.Print(LogClass.Application, "Failed to convert the received Ryujinx version from Github!");

-                Dispatcher.UIThread.Post(async () =>
-                {
-                    await ContentDialogHelper.CreateWarningDialog(
-                        LocaleManager.Instance[LocaleKeys.DialogUpdaterConvertFailedGithubMessage],
-                        LocaleManager.Instance[LocaleKeys.DialogUpdaterCancelUpdateMessage]);
-                });
+                await ContentDialogHelper.CreateWarningDialog(
+                    LocaleManager.Instance[LocaleKeys.DialogUpdaterConvertFailedGithubMessage],
+                    LocaleManager.Instance[LocaleKeys.DialogUpdaterCancelUpdateMessage]);

                _running = false;

@ -183,10 +173,9 @@ namespace Ryujinx.Modules
            {
                if (showVersionUpToDate)
                {
-                    Dispatcher.UIThread.Post(async () =>
-                    {
-                        await ContentDialogHelper.CreateUpdaterInfoDialog(LocaleManager.Instance[LocaleKeys.DialogUpdaterAlreadyOnLatestVersionMessage], "");
-                    });
+                    await ContentDialogHelper.CreateUpdaterInfoDialog(
+                        LocaleManager.Instance[LocaleKeys.DialogUpdaterAlreadyOnLatestVersionMessage],
+                        "");
                }

                _running = false;
@ -212,7 +201,7 @@ namespace Ryujinx.Modules
                _buildSize = -1;
            }

-            Dispatcher.UIThread.Post(async () =>
+            await Dispatcher.UIThread.InvokeAsync(async () =>
            {
                // Show a message asking the user if they want to update
                var shouldUpdate = await ContentDialogHelper.CreateChoiceDialog(
@ -222,7 +211,7 @@ namespace Ryujinx.Modules

                if (shouldUpdate)
                {
-                    UpdateRyujinx(mainWindow, _buildUrl);
+                    await UpdateRyujinx(mainWindow, _buildUrl);
                }
                else
                {
@ -241,7 +230,7 @@ namespace Ryujinx.Modules
            return result;
        }

-        private static async void UpdateRyujinx(Window parent, string downloadUrl)
+        private static async Task UpdateRyujinx(Window parent, string downloadUrl)
        {
            _updateSuccessful = false;

@ -579,27 +568,24 @@ namespace Ryujinx.Modules
            }
        }

-        private static async void InstallUpdate(TaskDialog taskDialog, string updateFile)
+        private static void InstallUpdate(TaskDialog taskDialog, string updateFile)
        {
            // Extract Update
            taskDialog.SubHeader = LocaleManager.Instance[LocaleKeys.UpdaterExtracting];
            taskDialog.SetProgressBarState(0, TaskDialogProgressState.Normal);

-            await Task.Run(() =>
+            if (OperatingSystem.IsLinux() || OperatingSystem.IsMacOS())
            {
-                if (OperatingSystem.IsLinux() || OperatingSystem.IsMacOS())
-                {
-                    ExtractTarGzipFile(taskDialog, updateFile, _updateDir);
-                }
-                else if (OperatingSystem.IsWindows())
-                {
-                    ExtractZipFile(taskDialog, updateFile, _updateDir);
-                }
-                else
-                {
-                    throw new NotSupportedException();
-                }
-            });
+                ExtractTarGzipFile(taskDialog, updateFile, _updateDir);
+            }
+            else if (OperatingSystem.IsWindows())
+            {
+                ExtractZipFile(taskDialog, updateFile, _updateDir);
+            }
+            else
+            {
+                throw new NotSupportedException();
+            }

            // Delete downloaded zip
            File.Delete(updateFile);
@ -613,36 +599,33 @@ namespace Ryujinx.Modules
            if (!OperatingSystem.IsMacOS())
            {
                // Replace old files
-                await Task.Run(() =>
+                double count = 0;
+                foreach (string file in allFiles)
                {
-                    double count = 0;
-                    foreach (string file in allFiles)
+                    count++;
+                    try
                    {
-                        count++;
-                        try
-                        {
-                            File.Move(file, file + ".ryuold");
+                        File.Move(file, file + ".ryuold");

-                            Dispatcher.UIThread.Post(() =>
-                            {
-                                taskDialog.SetProgressBarState(GetPercentage(count, allFiles.Count), TaskDialogProgressState.Normal);
-                            });
-                        }
-                        catch
+                        Dispatcher.UIThread.InvokeAsync(() =>
                        {
-                            Logger.Warning?.Print(LogClass.Application, LocaleManager.Instance.UpdateAndGetDynamicValue(LocaleKeys.UpdaterRenameFailed, file));
-                        }
+                            taskDialog.SetProgressBarState(GetPercentage(count, allFiles.Count), TaskDialogProgressState.Normal);
+                        });
                    }
-
-                    Dispatcher.UIThread.Post(() =>
+                    catch
                    {
-                        taskDialog.SubHeader = LocaleManager.Instance[LocaleKeys.UpdaterAddingFiles];
-                        taskDialog.SetProgressBarState(0, TaskDialogProgressState.Normal);
-                    });
+                        Logger.Warning?.Print(LogClass.Application, LocaleManager.Instance.UpdateAndGetDynamicValue(LocaleKeys.UpdaterRenameFailed, file));
+                    }
+                }

-                    MoveAllFilesOver(_updatePublishDir, _homeDir, taskDialog);
+                Dispatcher.UIThread.InvokeAsync(() =>
+                {
+                    taskDialog.SubHeader = LocaleManager.Instance[LocaleKeys.UpdaterAddingFiles];
+                    taskDialog.SetProgressBarState(0, TaskDialogProgressState.Normal);
                });

+                MoveAllFilesOver(_updatePublishDir, _homeDir, taskDialog);
+
                Directory.Delete(_updateDir, true);
            }

@ -658,12 +641,11 @@ namespace Ryujinx.Modules
            {
                if (showWarnings)
                {
-                    Dispatcher.UIThread.Post(async () =>
-                    {
-                        await ContentDialogHelper.CreateWarningDialog(
+                    Dispatcher.UIThread.InvokeAsync(() =>
+                        ContentDialogHelper.CreateWarningDialog(
                            LocaleManager.Instance[LocaleKeys.DialogUpdaterArchNotSupportedMessage],
-                            LocaleManager.Instance[LocaleKeys.DialogUpdaterArchNotSupportedSubMessage]);
-                    });
+                            LocaleManager.Instance[LocaleKeys.DialogUpdaterArchNotSupportedSubMessage])
+                    );
                }

                return false;
@ -673,12 +655,11 @@ namespace Ryujinx.Modules
            {
                if (showWarnings)
                {
-                    Dispatcher.UIThread.Post(async () =>
-                    {
-                        await ContentDialogHelper.CreateWarningDialog(
+                    Dispatcher.UIThread.InvokeAsync(() =>
+                        ContentDialogHelper.CreateWarningDialog(
                            LocaleManager.Instance[LocaleKeys.DialogUpdaterNoInternetMessage],
-                            LocaleManager.Instance[LocaleKeys.DialogUpdaterNoInternetSubMessage]);
-                    });
+                            LocaleManager.Instance[LocaleKeys.DialogUpdaterNoInternetSubMessage])
+                    );
                }

                return false;
@ -688,12 +669,11 @@ namespace Ryujinx.Modules
            {
                if (showWarnings)
                {
-                    Dispatcher.UIThread.Post(async () =>
-                    {
-                        await ContentDialogHelper.CreateWarningDialog(
+                    Dispatcher.UIThread.InvokeAsync(() =>
+                        ContentDialogHelper.CreateWarningDialog(
                            LocaleManager.Instance[LocaleKeys.DialogUpdaterDirtyBuildMessage],
-                            LocaleManager.Instance[LocaleKeys.DialogUpdaterDirtyBuildSubMessage]);
-                    });
+                            LocaleManager.Instance[LocaleKeys.DialogUpdaterDirtyBuildSubMessage])
+                    );
                }

                return false;
@ -705,21 +685,19 @@ namespace Ryujinx.Modules
            {
                if (ReleaseInformation.IsFlatHubBuild())
                {
-                    Dispatcher.UIThread.Post(async () =>
-                    {
-                        await ContentDialogHelper.CreateWarningDialog(
+                    Dispatcher.UIThread.InvokeAsync(() =>
+                        ContentDialogHelper.CreateWarningDialog(
                            LocaleManager.Instance[LocaleKeys.UpdaterDisabledWarningTitle],
-                            LocaleManager.Instance[LocaleKeys.DialogUpdaterFlatpakNotSupportedMessage]);
-                    });
+                            LocaleManager.Instance[LocaleKeys.DialogUpdaterFlatpakNotSupportedMessage])
+                    );
                }
                else
                {
-                    Dispatcher.UIThread.Post(async () =>
-                    {
-                        await ContentDialogHelper.CreateWarningDialog(
+                    Dispatcher.UIThread.InvokeAsync(() =>
+                        ContentDialogHelper.CreateWarningDialog(
                            LocaleManager.Instance[LocaleKeys.UpdaterDisabledWarningTitle],
-                            LocaleManager.Instance[LocaleKeys.DialogUpdaterDirtyBuildSubMessage]);
-                    });
+                            LocaleManager.Instance[LocaleKeys.DialogUpdaterDirtyBuildSubMessage])
+                    );
                }
            }

--- a/src/Ryujinx.Ava/UI/Applet/AvaHostUiHandler.cs
+++ b/src/Ryujinx.Ava/UI/Applet/AvaHostUiHandler.cs
@ -106,7 +106,7 @@ namespace Ryujinx.Ava.UI.Applet
            bool error = false;
            string inputText = args.InitialText ?? "";

-            Dispatcher.UIThread.Post(async () =>
+            Dispatcher.UIThread.InvokeAsync(async () =>
            {
                try
                {
@ -149,7 +149,7 @@ namespace Ryujinx.Ava.UI.Applet

            bool showDetails = false;

-            Dispatcher.UIThread.Post(async () =>
+            Dispatcher.UIThread.InvokeAsync(async () =>
            {
                try
                {
--- a/src/Ryujinx.Ava/UI/Applet/ErrorAppletWindow.axaml
+++ b/src/Ryujinx.Ava/UI/Applet/ErrorAppletWindow.axaml
@ -6,9 +6,11 @@
    xmlns:locale="clr-namespace:Ryujinx.Ava.Common.Locale"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    Title="{locale:Locale ErrorWindowTitle}"
+    xmlns:views="using:Ryujinx.Ava.UI.Applet"
    Width="450"
    Height="340"
    CanResize="False"
+    x:DataType="views:ErrorAppletWindow"
    SizeToContent="Height"
    mc:Ignorable="d"
    Focusable="True">
@ -38,7 +40,7 @@
            Grid.Column="1"
            Margin="10"
            VerticalAlignment="Stretch"
-            Text="{ReflectionBinding Message}"
+            Text="{Binding Message}"
            TextWrapping="Wrap" />
        <StackPanel
            Name="ButtonStack"
@ -49,4 +51,4 @@
            Orientation="Horizontal"
            Spacing="10" />
    </Grid>
-</Window>
+</Window>
--- a/src/Ryujinx.Ava/UI/Applet/SwkbdAppletDialog.axaml
+++ b/src/Ryujinx.Ava/UI/Applet/SwkbdAppletDialog.axaml
@ -4,7 +4,9 @@
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+    xmlns:views="using:Ryujinx.Ava.UI.Controls"
    Width="400"
+    x:DataType="views:SwkbdAppletDialog"
    mc:Ignorable="d"
    Focusable="True">
    <Grid
@ -34,13 +36,13 @@
            Grid.Row="1"
            Grid.Column="1"
            Margin="5"
-            Text="{ReflectionBinding MainText}"
+            Text="{Binding MainText}"
            TextWrapping="Wrap" />
        <TextBlock
            Grid.Row="2"
            Grid.Column="1"
            Margin="5"
-            Text="{ReflectionBinding SecondaryText}"
+            Text="{Binding SecondaryText}"
            TextWrapping="Wrap" />
        <TextBox
            Name="Input"
@ -50,7 +52,7 @@
            VerticalAlignment="Center"
            Focusable="True"
            KeyUp="Message_KeyUp"
-            Text="{ReflectionBinding Message}"
+            Text="{Binding Message}"
            TextInput="Message_TextInput"
            TextWrapping="Wrap"
            UseFloatingWatermark="True" />
--- a/src/Ryujinx.Ava/UI/Controls/ApplicationContextMenu.axaml.cs
+++ b/src/Ryujinx.Ava/UI/Controls/ApplicationContextMenu.axaml.cs
@ -54,7 +54,7 @@ namespace Ryujinx.Ava.UI.Controls
        {
            if (sender is MenuItem { DataContext: MainWindowViewModel viewModel })
            {
-                OpenSaveDirectory(viewModel, SaveDataType.Account, userId: new UserId((ulong)viewModel.AccountManager.LastOpenedUser.UserId.High, (ulong)viewModel.AccountManager.LastOpenedUser.UserId.Low));
+                OpenSaveDirectory(viewModel, SaveDataType.Account, new UserId((ulong)viewModel.AccountManager.LastOpenedUser.UserId.High, (ulong)viewModel.AccountManager.LastOpenedUser.UserId.Low));
            }
        }

@ -62,14 +62,14 @@ namespace Ryujinx.Ava.UI.Controls
        {
            var viewModel = (sender as MenuItem)?.DataContext as MainWindowViewModel;

-            OpenSaveDirectory(viewModel, SaveDataType.Device, userId: default);
+            OpenSaveDirectory(viewModel, SaveDataType.Device, default);
        }

        public void OpenBcatSaveDirectory_Click(object sender, RoutedEventArgs args)
        {
            var viewModel = (sender as MenuItem)?.DataContext as MainWindowViewModel;

-            OpenSaveDirectory(viewModel, SaveDataType.Bcat, userId: default);
+            OpenSaveDirectory(viewModel, SaveDataType.Bcat, default);
        }

        private static void OpenSaveDirectory(MainWindowViewModel viewModel, SaveDataType saveDataType, UserId userId)
@ -158,11 +158,12 @@ namespace Ryujinx.Ava.UI.Controls

            if (viewModel?.SelectedApplication != null)
            {
-                UserResult result = await ContentDialogHelper.CreateConfirmationDialog(LocaleManager.Instance[LocaleKeys.DialogWarning],
-                                                                                       LocaleManager.Instance.UpdateAndGetDynamicValue(LocaleKeys.DialogPPTCDeletionMessage, viewModel.SelectedApplication.TitleName),
-                                                                                       LocaleManager.Instance[LocaleKeys.InputDialogYes],
-                                                                                       LocaleManager.Instance[LocaleKeys.InputDialogNo],
-                                                                                       LocaleManager.Instance[LocaleKeys.RyujinxConfirm]);
+                UserResult result = await ContentDialogHelper.CreateConfirmationDialog(
+                    LocaleManager.Instance[LocaleKeys.DialogWarning],
+                    LocaleManager.Instance.UpdateAndGetDynamicValue(LocaleKeys.DialogPPTCDeletionMessage, viewModel.SelectedApplication.TitleName),
+                    LocaleManager.Instance[LocaleKeys.InputDialogYes],
+                    LocaleManager.Instance[LocaleKeys.InputDialogNo],
+                    LocaleManager.Instance[LocaleKeys.RyujinxConfirm]);

                if (result == UserResult.Yes)
                {
@ -205,11 +206,12 @@ namespace Ryujinx.Ava.UI.Controls

            if (viewModel?.SelectedApplication != null)
            {
-                UserResult result = await ContentDialogHelper.CreateConfirmationDialog(LocaleManager.Instance[LocaleKeys.DialogWarning],
-                                                                                       LocaleManager.Instance.UpdateAndGetDynamicValue(LocaleKeys.DialogShaderDeletionMessage, viewModel.SelectedApplication.TitleName),
-                                                                                       LocaleManager.Instance[LocaleKeys.InputDialogYes],
-                                                                                       LocaleManager.Instance[LocaleKeys.InputDialogNo],
-                                                                                       LocaleManager.Instance[LocaleKeys.RyujinxConfirm]);
+                UserResult result = await ContentDialogHelper.CreateConfirmationDialog(
+                    LocaleManager.Instance[LocaleKeys.DialogWarning],
+                    LocaleManager.Instance.UpdateAndGetDynamicValue(LocaleKeys.DialogShaderDeletionMessage, viewModel.SelectedApplication.TitleName),
+                    LocaleManager.Instance[LocaleKeys.InputDialogYes],
+                    LocaleManager.Instance[LocaleKeys.InputDialogNo],
+                    LocaleManager.Instance[LocaleKeys.RyujinxConfirm]);

                if (result == UserResult.Yes)
                {
@ -335,13 +337,13 @@ namespace Ryujinx.Ava.UI.Controls
            }
        }

-        public void RunApplication_Click(object sender, RoutedEventArgs args)
+        public async void RunApplication_Click(object sender, RoutedEventArgs args)
        {
            var viewModel = (sender as MenuItem)?.DataContext as MainWindowViewModel;

            if (viewModel?.SelectedApplication != null)
            {
-                viewModel.LoadApplication(viewModel.SelectedApplication.Path);
+                await viewModel.LoadApplication(viewModel.SelectedApplication.Path);
            }
        }
    }
--- a/src/Ryujinx.Ava/UI/Controls/ApplicationGridView.axaml
+++ b/src/Ryujinx.Ava/UI/Controls/ApplicationGridView.axaml
@ -46,7 +46,7 @@
                    <Setter Property="CornerRadius" Value="4" />
                </Style>
                <Style Selector="ListBoxItem:selected /template/ Rectangle#SelectionIndicator">
-                    <Setter Property="MinHeight" Value="{ReflectionBinding $parent[UserControl].DataContext.GridItemSelectorSize}" />
+                    <Setter Property="MinHeight" Value="{Binding $parent[UserControl].((viewModels:MainWindowViewModel)DataContext).GridItemSelectorSize}" />
                </Style>
            </ListBox.Styles>
            <ListBox.ItemTemplate>
@ -56,10 +56,10 @@
                            Margin="10"
                            HorizontalAlignment="Stretch"
                            VerticalAlignment="Stretch"
-                            Classes.huge="{ReflectionBinding $parent[UserControl].DataContext.IsGridHuge}"
-                            Classes.large="{ReflectionBinding $parent[UserControl].DataContext.IsGridLarge}"
-                            Classes.normal="{ReflectionBinding $parent[UserControl].DataContext.IsGridMedium}"
-                            Classes.small="{ReflectionBinding $parent[UserControl].DataContext.IsGridSmall}"
+                            Classes.huge="{Binding $parent[UserControl].((viewModels:MainWindowViewModel)DataContext).IsGridHuge}"
+                            Classes.large="{Binding $parent[UserControl].((viewModels:MainWindowViewModel)DataContext).IsGridLarge}"
+                            Classes.normal="{Binding $parent[UserControl].((viewModels:MainWindowViewModel)DataContext).IsGridMedium}"
+                            Classes.small="{Binding $parent[UserControl].((viewModels:MainWindowViewModel)DataContext).IsGridSmall}"
                            ClipToBounds="True"
                            CornerRadius="4">
                            <Grid>
@ -78,7 +78,7 @@
                                    Margin="0,10,0,0"
                                    HorizontalAlignment="Stretch"
                                    VerticalAlignment="Stretch"
-                                    IsVisible="{ReflectionBinding $parent[UserControl].DataContext.ShowNames}">
+                                    IsVisible="{Binding $parent[UserControl].((viewModels:MainWindowViewModel)DataContext).ShowNames}">
                                    <TextBlock
                                        HorizontalAlignment="Center"
                                        VerticalAlignment="Center"
@ -101,4 +101,4 @@
            </ListBox.ItemTemplate>
        </ListBox>
    </Grid>
-</UserControl>
+</UserControl>
--- a/src/Ryujinx.Ava/UI/Controls/ApplicationListView.axaml
+++ b/src/Ryujinx.Ava/UI/Controls/ApplicationListView.axaml
@ -42,7 +42,7 @@
            </ListBox.ItemsPanel>
            <ListBox.Styles>
                <Style Selector="ListBoxItem:selected /template/ Rectangle#SelectionIndicator">
-                    <Setter Property="MinHeight" Value="{ReflectionBinding $parent[UserControl].DataContext.ListItemSelectorSize}" />
+                    <Setter Property="MinHeight" Value="{Binding $parent[UserControl].((viewModels:MainWindowViewModel)DataContext).ListItemSelectorSize}" />
                </Style>
            </ListBox.Styles>
            <ListBox.ItemTemplate>
@ -67,10 +67,10 @@
                                    Grid.RowSpan="3"
                                    Grid.Column="0"
                                    Margin="0"
-                                    Classes.huge="{ReflectionBinding $parent[UserControl].DataContext.IsGridHuge}"
-                                    Classes.large="{ReflectionBinding $parent[UserControl].DataContext.IsGridLarge}"
-                                    Classes.normal="{ReflectionBinding $parent[UserControl].DataContext.IsGridMedium}"
-                                    Classes.small="{ReflectionBinding $parent[UserControl].DataContext.IsGridSmall}"
+                                    Classes.huge="{Binding $parent[UserControl].((viewModels:MainWindowViewModel)DataContext).IsGridHuge}"
+                                    Classes.large="{Binding $parent[UserControl].((viewModels:MainWindowViewModel)DataContext).IsGridLarge}"
+                                    Classes.normal="{Binding $parent[UserControl].((viewModels:MainWindowViewModel)DataContext).IsGridMedium}"
+                                    Classes.small="{Binding $parent[UserControl].((viewModels:MainWindowViewModel)DataContext).IsGridSmall}"
                                    Source="{Binding Icon, Converter={StaticResource ByteImage}}" />
                                <Border
                                    Grid.Column="2"
@ -157,4 +157,4 @@
            </ListBox.ItemTemplate>
        </ListBox>
    </Grid>
-</UserControl>
+</UserControl>
--- a/src/Ryujinx.Ava/UI/ViewModels/DownloadableContentManagerViewModel.cs
+++ b/src/Ryujinx.Ava/UI/ViewModels/DownloadableContentManagerViewModel.cs
@ -212,9 +212,9 @@ namespace Ryujinx.Ava.UI.ViewModels
                    {
                        Patterns = new[] { "*.nsp" },
                        AppleUniformTypeIdentifiers = new[] { "com.ryujinx.nsp" },
-                        MimeTypes = new[] { "application/x-nx-nsp" }
-                    }
-                }
+                        MimeTypes = new[] { "application/x-nx-nsp" },
+                    },
+                },
            });

            foreach (var file in result)
--- a/src/Ryujinx.Ava/UI/ViewModels/MainWindowViewModel.cs
+++ b/src/Ryujinx.Ava/UI/ViewModels/MainWindowViewModel.cs
@ -26,6 +26,7 @@ using Ryujinx.HLE.FileSystem;
 using Ryujinx.HLE.HOS;
 using Ryujinx.HLE.HOS.Services.Account.Acc;
 using Ryujinx.HLE.Ui;
+using Ryujinx.Input.HLE;
 using Ryujinx.Modules;
 using Ryujinx.Ui.App.Common;
 using Ryujinx.Ui.Common;
@ -39,7 +40,6 @@ using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
 using Image = SixLabors.ImageSharp.Image;
-using InputManager = Ryujinx.Input.HLE.InputManager;
 using Key = Ryujinx.Input.Key;
 using MissingKeyException = LibHac.Common.Keys.MissingKeyException;
 using ShaderCacheLoadingState = Ryujinx.Graphics.Gpu.Shader.ShaderCacheState;
@ -1068,9 +1068,7 @@ namespace Ryujinx.Ava.UI.ViewModels
                {
                    Logger.Error?.Print(LogClass.Application, ex.ToString());

-                    static async void Action() => await UserErrorDialog.ShowUserErrorDialog(UserError.NoKeys);
-
-                    Dispatcher.UIThread.Post(Action);
+                    await UserErrorDialog.ShowUserErrorDialog(UserError.NoKeys);
                }
            }
            catch (Exception ex)
@ -1163,16 +1161,13 @@ namespace Ryujinx.Ava.UI.ViewModels
            AppHost?.DisposeContext();
        }

-        private void HandleRelaunch()
+        private async Task HandleRelaunch()
        {
            if (UserChannelPersistence.PreviousIndex != -1 && UserChannelPersistence.ShouldRestart)
            {
                UserChannelPersistence.ShouldRestart = false;

-                Dispatcher.UIThread.Post(() =>
-                {
-                    LoadApplication(_currentEmulatedGamePath);
-                });
+                await LoadApplication(_currentEmulatedGamePath);
            }
            else
            {
@ -1191,7 +1186,7 @@ namespace Ryujinx.Ava.UI.ViewModels
                    Application.Current.Styles.TryGetResource(args.VSyncEnabled
                        ? "VsyncEnabled"
                        : "VsyncDisabled",
-                        Avalonia.Application.Current.ActualThemeVariant,
+                        Application.Current.ActualThemeVariant,
                        out object color);

                    if (color is not null)
@ -1283,7 +1278,7 @@ namespace Ryujinx.Ava.UI.ViewModels
            Glyph = Glyph.Grid;
        }

-        public async void InstallFirmwareFromFile()
+        public async Task InstallFirmwareFromFile()
        {
            var result = await StorageProvider.OpenFilePickerAsync(new FilePickerOpenOptions
            {
@ -1294,21 +1289,21 @@ namespace Ryujinx.Ava.UI.ViewModels
                    {
                        Patterns = new[] { "*.xci", "*.zip" },
                        AppleUniformTypeIdentifiers = new[] { "com.ryujinx.xci", "public.zip-archive" },
-                        MimeTypes = new[] { "application/x-nx-xci", "application/zip" }
+                        MimeTypes = new[] { "application/x-nx-xci", "application/zip" },
                    },
                    new("XCI")
                    {
                        Patterns = new[] { "*.xci" },
                        AppleUniformTypeIdentifiers = new[] { "com.ryujinx.xci" },
-                        MimeTypes = new[] { "application/x-nx-xci" }
+                        MimeTypes = new[] { "application/x-nx-xci" },
                    },
                    new("ZIP")
                    {
                        Patterns = new[] { "*.zip" },
                        AppleUniformTypeIdentifiers = new[] { "public.zip-archive" },
-                        MimeTypes = new[] { "application/zip" }
+                        MimeTypes = new[] { "application/zip" },
                    },
-                }
+                },
            });

            if (result.Count > 0)
@ -1317,11 +1312,11 @@ namespace Ryujinx.Ava.UI.ViewModels
            }
        }

-        public async void InstallFirmwareFromFolder()
+        public async Task InstallFirmwareFromFolder()
        {
            var result = await StorageProvider.OpenFolderPickerAsync(new FolderPickerOpenOptions
            {
-                AllowMultiple = false
+                AllowMultiple = false,
            });

            if (result.Count > 0)
@ -1352,7 +1347,7 @@ namespace Ryujinx.Ava.UI.ViewModels
            }
        }

-        public async void ExitCurrentState()
+        public async Task ExitCurrentState()
        {
            if (WindowState == WindowState.FullScreen)
            {
@ -1377,7 +1372,7 @@ namespace Ryujinx.Ava.UI.ViewModels
            }
        }

-        public async void ManageProfiles()
+        public async Task ManageProfiles()
        {
            await NavigationDialogHost.Show(AccountManager, ContentManager, VirtualFileSystem, LibHacHorizonManager.RyujinxClient);
        }
@ -1387,7 +1382,7 @@ namespace Ryujinx.Ava.UI.ViewModels
            AppHost.Device.System.SimulateWakeUpMessage();
        }

-        public async void OpenFile()
+        public async Task OpenFile()
        {
            var result = await StorageProvider.OpenFilePickerAsync(new FilePickerOpenOptions
            {
@ -1404,7 +1399,7 @@ namespace Ryujinx.Ava.UI.ViewModels
                            "com.ryujinx.xci",
                            "com.ryujinx.nca",
                            "com.ryujinx.nro",
-                            "com.ryujinx.nso"
+                            "com.ryujinx.nso",
                        },
                        MimeTypes = new[]
                        {
@ -1412,63 +1407,63 @@ namespace Ryujinx.Ava.UI.ViewModels
                            "application/x-nx-xci",
                            "application/x-nx-nca",
                            "application/x-nx-nro",
-                            "application/x-nx-nso"
-                        }
+                            "application/x-nx-nso",
+                        },
                    },
                    new("NSP")
                    {
                        Patterns = new[] { "*.nsp" },
                        AppleUniformTypeIdentifiers = new[] { "com.ryujinx.nsp" },
-                        MimeTypes = new[] { "application/x-nx-nsp" }
+                        MimeTypes = new[] { "application/x-nx-nsp" },
                    },
                    new("XCI")
                    {
                        Patterns = new[] { "*.xci" },
                        AppleUniformTypeIdentifiers = new[] { "com.ryujinx.xci" },
-                        MimeTypes = new[] { "application/x-nx-xci" }
+                        MimeTypes = new[] { "application/x-nx-xci" },
                    },
                    new("NCA")
                    {
                        Patterns = new[] { "*.nca" },
                        AppleUniformTypeIdentifiers = new[] { "com.ryujinx.nca" },
-                        MimeTypes = new[] { "application/x-nx-nca" }
+                        MimeTypes = new[] { "application/x-nx-nca" },
                    },
                    new("NRO")
                    {
                        Patterns = new[] { "*.nro" },
                        AppleUniformTypeIdentifiers = new[] { "com.ryujinx.nro" },
-                        MimeTypes = new[] { "application/x-nx-nro" }
+                        MimeTypes = new[] { "application/x-nx-nro" },
                    },
                    new("NSO")
                    {
                        Patterns = new[] { "*.nso" },
                        AppleUniformTypeIdentifiers = new[] { "com.ryujinx.nso" },
-                        MimeTypes = new[] { "application/x-nx-nso" }
+                        MimeTypes = new[] { "application/x-nx-nso" },
                    },
-                }
+                },
            });

            if (result.Count > 0)
            {
-                LoadApplication(result[0].Path.LocalPath);
+                await LoadApplication(result[0].Path.LocalPath);
            }
        }

-        public async void OpenFolder()
+        public async Task OpenFolder()
        {
            var result = await StorageProvider.OpenFolderPickerAsync(new FolderPickerOpenOptions
            {
                Title = LocaleManager.Instance[LocaleKeys.OpenFolderDialogTitle],
-                AllowMultiple = false
+                AllowMultiple = false,
            });

            if (result.Count > 0)
            {
-                LoadApplication(result[0].Path.LocalPath);
+                await LoadApplication(result[0].Path.LocalPath);
            }
        }

-        public async void LoadApplication(string path, bool startFullscreen = false, string titleName = "")
+        public async Task LoadApplication(string path, bool startFullscreen = false, string titleName = "")
        {
            if (AppHost != null)
            {
@ -1505,35 +1500,30 @@ namespace Ryujinx.Ava.UI.ViewModels
                this,
                TopLevel);

-            async void Action()
+            if (!await AppHost.LoadGuestApplication())
            {
-                if (!await AppHost.LoadGuestApplication())
-                {
-                    AppHost.DisposeContext();
-                    AppHost = null;
+                AppHost.DisposeContext();
+                AppHost = null;

-                    return;
-                }
-
-                CanUpdate = false;
-
-                LoadHeading = TitleName = titleName;
-
-                if (string.IsNullOrWhiteSpace(titleName))
-                {
-                    LoadHeading = LocaleManager.Instance.UpdateAndGetDynamicValue(LocaleKeys.LoadingHeading, AppHost.Device.Processes.ActiveApplication.Name);
-                    TitleName = AppHost.Device.Processes.ActiveApplication.Name;
-                }
-
-                SwitchToRenderer(startFullscreen);
-
-                _currentEmulatedGamePath = path;
-
-                Thread gameThread = new(InitializeGame) { Name = "GUI.WindowThread" };
-                gameThread.Start();
+                return;
            }

-            Dispatcher.UIThread.Post(Action);
+            CanUpdate = false;
+
+            LoadHeading = TitleName = titleName;
+
+            if (string.IsNullOrWhiteSpace(titleName))
+            {
+                LoadHeading = LocaleManager.Instance.UpdateAndGetDynamicValue(LocaleKeys.LoadingHeading, AppHost.Device.Processes.ActiveApplication.Name);
+                TitleName = AppHost.Device.Processes.ActiveApplication.Name;
+            }
+
+            SwitchToRenderer(startFullscreen);
+
+            _currentEmulatedGamePath = path;
+
+            Thread gameThread = new(InitializeGame) { Name = "GUI.WindowThread" };
+            gameThread.Start();
        }

        public void SwitchToRenderer(bool startFullscreen)
@ -1596,7 +1586,7 @@ namespace Ryujinx.Ava.UI.ViewModels

            IsGameRunning = false;

-            Dispatcher.UIThread.InvokeAsync(() =>
+            Dispatcher.UIThread.InvokeAsync(async () =>
            {
                ShowMenuAndStatusBar = true;
                ShowContent = true;
@ -1609,7 +1599,7 @@ namespace Ryujinx.Ava.UI.ViewModels

                AppHost = null;

-                HandleRelaunch();
+                await HandleRelaunch();
            });

            RendererHostControl.WindowCreated -= RendererHost_Created;
--- a/src/Ryujinx.Ava/UI/ViewModels/SettingsViewModel.cs
+++ b/src/Ryujinx.Ava/UI/ViewModels/SettingsViewModel.cs
@ -10,6 +10,7 @@ using Ryujinx.Ava.UI.Helpers;
 using Ryujinx.Ava.UI.Windows;
 using Ryujinx.Common.Configuration;
 using Ryujinx.Common.Configuration.Hid;
+using Ryujinx.Common.Configuration.Multiplayer;
 using Ryujinx.Common.GraphicsDriver;
 using Ryujinx.Common.Logging;
 using Ryujinx.Graphics.Vulkan;
@ -54,6 +55,7 @@ namespace Ryujinx.Ava.UI.ViewModels
        public event Action CloseWindow;
        public event Action SaveSettingsEvent;
        private int _networkInterfaceIndex;
+        private int _multiplayerModeIndex;

        public int ResolutionScale
        {
@ -76,14 +78,13 @@ namespace Ryujinx.Ava.UI.ViewModels

                if (_graphicsBackendMultithreadingIndex != (int)ConfigurationState.Instance.Graphics.BackendThreading.Value)
                {
-                    Dispatcher.UIThread.Post(async () =>
-                    {
-                        await ContentDialogHelper.CreateInfoDialog(LocaleManager.Instance[LocaleKeys.DialogSettingsBackendThreadingWarningMessage],
+                    Dispatcher.UIThread.InvokeAsync(() =>
+                         ContentDialogHelper.CreateInfoDialog(LocaleManager.Instance[LocaleKeys.DialogSettingsBackendThreadingWarningMessage],
                            "",
                            "",
                            LocaleManager.Instance[LocaleKeys.InputDialogOk],
-                            LocaleManager.Instance[LocaleKeys.DialogSettingsBackendThreadingWarningTitle]);
-                    });
+                            LocaleManager.Instance[LocaleKeys.DialogSettingsBackendThreadingWarningTitle])
+                    );
                }

                OnPropertyChanged();
@ -251,6 +252,11 @@ namespace Ryujinx.Ava.UI.ViewModels
            get => new(_networkInterfaces.Keys);
        }

+        public AvaloniaList<string> MultiplayerModes
+        {
+            get => new(Enum.GetNames<MultiplayerMode>());
+        }
+
        public KeyboardHotkeys KeyboardHotkeys
        {
            get => _keyboardHotkeys;
@ -272,6 +278,16 @@ namespace Ryujinx.Ava.UI.ViewModels
            }
        }

+        public int MultiplayerModeIndex
+        {
+            get => _multiplayerModeIndex;
+            set
+            {
+                _multiplayerModeIndex = value;
+                ConfigurationState.Instance.Multiplayer.Mode.Value = (MultiplayerMode)_multiplayerModeIndex;
+            }
+        }
+
        public SettingsViewModel(VirtualFileSystem virtualFileSystem, ContentManager contentManager) : this()
        {
            _virtualFileSystem = virtualFileSystem;
@ -478,6 +494,8 @@ namespace Ryujinx.Ava.UI.ViewModels
            EnableFsAccessLog = config.Logger.EnableFsAccessLog;
            FsGlobalAccessLogMode = config.System.FsGlobalAccessLogMode;
            OpenglDebugLevel = (int)config.Logger.GraphicsDebugLevel.Value;
+
+            MultiplayerModeIndex = (int)config.Multiplayer.Mode.Value;
        }

        public void SaveSettings()
@ -579,6 +597,7 @@ namespace Ryujinx.Ava.UI.ViewModels
            config.Logger.GraphicsDebugLevel.Value = (GraphicsDebugLevel)OpenglDebugLevel;

            config.Multiplayer.LanInterfaceId.Value = _networkInterfaces[NetworkInterfaceList[NetworkInterfaceIndex]];
+            config.Multiplayer.Mode.Value = (MultiplayerMode)MultiplayerModeIndex;

            config.ToFileFormat().SaveConfig(Program.ConfigurationPath);

--- a/src/Ryujinx.Ava/UI/ViewModels/TitleUpdateViewModel.cs
+++ b/src/Ryujinx.Ava/UI/ViewModels/TitleUpdateViewModel.cs
@ -22,6 +22,7 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Threading.Tasks;
 using Path = System.IO.Path;
 using SpanHelpers = LibHac.Common.SpanHelpers;

@ -184,18 +185,12 @@ namespace Ryujinx.Ava.UI.ViewModels
                    }
                    else
                    {
-                        Dispatcher.UIThread.Post(async () =>
-                        {
-                            await ContentDialogHelper.CreateErrorDialog(LocaleManager.Instance[LocaleKeys.DialogUpdateAddUpdateErrorMessage]);
-                        });
+                        Dispatcher.UIThread.InvokeAsync(() => ContentDialogHelper.CreateErrorDialog(LocaleManager.Instance[LocaleKeys.DialogUpdateAddUpdateErrorMessage]));
                    }
                }
                catch (Exception ex)
                {
-                    Dispatcher.UIThread.Post(async () =>
-                    {
-                        await ContentDialogHelper.CreateErrorDialog(LocaleManager.Instance.UpdateAndGetDynamicValue(LocaleKeys.DialogLoadNcaErrorMessage, ex.Message, path));
-                    });
+                    Dispatcher.UIThread.InvokeAsync(() => ContentDialogHelper.CreateErrorDialog(LocaleManager.Instance.UpdateAndGetDynamicValue(LocaleKeys.DialogLoadNcaErrorMessage, ex.Message, path)));
                }
            }
        }
@ -207,7 +202,7 @@ namespace Ryujinx.Ava.UI.ViewModels
            SortUpdates();
        }

-        public async void Add()
+        public async Task Add()
        {
            var result = await StorageProvider.OpenFilePickerAsync(new FilePickerOpenOptions
            {
@ -218,9 +213,9 @@ namespace Ryujinx.Ava.UI.ViewModels
                    {
                        Patterns = new[] { "*.nsp" },
                        AppleUniformTypeIdentifiers = new[] { "com.ryujinx.nsp" },
-                        MimeTypes = new[] { "application/x-nx-nsp" }
-                    }
-                }
+                        MimeTypes = new[] { "application/x-nx-nsp" },
+                    },
+                },
            });

            foreach (var file in result)
--- a/src/Ryujinx.Ava/UI/Views/Main/MainMenuBarView.axaml.cs
+++ b/src/Ryujinx.Ava/UI/Views/Main/MainMenuBarView.axaml.cs
@ -17,7 +17,6 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Threading.Tasks;

 namespace Ryujinx.Ava.UI.Views.Main
 {
@ -107,20 +106,14 @@ namespace Ryujinx.Ava.UI.Views.Main
            await Window.ViewModel.AppHost?.ShowExitPrompt();
        }

-        private async void PauseEmulation_Click(object sender, RoutedEventArgs e)
+        private void PauseEmulation_Click(object sender, RoutedEventArgs e)
        {
-            await Task.Run(() =>
-            {
-                Window.ViewModel.AppHost?.Pause();
-            });
+            Window.ViewModel.AppHost?.Pause();
        }

-        private async void ResumeEmulation_Click(object sender, RoutedEventArgs e)
+        private void ResumeEmulation_Click(object sender, RoutedEventArgs e)
        {
-            await Task.Run(() =>
-            {
-                Window.ViewModel.AppHost?.Resume();
-            });
+            Window.ViewModel.AppHost?.Resume();
        }

        public async void OpenSettings(object sender, RoutedEventArgs e)
@ -132,13 +125,13 @@ namespace Ryujinx.Ava.UI.Views.Main
            ViewModel.LoadConfigurableHotKeys();
        }

-        public void OpenMiiApplet(object sender, RoutedEventArgs e)
+        public async void OpenMiiApplet(object sender, RoutedEventArgs e)
        {
            string contentPath = ViewModel.ContentManager.GetInstalledContentPath(0x0100000000001009, StorageId.BuiltInSystem, NcaContentType.Program);

            if (!string.IsNullOrEmpty(contentPath))
            {
-                ViewModel.LoadApplication(contentPath, false, "Mii Applet");
+                await ViewModel.LoadApplication(contentPath, false, "Mii Applet");
            }
        }

@ -196,8 +189,7 @@ namespace Ryujinx.Ava.UI.Views.Main
        {
            if (FileAssociationHelper.Install())
            {
-                await ContentDialogHelper.CreateInfoDialog(LocaleManager.Instance[LocaleKeys.DialogInstallFileTypesSuccessMessage],
-                    string.Empty, LocaleManager.Instance[LocaleKeys.InputDialogOk], string.Empty, string.Empty);
+                await ContentDialogHelper.CreateInfoDialog(LocaleManager.Instance[LocaleKeys.DialogInstallFileTypesSuccessMessage], string.Empty, LocaleManager.Instance[LocaleKeys.InputDialogOk], string.Empty, string.Empty);
            }
            else
            {
@ -209,8 +201,7 @@ namespace Ryujinx.Ava.UI.Views.Main
        {
            if (FileAssociationHelper.Uninstall())
            {
-                await ContentDialogHelper.CreateInfoDialog(LocaleManager.Instance[LocaleKeys.DialogUninstallFileTypesSuccessMessage],
-                    string.Empty, LocaleManager.Instance[LocaleKeys.InputDialogOk], string.Empty, string.Empty);
+                await ContentDialogHelper.CreateInfoDialog(LocaleManager.Instance[LocaleKeys.DialogUninstallFileTypesSuccessMessage], string.Empty, LocaleManager.Instance[LocaleKeys.InputDialogOk], string.Empty, string.Empty);
            }
            else
            {
--- a/src/Ryujinx.Ava/UI/Views/Settings/SettingsNetworkView.axaml
+++ b/src/Ryujinx.Ava/UI/Views/Settings/SettingsNetworkView.axaml
@ -23,21 +23,34 @@
                HorizontalAlignment="Stretch"
                Orientation="Vertical"
                Spacing="10">
+                <TextBlock Classes="h1" Text="{locale:Locale SettingsTabNetworkMultiplayer}" />
+                <StackPanel Margin="10,0,0,0" Orientation="Horizontal">
+                    <TextBlock VerticalAlignment="Center"
+                        Text="{locale:Locale MultiplayerMode}"
+                        ToolTip.Tip="{locale:Locale MultiplayerModeTooltip}"
+                        Width="200" />
+                    <ComboBox SelectedIndex="{Binding MultiplayerModeIndex}"
+                        ToolTip.Tip="{locale:Locale MultiplayerModeTooltip}"
+                        HorizontalContentAlignment="Left"
+                        ItemsSource="{Binding MultiplayerModes}"
+                        Width="250" />
+                </StackPanel>
+                <Separator Height="1" />
                <TextBlock Classes="h1" Text="{locale:Locale SettingsTabNetworkConnection}" />
                <CheckBox Margin="10,0,0,0" IsChecked="{Binding EnableInternetAccess}">
                    <TextBlock Text="{locale:Locale SettingsTabSystemEnableInternetAccess}"
-                               ToolTip.Tip="{locale:Locale EnableInternetAccessTooltip}" />
+                        ToolTip.Tip="{locale:Locale EnableInternetAccessTooltip}" />
                </CheckBox>
                <StackPanel Margin="10,0,0,0" Orientation="Horizontal">
                    <TextBlock VerticalAlignment="Center"
-                               Text="{locale:Locale SettingsTabNetworkInterface}"
-                               ToolTip.Tip="{locale:Locale NetworkInterfaceTooltip}"
-                               Width="200" />
+                        Text="{locale:Locale SettingsTabNetworkInterface}"
+                        ToolTip.Tip="{locale:Locale NetworkInterfaceTooltip}"
+                        Width="200" />
                    <ComboBox SelectedIndex="{Binding NetworkInterfaceIndex}"
-                              ToolTip.Tip="{locale:Locale NetworkInterfaceTooltip}"
-                              HorizontalContentAlignment="Left"
-                              ItemsSource="{Binding NetworkInterfaceList}"
-                              Width="250" />
+                        ToolTip.Tip="{locale:Locale NetworkInterfaceTooltip}"
+                        HorizontalContentAlignment="Left"
+                        ItemsSource="{Binding NetworkInterfaceList}"
+                        Width="250" />
                </StackPanel>
            </StackPanel>
        </Border>
--- a/src/Ryujinx.Ava/UI/Views/Settings/SettingsUIView.axaml.cs
+++ b/src/Ryujinx.Ava/UI/Views/Settings/SettingsUIView.axaml.cs
@ -34,7 +34,7 @@ namespace Ryujinx.Ava.UI.Views.Settings
                {
                    var result = await window.StorageProvider.OpenFolderPickerAsync(new FolderPickerOpenOptions
                    {
-                        AllowMultiple = false
+                        AllowMultiple = false,
                    });

                    if (result.Count > 0)
@ -75,9 +75,9 @@ namespace Ryujinx.Ava.UI.Views.Settings
                    {
                        Patterns = new[] { "*.xaml" },
                        AppleUniformTypeIdentifiers = new[] { "com.ryujinx.xaml" },
-                        MimeTypes = new[] { "application/xaml+xml" }
-                    }
-                }
+                        MimeTypes = new[] { "application/xaml+xml" },
+                    },
+                },
            });

            if (result.Count > 0)
--- a/src/Ryujinx.Ava/UI/Views/User/UserProfileImageSelectorView.axaml.cs
+++ b/src/Ryujinx.Ava/UI/Views/User/UserProfileImageSelectorView.axaml.cs
@ -75,9 +75,9 @@ namespace Ryujinx.Ava.UI.Views.User
                    {
                        Patterns = new[] { "*.jpg", "*.jpeg", "*.png", "*.bmp" },
                        AppleUniformTypeIdentifiers = new[] { "public.jpeg", "public.png", "com.microsoft.bmp" },
-                        MimeTypes = new[] { "image/jpeg", "image/png", "image/bmp" }
-                    }
-                }
+                        MimeTypes = new[] { "image/jpeg", "image/png", "image/bmp" },
+                    },
+                },
            });

            if (result.Count > 0)
--- a/src/Ryujinx.Ava/UI/Windows/CheatWindow.axaml
+++ b/src/Ryujinx.Ava/UI/Windows/CheatWindow.axaml
@ -11,6 +11,7 @@
    Height="500"
    MinWidth="500"
    MinHeight="500"
+    x:DataType="window:CheatWindow"
    WindowStartupLocation="CenterOwner"
    mc:Ignorable="d"
    Focusable="True">
@ -40,7 +41,7 @@
            HorizontalAlignment="Center"
            VerticalAlignment="Center"
            LineHeight="18"
-            Text="{ReflectionBinding Heading}"
+            Text="{Binding Heading}"
            TextAlignment="Center"
            TextWrapping="Wrap" />
        <TextBlock
@ -61,7 +62,7 @@
            MinWidth="160"
            HorizontalAlignment="Center"
            VerticalAlignment="Center"
-            Text="{ReflectionBinding BuildId}"
+            Text="{Binding BuildId}"
            IsReadOnly="True" />
        <Border
            Grid.Row="3"
@ -77,7 +78,7 @@
                MinHeight="300"
                HorizontalAlignment="Stretch"
                VerticalAlignment="Stretch"
-                ItemsSource="{ReflectionBinding LoadedCheats}">
+                ItemsSource="{Binding LoadedCheats}">
                <TreeView.Styles>
                    <Styles>
                        <Style Selector="TreeViewItem:empty /template/ ItemsPresenter">
@ -120,18 +121,18 @@
                    Name="SaveButton"
                    MinWidth="90"
                    Margin="5"
-                    Command="{ReflectionBinding Save}"
-                    IsVisible="{ReflectionBinding !NoCheatsFound}">
+                    Command="{Binding Save}"
+                    IsVisible="{Binding !NoCheatsFound}">
                    <TextBlock Text="{locale:Locale SettingsButtonSave}" />
                </Button>
                <Button
                    Name="CancelButton"
                    MinWidth="90"
                    Margin="5"
-                    Command="{ReflectionBinding Close}">
+                    Command="{Binding Close}">
                    <TextBlock Text="{locale:Locale InputDialogCancel}" />
                </Button>
            </DockPanel>
        </DockPanel>
    </Grid>
-</window:StyleableWindow>
+</window:StyleableWindow>
--- a/src/Ryujinx.Ava/UI/Windows/CheatWindow.axaml.cs
+++ b/src/Ryujinx.Ava/UI/Windows/CheatWindow.axaml.cs
@ -17,7 +17,7 @@ namespace Ryujinx.Ava.UI.Windows
        private readonly string _enabledCheatsPath;
        public bool NoCheatsFound { get; }

-        private AvaloniaList<CheatsList> LoadedCheats { get; }
+        public AvaloniaList<CheatsList> LoadedCheats { get; }

        public string Heading { get; }
        public string BuildId { get; }
--- a/src/Ryujinx.Ava/UI/Windows/DownloadableContentManagerWindow.axaml
+++ b/src/Ryujinx.Ava/UI/Windows/DownloadableContentManagerWindow.axaml
@ -39,14 +39,14 @@
                        Name="EnableAllButton"
                        MinWidth="90"
                        Margin="5"
-                        Command="{ReflectionBinding EnableAll}">
+                        Command="{Binding EnableAll}">
                        <TextBlock Text="{locale:Locale DlcManagerEnableAllButton}" />
                    </Button>
                    <Button
                        Name="DisableAllButton"
                        MinWidth="90"
                        Margin="5"
-                        Command="{ReflectionBinding DisableAll}">
+                        Command="{Binding DisableAll}">
                        <TextBlock Text="{locale:Locale DlcManagerDisableAllButton}" />
                    </Button>
                </StackPanel>
@ -157,14 +157,14 @@
                    Name="AddButton"
                    MinWidth="90"
                    Margin="5"
-                    Command="{ReflectionBinding Add}">
+                    Command="{Binding Add}">
                    <TextBlock Text="{locale:Locale SettingsTabGeneralAdd}" />
                </Button>
                <Button
                    Name="RemoveAllButton"
                    MinWidth="90"
                    Margin="5"
-                    Command="{ReflectionBinding RemoveAll}">
+                    Command="{Binding RemoveAll}">
                    <TextBlock Text="{locale:Locale DlcManagerRemoveAllButton}" />
                </Button>
            </StackPanel>
@ -189,4 +189,4 @@
            </StackPanel>
        </Panel>
    </Grid>
-</UserControl>
+</UserControl>
--- a/src/Ryujinx.Ava/UI/Windows/MainWindow.axaml.cs
+++ b/src/Ryujinx.Ava/UI/Windows/MainWindow.axaml.cs
@ -15,6 +15,7 @@ using Ryujinx.Graphics.Gpu;
 using Ryujinx.HLE.FileSystem;
 using Ryujinx.HLE.HOS;
 using Ryujinx.HLE.HOS.Services.Account.Acc;
+using Ryujinx.Input.HLE;
 using Ryujinx.Input.SDL2;
 using Ryujinx.Modules;
 using Ryujinx.Ui.App.Common;
@ -24,8 +25,8 @@ using Ryujinx.Ui.Common.Helper;
 using System;
 using System.IO;
 using System.Runtime.Versioning;
+using System.Threading;
 using System.Threading.Tasks;
-using InputManager = Ryujinx.Input.HLE.InputManager;

 namespace Ryujinx.Ava.UI.Windows
 {
@ -79,35 +80,11 @@ namespace Ryujinx.Ava.UI.Windows

            if (Program.PreviewerDetached)
            {
-                Initialize();
-
                InputManager = new InputManager(new AvaloniaKeyboardDriver(this), new SDL2GamepadDriver());

-                ViewModel.Initialize(
-                    ContentManager,
-                    StorageProvider,
-                    ApplicationLibrary,
-                    VirtualFileSystem,
-                    AccountManager,
-                    InputManager,
-                    _userChannelPersistence,
-                    LibHacHorizonManager,
-                    UiHandler,
-                    ShowLoading,
-                    SwitchToGameControl,
-                    SetMainContent,
-                    this);
-
-                ViewModel.RefreshFirmwareStatus();
-
-                LoadGameList();
-
                this.GetObservable(IsActiveProperty).Subscribe(IsActiveChanged);
                this.ScalingChanged += OnScalingChanged;
            }
-
-            ApplicationLibrary.ApplicationCountUpdated += ApplicationLibrary_ApplicationCountUpdated;
-            ApplicationLibrary.ApplicationAdded += ApplicationLibrary_ApplicationAdded;
        }

        protected override void OnApplyTemplate(TemplateAppliedEventArgs e)
@ -122,36 +99,17 @@ namespace Ryujinx.Ava.UI.Windows
            ViewModel.IsActive = obj;
        }

-        public void LoadGameList()
-        {
-            if (_isLoading)
-            {
-                return;
-            }
-
-            _isLoading = true;
-
-            LoadApplications();
-
-            _isLoading = false;
-        }
-
        private void OnScalingChanged(object sender, EventArgs e)
        {
            Program.DesktopScaleFactor = this.RenderScaling;
        }

-        public void AddApplication(ApplicationData applicationData)
-        {
-            Dispatcher.UIThread.InvokeAsync(() =>
-            {
-                ViewModel.Applications.Add(applicationData);
-            });
-        }
-
        private void ApplicationLibrary_ApplicationAdded(object sender, ApplicationAddedEventArgs e)
        {
-            AddApplication(e.AppData);
+            Dispatcher.UIThread.Post(() =>
+            {
+                ViewModel.Applications.Add(e.AppData);
+            });
        }

        private void ApplicationLibrary_ApplicationCountUpdated(object sender, ApplicationCountUpdatedEventArgs e)
@ -183,7 +141,7 @@ namespace Ryujinx.Ava.UI.Windows

                string path = new FileInfo(args.Application.Path).FullName;

-                ViewModel.LoadApplication(path);
+                ViewModel.LoadApplication(path).Wait();
            }

            args.Handled = true;
@ -202,13 +160,10 @@ namespace Ryujinx.Ava.UI.Windows
            ViewModel.ShowContent = true;
            ViewModel.IsLoadingIndeterminate = false;

-            Dispatcher.UIThread.InvokeAsync(() =>
+            if (startFullscreen && ViewModel.WindowState != WindowState.FullScreen)
            {
-                if (startFullscreen && ViewModel.WindowState != WindowState.FullScreen)
-                {
-                    ViewModel.ToggleFullscreen();
-                }
-            });
+                ViewModel.ToggleFullscreen();
+            }
        }

        public void ShowLoading(bool startFullscreen = false)
@ -217,13 +172,10 @@ namespace Ryujinx.Ava.UI.Windows
            ViewModel.ShowLoadProgress = true;
            ViewModel.IsLoadingIndeterminate = true;

-            Dispatcher.UIThread.InvokeAsync(() =>
+            if (startFullscreen && ViewModel.WindowState != WindowState.FullScreen)
            {
-                if (startFullscreen && ViewModel.WindowState != WindowState.FullScreen)
-                {
-                    ViewModel.ToggleFullscreen();
-                }
-            });
+                ViewModel.ToggleFullscreen();
+            }
        }

        private void Initialize()
@ -251,11 +203,11 @@ namespace Ryujinx.Ava.UI.Windows

            VirtualFileSystem.ReloadKeySet();

-            ApplicationHelper.Initialize(VirtualFileSystem, AccountManager, LibHacHorizonManager.RyujinxClient, this);
+            ApplicationHelper.Initialize(VirtualFileSystem, AccountManager, LibHacHorizonManager.RyujinxClient);
        }

        [SupportedOSPlatform("linux")]
-        private static async void ShowVmMaxMapCountWarning()
+        private static async Task ShowVmMaxMapCountWarning()
        {
            LocaleManager.Instance.UpdateAndGetDynamicValue(LocaleKeys.LinuxVmMaxMapCountWarningTextSecondary,
                LinuxHelper.VmMaxMapCount, LinuxHelper.RecommendedVmMaxMapCount);
@ -267,7 +219,7 @@ namespace Ryujinx.Ava.UI.Windows
        }

        [SupportedOSPlatform("linux")]
-        private static async void ShowVmMaxMapCountDialog()
+        private static async Task ShowVmMaxMapCountDialog()
        {
            LocaleManager.Instance.UpdateAndGetDynamicValue(LocaleKeys.LinuxVmMaxMapCountDialogTextPrimary,
                LinuxHelper.RecommendedVmMaxMapCount);
@ -313,33 +265,46 @@ namespace Ryujinx.Ava.UI.Windows

        private void CheckLaunchState()
        {
-            if (ShowKeyErrorOnLoad)
-            {
-                ShowKeyErrorOnLoad = false;
-
-                Dispatcher.UIThread.Post(async () => await
-                    UserErrorDialog.ShowUserErrorDialog(UserError.NoKeys));
-            }
-
            if (OperatingSystem.IsLinux() && LinuxHelper.VmMaxMapCount < LinuxHelper.RecommendedVmMaxMapCount)
            {
                Logger.Warning?.Print(LogClass.Application, $"The value of vm.max_map_count is lower than {LinuxHelper.RecommendedVmMaxMapCount}. ({LinuxHelper.VmMaxMapCount})");

                if (LinuxHelper.PkExecPath is not null)
                {
-                    Dispatcher.UIThread.Post(ShowVmMaxMapCountDialog);
+                    Dispatcher.UIThread.Post(async () =>
+                    {
+                        if (OperatingSystem.IsLinux())
+                        {
+                            await ShowVmMaxMapCountDialog();
+                        }
+                    });
                }
                else
                {
-                    Dispatcher.UIThread.Post(ShowVmMaxMapCountWarning);
+                    Dispatcher.UIThread.Post(async () =>
+                    {
+                        if (OperatingSystem.IsLinux())
+                        {
+                            await ShowVmMaxMapCountWarning();
+                        }
+                    });
                }
            }

-            if (_deferLoad)
+            if (!ShowKeyErrorOnLoad)
            {
-                _deferLoad = false;
+                if (_deferLoad)
+                {
+                    _deferLoad = false;

-                ViewModel.LoadApplication(_launchPath, _startFullscreen);
+                    ViewModel.LoadApplication(_launchPath, _startFullscreen).Wait();
+                }
+            }
+            else
+            {
+                ShowKeyErrorOnLoad = false;
+
+                Dispatcher.UIThread.Post(async () => await UserErrorDialog.ShowUserErrorDialog(UserError.NoKeys));
            }

            if (ConfigurationState.Instance.CheckUpdatesOnStart.Value && Updater.CanUpdate(false))
@ -372,7 +337,7 @@ namespace Ryujinx.Ava.UI.Windows
            ViewModel.WindowHeight = ConfigurationState.Instance.Ui.WindowStartup.WindowSizeHeight * Program.WindowScaleFactor;
            ViewModel.WindowWidth = ConfigurationState.Instance.Ui.WindowStartup.WindowSizeWidth * Program.WindowScaleFactor;

-            ViewModel.WindowState = ConfigurationState.Instance.Ui.WindowStartup.WindowMaximized.Value is true ? WindowState.Maximized : WindowState.Normal;
+            ViewModel.WindowState = ConfigurationState.Instance.Ui.WindowStartup.WindowMaximized.Value ? WindowState.Maximized : WindowState.Normal;

            if (CheckScreenBounds(savedPoint))
            {
@ -415,6 +380,30 @@ namespace Ryujinx.Ava.UI.Windows
        {
            base.OnOpened(e);

+            Initialize();
+
+            ViewModel.Initialize(
+                ContentManager,
+                StorageProvider,
+                ApplicationLibrary,
+                VirtualFileSystem,
+                AccountManager,
+                InputManager,
+                _userChannelPersistence,
+                LibHacHorizonManager,
+                UiHandler,
+                ShowLoading,
+                SwitchToGameControl,
+                SetMainContent,
+                this);
+
+            ApplicationLibrary.ApplicationCountUpdated += ApplicationLibrary_ApplicationCountUpdated;
+            ApplicationLibrary.ApplicationAdded += ApplicationLibrary_ApplicationAdded;
+
+            ViewModel.RefreshFirmwareStatus();
+
+            LoadApplications();
+
            CheckLaunchState();
        }

@ -514,18 +503,15 @@ namespace Ryujinx.Ava.UI.Windows
            });
        }

-        public async void LoadApplications()
+        public void LoadApplications()
        {
-            await Dispatcher.UIThread.InvokeAsync(() =>
-            {
-                ViewModel.Applications.Clear();
+            ViewModel.Applications.Clear();

-                StatusBarView.LoadProgressBar.IsVisible = true;
-                ViewModel.StatusBarProgressMaximum = 0;
-                ViewModel.StatusBarProgressValue = 0;
+            StatusBarView.LoadProgressBar.IsVisible = true;
+            ViewModel.StatusBarProgressMaximum = 0;
+            ViewModel.StatusBarProgressValue = 0;

-                LocaleManager.Instance.UpdateAndGetDynamicValue(LocaleKeys.StatusBarGamesLoaded, 0, 0);
-            });
+            LocaleManager.Instance.UpdateAndGetDynamicValue(LocaleKeys.StatusBarGamesLoaded, 0, 0);

            ReloadGameList();
        }
@ -558,9 +544,17 @@ namespace Ryujinx.Ava.UI.Windows

            _isLoading = true;

-            ApplicationLibrary.LoadApplications(ConfigurationState.Instance.Ui.GameDirs.Value, ConfigurationState.Instance.System.Language);
+            Thread applicationLibraryThread = new(() =>
+            {
+                ApplicationLibrary.LoadApplications(ConfigurationState.Instance.Ui.GameDirs, ConfigurationState.Instance.System.Language);

-            _isLoading = false;
+                _isLoading = false;
+            })
+            {
+                Name = "GUI.ApplicationLibraryThread",
+                IsBackground = true,
+            };
+            applicationLibraryThread.Start();
        }
    }
 }
--- a/src/Ryujinx.Ava/UI/Windows/StyleableWindow.cs
+++ b/src/Ryujinx.Ava/UI/Windows/StyleableWindow.cs
@ -3,7 +3,6 @@ using Avalonia.Controls.Primitives;
 using Avalonia.Media.Imaging;
 using Avalonia.Platform;
 using Ryujinx.Ui.Common.Configuration;
-using System;
 using System.IO;
 using System.Reflection;

@ -25,11 +24,6 @@ namespace Ryujinx.Ava.UI.Windows
            IconImage = new Bitmap(stream);
        }

-        protected override void OnOpened(EventArgs e)
-        {
-            base.OnOpened(e);
-        }
-
        protected override void OnApplyTemplate(TemplateAppliedEventArgs e)
        {
            base.OnApplyTemplate(e);
--- a/src/Ryujinx.Common/Collections/IntervalTree.cs
+++ b/src/Ryujinx.Common/Collections/IntervalTree.cs
@ -192,7 +192,7 @@ namespace Ryujinx.Common.Collections
                    {
                        if (start.CompareTo(overlap.End) < 0)
                        {
-                            if (overlaps.Length >= overlapCount)
+                            if (overlaps.Length <= overlapCount)
                            {
                                Array.Resize(ref overlaps, overlapCount + ArrayGrowthSize);
                            }
--- a/src/Ryujinx.Common/Configuration/Multiplayer/MultiplayerMode.cs
+++ b/src/Ryujinx.Common/Configuration/Multiplayer/MultiplayerMode.cs
@ -0,0 +1,7 @@
+namespace Ryujinx.Common.Configuration.Multiplayer
+{
+    public enum MultiplayerMode
+    {
+        Disabled,
+    }
+}
--- a/src/Ryujinx.Common/Memory/StructArrayHelpers.cs
+++ b/src/Ryujinx.Common/Memory/StructArrayHelpers.cs
@ -791,5 +791,34 @@ namespace Ryujinx.Common.Memory
        [Pure]
        public Span<T> AsSpan() => MemoryMarshal.CreateSpan(ref _e0, Length);
    }
+
+    public struct Array140<T> : IArray<T> where T : unmanaged
+    {
+        T _e0;
+        Array64<T> _other;
+        Array64<T> _other2;
+        Array11<T> _other3;
+        public readonly int Length => 140;
+        public ref T this[int index] => ref AsSpan()[index];
+
+        [Pure]
+        public Span<T> AsSpan() => MemoryMarshal.CreateSpan(ref _e0, Length);
+    }
+
+    public struct Array384<T> : IArray<T> where T : unmanaged
+    {
+        T _e0;
+        Array64<T> _other;
+        Array64<T> _other2;
+        Array64<T> _other3;
+        Array64<T> _other4;
+        Array64<T> _other5;
+        Array63<T> _other6;
+        public readonly int Length => 384;
+        public ref T this[int index] => ref AsSpan()[index];
+
+        [Pure]
+        public Span<T> AsSpan() => MemoryMarshal.CreateSpan(ref _e0, Length);
+    }
 }
 #pragma warning restore CS0169, IDE0051
--- a/src/Ryujinx.Common/Utilities/NetworkHelpers.cs
+++ b/src/Ryujinx.Common/Utilities/NetworkHelpers.cs
@ -1,4 +1,6 @@
-using System.Net.NetworkInformation;
+using System.Buffers.Binary;
+using System.Net;
+using System.Net.NetworkInformation;

 namespace Ryujinx.Common.Utilities
 {
@ -62,5 +64,15 @@ namespace Ryujinx.Common.Utilities

            return (targetProperties, targetAddressInfo);
        }
+
+        public static uint ConvertIpv4Address(IPAddress ipAddress)
+        {
+            return BinaryPrimitives.ReadUInt32BigEndian(ipAddress.GetAddressBytes());
+        }
+
+        public static uint ConvertIpv4Address(string ipAddress)
+        {
+            return ConvertIpv4Address(IPAddress.Parse(ipAddress));
+        }
    }
 }
--- a/src/Ryujinx.Cpu/AppleHv/HvAddressSpace.cs
+++ b/src/Ryujinx.Cpu/AppleHv/HvAddressSpace.cs
@ -1,9 +1,11 @@
 using Ryujinx.Cpu.AppleHv.Arm;
 using Ryujinx.Memory;
 using System;
+using System.Runtime.Versioning;

 namespace Ryujinx.Cpu.AppleHv
 {
+    [SupportedOSPlatform("macos")]
    class HvAddressSpace : IDisposable
    {
        private const ulong KernelRegionBase = unchecked((ulong)-(1L << 39));
--- a/src/Ryujinx.Cpu/AppleHv/HvAddressSpaceRange.cs
+++ b/src/Ryujinx.Cpu/AppleHv/HvAddressSpaceRange.cs
@ -2,10 +2,12 @@ using Ryujinx.Cpu.AppleHv.Arm;
 using System;
 using System.Diagnostics;
 using System.Runtime.InteropServices;
+using System.Runtime.Versioning;
 using System.Threading;

 namespace Ryujinx.Cpu.AppleHv
 {
+    [SupportedOSPlatform("macos")]
    class HvAddressSpaceRange : IDisposable
    {
        private const ulong AllocationGranule = 1UL << 14;
--- a/src/Ryujinx.Cpu/AppleHv/HvApi.cs
+++ b/src/Ryujinx.Cpu/AppleHv/HvApi.cs
@ -1,5 +1,6 @@
 using System;
 using System.Runtime.InteropServices;
+using System.Runtime.Versioning;

 namespace Ryujinx.Cpu.AppleHv
 {
@ -12,10 +13,18 @@ namespace Ryujinx.Cpu.AppleHv
 #pragma warning restore CS0649
    }

+    enum HvExitReason : uint
+    {
+        Canceled,
+        Exception,
+        VTimerActivated,
+        Unknown,
+    }
+
    struct HvVcpuExit
    {
 #pragma warning disable CS0649 // Field is never assigned to
-        public uint Reason;
+        public HvExitReason Reason;
        public HvVcpuExitException Exception;
 #pragma warning restore CS0649
    }
@ -255,6 +264,7 @@ namespace Ryujinx.Cpu.AppleHv
        }
    }

+    [SupportedOSPlatform("macos")]
    static partial class HvApi
    {
        public const string LibraryName = "/System/Library/Frameworks/Hypervisor.framework/Hypervisor";
--- a/src/Ryujinx.Cpu/AppleHv/HvCpuContext.cs
+++ b/src/Ryujinx.Cpu/AppleHv/HvCpuContext.cs
@ -1,7 +1,9 @@
 using ARMeilleure.Memory;
+using System.Runtime.Versioning;

 namespace Ryujinx.Cpu.AppleHv
 {
+    [SupportedOSPlatform("macos")]
    class HvCpuContext : ICpuContext
    {
        private readonly ITickSource _tickSource;
--- a/src/Ryujinx.Cpu/AppleHv/HvEngine.cs
+++ b/src/Ryujinx.Cpu/AppleHv/HvEngine.cs
@ -1,7 +1,9 @@
 using ARMeilleure.Memory;
+using System.Runtime.Versioning;

 namespace Ryujinx.Cpu.AppleHv
 {
+    [SupportedOSPlatform("macos")]
    public class HvEngine : ICpuEngine
    {
        private readonly ITickSource _tickSource;
--- a/src/Ryujinx.Cpu/AppleHv/HvExecutionContext.cs
+++ b/src/Ryujinx.Cpu/AppleHv/HvExecutionContext.cs
@ -2,9 +2,12 @@ using ARMeilleure.State;
 using Ryujinx.Cpu.AppleHv.Arm;
 using Ryujinx.Memory.Tracking;
 using System;
+using System.Runtime.Versioning;
+using System.Threading;

 namespace Ryujinx.Cpu.AppleHv
 {
+    [SupportedOSPlatform("macos")]
    class HvExecutionContext : IExecutionContext
    {
        /// <inheritdoc/>
@ -67,6 +70,8 @@ namespace Ryujinx.Cpu.AppleHv

        private readonly ExceptionCallbacks _exceptionCallbacks;

+        private int _interruptRequested;
+
        public HvExecutionContext(ICounter counter, ExceptionCallbacks exceptionCallbacks)
        {
            _counter = counter;
@ -111,7 +116,15 @@ namespace Ryujinx.Cpu.AppleHv
        /// <inheritdoc/>
        public void RequestInterrupt()
        {
-            _impl.RequestInterrupt();
+            if (Interlocked.Exchange(ref _interruptRequested, 1) == 0 && _impl is HvExecutionContextVcpu impl)
+            {
+                impl.RequestInterrupt();
+            }
+        }
+
+        private bool GetAndClearInterruptRequested()
+        {
+            return Interlocked.Exchange(ref _interruptRequested, 0) != 0;
        }

        /// <inheritdoc/>
@ -131,9 +144,9 @@ namespace Ryujinx.Cpu.AppleHv
            {
                HvApi.hv_vcpu_run(vcpu.Handle).ThrowOnError();

-                uint reason = vcpu.ExitInfo->Reason;
+                HvExitReason reason = vcpu.ExitInfo->Reason;

-                if (reason == 1)
+                if (reason == HvExitReason.Exception)
                {
                    uint hvEsr = (uint)vcpu.ExitInfo->Exception.Syndrome;
                    ExceptionClass hvEc = (ExceptionClass)(hvEsr >> 26);
@ -146,14 +159,22 @@ namespace Ryujinx.Cpu.AppleHv
                    address = SynchronousException(memoryManager, ref vcpu);
                    HvApi.hv_vcpu_set_reg(vcpu.Handle, HvReg.PC, address).ThrowOnError();
                }
-                else if (reason == 0)
+                else if (reason == HvExitReason.Canceled || reason == HvExitReason.VTimerActivated)
                {
-                    if (_impl.GetAndClearInterruptRequested())
+                    if (GetAndClearInterruptRequested())
                    {
                        ReturnToPool(vcpu);
                        InterruptHandler();
                        vcpu = RentFromPool(memoryManager.AddressSpace, vcpu);
                    }
+
+                    if (reason == HvExitReason.VTimerActivated)
+                    {
+                        vcpu.EnableAndUpdateVTimer();
+
+                        // Unmask VTimer interrupts.
+                        HvApi.hv_vcpu_set_vtimer_mask(vcpu.Handle, false).ThrowOnError();
+                    }
                }
                else
                {
--- a/src/Ryujinx.Cpu/AppleHv/HvExecutionContextShadow.cs
+++ b/src/Ryujinx.Cpu/AppleHv/HvExecutionContextShadow.cs
@ -46,14 +46,5 @@ namespace Ryujinx.Cpu.AppleHv
        {
            _v[index] = value;
        }
-
-        public void RequestInterrupt()
-        {
-        }
-
-        public bool GetAndClearInterruptRequested()
-        {
-            return false;
-        }
    }
 }
--- a/src/Ryujinx.Cpu/AppleHv/HvExecutionContextVcpu.cs
+++ b/src/Ryujinx.Cpu/AppleHv/HvExecutionContextVcpu.cs
@ -2,10 +2,11 @@ using ARMeilleure.State;
 using Ryujinx.Memory;
 using System;
 using System.Runtime.InteropServices;
-using System.Threading;
+using System.Runtime.Versioning;

 namespace Ryujinx.Cpu.AppleHv
 {
+    [SupportedOSPlatform("macos")]
    class HvExecutionContextVcpu : IHvExecutionContext
    {
        private static readonly MemoryBlock _setSimdFpRegFuncMem;
@ -135,7 +136,6 @@ namespace Ryujinx.Cpu.AppleHv
        }

        private readonly ulong _vcpu;
-        private int _interruptRequested;

        public HvExecutionContextVcpu(ulong vcpu)
        {
@ -181,16 +181,8 @@ namespace Ryujinx.Cpu.AppleHv

        public void RequestInterrupt()
        {
-            if (Interlocked.Exchange(ref _interruptRequested, 1) == 0)
-            {
-                ulong vcpu = _vcpu;
-                HvApi.hv_vcpus_exit(ref vcpu, 1);
-            }
-        }
-
-        public bool GetAndClearInterruptRequested()
-        {
-            return Interlocked.Exchange(ref _interruptRequested, 0) != 0;
+            ulong vcpu = _vcpu;
+            HvApi.hv_vcpus_exit(ref vcpu, 1);
        }
    }
 }
--- a/src/Ryujinx.Cpu/AppleHv/HvMemoryBlockAllocation.cs
+++ b/src/Ryujinx.Cpu/AppleHv/HvMemoryBlockAllocation.cs
@ -1,8 +1,10 @@
 using Ryujinx.Memory;
 using System;
+using System.Runtime.Versioning;

 namespace Ryujinx.Cpu.AppleHv
 {
+    [SupportedOSPlatform("macos")]
    readonly struct HvMemoryBlockAllocation : IDisposable
    {
        private readonly HvMemoryBlockAllocator _owner;
--- a/src/Ryujinx.Cpu/AppleHv/HvMemoryBlockAllocator.cs
+++ b/src/Ryujinx.Cpu/AppleHv/HvMemoryBlockAllocator.cs
@ -1,7 +1,9 @@
 using Ryujinx.Memory;
+using System.Runtime.Versioning;

 namespace Ryujinx.Cpu.AppleHv
 {
+    [SupportedOSPlatform("macos")]
    class HvMemoryBlockAllocator : PrivateMemoryAllocatorImpl<HvMemoryBlockAllocator.Block>
    {
        public class Block : PrivateMemoryAllocator.Block
--- a/src/Ryujinx.Cpu/AppleHv/HvMemoryManager.cs
+++ b/src/Ryujinx.Cpu/AppleHv/HvMemoryManager.cs
@ -7,6 +7,7 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+using System.Runtime.Versioning;
 using System.Threading;

 namespace Ryujinx.Cpu.AppleHv
@ -14,6 +15,7 @@ namespace Ryujinx.Cpu.AppleHv
    /// <summary>
    /// Represents a CPU memory manager which maps guest virtual memory directly onto the Hypervisor page table.
    /// </summary>
+    [SupportedOSPlatform("macos")]
    public class HvMemoryManager : MemoryManagerBase, IMemoryManager, IVirtualMemoryManagerTracked, IWritableBlock
    {
        public const int PageBits = 12;
--- a/src/Ryujinx.Cpu/AppleHv/HvVcpu.cs
+++ b/src/Ryujinx.Cpu/AppleHv/HvVcpu.cs
@ -1,7 +1,15 @@
+using System.Diagnostics;
+using System.Runtime.Versioning;
+
 namespace Ryujinx.Cpu.AppleHv
 {
+    [SupportedOSPlatform("macos")]
    unsafe class HvVcpu
    {
+        private const ulong InterruptIntervalNs = 16 * 1000000; // 16 ms
+
+        private static ulong _interruptTimeDeltaTicks = 0;
+
        public readonly ulong Handle;
        public readonly HvVcpuExit* ExitInfo;
        public readonly IHvExecutionContext ShadowContext;
@ -21,5 +29,28 @@ namespace Ryujinx.Cpu.AppleHv
            NativeContext = nativeContext;
            IsEphemeral = isEphemeral;
        }
+
+        public void EnableAndUpdateVTimer()
+        {
+            // We need to ensure interrupts will be serviced,
+            // and for that we set up the VTime to trigger an interrupt at fixed intervals.
+
+            ulong deltaTicks = _interruptTimeDeltaTicks;
+
+            if (deltaTicks == 0)
+            {
+                // Calculate our time delta in ticks based on the current clock frequency.
+
+                int result = TimeApi.mach_timebase_info(out var timeBaseInfo);
+
+                Debug.Assert(result == 0);
+
+                deltaTicks = ((InterruptIntervalNs * timeBaseInfo.Denom) + (timeBaseInfo.Numer - 1)) / timeBaseInfo.Numer;
+                _interruptTimeDeltaTicks = deltaTicks;
+            }
+
+            HvApi.hv_vcpu_set_sys_reg(Handle, HvSysReg.CNTV_CTL_EL0, 1).ThrowOnError();
+            HvApi.hv_vcpu_set_sys_reg(Handle, HvSysReg.CNTV_CVAL_EL0, TimeApi.mach_absolute_time() + deltaTicks).ThrowOnError();
+        }
    }
 }
--- a/src/Ryujinx.Cpu/AppleHv/HvVcpuPool.cs
+++ b/src/Ryujinx.Cpu/AppleHv/HvVcpuPool.cs
@ -1,8 +1,10 @@
 using System;
+using System.Runtime.Versioning;
 using System.Threading;

 namespace Ryujinx.Cpu.AppleHv
 {
+    [SupportedOSPlatform("macos")]
    class HvVcpuPool
    {
        // Since there's a limit on the number of VCPUs we can create,
@ -81,6 +83,8 @@ namespace Ryujinx.Cpu.AppleHv

            HvVcpu vcpu = new(vcpuHandle, exitInfo, shadowContext, nativeContext, isEphemeral);

+            vcpu.EnableAndUpdateVTimer();
+
            return vcpu;
        }

--- a/src/Ryujinx.Cpu/AppleHv/HvVm.cs
+++ b/src/Ryujinx.Cpu/AppleHv/HvVm.cs
@ -1,8 +1,10 @@
 using Ryujinx.Memory;
 using System;
+using System.Runtime.Versioning;

 namespace Ryujinx.Cpu.AppleHv
 {
+    [SupportedOSPlatform("macos")]
    static class HvVm
    {
        // This alignment allows us to use larger blocks on the page table.
--- a/src/Ryujinx.Cpu/AppleHv/IHvExecutionContext.cs
+++ b/src/Ryujinx.Cpu/AppleHv/IHvExecutionContext.cs
@ -2,7 +2,7 @@ using ARMeilleure.State;

 namespace Ryujinx.Cpu.AppleHv
 {
-    public interface IHvExecutionContext
+    interface IHvExecutionContext
    {
        ulong Pc { get; set; }
        ulong ElrEl1 { get; set; }
@ -39,8 +39,5 @@ namespace Ryujinx.Cpu.AppleHv
                SetV(i, context.GetV(i));
            }
        }
-
-        void RequestInterrupt();
-        bool GetAndClearInterruptRequested();
    }
 }
--- a/src/Ryujinx.Cpu/AppleHv/TimeApi.cs
+++ b/src/Ryujinx.Cpu/AppleHv/TimeApi.cs
@ -0,0 +1,21 @@
+using System.Runtime.InteropServices;
+using System.Runtime.Versioning;
+
+namespace Ryujinx.Cpu.AppleHv
+{
+    struct MachTimebaseInfo
+    {
+        public uint Numer;
+        public uint Denom;
+    }
+
+    [SupportedOSPlatform("macos")]
+    static partial class TimeApi
+    {
+        [LibraryImport("libc", SetLastError = true)]
+        public static partial ulong mach_absolute_time();
+
+        [LibraryImport("libc", SetLastError = true)]
+        public static partial int mach_timebase_info(out MachTimebaseInfo info);
+    }
+}
--- a/src/Ryujinx.Graphics.GAL/Format.cs
+++ b/src/Ryujinx.Graphics.GAL/Format.cs
@ -335,6 +335,45 @@ namespace Ryujinx.Graphics.GAL
            return 1;
        }

+        /// <summary>
+        /// Checks if the texture format is a depth or depth-stencil format.
+        /// </summary>
+        /// <param name="format">Texture format</param>
+        /// <returns>True if the format is a depth or depth-stencil format, false otherwise</returns>
+        public static bool HasDepth(this Format format)
+        {
+            switch (format)
+            {
+                case Format.D16Unorm:
+                case Format.D24UnormS8Uint:
+                case Format.S8UintD24Unorm:
+                case Format.D32Float:
+                case Format.D32FloatS8Uint:
+                    return true;
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Checks if the texture format is a stencil or depth-stencil format.
+        /// </summary>
+        /// <param name="format">Texture format</param>
+        /// <returns>True if the format is a stencil or depth-stencil format, false otherwise</returns>
+        public static bool HasStencil(this Format format)
+        {
+            switch (format)
+            {
+                case Format.D24UnormS8Uint:
+                case Format.S8UintD24Unorm:
+                case Format.D32FloatS8Uint:
+                case Format.S8Uint:
+                    return true;
+            }
+
+            return false;
+        }
+
        /// <summary>
        /// Checks if the texture format is valid to use as image format.
        /// </summary>
--- a/src/Ryujinx.Graphics.GAL/ResourceLayout.cs
+++ b/src/Ryujinx.Graphics.GAL/ResourceLayout.cs
@ -15,14 +15,6 @@ namespace Ryujinx.Graphics.GAL
        BufferImage,
    }

-    public enum ResourceAccess : byte
-    {
-        None = 0,
-        Read = 1,
-        Write = 2,
-        ReadWrite = Read | Write,
-    }
-
    [Flags]
    public enum ResourceStages : byte
    {
@ -81,19 +73,17 @@ namespace Ryujinx.Graphics.GAL
        public int Binding { get; }
        public ResourceType Type { get; }
        public ResourceStages Stages { get; }
-        public ResourceAccess Access { get; }

-        public ResourceUsage(int binding, ResourceType type, ResourceStages stages, ResourceAccess access)
+        public ResourceUsage(int binding, ResourceType type, ResourceStages stages)
        {
            Binding = binding;
            Type = type;
            Stages = stages;
-            Access = access;
        }

        public override int GetHashCode()
        {
-            return HashCode.Combine(Binding, Type, Stages, Access);
+            return HashCode.Combine(Binding, Type, Stages);
        }

        public override bool Equals(object obj)
@ -103,7 +93,7 @@ namespace Ryujinx.Graphics.GAL

        public bool Equals(ResourceUsage other)
        {
-            return Binding == other.Binding && Type == other.Type && Stages == other.Stages && Access == other.Access;
+            return Binding == other.Binding && Type == other.Type && Stages == other.Stages;
        }

        public static bool operator ==(ResourceUsage left, ResourceUsage right)
--- a/src/Ryujinx.Graphics.Gpu/Engine/Threed/ComputeDraw/VtgAsComputeContext.cs
+++ b/src/Ryujinx.Graphics.Gpu/Engine/Threed/ComputeDraw/VtgAsComputeContext.cs
@ -490,10 +490,11 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed.ComputeDraw
        /// </summary>
        /// <param name="offset">Offset of the range</param>
        /// <param name="size">Size of the range in bytes</param>
+        /// <param name="write">Indicates if the buffer contents will be modified</param>
        /// <returns>Range</returns>
-        public BufferRange GetVertexDataBufferRange(int offset, int size)
+        public BufferRange GetVertexDataBufferRange(int offset, int size, bool write)
        {
-            return new BufferRange(_vertexDataBuffer.Handle, offset, size);
+            return new BufferRange(_vertexDataBuffer.Handle, offset, size, write);
        }

        /// <summary>
@ -501,10 +502,11 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed.ComputeDraw
        /// </summary>
        /// <param name="offset">Offset of the range</param>
        /// <param name="size">Size of the range in bytes</param>
+        /// <param name="write">Indicates if the buffer contents will be modified</param>
        /// <returns>Range</returns>
-        public BufferRange GetGeometryVertexDataBufferRange(int offset, int size)
+        public BufferRange GetGeometryVertexDataBufferRange(int offset, int size, bool write)
        {
-            return new BufferRange(_geometryVertexDataBuffer.Handle, offset, size);
+            return new BufferRange(_geometryVertexDataBuffer.Handle, offset, size, write);
        }

        /// <summary>
@ -512,10 +514,11 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed.ComputeDraw
        /// </summary>
        /// <param name="offset">Offset of the range</param>
        /// <param name="size">Size of the range in bytes</param>
+        /// <param name="write">Indicates if the buffer contents will be modified</param>
        /// <returns>Range</returns>
-        public BufferRange GetGeometryIndexDataBufferRange(int offset, int size)
+        public BufferRange GetGeometryIndexDataBufferRange(int offset, int size, bool write)
        {
-            return new BufferRange(_geometryIndexDataBuffer.Handle, offset, size);
+            return new BufferRange(_geometryIndexDataBuffer.Handle, offset, size, write);
        }

        /// <summary>
--- a/src/Ryujinx.Graphics.Gpu/Engine/Threed/ComputeDraw/VtgAsComputeState.cs
+++ b/src/Ryujinx.Graphics.Gpu/Engine/Threed/ComputeDraw/VtgAsComputeState.cs
@ -202,7 +202,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed.ComputeDraw
            _context.Renderer.Pipeline.SetUniformBuffers(stackalloc[] { new BufferAssignment(vertexInfoBinding, vertexInfoRange) });

            int vertexDataBinding = _vertexAsCompute.Reservations.VertexOutputStorageBufferBinding;
-            BufferRange vertexDataRange = _vacContext.GetVertexDataBufferRange(_vertexDataOffset, _vertexDataSize);
+            BufferRange vertexDataRange = _vacContext.GetVertexDataBufferRange(_vertexDataOffset, _vertexDataSize, write: true);
            _context.Renderer.Pipeline.SetStorageBuffers(stackalloc[] { new BufferAssignment(vertexDataBinding, vertexDataRange) });

            _vacContext.VertexInfoBufferUpdater.Commit();
@ -245,9 +245,9 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed.ComputeDraw
            int geometryVbBinding = _geometryAsCompute.Reservations.GeometryVertexOutputStorageBufferBinding;
            int geometryIbBinding = _geometryAsCompute.Reservations.GeometryIndexOutputStorageBufferBinding;

-            BufferRange vertexDataRange = _vacContext.GetVertexDataBufferRange(_vertexDataOffset, _vertexDataSize);
-            BufferRange vertexBuffer = _vacContext.GetGeometryVertexDataBufferRange(_geometryVertexDataOffset, _geometryVertexDataSize);
-            BufferRange indexBuffer = _vacContext.GetGeometryIndexDataBufferRange(_geometryIndexDataOffset, _geometryIndexDataSize);
+            BufferRange vertexDataRange = _vacContext.GetVertexDataBufferRange(_vertexDataOffset, _vertexDataSize, write: false);
+            BufferRange vertexBuffer = _vacContext.GetGeometryVertexDataBufferRange(_geometryVertexDataOffset, _geometryVertexDataSize, write: true);
+            BufferRange indexBuffer = _vacContext.GetGeometryIndexDataBufferRange(_geometryIndexDataOffset, _geometryIndexDataSize, write: true);

            _context.Renderer.Pipeline.SetStorageBuffers(stackalloc[]
            {
@ -293,8 +293,8 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed.ComputeDraw

            if (_geometryAsCompute != null)
            {
-                BufferRange vertexBuffer = _vacContext.GetGeometryVertexDataBufferRange(_geometryVertexDataOffset, _geometryVertexDataSize);
-                BufferRange indexBuffer = _vacContext.GetGeometryIndexDataBufferRange(_geometryIndexDataOffset, _geometryIndexDataSize);
+                BufferRange vertexBuffer = _vacContext.GetGeometryVertexDataBufferRange(_geometryVertexDataOffset, _geometryVertexDataSize, write: false);
+                BufferRange indexBuffer = _vacContext.GetGeometryIndexDataBufferRange(_geometryIndexDataOffset, _geometryIndexDataSize, write: false);

                _context.Renderer.Pipeline.SetProgram(_vertexPassthroughProgram);
                _context.Renderer.Pipeline.SetIndexBuffer(indexBuffer, IndexType.UInt);
@ -310,7 +310,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed.ComputeDraw
            }
            else
            {
-                BufferRange vertexDataRange = _vacContext.GetVertexDataBufferRange(_vertexDataOffset, _vertexDataSize);
+                BufferRange vertexDataRange = _vacContext.GetVertexDataBufferRange(_vertexDataOffset, _vertexDataSize, write: false);

                _context.Renderer.Pipeline.SetProgram(_vertexPassthroughProgram);
                _context.Renderer.Pipeline.SetStorageBuffers(stackalloc[] { new BufferAssignment(vertexDataBinding, vertexDataRange) });
--- a/src/Ryujinx.Graphics.Gpu/Engine/Threed/DrawManager.cs
+++ b/src/Ryujinx.Graphics.Gpu/Engine/Threed/DrawManager.cs
@ -1,6 +1,7 @@
 using Ryujinx.Graphics.GAL;
 using Ryujinx.Graphics.Gpu.Engine.Threed.ComputeDraw;
 using Ryujinx.Graphics.Gpu.Engine.Types;
+using Ryujinx.Graphics.Gpu.Image;
 using Ryujinx.Graphics.Gpu.Memory;
 using System;

@ -806,25 +807,69 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
                updateFlags |= RenderTargetUpdateFlags.Layered;
            }

-            if (clearDepth || clearStencil)
+            bool clearDS = clearDepth || clearStencil;
+
+            if (clearDS)
            {
                updateFlags |= RenderTargetUpdateFlags.UpdateDepthStencil;
            }

-            engine.UpdateRenderTargetState(updateFlags, singleUse: componentMask != 0 ? index : -1);
-
            // If there is a mismatch on the host clip region and the one explicitly defined by the guest
            // on the screen scissor state, then we need to force only one texture to be bound to avoid
            // host clipping.
            var screenScissorState = _state.State.ScreenScissorState;

+            bool clearAffectedByStencilMask = (_state.State.ClearFlags & 1) != 0;
+            bool clearAffectedByScissor = (_state.State.ClearFlags & 0x100) != 0;
+
+            if (clearDS || componentMask == 15)
+            {
+                // A full clear if scissor is disabled, or it matches the screen scissor state.
+
+                bool fullClear = screenScissorState.X == 0 && screenScissorState.Y == 0;
+
+                if (fullClear && clearAffectedByScissor && _state.State.ScissorState[0].Enable)
+                {
+                    ref var scissorState = ref _state.State.ScissorState[0];
+
+                    fullClear = scissorState.X1 == screenScissorState.X &&
+                        scissorState.Y1 == screenScissorState.Y &&
+                        scissorState.X2 >= screenScissorState.X + screenScissorState.Width &&
+                        scissorState.Y2 >= screenScissorState.Y + screenScissorState.Height;
+                }
+
+                if (fullClear && clearDS)
+                {
+                    // Must clear all aspects of the depth-stencil format.
+
+                    FormatInfo dsFormat = _state.State.RtDepthStencilState.Format.Convert();
+
+                    bool hasDepth = dsFormat.Format.HasDepth();
+                    bool hasStencil = dsFormat.Format.HasStencil();
+
+                    if (hasStencil && (!clearStencil || (clearAffectedByStencilMask && _state.State.StencilTestState.FrontMask != 0xff)))
+                    {
+                        fullClear = false;
+                    }
+                    else if (hasDepth && !clearDepth)
+                    {
+                        fullClear = false;
+                    }
+                }
+
+                if (fullClear)
+                {
+                    updateFlags |= RenderTargetUpdateFlags.DiscardClip;
+                }
+            }
+
+            engine.UpdateRenderTargetState(updateFlags, singleUse: componentMask != 0 ? index : -1);
+
            // Must happen after UpdateRenderTargetState to have up-to-date clip region values.
            bool clipMismatch = (screenScissorState.X | screenScissorState.Y) != 0 ||
                                screenScissorState.Width != _channel.TextureManager.ClipRegionWidth ||
                                screenScissorState.Height != _channel.TextureManager.ClipRegionHeight;

-            bool clearAffectedByStencilMask = (_state.State.ClearFlags & 1) != 0;
-            bool clearAffectedByScissor = (_state.State.ClearFlags & 0x100) != 0;
            bool needsCustomScissor = !clearAffectedByScissor || clipMismatch;

            // Scissor and rasterizer discard also affect clears.
--- a/src/Ryujinx.Graphics.Gpu/Engine/Threed/RenderTargetUpdateFlags.cs
+++ b/src/Ryujinx.Graphics.Gpu/Engine/Threed/RenderTargetUpdateFlags.cs
@ -33,6 +33,11 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
        /// </summary>
        UpdateDepthStencil = 1 << 3,

+        /// <summary>
+        /// Indicates that the data in the clip region can be discarded for the next use.
+        /// </summary>
+        DiscardClip = 1 << 4,
+
        /// <summary>
        /// Default update flags for draw.
        /// </summary>
--- a/src/Ryujinx.Graphics.Gpu/Engine/Threed/StateUpdater.cs
+++ b/src/Ryujinx.Graphics.Gpu/Engine/Threed/StateUpdater.cs
@ -447,6 +447,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
            bool useControl = updateFlags.HasFlag(RenderTargetUpdateFlags.UseControl);
            bool layered = updateFlags.HasFlag(RenderTargetUpdateFlags.Layered);
            bool singleColor = updateFlags.HasFlag(RenderTargetUpdateFlags.SingleColor);
+            bool discard = updateFlags.HasFlag(RenderTargetUpdateFlags.DiscardClip);

            int count = useControl ? rtControl.UnpackCount() : Constants.TotalRenderTargets;

@ -486,6 +487,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
                    memoryManager,
                    colorState,
                    _vtgWritesRtLayer || layered,
+                    discard,
                    samplesInX,
                    samplesInY,
                    sizeHint);
@ -525,6 +527,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
                    dsState,
                    dsSize,
                    _vtgWritesRtLayer || layered,
+                    discard,
                    samplesInX,
                    samplesInY,
                    sizeHint);
--- a/src/Ryujinx.Graphics.Gpu/Image/Texture.cs
+++ b/src/Ryujinx.Graphics.Gpu/Image/Texture.cs
@ -570,6 +570,18 @@ namespace Ryujinx.Graphics.Gpu.Image
            return Group.CheckDirty(this, consume);
        }

+        /// <summary>
+        /// Discards all data for this texture.
+        /// This clears all dirty flags, modified flags, and pending copies from other textures.
+        /// It should be used if the texture data will be fully overwritten by the next use.
+        /// </summary>
+        public void DiscardData()
+        {
+            Group.DiscardData(this);
+
+            _dirty = false;
+        }
+
        /// <summary>
        /// Synchronizes guest and host memory.
        /// This will overwrite the texture data with the texture data on the guest memory, if a CPU
--- a/src/Ryujinx.Graphics.Gpu/Image/TextureCache.cs
+++ b/src/Ryujinx.Graphics.Gpu/Image/TextureCache.cs
@ -311,7 +311,7 @@ namespace Ryujinx.Graphics.Gpu.Image
                flags |= TextureSearchFlags.NoCreate;
            }

-            Texture texture = FindOrCreateTexture(memoryManager, flags, info, 0);
+            Texture texture = FindOrCreateTexture(memoryManager, flags, info, 0, sizeHint: sizeHint);

            texture?.SynchronizeMemory();

@ -324,6 +324,7 @@ namespace Ryujinx.Graphics.Gpu.Image
        /// <param name="memoryManager">GPU memory manager where the texture is mapped</param>
        /// <param name="colorState">Color buffer texture to find or create</param>
        /// <param name="layered">Indicates if the texture might be accessed with a non-zero layer index</param>
+        /// <param name="discard">Indicates that the sizeHint region's data will be overwritten</param>
        /// <param name="samplesInX">Number of samples in the X direction, for MSAA</param>
        /// <param name="samplesInY">Number of samples in the Y direction, for MSAA</param>
        /// <param name="sizeHint">A hint indicating the minimum used size for the texture</param>
@ -332,6 +333,7 @@ namespace Ryujinx.Graphics.Gpu.Image
            MemoryManager memoryManager,
            RtColorState colorState,
            bool layered,
+            bool discard,
            int samplesInX,
            int samplesInY,
            Size sizeHint)
@ -398,7 +400,14 @@ namespace Ryujinx.Graphics.Gpu.Image

            int layerSize = !isLinear ? colorState.LayerSize * 4 : 0;

-            Texture texture = FindOrCreateTexture(memoryManager, TextureSearchFlags.WithUpscale, info, layerSize);
+            var flags = TextureSearchFlags.WithUpscale;
+
+            if (discard)
+            {
+                flags |= TextureSearchFlags.DiscardData;
+            }
+
+            Texture texture = FindOrCreateTexture(memoryManager, flags, info, layerSize, sizeHint: sizeHint);

            texture?.SynchronizeMemory();

@ -412,6 +421,7 @@ namespace Ryujinx.Graphics.Gpu.Image
        /// <param name="dsState">Depth-stencil buffer texture to find or create</param>
        /// <param name="size">Size of the depth-stencil texture</param>
        /// <param name="layered">Indicates if the texture might be accessed with a non-zero layer index</param>
+        /// <param name="discard">Indicates that the sizeHint region's data will be overwritten</param>
        /// <param name="samplesInX">Number of samples in the X direction, for MSAA</param>
        /// <param name="samplesInY">Number of samples in the Y direction, for MSAA</param>
        /// <param name="sizeHint">A hint indicating the minimum used size for the texture</param>
@ -421,6 +431,7 @@ namespace Ryujinx.Graphics.Gpu.Image
            RtDepthStencilState dsState,
            Size3D size,
            bool layered,
+            bool discard,
            int samplesInX,
            int samplesInY,
            Size sizeHint)
@ -465,7 +476,14 @@ namespace Ryujinx.Graphics.Gpu.Image
                target,
                formatInfo);

-            Texture texture = FindOrCreateTexture(memoryManager, TextureSearchFlags.WithUpscale, info, dsState.LayerSize * 4);
+            var flags = TextureSearchFlags.WithUpscale;
+
+            if (discard)
+            {
+                flags |= TextureSearchFlags.DiscardData;
+            }
+
+            Texture texture = FindOrCreateTexture(memoryManager, flags, info, dsState.LayerSize * 4, sizeHint: sizeHint);

            texture?.SynchronizeMemory();

@ -500,6 +518,37 @@ namespace Ryujinx.Graphics.Gpu.Image
            return Math.Clamp(widthAligned - alignment + 1, minimumWidth, widthAligned);
        }

+        /// <summary>
+        /// Determines if texture data should be fully discarded
+        /// based on the size hint region and whether it is set to be discarded.
+        /// </summary>
+        /// <param name="discard">Whether the size hint region should be discarded</param>
+        /// <param name="texture">The texture being discarded</param>
+        /// <param name="sizeHint">A hint indicating the minimum used size for the texture</param>
+        /// <returns>True if the data should be discarded, false otherwise</returns>
+        private static bool ShouldDiscard(bool discard, Texture texture, Size? sizeHint)
+        {
+            return discard &&
+                texture.Info.DepthOrLayers == 1 &&
+                sizeHint != null &&
+                texture.Width <= sizeHint.Value.Width &&
+                texture.Height <= sizeHint.Value.Height;
+        }
+
+        /// <summary>
+        /// Discards texture data if requested and possible.
+        /// </summary>
+        /// <param name="discard">Whether the size hint region should be discarded</param>
+        /// <param name="texture">The texture being discarded</param>
+        /// <param name="sizeHint">A hint indicating the minimum used size for the texture</param>
+        private static void DiscardIfNeeded(bool discard, Texture texture, Size? sizeHint)
+        {
+            if (ShouldDiscard(discard, texture, sizeHint))
+            {
+                texture.DiscardData();
+            }
+        }
+
        /// <summary>
        /// Tries to find an existing texture, or create a new one if not found.
        /// </summary>
@ -507,6 +556,7 @@ namespace Ryujinx.Graphics.Gpu.Image
        /// <param name="flags">The texture search flags, defines texture comparison rules</param>
        /// <param name="info">Texture information of the texture to be found or created</param>
        /// <param name="layerSize">Size in bytes of a single texture layer</param>
+        /// <param name="sizeHint">A hint indicating the minimum used size for the texture</param>
        /// <param name="range">Optional ranges of physical memory where the texture data is located</param>
        /// <returns>The texture</returns>
        public Texture FindOrCreateTexture(
@ -514,9 +564,11 @@ namespace Ryujinx.Graphics.Gpu.Image
            TextureSearchFlags flags,
            TextureInfo info,
            int layerSize = 0,
+            Size? sizeHint = null,
            MultiRange? range = null)
        {
            bool isSamplerTexture = (flags & TextureSearchFlags.ForSampler) != 0;
+            bool discard = (flags & TextureSearchFlags.DiscardData) != 0;

            TextureScaleMode scaleMode = IsUpscaleCompatible(info, (flags & TextureSearchFlags.WithUpscale) != 0);

@ -612,6 +664,8 @@ namespace Ryujinx.Graphics.Gpu.Image

            if (texture != null)
            {
+                DiscardIfNeeded(discard, texture, sizeHint);
+
                texture.SynchronizeMemory();

                return texture;
@ -642,11 +696,14 @@ namespace Ryujinx.Graphics.Gpu.Image
            }

            // Find view compatible matches.
-            int overlapsCount;
+            int overlapsCount = 0;

-            lock (_textures)
+            if (info.Target != Target.TextureBuffer)
            {
-                overlapsCount = _textures.FindOverlaps(range.Value, ref _textureOverlaps);
+                lock (_textures)
+                {
+                    overlapsCount = _textures.FindOverlaps(range.Value, ref _textureOverlaps);
+                }
            }

            if (_overlapInfo.Length != _textureOverlaps.Length)
@ -907,7 +964,7 @@ namespace Ryujinx.Graphics.Gpu.Image

                // We need to synchronize before copying the old view data to the texture,
                // otherwise the copied data would be overwritten by a future synchronization.
-                texture.InitializeData(false, setData);
+                texture.InitializeData(false, setData && !ShouldDiscard(discard, texture, sizeHint));

                texture.Group.InitializeOverlaps();

--- a/src/Ryujinx.Graphics.Gpu/Image/TextureGroup.cs
+++ b/src/Ryujinx.Graphics.Gpu/Image/TextureGroup.cs
@ -79,6 +79,7 @@ namespace Ryujinx.Graphics.Gpu.Image
        private int[] _allOffsets;
        private int[] _sliceSizes;
        private readonly bool _is3D;
+        private readonly bool _isBuffer;
        private bool _hasMipViews;
        private bool _hasLayerViews;
        private readonly int _layers;
@ -118,6 +119,7 @@ namespace Ryujinx.Graphics.Gpu.Image
            _physicalMemory = physicalMemory;

            _is3D = storage.Info.Target == Target.Texture3D;
+            _isBuffer = storage.Info.Target == Target.TextureBuffer;
            _layers = storage.Info.GetSlices();
            _levels = storage.Info.Levels;

@ -278,6 +280,24 @@ namespace Ryujinx.Graphics.Gpu.Image
            return dirty;
        }

+        /// <summary>
+        /// Discards all data for a given texture.
+        /// This clears all dirty flags, modified flags, and pending copies from other textures.
+        /// </summary>
+        /// <param name="texture">The texture being discarded</param>
+        public void DiscardData(Texture texture)
+        {
+            EvaluateRelevantHandles(texture, (baseHandle, regionCount, split) =>
+            {
+                for (int i = 0; i < regionCount; i++)
+                {
+                    TextureGroupHandle group = _handles[baseHandle + i];
+
+                    group.DiscardData();
+                }
+            });
+        }
+
        /// <summary>
        /// Synchronize memory for a given texture.
        /// If overlapping tracking handles are dirty, fully or partially synchronize the texture data.
@ -776,7 +796,11 @@ namespace Ryujinx.Graphics.Gpu.Image
            int targetLayerHandles = _hasLayerViews ? slices : 1;
            int targetLevelHandles = _hasMipViews ? levels : 1;

-            if (_is3D)
+            if (_isBuffer)
+            {
+                return;
+            }
+            else if (_is3D)
            {
                // Future mip levels come after all layers of the last mip level. Each mipmap has less layers (depth) than the last.

@ -1309,7 +1333,11 @@ namespace Ryujinx.Graphics.Gpu.Image
        {
            TextureGroupHandle[] handles;

-            if (!(_hasMipViews || _hasLayerViews))
+            if (_isBuffer)
+            {
+                handles = Array.Empty<TextureGroupHandle>();
+            }
+            else if (!(_hasMipViews || _hasLayerViews))
            {
                // Single dirty region.
                var cpuRegionHandles = new RegionHandle[TextureRange.Count];
--- a/src/Ryujinx.Graphics.Gpu/Image/TextureGroupHandle.cs
+++ b/src/Ryujinx.Graphics.Gpu/Image/TextureGroupHandle.cs
@ -2,7 +2,6 @@
 using Ryujinx.Memory.Tracking;
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using System.Threading;

 namespace Ryujinx.Graphics.Gpu.Image
@ -155,6 +154,24 @@ namespace Ryujinx.Graphics.Gpu.Image
            }
        }

+        /// <summary>
+        /// Discards all data for this handle.
+        /// This clears all dirty flags, modified flags, and pending copies from other handles.
+        /// </summary>
+        public void DiscardData()
+        {
+            Modified = false;
+            DeferredCopy = null;
+
+            foreach (RegionHandle handle in Handles)
+            {
+                if (handle.Dirty)
+                {
+                    handle.Reprotect();
+                }
+            }
+        }
+
        /// <summary>
        /// Calculate a list of which views overlap this handle.
        /// </summary>
--- a/src/Ryujinx.Graphics.Gpu/Image/TextureSearchFlags.cs
+++ b/src/Ryujinx.Graphics.Gpu/Image/TextureSearchFlags.cs
@ -14,5 +14,6 @@ namespace Ryujinx.Graphics.Gpu.Image
        DepthAlias = 1 << 3,
        WithUpscale = 1 << 4,
        NoCreate = 1 << 5,
+        DiscardData = 1 << 6,
    }
 }
--- a/src/Ryujinx.Graphics.Gpu/Shader/DiskCache/DiskCacheHostStorage.cs
+++ b/src/Ryujinx.Graphics.Gpu/Shader/DiskCache/DiskCacheHostStorage.cs
@ -22,7 +22,7 @@ namespace Ryujinx.Graphics.Gpu.Shader.DiskCache
        private const ushort FileFormatVersionMajor = 1;
        private const ushort FileFormatVersionMinor = 2;
        private const uint FileFormatVersionPacked = ((uint)FileFormatVersionMajor << 16) | FileFormatVersionMinor;
-        private const uint CodeGenVersion = 5551;
+        private const uint CodeGenVersion = 5682;

        private const string SharedTocFileName = "shared.toc";
        private const string SharedDataFileName = "shared.data";
--- a/src/Ryujinx.Graphics.Gpu/Shader/ShaderInfoBuilder.cs
+++ b/src/Ryujinx.Graphics.Gpu/Shader/ShaderInfoBuilder.cs
@ -61,7 +61,7 @@ namespace Ryujinx.Graphics.Gpu.Shader
            }

            AddDescriptor(SupportBufferStages, ResourceType.UniformBuffer, UniformSetIndex, 0, 1);
-            AddUsage(SupportBufferStages, ResourceType.UniformBuffer, ResourceAccess.Read, UniformSetIndex, 0, 1);
+            AddUsage(SupportBufferStages, ResourceType.UniformBuffer, UniformSetIndex, 0, 1);

            ResourceReservationCounts rrc = new(!context.Capabilities.SupportsTransformFeedback && tfEnabled, vertexAsCompute);

@ -73,16 +73,16 @@ namespace Ryujinx.Graphics.Gpu.Shader
            // TODO: Handle that better? Maybe we should only set the binding that are really needed on each shader.
            ResourceStages stages = vertexAsCompute ? ResourceStages.Compute | ResourceStages.Vertex : VtgStages;

-            PopulateDescriptorAndUsages(stages, ResourceType.UniformBuffer, ResourceAccess.Read, UniformSetIndex, 1, rrc.ReservedConstantBuffers - 1);
-            PopulateDescriptorAndUsages(stages, ResourceType.StorageBuffer, ResourceAccess.ReadWrite, StorageSetIndex, 0, rrc.ReservedStorageBuffers);
-            PopulateDescriptorAndUsages(stages, ResourceType.BufferTexture, ResourceAccess.Read, TextureSetIndex, 0, rrc.ReservedTextures);
-            PopulateDescriptorAndUsages(stages, ResourceType.BufferImage, ResourceAccess.ReadWrite, ImageSetIndex, 0, rrc.ReservedImages);
+            PopulateDescriptorAndUsages(stages, ResourceType.UniformBuffer, UniformSetIndex, 1, rrc.ReservedConstantBuffers - 1);
+            PopulateDescriptorAndUsages(stages, ResourceType.StorageBuffer, StorageSetIndex, 0, rrc.ReservedStorageBuffers);
+            PopulateDescriptorAndUsages(stages, ResourceType.BufferTexture, TextureSetIndex, 0, rrc.ReservedTextures);
+            PopulateDescriptorAndUsages(stages, ResourceType.BufferImage, ImageSetIndex, 0, rrc.ReservedImages);
        }

-        private void PopulateDescriptorAndUsages(ResourceStages stages, ResourceType type, ResourceAccess access, int setIndex, int start, int count)
+        private void PopulateDescriptorAndUsages(ResourceStages stages, ResourceType type, int setIndex, int start, int count)
        {
            AddDescriptor(stages, type, setIndex, start, count);
-            AddUsage(stages, type, access, setIndex, start, count);
+            AddUsage(stages, type, setIndex, start, count);
        }

        /// <summary>
@ -174,15 +174,14 @@ namespace Ryujinx.Graphics.Gpu.Shader
        /// </summary>
        /// <param name="stages">Shader stages where the resource is used</param>
        /// <param name="type">Type of the resource</param>
-        /// <param name="access">How the resource is accessed by the shader stages where it is used</param>
        /// <param name="setIndex">Descriptor set number where the resource will be bound</param>
        /// <param name="binding">Binding number where the resource will be bound</param>
        /// <param name="count">Number of resources bound at the binding location</param>
-        private void AddUsage(ResourceStages stages, ResourceType type, ResourceAccess access, int setIndex, int binding, int count)
+        private void AddUsage(ResourceStages stages, ResourceType type, int setIndex, int binding, int count)
        {
            for (int index = 0; index < count; index++)
            {
-                _resourceUsages[setIndex].Add(new ResourceUsage(binding + index, type, stages, access));
+                _resourceUsages[setIndex].Add(new ResourceUsage(binding + index, type, stages));
            }
        }

@ -200,8 +199,7 @@ namespace Ryujinx.Graphics.Gpu.Shader
                _resourceUsages[setIndex].Add(new ResourceUsage(
                    buffer.Binding,
                    isStorage ? ResourceType.StorageBuffer : ResourceType.UniformBuffer,
-                    stages,
-                    buffer.Flags.HasFlag(BufferUsageFlags.Write) ? ResourceAccess.ReadWrite : ResourceAccess.Read));
+                    stages));
            }
        }

@ -225,8 +223,7 @@ namespace Ryujinx.Graphics.Gpu.Shader
                _resourceUsages[setIndex].Add(new ResourceUsage(
                    texture.Binding,
                    type,
-                    stages,
-                    texture.Flags.HasFlag(TextureUsageFlags.ImageStore) ? ResourceAccess.ReadWrite : ResourceAccess.Read));
+                    stages));
            }
        }

--- a/src/Ryujinx.Graphics.Gpu/Window.cs
+++ b/src/Ryujinx.Graphics.Gpu/Window.cs
@ -200,7 +200,7 @@ namespace Ryujinx.Graphics.Gpu
            {
                pt.AcquireCallback(_context, pt.UserObj);

-                Image.Texture texture = pt.Cache.FindOrCreateTexture(null, TextureSearchFlags.WithUpscale, pt.Info, 0, pt.Range);
+                Image.Texture texture = pt.Cache.FindOrCreateTexture(null, TextureSearchFlags.WithUpscale, pt.Info, 0, range: pt.Range);

                pt.Cache.Tick();

--- a/src/Ryujinx.Graphics.Shader/CodeGen/Spirv/SpirvGenerator.cs
+++ b/src/Ryujinx.Graphics.Shader/CodeGen/Spirv/SpirvGenerator.cs
@ -89,6 +89,16 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
                context.AddCapability(Capability.DrawParameters);
            }

+            if (context.Definitions.Stage != ShaderStage.Fragment &&
+                context.Definitions.Stage != ShaderStage.Geometry &&
+                context.Definitions.Stage != ShaderStage.Compute &&
+                (context.Info.IoDefinitions.Contains(new IoDefinition(StorageKind.Output, IoVariable.Layer)) ||
+                context.Info.IoDefinitions.Contains(new IoDefinition(StorageKind.Output, IoVariable.ViewportIndex))))
+            {
+                context.AddExtension("SPV_EXT_shader_viewport_index_layer");
+                context.AddCapability(Capability.ShaderViewportIndexLayerEXT);
+            }
+
            if (context.Info.IoDefinitions.Contains(new IoDefinition(StorageKind.Output, IoVariable.ViewportMask)))
            {
                context.AddExtension("SPV_NV_viewport_array2");
@ -277,14 +287,6 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
                        localSizeZ);
                }

-                if (context.Definitions.Stage != ShaderStage.Fragment &&
-                    context.Definitions.Stage != ShaderStage.Geometry &&
-                    context.Definitions.Stage != ShaderStage.Compute &&
-                    context.Info.IoDefinitions.Contains(new IoDefinition(StorageKind.Output, IoVariable.Layer)))
-                {
-                    context.AddCapability(Capability.ShaderLayer);
-                }
-
                if (context.Definitions.TransformFeedbackEnabled && context.Definitions.LastInVertexPipeline)
                {
                    context.AddExecutionMode(spvFunc, ExecutionMode.Xfb);
--- a/src/Ryujinx.Graphics.Shader/Translation/Optimizations/GlobalToStorage.cs
+++ b/src/Ryujinx.Graphics.Shader/Translation/Optimizations/GlobalToStorage.cs
@ -1126,7 +1126,7 @@ namespace Ryujinx.Graphics.Shader.Translation.Optimizations
            // so we want to get the byte offset back, since each one of those word
            // offsets are a new "local variable" which will not match.

-            if (operation.GetSource(0).AsgOp is Operation shiftRightOp &&
+            if (operation.GetSource(1).AsgOp is Operation shiftRightOp &&
                shiftRightOp.Inst == Instruction.ShiftRightU32 &&
                shiftRightOp.GetSource(1).Type == OperandType.Constant &&
                shiftRightOp.GetSource(1).Value == 2)
@ -1158,9 +1158,11 @@ namespace Ryujinx.Graphics.Shader.Translation.Optimizations

        private static bool TryGetLocalMemoryOffset(Operation operation, out int constOffset)
        {
-            if (operation.GetSource(0).Type == OperandType.Constant)
+            Operand offset = operation.GetSource(1);
+
+            if (offset.Type == OperandType.Constant)
            {
-                constOffset = operation.GetSource(0).Value;
+                constOffset = offset.Value;
                return true;
            }

--- a/src/Ryujinx.Graphics.Shader/Translation/TranslatorContext.cs
+++ b/src/Ryujinx.Graphics.Shader/Translation/TranslatorContext.cs
@ -576,6 +576,11 @@ namespace Ryujinx.Graphics.Shader.Translation
            int outputAttributesMask = AttributeUsage.UsedOutputAttributes;
            int layerOutputAttr = LayerOutputAttribute;

+            if (LayerOutputWritten)
+            {
+                outputAttributesMask |= 1 << ((layerOutputAttr - AttributeConsts.UserAttributeBase) / 16);
+            }
+
            OutputTopology outputTopology;
            int maxOutputVertices;

--- a/src/Ryujinx.Graphics.Vulkan/CommandBufferPool.cs
+++ b/src/Ryujinx.Graphics.Vulkan/CommandBufferPool.cs
@ -27,6 +27,7 @@ namespace Ryujinx.Graphics.Vulkan
        {
            public bool InUse;
            public bool InConsumption;
+            public int SubmissionCount;
            public CommandBuffer CommandBuffer;
            public FenceHolder Fence;
            public SemaphoreHolder Semaphore;
@ -193,6 +194,11 @@ namespace Ryujinx.Graphics.Vulkan
            return _commandBuffers[cbIndex].Fence;
        }

+        public int GetSubmissionCount(int cbIndex)
+        {
+            return _commandBuffers[cbIndex].SubmissionCount;
+        }
+
        private int FreeConsumed(bool wait)
        {
            int freeEntry = 0;
@ -282,6 +288,7 @@ namespace Ryujinx.Graphics.Vulkan
                Debug.Assert(entry.CommandBuffer.Handle == cbs.CommandBuffer.Handle);
                entry.InUse = false;
                entry.InConsumption = true;
+                entry.SubmissionCount++;
                _inUseCount--;

                var commandBuffer = entry.CommandBuffer;
--- a/src/Ryujinx.Graphics.Vulkan/DescriptorSetManager.cs
+++ b/src/Ryujinx.Graphics.Vulkan/DescriptorSetManager.cs
@ -6,7 +6,7 @@ namespace Ryujinx.Graphics.Vulkan
 {
    class DescriptorSetManager : IDisposable
    {
-        private const uint DescriptorPoolMultiplier = 16;
+        public const uint MaxSets = 16;

        public class DescriptorPoolHolder : IDisposable
        {
@ -14,36 +14,28 @@ namespace Ryujinx.Graphics.Vulkan
            public Device Device { get; }

            private readonly DescriptorPool _pool;
-            private readonly uint _capacity;
+            private int _freeDescriptors;
            private int _totalSets;
            private int _setsInUse;
            private bool _done;

-            public unsafe DescriptorPoolHolder(Vk api, Device device)
+            public unsafe DescriptorPoolHolder(Vk api, Device device, ReadOnlySpan<DescriptorPoolSize> poolSizes, bool updateAfterBind)
            {
                Api = api;
                Device = device;

-                var poolSizes = new[]
+                foreach (var poolSize in poolSizes)
                {
-                    new DescriptorPoolSize(DescriptorType.UniformBuffer, (1 + Constants.MaxUniformBufferBindings) * DescriptorPoolMultiplier),
-                    new DescriptorPoolSize(DescriptorType.StorageBuffer, Constants.MaxStorageBufferBindings * DescriptorPoolMultiplier),
-                    new DescriptorPoolSize(DescriptorType.CombinedImageSampler, Constants.MaxTextureBindings * DescriptorPoolMultiplier),
-                    new DescriptorPoolSize(DescriptorType.StorageImage, Constants.MaxImageBindings * DescriptorPoolMultiplier),
-                    new DescriptorPoolSize(DescriptorType.UniformTexelBuffer, Constants.MaxTextureBindings * DescriptorPoolMultiplier),
-                    new DescriptorPoolSize(DescriptorType.StorageTexelBuffer, Constants.MaxImageBindings * DescriptorPoolMultiplier),
-                };
-
-                uint maxSets = (uint)poolSizes.Length * DescriptorPoolMultiplier;
-
-                _capacity = maxSets;
+                    _freeDescriptors += (int)poolSize.DescriptorCount;
+                }

                fixed (DescriptorPoolSize* pPoolsSize = poolSizes)
                {
                    var descriptorPoolCreateInfo = new DescriptorPoolCreateInfo
                    {
                        SType = StructureType.DescriptorPoolCreateInfo,
-                        MaxSets = maxSets,
+                        Flags = updateAfterBind ? DescriptorPoolCreateFlags.UpdateAfterBindBit : DescriptorPoolCreateFlags.None,
+                        MaxSets = MaxSets,
                        PoolSizeCount = (uint)poolSizes.Length,
                        PPoolSizes = pPoolsSize,
                    };
@ -52,18 +44,22 @@ namespace Ryujinx.Graphics.Vulkan
                }
            }

-            public DescriptorSetCollection AllocateDescriptorSets(ReadOnlySpan<DescriptorSetLayout> layouts)
+            public unsafe DescriptorSetCollection AllocateDescriptorSets(ReadOnlySpan<DescriptorSetLayout> layouts, int consumedDescriptors)
            {
-                TryAllocateDescriptorSets(layouts, isTry: false, out var dsc);
+                TryAllocateDescriptorSets(layouts, consumedDescriptors, isTry: false, out var dsc);
                return dsc;
            }

-            public bool TryAllocateDescriptorSets(ReadOnlySpan<DescriptorSetLayout> layouts, out DescriptorSetCollection dsc)
+            public bool TryAllocateDescriptorSets(ReadOnlySpan<DescriptorSetLayout> layouts, int consumedDescriptors, out DescriptorSetCollection dsc)
            {
-                return TryAllocateDescriptorSets(layouts, isTry: true, out dsc);
+                return TryAllocateDescriptorSets(layouts, consumedDescriptors, isTry: true, out dsc);
            }

-            private unsafe bool TryAllocateDescriptorSets(ReadOnlySpan<DescriptorSetLayout> layouts, bool isTry, out DescriptorSetCollection dsc)
+            private unsafe bool TryAllocateDescriptorSets(
+                ReadOnlySpan<DescriptorSetLayout> layouts,
+                int consumedDescriptors,
+                bool isTry,
+                out DescriptorSetCollection dsc)
            {
                Debug.Assert(!_done);

@ -84,7 +80,7 @@ namespace Ryujinx.Graphics.Vulkan
                        var result = Api.AllocateDescriptorSets(Device, &descriptorSetAllocateInfo, pDescriptorSets);
                        if (isTry && result == Result.ErrorOutOfPoolMemory)
                        {
-                            _totalSets = (int)_capacity;
+                            _totalSets = (int)MaxSets;
                            _done = true;
                            DestroyIfDone();
                            dsc = default;
@ -95,6 +91,7 @@ namespace Ryujinx.Graphics.Vulkan
                    }
                }

+                _freeDescriptors -= consumedDescriptors;
                _totalSets += layouts.Length;
                _setsInUse += layouts.Length;

@ -109,9 +106,15 @@ namespace Ryujinx.Graphics.Vulkan
                DestroyIfDone();
            }

-            public bool CanFit(int count)
+            public bool CanFit(int setsCount, int descriptorsCount)
            {
-                if (_totalSets + count <= _capacity)
+                // Try to determine if an allocation with the given parameters will succeed.
+                // An allocation may fail if the sets count or descriptors count exceeds the available counts
+                // of the pool.
+                // Not getting that right is not fatal, it will just create a new pool and try again,
+                // but it is less efficient.
+
+                if (_totalSets + setsCount <= MaxSets && _freeDescriptors >= descriptorsCount)
                {
                    return true;
                }
@ -148,46 +151,74 @@ namespace Ryujinx.Graphics.Vulkan
        }

        private readonly Device _device;
-        private DescriptorPoolHolder _currentPool;
+        private readonly DescriptorPoolHolder[] _currentPools;

-        public DescriptorSetManager(Device device)
+        public DescriptorSetManager(Device device, int poolCount)
        {
            _device = device;
+            _currentPools = new DescriptorPoolHolder[poolCount];
        }

-        public Auto<DescriptorSetCollection> AllocateDescriptorSet(Vk api, DescriptorSetLayout layout)
+        public Auto<DescriptorSetCollection> AllocateDescriptorSet(
+            Vk api,
+            DescriptorSetLayout layout,
+            ReadOnlySpan<DescriptorPoolSize> poolSizes,
+            int poolIndex,
+            int consumedDescriptors,
+            bool updateAfterBind)
        {
            Span<DescriptorSetLayout> layouts = stackalloc DescriptorSetLayout[1];
            layouts[0] = layout;
-            return AllocateDescriptorSets(api, layouts);
+            return AllocateDescriptorSets(api, layouts, poolSizes, poolIndex, consumedDescriptors, updateAfterBind);
        }

-        public Auto<DescriptorSetCollection> AllocateDescriptorSets(Vk api, ReadOnlySpan<DescriptorSetLayout> layouts)
+        public Auto<DescriptorSetCollection> AllocateDescriptorSets(
+            Vk api,
+            ReadOnlySpan<DescriptorSetLayout> layouts,
+            ReadOnlySpan<DescriptorPoolSize> poolSizes,
+            int poolIndex,
+            int consumedDescriptors,
+            bool updateAfterBind)
        {
            // If we fail the first time, just create a new pool and try again.
-            if (!GetPool(api, layouts.Length).TryAllocateDescriptorSets(layouts, out var dsc))
+
+            var pool = GetPool(api, poolSizes, poolIndex, layouts.Length, consumedDescriptors, updateAfterBind);
+            if (!pool.TryAllocateDescriptorSets(layouts, consumedDescriptors, out var dsc))
            {
-                dsc = GetPool(api, layouts.Length).AllocateDescriptorSets(layouts);
+                pool = GetPool(api, poolSizes, poolIndex, layouts.Length, consumedDescriptors, updateAfterBind);
+                dsc = pool.AllocateDescriptorSets(layouts, consumedDescriptors);
            }

            return new Auto<DescriptorSetCollection>(dsc);
        }

-        private DescriptorPoolHolder GetPool(Vk api, int requiredCount)
+        private DescriptorPoolHolder GetPool(
+            Vk api,
+            ReadOnlySpan<DescriptorPoolSize> poolSizes,
+            int poolIndex,
+            int setsCount,
+            int descriptorsCount,
+            bool updateAfterBind)
        {
-            if (_currentPool == null || !_currentPool.CanFit(requiredCount))
+            ref DescriptorPoolHolder currentPool = ref _currentPools[poolIndex];
+
+            if (currentPool == null || !currentPool.CanFit(setsCount, descriptorsCount))
            {
-                _currentPool = new DescriptorPoolHolder(api, _device);
+                currentPool = new DescriptorPoolHolder(api, _device, poolSizes, updateAfterBind);
            }

-            return _currentPool;
+            return currentPool;
        }

        protected virtual void Dispose(bool disposing)
        {
            if (disposing)
            {
-                _currentPool?.Dispose();
+                for (int index = 0; index < _currentPools.Length; index++)
+                {
+                    _currentPools[index]?.Dispose();
+                    _currentPools[index] = null;
+                }
            }
        }

--- a/src/Ryujinx.Graphics.Vulkan/DescriptorSetUpdater.cs
+++ b/src/Ryujinx.Graphics.Vulkan/DescriptorSetUpdater.cs
@ -59,6 +59,8 @@ namespace Ryujinx.Graphics.Vulkan
        private BitMapStruct<Array2<long>> _uniformMirrored;
        private BitMapStruct<Array2<long>> _storageMirrored;

+        private bool _updateDescriptorCacheCbIndex;
+
        [Flags]
        private enum DirtyFlags
        {
@ -218,6 +220,7 @@ namespace Ryujinx.Graphics.Vulkan
        public void SetProgram(ShaderCollection program)
        {
            _program = program;
+            _updateDescriptorCacheCbIndex = true;
            _dirty = DirtyFlags.All;
        }

@ -490,7 +493,13 @@ namespace Ryujinx.Graphics.Vulkan

            var dummyBuffer = _dummyBuffer?.GetBuffer();

-            var dsc = program.GetNewDescriptorSetCollection(_gd, cbs.CommandBufferIndex, setIndex, out var isNew).Get(cbs);
+            if (_updateDescriptorCacheCbIndex)
+            {
+                _updateDescriptorCacheCbIndex = false;
+                program.UpdateDescriptorCacheCommandBufferIndex(cbs.CommandBufferIndex);
+            }
+
+            var dsc = program.GetNewDescriptorSetCollection(setIndex, out var isNew).Get(cbs);

            if (!program.HasMinimalLayout)
            {
@ -697,6 +706,7 @@ namespace Ryujinx.Graphics.Vulkan

        public void SignalCommandBufferChange()
        {
+            _updateDescriptorCacheCbIndex = true;
            _dirty = DirtyFlags.All;

            _uniformSet.Clear();
--- a/src/Ryujinx.Graphics.Vulkan/FramebufferParams.cs
+++ b/src/Ryujinx.Graphics.Vulkan/FramebufferParams.cs
@ -257,14 +257,22 @@ namespace Ryujinx.Graphics.Vulkan

                if (realIndex != -1)
                {
-                    _colors[realIndex].Storage?.InsertReadToWriteBarrier(cbs, AccessFlags.ColorAttachmentWriteBit, PipelineStageFlags.ColorAttachmentOutputBit);
+                    _colors[realIndex].Storage?.InsertReadToWriteBarrier(
+                        cbs,
+                        AccessFlags.ColorAttachmentWriteBit,
+                        PipelineStageFlags.ColorAttachmentOutputBit,
+                        insideRenderPass: true);
                }
            }
        }

        public void InsertClearBarrierDS(CommandBufferScoped cbs)
        {
-            _depthStencil?.Storage?.InsertReadToWriteBarrier(cbs, AccessFlags.DepthStencilAttachmentWriteBit, PipelineStageFlags.LateFragmentTestsBit);
+            _depthStencil?.Storage?.InsertReadToWriteBarrier(
+                cbs,
+                AccessFlags.DepthStencilAttachmentWriteBit,
+                PipelineStageFlags.LateFragmentTestsBit,
+                insideRenderPass: true);
        }
    }
 }
--- a/src/Ryujinx.Graphics.Vulkan/HardwareCapabilities.cs
+++ b/src/Ryujinx.Graphics.Vulkan/HardwareCapabilities.cs
@ -41,6 +41,7 @@ namespace Ryujinx.Graphics.Vulkan
        public readonly bool SupportsPreciseOcclusionQueries;
        public readonly bool SupportsPipelineStatisticsQuery;
        public readonly bool SupportsGeometryShader;
+        public readonly bool SupportsTessellationShader;
        public readonly bool SupportsViewportArray2;
        public readonly bool SupportsHostImportedMemory;
        public readonly bool SupportsDepthClipControl;
@ -77,6 +78,7 @@ namespace Ryujinx.Graphics.Vulkan
            bool supportsPreciseOcclusionQueries,
            bool supportsPipelineStatisticsQuery,
            bool supportsGeometryShader,
+            bool supportsTessellationShader,
            bool supportsViewportArray2,
            bool supportsHostImportedMemory,
            bool supportsDepthClipControl,
@ -112,6 +114,7 @@ namespace Ryujinx.Graphics.Vulkan
            SupportsPreciseOcclusionQueries = supportsPreciseOcclusionQueries;
            SupportsPipelineStatisticsQuery = supportsPipelineStatisticsQuery;
            SupportsGeometryShader = supportsGeometryShader;
+            SupportsTessellationShader = supportsTessellationShader;
            SupportsViewportArray2 = supportsViewportArray2;
            SupportsHostImportedMemory = supportsHostImportedMemory;
            SupportsDepthClipControl = supportsDepthClipControl;
--- a/src/Ryujinx.Graphics.Vulkan/MemoryAllocator.cs
+++ b/src/Ryujinx.Graphics.Vulkan/MemoryAllocator.cs
@ -1,6 +1,7 @@
 using Silk.NET.Vulkan;
 using System;
 using System.Collections.Generic;
+using System.Threading;

 namespace Ryujinx.Graphics.Vulkan
 {
@ -13,6 +14,7 @@ namespace Ryujinx.Graphics.Vulkan
        private readonly Device _device;
        private readonly List<MemoryAllocatorBlockList> _blockLists;
        private readonly int _blockAlignment;
+        private readonly ReaderWriterLockSlim _lock;

        public MemoryAllocator(Vk api, VulkanPhysicalDevice physicalDevice, Device device)
        {
@ -21,6 +23,7 @@ namespace Ryujinx.Graphics.Vulkan
            _device = device;
            _blockLists = new List<MemoryAllocatorBlockList>();
            _blockAlignment = (int)Math.Min(int.MaxValue, MaxDeviceMemoryUsageEstimate / _physicalDevice.PhysicalDeviceProperties.Limits.MaxMemoryAllocationCount);
+            _lock = new(LockRecursionPolicy.NoRecursion);
        }

        public MemoryAllocation AllocateDeviceMemory(
@ -40,21 +43,37 @@ namespace Ryujinx.Graphics.Vulkan

        private MemoryAllocation Allocate(int memoryTypeIndex, ulong size, ulong alignment, bool map, bool isBuffer)
        {
-            for (int i = 0; i < _blockLists.Count; i++)
+            _lock.EnterReadLock();
+
+            try
            {
-                var bl = _blockLists[i];
-                if (bl.MemoryTypeIndex == memoryTypeIndex && bl.ForBuffer == isBuffer)
+                for (int i = 0; i < _blockLists.Count; i++)
                {
-                    lock (bl)
+                    var bl = _blockLists[i];
+                    if (bl.MemoryTypeIndex == memoryTypeIndex && bl.ForBuffer == isBuffer)
                    {
                        return bl.Allocate(size, alignment, map);
                    }
                }
            }
+            finally
+            {
+                _lock.ExitReadLock();
+            }

-            var newBl = new MemoryAllocatorBlockList(_api, _device, memoryTypeIndex, _blockAlignment, isBuffer);
-            _blockLists.Add(newBl);
-            return newBl.Allocate(size, alignment, map);
+            _lock.EnterWriteLock();
+
+            try
+            {
+                var newBl = new MemoryAllocatorBlockList(_api, _device, memoryTypeIndex, _blockAlignment, isBuffer);
+                _blockLists.Add(newBl);
+
+                return newBl.Allocate(size, alignment, map);
+            }
+            finally
+            {
+                _lock.ExitWriteLock();
+            }
        }

        internal int FindSuitableMemoryTypeIndex(
--- a/src/Ryujinx.Graphics.Vulkan/MemoryAllocatorBlockList.cs
+++ b/src/Ryujinx.Graphics.Vulkan/MemoryAllocatorBlockList.cs
@ -3,6 +3,7 @@ using Silk.NET.Vulkan;
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
+using System.Threading;

 namespace Ryujinx.Graphics.Vulkan
 {
@ -166,6 +167,8 @@ namespace Ryujinx.Graphics.Vulkan

        private readonly int _blockAlignment;

+        private readonly ReaderWriterLockSlim _lock;
+
        public MemoryAllocatorBlockList(Vk api, Device device, int memoryTypeIndex, int blockAlignment, bool forBuffer)
        {
            _blocks = new List<Block>();
@ -174,6 +177,7 @@ namespace Ryujinx.Graphics.Vulkan
            MemoryTypeIndex = memoryTypeIndex;
            ForBuffer = forBuffer;
            _blockAlignment = blockAlignment;
+            _lock = new(LockRecursionPolicy.NoRecursion);
        }

        public unsafe MemoryAllocation Allocate(ulong size, ulong alignment, bool map)
@ -184,19 +188,28 @@ namespace Ryujinx.Graphics.Vulkan
                throw new ArgumentOutOfRangeException(nameof(alignment), $"Invalid alignment 0x{alignment:X}.");
            }

-            for (int i = 0; i < _blocks.Count; i++)
-            {
-                var block = _blocks[i];
+            _lock.EnterReadLock();

-                if (block.Mapped == map && block.Size >= size)
+            try
+            {
+                for (int i = 0; i < _blocks.Count; i++)
                {
-                    ulong offset = block.Allocate(size, alignment);
-                    if (offset != InvalidOffset)
+                    var block = _blocks[i];
+
+                    if (block.Mapped == map && block.Size >= size)
                    {
-                        return new MemoryAllocation(this, block, block.Memory, GetHostPointer(block, offset), offset, size);
+                        ulong offset = block.Allocate(size, alignment);
+                        if (offset != InvalidOffset)
+                        {
+                            return new MemoryAllocation(this, block, block.Memory, GetHostPointer(block, offset), offset, size);
+                        }
                    }
                }
            }
+            finally
+            {
+                _lock.ExitReadLock();
+            }

            ulong blockAlignedSize = BitUtils.AlignUp(size, (ulong)_blockAlignment);

@ -244,14 +257,23 @@ namespace Ryujinx.Graphics.Vulkan

            if (block.IsTotallyFree())
            {
-                for (int i = 0; i < _blocks.Count; i++)
+                _lock.EnterWriteLock();
+
+                try
                {
-                    if (_blocks[i] == block)
+                    for (int i = 0; i < _blocks.Count; i++)
                    {
-                        _blocks.RemoveAt(i);
-                        break;
+                        if (_blocks[i] == block)
+                        {
+                            _blocks.RemoveAt(i);
+                            break;
+                        }
                    }
                }
+                finally
+                {
+                    _lock.ExitWriteLock();
+                }

                block.Destroy(_api, _device);
            }
@ -259,13 +281,22 @@ namespace Ryujinx.Graphics.Vulkan

        private void InsertBlock(Block block)
        {
-            int index = _blocks.BinarySearch(block);
-            if (index < 0)
-            {
-                index = ~index;
-            }
+            _lock.EnterWriteLock();

-            _blocks.Insert(index, block);
+            try
+            {
+                int index = _blocks.BinarySearch(block);
+                if (index < 0)
+                {
+                    index = ~index;
+                }
+
+                _blocks.Insert(index, block);
+            }
+            finally
+            {
+                _lock.ExitWriteLock();
+            }
        }

        public void Dispose()
--- a/src/Ryujinx.Graphics.Vulkan/PipelineBase.cs
+++ b/src/Ryujinx.Graphics.Vulkan/PipelineBase.cs
@ -149,10 +149,22 @@ namespace Ryujinx.Graphics.Vulkan
                DstAccessMask = AccessFlags.MemoryReadBit | AccessFlags.MemoryWriteBit,
            };

+            PipelineStageFlags pipelineStageFlags = PipelineStageFlags.VertexShaderBit | PipelineStageFlags.FragmentShaderBit;
+
+            if (Gd.Capabilities.SupportsGeometryShader)
+            {
+                pipelineStageFlags |= PipelineStageFlags.GeometryShaderBit;
+            }
+
+            if (Gd.Capabilities.SupportsTessellationShader)
+            {
+                pipelineStageFlags |= PipelineStageFlags.TessellationControlShaderBit | PipelineStageFlags.TessellationEvaluationShaderBit;
+            }
+
            Gd.Api.CmdPipelineBarrier(
                CommandBuffer,
-                PipelineStageFlags.FragmentShaderBit,
-                PipelineStageFlags.FragmentShaderBit,
+                pipelineStageFlags,
+                pipelineStageFlags,
                0,
                1,
                memoryBarrier,
--- a/src/Ryujinx.Graphics.Vulkan/PipelineConverter.cs
+++ b/src/Ryujinx.Graphics.Vulkan/PipelineConverter.cs
@ -9,8 +9,12 @@ namespace Ryujinx.Graphics.Vulkan
 {
    static class PipelineConverter
    {
-        private const AccessFlags SubpassSrcAccessMask = AccessFlags.MemoryReadBit | AccessFlags.MemoryWriteBit | AccessFlags.ColorAttachmentWriteBit;
-        private const AccessFlags SubpassDstAccessMask = AccessFlags.MemoryReadBit | AccessFlags.MemoryWriteBit | AccessFlags.ShaderReadBit;
+        private const AccessFlags SubpassAccessMask =
+            AccessFlags.MemoryReadBit |
+            AccessFlags.MemoryWriteBit |
+            AccessFlags.ShaderReadBit |
+            AccessFlags.ColorAttachmentWriteBit |
+            AccessFlags.DepthStencilAttachmentWriteBit;

        public static unsafe DisposableRenderPass ToRenderPass(this ProgramPipelineState state, VulkanRenderer gd, Device device)
        {
@ -132,8 +136,8 @@ namespace Ryujinx.Graphics.Vulkan
                0,
                PipelineStageFlags.AllGraphicsBit,
                PipelineStageFlags.AllGraphicsBit,
-                SubpassSrcAccessMask,
-                SubpassDstAccessMask,
+                SubpassAccessMask,
+                SubpassAccessMask,
                0);
        }

@ -146,8 +150,8 @@ namespace Ryujinx.Graphics.Vulkan
                0,
                PipelineStageFlags.AllGraphicsBit,
                PipelineStageFlags.AllGraphicsBit,
-                SubpassSrcAccessMask,
-                SubpassDstAccessMask,
+                SubpassAccessMask,
+                SubpassAccessMask,
                0);
        }

--- a/src/Ryujinx.Graphics.Vulkan/PipelineDynamicState.cs
+++ b/src/Ryujinx.Graphics.Vulkan/PipelineDynamicState.cs
@ -146,7 +146,10 @@ namespace Ryujinx.Graphics.Vulkan

        private void RecordScissor(Vk api, CommandBuffer commandBuffer)
        {
-            api.CmdSetScissor(commandBuffer, 0, (uint)ScissorsCount, _scissors.AsSpan());
+            if (ScissorsCount != 0)
+            {
+                api.CmdSetScissor(commandBuffer, 0, (uint)ScissorsCount, _scissors.AsSpan());
+            }
        }

        private readonly void RecordStencilMasks(Vk api, CommandBuffer commandBuffer)
--- a/src/Ryujinx.Graphics.Vulkan/PipelineLayoutCacheEntry.cs
+++ b/src/Ryujinx.Graphics.Vulkan/PipelineLayoutCacheEntry.cs
@ -1,5 +1,6 @@
 using Ryujinx.Graphics.GAL;
 using Silk.NET.Vulkan;
+using System;
 using System.Collections.Generic;
 using System.Collections.ObjectModel;

@ -7,15 +8,28 @@ namespace Ryujinx.Graphics.Vulkan
 {
    class PipelineLayoutCacheEntry
    {
+        // Those were adjusted based on current descriptor usage and the descriptor counts usually used on pipeline layouts.
+        // It might be a good idea to tweak them again if those change, or maybe find a way to calculate an optimal value dynamically.
+        private const uint DefaultUniformBufferPoolCapacity = 19 * DescriptorSetManager.MaxSets;
+        private const uint DefaultStorageBufferPoolCapacity = 16 * DescriptorSetManager.MaxSets;
+        private const uint DefaultTexturePoolCapacity = 128 * DescriptorSetManager.MaxSets;
+        private const uint DefaultImagePoolCapacity = 8 * DescriptorSetManager.MaxSets;
+
+        private const int MaxPoolSizesPerSet = 2;
+
        private readonly VulkanRenderer _gd;
        private readonly Device _device;

        public DescriptorSetLayout[] DescriptorSetLayouts { get; }
        public PipelineLayout PipelineLayout { get; }

+        private readonly int[] _consumedDescriptorsPerSet;
+
        private readonly List<Auto<DescriptorSetCollection>>[][] _dsCache;
+        private List<Auto<DescriptorSetCollection>>[] _currentDsCache;
        private readonly int[] _dsCacheCursor;
        private int _dsLastCbIndex;
+        private int _dsLastSubmissionCount;

        private PipelineLayoutCacheEntry(VulkanRenderer gd, Device device, int setsCount)
        {
@ -44,29 +58,55 @@ namespace Ryujinx.Graphics.Vulkan
            bool usePushDescriptors) : this(gd, device, setDescriptors.Count)
        {
            (DescriptorSetLayouts, PipelineLayout) = PipelineLayoutFactory.Create(gd, device, setDescriptors, usePushDescriptors);
+
+            _consumedDescriptorsPerSet = new int[setDescriptors.Count];
+
+            for (int setIndex = 0; setIndex < setDescriptors.Count; setIndex++)
+            {
+                int count = 0;
+
+                foreach (var descriptor in setDescriptors[setIndex].Descriptors)
+                {
+                    count += descriptor.Count;
+                }
+
+                _consumedDescriptorsPerSet[setIndex] = count;
+            }
        }

-        public Auto<DescriptorSetCollection> GetNewDescriptorSetCollection(
-            VulkanRenderer gd,
-            int commandBufferIndex,
-            int setIndex,
-            out bool isNew)
+        public void UpdateCommandBufferIndex(int commandBufferIndex)
        {
-            if (_dsLastCbIndex != commandBufferIndex)
+            int submissionCount = _gd.CommandBufferPool.GetSubmissionCount(commandBufferIndex);
+
+            if (_dsLastCbIndex != commandBufferIndex || _dsLastSubmissionCount != submissionCount)
            {
                _dsLastCbIndex = commandBufferIndex;
-
-                for (int i = 0; i < _dsCacheCursor.Length; i++)
-                {
-                    _dsCacheCursor[i] = 0;
-                }
+                _dsLastSubmissionCount = submissionCount;
+                Array.Clear(_dsCacheCursor);
            }

-            var list = _dsCache[commandBufferIndex][setIndex];
+            _currentDsCache = _dsCache[commandBufferIndex];
+        }
+
+        public Auto<DescriptorSetCollection> GetNewDescriptorSetCollection(int setIndex, out bool isNew)
+        {
+            var list = _currentDsCache[setIndex];
            int index = _dsCacheCursor[setIndex]++;
            if (index == list.Count)
            {
-                var dsc = gd.DescriptorSetManager.AllocateDescriptorSet(gd.Api, DescriptorSetLayouts[setIndex]);
+                Span<DescriptorPoolSize> poolSizes = stackalloc DescriptorPoolSize[MaxPoolSizesPerSet];
+                poolSizes = GetDescriptorPoolSizes(poolSizes, setIndex);
+
+                int consumedDescriptors = _consumedDescriptorsPerSet[setIndex];
+
+                var dsc = _gd.DescriptorSetManager.AllocateDescriptorSet(
+                    _gd.Api,
+                    DescriptorSetLayouts[setIndex],
+                    poolSizes,
+                    setIndex,
+                    consumedDescriptors,
+                    false);
+
                list.Add(dsc);
                isNew = true;
                return dsc;
@ -76,6 +116,33 @@ namespace Ryujinx.Graphics.Vulkan
            return list[index];
        }

+        private static Span<DescriptorPoolSize> GetDescriptorPoolSizes(Span<DescriptorPoolSize> output, int setIndex)
+        {
+            int count = 1;
+
+            switch (setIndex)
+            {
+                case PipelineBase.UniformSetIndex:
+                    output[0] = new(DescriptorType.UniformBuffer, DefaultUniformBufferPoolCapacity);
+                    break;
+                case PipelineBase.StorageSetIndex:
+                    output[0] = new(DescriptorType.StorageBuffer, DefaultStorageBufferPoolCapacity);
+                    break;
+                case PipelineBase.TextureSetIndex:
+                    output[0] = new(DescriptorType.CombinedImageSampler, DefaultTexturePoolCapacity);
+                    output[1] = new(DescriptorType.UniformTexelBuffer, DefaultTexturePoolCapacity);
+                    count = 2;
+                    break;
+                case PipelineBase.ImageSetIndex:
+                    output[0] = new(DescriptorType.StorageImage, DefaultImagePoolCapacity);
+                    output[1] = new(DescriptorType.StorageTexelBuffer, DefaultImagePoolCapacity);
+                    count = 2;
+                    break;
+            }
+
+            return output[..count];
+        }
+
        protected virtual unsafe void Dispose(bool disposing)
        {
            if (disposing)
--- a/src/Ryujinx.Graphics.Vulkan/ResourceBindingSegment.cs
+++ b/src/Ryujinx.Graphics.Vulkan/ResourceBindingSegment.cs
@ -8,15 +8,13 @@ namespace Ryujinx.Graphics.Vulkan
        public readonly int Count;
        public readonly ResourceType Type;
        public readonly ResourceStages Stages;
-        public readonly ResourceAccess Access;

-        public ResourceBindingSegment(int binding, int count, ResourceType type, ResourceStages stages, ResourceAccess access)
+        public ResourceBindingSegment(int binding, int count, ResourceType type, ResourceStages stages)
        {
            Binding = binding;
            Count = count;
            Type = type;
            Stages = stages;
-            Access = access;
        }
    }
 }
--- a/src/Ryujinx.Graphics.Vulkan/ResourceLayoutBuilder.cs
+++ b/src/Ryujinx.Graphics.Vulkan/ResourceLayoutBuilder.cs
@ -34,22 +34,12 @@ namespace Ryujinx.Graphics.Vulkan
                _ => throw new ArgumentException($"Invalid resource type \"{type}\"."),
            };

-            ResourceAccess access = IsReadOnlyType(type) ? ResourceAccess.Read : ResourceAccess.ReadWrite;
-
            _resourceDescriptors[setIndex].Add(new ResourceDescriptor(binding, 1, type, stages));
-            _resourceUsages[setIndex].Add(new ResourceUsage(binding, type, stages, access));
+            _resourceUsages[setIndex].Add(new ResourceUsage(binding, type, stages));

            return this;
        }

-        private static bool IsReadOnlyType(ResourceType type)
-        {
-            return type == ResourceType.UniformBuffer ||
-                   type == ResourceType.Sampler ||
-                   type == ResourceType.TextureAndSampler ||
-                   type == ResourceType.BufferTexture;
-        }
-
        public ResourceLayout Build()
        {
            var descriptors = new ResourceDescriptorCollection[TotalSets];
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
gdkchan	8b2625b0be	Decrement nvmap reference count on surface flinger prealloc (#5753 )	2023-10-02 22:13:29 +00:00
gdkchan	651e24fed9	Signal friends completion event and stub CheckBlockedUserListAvailability (#5743 )	2023-09-29 13:24:44 +02:00
gdkchan	41b104d0fb	Fix audio renderer compressor effect (#5742 ) * Delete DecibelToLinearExtended and fix Log10 function * Fix CopyBuffer and ClearBuffer * Change effect states from class to struct + formatting * Formatting * Make UpdateLowPassFilter readonly * More compressor fixes	2023-09-29 10:48:49 +00:00
dependabot[bot]	bc44b85b0b	nuget: bump FluentAvaloniaUI from 2.0.1 to 2.0.4 (#5729 ) * nuget: bump FluentAvaloniaUI from 2.0.1 to 2.0.4 Bumps [FluentAvaloniaUI](https://github.com/amwx/FluentAvalonia) from 2.0.1 to 2.0.4. - [Commits](https://github.com/amwx/FluentAvalonia/commits) --- updated-dependencies: - dependency-name: FluentAvaloniaUI dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] <support@github.com> * Update Directory.Packages.props --------- Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> Co-authored-by: Ac_K <Acoustik666@gmail.com>	2023-09-28 00:15:45 +02:00
gdkchan	01c2b8097c	Implement NGC service (#5681 ) * Implement NGC service * Use raw byte arrays instead of string for _wordSeparators * Silence IDE0230 for _wordSeparators * Try to silence warning about _rangeValuesCount not being read on SparseSet * Make AcType enum private * Add abstract methods and one TODO that I forgot * PR feedback * More PR feedback * More PR feedback	2023-09-27 19:21:26 +02:00
dependabot[bot]	4bd2ca3f0d	nuget: bump System.IdentityModel.Tokens.Jwt from 6.31.0 to 7.0.0 (#5730 ) Bumps [System.IdentityModel.Tokens.Jwt](https://github.com/AzureAD/azure-activedirectory-identitymodel-extensions-for-dotnet) from 6.31.0 to 7.0.0. - [Release notes](https://github.com/AzureAD/azure-activedirectory-identitymodel-extensions-for-dotnet/releases) - [Changelog](https://github.com/AzureAD/azure-activedirectory-identitymodel-extensions-for-dotnet/blob/dev/CHANGELOG.md) - [Commits](https://github.com/AzureAD/azure-activedirectory-identitymodel-extensions-for-dotnet/compare/6.31.0...7.0.0) --- updated-dependencies: - dependency-name: System.IdentityModel.Tokens.Jwt dependency-type: direct:production update-type: version-update:semver-major ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2023-09-27 19:03:41 +02:00
riperiperi	e63157cc33	GPU: Don't create tracking handles for buffer textures (#5727 ) * GPU: Don't create tracking handles for buffer textures Buffer texture memory is handled by the buffer cache - the texture shouldn't create any tracking handles as they aren't used. This change simply makes them create and iterate 0 tracking handles, while keeping the rest of the texture group around. This prevents a possible issue where many buffer textures are created as views of overlapping buffer ranges, and virtual regions have many dependant textures that don't actually contribute anything to handle state. Should improve performance in Mortal Kombat 1, possibly certain UE4 games when FIFO raises to 100%. * Fix interval tree bug * Don't check view compatibility for buffer textures	2023-09-26 12:37:10 -03:00
Ac_K	7f2fb049f5	Ava: Fix regressions by rewriting CheckLaunchState (#5728 )	2023-09-26 07:17:55 +02:00
gdkchan	4744bde0e5	Reduce the amount of descriptor pool allocations on Vulkan (#5673 ) * Reduce the amount of descriptor pool allocations on Vulkan * Formatting * Slice can be simplified * Make GetDescriptorPoolSizes static * Adjust CanFit calculation so that TryAllocateDescriptorSets never fails * Remove unused field	2023-09-26 02:00:02 +02:00
gdkchan	4a835bb2b9	Make Vulkan memory allocator actually thread safe (#5575 ) * Make Vulkan memory allocator actually thread safe * Make free thread safe too * PR feedback	2023-09-26 01:50:06 +02:00
gdkchan	ddc9ae2a83	Add VTimer as alternative interrupt method on Apple Hypervisor (#5663 ) * Add VTimer as alternative interrupt method on Apple Hypervisor * Fix naming violations on TimeApi * Fix timer interval (was 16us rather than 16ms) * Fix delta ticks calculation * Missing ThrowOnError call * Add SupportedOSPlatform attribute on AppleHv classes	2023-09-26 01:18:32 +02:00
Isaac Marovitz	d6d3cdd573	Ava UI: Refactor `async` usage (#5516 ) * Remove `async void` * Async LoadApplications * Formatting and such * Remove async from InstallUpdate * Update src/Ryujinx.Ava/UI/Controls/ApplicationContextMenu.axaml.cs Co-authored-by: TSRBerry <20988865+TSRBerry@users.noreply.github.com> * Cleanup LoadApplications() * Cleanup * Formatting * Revert some stuff * Cleanup * Update src/Ryujinx.Ava/UI/ViewModels/MainWindowViewModel.cs Co-authored-by: Ac_K <Acoustik666@gmail.com> * Ack suggestions * Whitespace * Fix Peri suggestion * Add missing trailing commas * Remove redundant method override * Remove Dispatcher.UIThread.InvokeAsync/Post where possible --------- Co-authored-by: TSR Berry <20988865+TSRBerry@users.noreply.github.com> Co-authored-by: Ac_K <Acoustik666@gmail.com>	2023-09-26 00:04:58 +02:00
TSRBerry	53bd4c9f60	Add ldn:u implementation, INetworkClient interface and DisabledLdnClient (#5652 ) * Impl first attempt to LDN * Make this work. - Endianness swap on all IPs. - Use local network IP for connections, rather than 127.0.0.1. This is to be changed when tunnelling or whatever. - Mac addresses are now randomly assigned on the server. (fixes joining lobbies) - Fixed the "connected" handler for stations to actually find a - Added info retrieval when connected to a station. - Users that disconnect are now removed from rooms they were in. (still need to broadcast tho) - The communication service does a bit better with being closed now. - Some locking around the game instance dictionary. * We may just be "initialized". Ignore this for now. * Lots of WIP * Add Disconnect packet * Improve signalling of internal events. * Fix scan. * Fix some more stupid things. * Enable NoDelay on all sockets. * Add station accept policy, disconnect function. * Limit max number of games. * Split out networking stuff from HLE, so it can be swapped. * Update logging calls. * Missed a spot. * Call SignalDisconnect instead of SetState * Add comment to GetNetworkInfo * Update configuration + UI Now has its own tab, more options. * Refactoring IUserLocalCommunicationService ( Expected new issues :'( ) * some cleanup * More fix * Correctly handle errors when connecting. * Disable Private call and clean symbols Structs cleanup * Big cleanup * Fix InvalidHandle (in MK8D and other games) * Add Reject and Private Network support (v1) RyuLdn Version bumped to 1. * Add Initialize Packet Allows users to keep Mac Addresses assigned by the server. * Add SetWirelessControllerRestriction and some cleanup * LDN-2 Initial Rebase Make this work. - Endianness swap on all IPs. - Use local network IP for connections, rather than 127.0.0.1. This is to be changed when tunnelling or whatever. - Fixed the "connected" handler for stations to actually find a - The communication service does a bit better with being closed now. - Some locking around the game instance dictionary. We may just be "initialized". Ignore this for now. Lots of WIP Implement scan filter. Improve signalling of internal events. Fix scan. Fix 0 width data, scan reply end delay removed. Fix some more stupid things. Enable NoDelay on all sockets. Add station accept policy, disconnect function. Limit max number of games. Split out networking stuff from HLE, so it can be swapped. Update logging calls. Missed a spot. SetAdvertiseData when open, don't return games that have accept policy 1 Update configuration + UI Now has its own tab, more options. Don't Keepalive, it causes problems. Refactoring IUserLocalCommunicationService ( Expected new issues :'( ) some cleanup More fix Correctly handle errors when connecting. Disable Private call and clean symbols Structs cleanup Big cleanup Fix InvalidHandle (in MK8D and other games) Add Reject and Private Network support (v1) Disable TcpNoDelay option on linux. Add SetWirelessControllerRestriction and some cleanup Misc cleanup, implement broadcast flag. Misc Changes * Fix GetNetworkInfo * Fix some small issues * Implement GetNetworkInfoLatestUpdate * Hotfix when LocalCommunicationId = 0xFFFFFFFFFFFFFFFF * Fix ARMS Scan (and other games using wrong LocalCommunicationId * Fix latest update when host leaves * Revert "Fix ARMS Scan (and other games using wrong LocalCommunicationId" This reverts commit 519c283d3993e2fdfafb8ac6b4e0a98231f6fb75. * Fix the localCommunicationId = -1 * Don't set Connect flag for nodes already in the room before joining. * Make IUserLocalCommunicationService disposable * Don't dispose if there's no client. * LDN-2-2 Rebase Make this work. - Endianness swap on all IPs. - Use local network IP for connections, rather than 127.0.0.1. This is to be changed when tunnelling or whatever. - Fixed the "connected" handler for stations to actually find a - The communication service does a bit better with being closed now. - Some locking around the game instance dictionary. We may just be "initialized". Ignore this for now. Put sockets behind an interface, so that they can be swapped for something proxyable Lots of WIP Implement scan filter. Improve signalling of internal events. Fix scan. Fix 0 width data, scan reply end delay removed. Fix some more stupid things. Enable NoDelay on all sockets. Add station accept policy, disconnect function. Limit max number of games. Split out networking stuff from HLE, so it can be swapped. Update logging calls. Missed a spot. SetAdvertiseData when open, don't return games that have accept policy 1 Update configuration + UI Now has its own tab, more options. Don't Keepalive, it causes problems. Refactoring IUserLocalCommunicationService ( Expected new issues :'( ) some cleanup More fix Correctly handle errors when connecting. Disable Private call and clean symbols Structs cleanup Big cleanup Fix InvalidHandle (in MK8D and other games) Add Reject and Private Network support (v1) Disable TcpNoDelay option on linux. Add SetWirelessControllerRestriction and some cleanup Misc cleanup, implement broadcast flag. Misc Changes Fix GetNetworkInfo Fix some small issues Disable LAN by default til the config is added. Fix Splatoon 2 - Stub nfp IUser::StartDetection / IUser::StopDetection. - Stub ntc IEnsureNetworkClockAvailabilityService and needed calls. Cleanup previous fixes Stub IAudioInManager/IAudioIn for Splatoon 2 LAN Add LAN settings to multiplayer tab LAN Play > LAN Mode Implement GetNetworkInfoLatestUpdate Hotfix when LocalCommunicationId = 0xFFFFFFFFFFFFFFFF Fix ARMS Scan (and other games using wrong LocalCommunicationId Fix latest update when host leaves Revert "Fix ARMS Scan (and other games using wrong LocalCommunicationId" This reverts commit 519c283d3993e2fdfafb8ac6b4e0a98231f6fb75. Fix the localCommunicationId = -1 Don't set Connect flag for nodes already in the room before joining. Make IUserLocalCommunicationService disposable Fix crash when using LAN mode on linux. Actually use that call Don't dispose if there's no client. Fix the settings window crash Fix configurationFileUpdated Make LDN compatible with Ryujinx/Ryujinx#3805 * Ava: Add Ldn options to SettingsNetworkTab * Ava: Add update events for multiplayer options * Apply formatting * Remove LdnHelper * ldn: Fix hardcoded /24 subnet mask * Fix naming rule violations * Add missing summary doc tag * Remove NetCoreServer dependency * Address code style issues and typos Co-authored-by: gdkchan <gab.dark.100@gmail.com> * Call CloseStation/CloseAccessPoint to reduce code duplication * Fix typo Co-authored-by: gdkchan <gab.dark.100@gmail.com> * Fix missing trailing commas * Extract AddressList from AddressEntry * Use AcceptPolicy as a type for LdnNetworkInfo.StationAcceptPolicy * Add Flags attribute to ScanFilterFlag * Rename struct members for LdnNetworkInfo * Remove extra line Co-authored-by: Ac_K <Acoustik666@gmail.com> * Extract NetworkErrorMessage from NetworkError * Fix missing trailing commas --------- Co-authored-by: Ac_K <Acoustik666@gmail.com> Co-authored-by: riperiperi <rhy3756547@hotmail.com> Co-authored-by: gdkchan <gab.dark.100@gmail.com>	2023-09-25 23:50:43 +02:00
Theun de Bruijn	eca8808649	Headless: Add support for Scaling Filters, Anti-aliasing and Exclusive Fullscreen (#5412 ) * Headless: Added support for fullscreen option * Headless: cleanup of fullscreen support * Headless: fullscreen support : implemented proposed changes * Headless: fullscreen support: cleanup * Headless: exclusive fullscreen support: wip * Headless: exclusive fullscreen support: add. windows scale interop * Headless: exclusive fullscreen support: cleanup * Headless: exclusive fullscreen support: cleanup * Headless: fullscreen support: fix for OpenGL scaling * Headless: fullscreen support: cleanup * Headless: fullscreen support: cleanup * Headless: fullscreen support: add. Vulkan fix * Headless: fullscreen support: add. macOS fullscreen fix * Headless: fullscreen support: cleanup * Headless: fullscreen support: cleanup * Headless: fullscreen support: cleanup * Headless: exclusive fullscreen support: add. display selection logic * Headless: exclusive fullscreen support: add. anti-aliasing + scaling-filter logic * Headless: exclusive fullscreen support: upd. options to be case-insensitive * Headless: exclusive fullscreen support: force default values for scaling + anti-aliasing options * Headless: upd. OpenGL --fullscreen window size logic * Headless: upd. fullscreen logic * Headless: cleanup * Headless: refac. DisplayId option naming * Headless: refac. scaling + anti-aliasing option handling * Headless: refac. namespace handling * Headless: upd. imports ordering * Apply suggestions from code review Co-authored-by: TSRBerry <20988865+TSRBerry@users.noreply.github.com> --------- Co-authored-by: Ac_K <Acoustik666@gmail.com> Co-authored-by: TSRBerry <20988865+TSRBerry@users.noreply.github.com>	2023-09-25 23:40:16 +02:00
riperiperi	f6c3f1cdfd	GPU: Discard data when getting texture before full clear (#5719 ) * GPU: Discard data when getting texture before full clear * Fix rules and order of clear checks * Fix formatting	2023-09-25 23:07:03 +02:00
dependabot[bot]	8026e1c804	nuget: bump Microsoft.NET.Test.Sdk from 17.6.3 to 17.7.2 (#5622 ) Bumps [Microsoft.NET.Test.Sdk](https://github.com/microsoft/vstest) from 17.6.3 to 17.7.2. - [Release notes](https://github.com/microsoft/vstest/releases) - [Changelog](https://github.com/microsoft/vstest/blob/main/docs/releases.md) - [Commits](https://github.com/microsoft/vstest/compare/v17.6.3...v17.7.2) --- updated-dependencies: - dependency-name: Microsoft.NET.Test.Sdk dependency-type: direct:production update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2023-09-25 21:29:09 +02:00
Isaac Marovitz	d9f9bbfaa6	Vulkan: Fix barriers on macOS (#5700 ) * Use old method on macOS * gdk suggestions * Update src/Ryujinx.Graphics.Vulkan/TextureStorage.cs Co-authored-by: gdkchan <gab.dark.100@gmail.com> * Update src/Ryujinx.Graphics.Vulkan/TextureStorage.cs Co-authored-by: gdkchan <gab.dark.100@gmail.com> --------- Co-authored-by: gdkchan <gab.dark.100@gmail.com>	2023-09-23 19:32:36 -03:00
MutantAura	fe9e19d8cc	[INFRA] Addition of basic contributor guides and docs framework. (#5581 ) * Addition of basic contributor docs. - Main contributor guide landing page. - C# codestyle doc. - Pull request guide doc. All files and structure heavily inspired by the dotnet/runtime docs: https://github.com/dotnet/runtime/tree/main/docs * fix typos and review changes * Update XML doc requirement & conversation review.	2023-09-22 16:21:11 +02:00
Ac_K	fb55f57da7	Horizon: Migrate wlan and stubs latest services (#5708 ) * Horizon: Migrate wlan and stubs latest services This PR migrate empty wlan services, values are found by RE. Latest firmwares added some other services which are now stubbed and up-to-date. * Fix imports ordering	2023-09-20 22:55:27 +02:00
gdkchan	44862dce3e	Stub unsupported BSD socket options (#5670 ) * Stub unsupported BSD socket options * Span.Clear	2023-09-19 19:35:56 +02:00
Emmanuel Hansen	e601419bd4	make cheat list binding public (#5697 )	2023-09-19 16:51:56 +00:00
Emmanuel Hansen	d6bc0de785	use compiled bidning for localizations (#5684 )	2023-09-18 22:20:59 +02:00
Emmanuel Hansen	9f26fd3600	remove some usages of reflection binding (#5686 )	2023-09-18 22:09:22 +02:00
gdkchan	88df636c87	Replace ShaderOutputLayer with equivalent ShaderViewportIndexLayerEXT capability (#5683 )	2023-09-16 18:49:13 +02:00
gdkchan	7ccff037e8	Fix some Vulkan validation errors (mostly related to barriers) (#5603 ) * Replace image barriers inside render pass with more generic memory barrier * Remove forceStorage since it was creating images with storage bit for formats that are not StorageImage compatible * Add missing flags on subpass dependency * Don't call vkCmdSetScissor with a scissor count of 0 * One semaphore per swapchain image * Remove compute stage from read to write barriers * Try to improve Pipeline.Barrier nonsense * Set PipelineStateFlags based on supported stages	2023-09-14 19:58:11 +02:00
gdkchan	a745913329	Fix gl_Layer to geometry shader change not writing gl_Layer (#5682 ) * Fix gl_Layer to geometry shader change not writing gl_Layer * Shader cache version bump	2023-09-14 14:53:53 -03:00
Ac_K	e6700b314f	lbl: Migrate service to Horizon (#5628 ) * lbl: Migrate service to Horizon * Fix formatting * Addresses gdkchan's feedback * Fix comments	2023-09-14 09:50:19 +02:00
gdkchan	e2cfe6fe44	Fix shader GlobalToStorage pass when base address comes from local or shared memory (#5668 ) * Fix shader GlobalToStorage pass when base address comes from local or shared memory * Shader cache version bump	2023-09-11 01:22:18 +00:00
Marco Carvalho	210f475484	Replacing 'Assembly.GetExecutingAssembly()' with 'Type.Assembly' (#5545 )	2023-09-07 14:10:58 +02:00
gdkchan	ddb6493896	Delete ResourceAccess (#5626 ) * Delete ResourceAccess * Set write flag for vertex/geometry as compute output buffers	2023-09-05 22:59:21 +02:00
siegmund-heiss-ich	f631933e60	Add macOS Headless release workflow (#5272 ) * Add macOS Headless release workflow * Add MACH-O check before applying signature * Rename script for consistency * Remove redundant compiler flag * Fix release.yml arguments + names * Update headless.sh to include changes of pr #5398	2023-09-05 01:28:44 +02:00