Implement HLE macros for render target clears (#3528)

* Implement HLE macros for render target clears

* Add constants for the offsets

ARMeilleure/Signal/NativeSignalHandler.cs

@@ -197,12 +197,29 @@ namespace ARMeilleure.Signal
                 // Only call tracking if in range.
                 context.BranchIfFalse(nextLabel, inRange, BasicBlockFrequency.Cold);
 
-                context.Copy(inRegionLocal, Const(1));
                 Operand offset = context.BitwiseAnd(context.Subtract(faultAddress, rangeAddress), Const(~PageMask));
 
                 // Call the tracking action, with the pointer's relative offset to the base address.
                 Operand trackingActionPtr = context.Load(OperandType.I64, Const((ulong)signalStructPtr + rangeBaseOffset + 20));
-                context.Call(trackingActionPtr, OperandType.I32, offset, Const(PageSize), isWrite, Const(0));
+
+                context.Copy(inRegionLocal, Const(0));
+
+                Operand skipActionLabel = Label();
+
+                // Tracking action should be non-null to call it, otherwise assume false return.
+                context.BranchIfFalse(skipActionLabel, trackingActionPtr);
+                Operand result = context.Call(trackingActionPtr, OperandType.I32, offset, Const(PageSize), isWrite, Const(0));
+                context.Copy(inRegionLocal, result);
+
+                context.MarkLabel(skipActionLabel);
+
+                // If the tracking action returns false or does not exist, it might be an invalid access due to a partial overlap on Windows.
+                if (OperatingSystem.IsWindows())
+                {
+                    context.BranchIfTrue(endLabel, inRegionLocal);
+
+                    context.Copy(inRegionLocal, WindowsPartialUnmapHandler.EmitRetryFromAccessViolation(context));
+                }
 
                 context.Branch(endLabel);
 

ARMeilleure/Signal/TestMethods.cs

@@ -0,0 +1,84 @@
+using ARMeilleure.IntermediateRepresentation;
+using ARMeilleure.Translation;
+using System;
+
+using static ARMeilleure.IntermediateRepresentation.Operand.Factory;
+
+namespace ARMeilleure.Signal
+{
+    public struct NativeWriteLoopState
+    {
+        public int Running;
+        public int Error;
+    }
+
+    public static class TestMethods
+    {
+        public delegate bool DebugPartialUnmap();
+        public delegate int DebugThreadLocalMapGetOrReserve(int threadId, int initialState);
+        public delegate void DebugNativeWriteLoop(IntPtr nativeWriteLoopPtr, IntPtr writePtr);
+
+        public static DebugPartialUnmap GenerateDebugPartialUnmap()
+        {
+            EmitterContext context = new EmitterContext();
+
+            var result = WindowsPartialUnmapHandler.EmitRetryFromAccessViolation(context);
+
+            context.Return(result);
+
+            // Compile and return the function.
+
+            ControlFlowGraph cfg = context.GetControlFlowGraph();
+
+            OperandType[] argTypes = new OperandType[] { OperandType.I64 };
+
+            return Compiler.Compile(cfg, argTypes, OperandType.I32, CompilerOptions.HighCq).Map<DebugPartialUnmap>();
+        }
+
+        public static DebugThreadLocalMapGetOrReserve GenerateDebugThreadLocalMapGetOrReserve(IntPtr structPtr)
+        {
+            EmitterContext context = new EmitterContext();
+
+            var result = WindowsPartialUnmapHandler.EmitThreadLocalMapIntGetOrReserve(context, structPtr, context.LoadArgument(OperandType.I32, 0), context.LoadArgument(OperandType.I32, 1));
+
+            context.Return(result);
+
+            // Compile and return the function.
+
+            ControlFlowGraph cfg = context.GetControlFlowGraph();
+
+            OperandType[] argTypes = new OperandType[] { OperandType.I64 };
+
+            return Compiler.Compile(cfg, argTypes, OperandType.I32, CompilerOptions.HighCq).Map<DebugThreadLocalMapGetOrReserve>();
+        }
+
+        public static DebugNativeWriteLoop GenerateDebugNativeWriteLoop()
+        {
+            EmitterContext context = new EmitterContext();
+
+            // Loop a write to the target address until "running" is false.
+
+            Operand structPtr = context.Copy(context.LoadArgument(OperandType.I64, 0));
+            Operand writePtr = context.Copy(context.LoadArgument(OperandType.I64, 1));
+
+            Operand loopLabel = Label();
+            context.MarkLabel(loopLabel);
+
+            context.Store(writePtr, Const(12345));
+
+            Operand running = context.Load(OperandType.I32, structPtr);
+
+            context.BranchIfTrue(loopLabel, running);
+
+            context.Return();
+
+            // Compile and return the function.
+
+            ControlFlowGraph cfg = context.GetControlFlowGraph();
+
+            OperandType[] argTypes = new OperandType[] { OperandType.I64 };
+
+            return Compiler.Compile(cfg, argTypes, OperandType.None, CompilerOptions.HighCq).Map<DebugNativeWriteLoop>();
+        }
+    }
+}

ARMeilleure/Signal/WindowsPartialUnmapHandler.cs

@@ -0,0 +1,186 @@
+using ARMeilleure.IntermediateRepresentation;
+using ARMeilleure.Translation;
+using Ryujinx.Common.Memory.PartialUnmaps;
+using System;
+
+using static ARMeilleure.IntermediateRepresentation.Operand.Factory;
+
+namespace ARMeilleure.Signal
+{
+    /// <summary>
+    /// Methods to handle signals caused by partial unmaps. See the structs for C# implementations of the methods.
+    /// </summary>
+    internal static class WindowsPartialUnmapHandler
+    {
+        public static Operand EmitRetryFromAccessViolation(EmitterContext context)
+        {
+            IntPtr partialRemapStatePtr = PartialUnmapState.GlobalState;
+            IntPtr localCountsPtr = IntPtr.Add(partialRemapStatePtr, PartialUnmapState.LocalCountsOffset);
+
+            // Get the lock first.
+            EmitNativeReaderLockAcquire(context, IntPtr.Add(partialRemapStatePtr, PartialUnmapState.PartialUnmapLockOffset));
+
+            IntPtr getCurrentThreadId = WindowsSignalHandlerRegistration.GetCurrentThreadIdFunc();
+            Operand threadId = context.Call(Const((ulong)getCurrentThreadId), OperandType.I32);
+            Operand threadIndex = EmitThreadLocalMapIntGetOrReserve(context, localCountsPtr, threadId, Const(0));
+
+            Operand endLabel = Label();
+            Operand retry = context.AllocateLocal(OperandType.I32);
+            Operand threadIndexValidLabel = Label();
+
+            context.BranchIfFalse(threadIndexValidLabel, context.ICompareEqual(threadIndex, Const(-1)));
+
+            context.Copy(retry, Const(1)); // Always retry when thread local cannot be allocated.
+
+            context.Branch(endLabel);
+
+            context.MarkLabel(threadIndexValidLabel);
+
+            Operand threadLocalPartialUnmapsPtr = EmitThreadLocalMapIntGetValuePtr(context, localCountsPtr, threadIndex);
+            Operand threadLocalPartialUnmaps = context.Load(OperandType.I32, threadLocalPartialUnmapsPtr);
+            Operand partialUnmapsCount = context.Load(OperandType.I32, Const((ulong)IntPtr.Add(partialRemapStatePtr, PartialUnmapState.PartialUnmapsCountOffset)));
+
+            context.Copy(retry, context.ICompareNotEqual(threadLocalPartialUnmaps, partialUnmapsCount));
+
+            Operand noRetryLabel = Label();
+
+            context.BranchIfFalse(noRetryLabel, retry);
+
+            // if (retry) {
+
+            context.Store(threadLocalPartialUnmapsPtr, partialUnmapsCount);
+
+            context.Branch(endLabel);
+
+            context.MarkLabel(noRetryLabel);
+
+            // }
+
+            context.MarkLabel(endLabel);
+
+            // Finally, release the lock and return the retry value.
+            EmitNativeReaderLockRelease(context, IntPtr.Add(partialRemapStatePtr, PartialUnmapState.PartialUnmapLockOffset));
+
+            return retry;
+        }
+
+        public static Operand EmitThreadLocalMapIntGetOrReserve(EmitterContext context, IntPtr threadLocalMapPtr, Operand threadId, Operand initialState)
+        {
+            Operand idsPtr = Const((ulong)IntPtr.Add(threadLocalMapPtr, ThreadLocalMap<int>.ThreadIdsOffset));
+
+            Operand i = context.AllocateLocal(OperandType.I32);
+
+            context.Copy(i, Const(0));
+
+            // (Loop 1) Check all slots for a matching Thread ID (while also trying to allocate)
+
+            Operand endLabel = Label();
+
+            Operand loopLabel = Label();
+            context.MarkLabel(loopLabel);
+
+            Operand offset = context.Multiply(i, Const(sizeof(int)));
+            Operand idPtr = context.Add(idsPtr, context.SignExtend32(OperandType.I64, offset));
+
+            // Check that this slot has the thread ID.
+            Operand existingId = context.CompareAndSwap(idPtr, threadId, threadId);
+
+            // If it was already the thread ID, then we just need to return i.
+            context.BranchIfTrue(endLabel, context.ICompareEqual(existingId, threadId));
+
+            context.Copy(i, context.Add(i, Const(1)));
+
+            context.BranchIfTrue(loopLabel, context.ICompareLess(i, Const(ThreadLocalMap<int>.MapSize)));
+
+            // (Loop 2) Try take a slot that is 0 with our Thread ID.
+
+            context.Copy(i, Const(0)); // Reset i.
+
+            Operand loop2Label = Label();
+            context.MarkLabel(loop2Label);
+
+            Operand offset2 = context.Multiply(i, Const(sizeof(int)));
+            Operand idPtr2 = context.Add(idsPtr, context.SignExtend32(OperandType.I64, offset2));
+
+            // Try and swap in the thread id on top of 0.
+            Operand existingId2 = context.CompareAndSwap(idPtr2, Const(0), threadId);
+
+            Operand idNot0Label = Label();
+
+            // If it was 0, then we need to initialize the struct entry and return i.
+            context.BranchIfFalse(idNot0Label, context.ICompareEqual(existingId2, Const(0)));
+
+            Operand structsPtr = Const((ulong)IntPtr.Add(threadLocalMapPtr, ThreadLocalMap<int>.StructsOffset));
+            Operand structPtr = context.Add(structsPtr, context.SignExtend32(OperandType.I64, offset2));
+            context.Store(structPtr, initialState);
+
+            context.Branch(endLabel);
+
+            context.MarkLabel(idNot0Label);
+
+            context.Copy(i, context.Add(i, Const(1)));
+
+            context.BranchIfTrue(loop2Label, context.ICompareLess(i, Const(ThreadLocalMap<int>.MapSize)));
+
+            context.Copy(i, Const(-1)); // Could not place the thread in the list.
+
+            context.MarkLabel(endLabel);
+
+            return context.Copy(i);
+        }
+
+        private static Operand EmitThreadLocalMapIntGetValuePtr(EmitterContext context, IntPtr threadLocalMapPtr, Operand index)
+        {
+            Operand offset = context.Multiply(index, Const(sizeof(int)));
+            Operand structsPtr = Const((ulong)IntPtr.Add(threadLocalMapPtr, ThreadLocalMap<int>.StructsOffset));
+
+            return context.Add(structsPtr, context.SignExtend32(OperandType.I64, offset));
+        }
+
+        private static void EmitThreadLocalMapIntRelease(EmitterContext context, IntPtr threadLocalMapPtr, Operand threadId, Operand index)
+        {
+            Operand offset = context.Multiply(index, Const(sizeof(int)));
+            Operand idsPtr = Const((ulong)IntPtr.Add(threadLocalMapPtr, ThreadLocalMap<int>.ThreadIdsOffset));
+            Operand idPtr = context.Add(idsPtr, context.SignExtend32(OperandType.I64, offset));
+
+            context.CompareAndSwap(idPtr, threadId, Const(0));
+        }
+
+        private static void EmitAtomicAddI32(EmitterContext context, Operand ptr, Operand additive)
+        {
+            Operand loop = Label();
+            context.MarkLabel(loop);
+
+            Operand initial = context.Load(OperandType.I32, ptr);
+            Operand newValue = context.Add(initial, additive);
+
+            Operand replaced = context.CompareAndSwap(ptr, initial, newValue);
+
+            context.BranchIfFalse(loop, context.ICompareEqual(initial, replaced));
+        }
+
+        private static void EmitNativeReaderLockAcquire(EmitterContext context, IntPtr nativeReaderLockPtr)
+        {
+            Operand writeLockPtr = Const((ulong)IntPtr.Add(nativeReaderLockPtr, NativeReaderWriterLock.WriteLockOffset));
+
+            // Spin until we can acquire the write lock.
+            Operand spinLabel = Label();
+            context.MarkLabel(spinLabel);
+
+            // Old value must be 0 to continue (we gained the write lock)
+            context.BranchIfTrue(spinLabel, context.CompareAndSwap(writeLockPtr, Const(0), Const(1)));
+
+            // Increment reader count.
+            EmitAtomicAddI32(context, Const((ulong)IntPtr.Add(nativeReaderLockPtr, NativeReaderWriterLock.ReaderCountOffset)), Const(1));
+
+            // Release write lock.
+            context.CompareAndSwap(writeLockPtr, Const(1), Const(0));
+        }
+
+        private static void EmitNativeReaderLockRelease(EmitterContext context, IntPtr nativeReaderLockPtr)
+        {
+            // Decrement reader count.
+            EmitAtomicAddI32(context, Const((ulong)IntPtr.Add(nativeReaderLockPtr, NativeReaderWriterLock.ReaderCountOffset)), Const(-1));
+        }
+    }
+}

ARMeilleure/Signal/WindowsSignalHandlerRegistration.cs

@@ -1,9 +1,10 @@
 using System;
+using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 
 namespace ARMeilleure.Signal
 {
-    class WindowsSignalHandlerRegistration
+    unsafe class WindowsSignalHandlerRegistration
     {
         [DllImport("kernel32.dll")]
         private static extern IntPtr AddVectoredExceptionHandler(uint first, IntPtr handler);
@@ -11,6 +12,14 @@ namespace ARMeilleure.Signal
         [DllImport("kernel32.dll")]
         private static extern ulong RemoveVectoredExceptionHandler(IntPtr handle);
 
+        [DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Ansi)]
+        static extern IntPtr LoadLibrary([MarshalAs(UnmanagedType.LPStr)] string lpFileName);
+
+        [DllImport("kernel32.dll", CharSet = CharSet.Ansi, ExactSpelling = true, SetLastError = true)]
+        private static extern IntPtr GetProcAddress(IntPtr hModule, string procName);
+
+        private static IntPtr _getCurrentThreadIdPtr;
+
         public static IntPtr RegisterExceptionHandler(IntPtr action)
         {
             return AddVectoredExceptionHandler(1, action);
@@ -20,5 +29,17 @@ namespace ARMeilleure.Signal
         {
             return RemoveVectoredExceptionHandler(handle) != 0;
         }
+
+        public static IntPtr GetCurrentThreadIdFunc()
+        {
+            if (_getCurrentThreadIdPtr == IntPtr.Zero)
+            {
+                IntPtr handle = LoadLibrary("kernel32.dll");
+
+                _getCurrentThreadIdPtr = GetProcAddress(handle, "GetCurrentThreadId");
+            }
+
+            return _getCurrentThreadIdPtr;
+        }
     }
 }

Ryujinx.Ava/AppHost.cs

@@ -1,5 +1,6 @@
 using ARMeilleure.Translation;
 using ARMeilleure.Translation.PTC;
+using Avalonia;
 using Avalonia.Input;
 using Avalonia.Threading;
 using LibHac.Tools.FsSystem;
@@ -13,6 +14,7 @@ using Ryujinx.Ava.Common.Locale;
 using Ryujinx.Ava.Input;
 using Ryujinx.Ava.Ui.Controls;
 using Ryujinx.Ava.Ui.Models;
+using Ryujinx.Ava.Ui.Vulkan;
 using Ryujinx.Ava.Ui.Windows;
 using Ryujinx.Common;
 using Ryujinx.Common.Configuration;
@@ -22,6 +24,7 @@ using Ryujinx.Graphics.GAL;
 using Ryujinx.Graphics.GAL.Multithreading;
 using Ryujinx.Graphics.Gpu;
 using Ryujinx.Graphics.OpenGL;
+using Ryujinx.Graphics.Vulkan;
 using Ryujinx.HLE.FileSystem;
 using Ryujinx.HLE.HOS;
 using Ryujinx.HLE.HOS.Services.Account.Acc;
@@ -366,6 +369,7 @@ namespace Ryujinx.Ava
             ConfigurationState.Instance.System.IgnoreMissingServices.Event -= UpdateIgnoreMissingServicesState;
             ConfigurationState.Instance.Graphics.AspectRatio.Event -= UpdateAspectRatioState;
             ConfigurationState.Instance.System.EnableDockedMode.Event -= UpdateDockedModeState;
+            ConfigurationState.Instance.System.AudioVolume.Event -= UpdateAudioVolumeState;
 
             _gpuCancellationTokenSource.Cancel();
             _gpuCancellationTokenSource.Dispose();
@@ -587,7 +591,23 @@ namespace Ryujinx.Ava
         {
             VirtualFileSystem.ReloadKeySet();
 
-            IRenderer renderer = new Renderer();
+            IRenderer renderer;
+
+            if (Program.UseVulkan)
+            {
+                var vulkan = AvaloniaLocator.Current.GetService<VulkanPlatformInterface>();
+                renderer = new VulkanRenderer(vulkan.Instance.InternalHandle,
+                    vulkan.Device.InternalHandle,
+                    vulkan.PhysicalDevice.InternalHandle,
+                    vulkan.Device.Queue.InternalHandle,
+                    vulkan.PhysicalDevice.QueueFamilyIndex,
+                    vulkan.Device.Lock);
+            }
+            else
+            {
+                renderer = new OpenGLRenderer();
+            }
+
             IHardwareDeviceDriver deviceDriver = new DummyHardwareDeviceDriver();
 
             BackendThreading threadingMode = ConfigurationState.Instance.Graphics.BackendThreading;
@@ -795,9 +815,12 @@ namespace Ryujinx.Ava
 
             _renderer.ScreenCaptured += Renderer_ScreenCaptured;
 
-            (_renderer as Renderer).InitializeBackgroundContext(SPBOpenGLContext.CreateBackgroundContext(Renderer.GameContext));
+            if (!Program.UseVulkan)
+            {
+                (_renderer as OpenGLRenderer).InitializeBackgroundContext(SPBOpenGLContext.CreateBackgroundContext((Renderer as OpenGLRendererControl).GameContext));
 
-            Renderer.MakeCurrent();
+                Renderer.MakeCurrent();
+            }
 
             Device.Gpu.Renderer.Initialize(_glLogLevel);
 
@@ -856,16 +879,15 @@ namespace Ryujinx.Ava
                 dockedMode += $" ({scale}x)";
             }
 
-            string vendor = _renderer is Renderer renderer ? renderer.GpuVendor : "";
-
             StatusUpdatedEvent?.Invoke(this, new StatusUpdatedEventArgs(
                 Device.EnableDeviceVsync,
                 Device.GetVolume(),
+                Program.UseVulkan ? "Vulkan" : "OpenGL",
                 dockedMode,
                 ConfigurationState.Instance.Graphics.AspectRatio.Value.ToText(),
                 LocaleManager.Instance["Game"] + $": {Device.Statistics.GetGameFrameRate():00.00} FPS ({Device.Statistics.GetGameFrameTime():00.00} ms)",
                 $"FIFO: {Device.Statistics.GetFifoPercent():00.00} %",
-                $"GPU: {vendor}"));
+                $"GPU: {_renderer.GetHardwareInfo().GpuVendor}"));
 
             Renderer.Present(image);
         }

Ryujinx.Ava/Assets/Locales/de_DE.json

@@ -118,11 +118,11 @@
   "SettingsTabSystemAudioBackendSoundIO": "SoundIO",
   "SettingsTabSystemAudioBackendSDL2": "SDL2",
   "SettingsTabSystemHacks": "Hacks",
-  "SettingsTabSystemHacksNote": " - Können Fehler verursachen",
+  "SettingsTabSystemHacksNote": " (Können Fehler verursachen)",
   "SettingsTabSystemExpandDramSize": "Erweitere DRAM Größe auf 6GB",
   "SettingsTabSystemIgnoreMissingServices": "Ignoriere fehlende Dienste",
   "SettingsTabGraphics": "Grafik",
-  "SettingsTabGraphicsEnhancements": "Verbesserungen",
+  "SettingsTabGraphicsAPI": "Grafik-API",
   "SettingsTabGraphicsEnableShaderCache": "Aktiviere den Shader Cache",
   "SettingsTabGraphicsAnisotropicFiltering": "Anisotrope Filterung:",
   "SettingsTabGraphicsAnisotropicFilteringAuto": "Auto",
@@ -416,7 +416,7 @@
   "CommonFavorite": "Favoriten",
   "OrderAscending": "Aufsteigend",
   "OrderDescending": "Absteigend",
-  "SettingsTabGraphicsFeatures": "Erweiterungen",
+  "SettingsTabGraphicsFeatures": "Erweiterungen & Verbesserungen",
   "ErrorWindowTitle": "Fehler-Fenster",
   "ToggleDiscordTooltip": "Aktiviert/Deaktiviert Discord Rich Presence",
   "AddGameDirBoxTooltip": "Gibt das Spielverzeichnis an, das der Liste hinzuzufügt wird",

Ryujinx.Ava/Assets/Locales/el_GR.json

@@ -118,11 +118,11 @@
   "SettingsTabSystemAudioBackendSoundIO": "SoundIO",
   "SettingsTabSystemAudioBackendSDL2": "SDL2",
   "SettingsTabSystemHacks": "Μικροδιορθώσεις",
-  "SettingsTabSystemHacksNote": " - Μπορεί να προκαλέσουν αστάθεια",
+  "SettingsTabSystemHacksNote": " (Μπορεί να προκαλέσουν αστάθεια)",
   "SettingsTabSystemExpandDramSize": "Επέκταση μεγέθους DRAM στα 6GB",
   "SettingsTabSystemIgnoreMissingServices": "Αγνόηση υπηρεσιών που λείπουν",
   "SettingsTabGraphics": "Γραφικά",
-  "SettingsTabGraphicsEnhancements": "Βελτιώσεις",
+  "SettingsTabGraphicsAPI": "API Γραφικά",
   "SettingsTabGraphicsEnableShaderCache": "Ενεργοποίηση Προσωρινής Μνήμης Shader",
   "SettingsTabGraphicsAnisotropicFiltering": "Ανισότροπο Φιλτράρισμα:",
   "SettingsTabGraphicsAnisotropicFilteringAuto": "Αυτόματο",
@@ -416,7 +416,7 @@
   "CommonFavorite": "Αγαπημένα",
   "OrderAscending": "Αύξουσα",
   "OrderDescending": "Φθίνουσα",
-  "SettingsTabGraphicsFeatures": "Χαρακτηριστικά",
+  "SettingsTabGraphicsFeatures": "Χαρακτηριστικά & Βελτιώσεις",
   "ErrorWindowTitle": "Παράθυρο σφάλματος",
   "ToggleDiscordTooltip": "Ενεργοποιεί ή απενεργοποιεί την Εμπλουτισμένη Παρουσία σας στο Discord",
   "AddGameDirBoxTooltip": "Εισαγάγετε μία τοποθεσία παιχνιδιών για προσθήκη στη λίστα",

Ryujinx.Ava/Assets/Locales/en_US.json

@@ -122,8 +122,8 @@
   "SettingsTabSystemExpandDramSize": "Expand DRAM Size to 6GB",
   "SettingsTabSystemIgnoreMissingServices": "Ignore Missing Services",
   "SettingsTabGraphics": "Graphics",
-  "SettingsTabGraphicsEnhancements": "Enhancements",
-  "SettingsTabGraphicsEnableShaderCache": "Shader Cache",
+  "SettingsTabGraphicsAPI": "Graphics API",
+  "SettingsTabGraphicsEnableShaderCache": "Enable Shader Cache",
   "SettingsTabGraphicsAnisotropicFiltering": "Anisotropic Filtering:",
   "SettingsTabGraphicsAnisotropicFilteringAuto": "Auto",
   "SettingsTabGraphicsAnisotropicFiltering2x": "2x",
@@ -416,7 +416,7 @@
   "CommonFavorite": "Favorite",
   "OrderAscending": "Ascending",
   "OrderDescending": "Descending",
-  "SettingsTabGraphicsFeatures": "Features",
+  "SettingsTabGraphicsFeatures": "Features & Enhancements",
   "ErrorWindowTitle": "Error Window",
   "ToggleDiscordTooltip": "Choose whether or not to display Ryujinx on your \"currently playing\" Discord activity",
   "AddGameDirBoxTooltip": "Enter a game directory to add to the list",
@@ -579,5 +579,14 @@
   "SettingsTabHotkeysResScaleUpHotkey": "Increase resolution:",
   "SettingsTabHotkeysResScaleDownHotkey": "Decrease resolution:",
   "UserProfilesName": "Name:",
-  "UserProfilesUserId" : "User Id:"
+  "UserProfilesUserId" : "User Id:",
+  "SettingsTabGraphicsBackend": "Graphics Backend",
+  "SettingsTabGraphicsBackendTooltip": "Graphics Backend to use",
+  "SettingsEnableTextureRecompression": "Enable Texture Recompression",
+  "SettingsEnableTextureRecompressionTooltip": "Compresses certain textures in order to reduce VRAM usage.\n\nRecommended for use with GPUs that have less than 4GB VRAM.\n\nLeave OFF if unsure.",
+  "SettingsTabGraphicsPreferredGpu": "Preferred GPU",
+  "SettingsTabGraphicsPreferredGpuTooltip": "Select the graphics card that will be used with the Vulkan graphics backend.\n\nDoes not affect the GPU that OpenGL will use.\n\nSet to the GPU flagged as \"dGPU\" if unsure. If there isn't one, leave untouched.",
+  "SettingsAppRequiredRestartMessage": "Ryujinx Restart Required",
+  "SettingsGpuBackendRestartMessage": "Graphics Backend or Gpu settings have been modified. This will require a restart to be applied",
+  "SettingsGpuBackendRestartSubMessage": "Do you want to restart now?"
 }

Ryujinx.Ava/Assets/Locales/es_ES.json

@@ -118,12 +118,12 @@
   "SettingsTabSystemAudioBackendSoundIO": "SoundIO",
   "SettingsTabSystemAudioBackendSDL2": "SDL2",
   "SettingsTabSystemHacks": "Hacks",
-  "SettingsTabSystemHacksNote": " - Pueden causar inestabilidad",
+  "SettingsTabSystemHacksNote": " (Pueden causar inestabilidad)",
   "SettingsTabSystemExpandDramSize": "Expandir DRAM a 6GB",
   "SettingsTabSystemIgnoreMissingServices": "Ignorar servicios no implementados",
   "SettingsTabGraphics": "Gráficos",
-  "SettingsTabGraphicsEnhancements": "Mejoras",
-  "SettingsTabGraphicsEnableShaderCache": "Caché de sombreadores",
+  "SettingsTabGraphicsAPI": "API de gráficos",
+  "SettingsTabGraphicsEnableShaderCache": "Habilitar caché de sombreadores",
   "SettingsTabGraphicsAnisotropicFiltering": "Filtro anisotrópico:",
   "SettingsTabGraphicsAnisotropicFilteringAuto": "Auto",
   "SettingsTabGraphicsAnisotropicFiltering2x": "x2",
@@ -416,7 +416,7 @@
   "CommonFavorite": "Favorito",
   "OrderAscending": "Ascendente",
   "OrderDescending": "Descendente",
-  "SettingsTabGraphicsFeatures": "Funcionalidades",
+  "SettingsTabGraphicsFeatures": "Funcionalidades & Mejoras",
   "ErrorWindowTitle": "Ventana de error",
   "ToggleDiscordTooltip": "Elige si muestras Ryujinx o no en tu actividad de Discord cuando lo estés usando",
   "AddGameDirBoxTooltip": "Elige un directorio de juegos para mostrar en la ventana principal",

Ryujinx.Ava/Assets/Locales/fr_FR.json

@@ -111,11 +111,11 @@
   "SettingsTabSystemAudioBackendSoundIO": "SoundIO",
   "SettingsTabSystemAudioBackendSDL2": "SDL2",
   "SettingsTabSystemHacks": "Hacks",
-  "SettingsTabSystemHacksNote": " - Cela peut causer des instabilitées",
+  "SettingsTabSystemHacksNote": " (Cela peut causer des instabilitées)",
   "SettingsTabSystemExpandDramSize": "Augmenter la taille de la DRAM à 6GB",
   "SettingsTabSystemIgnoreMissingServices": "Ignorer les services manquant",
   "SettingsTabGraphics": "Graphique",
-  "SettingsTabGraphicsEnhancements": "Améliorations",
+  "SettingsTabGraphicsAPI": "API Graphique",
   "SettingsTabGraphicsEnableShaderCache": "Activer le cache des shaders",
   "SettingsTabGraphicsAnisotropicFiltering": "Filtrage anisotrope:",
   "SettingsTabGraphicsAnisotropicFilteringAuto": "Auto",
@@ -138,6 +138,7 @@
   "SettingsTabGraphicsAspectRatioStretch": "Écran étiré",
   "SettingsTabGraphicsDeveloperOptions": "Options développeur",
   "SettingsTabGraphicsShaderDumpPath": "Chemin du dossier de dump des shaders:",
+  "SettingsTabGraphicsFeatures": "Fonctionnalités & Améliorations",
   "SettingsTabLogging": "Journaux",
   "SettingsTabLoggingLogging": "Journaux",
   "SettingsTabLoggingEnableLoggingToFile": "Activer la sauvegarde des journaux vers un fichier",

Ryujinx.Ava/Assets/Locales/it_IT.json

@@ -118,11 +118,11 @@
     "SettingsTabSystemAudioBackendSoundIO": "SoundIO",
     "SettingsTabSystemAudioBackendSDL2": "SDL2",
     "SettingsTabSystemHacks": "Hacks",
-    "SettingsTabSystemHacksNote": " - Possono causare instabilità",
+    "SettingsTabSystemHacksNote": " (Possono causare instabilità)",
     "SettingsTabSystemExpandDramSize": "Espandi dimensione DRAM a 6GB",
     "SettingsTabSystemIgnoreMissingServices": "Ignora servizi mancanti",
     "SettingsTabGraphics": "Grafica",
-    "SettingsTabGraphicsEnhancements": "Miglioramenti",
+    "SettingsTabGraphicsAPI": "API Grafiche",
     "SettingsTabGraphicsEnableShaderCache": "Attiva Shader Cache",
     "SettingsTabGraphicsAnisotropicFiltering": "Filtro anisotropico:",
     "SettingsTabGraphicsAnisotropicFilteringAuto": "Auto",
@@ -416,7 +416,7 @@
     "CommonFavorite": "Preferito",
     "OrderAscending": "Crescente",
     "OrderDescending": "Decrescente",
-    "SettingsTabGraphicsFeatures": "Funzionalità",
+    "SettingsTabGraphicsFeatures": "Funzionalità & Miglioramenti",
     "ErrorWindowTitle": "Finestra errore",
     "ToggleDiscordTooltip": "Attiva o disattiva Discord Rich Presence",
     "AddGameDirBoxTooltip": "Inserisci la directory di un gioco per aggiungerlo alla lista",

Ryujinx.Ava/Assets/Locales/ko_KR.json

@@ -118,11 +118,11 @@
   "SettingsTabSystemAudioBackendSoundIO": "SoundIO",
   "SettingsTabSystemAudioBackendSDL2": "SDL2",
   "SettingsTabSystemHacks": "해킹",
-  "SettingsTabSystemHacksNote": " - 불안정을 일으킬 수 있음",
+  "SettingsTabSystemHacksNote": " (불안정을 일으킬 수 있음)",
   "SettingsTabSystemExpandDramSize": "DRAM 크기를 6GB로 확장",
   "SettingsTabSystemIgnoreMissingServices": "누락된 서비스 무시",
   "SettingsTabGraphics": "제도법",
-  "SettingsTabGraphicsEnhancements": "개선 사항",
+  "SettingsTabGraphicsAPI": "그래픽 API",
   "SettingsTabGraphicsEnableShaderCache": "셰이더 캐시 활성화",
   "SettingsTabGraphicsAnisotropicFiltering": "이방성 필터링 :",
   "SettingsTabGraphicsAnisotropicFilteringAuto": "자동적 인",
@@ -415,7 +415,7 @@
   "CommonFavorite": "가장 좋아하는",
   "OrderAscending": "오름차순",
   "OrderDescending": "내림차순",
-  "SettingsTabGraphicsFeatures": "특징",
+  "SettingsTabGraphicsFeatures": "특징ㆍ개선 사항",
   "ErrorWindowTitle": "오류 창",
   "ToggleDiscordTooltip": "Discord Rich Presence 활성화 또는 비활성화",
   "AddGameDirBoxTooltip": "게임 디렉토리를 입력하여 목록에 추가하세요",

Ryujinx.Ava/Assets/Locales/pt_BR.json

@@ -118,11 +118,11 @@
   "SettingsTabSystemAudioBackendSoundIO": "SoundIO",
   "SettingsTabSystemAudioBackendSDL2": "SDL2",
   "SettingsTabSystemHacks": "Hacks",
-  "SettingsTabSystemHacksNote": " - Pode causar instabilidade",
+  "SettingsTabSystemHacksNote": " (Pode causar instabilidade)",
   "SettingsTabSystemExpandDramSize": "Expandir memória para 6GB",
   "SettingsTabSystemIgnoreMissingServices": "Ignorar serviços não implementados",
   "SettingsTabGraphics": "Gráficos",
-  "SettingsTabGraphicsEnhancements": "Melhorias",
+  "SettingsTabGraphicsAPI": "API gráfica",
   "SettingsTabGraphicsEnableShaderCache": "Habilitar cache de shader",
   "SettingsTabGraphicsAnisotropicFiltering": "Filtragem anisotrópica:",
   "SettingsTabGraphicsAnisotropicFilteringAuto": "Auto",
@@ -416,7 +416,7 @@
   "CommonFavorite": "Favorito",
   "OrderAscending": "Ascendente",
   "OrderDescending": "Descendente",
-  "SettingsTabGraphicsFeatures": "Recursos",
+  "SettingsTabGraphicsFeatures": "Recursos & Melhorias",
   "ErrorWindowTitle": "Janela de erro",
   "ToggleDiscordTooltip": "Habilita ou desabilita Discord Rich Presence",
   "AddGameDirBoxTooltip": "Escreva um diretório de jogo para adicionar à lista",

Ryujinx.Ava/Assets/Locales/ru_RU.json

@@ -118,11 +118,11 @@
   "SettingsTabSystemAudioBackendSoundIO": "SoundIO",
   "SettingsTabSystemAudioBackendSDL2": "SDL2",
   "SettingsTabSystemHacks": "Хаки",
-  "SettingsTabSystemHacksNote": " - Эти многие настройки вызывают нестабильность",
+  "SettingsTabSystemHacksNote": " (Эти многие настройки вызывают нестабильность)",
   "SettingsTabSystemExpandDramSize": "Увеличение размера DRAM до 6GB",
   "SettingsTabSystemIgnoreMissingServices": "Игнорировать отсутствующие службы",
   "SettingsTabGraphics": "Графика",
-  "SettingsTabGraphicsEnhancements": "Улучшения",
+  "SettingsTabGraphicsAPI": "Графические API",
   "SettingsTabGraphicsEnableShaderCache": "Включить кэш шейдеров",
   "SettingsTabGraphicsAnisotropicFiltering": "Анизотропная фильтрация:",
   "SettingsTabGraphicsAnisotropicFilteringAuto": "Автоматически",
@@ -377,7 +377,7 @@
   "DialogUpdateAddUpdateErrorMessage": "Указанный файл не содержит обновления для выбранного заголовка!",
   "DialogSettingsBackendThreadingWarningTitle": "Предупреждение: многопоточность в бэкенде",
   "DialogSettingsBackendThreadingWarningMessage": "Ryujinx необходимо перезапустить после изменения этой опции, чтобы она полностью применилась. В зависимости от вашей платформы вам может потребоваться вручную отключить собственную многопоточность вашего драйвера при использовании Ryujinx.",
-  "SettingsTabGraphicsFeaturesOptions": "Функции",
+  "SettingsTabGraphicsFeaturesOptions": "Функции & Улучшения",
   "SettingsTabGraphicsBackendMultithreading": "Многопоточность графического бэкенда:",
   "CommonAuto": "Автоматически",
   "CommonOff": "Выключен",

Ryujinx.Ava/Assets/Locales/tr_TR.json

@@ -118,11 +118,11 @@
   "SettingsTabSystemAudioBackendSoundIO": "SoundIO",
   "SettingsTabSystemAudioBackendSDL2": "SDL2",
   "SettingsTabSystemHacks": "Hacklar",
-  "SettingsTabSystemHacksNote": " - Bunlar birçok dengesizlik oluşturabilir",
+  "SettingsTabSystemHacksNote": " (Bunlar birçok dengesizlik oluşturabilir)",
   "SettingsTabSystemExpandDramSize": "DRAM boyutunu 6GB'a genişlet",
   "SettingsTabSystemIgnoreMissingServices": "Eksik Servisleri Görmezden Gel",
   "SettingsTabGraphics": "Grafikler",
-  "SettingsTabGraphicsEnhancements": "İyileştirmeler",
+  "SettingsTabGraphicsAPI": "Grafikler API",
   "SettingsTabGraphicsEnableShaderCache": "Shader Cache'i Etkinleştir",
   "SettingsTabGraphicsAnisotropicFiltering": "Anisotropic Filtering:",
   "SettingsTabGraphicsAnisotropicFilteringAuto": "Otomatik",
@@ -416,7 +416,7 @@
   "CommonFavorite": "Favori",
   "OrderAscending": "Artan",
   "OrderDescending": "Azalan",
-  "SettingsTabGraphicsFeatures": "Özellikler",
+  "SettingsTabGraphicsFeatures": "Özellikler & İyileştirmeler",
   "ErrorWindowTitle": "Hata Penceresi",
   "ToggleDiscordTooltip": "Discord Rich Presence'i Aç/Kapat",
   "AddGameDirBoxTooltip": "Listeye eklemek için bir oyun dizini ekleyin",

Ryujinx.Ava/Assets/Locales/zh_CN.json

@@ -118,11 +118,11 @@
   "SettingsTabSystemAudioBackendSoundIO": "SoundIO",
   "SettingsTabSystemAudioBackendSDL2": "SDL2",
   "SettingsTabSystemHacks": "修正",
-  "SettingsTabSystemHacksNote": " - 会引起模拟器不稳定",
+  "SettingsTabSystemHacksNote": " (会引起模拟器不稳定)",
   "SettingsTabSystemExpandDramSize": "将模拟RAM大小扩展到 6GB",
   "SettingsTabSystemIgnoreMissingServices": "忽略缺少的服务",
   "SettingsTabGraphics": "图像",
-  "SettingsTabGraphicsEnhancements": "增强",
+  "SettingsTabGraphicsAPI": "的图形 API",
   "SettingsTabGraphicsEnableShaderCache": "启用着色器缓存",
   "SettingsTabGraphicsAnisotropicFiltering": "各向异性过滤:",
   "SettingsTabGraphicsAnisotropicFilteringAuto": "自动",
@@ -416,7 +416,7 @@
   "CommonFavorite": "收藏",
   "OrderAscending": "从小到大",
   "OrderDescending": "从大到小",
-  "SettingsTabGraphicsFeatures": "额外功能",
+  "SettingsTabGraphicsFeatures": "额外功能和增强",
   "ErrorWindowTitle": "错误窗口",
   "ToggleDiscordTooltip": "启用或关闭 Discord 详细在线状态展示",
   "AddGameDirBoxTooltip": "输入要添加的游戏目录",

Ryujinx.Ava/Assets/Locales/zh_TW.json

@@ -118,7 +118,7 @@
   "SettingsTabSystemAudioBackendSoundIO": "SoundIO",
   "SettingsTabSystemAudioBackendSDL2": "SDL2",
   "SettingsTabSystemHacks": "修正",
-  "SettingsTabSystemHacksNote": " - 會引起模擬器不穩定",
+  "SettingsTabSystemHacksNote": " (會引起模擬器不穩定)",
   "SettingsTabSystemExpandDramSize": "將模擬記憶體大小擴充至 6GB",
   "SettingsTabSystemIgnoreMissingServices": "忽略缺少的服務",
   "SettingsTabGraphics": "圖形",

Ryujinx.Ava/Program.cs

@@ -3,6 +3,7 @@ using Avalonia;
 using Avalonia.OpenGL;
 using Avalonia.Rendering;
 using Avalonia.Threading;
+using Ryujinx.Ava.Ui.Backend;
 using Ryujinx.Ava.Ui.Controls;
 using Ryujinx.Ava.Ui.Windows;
 using Ryujinx.Common;
@@ -11,9 +12,12 @@ using Ryujinx.Common.GraphicsDriver;
 using Ryujinx.Common.Logging;
 using Ryujinx.Common.System;
 using Ryujinx.Common.SystemInfo;
+using Ryujinx.Graphics.Vulkan;
 using Ryujinx.Modules;
 using Ryujinx.Ui.Common;
 using Ryujinx.Ui.Common.Configuration;
+using Silk.NET.Vulkan.Extensions.EXT;
+using Silk.NET.Vulkan.Extensions.KHR;
 using System;
 using System.Collections.Generic;
 using System.IO;
@@ -25,17 +29,20 @@ namespace Ryujinx.Ava
     internal class Program
     {
         public static double WindowScaleFactor { get; set; }
+        public static double ActualScaleFactor { get; set; }
         public static string Version { get; private set; }
         public static string ConfigurationPath { get; private set; }
         public static string CommandLineProfile { get; set; }
         public static bool PreviewerDetached { get; private set; }
 
         public static RenderTimer RenderTimer { get; private set; }
+        public static bool UseVulkan { get; private set; }
 
         [DllImport("user32.dll", SetLastError = true)]
         public static extern int MessageBoxA(IntPtr hWnd, string text, string caption, uint type);
 
         private const uint MB_ICONWARNING = 0x30;
+        private const int BaseDpi = 96;
 
         public static void Main(string[] args)
         {
@@ -66,7 +73,7 @@ namespace Ryujinx.Ava
                     EnableMultiTouch = true,
                     EnableIme = true,
                     UseEGL = false,
-                    UseGpu = true,
+                    UseGpu = !UseVulkan,
                     GlProfiles = new List<GlVersion>()
                     {
                         new GlVersion(GlProfileType.OpenGL, 4, 3)
@@ -75,7 +82,7 @@ namespace Ryujinx.Ava
                 .With(new Win32PlatformOptions
                 {
                     EnableMultitouch = true,
-                    UseWgl = true,
+                    UseWgl = !UseVulkan,
                     WglProfiles = new List<GlVersion>()
                     {
                         new GlVersion(GlProfileType.OpenGL, 4, 3)
@@ -84,6 +91,19 @@ namespace Ryujinx.Ava
                     CompositionBackdropCornerRadius = 8f,
                 })
                 .UseSkia()
+                .With(new Ui.Vulkan.VulkanOptions()
+                {
+                    ApplicationName = "Ryujinx.Graphics.Vulkan",
+                    VulkanVersion = new Version(1, 2),
+                    MaxQueueCount = 2,
+                    PreferDiscreteGpu = true,
+                    PreferredDevice = !PreviewerDetached ? "" : ConfigurationState.Instance.Graphics.PreferredGpu.Value,
+                    UseDebug = !PreviewerDetached ? false : ConfigurationState.Instance.Logger.GraphicsDebugLevel.Value != GraphicsDebugLevel.None,
+                })
+                .With(new SkiaOptions()
+                {
+                    CustomGpuFactory = UseVulkan ? SkiaGpuFactory.CreateVulkanGpu : null
+                })
                 .AfterSetup(_ =>
                 {
                     AvaloniaLocator.CurrentMutable
@@ -136,9 +156,6 @@ namespace Ryujinx.Ava
                 }
             }
 
-            // Make process DPI aware for proper window sizing on high-res screens.
-            WindowScaleFactor = ForceDpiAware.GetWindowScaleFactor();
-
             // Delete backup files after updating.
             Task.Run(Updater.CleanupUpdate);
 
@@ -162,6 +179,18 @@ namespace Ryujinx.Ava
 
             ReloadConfig();
 
+            UseVulkan = PreviewerDetached ? ConfigurationState.Instance.Graphics.GraphicsBackend.Value == GraphicsBackend.Vulkan : false;
+
+            if (UseVulkan)
+            {
+                // With a custom gpu backend, avalonia doesn't enable dpi awareness, so the backend must handle it. This isn't so for the opengl backed,
+                // as that uses avalonia's gpu backend and it's enabled there.
+                ForceDpiAware.Windows();
+            }
+
+            WindowScaleFactor = ForceDpiAware.GetWindowScaleFactor();
+            ActualScaleFactor = ForceDpiAware.GetActualScaleFactor() / BaseDpi;
+
             // Logging system information.
             PrintSystemInfo();
 

Ryujinx.Ava/Ryujinx.Ava.csproj

@@ -28,16 +28,20 @@
     <PackageReference Include="FluentAvaloniaUI" Version="1.4.1" />
     <PackageReference Include="XamlNameReferenceGenerator" Version="1.3.4" />
 
+    <PackageReference Include="OpenTK.Core" Version="4.7.2" />
     <PackageReference Include="Ryujinx.Audio.OpenAL.Dependencies" Version="1.21.0.1" Condition="'$(RuntimeIdentifier)' != 'linux-x64' AND '$(RuntimeIdentifier)' != 'osx-x64'" />
     <PackageReference Include="Ryujinx.Graphics.Nvdec.Dependencies" Version="5.0.1-build10" Condition="'$(RuntimeIdentifier)' != 'linux-x64' AND '$(RuntimeIdentifier)' != 'osx-x64'" />
-    <PackageReference Include="OpenTK.Graphics" Version="4.7.2" />
-    <PackageReference Include="SPB" Version="0.0.4-build17" />
+    <PackageReference Include="Silk.NET.Vulkan" Version="2.10.1" />
+    <PackageReference Include="Silk.NET.Vulkan.Extensions.EXT" Version="2.10.1" />
+    <PackageReference Include="Silk.NET.Vulkan.Extensions.KHR" Version="2.10.1" />
+    <PackageReference Include="SPB" Version="0.0.4-build24" />
     <PackageReference Include="SharpZipLib" Version="1.3.3" />
     <PackageReference Include="SixLabors.ImageSharp" Version="1.0.4" />
   </ItemGroup>
 
   <ItemGroup>
     <ProjectReference Include="..\Ryujinx.Audio.Backends.SDL2\Ryujinx.Audio.Backends.SDL2.csproj" />
+    <ProjectReference Include="..\Ryujinx.Graphics.Vulkan\Ryujinx.Graphics.Vulkan.csproj" />
     <ProjectReference Include="..\Ryujinx.Input\Ryujinx.Input.csproj" />
     <ProjectReference Include="..\Ryujinx.Input.SDL2\Ryujinx.Input.SDL2.csproj" />
     <ProjectReference Include="..\Ryujinx.Audio.Backends.OpenAL\Ryujinx.Audio.Backends.OpenAL.csproj" />

Ryujinx.Ava/Ui/Applet/AvaloniaDynamicTextInputHandler.cs

@@ -135,7 +135,7 @@ namespace Ryujinx.Ava.Ui.Applet
             Dispatcher.UIThread.Post(() =>
             {
                 _hiddenTextBox.Clear();
-                _parent.GlRenderer.Focus();
+                _parent.RendererControl.Focus();
 
                 _parent = null;
             });

Ryujinx.Ava/Ui/Backend/BackendSurface.cs

@@ -0,0 +1,76 @@
+using Avalonia;
+using System;
+using System.Runtime.InteropServices;
+using static Ryujinx.Ava.Ui.Backend.Interop;
+
+namespace Ryujinx.Ava.Ui.Backend
+{
+    public abstract class BackendSurface : IDisposable
+    {
+        protected IntPtr Display => _display;
+
+        private IntPtr _display = IntPtr.Zero;
+
+        [DllImport("libX11.so.6")]
+        public static extern IntPtr XOpenDisplay(IntPtr display);
+
+        [DllImport("libX11.so.6")]
+        public static extern int XCloseDisplay(IntPtr display);
+
+        private PixelSize _currentSize;
+        public IntPtr Handle { get; protected set; }
+
+        public bool IsDisposed { get; private set; }
+
+        public BackendSurface(IntPtr handle)
+        {
+            Handle = handle;
+
+            if (OperatingSystem.IsLinux())
+            {
+                _display = XOpenDisplay(IntPtr.Zero);
+            }
+        }
+
+        public PixelSize Size
+        {
+            get
+            {
+                PixelSize size = new PixelSize();
+                if (OperatingSystem.IsWindows())
+                {
+                    GetClientRect(Handle, out var rect);
+                    size = new PixelSize(rect.right, rect.bottom);
+                }
+                else if (OperatingSystem.IsLinux())
+                {
+                    XWindowAttributes attributes = new XWindowAttributes();
+                    XGetWindowAttributes(Display, Handle, ref attributes);
+
+                    size = new PixelSize(attributes.width, attributes.height);
+                }
+
+                _currentSize = size;
+
+                return size;
+            }
+        }
+
+        public PixelSize CurrentSize => _currentSize;
+
+        public virtual void Dispose()
+        {
+            if (IsDisposed)
+            {
+                throw new ObjectDisposedException(nameof(BackendSurface));
+            }
+
+            IsDisposed = true;
+
+            if (_display != IntPtr.Zero)
+            {
+                XCloseDisplay(_display);
+            }
+        }
+    }
+}

Ryujinx.Ava/Ui/Backend/Interop.cs

@@ -0,0 +1,49 @@
+using FluentAvalonia.Interop;
+using System;
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.Ava.Ui.Backend
+{
+    public static class Interop
+    {
+        [StructLayout(LayoutKind.Sequential)]
+        public struct XWindowAttributes
+        {
+            public int x;
+            public int y;
+            public int width;
+            public int height;
+            public int border_width;
+            public int depth;
+            public IntPtr visual;
+            public IntPtr root;
+            public int c_class;
+            public int bit_gravity;
+            public int win_gravity;
+            public int backing_store;
+            public IntPtr backing_planes;
+            public IntPtr backing_pixel;
+            public int save_under;
+            public IntPtr colormap;
+            public int map_installed;
+            public int map_state;
+            public IntPtr all_event_masks;
+            public IntPtr your_event_mask;
+            public IntPtr do_not_propagate_mask;
+            public int override_direct;
+            public IntPtr screen;
+        }
+
+        [DllImport("user32.dll")]
+        public static extern bool GetClientRect(IntPtr hwnd, out RECT lpRect);
+
+        [DllImport("libX11.so.6")]
+        public static extern int XCloseDisplay(IntPtr display);
+
+        [DllImport("libX11.so.6")]
+        public static extern int XGetWindowAttributes(IntPtr display, IntPtr window, ref XWindowAttributes attributes);
+
+        [DllImport("libX11.so.6")]
+        public static extern IntPtr XOpenDisplay(IntPtr display);
+    }
+}

Ryujinx.Ava/Ui/Backend/SkiaGpuFactory.cs

@@ -0,0 +1,26 @@
+using Avalonia;
+using Avalonia.Skia;
+using Ryujinx.Ava.Ui.Vulkan;
+using Ryujinx.Ava.Ui.Backend.Vulkan;
+
+namespace Ryujinx.Ava.Ui.Backend
+{
+    public static class SkiaGpuFactory
+    {
+        public static ISkiaGpu CreateVulkanGpu()
+        {
+            var skiaOptions = AvaloniaLocator.Current.GetService<SkiaOptions>() ?? new SkiaOptions();
+            var platformInterface = AvaloniaLocator.Current.GetService<VulkanPlatformInterface>();
+
+            if (platformInterface == null)
+            {
+                VulkanPlatformInterface.TryInitialize();
+            }
+
+            var gpu = new VulkanSkiaGpu(skiaOptions.MaxGpuResourceSizeBytes);
+            AvaloniaLocator.CurrentMutable.Bind<VulkanSkiaGpu>().ToConstant(gpu);
+
+            return gpu;
+        }
+    }
+}

Ryujinx.Ava/Ui/Backend/Vulkan/ResultExtensions.cs

@@ -0,0 +1,16 @@
+using System;
+using Silk.NET.Vulkan;
+
+namespace Ryujinx.Ava.Ui.Vulkan
+{
+    public static class ResultExtensions
+    {
+        public static void ThrowOnError(this Result result)
+        {
+            if (result != Result.Success)
+            {
+                throw new Exception($"Unexpected API error \"{result}\".");
+            }
+        }
+    }
+}

Ryujinx.Ava/Ui/Backend/Vulkan/Skia/VulkanRenderTarget.cs

@@ -0,0 +1,135 @@
+using System;
+using Avalonia.Skia;
+using Ryujinx.Ava.Ui.Vulkan;
+using Ryujinx.Ava.Ui.Vulkan.Surfaces;
+using SkiaSharp;
+
+namespace Ryujinx.Ava.Ui.Backend.Vulkan
+{
+    internal class VulkanRenderTarget : ISkiaGpuRenderTarget
+    {
+        public GRContext GrContext { get; set; }
+
+        private readonly VulkanSurfaceRenderTarget _surface;
+        private readonly IVulkanPlatformSurface _vulkanPlatformSurface;
+
+        public VulkanRenderTarget(VulkanPlatformInterface vulkanPlatformInterface, IVulkanPlatformSurface vulkanPlatformSurface)
+        {
+            _surface = vulkanPlatformInterface.CreateRenderTarget(vulkanPlatformSurface);
+            _vulkanPlatformSurface = vulkanPlatformSurface;
+        }
+
+        public void Dispose()
+        {
+            _surface.Dispose();
+        }
+
+        public ISkiaGpuRenderSession BeginRenderingSession()
+        {
+            var session = _surface.BeginDraw(_vulkanPlatformSurface.Scaling);
+            bool success = false;
+            try
+            {
+                var disp = session.Display;
+                var api = session.Api;
+
+                var size = session.Size;
+                var scaling = session.Scaling;
+                if (size.Width <= 0 || size.Height <= 0 || scaling < 0)
+                {
+                    size = new Avalonia.PixelSize(1, 1);
+                    scaling = 1;
+                }
+
+                lock (GrContext)
+                {
+                    GrContext.ResetContext();
+
+                    var imageInfo = new GRVkImageInfo()
+                    {
+                        CurrentQueueFamily = disp.QueueFamilyIndex,
+                        Format = _surface.ImageFormat,
+                        Image = _surface.Image.Handle,
+                        ImageLayout = (uint)_surface.Image.CurrentLayout,
+                        ImageTiling = (uint)_surface.Image.Tiling,
+                        ImageUsageFlags = _surface.UsageFlags,
+                        LevelCount = _surface.MipLevels,
+                        SampleCount = 1,
+                        Protected = false,
+                        Alloc = new GRVkAlloc()
+                        {
+                            Memory = _surface.Image.MemoryHandle,
+                            Flags = 0,
+                            Offset = 0,
+                            Size = _surface.MemorySize
+                        }
+                    };
+
+                    var renderTarget =
+                        new GRBackendRenderTarget((int)size.Width, (int)size.Height, 1,
+                            imageInfo);
+                    var surface = SKSurface.Create(GrContext, renderTarget,
+                        GRSurfaceOrigin.TopLeft,
+                        _surface.IsRgba ? SKColorType.Rgba8888 : SKColorType.Bgra8888, SKColorSpace.CreateSrgb());
+
+                    if (surface == null)
+                    {
+                        throw new InvalidOperationException(
+                            "Surface can't be created with the provided render target");
+                    }
+
+                    success = true;
+
+                    return new VulkanGpuSession(GrContext, renderTarget, surface, session);
+                }
+            }
+            finally
+            {
+                if (!success)
+                {
+                    session.Dispose();
+                }
+            }
+        }
+
+        public bool IsCorrupted { get; }
+
+        internal class VulkanGpuSession : ISkiaGpuRenderSession
+        {
+            private readonly GRBackendRenderTarget _backendRenderTarget;
+            private readonly VulkanSurfaceRenderingSession _vulkanSession;
+
+            public VulkanGpuSession(GRContext grContext,
+                GRBackendRenderTarget backendRenderTarget,
+                SKSurface surface,
+                VulkanSurfaceRenderingSession vulkanSession)
+            {
+                GrContext = grContext;
+                _backendRenderTarget = backendRenderTarget;
+                SkSurface = surface;
+                _vulkanSession = vulkanSession;
+
+                SurfaceOrigin = GRSurfaceOrigin.TopLeft;
+            }
+
+            public void Dispose()
+            {
+                lock (_vulkanSession.Display.Lock)
+                {
+                    SkSurface.Canvas.Flush();
+
+                    SkSurface.Dispose();
+                    _backendRenderTarget.Dispose();
+                    GrContext.Flush();
+
+                    _vulkanSession.Dispose();
+                }
+            }
+
+            public GRContext GrContext { get; }
+            public SKSurface SkSurface { get; }
+            public double ScaleFactor => _vulkanSession.Scaling;
+            public GRSurfaceOrigin SurfaceOrigin { get; }
+        }
+    }
+}

Ryujinx.Ava/Ui/Backend/Vulkan/Skia/VulkanSkiaGpu.cs

@@ -0,0 +1,124 @@
+using System;
+using System.Collections.Generic;
+using Avalonia;
+using Avalonia.Platform;
+using Avalonia.Skia;
+using Avalonia.X11;
+using Ryujinx.Ava.Ui.Vulkan;
+using Silk.NET.Vulkan;
+using SkiaSharp;
+
+namespace Ryujinx.Ava.Ui.Backend.Vulkan
+{
+    public class VulkanSkiaGpu : ISkiaGpu
+    {
+        private readonly VulkanPlatformInterface _vulkan;
+        private readonly long? _maxResourceBytes;
+        private GRVkBackendContext _grVkBackend;
+        private bool _initialized;
+
+        public GRContext GrContext { get; private set; }
+
+        public VulkanSkiaGpu(long? maxResourceBytes)
+        {
+            _vulkan = AvaloniaLocator.Current.GetService<VulkanPlatformInterface>();
+            _maxResourceBytes = maxResourceBytes;
+        }
+
+        private void Initialize()
+        {
+            if (_initialized)
+            {
+                return;
+            }
+
+            _initialized = true;
+            GRVkGetProcedureAddressDelegate getProc = (string name, IntPtr instanceHandle, IntPtr deviceHandle) =>
+            {
+                IntPtr addr = IntPtr.Zero;
+
+                if (deviceHandle != IntPtr.Zero)
+                {
+                    addr = _vulkan.Device.Api.GetDeviceProcAddr(new Device(deviceHandle), name);
+
+                    if (addr != IntPtr.Zero)
+                    {
+                        return addr;
+                    }
+
+                    addr = _vulkan.Device.Api.GetDeviceProcAddr(new Device(_vulkan.Device.Handle), name);
+
+                    if (addr != IntPtr.Zero)
+                    {
+                        return addr;
+                    }
+                }
+
+                addr = _vulkan.Device.Api.GetInstanceProcAddr(new Instance(_vulkan.Instance.Handle), name);
+
+                if (addr == IntPtr.Zero)
+                {
+                    addr = _vulkan.Device.Api.GetInstanceProcAddr(new Instance(instanceHandle), name);
+                }
+
+                return addr;
+            };
+
+            _grVkBackend = new GRVkBackendContext()
+            {
+                VkInstance = _vulkan.Device.Handle,
+                VkPhysicalDevice = _vulkan.PhysicalDevice.Handle,
+                VkDevice = _vulkan.Device.Handle,
+                VkQueue = _vulkan.Device.Queue.Handle,
+                GraphicsQueueIndex = _vulkan.PhysicalDevice.QueueFamilyIndex,
+                GetProcedureAddress = getProc
+            };
+            GrContext = GRContext.CreateVulkan(_grVkBackend);
+            if (_maxResourceBytes.HasValue)
+            {
+                GrContext.SetResourceCacheLimit(_maxResourceBytes.Value);
+            }
+        }
+
+        public ISkiaGpuRenderTarget TryCreateRenderTarget(IEnumerable<object> surfaces)
+        {
+            foreach (var surface in surfaces)
+            {
+                VulkanWindowSurface window;
+
+                if (surface is IPlatformHandle handle)
+                {
+                    window = new VulkanWindowSurface(handle.Handle);
+                }
+                else if (surface is X11FramebufferSurface x11FramebufferSurface)
+                {
+                    // As of Avalonia 0.10.13, an IPlatformHandle isn't passed for linux, so use reflection to otherwise get the window id
+                    var xId = (IntPtr)x11FramebufferSurface.GetType().GetField(
+                        "_xid",
+                        System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance).GetValue(x11FramebufferSurface);
+
+                    window = new VulkanWindowSurface(xId);
+                }
+                else
+                {
+                    continue;
+                }
+
+                VulkanRenderTarget vulkanRenderTarget = new VulkanRenderTarget(_vulkan, window);
+
+                Initialize();
+
+                vulkanRenderTarget.GrContext = GrContext;
+
+                return vulkanRenderTarget;
+            }
+
+            return null;
+        }
+
+        public ISkiaSurface TryCreateSurface(PixelSize size, ISkiaGpuRenderSession session)
+        {
+            return null;
+        }
+    }
+}

Ryujinx.Ava/Ui/Backend/Vulkan/Skia/VulkanSurface.cs

@@ -0,0 +1,53 @@
+using Avalonia;
+using Ryujinx.Ava.Ui.Vulkan;
+using Ryujinx.Ava.Ui.Vulkan.Surfaces;
+using Silk.NET.Vulkan;
+using Silk.NET.Vulkan.Extensions.KHR;
+using System;
+
+namespace Ryujinx.Ava.Ui.Backend.Vulkan
+{
+    internal class VulkanWindowSurface : BackendSurface, IVulkanPlatformSurface
+    {
+        public float Scaling => (float)Program.ActualScaleFactor;
+
+        public PixelSize SurfaceSize => Size;
+
+        public VulkanWindowSurface(IntPtr handle) : base(handle)
+        {
+        }
+
+        public unsafe SurfaceKHR CreateSurface(VulkanInstance instance)
+        {
+            if (OperatingSystem.IsWindows())
+            {
+                if (instance.Api.TryGetInstanceExtension(new Instance(instance.Handle), out KhrWin32Surface surfaceExtension))
+                {
+                    var createInfo = new Win32SurfaceCreateInfoKHR() { Hinstance = 0, Hwnd = Handle, SType = StructureType.Win32SurfaceCreateInfoKhr };
+
+                    surfaceExtension.CreateWin32Surface(new Instance(instance.Handle), createInfo, null, out var surface).ThrowOnError();
+
+                    return surface;
+                }
+            }
+            else if (OperatingSystem.IsLinux())
+            {
+                if (instance.Api.TryGetInstanceExtension(new Instance(instance.Handle), out KhrXlibSurface surfaceExtension))
+                {
+                    var createInfo = new XlibSurfaceCreateInfoKHR()
+                    {
+                        SType = StructureType.XlibSurfaceCreateInfoKhr,
+                        Dpy = (nint*)Display,
+                        Window = Handle
+                    };
+
+                    surfaceExtension.CreateXlibSurface(new Instance(instance.Handle), createInfo, null, out var surface).ThrowOnError();
+
+                    return surface;
+                }
+            }
+
+            throw new PlatformNotSupportedException("The current platform does not support surface creation.");
+        }
+    }
+}

Ryujinx.Ava/Ui/Backend/Vulkan/Surfaces/IVulkanPlatformSurface.cs

@@ -0,0 +1,13 @@
+using System;
+using Avalonia;
+using Silk.NET.Vulkan;
+
+namespace Ryujinx.Ava.Ui.Vulkan.Surfaces
+{
+    public interface IVulkanPlatformSurface : IDisposable
+    {
+        float Scaling { get; }
+        PixelSize SurfaceSize { get; }
+        SurfaceKHR CreateSurface(VulkanInstance instance);
+    }
+}

Ryujinx.Ava/Ui/Backend/Vulkan/Surfaces/VulkanSurfaceRenderTarget.cs

@@ -0,0 +1,92 @@
+using System;
+using Avalonia;
+using Silk.NET.Vulkan;
+
+namespace Ryujinx.Ava.Ui.Vulkan.Surfaces
+{
+    internal class VulkanSurfaceRenderTarget : IDisposable
+    {
+        private readonly VulkanPlatformInterface _platformInterface;
+
+        private readonly Format _format;
+
+        public VulkanImage Image { get; private set; }
+        public bool IsCorrupted { get; private set; } = true;
+
+        public uint MipLevels => Image.MipLevels;
+
+        public VulkanSurfaceRenderTarget(VulkanPlatformInterface platformInterface, VulkanSurface surface)
+        {
+            _platformInterface = platformInterface;
+
+            Display = VulkanDisplay.CreateDisplay(platformInterface.Instance, platformInterface.Device,
+                platformInterface.PhysicalDevice, surface);
+            Surface = surface;
+
+            // Skia seems to only create surfaces from images with unorm format
+
+            IsRgba = Display.SurfaceFormat.Format >= Format.R8G8B8A8Unorm &&
+                     Display.SurfaceFormat.Format <= Format.R8G8B8A8Srgb;
+
+            _format = IsRgba ? Format.R8G8B8A8Unorm : Format.B8G8R8A8Unorm;
+        }
+
+        public bool IsRgba { get; }
+
+        public uint ImageFormat => (uint) _format;
+
+        public ulong MemorySize => Image.MemorySize;
+
+        public VulkanDisplay Display { get; }
+
+        public VulkanSurface Surface { get; }
+
+        public uint UsageFlags => Image.UsageFlags;
+
+        public PixelSize Size { get; private set; }
+
+        public void Dispose()
+        {
+            _platformInterface.Device.WaitIdle();
+            DestroyImage();
+            Display?.Dispose();
+            Surface?.Dispose();
+        }
+
+        public VulkanSurfaceRenderingSession BeginDraw(float scaling)
+        {
+            var session = new VulkanSurfaceRenderingSession(Display, _platformInterface.Device, this, scaling);
+
+            if (IsCorrupted)
+            {
+                IsCorrupted = false;
+                DestroyImage();
+                CreateImage();
+            }
+            else
+            {
+                Image.TransitionLayout(ImageLayout.ColorAttachmentOptimal, AccessFlags.AccessNoneKhr);
+            }
+
+            return session;
+        }
+
+        public void Invalidate()
+        {
+            IsCorrupted = true;
+        }
+
+        private void CreateImage()
+        {
+            Size = Display.Size;
+
+            Image = new VulkanImage(_platformInterface.Device, _platformInterface.PhysicalDevice, _platformInterface.Device.CommandBufferPool, ImageFormat, Size);
+        }
+
+        private void DestroyImage()
+        {
+            _platformInterface.Device.WaitIdle();
+            Image?.Dispose();
+        }
+    }
+}

Ryujinx.Ava/Ui/Backend/Vulkan/VulkanCommandBufferPool.cs

@@ -0,0 +1,182 @@
+using System;
+using System.Collections.Generic;
+using Silk.NET.Vulkan;
+
+namespace Ryujinx.Ava.Ui.Vulkan
+{
+    internal class VulkanCommandBufferPool : IDisposable
+    {
+        private readonly VulkanDevice _device;
+        private readonly CommandPool _commandPool;
+
+        private readonly List<VulkanCommandBuffer> _usedCommandBuffers = new();
+
+        public unsafe VulkanCommandBufferPool(VulkanDevice device, VulkanPhysicalDevice physicalDevice)
+        {
+            _device = device;
+
+            var commandPoolCreateInfo = new CommandPoolCreateInfo
+            {
+                SType = StructureType.CommandPoolCreateInfo,
+                Flags = CommandPoolCreateFlags.CommandPoolCreateResetCommandBufferBit,
+                QueueFamilyIndex = physicalDevice.QueueFamilyIndex
+            };
+
+            device.Api.CreateCommandPool(_device.InternalHandle, commandPoolCreateInfo, null, out _commandPool)
+                .ThrowOnError();
+        }
+
+        private CommandBuffer AllocateCommandBuffer()
+        {
+            var commandBufferAllocateInfo = new CommandBufferAllocateInfo
+            {
+                SType = StructureType.CommandBufferAllocateInfo,
+                CommandPool = _commandPool,
+                CommandBufferCount = 1,
+                Level = CommandBufferLevel.Primary
+            };
+
+            _device.Api.AllocateCommandBuffers(_device.InternalHandle, commandBufferAllocateInfo, out var commandBuffer);
+
+            return commandBuffer;
+        }
+
+        public VulkanCommandBuffer CreateCommandBuffer()
+        {
+            return new(_device, this);
+        }
+
+        public void FreeUsedCommandBuffers()
+        {
+            lock (_usedCommandBuffers)
+            {
+                foreach (var usedCommandBuffer in _usedCommandBuffers)
+                {
+                    usedCommandBuffer.Dispose();
+                }
+
+                _usedCommandBuffers.Clear();
+            }
+        }
+
+        private void DisposeCommandBuffer(VulkanCommandBuffer commandBuffer)
+        {
+            lock (_usedCommandBuffers)
+            {
+                _usedCommandBuffers.Add(commandBuffer);
+            }
+        }
+
+        public void Dispose()
+        {
+            FreeUsedCommandBuffers();
+            _device.Api.DestroyCommandPool(_device.InternalHandle, _commandPool, Span<AllocationCallbacks>.Empty);
+        }
+
+        public class VulkanCommandBuffer : IDisposable
+        {
+            private readonly VulkanCommandBufferPool _commandBufferPool;
+            private readonly VulkanDevice _device;
+            private readonly Fence _fence;
+            private bool _hasEnded;
+            private bool _hasStarted;
+
+            public IntPtr Handle => InternalHandle.Handle;
+
+            internal CommandBuffer InternalHandle { get; }
+
+            internal unsafe VulkanCommandBuffer(VulkanDevice device, VulkanCommandBufferPool commandBufferPool)
+            {
+                _device = device;
+                _commandBufferPool = commandBufferPool;
+
+                InternalHandle = _commandBufferPool.AllocateCommandBuffer();
+
+                var fenceCreateInfo = new FenceCreateInfo()
+                {
+                    SType = StructureType.FenceCreateInfo,
+                    Flags = FenceCreateFlags.FenceCreateSignaledBit
+                };
+
+                device.Api.CreateFence(device.InternalHandle, fenceCreateInfo, null, out _fence);
+            }
+
+            public void BeginRecording()
+            {
+                if (!_hasStarted)
+                {
+                    _hasStarted = true;
+
+                    var beginInfo = new CommandBufferBeginInfo
+                    {
+                        SType = StructureType.CommandBufferBeginInfo,
+                        Flags = CommandBufferUsageFlags.CommandBufferUsageOneTimeSubmitBit
+                    };
+
+                    _device.Api.BeginCommandBuffer(InternalHandle, beginInfo);
+                }
+            }
+
+            public void EndRecording()
+            {
+                if (_hasStarted && !_hasEnded)
+                {
+                    _hasEnded = true;
+
+                    _device.Api.EndCommandBuffer(InternalHandle);
+                }
+            }
+
+            public void Submit()
+            {
+                Submit(null, null, null, _fence);
+            }
+
+            public unsafe void Submit(
+                ReadOnlySpan<Semaphore> waitSemaphores,
+                ReadOnlySpan<PipelineStageFlags> waitDstStageMask,
+                ReadOnlySpan<Semaphore> signalSemaphores,
+                Fence? fence = null)
+            {
+                EndRecording();
+
+                if (!fence.HasValue)
+                {
+                    fence = _fence;
+                }
+
+                fixed (Semaphore* pWaitSemaphores = waitSemaphores, pSignalSemaphores = signalSemaphores)
+                {
+                    fixed (PipelineStageFlags* pWaitDstStageMask = waitDstStageMask)
+                    {
+                        var commandBuffer = InternalHandle;
+                        var submitInfo = new SubmitInfo
+                        {
+                            SType = StructureType.SubmitInfo,
+                            WaitSemaphoreCount = waitSemaphores != null ? (uint)waitSemaphores.Length : 0,
+                            PWaitSemaphores = pWaitSemaphores,
+                            PWaitDstStageMask = pWaitDstStageMask,
+                            CommandBufferCount = 1,
+                            PCommandBuffers = &commandBuffer,
+                            SignalSemaphoreCount = signalSemaphores != null ? (uint)signalSemaphores.Length : 0,
+                            PSignalSemaphores = pSignalSemaphores,
+                        };
+
+                        _device.Api.ResetFences(_device.InternalHandle, 1, fence.Value);
+
+                        _device.Submit(submitInfo, fence.Value);
+                    }
+                }
+
+                _commandBufferPool.DisposeCommandBuffer(this);
+            }
+
+            public void Dispose()
+            {
+                _device.Api.WaitForFences(_device.InternalHandle, 1, _fence, true, ulong.MaxValue);
+                _device.Api.FreeCommandBuffers(_device.InternalHandle, _commandBufferPool._commandPool, 1, InternalHandle);
+                _device.Api.DestroyFence(_device.InternalHandle, _fence, Span<AllocationCallbacks>.Empty);
+            }
+        }
+    }
+}

Ryujinx.Ava/Ui/Backend/Vulkan/VulkanDevice.cs

@@ -0,0 +1,67 @@
+using System;
+using Silk.NET.Vulkan;
+
+namespace Ryujinx.Ava.Ui.Vulkan
+{
+    internal class VulkanDevice : IDisposable
+    {
+        private static object _lock = new object();
+
+        public VulkanDevice(Device apiHandle, VulkanPhysicalDevice physicalDevice, Vk api)
+        {
+            InternalHandle = apiHandle;
+            Api = api;
+
+            api.GetDeviceQueue(apiHandle, physicalDevice.QueueFamilyIndex, 0, out var queue);
+
+            var vulkanQueue = new VulkanQueue(this, queue);
+            Queue = vulkanQueue;
+
+            PresentQueue = vulkanQueue;
+
+            CommandBufferPool = new VulkanCommandBufferPool(this, physicalDevice);
+        }
+
+        public IntPtr Handle => InternalHandle.Handle;
+
+        internal Device InternalHandle { get; }
+        public Vk Api { get; }
+
+        public VulkanQueue Queue { get; private set; }
+        public VulkanQueue PresentQueue { get; }
+        public VulkanCommandBufferPool CommandBufferPool { get; }
+
+        public void Dispose()
+        {
+            WaitIdle();
+            CommandBufferPool?.Dispose();
+            Queue = null;
+        }
+
+        internal void Submit(SubmitInfo submitInfo, Fence fence = default)
+        {
+            lock (_lock)
+            {
+                Api.QueueSubmit(Queue.InternalHandle, 1, submitInfo, fence).ThrowOnError();
+            }
+        }
+
+        public void WaitIdle()
+        {
+            lock (_lock)
+            {
+                Api.DeviceWaitIdle(InternalHandle);
+            }
+        }
+
+        public void QueueWaitIdle()
+        {
+            lock (_lock)
+            {
+                Api.QueueWaitIdle(Queue.InternalHandle);
+            }
+        }
+
+        public object Lock => _lock;
+    }
+}

Ryujinx.Ava/Ui/Backend/Vulkan/VulkanDisplay.cs

@@ -0,0 +1,439 @@
+using System;
+using System.Linq;
+using System.Threading;
+using Avalonia;
+using Ryujinx.Ava.Ui.Vulkan.Surfaces;
+using Ryujinx.Ui.Common.Configuration;
+using Silk.NET.Vulkan;
+using Silk.NET.Vulkan.Extensions.KHR;
+
+namespace Ryujinx.Ava.Ui.Vulkan
+{
+    internal class VulkanDisplay : IDisposable
+    {
+        private static KhrSwapchain _swapchainExtension;
+        private readonly VulkanInstance _instance;
+        private readonly VulkanPhysicalDevice _physicalDevice;
+        private readonly VulkanSemaphorePair _semaphorePair;
+        private uint _nextImage;
+        private readonly VulkanSurface _surface;
+        private SurfaceFormatKHR _surfaceFormat;
+        private SwapchainKHR _swapchain;
+        private Extent2D _swapchainExtent;
+        private Image[] _swapchainImages;
+        private VulkanDevice _device { get; }
+        private ImageView[] _swapchainImageViews = new ImageView[0];
+        private bool _vsyncStateChanged;
+        private bool _vsyncEnabled;
+
+        public VulkanCommandBufferPool CommandBufferPool { get; set; }
+
+        public object Lock => _device.Lock;
+
+        private VulkanDisplay(VulkanInstance instance, VulkanDevice device,
+            VulkanPhysicalDevice physicalDevice, VulkanSurface surface, SwapchainKHR swapchain,
+            Extent2D swapchainExtent)
+        {
+            _instance = instance;
+            _device = device;
+            _physicalDevice = physicalDevice;
+            _swapchain = swapchain;
+            _swapchainExtent = swapchainExtent;
+            _surface = surface;
+
+            CreateSwapchainImages();
+
+            _semaphorePair = new VulkanSemaphorePair(_device);
+
+            CommandBufferPool = new VulkanCommandBufferPool(device, physicalDevice);
+        }
+
+        public PixelSize Size { get; private set; }
+        public uint QueueFamilyIndex => _physicalDevice.QueueFamilyIndex;
+
+        internal SurfaceFormatKHR SurfaceFormat
+        {
+            get
+            {
+                if (_surfaceFormat.Format == Format.Undefined)
+                {
+                    _surfaceFormat = _surface.GetSurfaceFormat(_physicalDevice);
+                }
+
+                return _surfaceFormat;
+            }
+        }
+
+        public void Dispose()
+        {
+            _device.WaitIdle();
+            _semaphorePair?.Dispose();
+            DestroyCurrentImageViews();
+            _swapchainExtension.DestroySwapchain(_device.InternalHandle, _swapchain, Span<AllocationCallbacks>.Empty);
+            CommandBufferPool.Dispose();
+        }
+
+        private static unsafe SwapchainKHR CreateSwapchain(VulkanInstance instance, VulkanDevice device,
+            VulkanPhysicalDevice physicalDevice, VulkanSurface surface, out Extent2D swapchainExtent,
+            SwapchainKHR? oldswapchain = null, bool vsyncEnabled = true)
+        {
+            if (_swapchainExtension == null)
+            {
+                instance.Api.TryGetDeviceExtension(instance.InternalHandle, device.InternalHandle, out _swapchainExtension);
+            }
+
+            while (!surface.CanSurfacePresent(physicalDevice))
+            {
+                Thread.Sleep(16);
+            }
+
+            VulkanSurface.SurfaceExtension.GetPhysicalDeviceSurfaceCapabilities(physicalDevice.InternalHandle,
+                surface.ApiHandle, out var capabilities);
+
+            var imageCount = capabilities.MinImageCount + 1;
+            if (capabilities.MaxImageCount > 0 && imageCount > capabilities.MaxImageCount)
+            {
+                imageCount = capabilities.MaxImageCount;
+            }
+
+            var surfaceFormat = surface.GetSurfaceFormat(physicalDevice);
+
+            bool supportsIdentityTransform = capabilities.SupportedTransforms.HasFlag(SurfaceTransformFlagsKHR.SurfaceTransformIdentityBitKhr);
+            bool isRotated = capabilities.CurrentTransform.HasFlag(SurfaceTransformFlagsKHR.SurfaceTransformRotate90BitKhr) ||
+                capabilities.CurrentTransform.HasFlag(SurfaceTransformFlagsKHR.SurfaceTransformRotate270BitKhr);
+
+            swapchainExtent = GetSwapchainExtent(surface, capabilities);
+
+            CompositeAlphaFlagsKHR compositeAlphaFlags = GetSuitableCompositeAlphaFlags(capabilities);
+
+            PresentModeKHR presentMode = GetSuitablePresentMode(physicalDevice, surface, vsyncEnabled);
+
+            var swapchainCreateInfo = new SwapchainCreateInfoKHR
+            {
+                SType = StructureType.SwapchainCreateInfoKhr,
+                Surface = surface.ApiHandle,
+                MinImageCount = imageCount,
+                ImageFormat = surfaceFormat.Format,
+                ImageColorSpace = surfaceFormat.ColorSpace,
+                ImageExtent = swapchainExtent,
+                ImageUsage =
+                    ImageUsageFlags.ImageUsageColorAttachmentBit | ImageUsageFlags.ImageUsageTransferDstBit,
+                ImageSharingMode = SharingMode.Exclusive,
+                ImageArrayLayers = 1,
+                PreTransform = supportsIdentityTransform && isRotated ?
+                    SurfaceTransformFlagsKHR.SurfaceTransformIdentityBitKhr :
+                    capabilities.CurrentTransform,
+                CompositeAlpha = compositeAlphaFlags,
+                PresentMode = presentMode,
+                Clipped = true,
+                OldSwapchain = oldswapchain ?? new SwapchainKHR()
+            };
+
+            _swapchainExtension.CreateSwapchain(device.InternalHandle, swapchainCreateInfo, null, out var swapchain)
+                .ThrowOnError();
+
+            if (oldswapchain != null)
+            {
+                _swapchainExtension.DestroySwapchain(device.InternalHandle, oldswapchain.Value, null);
+            }
+
+            return swapchain;
+        }
+
+        private static unsafe Extent2D GetSwapchainExtent(VulkanSurface surface, SurfaceCapabilitiesKHR capabilities)
+        {
+            Extent2D swapchainExtent;
+            if (capabilities.CurrentExtent.Width != uint.MaxValue)
+            {
+                swapchainExtent = capabilities.CurrentExtent;
+            }
+            else
+            {
+                var surfaceSize = surface.SurfaceSize;
+
+                var width = Math.Clamp((uint)surfaceSize.Width, capabilities.MinImageExtent.Width, capabilities.MaxImageExtent.Width);
+                var height = Math.Clamp((uint)surfaceSize.Height, capabilities.MinImageExtent.Height, capabilities.MaxImageExtent.Height);
+
+                swapchainExtent = new Extent2D(width, height);
+            }
+
+            return swapchainExtent;
+        }
+
+        private static unsafe CompositeAlphaFlagsKHR GetSuitableCompositeAlphaFlags(SurfaceCapabilitiesKHR capabilities)
+        {
+            var compositeAlphaFlags = CompositeAlphaFlagsKHR.CompositeAlphaOpaqueBitKhr;
+
+            if (capabilities.SupportedCompositeAlpha.HasFlag(CompositeAlphaFlagsKHR.CompositeAlphaPostMultipliedBitKhr))
+            {
+                compositeAlphaFlags = CompositeAlphaFlagsKHR.CompositeAlphaPostMultipliedBitKhr;
+            }
+            else if (capabilities.SupportedCompositeAlpha.HasFlag(CompositeAlphaFlagsKHR.CompositeAlphaPreMultipliedBitKhr))
+            {
+                compositeAlphaFlags = CompositeAlphaFlagsKHR.CompositeAlphaPreMultipliedBitKhr;
+            }
+
+            return compositeAlphaFlags;
+        }
+
+        private static unsafe PresentModeKHR GetSuitablePresentMode(VulkanPhysicalDevice physicalDevice, VulkanSurface surface, bool vsyncEnabled)
+        {
+            uint presentModesCount;
+
+            VulkanSurface.SurfaceExtension.GetPhysicalDeviceSurfacePresentModes(physicalDevice.InternalHandle,
+                surface.ApiHandle,
+                &presentModesCount, null);
+
+            var presentModes = new PresentModeKHR[presentModesCount];
+
+            fixed (PresentModeKHR* pPresentModes = presentModes)
+            {
+                VulkanSurface.SurfaceExtension.GetPhysicalDeviceSurfacePresentModes(physicalDevice.InternalHandle,
+                    surface.ApiHandle, &presentModesCount, pPresentModes);
+            }
+
+            var modes = presentModes.ToList();
+            var presentMode = PresentModeKHR.PresentModeFifoKhr;
+
+            if (!vsyncEnabled && modes.Contains(PresentModeKHR.PresentModeImmediateKhr))
+            {
+                presentMode = PresentModeKHR.PresentModeImmediateKhr;
+            }
+            else if (modes.Contains(PresentModeKHR.PresentModeMailboxKhr))
+            {
+                presentMode = PresentModeKHR.PresentModeMailboxKhr;
+            }
+            else if (modes.Contains(PresentModeKHR.PresentModeImmediateKhr))
+            {
+                presentMode = PresentModeKHR.PresentModeImmediateKhr;
+            }
+
+            return presentMode;
+        }
+
+        internal static VulkanDisplay CreateDisplay(VulkanInstance instance, VulkanDevice device,
+            VulkanPhysicalDevice physicalDevice, VulkanSurface surface)
+        {
+            var swapchain = CreateSwapchain(instance, device, physicalDevice, surface, out var extent, null, true);
+
+            return new VulkanDisplay(instance, device, physicalDevice, surface, swapchain, extent);
+        }
+
+        private unsafe void CreateSwapchainImages()
+        {
+            DestroyCurrentImageViews();
+
+            Size = new PixelSize((int)_swapchainExtent.Width, (int)_swapchainExtent.Height);
+
+            uint imageCount = 0;
+
+            _swapchainExtension.GetSwapchainImages(_device.InternalHandle, _swapchain, &imageCount, null);
+
+            _swapchainImages = new Image[imageCount];
+
+            fixed (Image* pSwapchainImages = _swapchainImages)
+            {
+                _swapchainExtension.GetSwapchainImages(_device.InternalHandle, _swapchain, &imageCount, pSwapchainImages);
+            }
+
+            _swapchainImageViews = new ImageView[imageCount];
+
+            var surfaceFormat = SurfaceFormat;
+
+            for (var i = 0; i < imageCount; i++)
+            {
+                _swapchainImageViews[i] = CreateSwapchainImageView(_swapchainImages[i], surfaceFormat.Format);
+            }
+        }
+
+        private void DestroyCurrentImageViews()
+        {
+            for (var i = 0; i < _swapchainImageViews.Length; i++)
+            {
+                _instance.Api.DestroyImageView(_device.InternalHandle, _swapchainImageViews[i], Span<AllocationCallbacks>.Empty);
+            }
+        }
+
+        internal void ChangeVSyncMode(bool vsyncEnabled)
+        {
+            _vsyncStateChanged = true;
+            _vsyncEnabled = vsyncEnabled;
+        }
+
+        private void Recreate()
+        {
+            _device.WaitIdle();
+            _swapchain = CreateSwapchain(_instance, _device, _physicalDevice, _surface, out _swapchainExtent, _swapchain, _vsyncEnabled);
+
+            CreateSwapchainImages();
+        }
+
+        private unsafe ImageView CreateSwapchainImageView(Image swapchainImage, Format format)
+        {
+            var componentMapping = new ComponentMapping(
+                ComponentSwizzle.Identity,
+                ComponentSwizzle.Identity,
+                ComponentSwizzle.Identity,
+                ComponentSwizzle.Identity);
+
+            var subresourceRange = new ImageSubresourceRange(ImageAspectFlags.ImageAspectColorBit, 0, 1, 0, 1);
+
+            var imageCreateInfo = new ImageViewCreateInfo
+            {
+                SType = StructureType.ImageViewCreateInfo,
+                Image = swapchainImage,
+                ViewType = ImageViewType.ImageViewType2D,
+                Format = format,
+                Components = componentMapping,
+                SubresourceRange = subresourceRange
+            };
+
+            _instance.Api.CreateImageView(_device.InternalHandle, imageCreateInfo, null, out var imageView).ThrowOnError();
+            return imageView;
+        }
+
+        public bool EnsureSwapchainAvailable()
+        {
+            if (Size != _surface.SurfaceSize || _vsyncStateChanged)
+            {
+                _vsyncStateChanged = false;
+
+                Recreate();
+
+                return false;
+            }
+
+            return true;
+        }
+
+        internal VulkanCommandBufferPool.VulkanCommandBuffer StartPresentation(VulkanSurfaceRenderTarget renderTarget)
+        {
+            _nextImage = 0;
+            while (true)
+            {
+                var acquireResult = _swapchainExtension.AcquireNextImage(
+                    _device.InternalHandle,
+                    _swapchain,
+                    ulong.MaxValue,
+                    _semaphorePair.ImageAvailableSemaphore,
+                    new Fence(),
+                    ref _nextImage);
+
+                if (acquireResult == Result.ErrorOutOfDateKhr ||
+                    acquireResult == Result.SuboptimalKhr)
+                {
+                    Recreate();
+                }
+                else
+                {
+                    acquireResult.ThrowOnError();
+                    break;
+                }
+            }
+
+            var commandBuffer = CommandBufferPool.CreateCommandBuffer();
+            commandBuffer.BeginRecording();
+
+            VulkanMemoryHelper.TransitionLayout(_device, commandBuffer.InternalHandle,
+                _swapchainImages[_nextImage], ImageLayout.Undefined,
+                AccessFlags.AccessNoneKhr,
+                ImageLayout.TransferDstOptimal,
+                AccessFlags.AccessTransferWriteBit,
+                1);
+
+            return commandBuffer;
+        }
+
+        internal void BlitImageToCurrentImage(VulkanSurfaceRenderTarget renderTarget, CommandBuffer commandBuffer)
+        {
+            VulkanMemoryHelper.TransitionLayout(_device, commandBuffer,
+                renderTarget.Image.InternalHandle.Value, (ImageLayout)renderTarget.Image.CurrentLayout,
+                AccessFlags.AccessNoneKhr,
+                ImageLayout.TransferSrcOptimal,
+                AccessFlags.AccessTransferReadBit,
+                renderTarget.MipLevels);
+
+            var srcBlitRegion = new ImageBlit
+            {
+                SrcOffsets = new ImageBlit.SrcOffsetsBuffer
+                {
+                    Element0 = new Offset3D(0, 0, 0),
+                    Element1 = new Offset3D(renderTarget.Size.Width, renderTarget.Size.Height, 1),
+                },
+                DstOffsets = new ImageBlit.DstOffsetsBuffer
+                {
+                    Element0 = new Offset3D(0, 0, 0),
+                    Element1 = new Offset3D(Size.Width, Size.Height, 1),
+                },
+                SrcSubresource = new ImageSubresourceLayers
+                {
+                    AspectMask = ImageAspectFlags.ImageAspectColorBit,
+                    BaseArrayLayer = 0,
+                    LayerCount = 1,
+                    MipLevel = 0
+                },
+                DstSubresource = new ImageSubresourceLayers
+                {
+                    AspectMask = ImageAspectFlags.ImageAspectColorBit,
+                    BaseArrayLayer = 0,
+                    LayerCount = 1,
+                    MipLevel = 0
+                }
+            };
+
+            _device.Api.CmdBlitImage(commandBuffer, renderTarget.Image.InternalHandle.Value,
+                ImageLayout.TransferSrcOptimal,
+                _swapchainImages[_nextImage],
+                ImageLayout.TransferDstOptimal,
+                1,
+                srcBlitRegion,
+                Filter.Linear);
+
+            VulkanMemoryHelper.TransitionLayout(_device, commandBuffer,
+                renderTarget.Image.InternalHandle.Value, ImageLayout.TransferSrcOptimal,
+                AccessFlags.AccessTransferReadBit,
+                (ImageLayout)renderTarget.Image.CurrentLayout,
+                AccessFlags.AccessNoneKhr,
+                renderTarget.MipLevels);
+        }
+
+        internal unsafe void EndPresentation(VulkanCommandBufferPool.VulkanCommandBuffer commandBuffer)
+        {
+            VulkanMemoryHelper.TransitionLayout(_device, commandBuffer.InternalHandle,
+                _swapchainImages[_nextImage], ImageLayout.TransferDstOptimal,
+                AccessFlags.AccessNoneKhr,
+                ImageLayout.PresentSrcKhr,
+                AccessFlags.AccessNoneKhr,
+                1);
+
+            commandBuffer.Submit(
+                stackalloc[] { _semaphorePair.ImageAvailableSemaphore },
+                stackalloc[] { PipelineStageFlags.PipelineStageColorAttachmentOutputBit },
+                stackalloc[] { _semaphorePair.RenderFinishedSemaphore });
+
+            var semaphore = _semaphorePair.RenderFinishedSemaphore;
+            var swapchain = _swapchain;
+            var nextImage = _nextImage;
+
+            Result result;
+
+            var presentInfo = new PresentInfoKHR
+            {
+                SType = StructureType.PresentInfoKhr,
+                WaitSemaphoreCount = 1,
+                PWaitSemaphores = &semaphore,
+                SwapchainCount = 1,
+                PSwapchains = &swapchain,
+                PImageIndices = &nextImage,
+                PResults = &result
+            };
+
+            lock (_device.Lock)
+            {
+                _swapchainExtension.QueuePresent(_device.PresentQueue.InternalHandle, presentInfo);
+            }
+
+            CommandBufferPool.FreeUsedCommandBuffers();
+        }
+    }
+}

Ryujinx.Ava/Ui/Backend/Vulkan/VulkanImage.cs

@@ -0,0 +1,167 @@
+using System;
+using Avalonia;
+using Silk.NET.Vulkan;
+
+namespace Ryujinx.Ava.Ui.Vulkan
+{
+    internal class VulkanImage : IDisposable
+    {
+        private readonly VulkanDevice _device;
+        private readonly VulkanPhysicalDevice _physicalDevice;
+        private readonly VulkanCommandBufferPool _commandBufferPool;
+        private ImageLayout _currentLayout;
+        private AccessFlags _currentAccessFlags;
+        private ImageUsageFlags _imageUsageFlags { get; }
+        private ImageView? _imageView { get; set; }
+        private DeviceMemory _imageMemory { get; set; }
+
+        internal Image? InternalHandle { get; private set; }
+        internal Format Format { get; }
+        internal ImageAspectFlags AspectFlags { get; private set; }
+
+        public ulong Handle => InternalHandle?.Handle ?? 0;
+        public ulong ViewHandle => _imageView?.Handle ?? 0;
+        public uint UsageFlags => (uint)_imageUsageFlags;
+        public ulong MemoryHandle => _imageMemory.Handle;
+        public uint MipLevels { get; private set; }
+        public PixelSize Size { get; }
+        public ulong MemorySize { get; private set; }
+        public uint CurrentLayout => (uint)_currentLayout;
+
+        public VulkanImage(
+            VulkanDevice device,
+            VulkanPhysicalDevice physicalDevice,
+            VulkanCommandBufferPool commandBufferPool,
+            uint format,
+            PixelSize size,
+            uint mipLevels = 0)
+        {
+            _device = device;
+            _physicalDevice = physicalDevice;
+            _commandBufferPool = commandBufferPool;
+            Format = (Format)format;
+            Size = size;
+            MipLevels = mipLevels;
+            _imageUsageFlags =
+                ImageUsageFlags.ImageUsageColorAttachmentBit | ImageUsageFlags.ImageUsageTransferDstBit |
+                ImageUsageFlags.ImageUsageTransferSrcBit | ImageUsageFlags.ImageUsageSampledBit;
+
+            Initialize();
+        }
+
+        public unsafe void Initialize()
+        {
+            if (!InternalHandle.HasValue)
+            {
+                MipLevels = MipLevels != 0 ? MipLevels : (uint)Math.Floor(Math.Log(Math.Max(Size.Width, Size.Height), 2));
+
+                var imageCreateInfo = new ImageCreateInfo
+                {
+                    SType = StructureType.ImageCreateInfo,
+                    ImageType = ImageType.ImageType2D,
+                    Format = Format,
+                    Extent = new Extent3D((uint?)Size.Width, (uint?)Size.Height, 1),
+                    MipLevels = MipLevels,
+                    ArrayLayers = 1,
+                    Samples = SampleCountFlags.SampleCount1Bit,
+                    Tiling = Tiling,
+                    Usage = _imageUsageFlags,
+                    SharingMode = SharingMode.Exclusive,
+                    InitialLayout = ImageLayout.Undefined,
+                    Flags = ImageCreateFlags.ImageCreateMutableFormatBit
+                };
+
+                _device.Api.CreateImage(_device.InternalHandle, imageCreateInfo, null, out var image).ThrowOnError();
+                InternalHandle = image;
+
+                _device.Api.GetImageMemoryRequirements(_device.InternalHandle, InternalHandle.Value,
+                    out var memoryRequirements);
+
+                var memoryAllocateInfo = new MemoryAllocateInfo
+                {
+                    SType = StructureType.MemoryAllocateInfo,
+                    AllocationSize = memoryRequirements.Size,
+                    MemoryTypeIndex = (uint)VulkanMemoryHelper.FindSuitableMemoryTypeIndex(
+                        _physicalDevice,
+                        memoryRequirements.MemoryTypeBits, MemoryPropertyFlags.MemoryPropertyDeviceLocalBit)
+                };
+
+                _device.Api.AllocateMemory(_device.InternalHandle, memoryAllocateInfo, null,
+                    out var imageMemory);
+
+                _imageMemory = imageMemory;
+
+                _device.Api.BindImageMemory(_device.InternalHandle, InternalHandle.Value, _imageMemory, 0);
+
+                MemorySize = memoryRequirements.Size;
+
+                var componentMapping = new ComponentMapping(
+                    ComponentSwizzle.Identity,
+                    ComponentSwizzle.Identity,
+                    ComponentSwizzle.Identity,
+                    ComponentSwizzle.Identity);
+
+                AspectFlags = ImageAspectFlags.ImageAspectColorBit;
+
+                var subresourceRange = new ImageSubresourceRange(AspectFlags, 0, MipLevels, 0, 1);
+
+                var imageViewCreateInfo = new ImageViewCreateInfo
+                {
+                    SType = StructureType.ImageViewCreateInfo,
+                    Image = InternalHandle.Value,
+                    ViewType = ImageViewType.ImageViewType2D,
+                    Format = Format,
+                    Components = componentMapping,
+                    SubresourceRange = subresourceRange
+                };
+
+                _device.Api
+                    .CreateImageView(_device.InternalHandle, imageViewCreateInfo, null, out var imageView)
+                    .ThrowOnError();
+
+                _imageView = imageView;
+
+                _currentLayout = ImageLayout.Undefined;
+
+                TransitionLayout(ImageLayout.ColorAttachmentOptimal, AccessFlags.AccessNoneKhr);
+            }
+        }
+
+        public ImageTiling Tiling => ImageTiling.Optimal;
+
+        internal void TransitionLayout(ImageLayout destinationLayout, AccessFlags destinationAccessFlags)
+        {
+            var commandBuffer = _commandBufferPool.CreateCommandBuffer();
+            commandBuffer.BeginRecording();
+
+            VulkanMemoryHelper.TransitionLayout(_device, commandBuffer.InternalHandle, InternalHandle.Value,
+                _currentLayout,
+                _currentAccessFlags,
+                destinationLayout, destinationAccessFlags,
+                MipLevels);
+
+            commandBuffer.EndRecording();
+
+            commandBuffer.Submit();
+
+            _currentLayout = destinationLayout;
+            _currentAccessFlags = destinationAccessFlags;
+        }
+
+        public void TransitionLayout(uint destinationLayout, uint destinationAccessFlags)
+        {
+            TransitionLayout((ImageLayout)destinationLayout, (AccessFlags)destinationAccessFlags);
+        }
+
+        public unsafe void Dispose()
+        {
+            _device.Api.DestroyImageView(_device.InternalHandle, _imageView.Value, null);
+            _device.Api.DestroyImage(_device.InternalHandle, InternalHandle.Value, null);
+            _device.Api.FreeMemory(_device.InternalHandle, _imageMemory, null);
+
+            _imageView = default;
+            InternalHandle = default;
+            _imageMemory = default;
+        }
+    }
+}

Ryujinx.Ava/Ui/Backend/Vulkan/VulkanInstance.cs

@@ -0,0 +1,136 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.InteropServices;
+using Silk.NET.Core;
+using Silk.NET.Vulkan;
+using Silk.NET.Vulkan.Extensions.EXT;
+
+namespace Ryujinx.Ava.Ui.Vulkan
+{
+    public class VulkanInstance : IDisposable
+    {
+        private const string EngineName = "Avalonia Vulkan";
+
+        private VulkanInstance(Instance apiHandle, Vk api)
+        {
+            InternalHandle = apiHandle;
+            Api = api;
+        }
+
+        public IntPtr Handle => InternalHandle.Handle;
+
+        internal Instance InternalHandle { get; }
+        public Vk Api { get; }
+
+        internal static IEnumerable<string> RequiredInstanceExtensions
+        {
+            get
+            {
+                yield return "VK_KHR_surface";
+                if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
+                {
+                    yield return "VK_KHR_xlib_surface";
+                }
+                else if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+                {
+                    yield return "VK_KHR_win32_surface";
+                }
+            }
+        }
+
+        public void Dispose()
+        {
+            Api?.DestroyInstance(InternalHandle, Span<AllocationCallbacks>.Empty);
+            Api?.Dispose();
+        }
+
+        internal static unsafe VulkanInstance Create(VulkanOptions options)
+        {
+            var api = Vk.GetApi();
+            var applicationName = Marshal.StringToHGlobalAnsi(options.ApplicationName);
+            var engineName = Marshal.StringToHGlobalAnsi(EngineName);
+            var enabledExtensions = new List<string>(options.InstanceExtensions);
+
+            enabledExtensions.AddRange(RequiredInstanceExtensions);
+
+            var applicationInfo = new ApplicationInfo
+            {
+                PApplicationName = (byte*)applicationName,
+                ApiVersion = new Version32((uint)options.VulkanVersion.Major, (uint)options.VulkanVersion.Minor,
+                    (uint)options.VulkanVersion.Build),
+                PEngineName = (byte*)engineName,
+                EngineVersion = new Version32(1, 0, 0),
+                ApplicationVersion = new Version32(1, 0, 0)
+            };
+
+            var enabledLayers = new HashSet<string>();
+
+            if (options.UseDebug)
+            {
+                enabledExtensions.Add(ExtDebugUtils.ExtensionName);
+                enabledExtensions.Add(ExtDebugReport.ExtensionName);
+                if (IsLayerAvailable(api, "VK_LAYER_KHRONOS_validation"))
+                    enabledLayers.Add("VK_LAYER_KHRONOS_validation");
+            }
+
+            foreach (var layer in options.EnabledLayers)
+                enabledLayers.Add(layer);
+
+            var ppEnabledExtensions = stackalloc IntPtr[enabledExtensions.Count];
+            var ppEnabledLayers = stackalloc IntPtr[enabledLayers.Count];
+
+            for (var i = 0; i < enabledExtensions.Count; i++)
+                ppEnabledExtensions[i] = Marshal.StringToHGlobalAnsi(enabledExtensions[i]);
+
+            var layers = enabledLayers.ToList();
+
+            for (var i = 0; i < enabledLayers.Count; i++)
+                ppEnabledLayers[i] = Marshal.StringToHGlobalAnsi(layers[i]);
+
+            var instanceCreateInfo = new InstanceCreateInfo
+            {
+                SType = StructureType.InstanceCreateInfo,
+                PApplicationInfo = &applicationInfo,
+                PpEnabledExtensionNames = (byte**)ppEnabledExtensions,
+                PpEnabledLayerNames = (byte**)ppEnabledLayers,
+                EnabledExtensionCount = (uint)enabledExtensions.Count,
+                EnabledLayerCount = (uint)enabledLayers.Count
+            };
+
+            api.CreateInstance(in instanceCreateInfo, null, out var instance).ThrowOnError();
+
+            Marshal.FreeHGlobal(applicationName);
+            Marshal.FreeHGlobal(engineName);
+
+            for (var i = 0; i < enabledExtensions.Count; i++) Marshal.FreeHGlobal(ppEnabledExtensions[i]);
+
+            for (var i = 0; i < enabledLayers.Count; i++) Marshal.FreeHGlobal(ppEnabledLayers[i]);
+
+            return new VulkanInstance(instance, api);
+        }
+
+        private static unsafe bool IsLayerAvailable(Vk api, string layerName)
+        {
+            uint layerPropertiesCount;
+
+            api.EnumerateInstanceLayerProperties(&layerPropertiesCount, null).ThrowOnError();
+
+            var layerProperties = new LayerProperties[layerPropertiesCount];
+
+            fixed (LayerProperties* pLayerProperties = layerProperties)
+            {
+                api.EnumerateInstanceLayerProperties(&layerPropertiesCount, layerProperties).ThrowOnError();
+
+                for (var i = 0; i < layerPropertiesCount; i++)
+                {
+                    var currentLayerName = Marshal.PtrToStringAnsi((IntPtr)pLayerProperties[i].LayerName);
+
+                    if (currentLayerName == layerName) return true;
+                }
+            }
+
+            return false;
+        }
+    }
+}

Ryujinx.Ava/Ui/Backend/Vulkan/VulkanMemoryHelper.cs

@@ -0,0 +1,59 @@
+using Silk.NET.Vulkan;
+
+namespace Ryujinx.Ava.Ui.Vulkan
+{
+    internal static class VulkanMemoryHelper
+    {
+        internal static int FindSuitableMemoryTypeIndex(VulkanPhysicalDevice physicalDevice, uint memoryTypeBits,
+            MemoryPropertyFlags flags)
+        {
+            physicalDevice.Api.GetPhysicalDeviceMemoryProperties(physicalDevice.InternalHandle, out var properties);
+
+            for (var i = 0; i < properties.MemoryTypeCount; i++)
+            {
+                var type = properties.MemoryTypes[i];
+
+                if ((memoryTypeBits & (1 << i)) != 0 && type.PropertyFlags.HasFlag(flags)) return i;
+            }
+
+            return -1;
+        }
+
+        internal static unsafe void TransitionLayout(VulkanDevice device,
+            CommandBuffer commandBuffer,
+            Image image,
+            ImageLayout sourceLayout,
+            AccessFlags sourceAccessMask,
+            ImageLayout destinationLayout,
+            AccessFlags destinationAccessMask,
+            uint mipLevels)
+        {
+            var subresourceRange = new ImageSubresourceRange(ImageAspectFlags.ImageAspectColorBit, 0, mipLevels, 0, 1);
+
+            var barrier = new ImageMemoryBarrier
+            {
+                SType = StructureType.ImageMemoryBarrier,
+                SrcAccessMask = sourceAccessMask,
+                DstAccessMask = destinationAccessMask,
+                OldLayout = sourceLayout,
+                NewLayout = destinationLayout,
+                SrcQueueFamilyIndex = Vk.QueueFamilyIgnored,
+                DstQueueFamilyIndex = Vk.QueueFamilyIgnored,
+                Image = image,
+                SubresourceRange = subresourceRange
+            };
+
+            device.Api.CmdPipelineBarrier(
+                commandBuffer,
+                PipelineStageFlags.PipelineStageAllCommandsBit,
+                PipelineStageFlags.PipelineStageAllCommandsBit,
+                0,
+                0,
+                null,
+                0,
+                null,
+                1,
+                barrier);
+        }
+    }
+}

Ryujinx.Ava/Ui/Backend/Vulkan/VulkanOptions.cs

@@ -0,0 +1,49 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Ryujinx.Ava.Ui.Vulkan
+{
+    public class VulkanOptions
+    {
+        /// <summary>
+        /// Sets the application name of the Vulkan instance
+        /// </summary>
+        public string ApplicationName { get; set; }
+
+        /// <summary>
+        /// Specifies the Vulkan API version to use
+        /// </summary>
+        public Version VulkanVersion { get; set; } = new Version(1, 1, 0);
+
+        /// <summary>
+        /// Specifies additional extensions to enable if available on the instance
+        /// </summary>
+        public IEnumerable<string> InstanceExtensions { get; set; } = Enumerable.Empty<string>();
+
+        /// <summary>
+        /// Specifies layers to enable if available on the instance
+        /// </summary>
+        public IEnumerable<string> EnabledLayers { get; set; } = Enumerable.Empty<string>();
+
+        /// <summary>
+        /// Enables the debug layer
+        /// </summary>
+        public bool UseDebug { get; set; }
+
+        /// <summary>
+        /// Selects the first suitable discrete GPU available
+        /// </summary>
+        public bool PreferDiscreteGpu { get; set; }
+
+        /// <summary>
+        /// Sets the device to use if available and suitable.
+        /// </summary>
+        public string PreferredDevice { get; set; }
+
+        /// <summary>
+        /// Max number of device queues to request
+        /// </summary>
+        public uint MaxQueueCount { get; set; }
+    }
+}

Ryujinx.Ava/Ui/Backend/Vulkan/VulkanPhysicalDevice.cs

@@ -0,0 +1,219 @@
+using Ryujinx.Graphics.Vulkan;
+using Silk.NET.Core;
+using Silk.NET.Vulkan;
+using Silk.NET.Vulkan.Extensions.KHR;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.Ava.Ui.Vulkan
+{
+    public unsafe class VulkanPhysicalDevice
+    {
+        private VulkanPhysicalDevice(PhysicalDevice apiHandle, Vk api, uint queueCount, uint queueFamilyIndex)
+        {
+            InternalHandle = apiHandle;
+            Api = api;
+            QueueCount = queueCount;
+            QueueFamilyIndex = queueFamilyIndex;
+
+            api.GetPhysicalDeviceProperties(apiHandle, out var properties);
+
+            DeviceName = Marshal.PtrToStringAnsi((IntPtr)properties.DeviceName);
+            DeviceId = VulkanInitialization.StringFromIdPair(properties.VendorID, properties.DeviceID);
+
+            var version = (Version32)properties.ApiVersion;
+            ApiVersion = new Version((int)version.Major, (int)version.Minor, 0, (int)version.Patch);
+        }
+
+        internal PhysicalDevice InternalHandle { get; }
+        internal Vk Api { get; }
+        public uint QueueCount { get; }
+        public uint QueueFamilyIndex { get; }
+        public IntPtr Handle => InternalHandle.Handle;
+
+        public string DeviceName { get; }
+        public string DeviceId { get; }
+        public Version ApiVersion { get; }
+        public static Dictionary<PhysicalDevice, PhysicalDeviceProperties> PhysicalDevices { get; private set; }
+        public static IEnumerable<KeyValuePair<PhysicalDevice, PhysicalDeviceProperties>> SuitableDevices { get; private set; }
+
+        internal static void SelectAvailableDevices(VulkanInstance instance,
+            VulkanSurface surface, bool preferDiscreteGpu, string preferredDevice)
+        {
+            uint physicalDeviceCount;
+
+            instance.Api.EnumeratePhysicalDevices(instance.InternalHandle, &physicalDeviceCount, null).ThrowOnError();
+
+            var physicalDevices = new PhysicalDevice[physicalDeviceCount];
+
+            fixed (PhysicalDevice* pPhysicalDevices = physicalDevices)
+            {
+                instance.Api.EnumeratePhysicalDevices(instance.InternalHandle, &physicalDeviceCount, pPhysicalDevices)
+                    .ThrowOnError();
+            }
+
+            PhysicalDevices = new Dictionary<PhysicalDevice, PhysicalDeviceProperties>();
+
+            foreach (var physicalDevice in physicalDevices)
+            {
+                instance.Api.GetPhysicalDeviceProperties(physicalDevice, out var properties);
+                PhysicalDevices.Add(physicalDevice, properties);
+            }
+
+            SuitableDevices = PhysicalDevices.Where(x => IsSuitableDevice(
+                instance.Api,
+                x.Key,
+                x.Value,
+                surface.ApiHandle,
+                out _,
+                out _));
+        }
+
+        internal static VulkanPhysicalDevice FindSuitablePhysicalDevice(VulkanInstance instance,
+            VulkanSurface surface, bool preferDiscreteGpu, string preferredDevice)
+        {
+            SelectAvailableDevices(instance, surface, preferDiscreteGpu, preferredDevice);
+
+            uint queueFamilyIndex = 0;
+            uint queueCount = 0;
+
+            if (!string.IsNullOrWhiteSpace(preferredDevice))
+            {
+                var physicalDevice = SuitableDevices.FirstOrDefault(x => VulkanInitialization.StringFromIdPair(x.Value.VendorID, x.Value.DeviceID) == preferredDevice);
+
+                queueFamilyIndex = FindSuitableQueueFamily(instance.Api, physicalDevice.Key,
+                    surface.ApiHandle, out queueCount);
+                if (queueFamilyIndex != int.MaxValue)
+                {
+                    return new VulkanPhysicalDevice(physicalDevice.Key, instance.Api, queueCount, queueFamilyIndex);
+                }
+            }
+
+            if (preferDiscreteGpu)
+            {
+                var discreteGpus = SuitableDevices.Where(p => p.Value.DeviceType == PhysicalDeviceType.DiscreteGpu);
+
+                foreach (var gpu in discreteGpus)
+                {
+                    queueFamilyIndex = FindSuitableQueueFamily(instance.Api, gpu.Key,
+                    surface.ApiHandle, out queueCount);
+                    if (queueFamilyIndex != int.MaxValue)
+                    {
+                        return new VulkanPhysicalDevice(gpu.Key, instance.Api, queueCount, queueFamilyIndex);
+                    }
+                }
+            }
+
+            foreach (var physicalDevice in SuitableDevices)
+            {
+                queueFamilyIndex = FindSuitableQueueFamily(instance.Api, physicalDevice.Key,
+                     surface.ApiHandle, out queueCount);
+                if (queueFamilyIndex != int.MaxValue)
+                {
+                    return new VulkanPhysicalDevice(physicalDevice.Key, instance.Api, queueCount, queueFamilyIndex);
+                }
+            }
+
+            throw new Exception("No suitable physical device found");
+        }
+
+        private static unsafe bool IsSuitableDevice(Vk api, PhysicalDevice physicalDevice, PhysicalDeviceProperties properties, SurfaceKHR surface,
+            out uint queueCount, out uint familyIndex)
+        {
+            queueCount = 0;
+            familyIndex = 0;
+
+            if (properties.DeviceType == PhysicalDeviceType.Cpu) return false;
+
+            var extensionMatches = 0;
+            uint propertiesCount;
+
+            api.EnumerateDeviceExtensionProperties(physicalDevice, (byte*)null, &propertiesCount, null).ThrowOnError();
+
+            var extensionProperties = new ExtensionProperties[propertiesCount];
+
+            fixed (ExtensionProperties* pExtensionProperties = extensionProperties)
+            {
+                api.EnumerateDeviceExtensionProperties(
+                    physicalDevice,
+                    (byte*)null,
+                    &propertiesCount,
+                    pExtensionProperties).ThrowOnError();
+
+                for (var i = 0; i < propertiesCount; i++)
+                {
+                    var extensionName = Marshal.PtrToStringAnsi((IntPtr)pExtensionProperties[i].ExtensionName);
+
+                    if (VulkanInitialization.RequiredExtensions.Contains(extensionName))
+                    {
+                        extensionMatches++;
+                    }
+                }
+            }
+
+            if (extensionMatches == VulkanInitialization.RequiredExtensions.Length)
+            {
+                familyIndex = FindSuitableQueueFamily(api, physicalDevice, surface, out queueCount);
+
+                return familyIndex != uint.MaxValue;
+            }
+
+            return false;
+        }
+
+        internal unsafe string[] GetSupportedExtensions()
+        {
+            uint propertiesCount;
+
+            Api.EnumerateDeviceExtensionProperties(InternalHandle, (byte*)null, &propertiesCount, null).ThrowOnError();
+
+            var extensionProperties = new ExtensionProperties[propertiesCount];
+
+            fixed (ExtensionProperties* pExtensionProperties = extensionProperties)
+            {
+                Api.EnumerateDeviceExtensionProperties(InternalHandle, (byte*)null, &propertiesCount, pExtensionProperties)
+                    .ThrowOnError();
+            }
+
+            return extensionProperties.Select(x => Marshal.PtrToStringAnsi((IntPtr)x.ExtensionName)).ToArray();
+        }
+
+        private static uint FindSuitableQueueFamily(Vk api, PhysicalDevice physicalDevice, SurfaceKHR surface,
+            out uint queueCount)
+        {
+            const QueueFlags RequiredFlags = QueueFlags.QueueGraphicsBit | QueueFlags.QueueComputeBit;
+
+            var khrSurface = new KhrSurface(api.Context);
+
+            uint propertiesCount;
+
+            api.GetPhysicalDeviceQueueFamilyProperties(physicalDevice, &propertiesCount, null);
+
+            var properties = new QueueFamilyProperties[propertiesCount];
+
+            fixed (QueueFamilyProperties* pProperties = properties)
+            {
+                api.GetPhysicalDeviceQueueFamilyProperties(physicalDevice, &propertiesCount, pProperties);
+            }
+
+            for (uint index = 0; index < propertiesCount; index++)
+            {
+                var queueFlags = properties[index].QueueFlags;
+
+                khrSurface.GetPhysicalDeviceSurfaceSupport(physicalDevice, index, surface, out var surfaceSupported)
+                    .ThrowOnError();
+
+                if (queueFlags.HasFlag(RequiredFlags) && surfaceSupported)
+                {
+                    queueCount = properties[index].QueueCount;
+                    return index;
+                }
+            }
+
+            queueCount = 0;
+            return uint.MaxValue;
+        }
+    }
+}

Ryujinx.Ava/Ui/Backend/Vulkan/VulkanPlatformInterface.cs

@@ -0,0 +1,80 @@
+using Avalonia;
+using Ryujinx.Ava.Ui.Vulkan.Surfaces;
+using Ryujinx.Graphics.Vulkan;
+using Silk.NET.Vulkan;
+using System;
+
+namespace Ryujinx.Ava.Ui.Vulkan
+{
+    internal class VulkanPlatformInterface : IDisposable
+    {
+        private static VulkanOptions _options;
+
+        private VulkanPlatformInterface(VulkanInstance instance)
+        {
+            Instance = instance;
+            Api = instance.Api;
+        }
+
+        public VulkanPhysicalDevice PhysicalDevice { get; private set; }
+        public VulkanInstance Instance { get; }
+        public VulkanDevice Device { get; set; }
+        public Vk Api { get; private set; }
+        public VulkanSurfaceRenderTarget MainSurface { get; set; }
+
+        public void Dispose()
+        {
+            Device?.Dispose();
+            Instance?.Dispose();
+            Api?.Dispose();
+        }
+
+        private static VulkanPlatformInterface TryCreate()
+        {
+            _options = AvaloniaLocator.Current.GetService<VulkanOptions>() ?? new VulkanOptions();
+
+            var instance = VulkanInstance.Create(_options);
+
+            return new VulkanPlatformInterface(instance);
+        }
+
+        public static bool TryInitialize()
+        {
+            var feature = TryCreate();
+            if (feature != null)
+            {
+                AvaloniaLocator.CurrentMutable.Bind<VulkanPlatformInterface>().ToConstant(feature);
+                return true;
+            }
+
+            return false;
+        }
+
+        public VulkanSurfaceRenderTarget CreateRenderTarget(IVulkanPlatformSurface platformSurface)
+        {
+            var surface = VulkanSurface.CreateSurface(Instance, platformSurface);
+
+            if (Device == null)
+            {
+                PhysicalDevice = VulkanPhysicalDevice.FindSuitablePhysicalDevice(Instance, surface, _options.PreferDiscreteGpu, _options.PreferredDevice);
+                var device = VulkanInitialization.CreateDevice(Instance.Api,
+                                                               PhysicalDevice.InternalHandle,
+                                                               PhysicalDevice.QueueFamilyIndex,
+                                                               VulkanInitialization.GetSupportedExtensions(Instance.Api, PhysicalDevice.InternalHandle),
+                                                               PhysicalDevice.QueueCount);
+
+                Device = new VulkanDevice(device, PhysicalDevice, Instance.Api);
+            }
+
+            var renderTarget = new VulkanSurfaceRenderTarget(this, surface);
+
+            if (MainSurface == null && surface != null)
+            {
+                MainSurface = renderTarget;
+                MainSurface.Display.ChangeVSyncMode(false);
+            }
+
+            return renderTarget;
+        }
+    }
+}

Ryujinx.Ava/Ui/Backend/Vulkan/VulkanQueue.cs

@@ -0,0 +1,18 @@
+using System;
+using Silk.NET.Vulkan;
+
+namespace Ryujinx.Ava.Ui.Vulkan
+{
+    internal class VulkanQueue
+    {
+        public VulkanQueue(VulkanDevice device, Queue apiHandle)
+        {
+            Device = device;
+            InternalHandle = apiHandle;
+        }
+
+        public VulkanDevice Device { get; }
+        public IntPtr Handle => InternalHandle.Handle;
+        internal Queue InternalHandle { get; }
+    }
+}

Ryujinx.Ava/Ui/Backend/Vulkan/VulkanSemaphorePair.cs

@@ -0,0 +1,32 @@
+using System;
+using Silk.NET.Vulkan;
+
+namespace Ryujinx.Ava.Ui.Vulkan
+{
+    internal class VulkanSemaphorePair : IDisposable
+    {
+        private readonly VulkanDevice _device;
+
+        public unsafe VulkanSemaphorePair(VulkanDevice device)
+        {
+            _device = device;
+
+            var semaphoreCreateInfo = new SemaphoreCreateInfo { SType = StructureType.SemaphoreCreateInfo };
+
+            _device.Api.CreateSemaphore(_device.InternalHandle, semaphoreCreateInfo, null, out var semaphore).ThrowOnError();
+            ImageAvailableSemaphore = semaphore;
+
+            _device.Api.CreateSemaphore(_device.InternalHandle, semaphoreCreateInfo, null, out semaphore).ThrowOnError();
+            RenderFinishedSemaphore = semaphore;
+        }
+
+        internal Semaphore ImageAvailableSemaphore { get; }
+        internal Semaphore RenderFinishedSemaphore { get; }
+
+        public unsafe void Dispose()
+        {
+            _device.Api.DestroySemaphore(_device.InternalHandle, ImageAvailableSemaphore, null);
+            _device.Api.DestroySemaphore(_device.InternalHandle, RenderFinishedSemaphore, null);
+        }
+    }
+}

Ryujinx.Ava/Ui/Backend/Vulkan/VulkanSurface.cs

@@ -0,0 +1,75 @@
+using System;
+using Avalonia;
+using Ryujinx.Ava.Ui.Vulkan.Surfaces;
+using Silk.NET.Vulkan;
+using Silk.NET.Vulkan.Extensions.KHR;
+
+namespace Ryujinx.Ava.Ui.Vulkan
+{
+    public class VulkanSurface : IDisposable
+    {
+        private readonly VulkanInstance _instance;
+        private readonly IVulkanPlatformSurface _vulkanPlatformSurface;
+
+        private VulkanSurface(IVulkanPlatformSurface vulkanPlatformSurface, VulkanInstance instance)
+        {
+            _vulkanPlatformSurface = vulkanPlatformSurface;
+            _instance = instance;
+            ApiHandle = vulkanPlatformSurface.CreateSurface(instance);
+        }
+
+        internal SurfaceKHR ApiHandle { get; }
+
+        internal static KhrSurface SurfaceExtension { get; private set; }
+
+        internal PixelSize SurfaceSize => _vulkanPlatformSurface.SurfaceSize;
+
+        public void Dispose()
+        {
+            SurfaceExtension.DestroySurface(_instance.InternalHandle, ApiHandle, Span<AllocationCallbacks>.Empty);
+            _vulkanPlatformSurface.Dispose();
+        }
+
+        internal static VulkanSurface CreateSurface(VulkanInstance instance, IVulkanPlatformSurface vulkanPlatformSurface)
+        {
+            if (SurfaceExtension == null)
+            {
+                instance.Api.TryGetInstanceExtension(instance.InternalHandle, out KhrSurface extension);
+
+                SurfaceExtension = extension;
+            }
+
+            return new VulkanSurface(vulkanPlatformSurface, instance);
+        }
+
+        internal bool CanSurfacePresent(VulkanPhysicalDevice physicalDevice)
+        {
+            SurfaceExtension.GetPhysicalDeviceSurfaceSupport(physicalDevice.InternalHandle, physicalDevice.QueueFamilyIndex, ApiHandle, out var isSupported);
+
+            return isSupported;
+        }
+
+        internal SurfaceFormatKHR GetSurfaceFormat(VulkanPhysicalDevice physicalDevice)
+        {
+            Span<uint> surfaceFormatsCount = stackalloc uint[1];
+            SurfaceExtension.GetPhysicalDeviceSurfaceFormats(physicalDevice.InternalHandle, ApiHandle, surfaceFormatsCount, Span<SurfaceFormatKHR>.Empty);
+            Span<SurfaceFormatKHR> surfaceFormats = stackalloc SurfaceFormatKHR[(int)surfaceFormatsCount[0]];
+            SurfaceExtension.GetPhysicalDeviceSurfaceFormats(physicalDevice.InternalHandle, ApiHandle, surfaceFormatsCount, surfaceFormats);
+
+            if (surfaceFormats.Length == 1 && surfaceFormats[0].Format == Format.Undefined)
+            {
+                return new SurfaceFormatKHR(Format.B8G8R8A8Unorm, ColorSpaceKHR.ColorspaceSrgbNonlinearKhr);
+            }
+
+            foreach (var format in surfaceFormats)
+            {
+                if (format.Format == Format.B8G8R8A8Unorm && format.ColorSpace == ColorSpaceKHR.ColorspaceSrgbNonlinearKhr)
+                {
+                    return format;
+                }
+            }
+
+            return surfaceFormats[0];
+        }
+    }
+}

Ryujinx.Ava/Ui/Backend/Vulkan/VulkanSurfaceRenderingSession.cs

@@ -0,0 +1,48 @@
+using System;
+using Avalonia;
+using Ryujinx.Ava.Ui.Vulkan.Surfaces;
+using Silk.NET.Vulkan;
+
+namespace Ryujinx.Ava.Ui.Vulkan
+{
+    internal class VulkanSurfaceRenderingSession : IDisposable
+    {
+        private readonly VulkanDevice _device;
+        private readonly VulkanSurfaceRenderTarget _renderTarget;
+        private VulkanCommandBufferPool.VulkanCommandBuffer _commandBuffer;
+
+        public VulkanSurfaceRenderingSession(VulkanDisplay display, VulkanDevice device,
+            VulkanSurfaceRenderTarget renderTarget, float scaling)
+        {
+            Display = display;
+            _device = device;
+            _renderTarget = renderTarget;
+            Scaling = scaling;
+            Begin();
+        }
+
+        public VulkanDisplay Display { get; }
+
+        public PixelSize Size => _renderTarget.Size;
+        public Vk Api => _device.Api;
+
+        public float Scaling { get; }
+
+        private void Begin()
+        {
+            if (!Display.EnsureSwapchainAvailable())
+            {
+                _renderTarget.Invalidate();
+            }
+        }
+
+        public void Dispose()
+        {
+            _commandBuffer = Display.StartPresentation(_renderTarget);
+
+            Display.BlitImageToCurrentImage(_renderTarget, _commandBuffer.InternalHandle);
+
+            Display.EndPresentation(_commandBuffer);
+        }
+    }
+}

Ryujinx.Ava/Ui/Controls/OpenGLRendererControl.cs

@@ -0,0 +1,190 @@
+using Avalonia;
+using Avalonia.OpenGL;
+using Avalonia.Platform;
+using Avalonia.Rendering.SceneGraph;
+using Avalonia.Skia;
+using Avalonia.Threading;
+using OpenTK.Graphics.OpenGL;
+using Ryujinx.Common.Configuration;
+using SkiaSharp;
+using SPB.Graphics;
+using SPB.Graphics.OpenGL;
+using SPB.Platform;
+using SPB.Windowing;
+using System;
+
+namespace Ryujinx.Ava.Ui.Controls
+{
+    internal class OpenGLRendererControl : RendererControl
+    {
+        public int Major { get; }
+        public int Minor { get; }
+        public OpenGLContextBase GameContext { get; set; }
+
+        public static OpenGLContextBase PrimaryContext =>
+            AvaloniaLocator.Current.GetService<IPlatformOpenGlInterface>()
+                .PrimaryContext.AsOpenGLContextBase();
+
+        private SwappableNativeWindowBase _gameBackgroundWindow;
+
+        private IntPtr _fence;
+
+        public OpenGLRendererControl(int major, int minor, GraphicsDebugLevel graphicsDebugLevel) : base(graphicsDebugLevel)
+        {
+            Major = major;
+            Minor = minor;
+        }
+
+        public override void DestroyBackgroundContext()
+        {
+            _image = null;
+
+            if (_fence != IntPtr.Zero)
+            {
+                DrawOperation.Dispose();
+                GL.DeleteSync(_fence);
+            }
+
+            GlDrawOperation.DeleteFramebuffer();
+
+            GameContext?.Dispose();
+
+            _gameBackgroundWindow?.Dispose();
+        }
+
+        internal override void Present(object image)
+        {
+            Dispatcher.UIThread.InvokeAsync(() =>
+            {
+                Image = (int)image;
+            }).Wait();
+
+            if (_fence != IntPtr.Zero)
+            {
+                GL.DeleteSync(_fence);
+            }
+
+            _fence = GL.FenceSync(SyncCondition.SyncGpuCommandsComplete, WaitSyncFlags.None);
+
+            QueueRender();
+
+            _gameBackgroundWindow.SwapBuffers();
+        }
+
+        internal override void MakeCurrent()
+        {
+            GameContext.MakeCurrent(_gameBackgroundWindow);
+        }
+
+        internal override void MakeCurrent(SwappableNativeWindowBase window)
+        {
+            GameContext.MakeCurrent(window);
+        }
+
+        protected override void CreateWindow()
+        {
+            var flags = OpenGLContextFlags.Compat;
+            if (DebugLevel != GraphicsDebugLevel.None)
+            {
+                flags |= OpenGLContextFlags.Debug;
+            }
+            _gameBackgroundWindow = PlatformHelper.CreateOpenGLWindow(FramebufferFormat.Default, 0, 0, 100, 100);
+            _gameBackgroundWindow.Hide();
+
+            GameContext = PlatformHelper.CreateOpenGLContext(FramebufferFormat.Default, Major, Minor, flags, shareContext: PrimaryContext);
+            GameContext.Initialize(_gameBackgroundWindow);
+        }
+
+        protected override ICustomDrawOperation CreateDrawOperation()
+        {
+            return new GlDrawOperation(this);
+        }
+
+        private class GlDrawOperation : ICustomDrawOperation
+        {
+            private static int _framebuffer;
+
+            public Rect Bounds { get; }
+
+            private readonly OpenGLRendererControl _control;
+
+            public GlDrawOperation(OpenGLRendererControl control)
+            {
+                _control = control;
+                Bounds = _control.Bounds;
+            }
+
+            public void Dispose() { }
+
+            public static void DeleteFramebuffer()
+            {
+                if (_framebuffer == 0)
+                {
+                    GL.DeleteFramebuffer(_framebuffer);
+                }
+
+                _framebuffer = 0;
+            }
+
+            public bool Equals(ICustomDrawOperation other)
+            {
+                return other is GlDrawOperation operation && Equals(this, operation) && operation.Bounds == Bounds;
+            }
+
+            public bool HitTest(Point p)
+            {
+                return Bounds.Contains(p);
+            }
+
+            private void CreateRenderTarget()
+            {
+                _framebuffer = GL.GenFramebuffer();
+            }
+
+            public void Render(IDrawingContextImpl context)
+            {
+                if (_control.Image == null)
+                {
+                    return;
+                }
+
+                if (_framebuffer == 0)
+                {
+                    CreateRenderTarget();
+                }
+
+                int currentFramebuffer = GL.GetInteger(GetPName.FramebufferBinding);
+
+                var image = _control.Image;
+                var fence = _control._fence;
+
+                GL.BindFramebuffer(FramebufferTarget.Framebuffer, _framebuffer);
+                GL.FramebufferTexture2D(FramebufferTarget.Framebuffer, FramebufferAttachment.ColorAttachment0, TextureTarget.Texture2D, (int)image, 0);
+                GL.BindFramebuffer(FramebufferTarget.Framebuffer, currentFramebuffer);
+
+                if (context is not ISkiaDrawingContextImpl skiaDrawingContextImpl)
+                {
+                    return;
+                }
+
+                var imageInfo = new SKImageInfo((int)_control.RenderSize.Width, (int)_control.RenderSize.Height, SKColorType.Rgba8888);
+                var glInfo = new GRGlFramebufferInfo((uint)_framebuffer, SKColorType.Rgba8888.ToGlSizedFormat());
+
+                GL.WaitSync(fence, WaitSyncFlags.None, ulong.MaxValue);
+
+                using var backendTexture = new GRBackendRenderTarget(imageInfo.Width, imageInfo.Height, 1, 0, glInfo);
+                using var surface = SKSurface.Create(skiaDrawingContextImpl.GrContext, backendTexture, GRSurfaceOrigin.BottomLeft, SKColorType.Rgba8888);
+
+                if (surface == null)
+                {
+                    return;
+                }
+
+                var rect = new Rect(new Point(), _control.RenderSize);
+
+                using var snapshot = surface.Snapshot();
+                skiaDrawingContextImpl.SkCanvas.DrawImage(snapshot, rect.ToSKRect(), _control.Bounds.ToSKRect(), new SKPaint());
+            }
+        }
+    }
+}

Ryujinx.Ava/Ui/Controls/RendererControl.cs

@@ -2,65 +2,49 @@
 using Avalonia.Controls;
 using Avalonia.Data;
 using Avalonia.Media;
-using Avalonia.OpenGL;
-using Avalonia.Platform;
 using Avalonia.Rendering.SceneGraph;
-using Avalonia.Skia;
-using Avalonia.Threading;
-using OpenTK.Graphics.OpenGL;
 using Ryujinx.Common.Configuration;
-using SkiaSharp;
-using SPB.Graphics;
-using SPB.Graphics.OpenGL;
-using SPB.Platform;
 using SPB.Windowing;
 using System;
 
 namespace Ryujinx.Ava.Ui.Controls
 {
-    internal class RendererControl : Control
+    internal abstract class RendererControl : Control
     {
-        private int _image;
+        protected object _image;
 
         static RendererControl()
         {
             AffectsRender<RendererControl>(ImageProperty);
         }
 
-        public readonly static StyledProperty<int> ImageProperty =
-            AvaloniaProperty.Register<RendererControl, int>(nameof(Image), 0, inherits: true, defaultBindingMode: BindingMode.TwoWay);
+        public readonly static StyledProperty<object> ImageProperty =
+            AvaloniaProperty.Register<RendererControl, object>(
+                nameof(Image),
+                0,
+                inherits: true,
+                defaultBindingMode: BindingMode.TwoWay);
 
-        protected int Image
+        protected object Image
         {
             get => _image;
             set => SetAndRaise(ImageProperty, ref _image, value);
         }
 
-        public event EventHandler<EventArgs> GlInitialized;
+        public event EventHandler<EventArgs> RendererInitialized;
         public event EventHandler<Size> SizeChanged;
 
         protected Size RenderSize { get; private set; }
         public bool IsStarted { get; private set; }
 
-        public int Major { get; }
-        public int Minor { get; }
         public GraphicsDebugLevel DebugLevel { get; }
-        public OpenGLContextBase GameContext { get; set; }
-
-        public static OpenGLContextBase PrimaryContext => AvaloniaLocator.Current.GetService<IPlatformOpenGlInterface>().PrimaryContext.AsOpenGLContextBase();
-
-        private SwappableNativeWindowBase _gameBackgroundWindow;
 
         private bool _isInitialized;
 
-        private IntPtr _fence;
+        protected ICustomDrawOperation DrawOperation { get; private set; }
 
-        private GlDrawOperation _glDrawOperation;
-
-        public RendererControl(int major, int minor, GraphicsDebugLevel graphicsDebugLevel)
+        public RendererControl(GraphicsDebugLevel graphicsDebugLevel)
         {
-            Major = major;
-            Minor = minor;
             DebugLevel = graphicsDebugLevel;
             IObservable<Rect> resizeObservable = this.GetObservable(BoundsProperty);
 
@@ -69,7 +53,7 @@ namespace Ryujinx.Ava.Ui.Controls
             Focusable = true;
         }
 
-        private void Resized(Rect rect)
+        protected void Resized(Rect rect)
         {
             SizeChanged?.Invoke(this, rect.Size);
 
@@ -77,37 +61,40 @@ namespace Ryujinx.Ava.Ui.Controls
             {
                 RenderSize = rect.Size * VisualRoot.RenderScaling;
 
-                _glDrawOperation?.Dispose();
-                _glDrawOperation = new GlDrawOperation(this);
+                DrawOperation?.Dispose();
+                DrawOperation = CreateDrawOperation();
             }
         }
 
+        protected abstract ICustomDrawOperation CreateDrawOperation();
+        protected abstract void CreateWindow();
+
         public override void Render(DrawingContext context)
         {
             if (!_isInitialized)
             {
                 CreateWindow();
 
-                OnGlInitialized();
+                OnRendererInitialized();
                 _isInitialized = true;
             }
 
-            if (GameContext == null || !IsStarted || Image == 0)
+            if (!IsStarted || Image == null)
             {
                 return;
             }
 
-            if (_glDrawOperation != null)
+            if (DrawOperation != null)
             {
-                context.Custom(_glDrawOperation);
+                context.Custom(DrawOperation);
             }
 
             base.Render(context);
         }
 
-        protected void OnGlInitialized()
+        protected void OnRendererInitialized()
         {
-            GlInitialized?.Invoke(this, EventArgs.Empty);
+            RendererInitialized?.Invoke(this, EventArgs.Empty);
         }
 
         public void QueueRender()
@@ -115,24 +102,7 @@ namespace Ryujinx.Ava.Ui.Controls
             Program.RenderTimer.TickNow();
         }
 
-        internal void Present(object image)
-        {
-            Dispatcher.UIThread.InvokeAsync(() =>
-            {
-                Image = (int)image;
-            }).Wait();
-
-            if (_fence != IntPtr.Zero)
-            {
-                GL.DeleteSync(_fence);
-            }
-
-            _fence = GL.FenceSync(SyncCondition.SyncGpuCommandsComplete, WaitSyncFlags.None);
-
-            QueueRender();
-
-            _gameBackgroundWindow.SwapBuffers();
-        }
+        internal abstract void Present(object image);
 
         internal void Start()
         {
@@ -145,132 +115,8 @@ namespace Ryujinx.Ava.Ui.Controls
             IsStarted = false;
         }
 
-        public void DestroyBackgroundContext()
-        {
-            _image = 0;
-
-            if (_fence != IntPtr.Zero)
-            {
-                _glDrawOperation.Dispose();
-                GL.DeleteSync(_fence);
-            }
-
-            GlDrawOperation.DeleteFramebuffer();
-
-            GameContext?.Dispose();
-
-            _gameBackgroundWindow?.Dispose();
-        }
-
-        internal void MakeCurrent()
-        {
-            GameContext.MakeCurrent(_gameBackgroundWindow);
-        }
-
-        internal void MakeCurrent(SwappableNativeWindowBase window)
-        {
-            GameContext.MakeCurrent(window);
-        }
-
-        protected void CreateWindow()
-        {
-            var flags = OpenGLContextFlags.Compat;
-            if (DebugLevel != GraphicsDebugLevel.None)
-            {
-                flags |= OpenGLContextFlags.Debug;
-            }
-            _gameBackgroundWindow = PlatformHelper.CreateOpenGLWindow(FramebufferFormat.Default, 0, 0, 100, 100);
-            _gameBackgroundWindow.Hide();
-
-            GameContext = PlatformHelper.CreateOpenGLContext(FramebufferFormat.Default, Major, Minor, flags, shareContext: PrimaryContext);
-            GameContext.Initialize(_gameBackgroundWindow);
-        }
-
-        private class GlDrawOperation : ICustomDrawOperation
-        {
-            private static int _framebuffer;
-
-            public Rect Bounds { get; }
-
-            private readonly RendererControl _control;
-
-            public GlDrawOperation(RendererControl control)
-            {
-                _control = control;
-                Bounds = _control.Bounds;
-            }
-
-            public void Dispose() { }
-
-            public static void DeleteFramebuffer()
-            {
-                if (_framebuffer == 0)
-                {
-                    GL.DeleteFramebuffer(_framebuffer);
-                }
-
-                _framebuffer = 0;
-            }
-
-            public bool Equals(ICustomDrawOperation other)
-            {
-                return other is GlDrawOperation operation && Equals(this, operation) && operation.Bounds == Bounds;
-            }
-
-            public bool HitTest(Point p)
-            {
-                return Bounds.Contains(p);
-            }
-
-            private void CreateRenderTarget()
-            {
-                _framebuffer = GL.GenFramebuffer();
-            }
-
-            public void Render(IDrawingContextImpl context)
-            {
-                if (_control.Image == 0)
-                {
-                    return;
-                }
-
-                if (_framebuffer == 0)
-                {
-                    CreateRenderTarget();
-                }
-
-                int currentFramebuffer = GL.GetInteger(GetPName.FramebufferBinding);
-
-                var image = _control.Image;
-                var fence = _control._fence;
-
-                GL.BindFramebuffer(FramebufferTarget.Framebuffer, _framebuffer);
-                GL.FramebufferTexture2D(FramebufferTarget.Framebuffer, FramebufferAttachment.ColorAttachment0, TextureTarget.Texture2D, image, 0);
-                GL.BindFramebuffer(FramebufferTarget.Framebuffer, currentFramebuffer);
-
-                if (context is not ISkiaDrawingContextImpl skiaDrawingContextImpl)
-                {
-                    return;
-                }
-
-                var imageInfo = new SKImageInfo((int)_control.RenderSize.Width, (int)_control.RenderSize.Height, SKColorType.Rgba8888);
-                var glInfo = new GRGlFramebufferInfo((uint)_framebuffer, SKColorType.Rgba8888.ToGlSizedFormat());
-
-                GL.WaitSync(fence, WaitSyncFlags.None, ulong.MaxValue);
-
-                using var backendTexture = new GRBackendRenderTarget(imageInfo.Width, imageInfo.Height, 1, 0, glInfo);
-                using var surface = SKSurface.Create(skiaDrawingContextImpl.GrContext, backendTexture, GRSurfaceOrigin.BottomLeft, SKColorType.Rgba8888);
-
-                if (surface == null)
-                {
-                    return;
-                }
-
-                var rect = new Rect(new Point(), _control.RenderSize);
-
-                using var snapshot = surface.Snapshot();
-                skiaDrawingContextImpl.SkCanvas.DrawImage(snapshot, rect.ToSKRect(), _control.Bounds.ToSKRect(), new SKPaint());
-            }
-        }
+        public abstract void DestroyBackgroundContext();
+        internal abstract void MakeCurrent();
+        internal abstract void MakeCurrent(SwappableNativeWindowBase window);
     }
-}
+}

Ryujinx.Ava/Ui/Controls/VulkanRendererControl.cs

@@ -0,0 +1,153 @@
+using Avalonia;
+using Avalonia.Platform;
+using Avalonia.Rendering.SceneGraph;
+using Avalonia.Skia;
+using Avalonia.Threading;
+using Ryujinx.Ava.Ui.Backend.Vulkan;
+using Ryujinx.Ava.Ui.Vulkan;
+using Ryujinx.Common.Configuration;
+using Ryujinx.Graphics.Vulkan;
+using Silk.NET.Vulkan;
+using SkiaSharp;
+using SPB.Windowing;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Ryujinx.Ava.Ui.Controls
+{
+    internal class VulkanRendererControl : RendererControl
+    {
+        private VulkanPlatformInterface _platformInterface;
+
+        public VulkanRendererControl(GraphicsDebugLevel graphicsDebugLevel) : base(graphicsDebugLevel)
+        {
+            _platformInterface = AvaloniaLocator.Current.GetService<VulkanPlatformInterface>();
+        }
+
+        public override void DestroyBackgroundContext()
+        {
+
+        }
+
+        protected override ICustomDrawOperation CreateDrawOperation()
+        {
+            return new VulkanDrawOperation(this);
+        }
+
+        protected override void CreateWindow()
+        {
+        }
+
+        internal override void MakeCurrent()
+        {
+        }
+
+        internal override void MakeCurrent(SwappableNativeWindowBase window)
+        {
+        }
+
+        internal override void Present(object image)
+        {
+            Dispatcher.UIThread.InvokeAsync(() =>
+            {
+                Image = image;
+            }).Wait();
+
+            QueueRender();
+        }
+
+        private class VulkanDrawOperation : ICustomDrawOperation
+        {
+            public Rect Bounds { get; }
+
+            private readonly VulkanRendererControl _control;
+
+            public VulkanDrawOperation(VulkanRendererControl control)
+            {
+                _control = control;
+                Bounds = _control.Bounds;
+            }
+
+            public void Dispose()
+            {
+
+            }
+
+            public bool Equals(ICustomDrawOperation other)
+            {
+                return other is VulkanDrawOperation operation && Equals(this, operation) && operation.Bounds == Bounds;
+            }
+
+            public bool HitTest(Point p)
+            {
+                return Bounds.Contains(p);
+            }
+
+            public void Render(IDrawingContextImpl context)
+            {
+                if (_control.Image == null || _control.RenderSize.Width == 0 || _control.RenderSize.Height == 0)
+                {
+                    return;
+                }
+
+                var image = (PresentImageInfo)_control.Image;
+
+                if (context is not ISkiaDrawingContextImpl skiaDrawingContextImpl)
+                {
+                    return;
+                }
+
+                _control._platformInterface.Device.QueueWaitIdle();
+
+                var gpu = AvaloniaLocator.Current.GetService<VulkanSkiaGpu>();
+
+                var imageInfo = new GRVkImageInfo()
+                {
+                    CurrentQueueFamily = _control._platformInterface.PhysicalDevice.QueueFamilyIndex,
+                    Format = (uint)Format.R8G8B8A8Unorm,
+                    Image = image.Image.Handle,
+                    ImageLayout = (uint)ImageLayout.ColorAttachmentOptimal,
+                    ImageTiling = (uint)ImageTiling.Optimal,
+                    ImageUsageFlags = (uint)(ImageUsageFlags.ImageUsageColorAttachmentBit
+                                             | ImageUsageFlags.ImageUsageTransferSrcBit
+                                             | ImageUsageFlags.ImageUsageTransferDstBit),
+                    LevelCount = 1,
+                    SampleCount = 1,
+                    Protected = false,
+                    Alloc = new GRVkAlloc()
+                    {
+                        Memory = image.Memory.Handle,
+                        Flags = 0,
+                        Offset = image.MemoryOffset,
+                        Size = image.MemorySize
+                    }
+                };
+
+                using var backendTexture = new GRBackendRenderTarget(
+                    (int)_control.RenderSize.Width,
+                    (int)_control.RenderSize.Height,
+                    1,
+                    imageInfo);
+
+                using var surface = SKSurface.Create(
+                    gpu.GrContext,
+                    backendTexture,
+                    GRSurfaceOrigin.TopLeft,
+                    SKColorType.Rgba8888);
+
+                if (surface == null)
+                {
+                    return;
+                }
+
+                var rect = new Rect(new Point(), _control.RenderSize);
+
+                using var snapshot = surface.Snapshot();
+                skiaDrawingContextImpl.SkCanvas.DrawImage(snapshot, rect.ToSKRect(), _control.Bounds.ToSKRect(), new SKPaint());
+            }
+        }
+    }
+}

Ryujinx.Ava/Ui/Models/StatusUpdatedEventArgs.cs

@@ -6,16 +6,18 @@ namespace Ryujinx.Ava.Ui.Models
     {
         public bool VSyncEnabled { get; }
         public float Volume { get; }
+        public string GpuBackend { get; }
         public string AspectRatio { get; }
         public string DockedMode { get; }
         public string FifoStatus { get; }
         public string GameStatus { get; }
         public string GpuName { get; }
 
-        public StatusUpdatedEventArgs(bool vSyncEnabled, float volume, string dockedMode, string aspectRatio, string gameStatus, string fifoStatus, string gpuName)
+        public StatusUpdatedEventArgs(bool vSyncEnabled, float volume, string gpuBackend, string dockedMode, string aspectRatio, string gameStatus, string fifoStatus, string gpuName)
         {
             VSyncEnabled = vSyncEnabled;
             Volume = volume;
+            GpuBackend = gpuBackend;
             DockedMode = dockedMode;
             AspectRatio = aspectRatio;
             GameStatus = gameStatus;

Ryujinx.Ava/Ui/ViewModels/MainWindowViewModel.cs

@@ -197,6 +197,7 @@ namespace Ryujinx.Ava.Ui.ViewModels
         private string _pauseKey = "F5";
         private string _screenshotkey = "F8";
         private float _volume;
+        private string _backendText;
 
         public ApplicationData SelectedApplication
         {
@@ -335,7 +336,7 @@ namespace Ryujinx.Ava.Ui.ViewModels
             }
         }
 
-        public string GpuStatusText
+        public string GpuNameText
         {
             get => _gpuStatusText;
             set
@@ -346,6 +347,17 @@ namespace Ryujinx.Ava.Ui.ViewModels
             }
         }
 
+        public string BackendText
+        {
+            get => _backendText;
+            set
+            {
+                _backendText = value;
+
+                OnPropertyChanged();
+            }
+        }
+
         public string DockedStatusText
         {
             get => _dockedStatusText;

Ryujinx.Ava/Ui/ViewModels/SettingsViewModel.cs

@@ -1,6 +1,8 @@
+using Avalonia;
 using Avalonia.Collections;
 using Avalonia.Controls;
 using Avalonia.Threading;
+using DynamicData;
 using LibHac.Tools.FsSystem;
 using Ryujinx.Audio.Backends.OpenAL;
 using Ryujinx.Audio.Backends.SDL2;
@@ -8,18 +10,26 @@ using Ryujinx.Audio.Backends.SoundIo;
 using Ryujinx.Ava.Common.Locale;
 using Ryujinx.Ava.Input;
 using Ryujinx.Ava.Ui.Controls;
+using Ryujinx.Ava.Ui.Vulkan;
 using Ryujinx.Ava.Ui.Windows;
 using Ryujinx.Common.Configuration;
 using Ryujinx.Common.Configuration.Hid;
 using Ryujinx.Common.GraphicsDriver;
 using Ryujinx.Common.Logging;
+using Ryujinx.Graphics.Vulkan;
 using Ryujinx.HLE.FileSystem;
 using Ryujinx.HLE.HOS.Services.Time.TimeZone;
 using Ryujinx.Input;
 using Ryujinx.Ui.Common.Configuration;
 using Ryujinx.Ui.Common.Configuration.System;
+using Silk.NET.Vulkan;
 using System;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Diagnostics;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Threading.Tasks;
 using TimeZone = Ryujinx.Ava.Ui.Models.TimeZone;
 
 namespace Ryujinx.Ava.Ui.ViewModels
@@ -101,6 +111,7 @@ namespace Ryujinx.Ava.Ui.ViewModels
         public bool IgnoreMissingServices { get; set; }
         public bool ExpandDramSize { get; set; }
         public bool EnableShaderCache { get; set; }
+        public bool EnableTextureRecompression { get; set; }
         public bool EnableFileLog { get; set; }
         public bool EnableStub { get; set; }
         public bool EnableInfo { get; set; }
@@ -115,6 +126,7 @@ namespace Ryujinx.Ava.Ui.ViewModels
         public bool IsSDL2Enabled { get; set; }
         public bool EnableCustomTheme { get; set; }
         public bool IsCustomResolutionScaleActive => _resolutionScale == 0;
+        public bool IsVulkanSelected => GraphicsBackendIndex == 0;
 
         public string TimeZone { get; set; }
         public string ShaderDumpPath { get; set; }
@@ -129,6 +141,18 @@ namespace Ryujinx.Ava.Ui.ViewModels
         public int OpenglDebugLevel { get; set; }
         public int MemoryMode { get; set; }
         public int BaseStyleIndex { get; set; }
+        public int GraphicsBackendIndex
+        {
+            get => graphicsBackendIndex;
+            set
+            {
+                graphicsBackendIndex = value;
+                OnPropertyChanged();
+                OnPropertyChanged(nameof(IsVulkanSelected));
+            }
+        }
+
+        public int PreferredGpuIndex { get; set; }
 
         public float Volume
         {
@@ -148,8 +172,11 @@ namespace Ryujinx.Ava.Ui.ViewModels
         public AvaloniaList<TimeZone> TimeZones { get; set; }
 
         public AvaloniaList<string> GameDirectories { get; set; }
+        public ObservableCollection<ComboBoxItem> AvailableGpus { get; set; }
 
         private KeyboardHotkeys _keyboardHotkeys;
+        private int graphicsBackendIndex;
+        private List<string> _gpuIds = new List<string>();
 
         public KeyboardHotkeys KeyboardHotkeys
         {
@@ -180,12 +207,14 @@ namespace Ryujinx.Ava.Ui.ViewModels
         {
             GameDirectories = new AvaloniaList<string>();
             TimeZones = new AvaloniaList<TimeZone>();
+            AvailableGpus = new ObservableCollection<ComboBoxItem>();
             _validTzRegions = new List<string>();
 
             CheckSoundBackends();
 
             if (Program.PreviewerDetached)
             {
+                LoadAvailableGpus();
                 LoadCurrentConfiguration();
             }
         }
@@ -197,6 +226,34 @@ namespace Ryujinx.Ava.Ui.ViewModels
             IsSDL2Enabled = SDL2HardwareDeviceDriver.IsSupported;
         }
 
+        private unsafe void LoadAvailableGpus()
+        {
+            _gpuIds = new List<string>();
+            List<string> names = new List<string>();
+            if (!Program.UseVulkan)
+            {
+                var devices = VulkanRenderer.GetPhysicalDevices();
+                foreach (var device in devices)
+                {
+                    _gpuIds.Add(device.Id);
+                    names.Add($"{device.Name} {(device.IsDiscrete ? "(dGpu)" : "")}");
+                }
+            }
+            else
+            {
+                foreach (var device in VulkanPhysicalDevice.SuitableDevices)
+                {
+                    _gpuIds.Add(VulkanInitialization.StringFromIdPair(device.Value.VendorID, device.Value.DeviceID));
+                    var value = device.Value;
+                    var name = value.DeviceName;
+                    names.Add($"{Marshal.PtrToStringAnsi((IntPtr)name)} {(device.Value.DeviceType == PhysicalDeviceType.DiscreteGpu ? "(dGpu)" : "")}");
+                }
+            }
+
+            AvailableGpus.Clear();
+            AvailableGpus.AddRange(names.Select(x => new ComboBoxItem() { Content = x }));
+        }
+
         public void LoadTimeZones()
         {
             _timeZoneContentManager = new TimeZoneContentManager();
@@ -266,6 +323,7 @@ namespace Ryujinx.Ava.Ui.ViewModels
             IgnoreMissingServices = config.System.IgnoreMissingServices;
             ExpandDramSize = config.System.ExpandRam;
             EnableShaderCache = config.Graphics.EnableShaderCache;
+            EnableTextureRecompression = config.Graphics.EnableTextureRecompression;
             EnableFileLog = config.Logger.EnableFileLog;
             EnableStub = config.Logger.EnableStub;
             EnableInfo = config.Logger.EnableInfo;
@@ -286,6 +344,9 @@ namespace Ryujinx.Ava.Ui.ViewModels
             ShaderDumpPath = config.Graphics.ShadersDumpPath;
             CustomThemePath = config.Ui.CustomThemePath;
             BaseStyleIndex = config.Ui.BaseStyle == "Light" ? 0 : 1;
+            GraphicsBackendIndex = (int)config.Graphics.GraphicsBackend.Value;
+
+            PreferredGpuIndex = _gpuIds.Contains(config.Graphics.PreferredGpu) ? _gpuIds.IndexOf(config.Graphics.PreferredGpu) : 0;
 
             Language = (int)config.System.Language.Value;
             Region = (int)config.System.Region.Value;
@@ -313,7 +374,7 @@ namespace Ryujinx.Ava.Ui.ViewModels
             _previousVolumeLevel = Volume;
         }
 
-        public void SaveSettings()
+        public async Task SaveSettings()
         {
             List<string> gameDirs = new List<string>(GameDirectories);
 
@@ -324,6 +385,8 @@ namespace Ryujinx.Ava.Ui.ViewModels
                 config.System.TimeZone.Value = TimeZone;
             }
 
+            bool requiresRestart = config.Graphics.GraphicsBackend.Value != (GraphicsBackend)GraphicsBackendIndex;
+
             config.Logger.EnableError.Value = EnableError;
             config.Logger.EnableTrace.Value = EnableTrace;
             config.Logger.EnableWarn.Value = EnableWarn;
@@ -341,6 +404,8 @@ namespace Ryujinx.Ava.Ui.ViewModels
             config.HideCursorOnIdle.Value = HideCursorOnIdle;
             config.Graphics.EnableVsync.Value = EnableVsync;
             config.Graphics.EnableShaderCache.Value = EnableShaderCache;
+            config.Graphics.EnableTextureRecompression.Value = EnableTextureRecompression;
+            config.Graphics.GraphicsBackend.Value = (GraphicsBackend)GraphicsBackendIndex;
             config.System.EnablePtc.Value = EnablePptc;
             config.System.EnableInternetAccess.Value = EnableInternetAccess;
             config.System.EnableFsIntegrityChecks.Value = EnableFsIntegrityChecks;
@@ -354,6 +419,20 @@ namespace Ryujinx.Ava.Ui.ViewModels
             config.System.Language.Value = (Language)Language;
             config.System.Region.Value = (Region)Region;
 
+            var selectedGpu = _gpuIds.ElementAtOrDefault(PreferredGpuIndex);
+            if (!requiresRestart)
+            {
+                var platform = AvaloniaLocator.Current.GetService<VulkanPlatformInterface>();
+                if (platform != null)
+                {
+                    var physicalDevice = platform.PhysicalDevice;
+
+                    requiresRestart = physicalDevice.DeviceId != selectedGpu;
+                }
+            }
+
+            config.Graphics.PreferredGpu.Value = selectedGpu;
+
             if (ConfigurationState.Instance.Graphics.BackendThreading != (BackendThreading)GraphicsBackendMultithreadingIndex)
             {
                 DriverUtilities.ToggleOGLThreading(GraphicsBackendMultithreadingIndex == (int)BackendThreading.Off);
@@ -392,6 +471,20 @@ namespace Ryujinx.Ava.Ui.ViewModels
             MainWindow.UpdateGraphicsConfig();
 
             _previousVolumeLevel = Volume;
+
+            if (requiresRestart)
+            {
+                var choice = await ContentDialogHelper.CreateChoiceDialog(
+                    LocaleManager.Instance["SettingsAppRequiredRestartMessage"],
+                    LocaleManager.Instance["SettingsGpuBackendRestartMessage"],
+                    LocaleManager.Instance["SettingsGpuBackendRestartSubMessage"]);
+
+                if (choice)
+                {
+                    Process.Start(Environment.ProcessPath);
+                    Environment.Exit(0);
+                }
+            }
         }
 
         public void RevertIfNotSaved()

Ryujinx.Ava/Ui/Windows/MainWindow.axaml

@@ -721,7 +721,21 @@
                         HorizontalAlignment="Left"
                         VerticalAlignment="Center"
                         IsVisible="{Binding !ShowLoadProgress}"
-                        Text="{Binding GpuStatusText}"
+                        Text="{Binding BackendText}"
+                        TextAlignment="Left" />
+                    <Border
+                        Width="2"
+                        Height="12"
+                        Margin="2,0"
+                        BorderBrush="Gray"
+                        BorderThickness="1"
+                        IsVisible="{Binding !ShowLoadProgress}" />
+                    <TextBlock
+                        Margin="5,0,5,0"
+                        HorizontalAlignment="Left"
+                        VerticalAlignment="Center"
+                        IsVisible="{Binding !ShowLoadProgress}"
+                        Text="{Binding GpuNameText}"
                         TextAlignment="Left" />
                 </StackPanel>
                 <StackPanel

Ryujinx.Ava/Ui/Windows/MainWindow.axaml.cs

@@ -12,6 +12,7 @@ using Ryujinx.Ava.Ui.Applet;
 using Ryujinx.Ava.Ui.Controls;
 using Ryujinx.Ava.Ui.Models;
 using Ryujinx.Ava.Ui.ViewModels;
+using Ryujinx.Ava.Ui.Vulkan;
 using Ryujinx.Common.Configuration;
 using Ryujinx.Common.Logging;
 using Ryujinx.Graphics.Gpu;
@@ -59,7 +60,7 @@ namespace Ryujinx.Ava.Ui.Windows
         internal AppHost AppHost { get; private set; }
         public InputManager InputManager { get; private set; }
 
-        internal RendererControl GlRenderer { get; private set; }
+        internal RendererControl RendererControl { get; private set; }
         internal MainWindowViewModel ViewModel { get; private set; }
         public SettingsWindow SettingsWindow { get; set; }
 
@@ -140,7 +141,8 @@ namespace Ryujinx.Ava.Ui.Windows
                     ViewModel.AspectRatioStatusText = args.AspectRatio;
                     ViewModel.GameStatusText = args.GameStatus;
                     ViewModel.FifoStatusText = args.FifoStatus;
-                    ViewModel.GpuStatusText = args.GpuName;
+                    ViewModel.GpuNameText = args.GpuName;
+                    ViewModel.BackendText = args.GpuBackend;
 
                     ViewModel.ShowStatusSeparator = true;
                 });
@@ -237,8 +239,8 @@ namespace Ryujinx.Ava.Ui.Windows
 
             _mainViewContent = MainContent.Content as Control;
 
-            GlRenderer = new RendererControl(3, 3, ConfigurationState.Instance.Logger.GraphicsDebugLevel);
-            AppHost = new AppHost(GlRenderer, InputManager, path, VirtualFileSystem, ContentManager, AccountManager, _userChannelPersistence, this);
+            RendererControl = Program.UseVulkan ? new VulkanRendererControl(ConfigurationState.Instance.Logger.GraphicsDebugLevel) : new OpenGLRendererControl(3, 3, ConfigurationState.Instance.Logger.GraphicsDebugLevel);
+            AppHost = new AppHost(RendererControl, InputManager, path, VirtualFileSystem, ContentManager, AccountManager, _userChannelPersistence, this);
 
             if (!AppHost.LoadGuestApplication().Result)
             {
@@ -262,7 +264,7 @@ namespace Ryujinx.Ava.Ui.Windows
 
         private void InitializeGame()
         {
-            GlRenderer.GlInitialized += GlRenderer_Created;
+            RendererControl.RendererInitialized += GlRenderer_Created;
 
             AppHost.StatusUpdatedEvent += Update_StatusBar;
             AppHost.AppExit += AppHost_AppExit;
@@ -302,14 +304,14 @@ namespace Ryujinx.Ava.Ui.Windows
 
             Dispatcher.UIThread.InvokeAsync(() =>
             {
-                MainContent.Content = GlRenderer;
+                MainContent.Content = RendererControl;
 
                 if (startFullscreen && WindowState != WindowState.FullScreen)
                 {
                     ViewModel.ToggleFullscreen();
                 }
 
-                GlRenderer.Focus();
+                RendererControl.Focus();
             });
         }
 
@@ -361,8 +363,9 @@ namespace Ryujinx.Ava.Ui.Windows
 
                 HandleRelaunch();
             });
-            GlRenderer.GlInitialized -= GlRenderer_Created;
-            GlRenderer = null;
+
+            RendererControl.RendererInitialized -= GlRenderer_Created;
+            RendererControl = null;
 
             ViewModel.SelectedIcon = null;
 
@@ -513,6 +516,7 @@ namespace Ryujinx.Ava.Ui.Windows
             GraphicsConfig.MaxAnisotropy = ConfigurationState.Instance.Graphics.MaxAnisotropy;
             GraphicsConfig.ShadersDumpPath = ConfigurationState.Instance.Graphics.ShadersDumpPath;
             GraphicsConfig.EnableShaderCache = ConfigurationState.Instance.Graphics.EnableShaderCache;
+            GraphicsConfig.EnableTextureRecompression = ConfigurationState.Instance.Graphics.EnableTextureRecompression;
         }
 
         public void LoadHotKeys()

Ryujinx.Ava/Ui/Windows/SettingsWindow.axaml

@@ -504,43 +504,51 @@
                 VerticalScrollBarVisibility="Auto">
                 <Border>
                     <StackPanel
-                        Margin="10, 5"
+                        Margin="10,5"
                         HorizontalAlignment="Stretch"
                         Orientation="Vertical"
                         Spacing="10">
-                        <TextBlock FontWeight="Bold" Text="{locale:Locale SettingsTabGraphicsEnhancements}" />
+                        <TextBlock FontWeight="Bold" Text="{locale:Locale SettingsTabGraphicsAPI}" />
                         <StackPanel Margin="10,0,0,0" Orientation="Vertical" Spacing="10">
-                            <CheckBox IsChecked="{Binding EnableShaderCache}"
-                                  ToolTip.Tip="{locale:Locale ShaderCacheToggleTooltip}">
-                                <TextBlock Text="{locale:Locale SettingsTabGraphicsEnableShaderCache}" />
-                            </CheckBox>
                             <StackPanel Orientation="Horizontal">
-                                <TextBlock VerticalAlignment="Center"
-                                           ToolTip.Tip="{locale:Locale AnisotropyTooltip}"
-                                           Text="{locale:Locale SettingsTabGraphicsAnisotropicFiltering}"
-                                           Width="250" />
-                                <ComboBox SelectedIndex="{Binding MaxAnisotropy}"
-                                          Width="350"
-                                          HorizontalContentAlignment="Left"
-                                          ToolTip.Tip="{locale:Locale AnisotropyTooltip}">
-                                    <ComboBoxItem>
-                                        <TextBlock
-                                            Text="{locale:Locale SettingsTabGraphicsAnisotropicFilteringAuto}" />
-                                    </ComboBoxItem>
-                                    <ComboBoxItem>
-                                        <TextBlock Text="{locale:Locale SettingsTabGraphicsAnisotropicFiltering2x}" />
-                                    </ComboBoxItem>
-                                    <ComboBoxItem>
-                                        <TextBlock Text="{locale:Locale SettingsTabGraphicsAnisotropicFiltering4x}" />
-                                    </ComboBoxItem>
-                                    <ComboBoxItem>
-                                        <TextBlock Text="{locale:Locale SettingsTabGraphicsAnisotropicFiltering8x}" />
-                                    </ComboBoxItem>
-                                    <ComboBoxItem>
-                                        <TextBlock
-                                            Text="{locale:Locale SettingsTabGraphicsAnisotropicFiltering16x}" />
-                                    </ComboBoxItem>
-                                </ComboBox>
+                                    <TextBlock VerticalAlignment="Center"
+                                            ToolTip.Tip="{locale:Locale SettingsTabGraphicsBackendTooltip}"
+                                            Text="{locale:Locale SettingsTabGraphicsBackend}"
+                                            Width="250" />
+                                    <ComboBox Width="350"
+                                            HorizontalContentAlignment="Left"
+                                            ToolTip.Tip="{locale:Locale SettingsTabGraphicsBackendTooltip}"
+                                            SelectedIndex="{Binding GraphicsBackendIndex}">
+                                        <ComboBoxItem>
+                                            <TextBlock Text="Vulkan" />
+                                        </ComboBoxItem>
+                                        <ComboBoxItem>
+                                            <TextBlock Text="OpenGL" />
+                                        </ComboBoxItem>
+                                    </ComboBox>
+                                </StackPanel>
+                                <StackPanel Orientation="Horizontal" IsVisible="{Binding IsVulkanSelected}">
+                                    <TextBlock VerticalAlignment="Center"
+                                            ToolTip.Tip="{locale:Locale SettingsTabGraphicsPreferredGpuTooltip}"
+                                            Text="{locale:Locale SettingsTabGraphicsPreferredGpu}"
+                                            Width="250" />
+                                    <ComboBox Width="350"
+                                            HorizontalContentAlignment="Left"
+                                            ToolTip.Tip="{locale:Locale SettingsTabGraphicsPreferredGpuTooltip}"
+                                            SelectedIndex="{Binding PreferredGpuIndex}"
+                                            Items="{Binding AvailableGpus}"/>
+                                </StackPanel>
+                                <Separator Height="1" />
+                            <TextBlock FontWeight="Bold" Text="{locale:Locale SettingsTabGraphicsFeatures}" />
+                            <StackPanel Orientation="Vertical">
+                                <CheckBox IsChecked="{Binding EnableShaderCache}"
+                                    ToolTip.Tip="{locale:Locale ShaderCacheToggleTooltip}">
+                                    <TextBlock Text="{locale:Locale SettingsTabGraphicsEnableShaderCache}" />
+                                </CheckBox>
+                                <CheckBox IsChecked="{Binding EnableTextureRecompression}"
+                                    ToolTip.Tip="{locale:Locale SettingsEnableTextureRecompressionTooltip}">
+                                    <TextBlock Text="{locale:Locale SettingsEnableTextureRecompression}" />
+                                </CheckBox>
                             </StackPanel>
                             <StackPanel Orientation="Horizontal">
                                 <TextBlock VerticalAlignment="Center"
@@ -580,6 +588,34 @@
                                     Minimum="0.1"
                                     Value="{Binding CustomResolutionScale}" />
                             </StackPanel>
+                            <StackPanel Orientation="Horizontal">
+                                <TextBlock VerticalAlignment="Center"
+                                           ToolTip.Tip="{locale:Locale AnisotropyTooltip}"
+                                           Text="{locale:Locale SettingsTabGraphicsAnisotropicFiltering}"
+                                           Width="250" />
+                                <ComboBox SelectedIndex="{Binding MaxAnisotropy}"
+                                          Width="350"
+                                          HorizontalContentAlignment="Left"
+                                          ToolTip.Tip="{locale:Locale AnisotropyTooltip}">
+                                    <ComboBoxItem>
+                                        <TextBlock
+                                            Text="{locale:Locale SettingsTabGraphicsAnisotropicFilteringAuto}" />
+                                    </ComboBoxItem>
+                                    <ComboBoxItem>
+                                        <TextBlock Text="{locale:Locale SettingsTabGraphicsAnisotropicFiltering2x}" />
+                                    </ComboBoxItem>
+                                    <ComboBoxItem>
+                                        <TextBlock Text="{locale:Locale SettingsTabGraphicsAnisotropicFiltering4x}" />
+                                    </ComboBoxItem>
+                                    <ComboBoxItem>
+                                        <TextBlock Text="{locale:Locale SettingsTabGraphicsAnisotropicFiltering8x}" />
+                                    </ComboBoxItem>
+                                    <ComboBoxItem>
+                                        <TextBlock
+                                            Text="{locale:Locale SettingsTabGraphicsAnisotropicFiltering16x}" />
+                                    </ComboBoxItem>
+                                </ComboBox>
+                            </StackPanel>
                             <StackPanel Orientation="Horizontal">
                                 <TextBlock VerticalAlignment="Center"
                                            ToolTip.Tip="{locale:Locale AspectRatioTooltip}"
@@ -610,8 +646,6 @@
                                 </ComboBox>
                             </StackPanel>
                         </StackPanel>
-                        <Separator Height="1" />
-                        <TextBlock FontWeight="Bold" Text="{locale:Locale SettingsTabGraphicsFeatures}" />
                         <StackPanel
                             Margin="10,0,0,0"
                             HorizontalAlignment="Stretch"

Ryujinx.Ava/Ui/Windows/SettingsWindow.axaml.cs

@@ -1,4 +1,3 @@
-using Avalonia;
 using Avalonia.Controls;
 using Avalonia.Controls.Primitives;
 using Avalonia.Data;
@@ -15,9 +14,9 @@ using Ryujinx.Input;
 using Ryujinx.Input.Assigner;
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.IO;
 using System.Linq;
+using System.Threading.Tasks;
 using TimeZone = Ryujinx.Ava.Ui.Models.TimeZone;
 
 namespace Ryujinx.Ava.Ui.Windows
@@ -97,7 +96,7 @@ namespace Ryujinx.Ava.Ui.Windows
                     }
                 }
             }
-        }        
+        }
 
         private void Button_Unchecked(object sender, RoutedEventArgs e)
         {
@@ -209,9 +208,9 @@ namespace Ryujinx.Ava.Ui.Windows
             }
         }
 
-        private void SaveButton_Clicked(object sender, RoutedEventArgs e)
+        private async void SaveButton_Clicked(object sender, RoutedEventArgs e)
         {
-            SaveSettings();
+            await SaveSettings();
 
             Close();
         }
@@ -222,14 +221,14 @@ namespace Ryujinx.Ava.Ui.Windows
             Close();
         }
 
-        private void ApplyButton_Clicked(object sender, RoutedEventArgs e)
+        private async void ApplyButton_Clicked(object sender, RoutedEventArgs e)
         {
-            SaveSettings();
+            await SaveSettings();
         }
 
-        private void SaveSettings()
+        private async Task SaveSettings()
         {
-            ViewModel.SaveSettings();
+            await ViewModel.SaveSettings();
 
             ControllerSettings?.SaveCurrentProfile();
 

Ryujinx.Common/Configuration/GraphicsBackend.cs

@@ -0,0 +1,8 @@
+namespace Ryujinx.Common.Configuration
+{
+    public enum GraphicsBackend
+    {
+        Vulkan,
+        OpenGl
+    }
+}

Ryujinx.Common/Memory/PartialUnmaps/NativeReaderWriterLock.cs

@@ -0,0 +1,80 @@
+using System.Runtime.InteropServices;
+using System.Threading;
+
+using static Ryujinx.Common.Memory.PartialUnmaps.PartialUnmapHelpers;
+
+namespace Ryujinx.Common.Memory.PartialUnmaps
+{
+    /// <summary>
+    /// A simple implementation of a ReaderWriterLock which can be used from native code.
+    /// </summary>
+    [StructLayout(LayoutKind.Sequential, Pack = 1)]
+    public struct NativeReaderWriterLock
+    {
+        public int WriteLock;
+        public int ReaderCount;
+
+        public static int WriteLockOffset;
+        public static int ReaderCountOffset;
+
+        /// <summary>
+        /// Populates the field offsets for use when emitting native code.
+        /// </summary>
+        static NativeReaderWriterLock()
+        {
+            NativeReaderWriterLock instance = new NativeReaderWriterLock();
+
+            WriteLockOffset = OffsetOf(ref instance, ref instance.WriteLock);
+            ReaderCountOffset = OffsetOf(ref instance, ref instance.ReaderCount);
+        }
+
+        /// <summary>
+        /// Acquires the reader lock.
+        /// </summary>
+        public void AcquireReaderLock()
+        {
+            // Must take write lock for a very short time to become a reader.
+
+            while (Interlocked.CompareExchange(ref WriteLock, 1, 0) != 0) { }
+
+            Interlocked.Increment(ref ReaderCount);
+
+            Interlocked.Exchange(ref WriteLock, 0);
+        }
+
+        /// <summary>
+        /// Releases the reader lock.
+        /// </summary>
+        public void ReleaseReaderLock()
+        {
+            Interlocked.Decrement(ref ReaderCount);
+        }
+
+        /// <summary>
+        /// Upgrades to a writer lock. The reader lock is temporarily released while obtaining the writer lock.
+        /// </summary>
+        public void UpgradeToWriterLock()
+        {
+            // Prevent any more threads from entering reader.
+            // If the write lock is already taken, wait for it to not be taken.
+
+            Interlocked.Decrement(ref ReaderCount);
+
+            while (Interlocked.CompareExchange(ref WriteLock, 1, 0) != 0) { }
+
+            // Wait for reader count to drop to 0, then take the lock again as the only reader.
+
+            while (Interlocked.CompareExchange(ref ReaderCount, 1, 0) != 0) { }
+        }
+
+        /// <summary>
+        /// Downgrades from a writer lock, back to a reader one.
+        /// </summary>
+        public void DowngradeFromWriterLock()
+        {
+            // Release the WriteLock.
+
+            Interlocked.Exchange(ref WriteLock, 0);
+        }
+    }
+}

Ryujinx.Common/Memory/PartialUnmaps/PartialUnmapHelpers.cs

@@ -0,0 +1,20 @@
+using System.Runtime.CompilerServices;
+
+namespace Ryujinx.Common.Memory.PartialUnmaps
+{
+    static class PartialUnmapHelpers
+    {
+        /// <summary>
+        /// Calculates a byte offset of a given field within a struct.
+        /// </summary>
+        /// <typeparam name="T">Struct type</typeparam>
+        /// <typeparam name="T2">Field type</typeparam>
+        /// <param name="storage">Parent struct</param>
+        /// <param name="target">Field</param>
+        /// <returns>The byte offset of the given field in the given struct</returns>
+        public static int OffsetOf<T, T2>(ref T2 storage, ref T target)
+        {
+            return (int)Unsafe.ByteOffset(ref Unsafe.As<T2, T>(ref storage), ref target);
+        }
+    }
+}

Ryujinx.Common/Memory/PartialUnmaps/PartialUnmapState.cs

@@ -0,0 +1,160 @@
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Versioning;
+using System.Threading;
+
+using static Ryujinx.Common.Memory.PartialUnmaps.PartialUnmapHelpers;
+
+namespace Ryujinx.Common.Memory.PartialUnmaps
+{
+    /// <summary>
+    /// State for partial unmaps. Intended to be used on Windows.
+    /// </summary>
+    [StructLayout(LayoutKind.Sequential, Pack = 1)]
+    public struct PartialUnmapState
+    {
+        public NativeReaderWriterLock PartialUnmapLock;
+        public int PartialUnmapsCount;
+        public ThreadLocalMap<int> LocalCounts;
+
+        public readonly static int PartialUnmapLockOffset;
+        public readonly static int PartialUnmapsCountOffset;
+        public readonly static int LocalCountsOffset;
+
+        public readonly static IntPtr GlobalState;
+
+        [SupportedOSPlatform("windows")]
+        [DllImport("kernel32.dll")]
+        public static extern int GetCurrentThreadId();
+
+        [SupportedOSPlatform("windows")]
+        [DllImport("kernel32.dll", SetLastError = true)]
+        static extern IntPtr OpenThread(int dwDesiredAccess, bool bInheritHandle, uint dwThreadId);
+
+        [SupportedOSPlatform("windows")]
+        [DllImport("kernel32.dll", SetLastError = true)]
+        public static extern bool CloseHandle(IntPtr hObject);
+
+        [SupportedOSPlatform("windows")]
+        [DllImport("kernel32.dll", SetLastError = true)]
+        static extern bool GetExitCodeThread(IntPtr hThread, out uint lpExitCode);
+
+        /// <summary>
+        /// Creates a global static PartialUnmapState and populates the field offsets.
+        /// </summary>
+        static unsafe PartialUnmapState()
+        {
+            PartialUnmapState instance = new PartialUnmapState();
+
+            PartialUnmapLockOffset = OffsetOf(ref instance, ref instance.PartialUnmapLock);
+            PartialUnmapsCountOffset = OffsetOf(ref instance, ref instance.PartialUnmapsCount);
+            LocalCountsOffset = OffsetOf(ref instance, ref instance.LocalCounts);
+
+            int size = Unsafe.SizeOf<PartialUnmapState>();
+            GlobalState = Marshal.AllocHGlobal(size);
+            Unsafe.InitBlockUnaligned((void*)GlobalState, 0, (uint)size);
+        }
+
+        /// <summary>
+        /// Resets the global state.
+        /// </summary>
+        public static unsafe void Reset()
+        {
+            int size = Unsafe.SizeOf<PartialUnmapState>();
+            Unsafe.InitBlockUnaligned((void*)GlobalState, 0, (uint)size);
+        }
+
+        /// <summary>
+        /// Gets a reference to the global state.
+        /// </summary>
+        /// <returns>A reference to the global state</returns>
+        public static unsafe ref PartialUnmapState GetRef()
+        {
+            return ref Unsafe.AsRef<PartialUnmapState>((void*)GlobalState);
+        }
+
+        /// <summary>
+        /// Checks if an access violation handler should retry execution due to a fault caused by partial unmap.
+        /// </summary>
+        /// <remarks>
+        /// Due to Windows limitations, <see cref="UnmapView"/> might need to unmap more memory than requested.
+        /// The additional memory that was unmapped is later remapped, however this leaves a time gap where the
+        /// memory might be accessed but is unmapped. Users of the API must compensate for that by catching the
+        /// access violation and retrying if it happened between the unmap and remap operation.
+        /// This method can be used to decide if retrying in such cases is necessary or not.
+        /// 
+        /// This version of the function is not used, but serves as a reference for the native
+        /// implementation in ARMeilleure.
+        /// </remarks>
+        /// <returns>True if execution should be retried, false otherwise</returns>
+        [SupportedOSPlatform("windows")]
+        public bool RetryFromAccessViolation()
+        {
+            PartialUnmapLock.AcquireReaderLock();
+
+            int threadID = GetCurrentThreadId();
+            int threadIndex = LocalCounts.GetOrReserve(threadID, 0);
+
+            if (threadIndex == -1)
+            {
+                // Out of thread local space... try again later.
+
+                PartialUnmapLock.ReleaseReaderLock();
+
+                return true;
+            }
+
+            ref int threadLocalPartialUnmapsCount = ref LocalCounts.GetValue(threadIndex);
+
+            bool retry = threadLocalPartialUnmapsCount != PartialUnmapsCount;
+            if (retry)
+            {
+                threadLocalPartialUnmapsCount = PartialUnmapsCount;
+            }
+
+            PartialUnmapLock.ReleaseReaderLock();
+
+            return retry;
+        }
+
+        /// <summary>
+        /// Iterates and trims threads in the thread -> count map that
+        /// are no longer active.
+        /// </summary>
+        [SupportedOSPlatform("windows")]
+        public void TrimThreads()
+        {
+            const uint ExitCodeStillActive = 259;
+            const int ThreadQueryInformation = 0x40;
+
+            Span<int> ids = LocalCounts.ThreadIds.ToSpan();
+
+            for (int i = 0; i < ids.Length; i++)
+            {
+                int id = ids[i];
+                
+                if (id != 0)
+                {
+                    IntPtr handle = OpenThread(ThreadQueryInformation, false, (uint)id);
+
+                    if (handle == IntPtr.Zero)
+                    {
+                        Interlocked.CompareExchange(ref ids[i], 0, id);
+                    }
+                    else
+                    {
+                        GetExitCodeThread(handle, out uint exitCode);
+
+                        if (exitCode != ExitCodeStillActive)
+                        {
+                            Interlocked.CompareExchange(ref ids[i], 0, id);
+                        }
+
+                        CloseHandle(handle);
+                    }
+                }
+            }
+        }
+    }
+}

Ryujinx.Common/Memory/PartialUnmaps/ThreadLocalMap.cs

@@ -0,0 +1,92 @@
+using System.Runtime.InteropServices;
+using System.Threading;
+
+using static Ryujinx.Common.Memory.PartialUnmaps.PartialUnmapHelpers;
+
+namespace Ryujinx.Common.Memory.PartialUnmaps
+{
+    /// <summary>
+    /// A simple fixed size thread safe map that can be used from native code.
+    /// Integer thread IDs map to corresponding structs.
+    /// </summary>
+    /// <typeparam name="T">The value type for the map</typeparam>
+    [StructLayout(LayoutKind.Sequential, Pack = 1)]
+    public struct ThreadLocalMap<T> where T : unmanaged
+    {
+        public const int MapSize = 20;
+
+        public Array20<int> ThreadIds;
+        public Array20<T> Structs;
+
+        public static int ThreadIdsOffset;
+        public static int StructsOffset;
+
+        /// <summary>
+        /// Populates the field offsets for use when emitting native code.
+        /// </summary>
+        static ThreadLocalMap()
+        {
+            ThreadLocalMap<T> instance = new ThreadLocalMap<T>();
+
+            ThreadIdsOffset = OffsetOf(ref instance, ref instance.ThreadIds);
+            StructsOffset = OffsetOf(ref instance, ref instance.Structs);
+        }
+
+        /// <summary>
+        /// Gets the index of a given thread ID in the map, or reserves one.
+        /// When reserving a struct, its value is set to the given initial value.
+        /// Returns -1 when there is no space to reserve a new entry.
+        /// </summary>
+        /// <param name="threadId">Thread ID to use as a key</param>
+        /// <param name="initial">Initial value of the associated struct.</param>
+        /// <returns>The index of the entry, or -1 if none</returns>
+        public int GetOrReserve(int threadId, T initial)
+        {
+            // Try get a match first.
+
+            for (int i = 0; i < MapSize; i++)
+            {
+                int compare = Interlocked.CompareExchange(ref ThreadIds[i], threadId, threadId);
+
+                if (compare == threadId)
+                {
+                    return i;
+                }
+            }
+
+            // Try get a free entry. Since the id is assumed to be unique to this thread, we know it doesn't exist yet.
+
+            for (int i = 0; i < MapSize; i++)
+            {
+                int compare = Interlocked.CompareExchange(ref ThreadIds[i], threadId, 0);
+
+                if (compare == 0)
+                {
+                    Structs[i] = initial;
+                    return i;
+                }
+            }
+
+            return -1;
+        }
+
+        /// <summary>
+        /// Gets the struct value for a given map entry.
+        /// </summary>
+        /// <param name="index">Index of the entry</param>
+        /// <returns>A reference to the struct value</returns>
+        public ref T GetValue(int index)
+        {
+            return ref Structs[index];
+        }
+
+        /// <summary>
+        /// Releases an entry from the map.
+        /// </summary>
+        /// <param name="index">Index of the entry to release</param>
+        public void Release(int index)
+        {
+            Interlocked.Exchange(ref ThreadIds[index], 0);
+        }
+    }
+}

Ryujinx.Common/Memory/StructArrayHelpers.cs

@@ -640,4 +640,15 @@ namespace Ryujinx.Common.Memory
         public ref T this[int index] => ref ToSpan()[index];
         public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 64);
     }
+    public struct Array73<T> : IArray<T> where T : unmanaged
+    {
+#pragma warning disable CS0169
+        T _e0;
+        Array64<T> _other;
+        Array8<T> _other2;
+#pragma warning restore CS0169
+        public int Length => 73;
+        public ref T this[int index] => ref ToSpan()[index];
+        public Span<T> ToSpan() => MemoryMarshal.CreateSpan(ref _e0, 73);
+    }
 }

Ryujinx.Common/System/ForceDpiAware.cs

@@ -44,7 +44,7 @@ namespace Ryujinx.Common.System
             }
         }
 
-        public static double GetWindowScaleFactor()
+        public static double GetActualScaleFactor()
         {
             double userDpiScale = 96.0;
 
@@ -84,6 +84,13 @@ namespace Ryujinx.Common.System
                 Logger.Warning?.Print(LogClass.Application, $"Couldn't determine monitor DPI: {e.Message}");
             }
 
+            return userDpiScale;
+        }
+
+        public static double GetWindowScaleFactor()
+        {
+            double userDpiScale = GetActualScaleFactor();
+
             return Math.Min(userDpiScale / _standardDpiScale, _maxScaleFactor);
         }
     }

Ryujinx.Cpu/Jit/MemoryManagerHostMapped.cs

@@ -89,10 +89,10 @@ namespace Ryujinx.Cpu.Jit
             MemoryAllocationFlags asFlags = MemoryAllocationFlags.Reserve | MemoryAllocationFlags.ViewCompatible;
 
             _addressSpace = new MemoryBlock(asSize, asFlags);
-            _addressSpaceMirror = new MemoryBlock(asSize, asFlags | MemoryAllocationFlags.ForceWindows4KBViewMapping);
+            _addressSpaceMirror = new MemoryBlock(asSize, asFlags);
 
             Tracking = new MemoryTracking(this, PageSize, invalidAccessHandler);
-            _memoryEh = new MemoryEhMeilleure(_addressSpace, Tracking);
+            _memoryEh = new MemoryEhMeilleure(_addressSpace, _addressSpaceMirror, Tracking);
         }
 
         /// <summary>

Ryujinx.Cpu/MemoryEhMeilleure.cs

@@ -6,36 +6,57 @@ using System.Runtime.InteropServices;
 
 namespace Ryujinx.Cpu
 {
-    class MemoryEhMeilleure : IDisposable
+    public class MemoryEhMeilleure : IDisposable
     {
         private delegate bool TrackingEventDelegate(ulong address, ulong size, bool write, bool precise = false);
 
-        private readonly MemoryBlock _addressSpace;
         private readonly MemoryTracking _tracking;
         private readonly TrackingEventDelegate _trackingEvent;
 
         private readonly ulong _baseAddress;
+        private readonly ulong _mirrorAddress;
 
-        public MemoryEhMeilleure(MemoryBlock addressSpace, MemoryTracking tracking)
+        public MemoryEhMeilleure(MemoryBlock addressSpace, MemoryBlock addressSpaceMirror, MemoryTracking tracking)
         {
-            _addressSpace = addressSpace;
             _tracking = tracking;
 
-            _baseAddress = (ulong)_addressSpace.Pointer;
+            _baseAddress = (ulong)addressSpace.Pointer;
             ulong endAddress = _baseAddress + addressSpace.Size;
 
-            _trackingEvent = new TrackingEventDelegate(tracking.VirtualMemoryEventEh);
+            _trackingEvent = new TrackingEventDelegate(tracking.VirtualMemoryEvent);
             bool added = NativeSignalHandler.AddTrackedRegion((nuint)_baseAddress, (nuint)endAddress, Marshal.GetFunctionPointerForDelegate(_trackingEvent));
 
             if (!added)
             {
                 throw new InvalidOperationException("Number of allowed tracked regions exceeded.");
             }
+
+            if (OperatingSystem.IsWindows())
+            {
+                // Add a tracking event with no signal handler for the mirror on Windows.
+                // The native handler has its own code to check for the partial overlap race when regions are protected by accident,
+                // and when there is no signal handler present.
+
+                _mirrorAddress = (ulong)addressSpaceMirror.Pointer;
+                ulong endAddressMirror = _mirrorAddress + addressSpace.Size;
+
+                bool addedMirror = NativeSignalHandler.AddTrackedRegion((nuint)_mirrorAddress, (nuint)endAddressMirror, IntPtr.Zero);
+
+                if (!addedMirror)
+                {
+                    throw new InvalidOperationException("Number of allowed tracked regions exceeded.");
+                }
+            }
         }
 
         public void Dispose()
         {
             NativeSignalHandler.RemoveTrackedRegion((nuint)_baseAddress);
+
+            if (_mirrorAddress != 0)
+            {
+                NativeSignalHandler.RemoveTrackedRegion((nuint)_mirrorAddress);
+            }
         }
     }
 }

Ryujinx.Graphics.GAL/Capabilities.cs

@@ -11,19 +11,29 @@ namespace Ryujinx.Graphics.GAL
         public readonly bool HasVectorIndexingBug;
 
         public readonly bool SupportsAstcCompression;
+        public readonly bool SupportsBc123Compression;
+        public readonly bool SupportsBc45Compression;
+        public readonly bool SupportsBc67Compression;
         public readonly bool Supports3DTextureCompression;
         public readonly bool SupportsBgraFormat;
         public readonly bool SupportsR4G4Format;
         public readonly bool SupportsFragmentShaderInterlock;
         public readonly bool SupportsFragmentShaderOrderingIntel;
+        public readonly bool SupportsGeometryShaderPassthrough;
         public readonly bool SupportsImageLoadFormatted;
         public readonly bool SupportsMismatchingViewFormat;
+        public readonly bool SupportsCubemapView;
         public readonly bool SupportsNonConstantTextureOffset;
         public readonly bool SupportsShaderBallot;
         public readonly bool SupportsTextureShadowLod;
         public readonly bool SupportsViewportSwizzle;
         public readonly bool SupportsIndirectParameters;
 
+        public readonly uint MaximumUniformBuffersPerStage;
+        public readonly uint MaximumStorageBuffersPerStage;
+        public readonly uint MaximumTexturesPerStage;
+        public readonly uint MaximumImagesPerStage;
+
         public readonly int MaximumComputeSharedMemorySize;
         public readonly float MaximumSupportedAnisotropy;
         public readonly int StorageBufferOffsetAlignment;
@@ -34,18 +44,27 @@ namespace Ryujinx.Graphics.GAL
             bool hasFrontFacingBug,
             bool hasVectorIndexingBug,
             bool supportsAstcCompression,
+            bool supportsBc123Compression,
+            bool supportsBc45Compression,
+            bool supportsBc67Compression,
             bool supports3DTextureCompression,
             bool supportsBgraFormat,
             bool supportsR4G4Format,
             bool supportsFragmentShaderInterlock,
             bool supportsFragmentShaderOrderingIntel,
+            bool supportsGeometryShaderPassthrough,
             bool supportsImageLoadFormatted,
             bool supportsMismatchingViewFormat,
+            bool supportsCubemapView,
             bool supportsNonConstantTextureOffset,
             bool supportsShaderBallot,
             bool supportsTextureShadowLod,
             bool supportsViewportSwizzle,
             bool supportsIndirectParameters,
+            uint maximumUniformBuffersPerStage,
+            uint maximumStorageBuffersPerStage,
+            uint maximumTexturesPerStage,
+            uint maximumImagesPerStage,
             int maximumComputeSharedMemorySize,
             float maximumSupportedAnisotropy,
             int storageBufferOffsetAlignment)
@@ -55,18 +74,27 @@ namespace Ryujinx.Graphics.GAL
             HasFrontFacingBug = hasFrontFacingBug;
             HasVectorIndexingBug = hasVectorIndexingBug;
             SupportsAstcCompression = supportsAstcCompression;
+            SupportsBc123Compression = supportsBc123Compression;
+            SupportsBc45Compression = supportsBc45Compression;
+            SupportsBc67Compression = supportsBc67Compression;
             Supports3DTextureCompression = supports3DTextureCompression;
             SupportsBgraFormat = supportsBgraFormat;
             SupportsR4G4Format = supportsR4G4Format;
             SupportsFragmentShaderInterlock = supportsFragmentShaderInterlock;
             SupportsFragmentShaderOrderingIntel = supportsFragmentShaderOrderingIntel;
+            SupportsGeometryShaderPassthrough = supportsGeometryShaderPassthrough;
             SupportsImageLoadFormatted = supportsImageLoadFormatted;
             SupportsMismatchingViewFormat = supportsMismatchingViewFormat;
+            SupportsCubemapView = supportsCubemapView;
             SupportsNonConstantTextureOffset = supportsNonConstantTextureOffset;
             SupportsShaderBallot = supportsShaderBallot;
             SupportsTextureShadowLod = supportsTextureShadowLod;
             SupportsViewportSwizzle = supportsViewportSwizzle;
             SupportsIndirectParameters = supportsIndirectParameters;
+            MaximumUniformBuffersPerStage = maximumUniformBuffersPerStage;
+            MaximumStorageBuffersPerStage = maximumStorageBuffersPerStage;
+            MaximumTexturesPerStage = maximumTexturesPerStage;
+            MaximumImagesPerStage = maximumImagesPerStage;
             MaximumComputeSharedMemorySize = maximumComputeSharedMemorySize;
             MaximumSupportedAnisotropy = maximumSupportedAnisotropy;
             StorageBufferOffsetAlignment = storageBufferOffsetAlignment;

Ryujinx.Graphics.GAL/DeviceInfo.cs

@@ -0,0 +1,18 @@
+namespace Ryujinx.Graphics.GAL
+{
+    public struct DeviceInfo
+    {
+        public readonly string Id;
+        public readonly string Vendor;
+        public readonly string Name;
+        public readonly bool IsDiscrete;
+
+        public DeviceInfo(string id, string vendor, string name, bool isDiscrete)
+        {
+            Id = id;
+            Vendor = vendor;
+            Name = name;
+            IsDiscrete = isDiscrete;
+        }
+    }
+}

Ryujinx.Graphics.GAL/Format.cs

@@ -165,6 +165,120 @@ namespace Ryujinx.Graphics.GAL
 
     public static class FormatExtensions
     {
+        /// <summary>
+        /// Checks if the texture format is valid to use as image format.
+        /// </summary>
+        /// <param name="format">Texture format</param>
+        /// <returns>True if the texture can be used as image, false otherwise</returns>
+        public static bool IsImageCompatible(this Format format)
+        {
+            switch (format)
+            {
+                case Format.R8Unorm:
+                case Format.R8Snorm:
+                case Format.R8Uint:
+                case Format.R8Sint:
+                case Format.R16Float:
+                case Format.R16Unorm:
+                case Format.R16Snorm:
+                case Format.R16Uint:
+                case Format.R16Sint:
+                case Format.R32Float:
+                case Format.R32Uint:
+                case Format.R32Sint:
+                case Format.R8G8Unorm:
+                case Format.R8G8Snorm:
+                case Format.R8G8Uint:
+                case Format.R8G8Sint:
+                case Format.R16G16Float:
+                case Format.R16G16Unorm:
+                case Format.R16G16Snorm:
+                case Format.R16G16Uint:
+                case Format.R16G16Sint:
+                case Format.R32G32Float:
+                case Format.R32G32Uint:
+                case Format.R32G32Sint:
+                case Format.R8G8B8A8Unorm:
+                case Format.R8G8B8A8Snorm:
+                case Format.R8G8B8A8Uint:
+                case Format.R8G8B8A8Sint:
+                case Format.R16G16B16A16Float:
+                case Format.R16G16B16A16Unorm:
+                case Format.R16G16B16A16Snorm:
+                case Format.R16G16B16A16Uint:
+                case Format.R16G16B16A16Sint:
+                case Format.R32G32B32A32Float:
+                case Format.R32G32B32A32Uint:
+                case Format.R32G32B32A32Sint:
+                case Format.R10G10B10A2Unorm:
+                case Format.R10G10B10A2Uint:
+                case Format.R11G11B10Float:
+                    return true;
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Checks if the texture format is valid to use as render target color format.
+        /// </summary>
+        /// <param name="format">Texture format</param>
+        /// <returns>True if the texture can be used as render target, false otherwise</returns>
+        public static bool IsRtColorCompatible(this Format format)
+        {
+            switch (format)
+            {
+                case Format.R32G32B32A32Float:
+                case Format.R32G32B32A32Sint:
+                case Format.R32G32B32A32Uint:
+                case Format.R16G16B16A16Unorm:
+                case Format.R16G16B16A16Snorm:
+                case Format.R16G16B16A16Sint:
+                case Format.R16G16B16A16Uint:
+                case Format.R16G16B16A16Float:
+                case Format.R32G32Float:
+                case Format.R32G32Sint:
+                case Format.R32G32Uint:
+                case Format.B8G8R8A8Unorm:
+                case Format.B8G8R8A8Srgb:
+                case Format.R10G10B10A2Unorm:
+                case Format.R10G10B10A2Uint:
+                case Format.R8G8B8A8Unorm:
+                case Format.R8G8B8A8Srgb:
+                case Format.R8G8B8A8Snorm:
+                case Format.R8G8B8A8Sint:
+                case Format.R8G8B8A8Uint:
+                case Format.R16G16Unorm:
+                case Format.R16G16Snorm:
+                case Format.R16G16Sint:
+                case Format.R16G16Uint:
+                case Format.R16G16Float:
+                case Format.R11G11B10Float:
+                case Format.R32Sint:
+                case Format.R32Uint:
+                case Format.R32Float:
+                case Format.B5G6R5Unorm:
+                case Format.B5G5R5A1Unorm:
+                case Format.R8G8Unorm:
+                case Format.R8G8Snorm:
+                case Format.R8G8Sint:
+                case Format.R8G8Uint:
+                case Format.R16Unorm:
+                case Format.R16Snorm:
+                case Format.R16Sint:
+                case Format.R16Uint:
+                case Format.R16Float:
+                case Format.R8Unorm:
+                case Format.R8Snorm:
+                case Format.R8Sint:
+                case Format.R8Uint:
+                case Format.B5G5R5X1Unorm:
+                    return true;
+            }
+
+            return false;
+        }
+
         /// <summary>
         /// Checks if the texture format is an ASTC format.
         /// </summary>

Ryujinx.Graphics.GAL/HardwareInfo.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Ryujinx.Graphics.GAL
+{
+    public struct HardwareInfo
+    {
+        public string GpuVendor { get; }
+        public string GpuModel { get; }
+
+        public HardwareInfo(string gpuVendor, string gpuModel)
+        {
+            GpuVendor = gpuVendor;
+            GpuModel = gpuModel;
+        }
+    }
+}

Ryujinx.Graphics.GAL/IPipeline.cs

@@ -1,3 +1,4 @@
+using Ryujinx.Graphics.Shader;
 using System;
 
 namespace Ryujinx.Graphics.GAL
@@ -10,10 +11,11 @@ namespace Ryujinx.Graphics.GAL
 
         void ClearBuffer(BufferHandle destination, int offset, int size, uint value);
 
-        void ClearRenderTargetColor(int index, int layer, uint componentMask, ColorF color);
+        void ClearRenderTargetColor(int index, int layer, int layerCount, uint componentMask, ColorF color);
 
         void ClearRenderTargetDepthStencil(
             int layer,
+            int layerCount,
             float depthValue,
             bool depthMask,
             int stencilValue,
@@ -79,15 +81,13 @@ namespace Ryujinx.Graphics.GAL
         void SetRenderTargetColorMasks(ReadOnlySpan<uint> componentMask);
         void SetRenderTargets(ITexture[] colors, ITexture depthStencil);
 
-        void SetSampler(int binding, ISampler sampler);
-
-        void SetScissor(int index, bool enable, int x, int y, int width, int height);
+        void SetScissors(ReadOnlySpan<Rectangle<int>> regions);
 
         void SetStencilTest(StencilTestDescriptor stencilTest);
 
         void SetStorageBuffers(int first, ReadOnlySpan<BufferRange> buffers);
 
-        void SetTexture(int binding, ITexture texture);
+        void SetTextureAndSampler(ShaderStage stage, int binding, ITexture texture, ISampler sampler);
 
         void SetTransformFeedbackBuffers(ReadOnlySpan<BufferRange> buffers);
         void SetUniformBuffers(int first, ReadOnlySpan<BufferRange> buffers);
@@ -97,7 +97,7 @@ namespace Ryujinx.Graphics.GAL
         void SetVertexAttribs(ReadOnlySpan<VertexAttribDescriptor> vertexAttribs);
         void SetVertexBuffers(ReadOnlySpan<VertexBufferDescriptor> vertexBuffers);
 
-        void SetViewports(int first, ReadOnlySpan<Viewport> viewports, bool disableTransform);
+        void SetViewports(ReadOnlySpan<Viewport> viewports, bool disableTransform);
 
         void TextureBarrier();
         void TextureBarrierTiled();

Ryujinx.Graphics.GAL/IRenderer.cs

@@ -30,6 +30,7 @@ namespace Ryujinx.Graphics.GAL
         ReadOnlySpan<byte> GetBufferData(BufferHandle buffer, int offset, int size);
 
         Capabilities GetCapabilities();
+        HardwareInfo GetHardwareInfo();
 
         IProgram LoadProgramBinary(byte[] programBinary, bool hasFragmentShader, ShaderInfo info);
 

Ryujinx.Graphics.GAL/IShader.cs

@@ -1,6 +0,0 @@
-using System;
-
-namespace Ryujinx.Graphics.GAL
-{
-    public interface IShader : IDisposable { }
-}

Ryujinx.Graphics.GAL/Multithreading/CommandHelper.cs

@@ -201,14 +201,12 @@ namespace Ryujinx.Graphics.GAL.Multithreading
                 SetRenderTargetScaleCommand.Run(ref GetCommand<SetRenderTargetScaleCommand>(memory), threaded, renderer);
             _lookup[(int)CommandType.SetRenderTargets] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
                 SetRenderTargetsCommand.Run(ref GetCommand<SetRenderTargetsCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetSampler] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
-                SetSamplerCommand.Run(ref GetCommand<SetSamplerCommand>(memory), threaded, renderer);
             _lookup[(int)CommandType.SetScissor] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
-                SetScissorCommand.Run(ref GetCommand<SetScissorCommand>(memory), threaded, renderer);
+                SetScissorsCommand.Run(ref GetCommand<SetScissorsCommand>(memory), threaded, renderer);
             _lookup[(int)CommandType.SetStencilTest] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
                 SetStencilTestCommand.Run(ref GetCommand<SetStencilTestCommand>(memory), threaded, renderer);
-            _lookup[(int)CommandType.SetTexture] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
-                SetTextureCommand.Run(ref GetCommand<SetTextureCommand>(memory), threaded, renderer);
+            _lookup[(int)CommandType.SetTextureAndSampler] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
+                SetTextureAndSamplerCommand.Run(ref GetCommand<SetTextureAndSamplerCommand>(memory), threaded, renderer);
             _lookup[(int)CommandType.SetUserClipDistance] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>
                 SetUserClipDistanceCommand.Run(ref GetCommand<SetUserClipDistanceCommand>(memory), threaded, renderer);
             _lookup[(int)CommandType.SetVertexAttribs] = (Span<byte> memory, ThreadedRenderer threaded, IRenderer renderer) =>

Ryujinx.Graphics.GAL/Multithreading/CommandType.cs

@@ -82,10 +82,9 @@
         SetRenderTargetColorMasks,
         SetRenderTargetScale,
         SetRenderTargets,
-        SetSampler,
         SetScissor,
         SetStencilTest,
-        SetTexture,
+        SetTextureAndSampler,
         SetUserClipDistance,
         SetVertexAttribs,
         SetVertexBuffers,

Ryujinx.Graphics.GAL/Multithreading/Commands/ClearRenderTargetColorCommand.cs

@@ -5,20 +5,22 @@
         public CommandType CommandType => CommandType.ClearRenderTargetColor;
         private int _index;
         private int _layer;
+        private int _layerCount;
         private uint _componentMask;
         private ColorF _color;
 
-        public void Set(int index, int layer, uint componentMask, ColorF color)
+        public void Set(int index, int layer, int layerCount, uint componentMask, ColorF color)
         {
             _index = index;
             _layer = layer;
+            _layerCount = layerCount;
             _componentMask = componentMask;
             _color = color;
         }
 
         public static void Run(ref ClearRenderTargetColorCommand command, ThreadedRenderer threaded, IRenderer renderer)
         {
-            renderer.Pipeline.ClearRenderTargetColor(command._index, command._layer, command._componentMask, command._color);
+            renderer.Pipeline.ClearRenderTargetColor(command._index, command._layer, command._layerCount, command._componentMask, command._color);
         }
     }
 }

Ryujinx.Graphics.GAL/Multithreading/Commands/ClearRenderTargetDepthStencilCommand.cs

@@ -4,14 +4,16 @@
     {
         public CommandType CommandType => CommandType.ClearRenderTargetDepthStencil;
         private int _layer;
+        private int _layerCount;
         private float _depthValue;
         private bool _depthMask;
         private int _stencilValue;
         private int _stencilMask;
 
-        public void Set(int layer, float depthValue, bool depthMask, int stencilValue, int stencilMask)
+        public void Set(int layer, int layerCount, float depthValue, bool depthMask, int stencilValue, int stencilMask)
         {
             _layer = layer;
+            _layerCount = layerCount;
             _depthValue = depthValue;
             _depthMask = depthMask;
             _stencilValue = stencilValue;
@@ -20,7 +22,7 @@
 
         public static void Run(ref ClearRenderTargetDepthStencilCommand command, ThreadedRenderer threaded, IRenderer renderer)
         {
-            renderer.Pipeline.ClearRenderTargetDepthStencil(command._layer, command._depthValue, command._depthMask, command._stencilValue, command._stencilMask);
+            renderer.Pipeline.ClearRenderTargetDepthStencil(command._layer, command._layerCount, command._depthValue, command._depthMask, command._stencilValue, command._stencilMask);
         }
     }
 }

Ryujinx.Graphics.GAL/Multithreading/Commands/SetSamplerCommand.cs

@@ -1,23 +0,0 @@
-using Ryujinx.Graphics.GAL.Multithreading.Model;
-using Ryujinx.Graphics.GAL.Multithreading.Resources;
-
-namespace Ryujinx.Graphics.GAL.Multithreading.Commands
-{
-    struct SetSamplerCommand : IGALCommand
-    {
-        public CommandType CommandType => CommandType.SetSampler;
-        private int _index;
-        private TableRef<ISampler> _sampler;
-
-        public void Set(int index, TableRef<ISampler> sampler)
-        {
-            _index = index;
-            _sampler = sampler;
-        }
-
-        public static void Run(ref SetSamplerCommand command, ThreadedRenderer threaded, IRenderer renderer)
-        {
-            renderer.Pipeline.SetSampler(command._index, command._sampler.GetAs<ThreadedSampler>(threaded)?.Base);
-        }
-    }
-}

Ryujinx.Graphics.GAL/Multithreading/Commands/SetScissorCommand.cs

@@ -1,28 +0,0 @@
-namespace Ryujinx.Graphics.GAL.Multithreading.Commands
-{
-    struct SetScissorCommand : IGALCommand
-    {
-        public CommandType CommandType => CommandType.SetScissor;
-        private int _index;
-        private bool _enable;
-        private int _x;
-        private int _y;
-        private int _width;
-        private int _height;
-
-        public void Set(int index, bool enable, int x, int y, int width, int height)
-        {
-            _index = index;
-            _enable = enable;
-            _x = x;
-            _y = y;
-            _width = width;
-            _height = height;
-        }
-
-        public static void Run(ref SetScissorCommand command, ThreadedRenderer threaded, IRenderer renderer)
-        {
-            renderer.Pipeline.SetScissor(command._index, command._enable, command._x, command._y, command._width, command._height);
-        }
-    }
-}

Ryujinx.Graphics.GAL/Multithreading/Commands/SetScissorsCommand.cs

@@ -0,0 +1,22 @@
+using Ryujinx.Graphics.GAL.Multithreading.Model;
+
+namespace Ryujinx.Graphics.GAL.Multithreading.Commands
+{
+    struct SetScissorsCommand : IGALCommand
+    {
+        public CommandType CommandType => CommandType.SetScissor;
+        private SpanRef<Rectangle<int>> _scissors;
+
+        public void Set(SpanRef<Rectangle<int>> scissors)
+        {
+            _scissors = scissors;
+        }
+
+        public static void Run(ref SetScissorsCommand command, ThreadedRenderer threaded, IRenderer renderer)
+        {
+            renderer.Pipeline.SetScissors(command._scissors.Get(threaded));
+
+            command._scissors.Dispose(threaded);
+        }
+    }
+}

Ryujinx.Graphics.GAL/Multithreading/Commands/SetTextureAndSamplerCommand.cs

@@ -0,0 +1,28 @@
+using Ryujinx.Graphics.GAL.Multithreading.Model;
+using Ryujinx.Graphics.GAL.Multithreading.Resources;
+using Ryujinx.Graphics.Shader;
+
+namespace Ryujinx.Graphics.GAL.Multithreading.Commands
+{
+    struct SetTextureAndSamplerCommand : IGALCommand
+    {
+        public CommandType CommandType => CommandType.SetTextureAndSampler;
+        private ShaderStage _stage;
+        private int _binding;
+        private TableRef<ITexture> _texture;
+        private TableRef<ISampler> _sampler;
+
+        public void Set(ShaderStage stage, int binding, TableRef<ITexture> texture, TableRef<ISampler> sampler)
+        {
+            _stage = stage;
+            _binding = binding;
+            _texture = texture;
+            _sampler = sampler;
+        }
+
+        public static void Run(ref SetTextureAndSamplerCommand command, ThreadedRenderer threaded, IRenderer renderer)
+        {
+            renderer.Pipeline.SetTextureAndSampler(command._stage, command._binding, command._texture.GetAs<ThreadedTexture>(threaded)?.Base, command._sampler.GetAs<ThreadedSampler>(threaded)?.Base);
+        }
+    }
+}

Ryujinx.Graphics.GAL/Multithreading/Commands/SetTextureCommand.cs

@@ -1,23 +0,0 @@
-using Ryujinx.Graphics.GAL.Multithreading.Model;
-using Ryujinx.Graphics.GAL.Multithreading.Resources;
-
-namespace Ryujinx.Graphics.GAL.Multithreading.Commands
-{
-    struct SetTextureCommand : IGALCommand
-    {
-        public CommandType CommandType => CommandType.SetTexture;
-        private int _binding;
-        private TableRef<ITexture> _texture;
-
-        public void Set(int binding, TableRef<ITexture> texture)
-        {
-            _binding = binding;
-            _texture = texture;
-        }
-
-        public static void Run(ref SetTextureCommand command, ThreadedRenderer threaded, IRenderer renderer)
-        {
-            renderer.Pipeline.SetTexture(command._binding, command._texture.GetAs<ThreadedTexture>(threaded)?.Base);
-        }
-    }
-}

Ryujinx.Graphics.GAL/Multithreading/Commands/SetViewportsCommand.cs

@@ -7,13 +7,11 @@ namespace Ryujinx.Graphics.GAL.Multithreading.Commands
     struct SetViewportsCommand : IGALCommand
     {
         public CommandType CommandType => CommandType.SetViewports;
-        private int _first;
         private SpanRef<Viewport> _viewports;
         private bool _disableTransform;
 
-        public void Set(int first, SpanRef<Viewport> viewports, bool disableTransform)
+        public void Set(SpanRef<Viewport> viewports, bool disableTransform)
         {
-            _first = first;
             _viewports = viewports;
             _disableTransform = disableTransform;
         }
@@ -21,7 +19,7 @@ namespace Ryujinx.Graphics.GAL.Multithreading.Commands
         public static void Run(ref SetViewportsCommand command, ThreadedRenderer threaded, IRenderer renderer)
         {
             ReadOnlySpan<Viewport> viewports = command._viewports.Get(threaded);
-            renderer.Pipeline.SetViewports(command._first, viewports, command._disableTransform);
+            renderer.Pipeline.SetViewports(viewports, command._disableTransform);
             command._viewports.Dispose(threaded);
         }
     }

Ryujinx.Graphics.GAL/Multithreading/ThreadedPipeline.cs

@@ -1,6 +1,7 @@
 using Ryujinx.Graphics.GAL.Multithreading.Commands;
 using Ryujinx.Graphics.GAL.Multithreading.Model;
 using Ryujinx.Graphics.GAL.Multithreading.Resources;
+using Ryujinx.Graphics.Shader;
 using System;
 using System.Linq;
 
@@ -40,15 +41,15 @@ namespace Ryujinx.Graphics.GAL.Multithreading
             _renderer.QueueCommand();
         }
 
-        public void ClearRenderTargetColor(int index, int layer, uint componentMask, ColorF color)
+        public void ClearRenderTargetColor(int index, int layer, int layerCount, uint componentMask, ColorF color)
         {
-            _renderer.New<ClearRenderTargetColorCommand>().Set(index, layer, componentMask, color);
+            _renderer.New<ClearRenderTargetColorCommand>().Set(index, layer, layerCount, componentMask, color);
             _renderer.QueueCommand();
         }
 
-        public void ClearRenderTargetDepthStencil(int layer, float depthValue, bool depthMask, int stencilValue, int stencilMask)
+        public void ClearRenderTargetDepthStencil(int layer, int layerCount, float depthValue, bool depthMask, int stencilValue, int stencilMask)
         {
-            _renderer.New<ClearRenderTargetDepthStencilCommand>().Set(layer, depthValue, depthMask, stencilValue, stencilMask);
+            _renderer.New<ClearRenderTargetDepthStencilCommand>().Set(layer, layerCount, depthValue, depthMask, stencilValue, stencilMask);
             _renderer.QueueCommand();
         }
 
@@ -250,15 +251,9 @@ namespace Ryujinx.Graphics.GAL.Multithreading
             _renderer.QueueCommand();
         }
 
-        public void SetSampler(int binding, ISampler sampler)
+        public void SetScissors(ReadOnlySpan<Rectangle<int>> scissors)
         {
-            _renderer.New<SetSamplerCommand>().Set(binding, Ref(sampler));
-            _renderer.QueueCommand();
-        }
-
-        public void SetScissor(int index, bool enable, int x, int y, int width, int height)
-        {
-            _renderer.New<SetScissorCommand>().Set(index, enable, x, y, width, height);
+            _renderer.New<SetScissorsCommand>().Set(_renderer.CopySpan(scissors));
             _renderer.QueueCommand();
         }
 
@@ -274,9 +269,9 @@ namespace Ryujinx.Graphics.GAL.Multithreading
             _renderer.QueueCommand();
         }
 
-        public void SetTexture(int binding, ITexture texture)
+        public void SetTextureAndSampler(ShaderStage stage, int binding, ITexture texture, ISampler sampler)
         {
-            _renderer.New<SetTextureCommand>().Set(binding, Ref(texture));
+            _renderer.New<SetTextureAndSamplerCommand>().Set(stage, binding, Ref(texture), Ref(sampler));
             _renderer.QueueCommand();
         }
 
@@ -310,9 +305,9 @@ namespace Ryujinx.Graphics.GAL.Multithreading
             _renderer.QueueCommand();
         }
 
-        public void SetViewports(int first, ReadOnlySpan<Viewport> viewports, bool disableTransform)
+        public void SetViewports(ReadOnlySpan<Viewport> viewports, bool disableTransform)
         {
-            _renderer.New<SetViewportsCommand>().Set(first, _renderer.CopySpan(viewports), disableTransform);
+            _renderer.New<SetViewportsCommand>().Set(_renderer.CopySpan(viewports), disableTransform);
             _renderer.QueueCommand();
         }
 

Ryujinx.Graphics.GAL/Multithreading/ThreadedRenderer.cs

@@ -6,7 +6,6 @@ using Ryujinx.Graphics.GAL.Multithreading.Commands.Renderer;
 using Ryujinx.Graphics.GAL.Multithreading.Model;
 using Ryujinx.Graphics.GAL.Multithreading.Resources;
 using Ryujinx.Graphics.GAL.Multithreading.Resources.Programs;
-using Ryujinx.Graphics.Shader;
 using System;
 using System.Diagnostics;
 using System.Runtime.CompilerServices;
@@ -76,7 +75,7 @@ namespace Ryujinx.Graphics.GAL.Multithreading
             renderer.ScreenCaptured += (object sender, ScreenCaptureImageInfo info) => ScreenCaptured?.Invoke(this, info);
 
             Pipeline = new ThreadedPipeline(this, renderer.Pipeline);
-            Window = new ThreadedWindow(this, renderer.Window);
+            Window = new ThreadedWindow(this, renderer);
             Buffers = new BufferMap();
             Sync = new SyncMap();
             Programs = new ProgramQueue(renderer);
@@ -262,7 +261,9 @@ namespace Ryujinx.Graphics.GAL.Multithreading
         public IProgram CreateProgram(ShaderSource[] shaders, ShaderInfo info)
         {
             var program = new ThreadedProgram(this);
+
             SourceProgramRequest request = new SourceProgramRequest(program, shaders, info);
+
             Programs.Add(request);
 
             New<CreateProgramCommand>().Set(Ref((IProgramRequest)request));
@@ -337,6 +338,11 @@ namespace Ryujinx.Graphics.GAL.Multithreading
             return box.Result;
         }
 
+        public HardwareInfo GetHardwareInfo()
+        {
+            return _baseRenderer.GetHardwareInfo();
+        }
+
         /// <summary>
         /// Initialize the base renderer. Must be called on the render thread.
         /// </summary>

Ryujinx.Graphics.GAL/Multithreading/ThreadedWindow.cs

@@ -8,12 +8,12 @@ namespace Ryujinx.Graphics.GAL.Multithreading
     public class ThreadedWindow : IWindow
     {
         private ThreadedRenderer _renderer;
-        private IWindow _impl;
+        private IRenderer _impl;
 
-        public ThreadedWindow(ThreadedRenderer renderer, IWindow window)
+        public ThreadedWindow(ThreadedRenderer renderer, IRenderer impl)
         {
             _renderer = renderer;
-            _impl = window;
+            _impl = impl;
         }
 
         public void Present(ITexture texture, ImageCrop crop, Action<object> swapBuffersCallback)
@@ -28,7 +28,7 @@ namespace Ryujinx.Graphics.GAL.Multithreading
 
         public void SetSize(int width, int height)
         {
-            _impl.SetSize(width, height);
+            _impl.Window.SetSize(width, height);
         }
     }
 }

Ryujinx.Graphics.GAL/ProgramPipelineState.cs

@@ -0,0 +1,78 @@
+using Ryujinx.Common.Memory;
+using System;
+
+namespace Ryujinx.Graphics.GAL
+{
+    /// <summary>
+    /// Descriptor for a pipeline buffer binding.
+    /// </summary>
+    public struct BufferPipelineDescriptor
+    {
+        public bool Enable { get; }
+        public int Stride { get; }
+        public int Divisor { get; }
+
+        public BufferPipelineDescriptor(bool enable, int stride, int divisor)
+        {
+            Enable = enable;
+            Stride = stride;
+            Divisor = divisor;
+        }
+    }
+
+    /// <summary>
+    /// State required for a program to compile shaders.
+    /// </summary>
+    public struct ProgramPipelineState
+    {
+        // Some state is considered always dynamic and should not be included:
+        // - Viewports/Scissors
+        // - Bias values (not enable)
+
+        public int SamplesCount;
+        public Array8<bool> AttachmentEnable;
+        public Array8<Format> AttachmentFormats;
+        public bool DepthStencilEnable;
+        public Format DepthStencilFormat;
+
+        public bool LogicOpEnable;
+        public LogicalOp LogicOp;
+        public Array8<BlendDescriptor> BlendDescriptors;
+        public Array8<uint> ColorWriteMask;
+
+        public int VertexAttribCount;
+        public Array32<VertexAttribDescriptor> VertexAttribs;
+
+        public int VertexBufferCount;
+        public Array32<BufferPipelineDescriptor> VertexBuffers;
+
+        // TODO: Min/max depth bounds.
+        public DepthTestDescriptor DepthTest;
+        public StencilTestDescriptor StencilTest;
+        public FrontFace FrontFace;
+        public Face CullMode;
+        public bool CullEnable;
+
+        public PolygonModeMask BiasEnable;
+
+        public float LineWidth;
+        // TODO: Polygon mode.
+        public bool DepthClampEnable;
+        public bool RasterizerDiscard;
+        public PrimitiveTopology Topology;
+        public bool PrimitiveRestartEnable;
+        public uint PatchControlPoints;
+
+        public void SetVertexAttribs(ReadOnlySpan<VertexAttribDescriptor> vertexAttribs)
+        {
+            VertexAttribCount = vertexAttribs.Length;
+            vertexAttribs.CopyTo(VertexAttribs.ToSpan());
+        }
+
+        public void SetLogicOpState(bool enable, LogicalOp op)
+        {
+            LogicOp = op;
+            LogicOpEnable = enable;
+        }
+    }
+}

Ryujinx.Graphics.GAL/Rectangle.cs

@@ -0,0 +1,18 @@
+namespace Ryujinx.Graphics.GAL
+{
+    public struct Rectangle<T> where T : unmanaged
+    {
+        public T X { get; }
+        public T Y { get; }
+        public T Width { get; }
+        public T Height { get; }
+
+        public Rectangle(T x, T y, T width, T height)
+        {
+            X = x;
+            Y = y;
+            Width = width;
+            Height = height;
+        }
+    }
+}

Ryujinx.Graphics.GAL/RectangleF.cs

@@ -1,18 +0,0 @@
-namespace Ryujinx.Graphics.GAL
-{
-    public struct RectangleF
-    {
-        public float X { get; }
-        public float Y { get; }
-        public float Width { get; }
-        public float Height { get; }
-
-        public RectangleF(float x, float y, float width, float height)
-        {
-            X = x;
-            Y = y;
-            Width = width;
-            Height = height;
-        }
-    }
-}

Ryujinx.Graphics.GAL/SamplerCreateInfo.cs

@@ -50,5 +50,23 @@ namespace Ryujinx.Graphics.GAL
             MipLodBias      = mipLodBias;
             MaxAnisotropy   = maxAnisotropy;
         }
+
+        public static SamplerCreateInfo Create(MinFilter minFilter, MagFilter magFilter)
+        {
+            return new SamplerCreateInfo(
+                minFilter,
+                magFilter,
+                false,
+                AddressMode.ClampToEdge,
+                AddressMode.ClampToEdge,
+                AddressMode.ClampToEdge,
+                CompareMode.None,
+                GAL.CompareOp.Always,
+                new ColorF(0f, 0f, 0f, 0f),
+                0f,
+                0f,
+                0f,
+                1f);
+        }
     }
 }

Ryujinx.Graphics.GAL/ShaderBindings.cs

@@ -0,0 +1,24 @@
+using System.Collections.Generic;
+
+namespace Ryujinx.Graphics.GAL
+{
+    public struct ShaderBindings
+    {
+        public IReadOnlyCollection<int> UniformBufferBindings { get; }
+        public IReadOnlyCollection<int> StorageBufferBindings { get; }
+        public IReadOnlyCollection<int> TextureBindings { get; }
+        public IReadOnlyCollection<int> ImageBindings { get; }
+
+        public ShaderBindings(
+            IReadOnlyCollection<int> uniformBufferBindings,
+            IReadOnlyCollection<int> storageBufferBindings,
+            IReadOnlyCollection<int> textureBindings,
+            IReadOnlyCollection<int> imageBindings)
+        {
+            UniformBufferBindings = uniformBufferBindings;
+            StorageBufferBindings = storageBufferBindings;
+            TextureBindings = textureBindings;
+            ImageBindings = imageBindings;
+        }
+    }
+}

Ryujinx.Graphics.GAL/ShaderInfo.cs

@@ -3,10 +3,21 @@ namespace Ryujinx.Graphics.GAL
     public struct ShaderInfo
     {
         public int FragmentOutputMap { get; }
+        public ProgramPipelineState? State { get; }
+        public bool FromCache { get; set; }
 
-        public ShaderInfo(int fragmentOutputMap)
+        public ShaderInfo(int fragmentOutputMap, ProgramPipelineState state, bool fromCache = false)
         {
             FragmentOutputMap = fragmentOutputMap;
+            State = state;
+            FromCache = fromCache;
+        }
+
+        public ShaderInfo(int fragmentOutputMap, bool fromCache = false)
+        {
+            FragmentOutputMap = fragmentOutputMap;
+            State = null;
+            FromCache = fromCache;
         }
     }
 }

Ryujinx.Graphics.GAL/ShaderSource.cs

@@ -7,22 +7,24 @@ namespace Ryujinx.Graphics.GAL
     {
         public string Code { get; }
         public byte[] BinaryCode { get; }
+        public ShaderBindings Bindings { get; }
         public ShaderStage Stage { get; }
         public TargetLanguage Language { get; }
 
-        public ShaderSource(string code, byte[] binaryCode, ShaderStage stage, TargetLanguage language)
+        public ShaderSource(string code, byte[] binaryCode, ShaderBindings bindings, ShaderStage stage, TargetLanguage language)
         {
             Code = code;
             BinaryCode = binaryCode;
+            Bindings = bindings;
             Stage = stage;
             Language = language;
         }
 
-        public ShaderSource(string code, ShaderStage stage, TargetLanguage language) : this(code, null, stage, language)
+        public ShaderSource(string code, ShaderBindings bindings, ShaderStage stage, TargetLanguage language) : this(code, null, bindings, stage, language)
         {
         }
 
-        public ShaderSource(byte[] binaryCode, ShaderStage stage, TargetLanguage language) : this(null, binaryCode, stage, language)
+        public ShaderSource(byte[] binaryCode, ShaderBindings bindings, ShaderStage stage, TargetLanguage language) : this(null, binaryCode, bindings, stage, language)
         {
         }
     }

Ryujinx.Graphics.GAL/Viewport.cs

@@ -2,7 +2,7 @@ namespace Ryujinx.Graphics.GAL
 {
     public struct Viewport
     {
-        public RectangleF Region { get; }
+        public Rectangle<float> Region { get; }
 
         public ViewportSwizzle SwizzleX { get; }
         public ViewportSwizzle SwizzleY { get; }
@@ -13,13 +13,13 @@ namespace Ryujinx.Graphics.GAL
         public float DepthFar  { get; }
 
         public Viewport(
-            RectangleF      region,
-            ViewportSwizzle swizzleX,
-            ViewportSwizzle swizzleY,
-            ViewportSwizzle swizzleZ,
-            ViewportSwizzle swizzleW,
-            float           depthNear,
-            float           depthFar)
+            Rectangle<float> region,
+            ViewportSwizzle  swizzleX,
+            ViewportSwizzle  swizzleY,
+            ViewportSwizzle  swizzleZ,
+            ViewportSwizzle  swizzleW,
+            float            depthNear,
+            float            depthFar)
         {
             Region    = region;
             SwizzleX  = swizzleX;

Ryujinx.Graphics.Gpu/Constants.cs

@@ -18,7 +18,7 @@ namespace Ryujinx.Graphics.Gpu
         /// Maximum number of compute storage buffers.
         /// </summary>
         /// <remarks>
-        /// The maximum number of storage buffers is API limited, the hardware supports a unlimited amount.
+        /// The maximum number of storage buffers is API limited, the hardware supports an unlimited amount.
         /// </remarks>
         public const int TotalCpStorageBuffers = 16;
 
@@ -31,7 +31,7 @@ namespace Ryujinx.Graphics.Gpu
         /// Maximum number of graphics storage buffers.
         /// </summary>
         /// <remarks>
-        /// The maximum number of storage buffers is API limited, the hardware supports a unlimited amount.
+        /// The maximum number of storage buffers is API limited, the hardware supports an unlimited amount.
         /// </remarks>
         public const int TotalGpStorageBuffers = 16;
 
@@ -40,6 +40,22 @@ namespace Ryujinx.Graphics.Gpu
         /// </summary>
         public const int TotalTransformFeedbackBuffers = 4;
 
+        /// <summary>
+        /// Maximum number of textures on a single shader stage.
+        /// </summary>
+        /// <remarks>
+        /// The maximum number of textures is API limited, the hardware supports an unlimited amount.
+        /// </remarks>
+        public const int TotalTextures = 32;
+
+        /// <summary>
+        /// Maximum number of images on a single shader stage.
+        /// </summary>
+        /// <remarks>
+        /// The maximum number of images is API limited, the hardware supports an unlimited amount.
+        /// </remarks>
+        public const int TotalImages = 8;
+
         /// <summary>
         /// Maximum number of render target color buffers.
         /// </summary>
@@ -53,7 +69,7 @@ namespace Ryujinx.Graphics.Gpu
         /// <summary>
         /// Maximum number of vertex attributes.
         /// </summary>
-        public const int TotalVertexAttribs = 16;
+        public const int TotalVertexAttribs = 16; // FIXME: Should be 32, but OpenGL only supports 16.
 
         /// <summary>
         /// Maximum number of vertex buffers.

Ryujinx.Graphics.Gpu/Engine/Compute/ComputeClass.cs

@@ -238,8 +238,8 @@ namespace Ryujinx.Graphics.Gpu.Engine.Compute
             _channel.TextureManager.SetComputeMaxBindings(maxTextureBinding, maxImageBinding);
 
             // Should never return false for mismatching spec state, since the shader was fetched above.
-            _channel.TextureManager.CommitComputeBindings(cs.SpecializationState); 
-            
+            _channel.TextureManager.CommitComputeBindings(cs.SpecializationState);
+
             _channel.BufferManager.CommitComputeBindings();
 
             _context.Renderer.Pipeline.DispatchCompute(qmd.CtaRasterWidth, qmd.CtaRasterHeight, qmd.CtaRasterDepth);

Ryujinx.Graphics.Gpu/Engine/Dma/DmaClass.cs

@@ -147,6 +147,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.Dma
             int xCount = (int)_state.State.LineLengthIn;
             int yCount = (int)_state.State.LineCount;
 
+            _3dEngine.CreatePendingSyncs();
             _3dEngine.FlushUboDirty();
 
             if (copy2D)

Ryujinx.Graphics.Gpu/Engine/GPFifo/GPFifoClass.cs

@@ -15,6 +15,9 @@ namespace Ryujinx.Graphics.Gpu.Engine.GPFifo
         private readonly GPFifoProcessor _parent;
         private readonly DeviceState<GPFifoClassState> _state;
 
+        private int _previousSubChannel;
+        private bool _createSyncPending;
+
         private const int MacrosCount = 0x80;
 
         // Note: The size of the macro memory is unknown, we just make
@@ -48,6 +51,18 @@ namespace Ryujinx.Graphics.Gpu.Engine.GPFifo
             _macroCode = new int[MacroCodeSize];
         }
 
+        /// <summary>
+        /// Create any syncs from WaitForIdle command that are currently pending.
+        /// </summary>
+        public void CreatePendingSyncs()
+        {
+            if (_createSyncPending)
+            {
+                _createSyncPending = false;
+                _context.CreateHostSyncIfNeeded(false);
+            }
+        }
+
         /// <summary>
         /// Reads data from the class registers.
         /// </summary>
@@ -158,7 +173,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.GPFifo
             _parent.PerformDeferredDraws();
             _context.Renderer.Pipeline.Barrier();
 
-            _context.CreateHostSyncIfNeeded(false);
+            _createSyncPending = true;
         }
 
         /// <summary>

Ryujinx.Graphics.Gpu/Engine/GPFifo/GPFifoProcessor.cs

@@ -65,7 +65,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.GPFifo
             _channel = channel;
 
             _fifoClass = new GPFifoClass(context, this);
-            _3dClass = new ThreedClass(context, channel);
+            _3dClass = new ThreedClass(context, channel, _fifoClass);
             _computeClass = new ComputeClass(context, channel, _3dClass);
             _i2mClass = new InlineToMemoryClass(context, channel);
             _2dClass = new TwodClass(channel);

Ryujinx.Graphics.Gpu/Engine/MME/MacroHLE.cs

@@ -12,6 +12,10 @@ namespace Ryujinx.Graphics.Gpu.Engine.MME
     /// </summary>
     class MacroHLE : IMacroEE
     {
+        private const int ColorLayerCountOffset = 0x818;
+        private const int ColorStructSize = 0x40;
+        private const int ZetaLayerCountOffset = 0x1230;
+
         private readonly GPFifoProcessor _processor;
         private readonly MacroHLEFunctionName _functionName;
 
@@ -45,6 +49,12 @@ namespace Ryujinx.Graphics.Gpu.Engine.MME
         {
             switch (_functionName)
             {
+                case MacroHLEFunctionName.ClearColor:
+                    ClearColor(state, arg0);
+                    break;
+                case MacroHLEFunctionName.ClearDepthStencil:
+                    ClearDepthStencil(state, arg0);
+                    break;
                 case MacroHLEFunctionName.MultiDrawElementsIndirectCount:
                     MultiDrawElementsIndirectCount(state, arg0);
                     break;
@@ -53,6 +63,31 @@ namespace Ryujinx.Graphics.Gpu.Engine.MME
             }
         }
 
+        /// <summary>
+        /// Clears one bound color target.
+        /// </summary>
+        /// <param name="state">GPU state at the time of the call</param>
+        /// <param name="arg0">First argument of the call</param>
+        private void ClearColor(IDeviceState state, int arg0)
+        {
+            int index = (arg0 >> 6) & 0xf;
+            int layerCount = state.Read(ColorLayerCountOffset + index * ColorStructSize);
+
+            _processor.ThreedClass.Clear(arg0, layerCount);
+        }
+
+        /// <summary>
+        /// Clears the current depth-stencil target.
+        /// </summary>
+        /// <param name="state">GPU state at the time of the call</param>
+        /// <param name="arg0">First argument of the call</param>
+        private void ClearDepthStencil(IDeviceState state, int arg0)
+        {
+            int layerCount = state.Read(ZetaLayerCountOffset);
+
+            _processor.ThreedClass.Clear(arg0, layerCount);
+        }
+
         /// <summary>
         /// Performs a indirect multi-draw, with parameters from a GPU buffer.
         /// </summary>

Ryujinx.Graphics.Gpu/Engine/MME/MacroHLEFunctionName.cs

@@ -6,6 +6,8 @@
     enum MacroHLEFunctionName
     {
         None,
+        ClearColor,
+        ClearDepthStencil,
         MultiDrawElementsIndirectCount
     }
 }

Ryujinx.Graphics.Gpu/Engine/MME/MacroHLETable.cs

@@ -46,12 +46,19 @@ namespace Ryujinx.Graphics.Gpu.Engine.MME
 
         private static readonly TableEntry[] Table = new TableEntry[]
         {
+            new TableEntry(MacroHLEFunctionName.ClearColor, new Hash128(0xA9FB28D1DC43645A, 0xB177E5D2EAE67FB0), 0x28),
+            new TableEntry(MacroHLEFunctionName.ClearDepthStencil, new Hash128(0x1B96CB77D4879F4F, 0x8557032FE0C965FB), 0x24),
             new TableEntry(MacroHLEFunctionName.MultiDrawElementsIndirectCount, new Hash128(0x890AF57ED3FB1C37, 0x35D0C95C61F5386F), 0x19C)
         };
 
         private static bool IsMacroHLESupported(Capabilities caps, MacroHLEFunctionName name)
         {
-            if (name == MacroHLEFunctionName.MultiDrawElementsIndirectCount)
+            if (name == MacroHLEFunctionName.ClearColor ||
+                name == MacroHLEFunctionName.ClearDepthStencil)
+            {
+                return true;
+            }
+            else if (name == MacroHLEFunctionName.MultiDrawElementsIndirectCount)
             {
                 return caps.SupportsIndirectParameters;
             }

Ryujinx.Graphics.Gpu/Engine/Threed/DrawManager.cs

@@ -487,11 +487,23 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
 
         /// <summary>
         /// Clears the current color and depth-stencil buffers.
-        /// Which buffers should be cleared is also specified on the argument.
+        /// Which buffers should be cleared can also be specified with the argument.
         /// </summary>
         /// <param name="engine">3D engine where this method is being called</param>
         /// <param name="argument">Method call argument</param>
         public void Clear(ThreedClass engine, int argument)
+        {
+            Clear(engine, argument, 1);
+        }
+
+        /// <summary>
+        /// Clears the current color and depth-stencil buffers.
+        /// Which buffers should be cleared can also specified with the arguments.
+        /// </summary>
+        /// <param name="engine">3D engine where this method is being called</param>
+        /// <param name="argument">Method call argument</param>
+        /// <param name="layerCount">For array and 3D textures, indicates how many layers should be cleared</param>
+        public void Clear(ThreedClass engine, int argument, int layerCount)
         {
             ConditionalRenderEnabled renderEnable = ConditionalRendering.GetRenderEnable(
                 _context,
@@ -507,7 +519,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
             int index = (argument >> 6) & 0xf;
             int layer = (argument >> 10) & 0x3ff;
 
-            engine.UpdateRenderTargetState(useControl: false, layered: layer != 0, singleUse: index);
+            engine.UpdateRenderTargetState(useControl: false, layered: layer != 0 || layerCount > 1, singleUse: index);
 
             // 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
@@ -559,7 +571,12 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
                     scissorH = (int)MathF.Ceiling(scissorH * scale);
                 }
 
-                _context.Renderer.Pipeline.SetScissor(0, true, scissorX, scissorY, scissorW, scissorH);
+                Span<Rectangle<int>> scissors = stackalloc Rectangle<int>[]
+                {
+                    new Rectangle<int>(scissorX, scissorY, scissorW, scissorH)
+                };
+
+                _context.Renderer.Pipeline.SetScissors(scissors);
             }
 
             if (clipMismatch)
@@ -573,7 +590,6 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
 
             bool clearDepth = (argument & 1) != 0;
             bool clearStencil = (argument & 2) != 0;
-
             uint componentMask = (uint)((argument >> 2) & 0xf);
 
             if (componentMask != 0)
@@ -582,7 +598,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
 
                 ColorF color = new ColorF(clearColor.Red, clearColor.Green, clearColor.Blue, clearColor.Alpha);
 
-                _context.Renderer.Pipeline.ClearRenderTargetColor(index, layer, componentMask, color);
+                _context.Renderer.Pipeline.ClearRenderTargetColor(index, layer, layerCount, componentMask, color);
             }
 
             if (clearDepth || clearStencil)
@@ -604,6 +620,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
 
                 _context.Renderer.Pipeline.ClearRenderTargetDepthStencil(
                     layer,
+                    layerCount,
                     depthValue,
                     clearDepth,
                     stencilValue,

Ryujinx.Graphics.Gpu/Engine/Threed/StateUpdater.cs

@@ -1,4 +1,5 @@
 using Ryujinx.Common.Logging;
+using Ryujinx.Common.Memory;
 using Ryujinx.Graphics.GAL;
 using Ryujinx.Graphics.Gpu.Engine.Types;
 using Ryujinx.Graphics.Gpu.Image;
@@ -15,11 +16,11 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
     /// </summary>
     class StateUpdater
     {
-        public const int ShaderStateIndex = 0;
-        public const int RasterizerStateIndex = 1;
-        public const int ScissorStateIndex = 2;
-        public const int VertexBufferStateIndex = 3;
-        public const int PrimitiveRestartStateIndex = 4;
+        public const int ShaderStateIndex = 16;
+        public const int RasterizerStateIndex = 15;
+        public const int ScissorStateIndex = 18;
+        public const int VertexBufferStateIndex = 0;
+        public const int PrimitiveRestartStateIndex = 12;
 
         private readonly GpuContext _context;
         private readonly GpuChannel _channel;
@@ -31,6 +32,8 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
         private readonly ShaderProgramInfo[] _currentProgramInfo;
         private ShaderSpecializationState _shaderSpecState;
 
+        private ProgramPipelineState _pipeline;
+
         private bool _vtgWritesRtLayer;
         private byte _vsClipDistancesWritten;
 
@@ -54,7 +57,8 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
             _drawState = drawState;
             _currentProgramInfo = new ShaderProgramInfo[Constants.ShaderStages];
 
-            // ShaderState must be the first, as other state updates depends on information from the currently bound shader.
+            // ShaderState must be updated after other state updates, as pipeline state is sent to the backend when compiling new shaders.
+            // Render target state must appear after shader state as it depends on information from the currently bound shader.
             // Rasterizer and scissor states are checked by render target clear, their indexes
             // must be updated on the constants "RasterizerStateIndex" and "ScissorStateIndex" if modified.
             // The vertex buffer state may be forced dirty when a indexed draw starts, the "VertexBufferStateIndex"
@@ -62,53 +66,39 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
             // The order of the other state updates doesn't matter.
             _updateTracker = new StateUpdateTracker<ThreedClassState>(new[]
             {
-                new StateUpdateCallbackEntry(UpdateShaderState,
-                    nameof(ThreedClassState.ShaderBaseAddress),
-                    nameof(ThreedClassState.ShaderState)),
-
-                new StateUpdateCallbackEntry(UpdateRasterizerState, nameof(ThreedClassState.RasterizeEnable)),
-
-                new StateUpdateCallbackEntry(UpdateScissorState,
-                    nameof(ThreedClassState.ScissorState),
-                    nameof(ThreedClassState.ScreenScissorState)),
-
                 new StateUpdateCallbackEntry(UpdateVertexBufferState,
                     nameof(ThreedClassState.VertexBufferDrawState),
                     nameof(ThreedClassState.VertexBufferInstanced),
                     nameof(ThreedClassState.VertexBufferState),
                     nameof(ThreedClassState.VertexBufferEndAddress)),
 
-                new StateUpdateCallbackEntry(UpdatePrimitiveRestartState,
-                    nameof(ThreedClassState.PrimitiveRestartDrawArrays),
-                    nameof(ThreedClassState.PrimitiveRestartState)),
+                new StateUpdateCallbackEntry(UpdateVertexAttribState, nameof(ThreedClassState.VertexAttribState)),
 
-                new StateUpdateCallbackEntry(UpdateTessellationState,
-                    nameof(ThreedClassState.TessOuterLevel),
-                    nameof(ThreedClassState.TessInnerLevel),
-                    nameof(ThreedClassState.PatchVertices)),
+                new StateUpdateCallbackEntry(UpdateBlendState,
+                    nameof(ThreedClassState.BlendIndependent),
+                    nameof(ThreedClassState.BlendConstant),
+                    nameof(ThreedClassState.BlendStateCommon),
+                    nameof(ThreedClassState.BlendEnableCommon),
+                    nameof(ThreedClassState.BlendEnable),
+                    nameof(ThreedClassState.BlendState)),
 
-                new StateUpdateCallbackEntry(UpdateTfBufferState, nameof(ThreedClassState.TfBufferState)),
-                new StateUpdateCallbackEntry(UpdateUserClipState, nameof(ThreedClassState.ClipDistanceEnable)),
+                new StateUpdateCallbackEntry(UpdateFaceState, nameof(ThreedClassState.FaceState)),
 
-                new StateUpdateCallbackEntry(UpdateRenderTargetState,
-                    nameof(ThreedClassState.RtColorState),
-                    nameof(ThreedClassState.RtDepthStencilState),
-                    nameof(ThreedClassState.RtControl),
-                    nameof(ThreedClassState.RtDepthStencilSize),
-                    nameof(ThreedClassState.RtDepthStencilEnable)),
-
-                new StateUpdateCallbackEntry(UpdateDepthClampState, nameof(ThreedClassState.ViewVolumeClipControl)),
-
-                new StateUpdateCallbackEntry(UpdateAlphaTestState,
-                    nameof(ThreedClassState.AlphaTestEnable),
-                    nameof(ThreedClassState.AlphaTestRef),
-                    nameof(ThreedClassState.AlphaTestFunc)),
+                new StateUpdateCallbackEntry(UpdateStencilTestState,
+                    nameof(ThreedClassState.StencilBackMasks),
+                    nameof(ThreedClassState.StencilTestState),
+                    nameof(ThreedClassState.StencilBackTestState)),
 
                 new StateUpdateCallbackEntry(UpdateDepthTestState,
                     nameof(ThreedClassState.DepthTestEnable),
                     nameof(ThreedClassState.DepthWriteEnable),
                     nameof(ThreedClassState.DepthTestFunc)),
 
+                new StateUpdateCallbackEntry(UpdateTessellationState,
+                    nameof(ThreedClassState.TessOuterLevel),
+                    nameof(ThreedClassState.TessInnerLevel),
+                    nameof(ThreedClassState.PatchVertices)),
+
                 new StateUpdateCallbackEntry(UpdateViewportTransform,
                     nameof(ThreedClassState.DepthMode),
                     nameof(ThreedClassState.ViewportTransform),
@@ -116,6 +106,10 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
                     nameof(ThreedClassState.YControl),
                     nameof(ThreedClassState.ViewportTransformEnable)),
 
+                new StateUpdateCallbackEntry(UpdateLogicOpState, nameof(ThreedClassState.LogicOpState)),
+
+                new StateUpdateCallbackEntry(UpdateDepthClampState, nameof(ThreedClassState.ViewVolumeClipControl)),
+
                 new StateUpdateCallbackEntry(UpdatePolygonMode,
                     nameof(ThreedClassState.PolygonModeFront),
                     nameof(ThreedClassState.PolygonModeBack)),
@@ -126,21 +120,46 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
                     nameof(ThreedClassState.DepthBiasUnits),
                     nameof(ThreedClassState.DepthBiasClamp)),
 
-                new StateUpdateCallbackEntry(UpdateStencilTestState,
-                    nameof(ThreedClassState.StencilBackMasks),
-                    nameof(ThreedClassState.StencilTestState),
-                    nameof(ThreedClassState.StencilBackTestState)),
+                new StateUpdateCallbackEntry(UpdatePrimitiveRestartState, nameof(ThreedClassState.PrimitiveRestartState)),
+
+                new StateUpdateCallbackEntry(UpdateLineState,
+                    nameof(ThreedClassState.LineWidthSmooth),
+                    nameof(ThreedClassState.LineSmoothEnable)),
+
+                new StateUpdateCallbackEntry(UpdateRtColorMask,
+                    nameof(ThreedClassState.RtColorMaskShared),
+                    nameof(ThreedClassState.RtColorMask)),
+
+                new StateUpdateCallbackEntry(UpdateRasterizerState, nameof(ThreedClassState.RasterizeEnable)),
+
+                new StateUpdateCallbackEntry(UpdateShaderState,
+                    nameof(ThreedClassState.ShaderBaseAddress),
+                    nameof(ThreedClassState.ShaderState)),
+
+                new StateUpdateCallbackEntry(UpdateRenderTargetState,
+                    nameof(ThreedClassState.RtColorState),
+                    nameof(ThreedClassState.RtDepthStencilState),
+                    nameof(ThreedClassState.RtControl),
+                    nameof(ThreedClassState.RtDepthStencilSize),
+                    nameof(ThreedClassState.RtDepthStencilEnable)),
+
+                new StateUpdateCallbackEntry(UpdateScissorState,
+                    nameof(ThreedClassState.ScissorState),
+                    nameof(ThreedClassState.ScreenScissorState)),
+
+                new StateUpdateCallbackEntry(UpdateTfBufferState, nameof(ThreedClassState.TfBufferState)),
+                new StateUpdateCallbackEntry(UpdateUserClipState, nameof(ThreedClassState.ClipDistanceEnable)),
+
+                new StateUpdateCallbackEntry(UpdateAlphaTestState,
+                    nameof(ThreedClassState.AlphaTestEnable),
+                    nameof(ThreedClassState.AlphaTestRef),
+                    nameof(ThreedClassState.AlphaTestFunc)),
 
                 new StateUpdateCallbackEntry(UpdateSamplerPoolState,
                     nameof(ThreedClassState.SamplerPoolState),
                     nameof(ThreedClassState.SamplerIndex)),
 
                 new StateUpdateCallbackEntry(UpdateTexturePoolState, nameof(ThreedClassState.TexturePoolState)),
-                new StateUpdateCallbackEntry(UpdateVertexAttribState, nameof(ThreedClassState.VertexAttribState)),
-
-                new StateUpdateCallbackEntry(UpdateLineState,
-                    nameof(ThreedClassState.LineWidthSmooth),
-                    nameof(ThreedClassState.LineSmoothEnable)),
 
                 new StateUpdateCallbackEntry(UpdatePointState,
                     nameof(ThreedClassState.PointSize),
@@ -152,22 +171,6 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
                     nameof(ThreedClassState.IndexBufferState),
                     nameof(ThreedClassState.IndexBufferCount)),
 
-                new StateUpdateCallbackEntry(UpdateFaceState, nameof(ThreedClassState.FaceState)),
-
-                new StateUpdateCallbackEntry(UpdateRtColorMask,
-                    nameof(ThreedClassState.RtColorMaskShared),
-                    nameof(ThreedClassState.RtColorMask)),
-
-                new StateUpdateCallbackEntry(UpdateBlendState,
-                    nameof(ThreedClassState.BlendIndependent),
-                    nameof(ThreedClassState.BlendConstant),
-                    nameof(ThreedClassState.BlendStateCommon),
-                    nameof(ThreedClassState.BlendEnableCommon),
-                    nameof(ThreedClassState.BlendEnable),
-                    nameof(ThreedClassState.BlendState)),
-
-                new StateUpdateCallbackEntry(UpdateLogicOpState, nameof(ThreedClassState.LogicOpState)),
-
                 new StateUpdateCallbackEntry(UpdateMultisampleState,
                     nameof(ThreedClassState.AlphaToCoverageDitherEnable),
                     nameof(ThreedClassState.MultisampleControl))
@@ -324,6 +327,8 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
         /// </summary>
         private void UpdateTessellationState()
         {
+            _pipeline.PatchControlPoints = (uint)_state.State.PatchVertices;
+
             _context.Renderer.Pipeline.SetPatchParameters(
                 _state.State.PatchVertices,
                 _state.State.TessOuterLevel.ToSpan(),
@@ -356,6 +361,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
         private void UpdateRasterizerState()
         {
             bool enable = _state.State.RasterizeEnable;
+            _pipeline.RasterizerDiscard = !enable;
             _context.Renderer.Pipeline.SetRasterizerDiscard(!enable);
         }
 
@@ -497,11 +503,21 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
         /// </summary>
         public void UpdateScissorState()
         {
+            const int MinX = 0;
+            const int MinY = 0;
+            const int MaxW = 0xffff;
+            const int MaxH = 0xffff;
+
+            Span<Rectangle<int>> regions = stackalloc Rectangle<int>[Constants.TotalViewports];
+
             for (int index = 0; index < Constants.TotalViewports; index++)
             {
                 ScissorState scissor = _state.State.ScissorState[index];
 
-                bool enable = scissor.Enable && (scissor.X1 != 0 || scissor.Y1 != 0 || scissor.X2 != 0xffff || scissor.Y2 != 0xffff);
+                bool enable = scissor.Enable && (scissor.X1 != MinX ||
+                                                 scissor.Y1 != MinY ||
+                                                 scissor.X2 != MaxW ||
+                                                 scissor.Y2 != MaxH);
 
                 if (enable)
                 {
@@ -531,13 +547,15 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
                         height = (int)MathF.Ceiling(height * scale);
                     }
 
-                    _context.Renderer.Pipeline.SetScissor(index, true, x, y, width, height);
+                    regions[index] = new Rectangle<int>(x, y, width, height);
                 }
                 else
                 {
-                    _context.Renderer.Pipeline.SetScissor(index, false, 0, 0, 0, 0);
+                    regions[index] = new Rectangle<int>(MinX, MinY, MaxW, MaxH);
                 }
             }
+
+            _context.Renderer.Pipeline.SetScissors(regions);
         }
 
         /// <summary>
@@ -547,7 +565,10 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
         private void UpdateDepthClampState()
         {
             ViewVolumeClipControl clip = _state.State.ViewVolumeClipControl;
-            _context.Renderer.Pipeline.SetDepthClamp((clip & ViewVolumeClipControl.DepthClampDisabled) == 0);
+            bool clamp = (clip & ViewVolumeClipControl.DepthClampDisabled) == 0;
+
+            _pipeline.DepthClampEnable = clamp;
+            _context.Renderer.Pipeline.SetDepthClamp(clamp);
         }
 
         /// <summary>
@@ -566,10 +587,13 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
         /// </summary>
         private void UpdateDepthTestState()
         {
-            _context.Renderer.Pipeline.SetDepthTest(new DepthTestDescriptor(
+            DepthTestDescriptor descriptor = new DepthTestDescriptor(
                 _state.State.DepthTestEnable,
                 _state.State.DepthWriteEnable,
-                _state.State.DepthTestFunc));
+                _state.State.DepthTestFunc);
+
+            _pipeline.DepthTest = descriptor;
+            _context.Renderer.Pipeline.SetDepthTest(descriptor);
         }
 
         /// <summary>
@@ -596,7 +620,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
                     ref var scissor = ref _state.State.ScreenScissorState;
 
                     float rScale = _channel.TextureManager.RenderTargetScale;
-                    var scissorRect = new RectangleF(0, 0, (scissor.X + scissor.Width) * rScale, (scissor.Y + scissor.Height) * rScale);
+                    var scissorRect = new Rectangle<float>(0, 0, (scissor.X + scissor.Width) * rScale, (scissor.Y + scissor.Height) * rScale);
 
                     viewports[index] = new Viewport(scissorRect, ViewportSwizzle.PositiveX, ViewportSwizzle.PositiveY, ViewportSwizzle.PositiveZ, ViewportSwizzle.PositiveW, 0, 1);
                     continue;
@@ -633,7 +657,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
                     height *= scale;
                 }
 
-                RectangleF region = new RectangleF(x, y, width, height);
+                Rectangle<float> region = new Rectangle<float>(x, y, width, height);
 
                 ViewportSwizzle swizzleX = transform.UnpackSwizzleX();
                 ViewportSwizzle swizzleY = transform.UnpackSwizzleY();
@@ -653,7 +677,8 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
                 viewports[index] = new Viewport(region, swizzleX, swizzleY, swizzleZ, swizzleW, depthNear, depthFar);
             }
 
-            _context.Renderer.Pipeline.SetViewports(0, viewports, disableTransform);
+            _context.Renderer.Pipeline.SetDepthMode(GetDepthMode());
+            _context.Renderer.Pipeline.SetViewports(viewports, disableTransform);
         }
 
         /// <summary>
@@ -661,37 +686,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
         /// </summary>
         private void UpdateDepthMode()
         {
-            ref var transform = ref _state.State.ViewportTransform[0];
-            ref var extents = ref _state.State.ViewportExtents[0];
-
-            DepthMode depthMode;
-
-            if (!float.IsInfinity(extents.DepthNear) &&
-                !float.IsInfinity(extents.DepthFar) &&
-                (extents.DepthFar - extents.DepthNear) != 0)
-            {
-                // Try to guess the depth mode being used on the high level API
-                // based on current transform.
-                // It is setup like so by said APIs:
-                // If depth mode is ZeroToOne:
-                //  TranslateZ = Near
-                //  ScaleZ = Far - Near
-                // If depth mode is MinusOneToOne:
-                //  TranslateZ = (Near + Far) / 2
-                //  ScaleZ = (Far - Near) / 2
-                // DepthNear/Far are sorted such as that Near is always less than Far.
-                depthMode = extents.DepthNear != transform.TranslateZ &&
-                            extents.DepthFar  != transform.TranslateZ
-                    ? DepthMode.MinusOneToOne
-                    : DepthMode.ZeroToOne;
-            }
-            else
-            {
-                // If we can't guess from the viewport transform, then just use the depth mode register.
-                depthMode = (DepthMode)(_state.State.DepthMode & 1);
-            }
-
-            _context.Renderer.Pipeline.SetDepthMode(depthMode);
+            _context.Renderer.Pipeline.SetDepthMode(GetDepthMode());
         }
 
         /// <summary>
@@ -719,6 +714,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
             enables |= (depthBias.LineEnable ? PolygonModeMask.Line : 0);
             enables |= (depthBias.FillEnable ? PolygonModeMask.Fill : 0);
 
+            _pipeline.BiasEnable = enables;
             _context.Renderer.Pipeline.SetDepthBias(enables, factor, units / 2f, clamp);
         }
 
@@ -760,7 +756,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
                 backMask = test.FrontMask;
             }
 
-            _context.Renderer.Pipeline.SetStencilTest(new StencilTestDescriptor(
+            StencilTestDescriptor descriptor = new StencilTestDescriptor(
                 test.Enable,
                 test.FrontFunc,
                 test.FrontSFail,
@@ -775,7 +771,10 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
                 backDpFail,
                 backFuncRef,
                 backFuncMask,
-                backMask));
+                backMask);
+
+            _pipeline.StencilTest = descriptor;
+            _context.Renderer.Pipeline.SetStencilTest(descriptor);
         }
 
         /// <summary>
@@ -844,6 +843,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
                     format);
             }
 
+            _pipeline.SetVertexAttribs(vertexAttribs);
             _context.Renderer.Pipeline.SetVertexAttribs(vertexAttribs);
         }
 
@@ -855,6 +855,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
             float width = _state.State.LineWidthSmooth;
             bool smooth = _state.State.LineSmoothEnable;
 
+            _pipeline.LineWidth = width;
             _context.Renderer.Pipeline.SetLineParameters(width, smooth);
         }
 
@@ -881,6 +882,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
             PrimitiveRestartState primitiveRestart = _state.State.PrimitiveRestartState;
             bool enable = primitiveRestart.Enable && (_drawState.DrawIndexed || _state.State.PrimitiveRestartDrawArrays);
 
+            _pipeline.PrimitiveRestartEnable = enable;
             _context.Renderer.Pipeline.SetPrimitiveRestart(enable, primitiveRestart.Index);
         }
 
@@ -927,6 +929,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
 
                 if (!vertexBuffer.UnpackEnable())
                 {
+                    _pipeline.VertexBuffers[index] = new BufferPipelineDescriptor(false, 0, 0);
                     _channel.BufferManager.SetVertexBuffer(index, 0, 0, 0, 0);
 
                     continue;
@@ -944,6 +947,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
 
                 _drawState.IsAnyVbInstanced |= divisor != 0;
 
+                ulong vbSize = endAddress.Pack() - address + 1;
                 ulong size;
 
                 if (_drawState.IbStreamer.HasInlineIndexData || _drawState.DrawIndexed || stride == 0 || instanced)
@@ -951,7 +955,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
                     // This size may be (much) larger than the real vertex buffer size.
                     // Avoid calculating it this way, unless we don't have any other option.
 
-                    size = endAddress.Pack() - address + 1;
+                    size = vbSize;
 
                     if (stride > 0 && indexTypeSmall && _drawState.DrawIndexed && !instanced)
                     {
@@ -975,9 +979,10 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
 
                     var drawState = _state.State.VertexBufferDrawState;
 
-                    size = (ulong)((firstInstance + drawState.First + drawState.Count) * stride);
+                    size = Math.Min(vbSize, (ulong)((firstInstance + drawState.First + drawState.Count) * stride));
                 }
 
+                _pipeline.VertexBuffers[index] = new BufferPipelineDescriptor(_channel.MemoryManager.IsMapped(address), stride, divisor);
                 _channel.BufferManager.SetVertexBuffer(index, address, size, stride, divisor);
             }
         }
@@ -990,6 +995,8 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
             var yControl = _state.State.YControl;
             var face = _state.State.FaceState;
 
+            _pipeline.CullEnable = face.CullEnable;
+            _pipeline.CullMode = face.CullFace;
             _context.Renderer.Pipeline.SetFaceCulling(face.CullEnable, face.CullFace);
 
             UpdateFrontFace(yControl, face.FrontFace);
@@ -1009,6 +1016,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
                 frontFace = frontFace == FrontFace.CounterClockwise ? FrontFace.Clockwise : FrontFace.CounterClockwise;
             }
 
+            _pipeline.FrontFace = frontFace;
             _context.Renderer.Pipeline.SetFrontFace(frontFace);
         }
 
@@ -1034,6 +1042,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
                 componentMask |= (colorMask.UnpackAlpha() ? 8u : 0u);
 
                 componentMasks[index] = componentMask;
+                _pipeline.ColorWriteMask[index] = componentMask;
             }
 
             _context.Renderer.Pipeline.SetRenderTargetColorMasks(componentMasks);
@@ -1082,6 +1091,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
                         blend.AlphaDstFactor);
                 }
 
+                _pipeline.BlendDescriptors[index] = descriptor;
                 _context.Renderer.Pipeline.SetBlendState(index, descriptor);
             }
         }
@@ -1093,6 +1103,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
         {
             LogicalOpState logicOpState = _state.State.LogicOpState;
 
+            _pipeline.SetLogicOpState(logicOpState.Enable, logicOpState.LogicalOp);
             _context.Renderer.Pipeline.SetLogicOpState(logicOpState.Enable, logicOpState.LogicalOp);
         }
 
@@ -1138,7 +1149,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
             GpuChannelPoolState poolState = GetPoolState();
             GpuChannelGraphicsState graphicsState = GetGraphicsState();
 
-            CachedShaderProgram gs = shaderCache.GetGraphicsShader(ref _state.State, _channel, poolState, graphicsState, addresses);
+            CachedShaderProgram gs = shaderCache.GetGraphicsShader(ref _state.State, ref _pipeline, _channel, poolState, graphicsState, addresses);
 
             _shaderSpecState = gs.SpecializationState;
 
@@ -1245,13 +1256,69 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
         /// <returns>Current GPU channel state</returns>
         private GpuChannelGraphicsState GetGraphicsState()
         {
+            ref var vertexAttribState = ref _state.State.VertexAttribState;
+
+            Array32<AttributeType> attributeTypes = new Array32<AttributeType>();
+
+            for (int location = 0; location < attributeTypes.Length; location++)
+            {
+                attributeTypes[location] = vertexAttribState[location].UnpackType() switch
+                {
+                    3 => AttributeType.Sint,
+                    4 => AttributeType.Uint,
+                    _ => AttributeType.Float
+                };
+            }
+
             return new GpuChannelGraphicsState(
                 _state.State.EarlyZForce,
                 _drawState.Topology,
                 _state.State.TessMode,
-                _state.State.ViewportTransformEnable == 0,
                 (_state.State.MultisampleControl & 1) != 0,
-                _state.State.AlphaToCoverageDitherEnable);
+                _state.State.AlphaToCoverageDitherEnable,
+                _state.State.ViewportTransformEnable == 0,
+                GetDepthMode() == DepthMode.MinusOneToOne,
+                _state.State.VertexProgramPointSize,
+                _state.State.PointSize,
+                _state.State.AlphaTestEnable,
+                _state.State.AlphaTestFunc,
+                _state.State.AlphaTestRef,
+                ref attributeTypes);
+        }
+
+        private DepthMode GetDepthMode()
+        {
+            ref var transform = ref _state.State.ViewportTransform[0];
+            ref var extents = ref _state.State.ViewportExtents[0];
+
+            DepthMode depthMode;
+
+            if (!float.IsInfinity(extents.DepthNear) &&
+                !float.IsInfinity(extents.DepthFar) &&
+                (extents.DepthFar - extents.DepthNear) != 0)
+            {
+                // Try to guess the depth mode being used on the high level API
+                // based on current transform.
+                // It is setup like so by said APIs:
+                // If depth mode is ZeroToOne:
+                //  TranslateZ = Near
+                //  ScaleZ = Far - Near
+                // If depth mode is MinusOneToOne:
+                //  TranslateZ = (Near + Far) / 2
+                //  ScaleZ = (Far - Near) / 2
+                // DepthNear/Far are sorted such as that Near is always less than Far.
+                depthMode = extents.DepthNear != transform.TranslateZ &&
+                            extents.DepthFar  != transform.TranslateZ
+                    ? DepthMode.MinusOneToOne
+                    : DepthMode.ZeroToOne;
+            }
+            else
+            {
+                // If we can't guess from the viewport transform, then just use the depth mode register.
+                depthMode = (DepthMode)(_state.State.DepthMode & 1);
+            }
+
+            return depthMode;
         }
 
         /// <summary>

Ryujinx.Graphics.Gpu/Engine/Threed/ThreedClass.cs

@@ -1,5 +1,6 @@
 using Ryujinx.Graphics.Device;
 using Ryujinx.Graphics.GAL;
+using Ryujinx.Graphics.Gpu.Engine.GPFifo;
 using Ryujinx.Graphics.Gpu.Engine.InlineToMemory;
 using System;
 using System.Collections.Generic;
@@ -13,6 +14,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
     class ThreedClass : IDeviceState
     {
         private readonly GpuContext _context;
+        private readonly GPFifoClass _fifoClass;
         private readonly DeviceStateWithShadow<ThreedClassState> _state;
 
         private readonly InlineToMemoryClass _i2mClass;
@@ -26,9 +28,10 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
         /// </summary>
         /// <param name="context">GPU context</param>
         /// <param name="channel">GPU channel</param>
-        public ThreedClass(GpuContext context, GpuChannel channel)
+        public ThreedClass(GpuContext context, GpuChannel channel, GPFifoClass fifoClass)
         {
             _context = context;
+            _fifoClass = fifoClass;
             _state = new DeviceStateWithShadow<ThreedClassState>(new Dictionary<string, RwCallback>
             {
                 { nameof(ThreedClassState.LaunchDma), new RwCallback(LaunchDma, null) },
@@ -114,6 +117,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
         /// </summary>
         public void UpdateState()
         {
+            _fifoClass.CreatePendingSyncs();
             _cbUpdater.FlushUboDirty();
             _stateUpdater.Update();
         }
@@ -172,6 +176,14 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
             _stateUpdater.ForceShaderUpdate();
         }
 
+        /// <summary>
+        /// Create any syncs from WaitForIdle command that are currently pending.
+        /// </summary>
+        public void CreatePendingSyncs()
+        {
+            _fifoClass.CreatePendingSyncs();
+        }
+
         /// <summary>
         /// Flushes any queued UBO updates.
         /// </summary>
@@ -485,6 +497,17 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
             return 0;
         }
 
+        /// <summary>
+        /// Clears the current color and depth-stencil buffers.
+        /// Which buffers should be cleared can also specified with the arguments.
+        /// </summary>
+        /// <param name="argument">Method call argument</param>
+        /// <param name="layerCount">For array and 3D textures, indicates how many layers should be cleared</param>
+        public void Clear(int argument, int layerCount)
+        {
+            _drawManager.Clear(this, argument, layerCount);
+        }
+
         /// <summary>
         /// Performs a indirect multi-draw, with parameters from a GPU buffer.
         /// </summary>