Implement CreateLibraryAppletEx in ILibraryAppletCreator

- Fixes Ultracam 20+ (beta) support

src/ARMeilleure/Translation/PTC/Ptc.cs

@@ -31,14 +31,11 @@ namespace ARMeilleure.Translation.PTC
         private const string OuterHeaderMagicString = "PTCohd\0\0";
         private const string InnerHeaderMagicString = "PTCihd\0\0";
 
-        private const uint InternalVersion = 7010; //! To be incremented manually for each change to the ARMeilleure project.
+        private const uint InternalVersion = 7031; //! To be incremented manually for each change to the ARMeilleure project.
 
         private const string ActualDir = "0";
         private const string BackupDir = "1";
 
-        private const string TitleIdTextDefault = "0000000000000000";
-        private const string DisplayVersionDefault = "0";
-
         public static readonly Symbol PageTableSymbol = new(SymbolType.Special, 1);
         public static readonly Symbol CountTableSymbol = new(SymbolType.Special, 2);
         public static readonly Symbol DispatchStubSymbol = new(SymbolType.Special, 3);
@@ -64,8 +61,7 @@ namespace ARMeilleure.Translation.PTC
 
         private bool _disposed;
 
-        public string TitleIdText { get; private set; }
+        public PtcCacheInfo CacheInfo { get; private set; }
-        public string DisplayVersion { get; private set; }
 
         private MemoryManagerType _memoryMode;
 
@@ -92,8 +88,7 @@ namespace ARMeilleure.Translation.PTC
 
             _disposed = false;
 
-            TitleIdText = TitleIdTextDefault;
+            CacheInfo = new PtcCacheInfo(0, null, null, 0, null, "Unknown", "default");
-            DisplayVersion = DisplayVersionDefault;
 
             CachePathActual = string.Empty;
             CachePathBackup = string.Empty;
@@ -101,20 +96,24 @@ namespace ARMeilleure.Translation.PTC
             Disable();
         }
 
-        public void Initialize(string titleIdText, string displayVersion, bool enabled, MemoryManagerType memoryMode, string cacheSelector)
+        public void Initialize(PtcCacheInfo cacheInfo, bool enabled, MemoryManagerType memoryMode)
         {
             Wait();
 
             Profiler.Wait();
             Profiler.ClearEntries();
 
-            Logger.Info?.Print(LogClass.Ptc, $"Initializing Profiled Persistent Translation Cache v{InternalVersion}\n\t\t (title: {titleIdText}, version: '{displayVersion}', selector: '{cacheSelector}', enabled: {enabled}).");
+            CacheInfo = cacheInfo;
 
-            if (!enabled || string.IsNullOrEmpty(titleIdText) || titleIdText == TitleIdTextDefault)
+            Logger.Info?.Print(
+                LogClass.Ptc,
+                $"Initializing Profiled Persistent Translation Cache v{InternalVersion}\n\t\t " +
+                $"(pid: {cacheInfo.ProcessId}, title: {cacheInfo.TitleIdText}, application: {cacheInfo.ApplicationIdText}, " +
+                $"programIndex: {cacheInfo.ProgramIndex}, version: '{cacheInfo.DisplayVersion}', kind: {cacheInfo.ProcessKind}, " +
+                $"selector: '{cacheInfo.CacheSelector}', key: '{cacheInfo.CacheKey}', enabled: {enabled}).");
+
+            if (!enabled || cacheInfo.TitleIdText == PtcCacheInfo.TitleIdTextDefault)
             {
-                TitleIdText = TitleIdTextDefault;
-                DisplayVersion = DisplayVersionDefault;
-
                 CachePathActual = string.Empty;
                 CachePathBackup = string.Empty;
 
@@ -123,12 +122,10 @@ namespace ARMeilleure.Translation.PTC
                 return;
             }
 
-            TitleIdText = titleIdText;
-            DisplayVersion = !string.IsNullOrEmpty(displayVersion) ? displayVersion : DisplayVersionDefault;
             _memoryMode = memoryMode;
 
-            string workPathActual = Path.Combine(AppDataManager.GamesDirPath, TitleIdText, "cache", "cpu", ActualDir);
+            string workPathActual = Path.Combine(AppDataManager.GamesDirPath, CacheInfo.TitleIdText, "cache", "cpu", ActualDir);
-            string workPathBackup = Path.Combine(AppDataManager.GamesDirPath, TitleIdText, "cache", "cpu", BackupDir);
+            string workPathBackup = Path.Combine(AppDataManager.GamesDirPath, CacheInfo.TitleIdText, "cache", "cpu", BackupDir);
 
             if (!Directory.Exists(workPathActual))
             {
@@ -140,8 +137,14 @@ namespace ARMeilleure.Translation.PTC
                 Directory.CreateDirectory(workPathBackup);
             }
 
-            CachePathActual = Path.Combine(workPathActual, DisplayVersion) + "-" + cacheSelector;
+            CachePathActual = Path.Combine(workPathActual, CacheInfo.DisplayVersion) + "-" + CacheInfo.CacheSelector;
-            CachePathBackup = Path.Combine(workPathBackup, DisplayVersion) + "-" + cacheSelector;
+            CachePathBackup = Path.Combine(workPathBackup, CacheInfo.DisplayVersion) + "-" + CacheInfo.CacheSelector;
+
+            Logger.Info?.Print(
+                LogClass.Ptc,
+                $"PPTC cache owner selected (pid: {CacheInfo.ProcessId}, title: {CacheInfo.TitleIdText}, application: {CacheInfo.ApplicationIdText}, " +
+                $"version: '{CacheInfo.DisplayVersion}', kind: {CacheInfo.ProcessKind}, selector: '{CacheInfo.CacheSelector}', " +
+                $"key: '{CacheInfo.CacheKey}', path: '{CachePathActual}').");
 
             PreLoad();
             Profiler.PreLoad();
@@ -364,7 +367,12 @@ namespace ARMeilleure.Translation.PTC
 
             long fileSize = new FileInfo(fileName).Length;
 
-            Logger.Info?.Print(LogClass.Ptc, $"{(isBackup ? "Loaded Backup Translation Cache" : "Loaded Translation Cache")} (size: {fileSize} bytes, translated functions: {GetEntriesCount()}).");
+            Logger.Info?.Print(
+                LogClass.Ptc,
+                $"{(isBackup ? "Loaded Backup Translation Cache" : "Loaded Translation Cache")} " +
+                $"(pid: {CacheInfo.ProcessId}, title: {CacheInfo.TitleIdText}, version: '{CacheInfo.DisplayVersion}', kind: {CacheInfo.ProcessKind}, " +
+                $"selector: '{CacheInfo.CacheSelector}', key: '{CacheInfo.CacheKey}', path: '{fileName}', " +
+                $"size: {fileSize} bytes, translated functions: {GetEntriesCount()}).");
 
             return true;
         }

src/ARMeilleure/Translation/PTC/PtcCacheInfo.cs

@@ -0,0 +1,37 @@
+namespace ARMeilleure.Translation.PTC
+{
+    public readonly struct PtcCacheInfo
+    {
+        public const string TitleIdTextDefault = "0000000000000000";
+        public const string ApplicationIdTextDefault = "0000000000000000";
+        public const string DisplayVersionDefault = "0";
+
+        public ulong ProcessId { get; }
+        public string TitleIdText { get; }
+        public string ApplicationIdText { get; }
+        public byte ProgramIndex { get; }
+        public string DisplayVersion { get; }
+        public string ProcessKind { get; }
+        public string CacheSelector { get; }
+
+        public string CacheKey => $"{DisplayVersion}-{CacheSelector}";
+
+        public PtcCacheInfo(
+            ulong processId,
+            string titleIdText,
+            string applicationIdText,
+            byte programIndex,
+            string displayVersion,
+            string processKind,
+            string cacheSelector)
+        {
+            ProcessId = processId;
+            TitleIdText = !string.IsNullOrEmpty(titleIdText) ? titleIdText : TitleIdTextDefault;
+            ApplicationIdText = !string.IsNullOrEmpty(applicationIdText) ? applicationIdText : ApplicationIdTextDefault;
+            ProgramIndex = programIndex;
+            DisplayVersion = !string.IsNullOrEmpty(displayVersion) ? displayVersion : DisplayVersionDefault;
+            ProcessKind = processKind ?? string.Empty;
+            CacheSelector = string.IsNullOrEmpty(cacheSelector) ? "default" : cacheSelector;
+        }
+    }
+}

src/ARMeilleure/Translation/PTC/PtcProfiler.cs

@@ -23,7 +23,7 @@ namespace ARMeilleure.Translation.PTC
     {
         private const string OuterHeaderMagicString = "Pohd\0\0\0\0";
 
-        private const uint InternalVersion = 6698; //! Not to be incremented manually for each change to the ARMeilleure project.
+        private const uint InternalVersion = 7031; //! Not to be incremented manually for each change to the ARMeilleure project.
 
         private static readonly uint[] _migrateInternalVersions = 
         [
@@ -254,7 +254,12 @@ namespace ARMeilleure.Translation.PTC
 
             long fileSize = new FileInfo(fileName).Length;
 
-            Logger.Info?.Print(LogClass.Ptc, $"{(isBackup ? "Loaded Backup Profiling Info" : "Loaded Profiling Info")} (size: {fileSize} bytes, profiled functions: {ProfiledFuncs.Count}).");
+            Logger.Info?.Print(
+                LogClass.Ptc,
+                $"{(isBackup ? "Loaded Backup Profiling Info" : "Loaded Profiling Info")} " +
+                $"(pid: {_ptc.CacheInfo.ProcessId}, title: {_ptc.CacheInfo.TitleIdText}, version: '{_ptc.CacheInfo.DisplayVersion}', " +
+                $"kind: {_ptc.CacheInfo.ProcessKind}, selector: '{_ptc.CacheInfo.CacheSelector}', key: '{_ptc.CacheInfo.CacheKey}', " +
+                $"path: '{fileName}', size: {fileSize} bytes, profiled functions: {ProfiledFuncs.Count}).");
 
             return true;
         }
@@ -375,7 +380,11 @@ namespace ARMeilleure.Translation.PTC
 
             if (fileSize != 0L)
             {
-                Logger.Info?.Print(LogClass.Ptc, $"Saved Profiling Info (size: {fileSize} bytes, profiled functions: {profiledFuncsCount}).");
+                Logger.Info?.Print(
+                    LogClass.Ptc,
+                    $"Saved Profiling Info (pid: {_ptc.CacheInfo.ProcessId}, title: {_ptc.CacheInfo.TitleIdText}, version: '{_ptc.CacheInfo.DisplayVersion}', " +
+                    $"kind: {_ptc.CacheInfo.ProcessKind}, selector: '{_ptc.CacheInfo.CacheSelector}', key: '{_ptc.CacheInfo.CacheKey}', " +
+                    $"path: '{fileName}', size: {fileSize} bytes, profiled functions: {profiledFuncsCount}).");
             }
         }
 

src/ARMeilleure/Translation/Translator.cs

@@ -57,9 +57,9 @@ namespace ARMeilleure.Translation
             FunctionTable.Fill = (ulong)Stubs.SlowDispatchStub;
         }
 
-        public IPtcLoadState LoadDiskCache(string titleIdText, string displayVersion, bool enabled, string cacheSelector)
+        public IPtcLoadState LoadDiskCache(PtcCacheInfo cacheInfo, bool enabled)
         {
-            _ptc.Initialize(titleIdText, displayVersion, enabled, Memory.Type, cacheSelector);
+            _ptc.Initialize(cacheInfo, enabled, Memory.Type);
             return _ptc;
         }
 

src/LibKenjinx/LibKenjinx.Input.cs

@@ -2,6 +2,7 @@ using Ryujinx.Common.Configuration;
 using Ryujinx.Common.Configuration.Hid;
 using Ryujinx.Common.Configuration.Hid.Controller;
 using Ryujinx.Common.Configuration.Hid.Controller.Motion;
+using Ryujinx.HLE.HOS.Services.Hid;
 using Ryujinx.Input;
 using Ryujinx.Input.HLE;
 using System;
@@ -11,6 +12,8 @@ using System.Linq;
 using System.Numerics;
 using ConfigGamepadInputId = Ryujinx.Common.Configuration.Hid.Controller.GamepadInputId;
 using ConfigStickInputId = Ryujinx.Common.Configuration.Hid.Controller.StickInputId;
+using ControllerType = Ryujinx.Common.Configuration.Hid.ControllerType;
+using PlayerIndex = Ryujinx.Common.Configuration.Hid.PlayerIndex;
 using StickInputId = Ryujinx.Input.StickInputId;
 
 namespace LibKenjinx
@@ -268,7 +271,12 @@ namespace LibKenjinx
             throw new NotImplementedException();
         }
 
-        public void Rumble(float lowFrequency, float highFrequency, uint durationMs)
+        public bool HDRumble(VibrationValue left, VibrationValue right)
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool Rumble(float lowFrequency, float highFrequency, uint durationMs)
         {
             throw new NotImplementedException();
         }
@@ -487,9 +495,14 @@ namespace LibKenjinx
             //throw new System.NotImplementedException();
         }
 
-        public void Rumble(float lowFrequency, float highFrequency, uint durationMs)
+        public bool HDRumble(VibrationValue left, VibrationValue right)
         {
-            //throw new System.NotImplementedException();
+            throw new NotImplementedException();
+        }
+
+        public bool Rumble(float lowFrequency, float highFrequency, uint durationMs)
+        {
+            throw new NotImplementedException();
         }
 
         public GamepadStateSnapshot GetMappedStateSnapshot()

src/Ryujinx.Common/Configuration/Hid/Controller/RumbleConfigController.cs

@@ -16,5 +16,10 @@ namespace Ryujinx.Common.Configuration.Hid.Controller
         /// Enable Rumble
         /// </summary>
         public bool EnableRumble { get; set; }
+        
+        /// <summary>
+        /// Enable HD Rumble support
+        /// </summary
+        public bool UseHDRumble { get; set; }
     }
 }

src/Ryujinx.Common/Utilities/EmbeddedResources.cs

@@ -126,8 +126,13 @@ namespace Ryujinx.Common
 
         public static string[] GetAllAvailableResources(string path, string ext = "")
         {
-            return ResolveManifestPath(path).Item1.GetManifestResourceNames()
+            (Assembly assembly, string resourcePath) = ResolveManifestPath(path);
-                .Where(r => r.EndsWith(ext))
+
+            string manifestPath = assembly.GetName().Name + "." + resourcePath.Replace('/', '.');
+
+            return assembly.GetManifestResourceNames()
+                .Where(r => r.StartsWith(manifestPath + ".", StringComparison.Ordinal))
+                .Where(r => r.EndsWith(ext, StringComparison.Ordinal))
                 .ToArray();
         }
 

src/Ryujinx.Cpu/AppleHv/HvCpuContext.cs

@@ -1,4 +1,5 @@
 using ARMeilleure.Memory;
+using ARMeilleure.Translation.PTC;
 using System.Runtime.Versioning;
 
 namespace Ryujinx.Cpu.AppleHv
@@ -32,7 +33,7 @@ namespace Ryujinx.Cpu.AppleHv
         {
         }
 
-        public IDiskCacheLoadState LoadDiskCache(string titleIdText, string displayVersion, bool enabled, string cacheSelector)
+        public IDiskCacheLoadState LoadDiskCache(PtcCacheInfo cacheInfo, bool enabled)
         {
             return new DummyDiskCacheLoadState();
         }

src/Ryujinx.Cpu/ICpuContext.cs

@@ -1,4 +1,5 @@
 using System;
+using ARMeilleure.Translation.PTC;
 
 namespace Ryujinx.Cpu
 {
@@ -44,11 +45,10 @@ namespace Ryujinx.Cpu
         /// <remarks>
         /// If the execution engine is recompiling guest code, this can be used to load cached code from disk.
         /// </remarks>
-        /// <param name="titleIdText">Title ID of the application in padded hex form</param>
+        /// <param name="cacheInfo">Identity and selector for the process-owned disk cache</param>
-        /// <param name="displayVersion">Version of the application</param>
         /// <param name="enabled">True if the cache should be loaded from disk if it exists, false otherwise</param>
         /// <returns>Disk cache load progress reporter and manager</returns>
-        IDiskCacheLoadState LoadDiskCache(string titleIdText, string displayVersion, bool enabled, string cacheSelector);
+        IDiskCacheLoadState LoadDiskCache(PtcCacheInfo cacheInfo, bool enabled);
 
         /// <summary>
         /// Indicates that code has been loaded into guest memory, and that it might be executed in the future.

src/Ryujinx.Cpu/Jit/JitCpuContext.cs

@@ -1,6 +1,7 @@
 using ARMeilleure.Common;
 using ARMeilleure.Memory;
 using ARMeilleure.Translation;
+using ARMeilleure.Translation.PTC;
 using Ryujinx.Cpu.Signal;
 
 namespace Ryujinx.Cpu.Jit
@@ -49,9 +50,9 @@ namespace Ryujinx.Cpu.Jit
         }
 
         /// <inheritdoc/>
-        public IDiskCacheLoadState LoadDiskCache(string titleIdText, string displayVersion, bool enabled, string cacheSelector)
+        public IDiskCacheLoadState LoadDiskCache(PtcCacheInfo cacheInfo, bool enabled)
         {
-            return new JitDiskCacheLoadState(_translator.LoadDiskCache(titleIdText, displayVersion, enabled, cacheSelector));
+            return new JitDiskCacheLoadState(_translator.LoadDiskCache(cacheInfo, enabled));
         }
 
         /// <inheritdoc/>

src/Ryujinx.Cpu/LightningJit/LightningJitCpuContext.cs

@@ -1,5 +1,6 @@
 using ARMeilleure.Common;
 using ARMeilleure.Memory;
+using ARMeilleure.Translation.PTC;
 using Ryujinx.Cpu.Jit;
 using Ryujinx.Cpu.LightningJit.State;
 
@@ -51,7 +52,7 @@ namespace Ryujinx.Cpu.LightningJit
         }
 
         /// <inheritdoc/>
-        public IDiskCacheLoadState LoadDiskCache(string titleIdText, string displayVersion, bool enabled, string cacheSelector)
+        public IDiskCacheLoadState LoadDiskCache(PtcCacheInfo cacheInfo, bool enabled)
         {
             return new DummyDiskCacheLoadState();
         }

src/Ryujinx.Cpu/Nce/NceCpuContext.cs

@@ -1,4 +1,5 @@
 using ARMeilleure.Memory;
+using ARMeilleure.Translation.PTC;
 using Ryujinx.Cpu.Signal;
 using Ryujinx.Common;
 using Ryujinx.Memory;
@@ -127,7 +128,7 @@ namespace Ryujinx.Cpu.Nce
         }
 
         /// <inheritdoc/>
-        public IDiskCacheLoadState LoadDiskCache(string titleIdText, string displayVersion, bool enabled, string cacheSelector)
+        public IDiskCacheLoadState LoadDiskCache(PtcCacheInfo cacheInfo, bool enabled)
         {
             return new DummyDiskCacheLoadState();
         }

src/Ryujinx.Graphics.GAL/HardwareInfo.cs

@@ -5,12 +5,14 @@ namespace Ryujinx.Graphics.GAL
         public string GpuVendor { get; }
         public string GpuModel { get; }
         public string GpuDriver { get; }
+        public string GpuDriverVersion { get; }
 
-        public HardwareInfo(string gpuVendor, string gpuModel, string gpuDriver)
+        public HardwareInfo(string gpuVendor, string gpuModel, string gpuDriver, string gpuDriverVersion)
         {
             GpuVendor = gpuVendor;
             GpuModel = gpuModel;
             GpuDriver = gpuDriver;
+            GpuDriverVersion = gpuDriverVersion;
         }
     }
 }

src/Ryujinx.Graphics.Gpu/Image/TextureCompatibility.cs

@@ -369,12 +369,15 @@ namespace Ryujinx.Graphics.Gpu.Image
             }
 
             // Some APIs align the width for copy and render target textures,
-            // so the width may not match in this case for different uses of the same texture.
+            // so the width may not match for different uses of the same texture.
             // To account for this, we compare the aligned width here.
-            // We expect height to always match exactly, if the texture is the same.
+            // However, matching block footprints are not sufficient for compressed textures;
+            // their logical dimensions must also match.
             if (alignedWidthMatches && lhsSize.Height == rhsSize.Height)
             {
-                return (exact && lhsSize.Width != rhsSize.Width) || lhsSize.Width < rhsSize.Width
+                return ((lhs.FormatInfo.IsCompressed || rhs.FormatInfo.IsCompressed) &&
+                        (Math.Max(1, lhs.Width >> level) != rhs.Width || Math.Max(1, lhs.Height >> level) != rhs.Height)) ||
+                       (exact && lhsSize.Width != rhsSize.Width) || lhsSize.Width < rhsSize.Width
                     ? TextureViewCompatibility.CopyOnly
                     : result;
             }

src/Ryujinx.Graphics.Gpu/Image/TextureGroup.cs

@@ -182,7 +182,11 @@ namespace Ryujinx.Graphics.Gpu.Image
         {
             foreach (TextureIncompatibleOverlap overlap in _incompatibleOverlaps)
             {
-                if (overlap.Compatibility <= TextureViewCompatibility.LayoutIncompatible)
+                // LayoutIncompatible and better may still use a regular texture copy dependency.
+                // Fully Incompatible pairs are not copy compatible in general, but may still qualify for an
+                // exact raw byte copy dependency (checked internally by CreateCopyDependency) when they map
+                // to exactly the same guest memory, such as differently typed/sized aliases of the same data.
+                if (overlap.Compatibility <= TextureViewCompatibility.Incompatible)
                 {
                     CreateCopyDependency(overlap.Group, false, overlap.Compatibility);
                 }
@@ -226,7 +230,6 @@ namespace Ryujinx.Graphics.Gpu.Image
             }
         }
 
-
         /// <summary>
         /// Flushes incompatible overlaps if the storage format requires it, and they have been modified.
         /// This allows unsupported host formats to accept data written to format aliased textures.
@@ -659,7 +662,7 @@ namespace Ryujinx.Graphics.Gpu.Image
 
                 bool canImport = Storage.Info.IsLinear && Storage.Info.Stride >= Storage.Info.Width * Storage.Info.FormatInfo.BytesPerPixel;
 
-                IntPtr hostPointer = canImport ? _physicalMemory.GetHostPointer(Storage.Range) : 0;
+                nint hostPointer = canImport ? _physicalMemory.GetHostPointer(Storage.Range) : 0;
 
                 if (hostPointer != 0 && _context.Renderer.PrepareHostMapping(hostPointer, Storage.Size))
                 {
@@ -1049,7 +1052,7 @@ namespace Ryujinx.Graphics.Gpu.Image
             int endOffset = _allOffsets[viewEnd] + _sliceSizes[lastLevel];
             int size = endOffset - offset;
 
-            List<RegionHandle> result = new();
+            List<RegionHandle> result = [];
 
             for (int i = 0; i < TextureRange.Count; i++)
             {
@@ -1163,7 +1166,6 @@ namespace Ryujinx.Graphics.Gpu.Image
             SignalAllDirty();
         }
 
-
         /// <summary>
         /// Removes a view from the group, removing it from all overlap lists.
         /// </summary>
@@ -1385,7 +1387,7 @@ namespace Ryujinx.Graphics.Gpu.Image
 
                 if (_is3D)
                 {
-                    List<TextureGroupHandle> handlesList = new();
+                    List<TextureGroupHandle> handlesList = [];
 
                     for (int i = 0; i < levelHandles; i++)
                     {
@@ -1468,8 +1470,8 @@ namespace Ryujinx.Graphics.Gpu.Image
             // Get the location of each texture within its storage, so we can find the handles to apply the dependency to.
             // This can consist of multiple disjoint regions, for example if this is a mip slice of an array texture.
 
-            List<(int BaseHandle, int RegionCount)> targetRange = new();
+            List<(int BaseHandle, int RegionCount)> targetRange = [];
-            List<(int BaseHandle, int RegionCount)> otherRange = new();
+            List<(int BaseHandle, int RegionCount)> otherRange = [];
 
             EvaluateRelevantHandles(firstLayer, firstLevel, other.Info.GetSlices(), other.Info.Levels, (baseHandle, regionCount, _, _) =>
             {
@@ -1601,7 +1603,15 @@ namespace Ryujinx.Graphics.Gpu.Image
                         TextureInfo info = Storage.Info;
                         TextureInfo otherInfo = other.Storage.Info;
 
-                        bool textureCopy = TextureCompatibility.ViewLayoutCompatible(info, otherInfo, level, otherLevel) &&
+                        // ViewLayoutCompatible/CopySizeMatches only reason about textures with some genuine
+                        // format relationship (LayoutIncompatible or better) - they are not aware of, and must
+                        // never be used to justify, a plain texture-to-texture copy (which some backends
+                        // implement via a reinterpreting view) between fully Incompatible aliases such as a
+                        // depth format and an unrelated color format. For Incompatible pairs, only the strict
+                        // raw byte copy dependency below (which explicitly excludes depth/stencil formats) may
+                        // be used.
+                        bool textureCopy = compatibility != TextureViewCompatibility.Incompatible &&
+                            TextureCompatibility.ViewLayoutCompatible(info, otherInfo, level, otherLevel) &&
                             TextureCompatibility.CopySizeMatches(info, otherInfo, level, otherLevel);
 
                         if (textureCopy || rawCopy)
@@ -1659,9 +1669,12 @@ namespace Ryujinx.Graphics.Gpu.Image
         {
             if (!_incompatibleOverlaps.Any(overlap => overlap.Group == other.Group))
             {
-                if (copy && other.Compatibility <= TextureViewCompatibility.LayoutIncompatible)
+                if (copy && other.Compatibility <= TextureViewCompatibility.Incompatible)
                 {
                     // Any of the group's views may share compatibility, even if the parents do not fully.
+                    // Fully Incompatible groups are also let through here, since CreateCopyDependency will
+                    // fall back to an exact raw byte copy dependency for them when the strict requirements
+                    // for one are met (see CanCreateRawCopyDependency).
                     CreateCopyDependency(other.Group, false, other.Compatibility);
                 }
 
@@ -1803,4 +1816,3 @@ namespace Ryujinx.Graphics.Gpu.Image
         }
     }
 }
-

src/Ryujinx.Graphics.Gpu/Image/TextureGroupHandle.cs

@@ -717,6 +717,7 @@ namespace Ryujinx.Graphics.Gpu.Image
                 }
 
                 DeferredCopy = old.DeferredCopy;
+                DeferredCopyRaw = old.DeferredCopyRaw;
             }
         }
 

src/Ryujinx.Graphics.OpenGL/Framebuffer.cs

@@ -20,6 +20,27 @@ namespace Ryujinx.Graphics.OpenGL
         private int _colorsCount;
         private bool _dualSourceBlend;
 
+        public bool HasAttachments
+        {
+            get
+            {
+                if (_depthStencil != null)
+                {
+                    return true;
+                }
+
+                for (int index = 0; index < _colors.Length; index++)
+                {
+                    if (_colors[index] != null)
+                    {
+                        return true;
+                    }
+                }
+
+                return false;
+            }
+        }
+
         public Framebuffer()
         {
             Handle = GL.GenFramebuffer();
@@ -34,6 +55,12 @@ namespace Ryujinx.Graphics.OpenGL
             return Handle;
         }
 
+        public void SetDefaultSize(int width, int height)
+        {
+            GL.FramebufferParameter(FramebufferTarget.Framebuffer, FramebufferDefaultParameter.FramebufferDefaultWidth, Math.Max(1, width));
+            GL.FramebufferParameter(FramebufferTarget.Framebuffer, FramebufferDefaultParameter.FramebufferDefaultHeight, Math.Max(1, height));
+        }
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void AttachColor(int index, TextureView color)
         {
@@ -105,13 +132,20 @@ namespace Ryujinx.Graphics.OpenGL
             _colorsCount = colorsCount;
         }
 
-        private static void SetDrawBuffersImpl(int colorsCount)
+        private void SetDrawBuffersImpl(int colorsCount)
         {
             DrawBuffersEnum[] drawBuffers = new DrawBuffersEnum[colorsCount];
 
             for (int index = 0; index < colorsCount; index++)
             {
-                drawBuffers[index] = DrawBuffersEnum.ColorAttachment0 + index;
+                if (_colors[index] != null)
+                {
+                    drawBuffers[index] = DrawBuffersEnum.ColorAttachment0 + index;
+                }
+                else
+                {
+                    drawBuffers[index] = DrawBuffersEnum.None;
+                }
             }
 
             GL.DrawBuffers(colorsCount, drawBuffers);

src/Ryujinx.Graphics.OpenGL/OpenGLRenderer.cs

@@ -133,7 +133,7 @@ namespace Ryujinx.Graphics.OpenGL
 
         public HardwareInfo GetHardwareInfo()
         {
-            return new HardwareInfo(GpuVendor, GpuRenderer, GpuVendor); // OpenGL does not provide a driver name, vendor name is closest analogue.
+            return new HardwareInfo(GpuVendor, GpuRenderer, GpuVendor, GpuVersion); // OpenGL does not provide a driver name, vendor name is closest analogue.
         }
 
         public PinnedSpan<byte> GetBufferData(BufferHandle buffer, int offset, int size)

src/Ryujinx.Graphics.OpenGL/Pipeline.cs

@@ -1537,6 +1537,11 @@ namespace Ryujinx.Graphics.OpenGL
         {
             DrawCount++;
 
+            if (!_framebuffer.HasAttachments && _viewportArray.Length >= 4)
+            {
+                _framebuffer.SetDefaultSize((int)_viewportArray[2], (int)_viewportArray[3]);
+            }
+
             _unit0Texture?.Bind(0);
         }
 

src/Ryujinx.Graphics.Shader/CodeGen/Spirv/Instructions.cs

@@ -1773,7 +1773,7 @@ namespace Ryujinx.Graphics.Shader.CodeGen.Spirv
                     {
                         (_, varType) = IoMap.GetSpirvBuiltIn(ioVariable);
 
-                        if (IoMap.IsPerVertexBuiltIn(ioVariable))
+                        if (context.Definitions.Stage.IsVtg() && IoMap.IsPerVertexBuiltIn(ioVariable))
                         {
                             perVertexBuiltIn = ioVariable;
                             ioVariable = IoVariable.Position;

src/Ryujinx.Graphics.Shader/Translation/Optimizations/BindlessElimination.cs

@@ -70,19 +70,7 @@ namespace Ryujinx.Graphics.Shader.Translation.Optimizations
 
             Operand bindlessHandle = texOp.GetSource(0);
 
-            if (bindlessHandle.AsgOp is PhiNode phi)
+            if (!IsBindlessAccessAllowed(bindlessHandle))
-            {
-                for (int srcIndex = 0; srcIndex < phi.SourcesCount; srcIndex++)
-                {
-                    Operand phiSource = phi.GetSource(srcIndex);
-
-                    if (phiSource.AsgOp is not PhiNode && !IsBindlessAccessAllowed(phiSource))
-                    {
-                        return false;
-                    }
-                }
-            }
-            else if (!IsBindlessAccessAllowed(bindlessHandle))
             {
                 return false;
             }
@@ -100,7 +88,10 @@ namespace Ryujinx.Graphics.Shader.Translation.Optimizations
 
             texOp.SetSource(0, textureIndex);
 
-            bool hasSampler = !texOp.Inst.IsImage();
+            // Buffer textures use a TIC/BufferView only and never consume a sampler.
+            // Avoiding a sampler descriptor array here is especially important for bindless
+            // texture buffers, where the array can span the entire sampler pool for no benefit.
+            bool hasSampler = !texOp.Inst.IsImage() && texOp.Type != SamplerType.TextureBuffer;
 
             SetBindingPair textureSetAndBinding = resourceManager.GetTextureOrImageBinding(
                 texOp.Inst,
@@ -143,26 +134,112 @@ namespace Ryujinx.Graphics.Shader.Translation.Optimizations
 
         private static bool IsBindlessAccessAllowed(Operand bindlessHandle)
         {
-            if (bindlessHandle.Type == OperandType.ConstantBuffer)
+            // Walk only SSA merges and integer operations that can transparently construct
-            {
+            // or select a packed texture/sampler handle. Do not walk arbitrary operations:
-                // Bindless access with handles from constant buffer is allowed.
+            // finding an unrelated resource load elsewhere in the SSA graph must not enable
+            // descriptor-array access for this handle.
+            const int MaxVisitedOperands = 256;
+            const int MaxDepth = 64;
 
-                return true;
+            Stack<(Operand Operand, int Depth)> work = new();
+            HashSet<Operand> visited = new();
+
+            work.Push((bindlessHandle, 0));
+
+            while (work.Count != 0 && visited.Count < MaxVisitedOperands)
+            {
+                (Operand operand, int depth) = work.Pop();
+
+                if (operand == null || depth > MaxDepth || !visited.Add(operand))
+                {
+                    continue;
+                }
+
+                if (operand.Type == OperandType.ConstantBuffer)
+                {
+                    // Constant buffers are accepted by the existing direct-handle path and
+                    // remain accepted when SSA merges or integer handle arithmetic obscure them.
+                    return true;
+                }
+
+                if (operand.AsgOp is PhiNode phi)
+                {
+                    for (int index = 0; index < phi.SourcesCount; index++)
+                    {
+                        Operand source = phi.GetSource(index);
+
+                        if (source.Type != OperandType.Undefined)
+                        {
+                            work.Push((source, depth + 1));
+                        }
+                    }
+
+                    continue;
+                }
+
+                if (operand.AsgOp is not Operation operation)
+                {
+                    continue;
+                }
+
+                Instruction inst = operation.Inst & Instruction.Mask;
+
+                if (inst == Instruction.Load)
+                {
+                    // Preserve the performance restriction. Static CBUF operands are already
+                    // accepted above; accept their dynamically indexed Load form as the same
+                    // resource class, plus the existing shader-input and storage-buffer sources.
+                    // Other loads remain traversal barriers and cannot authorize a pool array.
+                    if (operation.StorageKind == StorageKind.ConstantBuffer ||
+                        operation.StorageKind == StorageKind.Input ||
+                        operation.StorageKind == StorageKind.StorageBuffer)
+                    {
+                        return true;
+                    }
+
+                    continue;
+                }
+
+                if (!IsHandleConstructionOperation(inst))
+                {
+                    // Texture/image operations, arbitrary loads, floating-point conversions,
+                    // calls and other unrelated calculations are deliberate traversal barriers.
+                    continue;
+                }
+
+                for (int index = 0; index < operation.SourcesCount; index++)
+                {
+                    work.Push((operation.GetSource(index), depth + 1));
+                }
             }
 
-            if (bindlessHandle.AsgOp is not Operation handleOp ||
+            return false;
-                handleOp.Inst != Instruction.Load ||
+        }
-                (handleOp.StorageKind != StorageKind.Input && handleOp.StorageKind != StorageKind.StorageBuffer))
-            {
-                // Right now, we only allow bindless access when the handle comes from a shader input or storage buffer.
-                // This is an artificial limitation to prevent it from being used in cases where it
-                // would have a large performance impact of loading all textures in the pool.
-                // It might be removed in the future, if we can mitigate the performance impact.
 
-                return false;
+        private static bool IsHandleConstructionOperation(Instruction inst)
-            }
+        {
-
+            return inst is
-            return true;
+                Instruction.Add or
+                Instruction.Subtract or
+                Instruction.Multiply or
+                Instruction.MultiplyHighS32 or
+                Instruction.MultiplyHighU32 or
+                Instruction.BitwiseAnd or
+                Instruction.BitwiseExclusiveOr or
+                Instruction.BitwiseNot or
+                Instruction.BitwiseOr or
+                Instruction.BitfieldExtractS32 or
+                Instruction.BitfieldExtractU32 or
+                Instruction.BitfieldInsert or
+                Instruction.ShiftLeft or
+                Instruction.ShiftRightS32 or
+                Instruction.ShiftRightU32 or
+                Instruction.MinimumU32 or
+                Instruction.MaximumU32 or
+                Instruction.ClampU32 or
+                Instruction.ConditionalSelect or
+                Instruction.Copy or
+                Instruction.VectorExtract;
         }
 
         private static bool TryConvertBindless(BasicBlock block, ResourceManager resourceManager, IGpuAccessor gpuAccessor, TextureOperation texOp)

src/Ryujinx.Graphics.Vulkan/FramebufferParams.cs

@@ -32,6 +32,29 @@ namespace Ryujinx.Graphics.Vulkan
         public bool HasDepthStencil { get; private set; }
         public int ColorAttachmentsCount => AttachmentsCount - (HasDepthStencil ? 1 : 0);
 
+        public bool SetVirtualSize(uint width, uint height, uint layers)
+        {
+            if (AttachmentsCount != 0)
+            {
+                return false;
+            }
+
+            width = Math.Max(1u, width);
+            height = Math.Max(1u, height);
+            layers = Math.Max(1u, layers);
+
+            if (Width == width && Height == height && Layers == layers)
+            {
+                return false;
+            }
+
+            Width = width;
+            Height = height;
+            Layers = layers;
+
+            return true;
+        }
+
         public FramebufferParams(Device device, TextureView view, uint width, uint height)
         {
             Format format = view.Info.Format;

src/Ryujinx.Graphics.Vulkan/PipelineBase.cs

@@ -843,6 +843,11 @@ namespace Ryujinx.Graphics.Vulkan
         public void SetImage(ShaderStage stage, int binding, ITexture image)
         {
             _descriptorSetUpdater.SetImage(Cbs, stage, binding, image);
+
+            if (stage == ShaderStage.Fragment && image is TextureView view)
+            {
+                FramebufferParams?.SetVirtualSize((uint)view.Width, (uint)view.Height, (uint)view.Layers);
+            }
         }
 
         public void SetImage(int binding, Auto<DisposableImageView> image)
@@ -1607,6 +1612,24 @@ namespace Ryujinx.Graphics.Vulkan
 
         private bool RecreateGraphicsPipelineIfNeeded()
         {
+            if (FramebufferParams != null &&
+                FramebufferParams.AttachmentsCount == 0 &&
+                FramebufferParams.Width == 1 &&
+                FramebufferParams.Height == 1 &&
+                DynamicState.ViewportsCount != 0)
+            {
+                // An attachmentless fragment pass can reach its first draw before the storage
+                // image descriptor is rebound. At that point the null framebuffer still has
+                // its constructor fallback of 1x1, even though the guest viewport already
+                // describes the real render area. Seed the virtual framebuffer from that
+                // viewport so the first storage-image draw is not clipped to one pixel.
+                Silk.NET.Vulkan.Viewport viewport = DynamicState.Viewports[0];
+                uint width = (uint)Math.Max(1f, Math.Abs(viewport.Width));
+                uint height = (uint)Math.Max(1f, Math.Abs(viewport.Height));
+
+                FramebufferParams.SetVirtualSize(width, height, 1);
+            }
+
             if (AutoFlush.ShouldFlushDraw(DrawCount))
             {
                 Gd.FlushAllCommands();

src/Ryujinx.Graphics.Vulkan/Vendor.cs

@@ -36,6 +36,9 @@ namespace Ryujinx.Graphics.Vulkan
         [GeneratedRegex(@"Adreno (\(TM\) )?(8[0-9]\d)")]
         public static partial Regex Adreno8xxRegex();
 
+        [GeneratedRegex(@"^\d+\.\d+\.\d+\.\d+$")]
+        internal static partial Regex IntelWindowsDriverVersionRegex();
+
         public static Vendor FromId(uint id)
         {
             return id switch

src/Ryujinx.Graphics.Vulkan/VulkanRenderer.cs

@@ -115,6 +115,7 @@ namespace Ryujinx.Graphics.Vulkan
         public string GpuDriver { get; private set; }
         public string GpuRenderer { get; private set; }
         public string GpuVersion { get; private set; }
+        public string GpuDriverVersion { get; private set; }
 
         public bool PreferThreading => true;
 
@@ -185,6 +186,14 @@ namespace Ryujinx.Graphics.Vulkan
                 SType = StructureType.PhysicalDeviceProperties2,
             };
 
+            PhysicalDeviceIDProperties propertiesId = new()
+            {
+                SType = StructureType.PhysicalDeviceIDProperties,
+                PNext = properties2.PNext,
+            };
+
+            properties2.PNext = &propertiesId;
+
             PhysicalDeviceSubgroupProperties propertiesSubgroup = new()
             {
                 SType = StructureType.PhysicalDeviceSubgroupProperties,
@@ -374,13 +383,17 @@ namespace Ryujinx.Graphics.Vulkan
             GpuVendor = VendorUtils.GetNameFromId(properties.VendorID);
             GpuDriver = hasDriverProperties && !OperatingSystem.IsMacOS() ?
                 VendorUtils.GetFriendlyDriverName(driverProperties.DriverID) : GpuVendor; // Fallback to vendor name if driver is unavailable or on MacOS where vendor is preferred.
+            GpuDriverVersion = TryGetIntelWindowsDriverVersionFromUuid(ref propertiesId, out string intelDriverVersion) ? intelDriverVersion :
+                hasDriverProperties ?
+                GetDriverInfo(ref driverProperties) ?? ParseDriverVersion(ref properties) :
+                ParseDriverVersion(ref properties);
 
             fixed (byte* deviceName = properties.DeviceName)
             {
                 GpuRenderer = Marshal.PtrToStringAnsi((nint)deviceName);
             }
 
-            GpuVersion = $"Vulkan v{ParseStandardVulkanVersion(properties.ApiVersion)}, Driver v{ParseDriverVersion(ref properties)}";
+            GpuVersion = $"Vulkan v{ParseStandardVulkanVersion(properties.ApiVersion)}";
 
             IsAmdGcn = !IsMoltenVk && Vendor == Vendor.Amd && VendorUtils.AmdGcnRegex().IsMatch(GpuRenderer);
 
@@ -846,7 +859,7 @@ namespace Ryujinx.Graphics.Vulkan
 
         public HardwareInfo GetHardwareInfo()
         {
-            return new HardwareInfo(GpuVendor, GpuRenderer, GpuDriver);
+            return new HardwareInfo(GpuVendor, GpuRenderer, GpuDriver, GpuDriverVersion);
         }
 
         /// <summary>
@@ -896,9 +909,55 @@ namespace Ryujinx.Graphics.Vulkan
                 return $"{(driverVersionRaw >> 22) & 0x3FF}.{(driverVersionRaw >> 14) & 0xFF}.{(driverVersionRaw >> 6) & 0xFF}.{driverVersionRaw & 0x3F}";
             }
 
+            // Intel's Windows Vulkan driver exposes the 101.xxxx build portion in a custom layout.
+            if (properties.VendorID == 0x8086 && OperatingSystem.IsWindows())
+            {
+                return $"{driverVersionRaw >> 14}.{driverVersionRaw & 0x3FFF}";
+            }
+
             return ParseStandardVulkanVersion(driverVersionRaw);
         }
 
+        private static unsafe string GetDriverInfo(ref PhysicalDeviceDriverPropertiesKHR driverProperties)
+        {
+            fixed (byte* driverInfo = driverProperties.DriverInfo)
+            {
+                string driverInfoString = Marshal.PtrToStringAnsi((nint)driverInfo);
+
+                return string.IsNullOrWhiteSpace(driverInfoString) ? null : driverInfoString;
+            }
+        }
+
+        private static unsafe bool TryGetIntelWindowsDriverVersionFromUuid(ref PhysicalDeviceIDProperties propertiesId, out string driverVersion)
+        {
+            driverVersion = null;
+
+            if (!OperatingSystem.IsWindows())
+            {
+                return false;
+            }
+
+            fixed (byte* driverUuid = propertiesId.DriverUuid)
+            {
+                string driverUuidString = Marshal.PtrToStringAnsi((nint)driverUuid, (int)Vk.UuidSize);
+                int terminatorIndex = driverUuidString.IndexOf('\0');
+
+                if (terminatorIndex >= 0)
+                {
+                    driverUuidString = driverUuidString[..terminatorIndex];
+                }
+
+                if (VendorUtils.IntelWindowsDriverVersionRegex().IsMatch(driverUuidString))
+                {
+                    driverVersion = driverUuidString;
+
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
         internal PrimitiveTopology TopologyRemap(PrimitiveTopology topology)
         {
             return topology switch
@@ -924,7 +983,7 @@ namespace Ryujinx.Graphics.Vulkan
 
         private void PrintGpuInformation()
         {
-            Logger.Notice.Print(LogClass.Gpu, $"{GpuVendor} {GpuRenderer} ({GpuVersion})");
+            Logger.Notice.Print(LogClass.Gpu, $"{GpuVendor} {GpuRenderer} ({GpuVersion}, Driver: {GpuDriver} {GpuDriverVersion})");
             Logger.Notice.Print(LogClass.Gpu, $"GPU Memory: {GetTotalGPUMemory() / (1024 * 1024)} MiB");
         }
 

src/Ryujinx.HLE/HOS/ArmProcessContext.cs

@@ -1,4 +1,5 @@
 using ARMeilleure.Memory;
+using ARMeilleure.Translation.PTC;
 using Ryujinx.Cpu;
 using Ryujinx.Graphics.Gpu;
 using Ryujinx.HLE.HOS.Kernel.Process;
@@ -9,12 +10,10 @@ namespace Ryujinx.HLE.HOS
     interface IArmProcessContext : IProcessContext
     {
         IDiskCacheLoadState Initialize(
-            string titleIdText,
+            PtcCacheInfo cacheInfo,
-            string displayVersion,
             bool diskCacheEnabled,
             ulong codeAddress,
-            ulong codeSize,
+            ulong codeSize);
-            string cacheSelector);
     }
 
     class ArmProcessContext<T> : IArmProcessContext where T : class, IVirtualMemoryManagerTracked, IMemoryManager
@@ -67,15 +66,13 @@ namespace Ryujinx.HLE.HOS
         }
 
         public IDiskCacheLoadState Initialize(
-            string titleIdText,
+            PtcCacheInfo cacheInfo,
-            string displayVersion,
             bool diskCacheEnabled,
             ulong codeAddress,
-            ulong codeSize,
+            ulong codeSize)
-            string cacheSelector)
         {
             _cpuContext.PrepareCodeRange(codeAddress, codeSize);
-            return _cpuContext.LoadDiskCache(titleIdText, displayVersion, diskCacheEnabled, cacheSelector);
+            return _cpuContext.LoadDiskCache(cacheInfo, diskCacheEnabled);
         }
 
         public void InvalidateCacheRegion(ulong address, ulong size)

src/Ryujinx.HLE/HOS/ArmProcessContextFactory.cs

@@ -1,3 +1,4 @@
+using ARMeilleure.Translation.PTC;
 using Ryujinx.Common.Configuration;
 using Ryujinx.Common.Logging;
 using Ryujinx.Cpu;
@@ -8,6 +9,7 @@ using Ryujinx.Cpu.Nce;
 using Ryujinx.Graphics.Gpu;
 using Ryujinx.HLE.HOS.Kernel;
 using Ryujinx.HLE.HOS.Kernel.Process;
+using Ryujinx.HLE.Loaders.Processes;
 using Ryujinx.Memory;
 using System;
 using System.Runtime.InteropServices;
@@ -18,8 +20,10 @@ namespace Ryujinx.HLE.HOS
     {
         private readonly ITickSource _tickSource;
         private readonly GpuContext _gpu;
-        private readonly string _titleIdText;
+        private readonly ulong _programId;
+        private readonly byte _programIndex;
         private readonly string _displayVersion;
+        private readonly ProcessKind _processKind;
         private readonly bool _diskCacheEnabled;
         private readonly string _diskCacheSelector;
         private readonly ulong _codeAddress;
@@ -30,8 +34,10 @@ namespace Ryujinx.HLE.HOS
         public ArmProcessContextFactory(
             ITickSource tickSource,
             GpuContext gpu,
-            string titleIdText,
+            ulong programId,
+            byte programIndex,
             string displayVersion,
+            ProcessKind processKind,
             bool diskCacheEnabled,
             string diskCacheSelector,
             ulong codeAddress,
@@ -39,8 +45,10 @@ namespace Ryujinx.HLE.HOS
         {
             _tickSource = tickSource;
             _gpu = gpu;
-            _titleIdText = titleIdText;
+            _programId = programId;
+            _programIndex = programIndex;
             _displayVersion = displayVersion;
+            _processKind = processKind;
             _diskCacheEnabled = diskCacheEnabled;
             _diskCacheSelector = diskCacheSelector;
             _codeAddress = codeAddress;
@@ -160,8 +168,18 @@ namespace Ryujinx.HLE.HOS
             }
 
             string cacheSelector = _diskCacheSelector ?? "default";
+            string programIdText = _programId == 0 ? string.Empty : $"{_programId:x16}";
+            string applicationIdText = _programId == 0 ? string.Empty : $"{_programId & ~0xFul:x16}";
+            PtcCacheInfo cacheInfo = new(
+                pid,
+                programIdText,
+                applicationIdText,
+                _programIndex,
+                _displayVersion,
+                _processKind.ToString(),
+                cacheSelector);
 
-            DiskCacheLoadState = processContext.Initialize(_titleIdText, _displayVersion, _diskCacheEnabled, _codeAddress, _codeSize, cacheSelector);
+            DiskCacheLoadState = processContext.Initialize(cacheInfo, _diskCacheEnabled, _codeAddress, _codeSize);
 
             return processContext;
         }

src/Ryujinx.HLE/HOS/Kernel/Common/KSystemControl.cs

@@ -26,12 +26,12 @@ namespace Ryujinx.HLE.HOS.Kernel.Common
             {
                 MemoryArrange.MemoryArrange4GiB or
                 MemoryArrange.MemoryArrange4GiBSystemDev or
-                MemoryArrange.MemoryArrange6GiBAppletDev => 3152 * MiB,
+                MemoryArrange.MemoryArrange6GiBAppletDev => 3236 * MiB,
                 MemoryArrange.MemoryArrange4GiBAppletDev => 2048 * MiB,
-                MemoryArrange.MemoryArrange6GiB => 4783 * MiB,
+                MemoryArrange.MemoryArrange6GiB => 4867 * MiB,
-                MemoryArrange.MemoryArrange8GiB => 6831 * MiB,
+                MemoryArrange.MemoryArrange8GiB => 6915 * MiB,
-                MemoryArrange.MemoryArrange10GiB => 8879 * MiB,
+                MemoryArrange.MemoryArrange10GiB => 8963 * MiB,
-                MemoryArrange.MemoryArrange12GiB => 10927 * MiB,
+                MemoryArrange.MemoryArrange12GiB => 11011 * MiB,
                 _ => throw new ArgumentException($"Invalid memory arrange \"{arrange}\"."),
             };
         }

src/Ryujinx.HLE/HOS/Kernel/Threading/KAddressArbiter.cs

@@ -15,7 +15,6 @@ namespace Ryujinx.HLE.HOS.Kernel.Threading
 
         private readonly Dictionary<ulong, List<KThread>> _condVarThreads;
         private readonly Dictionary<ulong, List<KThread>> _arbiterThreads;
-        private readonly ByDynamicPriority _byDynamicPriority;
 
         public KAddressArbiter(KernelContext context)
         {
@@ -23,7 +22,6 @@ namespace Ryujinx.HLE.HOS.Kernel.Threading
 
             _condVarThreads = [];
             _arbiterThreads = [];
-            _byDynamicPriority = new ByDynamicPriority();
         }
 
         public Result ArbitrateLock(int ownerHandle, ulong mutexAddress, int requesterHandle)
@@ -142,13 +140,8 @@ namespace Ryujinx.HLE.HOS.Kernel.Threading
 
             if (_condVarThreads.TryGetValue(condVarAddress, out List<KThread> threads))
             {
-                int i = 0;
+                int i = FindDynamicPriorityFifoInsertionIndex(threads, currentThread);
 
-                if (threads.Count > 0)
-                {
-                    i = threads.BinarySearch(currentThread, _byDynamicPriority);
-                    if (i < 0) i = ~i;
-                }
 
                 threads.Insert(i, currentThread);
             }
@@ -332,13 +325,8 @@ namespace Ryujinx.HLE.HOS.Kernel.Threading
                 
                 if (_arbiterThreads.TryGetValue(address, out List<KThread> threads))
                 {
-                    int i = 0;
+                    int i = FindDynamicPriorityFifoInsertionIndex(threads, currentThread);
 
-                    if (threads.Count > 0)
-                    {
-                        i = threads.BinarySearch(currentThread, _byDynamicPriority);
-                        if (i < 0) i = ~i;
-                    }
 
                     threads.Insert(i, currentThread);
                 }
@@ -424,13 +412,8 @@ namespace Ryujinx.HLE.HOS.Kernel.Threading
                 
                 if (_arbiterThreads.TryGetValue(address, out List<KThread> threads))
                 {
-                    int i = 0;
+                    int i = FindDynamicPriorityFifoInsertionIndex(threads, currentThread);
 
-                    if (threads.Count > 0)
-                    {
-                        i = threads.BinarySearch(currentThread, _byDynamicPriority);
-                        if (i < 0) i = ~i;
-                    }
 
                     threads.Insert(i, currentThread);
                 }
@@ -627,12 +610,28 @@ namespace Ryujinx.HLE.HOS.Kernel.Threading
             return validCount;
         }
         
-        private class ByDynamicPriority : IComparer<KThread>
+        private static int FindDynamicPriorityFifoInsertionIndex(List<KThread> threads, KThread currentThread)
         {
-            public int Compare(KThread x, KThread y)
+            int low = 0;
+            int high = threads.Count;
+
+            // Lower numeric values represent higher priorities. Use upper-bound insertion
+            // to preserve FIFO order among waiters with the same dynamic priority.
+            while (low < high)
             {
-                return x!.DynamicPriority.CompareTo(y!.DynamicPriority);
+                int middle = low + ((high - low) >> 1);
+
+                if (threads[middle].DynamicPriority <= currentThread.DynamicPriority)
+                {
+                    low = middle + 1;
+                }
+                else
+                {
+                    high = middle;
+                }
             }
+
+            return low;
         }
     }
 }

src/Ryujinx.HLE/HOS/ModLoader.cs

@@ -749,8 +749,28 @@ namespace Ryujinx.HLE.HOS
             }
 
             List<Cheat> cheats = mods.Cheats;
-            Dictionary<string, ulong> processExes = tamperInfo.BuildIds.Zip(tamperInfo.CodeAddresses, (k, v) => new { k, v })
+            Dictionary<string, ulong> processExes = new();
-                .ToDictionary(x => x.k[..Math.Min(Cheat.CheatIdSize, x.k.Length)], x => x.v);
+
+            foreach ((string buildId, ulong codeAddress) in tamperInfo.BuildIds.Zip(tamperInfo.CodeAddresses))
+            {
+                string normalizedBuildId = buildId[..Math.Min(Cheat.CheatIdSize, buildId.Length)];
+
+                if (processExes.TryGetValue(normalizedBuildId, out ulong existingAddress))
+                {
+                    if (existingAddress != codeAddress)
+                    {
+                        Logger.Warning?.Print(
+                            LogClass.ModLoader,
+                            $"Duplicate BuildId prefix '{normalizedBuildId}' has different code addresses. " +
+                            $"Existing: 0x{existingAddress:X}, duplicate: 0x{codeAddress:X}. " +
+                            $"Keeping the first one.");
+                    }
+
+                    continue;
+                }
+
+                processExes.Add(normalizedBuildId, codeAddress);
+            }
 
             foreach (Cheat cheat in cheats)
             {

src/Ryujinx.HLE/HOS/Services/Account/Acc/IAccountServiceForApplication.cs

@@ -71,7 +71,14 @@ namespace Ryujinx.HLE.HOS.Services.Account.Acc
             return _applicationServiceServer.IsUserRegistrationRequestPermitted(context);
         }
 
-        [CommandCmif(51)]
+        [CommandCmif(51)] // 1.0.0 – 18.1.0
+        // TrySelectUserWithoutInteraction(bool) -> nn::account::Uid
+        public ResultCode TrySelectUserWithoutInteractionDeprecated(ServiceCtx context)
+        {
+            return _applicationServiceServer.TrySelectUserWithoutInteraction(context);
+        }
+
+        [CommandCmif(52)] // 19.0.0+
         // TrySelectUserWithoutInteraction(bool) -> nn::account::Uid
         public ResultCode TrySelectUserWithoutInteraction(ServiceCtx context)
         {

src/Ryujinx.HLE/HOS/Services/Am/AppletAE/AllSystemAppletProxiesService/SystemAppletProxy/ICommonStateGetter.cs

@@ -12,12 +12,23 @@ namespace Ryujinx.HLE.HOS.Services.Am.AppletAE.AllSystemAppletProxiesService.Sys
 {
     class ICommonStateGetter : DisposableIpcService
     {
+        // Nintendo serves the VR goggle commands based on Title ID, apparently.
+        private static ReadOnlySpan<ulong> _supportedVRGoggleTitles =>
+        [
+            0x0100CA001D972000, // Nintendo Classics: Virtual Boy NSO
+            0x0100BFC01D976000  // Nintendo Classics: Virtual Boy NSO
+        ];
+        
+        private int _resolutionWidth = 1280;
+        private int _resolutionHeight = 720;
+        
         private readonly ServiceCtx _context;
 
         private readonly Apm.ManagerServer _apmManagerServer;
         private readonly Apm.SystemManagerServer _apmSystemManagerServer;
 
         private bool _vrModeEnabled;
+        private bool _vrMode3dEnabled;
 #pragma warning disable CS0414, IDE0052 // Remove unread private member
         private bool _lcdBacklighOffEnabled;
         private bool _requestExitToLibraryAppletAtExecuteNextProgramEnabled;
@@ -153,6 +164,47 @@ namespace Ryujinx.HLE.HOS.Services.Am.AppletAE.AllSystemAppletProxiesService.Sys
             return ResultCode.Success;
         }
 
+        [CommandCmif(30)]
+        // GetHomeButtonReaderLockAccessor() -> nn::am::service::ILockAccessor
+        public ResultCode GetHomeButtonReaderLockAccessor(ServiceCtx context)
+        {
+            // We currently do not have any home button functionality, so it's fine to stub this for now.
+            // Similar to using GetReaderLockAccessorEx() with inval=0.
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+            MakeObject(context, new ILockAccessor(context));
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(31)] // 2.0.0 +
+        // GetReaderLockAccessorEx(uint unknown) -> nn::am::service::ILockAccessor
+        public ResultCode GetReaderLockAccessorEx(ServiceCtx context)
+        {
+            uint unknown = context.RequestData.ReadUInt32();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm, new { unknown });
+            if (unknown < 0 || unknown > 3)
+            {
+                throw new ArgumentOutOfRangeException(nameof(unknown));
+            }
+            
+            MakeObject(context, new ILockAccessor(context));
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(32)] // 2.0.0+
+        // GetWriterLockAccessorEx(uint unknown) -> nn::am::service::ILockAccessor
+        public ResultCode GetWriterLockAccessorEx(ServiceCtx context)
+        {
+            uint unknown = context.RequestData.ReadUInt32();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm, new { unknown });
+            if (unknown < 0 || unknown > 3)
+            {
+                throw new ArgumentOutOfRangeException(nameof(unknown));
+            }
+            
+            MakeObject(context, new ILockAccessor(context));
+            return ResultCode.Success;
+        }
+
         [CommandCmif(50)] // 3.0.0+
         // IsVrModeEnabled() -> b8
         public ResultCode IsVrModeEnabled(ServiceCtx context)
@@ -177,8 +229,8 @@ namespace Ryujinx.HLE.HOS.Services.Am.AppletAE.AllSystemAppletProxiesService.Sys
         // SetLcdBacklighOffEnabled(b8)
         public ResultCode SetLcdBacklighOffEnabled(ServiceCtx context)
         {
-            // NOTE: Service sets a private field here, maybe this field is used somewhere else to turned off the backlight.
+            // NOTE: Service sets a private field here, maybe this field is used somewhere else to turn off the backlight.
-            //       Since we don't support backlight, it's fine to do nothing.
+            //       Since we don't support the backlight feature, it's fine to stub it.
 
             _lcdBacklighOffEnabled = context.RequestData.ReadBoolean();
 
@@ -298,6 +350,22 @@ namespace Ryujinx.HLE.HOS.Services.Am.AppletAE.AllSystemAppletProxiesService.Sys
             return (ResultCode)_apmSystemManagerServer.GetCurrentPerformanceConfiguration(context);
         }
 
+        [CommandCmif(130)] // 21.0.0+
+        // EnableStartupLogoDisappearedMessage()
+        public ResultCode EnableStartupLogoDisappearedMessage(ServiceCtx context)
+        {
+            // NOTE: Service only delivers the message once the startup logo has actually
+            //       disappeared. We never display one, so it is already deliverable. Callers
+            //       gate their first frame on this message and hang without it.
+
+            AppletStateMgr appletState = context.Device.System.AppletState;
+
+            appletState.Messages.Enqueue(AppletMessage.StartupLogoDisappeared);
+            appletState.MessageEvent.ReadableEvent.Signal();
+
+            return ResultCode.Success;
+        }
+
         [CommandCmif(300)] // 9.0.0+
         // GetSettingsPlatformRegion() -> u8
         public ResultCode GetSettingsPlatformRegion(ServiceCtx context)
@@ -310,6 +378,15 @@ namespace Ryujinx.HLE.HOS.Services.Am.AppletAE.AllSystemAppletProxiesService.Sys
             return ResultCode.Success;
         }
 
+        [CommandCmif(610)] // 21.0.0+
+        // UnknownCommand610(long unknown)
+        public ResultCode UnknownCommand610(ServiceCtx context)
+        {
+            long unknown = context.RequestData.ReadInt64();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm, new { unknown });
+            return ResultCode.Success;
+        }
+
         [CommandCmif(900)] // 11.0.0+
         // SetRequestExitToLibraryAppletAtExecuteNextProgramEnabled()
         public ResultCode SetRequestExitToLibraryAppletAtExecuteNextProgramEnabled(ServiceCtx context)
@@ -320,6 +397,100 @@ namespace Ryujinx.HLE.HOS.Services.Am.AppletAE.AllSystemAppletProxiesService.Sys
             return ResultCode.Success;
         }
 
+        [CommandCmif(1000)] // 19.0.0+
+        // BeginVrMode3d()
+        public ResultCode BeginVrMode3d(ServiceCtx context)
+        {
+            // NOTE: Service also applies a stereo scale to the goggle display, which we don't
+            //       model, so only the state is kept here.
+
+            _vrMode3dEnabled = true;
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(1001)] // 19.0.0+
+        // EndVrMode3d()
+        public ResultCode EndVrMode3d(ServiceCtx context)
+        {
+            _vrMode3dEnabled = false;
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(1002)] // 19.0.0+
+        // IsVrModeEnabled3d() -> b8
+        public ResultCode IsVrModeEnabled3d(ServiceCtx context)
+        {
+            context.ResponseData.Write(_vrMode3dEnabled);
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(1003)] // 21.0.0+
+        // GetVrLaboGoggleViewport() -> (s32 x, s32 y, s32 width, s32 height)
+        public ResultCode GetVrLaboGoggleViewport(ServiceCtx context)
+        {
+            if (!IsVrLaboGoggleSupportedTitle(context))
+            {
+                return ResultCode.ObjectInvalid;
+            }
+            
+            int VrDisplayCoordinateX = 0;
+            int VrDisplayCoordinateY = 0;
+            int VrDisplayWidth = _resolutionWidth;
+            int VrDisplayHeight = _resolutionHeight;
+
+            context.ResponseData.Write(VrDisplayCoordinateX);
+            context.ResponseData.Write(VrDisplayCoordinateY);
+            context.ResponseData.Write(VrDisplayWidth);
+            context.ResponseData.Write(VrDisplayHeight);
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(1004)] // 21.0.0+
+        // GetPanelPhysicalSizeForSpecificTitle() -> (f32 width, f32 height)
+        public ResultCode GetPanelPhysicalSizeForSpecificTitle(ServiceCtx context)
+        {
+            if (!IsVrLaboGoggleSupportedTitle(context))
+            {
+                return ResultCode.ObjectInvalid;
+            }
+            
+            // The switch provides micrometres, but the command reports millimetres.
+            // 6.2 inch 16:9 panel.
+            float PanelPhysicalWidthMicroMeters = 137250f;
+            float PanelPhysicalHeightMicroMeters = 77200f;
+            
+            context.ResponseData.Write(PanelPhysicalWidthMicroMeters / 1000f);
+            context.ResponseData.Write(PanelPhysicalHeightMicroMeters / 1000f);
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(1005)] // 21.0.0+
+        // GetPanelResolutionForSpecificTitle() -> (s32 width, s32 height)
+        public ResultCode GetPanelResolutionForSpecificTitle(ServiceCtx context)
+        {
+            if (!IsVrLaboGoggleSupportedTitle(context))
+            {
+                return ResultCode.ObjectInvalid;
+            }
+            
+            context.ResponseData.Write(_resolutionWidth);
+            context.ResponseData.Write(_resolutionHeight);
+
+            return ResultCode.Success;
+        }
+
+        private static bool IsVrLaboGoggleSupportedTitle(ServiceCtx context)
+        {
+            ulong programId = context.Device.Processes.ActiveApplication.ProgramId;
+
+            return _supportedVRGoggleTitles.Contains(programId);
+        }
+
         protected override void Dispose(bool isDisposing)
         {
             if (isDisposing)

src/Ryujinx.HLE/HOS/Services/Am/AppletAE/AllSystemAppletProxiesService/SystemAppletProxy/ILibraryAppletCreator.cs

@@ -21,6 +21,21 @@ namespace Ryujinx.HLE.HOS.Services.Am.AppletAE.AllSystemAppletProxiesService.Sys
             return ResultCode.Success;
         }
 
+        [CommandCmif(3)] // 20.0.0+
+        // CreateLibraryAppletEx(u32, u32, u64) -> object<nn::am::service::ILibraryAppletAccessor>
+        public ResultCode CreateLibraryAppletEx(ServiceCtx context)
+        {
+            AppletId appletId = (AppletId)context.RequestData.ReadInt32();
+
+            _ = context.RequestData.ReadInt32(); // libraryAppletMode
+
+            _ = context.RequestData.ReadUInt64(); // threadId
+
+            MakeObject(context, new ILibraryAppletAccessor(appletId, context.Device.System));
+
+            return ResultCode.Success;
+        }
+
         [CommandCmif(10)]
         // CreateStorage(u64) -> object<nn::am::service::IStorage>
         public ResultCode CreateStorage(ServiceCtx context)

src/Ryujinx.HLE/HOS/Services/Am/AppletAE/AllSystemAppletProxiesService/SystemAppletProxy/ILockAccessor.cs

@@ -0,0 +1,80 @@
+using Ryujinx.Common.Logging;
+using Ryujinx.HLE.HOS.Ipc;
+using Ryujinx.HLE.HOS.Kernel.Threading;
+using Ryujinx.Horizon.Common;
+using System;
+
+namespace Ryujinx.HLE.HOS.Services.Am.AppletAE.AllSystemAppletProxiesService.SystemAppletProxy
+{
+    class ILockAccessor : IpcService
+    {
+        private readonly ServiceCtx _context;
+
+        private readonly Apm.ManagerServer _apmManagerServer;
+        private readonly Apm.SystemManagerServer _apmSystemManagerServer;
+        
+        private readonly KEvent _lockEvent;
+        private int _lockEventHandle;
+
+        public ILockAccessor(ServiceCtx context)
+        {
+            
+            _context = context;
+            
+            _apmManagerServer = new Apm.ManagerServer(context);
+            _apmSystemManagerServer = new Apm.SystemManagerServer(context);
+
+            _lockEvent = new KEvent(context.Device.System.KernelContext);
+        }
+
+        [CommandCmif(1)]
+        // TryLock(unknown u8 bool) -> unknown u8 bool
+        public ResultCode TryLock(ServiceCtx context)
+        {
+            // Official sw only uses inflag=false.
+            // Official sw just closes the output handle.
+            // The input flag controls whether this returns the output handle. 
+            bool unknown = context.RequestData.ReadBoolean();
+            Logger.Stub?.PrintStub(LogClass.ServiceAm, new { unknown });
+            
+            context.ResponseData.Write(false);
+            context.Response.HandleDesc = IpcHandleDesc.MakeCopy(_lockEventHandle);
+            
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(2)]
+        // Unlock()
+        public ResultCode Unlock(ServiceCtx context)
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(3)]
+        // GetEvent() -> EventHandle w/ autoclear = false
+        public ResultCode GetEvent(ServiceCtx context)
+        {
+            if (_lockEventHandle == 0)
+            {
+                if (context.Process.HandleTable.GenerateHandle(_lockEvent.ReadableEvent, out _lockEventHandle) != Result.Success)
+                {
+                    throw new InvalidOperationException("Out of handles!");
+                }
+            }
+            
+            context.Response.HandleDesc = IpcHandleDesc.MakeCopy(_lockEventHandle);
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(4)] // 10.0.0+
+        // IsLocked() -> unknown u8 bool
+        public ResultCode IsLocked(ServiceCtx context)
+        {
+            Logger.Stub?.PrintStub(LogClass.ServiceAm);
+            context.ResponseData.Write(false);
+            return ResultCode.Success;
+        }
+    }
+}

src/Ryujinx.HLE/HOS/Services/Am/AppletAE/AllSystemAppletProxiesService/SystemAppletProxy/Types/AppletMessage.cs

@@ -32,5 +32,6 @@ namespace Ryujinx.HLE.HOS.Services.Am.AppletAE.AllSystemAppletProxiesService.Sys
         DetectShortPressingCaptureButton = 90,
         AlbumScreenShotTaken = 92,
         AlbumRecordingSaved = 93,
+        StartupLogoDisappeared = 95, // 21.0.0+
     }
 }

src/Ryujinx.HLE/HOS/Services/Hid/HidDevices/NpadDevices.cs

@@ -23,7 +23,7 @@ namespace Ryujinx.HLE.HOS.Services.Hid
         private readonly bool[] _supportedPlayers;
         private VibrationValue _neutralVibrationValue = new()
         {
-            AmplitudeLow = 0f,
+            AmplitudeLow = 0.01f,
             FrequencyLow = 160f,
             AmplitudeHigh = 0f,
             FrequencyHigh = 320f,

src/Ryujinx.HLE/HOS/Services/Hid/Types/SharedMemory/Npad/NpadCondition.cs

@@ -0,0 +1,23 @@
+namespace Ryujinx.HLE.HOS.Services.Hid.Types.SharedMemory.Npad
+{
+    struct NpadCondition
+    {
+#pragma warning disable CS0414 // Field is assigned but its value is never used
+        private uint _00;
+        private uint _04;
+        private NpadJoyHoldType _holdType;
+        private uint _0C;
+#pragma warning restore CS0414 // Field is assigned but its value is never used
+        
+        public static NpadCondition Create()
+        {
+            return new NpadCondition()
+            {
+                _00 = 0,
+                _04 = 1,
+                _holdType = NpadJoyHoldType.Horizontal,
+                _0C = 1,
+            };
+        }
+    }
+}

src/Ryujinx.HLE/HOS/Services/Hid/Types/SharedMemory/SharedMemory.cs

@@ -46,6 +46,12 @@ namespace Ryujinx.HLE.HOS.Services.Hid.Types.SharedMemory
         [FieldOffset(0x9A00)]
         public Array10<NpadState> Npads;
 
+        /// <summary>
+        /// Pad Condition.
+        /// </summary>
+        [FieldOffset(0x3e200)]
+        public NpadCondition Condition;
+
         public static SharedMemory Create()
         {
             SharedMemory result = new()
@@ -54,6 +60,7 @@ namespace Ryujinx.HLE.HOS.Services.Hid.Types.SharedMemory
                 TouchScreen = RingLifo<TouchScreenState>.Create(),
                 Mouse = RingLifo<MouseState>.Create(),
                 Keyboard = RingLifo<KeyboardState>.Create(),
+                Condition = NpadCondition.Create(),
             };
             
             Span<NpadState> npadsSpan = result.Npads.AsSpan();

src/Ryujinx.HLE/Loaders/Processes/ProcessLoader.cs

@@ -24,7 +24,16 @@ namespace Ryujinx.HLE.Loaders.Processes
 
         private ulong _latestPid;
 
-        public ProcessResult ActiveApplication => _processesByPid[_latestPid];
+        public ProcessResult ActiveApplication
+        {
+            get
+            {
+                if (_latestPid != 0 && _processesByPid.TryGetValue(_latestPid, out ProcessResult process))
+                    return process;
+
+                return null;
+            }
+        }
 
         public ProcessLoader(Switch device)
         {

src/Ryujinx.HLE/Loaders/Processes/ProcessLoaderHelper.cs

@@ -183,8 +183,10 @@ namespace Ryujinx.HLE.Loaders.Processes
             ArmProcessContextFactory processContextFactory = new(
                 context.Device.System.TickSource,
                 context.Device.Gpu,
-                string.Empty,
+                kip.ProgramId,
-                string.Empty,
+                0,
+                kip.Version.ToString(),
+                ProcessResult.GetProcessKind(kip.ProgramId),
                 false,
                 null,
                 codeAddress,
@@ -392,8 +394,10 @@ namespace Ryujinx.HLE.Loaders.Processes
             ArmProcessContextFactory processContextFactory = new(
                 context.Device.System.TickSource,
                 context.Device.Gpu,
-                $"{programId:x16}",
+                programId,
+                programIndex,
                 displayVersion,
+                ProcessResult.GetProcessKind(programId),
                 diskCacheEnabled,
                 diskCacheSelector,
                 codeStart,

src/Ryujinx.HLE/Loaders/Processes/ProcessResult.cs

@@ -87,7 +87,7 @@ namespace Ryujinx.HLE.Loaders.Processes
             AllowCodeMemoryForJit = allowCodeMemoryForJit;
         }
 
-        private static ProcessKind GetProcessKind(ulong programId)
+        internal static ProcessKind GetProcessKind(ulong programId)
         {
             if (programId == 0)
             {

src/Ryujinx.Input.SDL3/NpadHdRumble.cs

@@ -1,3 +1,4 @@
+using Ryujinx.Common.Logging;
 using Ryujinx.HLE.HOS.Services.Hid;
 using SDL;
 using static SDL.SDL3;
@@ -12,140 +13,276 @@ namespace Ryujinx.Input.SDL3
     {
         private readonly SDL_hid_device* _hidHandle;
 
+        private byte[] _buffer;
+        private static ushort _vendor;
+        private static ushort _product;
+        
         private int _globalCount;
+        private ulong _lastWriteTicks;
 
         private NpadHdRumble(SDL_hid_device* hidHandle)
         {
             _hidHandle = hidHandle;
+            InitializeDevice();
         }
 
         public static NpadHdRumble Create(SDL_Gamepad* gamepadHandle)
         {
-            ushort vendor = SDL_GetGamepadVendor(gamepadHandle);
+            _vendor = SDL_GetGamepadVendor(gamepadHandle);
-            if (vendor != 0x057e)
+            if (!Enum.IsDefined(typeof(HDRumbleSupportedVendor), _vendor))
             {
                 return null;
             }
 
-            ushort product = SDL_GetGamepadProduct(gamepadHandle);
+            _product = SDL_GetGamepadProduct(gamepadHandle);
-            if (product != 0x2006 && product != 0x2007 && product != 0x2009 && product != 0x200e)
+            if (!Enum.IsDefined(typeof(HDRumbleSupportedProduct), _product))
             {
                 return null;
             }
 
-            return new NpadHdRumble(SDL_hid_open(vendor, product, 0));
+            int serialNumber = 0;
+            string? serial = SDL_GetGamepadSerial(gamepadHandle);
+            if (serial is not null)
+            {
+                int.TryParse(serial, out serialNumber);
+            }
+            
+            return new NpadHdRumble(SDL_hid_open(_vendor, _product, serialNumber));
         }
 
         // Some of the code was translated from https://github.com/MIZUSHIKI/JoyShockLibrary-plus-HDRumble
-        private void WriteHdRumble(
+        private bool WriteNintendoHdRumble(VibrationValue left, VibrationValue right)
-            int encLeftLowFreq, int encLeftLowAmp,
-            int encLeftHighFreq, int encLeftHighAmp,
-            int encRightLowFreq, int encRightLowAmp,
-            int encRightHighFreq, int encRightHighAmp)
         {
-            byte[] buf = new byte[10];
+            int leftLowAmp = EncodeLowAmp(left.AmplitudeLow);
+            int leftLowFreq = EncodeLowFreq(left.FrequencyLow) + (leftLowAmp >> 8);
+            int leftHighFreq = EncodeHighFreq(left.FrequencyHigh);
+            int leftHighAmp = EncodeHighAmp(left.AmplitudeHigh) + (leftHighFreq >> 8);
                 
-            buf[0] = 0x10;
+            int rightLowAmp = EncodeLowAmp(right.AmplitudeLow);
-            buf[1] = (byte)((++_globalCount) & 0xF);
+            int rightLowFreq = EncodeLowFreq(right.FrequencyLow) + (rightLowAmp >> 8);
+            int rightHighFreq = EncodeHighFreq(right.FrequencyHigh);
+            int rightHighAmp = EncodeHighAmp(right.AmplitudeHigh) + (rightHighFreq >> 8);
             
-            buf[2] = (byte)(encLeftHighFreq & 0xFF);
+            _buffer[0] = 0x10;
-            buf[3] = (byte)(encLeftHighAmp + ((encLeftHighFreq >> 8) & 0xFF));
+            _buffer[1] = (byte)((_globalCount++) & 0xF);
-            buf[4] = (byte)(encLeftLowFreq + ((encLeftLowAmp >> 8) & 0xFF));
-            buf[5] = (byte)(encLeftLowAmp & 0xFF);
             
-            buf[6] = (byte)(encRightHighFreq & 0xFF);
+            // Left LRA
-            buf[7] = (byte)(encRightHighAmp + ((encRightHighFreq >> 8) & 0xFF));
+            _buffer[2] = (byte)(leftLowFreq & 0xFF);
-            buf[8] = (byte)(encRightLowFreq + ((encRightLowAmp >> 8) & 0xFF));
+            _buffer[3] = (byte)(leftHighAmp & 0xFF);
-            buf[9] = (byte)(encRightLowAmp & 0xFF);
+            _buffer[4] = (byte)(leftHighFreq & 0xFF);
+            _buffer[5] = (byte)(leftLowAmp & 0xFF);
+            
+            // Right LRA
+            _buffer[6] = (byte)(rightLowFreq & 0xFF);
+            _buffer[7] = (byte)(rightHighAmp & 0xFF);
+            _buffer[8] = (byte)(rightHighFreq & 0xFF);
+            _buffer[9] = (byte)(rightLowAmp & 0xFF);
             
             if (_globalCount > 0xF)
             {
                 _globalCount = 0x0;
             }
             
-            fixed (byte* ptr = buf)
+            fixed (byte* ptr = _buffer)
             {
-                SDL_hid_write(_hidHandle, ptr, (nuint)buf.Length);
+                if (SendHdRumble(ptr, (nuint)_buffer.Length) >= 0)
-            }
+                {
-        }
+                    return true;
+                }
                 
+                Logger.Error?.PrintMsg(LogClass.Hid, SDL_GetError());
+                SDL_ClearError();
+            }
+            
+            return false;
+        }
 
         private static int EncodeLowFreq(float lowFreq)
         {
-            float lf = Math.Clamp(lowFreq, 40.875885f, 626.286133f);
+            return (int)Math.Clamp(32 * Math.Log2(lowFreq * 0.1f) - 0x40, 81.75177f, 1252.572266f);
-            return (int)Math.Round(32 * Math.Log2(lf * 0.1f)) - 0x40;
         }
 
         private static int EncodeHighFreq(float highFreq)
         {
-            float hf = Math.Clamp(highFreq, 81.75177f, 1252.572266f);
+            return (int)Math.Clamp(32 * Math.Log2(highFreq * 0.1f) - 0x60, 81.75177f, 1252.572266f);
-            return ((int)Math.Round(32 * Math.Log2(hf * 0.1f)) - 0x60) * 4;
         }
 
         private static int EncodeLowAmp(float rawAmp)
         {
-            int encodedAmp = 0;
+            double encodedAmp = 0;
 
             if (rawAmp is > 0 and < 0.012f)
-            {
                 encodedAmp = 1;
-            }
-            else if (rawAmp is >= 0.012f and < 0.112f)
-            {
-                encodedAmp = (int)Math.Round(4 * Math.Log2(rawAmp * 110f));
-            }
-            else if (rawAmp is >= 0.112f and < 0.225f)
-            {
-                encodedAmp = (int)Math.Round(16 * Math.Log2(rawAmp * 17f));
-            }
-            else if (rawAmp is >= 0.225f and <= 1f)
-            {
-                encodedAmp = (int)Math.Round(32 * Math.Log2(rawAmp * 8.7f));
-            }
             
-            return (int)Math.Floor(encodedAmp / 2.0) + 64;
+            else if (rawAmp is >= 0.012f and < 0.112f)
+                encodedAmp = 4 * Math.Log2(rawAmp * 110f);
+            
+            else if (rawAmp is >= 0.112f and < 0.225f)
+                encodedAmp = 16 * Math.Log2(rawAmp * 17f);
+            
+            else if (rawAmp is >= 0.225f and <= 1f)
+                encodedAmp = 32 * Math.Log2(rawAmp * 8.7f);
+            
+            encodedAmp = Math.Round((encodedAmp / 2.0) + 64.0);
+            encodedAmp = Math.Clamp(encodedAmp, 0.0, 100.2867);
+            return (int)Math.Round(encodedAmp);
         }
 
         private static int EncodeHighAmp(float rawAmp)
         {
-            int encodedAmp = 0;
+            double encodedAmp = 0;
 
             if (rawAmp is > 0 and < 0.012f)
-            {
                 encodedAmp = 1;
-            }
-            else if (rawAmp is >= 0.012f and < 0.112f)
-            {
-                encodedAmp = (int)Math.Round(4 * Math.Log2(rawAmp * 110f));
-            }
-            else if (rawAmp is >= 0.112f and < 0.225f)
-            {
-                encodedAmp = (int)Math.Round(16 * Math.Log2(rawAmp * 17f));
-            }
-            else if (rawAmp is >= 0.225f and <= 1f)
-            {
-                encodedAmp = (int)Math.Round(32 * Math.Log2(rawAmp * 8.7f));
-            }
             
-            return encodedAmp * 2;
+            else if (rawAmp is >= 0.012f and < 0.112f)
+                encodedAmp = 4 * Math.Log2(rawAmp * 110f);
+            
+            else if (rawAmp is >= 0.112f and < 0.225f)
+                encodedAmp = 16 * Math.Log2(rawAmp * 17f);
+            
+            else if (rawAmp is >= 0.225f and <= 1f)
+                encodedAmp = 32 * Math.Log2(rawAmp * 8.7f);
+            
+            encodedAmp = Math.Round(encodedAmp / 2.0);
+            encodedAmp = Math.Clamp(encodedAmp, 0.0, 100.2867);
+            return (int)encodedAmp;
         }
 
         public bool HdRumble(VibrationValue left, VibrationValue right)
         {
-            WriteHdRumble(EncodeLowFreq(left.FrequencyLow),
+            if(_product is (ushort) HDRumbleSupportedProduct.ProController
-                EncodeLowAmp(left.AmplitudeLow),
+               or (ushort) HDRumbleSupportedProduct.JoyconLeft
-                EncodeHighFreq(left.FrequencyHigh),
+               or (ushort) HDRumbleSupportedProduct.JoyconRight
-                EncodeHighAmp(left.AmplitudeHigh),
+               or (ushort) HDRumbleSupportedProduct.JoyconPair
-                EncodeLowFreq(right.FrequencyLow),
+               or (ushort) HDRumbleSupportedProduct.JoyconGrip)
-                EncodeLowAmp(right.AmplitudeLow),
+            {
-                EncodeHighFreq(right.FrequencyHigh),
+                return WriteNintendoHdRumble(left, right);
-                EncodeHighAmp(right.AmplitudeHigh));
+            }
-            return true;
+
+            return false;
+        }
+
+        private int SendHdRumble(byte* data, nuint length)
+        {
+            int result = 0;
+            ulong currentTicks = SDL_GetTicks();
+
+            // Ditch rumble if we haven't hit the poll-rate yet.
+            if ((currentTicks - _lastWriteTicks) <= GetPollRate())
+            {
+                return result;
+            }
+            
+            result = SDL_hid_write(_hidHandle, data, length);
+            if (result >= 0)
+            {
+                _lastWriteTicks = currentTicks;
+            }
+            
+            return result;
+        }
+
+        private void InitializeDevice()
+        {
+            if (_vendor is (ushort)HDRumbleSupportedVendor.Nintendo)
+            {
+                _buffer = new byte[10];
+                byte[] init = new byte[64];
+
+                // Pro Controller and Charge Grip
+                if (_product 
+                    is (ushort)HDRumbleSupportedProduct.ProController 
+                    or (ushort)HDRumbleSupportedProduct.JoyconGrip)
+                {
+                    SDL_LockJoysticks();
+                    fixed (byte* ptr = init)
+                    {
+                        init[0] = 0x80;
+                        init[1] = 0x05; // Allow bluetooth timeout TODO: use 0x04 to force USB only (toggle?)
+                        SDL_hid_write(_hidHandle, ptr, 64);
+                    }
+                    SDL_UnlockJoysticks();
+                
+                    return;
+                }
+            
+                // Joycons
+                if (_product 
+                    is (ushort)HDRumbleSupportedProduct.JoyconLeft 
+                    or (ushort)HDRumbleSupportedProduct.JoyconRight
+                    or (ushort)HDRumbleSupportedProduct.JoyconPair)
+                {
+                
+                    SDL_LockJoysticks();
+                    fixed (byte* ptr = init)
+                    {
+                        // we could write data to the controller here (see above)
+                    }
+                    SDL_UnlockJoysticks();
+                    
+                    return;
+                }
+            }
+        }
+        
+        private ulong GetPollRate()
+        {
+            ulong pollRate = 0;
+            if (_vendor is (ushort)HDRumbleSupportedVendor.Nintendo)
+            {
+                // https://docs.handheldlegend.com/s/progcc-3/doc/lag-comparison-aAR1mV3JLX
+                pollRate = (ulong) 16.67;
+                if (_product is (ushort)HDRumbleSupportedProduct.ProController
+                    && SDL_hid_get_device_info(_hidHandle)->bus_type == SDL_hid_bus_type.SDL_HID_API_BUS_USB)
+                {
+                    pollRate = (ulong) 8.33;
+                }
+            }
+            
+            return pollRate;
         }
 
         public void Dispose()
         {
+            GC.SuppressFinalize(this);
             SDL_hid_close(_hidHandle);
         }
     }
+
+    public enum HDRumbleSupportedVendor : ushort
+    {
+        Nintendo = 0x057e,
+        Valve = 0x28de,
+        Sony = 0x054c
+    }
+
+    public enum HDRumbleSupportedProduct : ushort
+    {
+        // TODO: Currently, HD Rumble only supports the Pro Controller and JoyCons.
+        //       We need to initialize and report to each device differently.
+        
+        // Nintendo Switch: 0x057e
+        JoyconLeft = 0x2006,
+        JoyconRight = 0x2007,
+        JoyconPair = 0x2008,
+        ProController = 0x2009,
+        JoyconGrip = 0x200e,
+        
+        // Nintendo Switch 2: 0x057e
+        Joycon2Right = 0x2066,
+        Joycon2Left = 0x2067,
+        Joycon2Pair = 0x2068,
+        Switch2ProController = 0x2069,
+        GamecubeController = 0x2073,
+        
+        // Valve Steam Family: 0x28de
+        // https://github.com/libsdl-org/SDL/issues/9148
+        SteamDeck = 0x11ff,
+        SteamDeckVirtualDevice = 0x1205,
+        SteamController = 0x1106,
+        
+        // PlayStation Dualsense: 0x054c
+        Dualsense = 0x0ce6
+    }
 }

src/Ryujinx.Input.SDL3/SDL3Gamepad.cs

@@ -177,10 +177,12 @@ namespace Ryujinx.Input.SDL3
             return _hdRumble?.HdRumble(left, right) ?? false;
         }
 
-        public void Rumble(float lowFrequency, float highFrequency, uint durationMs)
+        public bool Rumble(float lowFrequency, float highFrequency, uint durationMs)
         {
             if ((Features & GamepadFeaturesFlag.Rumble) == 0)
-                return;
+            {
+                return false;
+            }
 
             ushort lowFrequencyRaw = (ushort)(lowFrequency * ushort.MaxValue);
             ushort highFrequencyRaw = (ushort)(highFrequency * ushort.MaxValue);
@@ -199,6 +201,15 @@ namespace Ryujinx.Input.SDL3
                 if (!SDL_RumbleGamepad(_gamepadHandle, lowFrequencyRaw, highFrequencyRaw, durationMs))
                     Logger.Error?.Print(LogClass.Hid, "Rumble is not supported on this game controller.");
             }
+            
+            if (!String.IsNullOrEmpty(SDL_GetError()))
+            {
+                Logger.Error?.PrintMsg(LogClass.Hid, SDL_GetError());
+                SDL_ClearError();
+                return false;
+            }
+
+            return true;
         }
 
         public Vector3 GetMotionData(MotionInputId inputId)

src/Ryujinx.Input.SDL3/SDL3JoyCon.cs

@@ -163,7 +163,7 @@ namespace Ryujinx.Input.SDL3
 
         public void SetTriggerThreshold(float triggerThreshold)
         {
-
+            // No operations
         }
         
         public bool HDRumble(VibrationValue left, VibrationValue right)
@@ -171,10 +171,12 @@ namespace Ryujinx.Input.SDL3
             return _hdRumble?.HdRumble(left, right) ?? false;
         }
 
-        public void Rumble(float lowFrequency, float highFrequency, uint durationMs)
+        public bool Rumble(float lowFrequency, float highFrequency, uint durationMs)
         {
             if ((Features & GamepadFeaturesFlag.Rumble) == 0)
-                return;
+            {
+                return false;
+            }
 
             ushort lowFrequencyRaw = (ushort)(lowFrequency * ushort.MaxValue);
             ushort highFrequencyRaw = (ushort)(highFrequency * ushort.MaxValue);
@@ -193,6 +195,15 @@ namespace Ryujinx.Input.SDL3
                 if (!SDL_RumbleGamepad(_gamepadHandle, lowFrequencyRaw, highFrequencyRaw, durationMs))
                     Logger.Error?.Print(LogClass.Hid, "Rumble is not supported on this game controller.");
             }
+            
+            if (!String.IsNullOrEmpty(SDL_GetError()))
+            {
+                Logger.Error?.PrintMsg(LogClass.Hid, SDL_GetError());
+                SDL_ClearError();
+                return false;
+            }
+
+            return true;
         }
 
         public Vector3 GetMotionData(MotionInputId inputId)

src/Ryujinx.Input.SDL3/SDL3JoyConPair.cs

@@ -1,4 +1,7 @@
-using Ryujinx.Common.Configuration.Hid;
+using Gommon;
+using Ryujinx.Common.Configuration.Hid;
+using Ryujinx.Common.Logging;
+using Ryujinx.HLE.HOS.Services.Hid;
 using System.Collections.Generic;
 using System.Linq;
 using System.Numerics;
@@ -61,7 +64,14 @@ namespace Ryujinx.Input.SDL3
             return left.IsPressed(inputId) || right.IsPressed(inputId);
         }
 
-        public void Rumble(float lowFrequency, float highFrequency, uint durationMs)
+        public bool HDRumble(VibrationValue left, VibrationValue right)
+        {
+            // return _hdRumble?.HdRumble(left, right) ?? false;
+            // TODO: Track rumble and motion on both controllers
+            return false;
+        }
+
+        public bool Rumble(float lowFrequency, float highFrequency, uint durationMs)
         {
             if (lowFrequency != 0)
             {
@@ -78,6 +88,15 @@ namespace Ryujinx.Input.SDL3
                 left.Rumble(0, 0, durationMs);
                 right.Rumble(0, 0, durationMs);
             }
+
+            if (!SDL_GetError().IsNullOrEmpty())
+            {
+                Logger.Error?.PrintMsg(LogClass.Hid, SDL_GetError());
+                SDL_ClearError();
+                return false;
+            }
+
+            return true;
         }
 
         public void SetConfiguration(InputConfig configuration)

src/Ryujinx.Input.SDL3/SDL3Keyboard.cs

@@ -1,6 +1,7 @@
 using Ryujinx.Common.Configuration.Hid;
 using Ryujinx.Common.Configuration.Hid.Keyboard;
 using SDL;
+using Ryujinx.HLE.HOS.Services.Hid;
 using System;
 using System.Collections.Generic;
 using System.Numerics;
@@ -385,9 +386,14 @@ namespace Ryujinx.Input.SDL3
             // No operations
         }
 
-        public void Rumble(float lowFrequency, float highFrequency, uint durationMs)
+        public bool HDRumble(VibrationValue left, VibrationValue right)
         {
-            // No operations
+            return false;
+        }
+        
+        public bool Rumble(float lowFrequency, float highFrequency, uint durationMs)
+        {
+            return false;
         }
 
         public Vector3 GetMotionData(MotionInputId inputId)

src/Ryujinx.Input.SDL3/SDL3Mouse.cs

@@ -1,4 +1,5 @@
 using Ryujinx.Common.Configuration.Hid;
+using Ryujinx.HLE.HOS.Services.Hid;
 using System;
 using System.Drawing;
 using System.Numerics;
@@ -66,7 +67,12 @@ namespace Ryujinx.Input.SDL3
             throw new NotImplementedException();
         }
 
-        public void Rumble(float lowFrequency, float highFrequency, uint durationMs)
+        public bool HDRumble(VibrationValue left, VibrationValue right)
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool Rumble(float lowFrequency, float highFrequency, uint durationMs)
         {
             throw new NotImplementedException();
         }

src/Ryujinx.Input/HLE/NpadController.cs

@@ -554,34 +554,38 @@ namespace Ryujinx.Input.HLE
         {
             if (queue.TryDequeue(out (VibrationValue, VibrationValue) dualVibrationValue))
             {
-                if (_config is StandardControllerInputConfig controllerConfig && controllerConfig.Rumble.EnableRumble)
+                if (_config is not StandardControllerInputConfig controllerConfig ||
+                    !controllerConfig.Rumble.EnableRumble)
                 {
-                    VibrationValue leftVibrationValue = dualVibrationValue.Item1;
+                    return;
-                    VibrationValue rightVibrationValue = dualVibrationValue.Item2;
-                    
-                    float low = Math.Min(1f, (float)((rightVibrationValue.AmplitudeLow * 0.85 + rightVibrationValue.AmplitudeHigh * 0.15) * controllerConfig.Rumble.StrongRumble));
-                    float high = Math.Min(1f, (float)((leftVibrationValue.AmplitudeLow * 0.15 + leftVibrationValue.AmplitudeHigh * 0.85) * controllerConfig.Rumble.WeakRumble));
-                    
-                    leftVibrationValue.AmplitudeLow *= controllerConfig.Rumble.WeakRumble;
-                    leftVibrationValue.AmplitudeHigh *= controllerConfig.Rumble.StrongRumble;
-                    rightVibrationValue.AmplitudeLow *= controllerConfig.Rumble.WeakRumble;
-                    rightVibrationValue.AmplitudeHigh *= controllerConfig.Rumble.StrongRumble;
-
-                    if (_gamepad?.HDRumble(leftVibrationValue, rightVibrationValue) == false)
-                    {
-                        _gamepad.Rumble(low, high, uint.MaxValue);
-                    }
-
-                    Logger.Debug?.Print(LogClass.Hid, $"Effect for {controllerConfig.PlayerIndex} " +
-                        $"L.low.amp={leftVibrationValue.AmplitudeLow}, " +
-                        $"L.high.amp={leftVibrationValue.AmplitudeHigh}, " +
-                        $"L.low.freq={leftVibrationValue.FrequencyLow}, " +
-                        $"L.high.freq={leftVibrationValue.FrequencyHigh}, " +
-                        $"R.low.amp={rightVibrationValue.AmplitudeLow}, " +
-                        $"R.high.amp={rightVibrationValue.AmplitudeHigh} " +
-                        $"R.low.freq={rightVibrationValue.FrequencyLow}, " +
-                        $"R.high.freq={rightVibrationValue.FrequencyHigh}");
                 }
+
+                VibrationValue leftVibrationValue = dualVibrationValue.Item1;
+                VibrationValue rightVibrationValue = dualVibrationValue.Item2;
+
+                float low = Math.Min(1f, (float)((rightVibrationValue.AmplitudeLow * 0.85 + rightVibrationValue.AmplitudeHigh * 0.15)));
+                float high = Math.Min(1f, (float)((leftVibrationValue.AmplitudeLow * 0.15 + leftVibrationValue.AmplitudeHigh * 0.85)));
+
+                leftVibrationValue.AmplitudeLow *= controllerConfig.Rumble.WeakRumble;
+                leftVibrationValue.AmplitudeHigh *= controllerConfig.Rumble.StrongRumble;
+                rightVibrationValue.AmplitudeLow *= controllerConfig.Rumble.WeakRumble;
+                rightVibrationValue.AmplitudeHigh *= controllerConfig.Rumble.StrongRumble;
+
+                if (!controllerConfig.Rumble.UseHDRumble || !_gamepad.HDRumble(leftVibrationValue, rightVibrationValue))
+                {
+                    _gamepad.Rumble(low, high, 0xFFFFFFFF);
+                }
+
+                Logger.Debug?.Print(LogClass.Hid, $"Effect for {controllerConfig.PlayerIndex} " + 
+                    // Value=value/multiplier * multiplier (result)
+                    $"L.low.amp={leftVibrationValue.AmplitudeLow / controllerConfig.Rumble.WeakRumble} * {controllerConfig.Rumble.WeakRumble} ({leftVibrationValue.AmplitudeLow}), " +
+                    $"L.high.amp={leftVibrationValue.AmplitudeHigh / controllerConfig.Rumble.StrongRumble} * {controllerConfig.Rumble.StrongRumble} ({leftVibrationValue.AmplitudeHigh}), " +
+                    $"L.low.freq={leftVibrationValue.FrequencyLow / controllerConfig.Rumble.WeakRumble} * {controllerConfig.Rumble.WeakRumble} ({leftVibrationValue.FrequencyLow}), " +
+                    $"L.high.freq={leftVibrationValue.FrequencyHigh / controllerConfig.Rumble.StrongRumble} * {controllerConfig.Rumble.StrongRumble} ({leftVibrationValue.FrequencyHigh}), " +
+                    $"R.low.amp={rightVibrationValue.AmplitudeLow / controllerConfig.Rumble.WeakRumble} * {controllerConfig.Rumble.WeakRumble} ({rightVibrationValue.AmplitudeLow}), " +
+                    $"R.high.amp={rightVibrationValue.AmplitudeHigh / controllerConfig.Rumble.StrongRumble} * {controllerConfig.Rumble.StrongRumble} ({rightVibrationValue.AmplitudeHigh}), " +
+                    $"R.low.freq={rightVibrationValue.FrequencyLow / controllerConfig.Rumble.WeakRumble} * {controllerConfig.Rumble.WeakRumble} ({rightVibrationValue.FrequencyLow}), " +
+                    $"R.high.freq={rightVibrationValue.FrequencyHigh / controllerConfig.Rumble.StrongRumble} * {controllerConfig.Rumble.StrongRumble} ({rightVibrationValue.FrequencyHigh})");
             }
         }
     }

src/Ryujinx.Input/IGamepad.cs

@@ -71,10 +71,7 @@ namespace Ryujinx.Input
         /// </summary>
         /// <param name="left">The vibration data for the left side</param>
         /// <param name="right">The vibration data for the right side</param>
-        bool HDRumble(VibrationValue left, VibrationValue right)
+        bool HDRumble(VibrationValue left, VibrationValue right);
-        {
-            return false;
-        }
 
         /// <summary>
         /// Starts a rumble effect on the gamepad.
@@ -82,10 +79,10 @@ namespace Ryujinx.Input
         /// <param name="lowFrequency">The intensity of the low frequency from 0.0f to 1.0f</param>
         /// <param name="highFrequency">The intensity of the high frequency from 0.0f to 1.0f</param>
         /// <param name="durationMs">The duration of the rumble effect in milliseconds.</param>
-        void Rumble(float lowFrequency, float highFrequency, uint durationMs);
+        bool Rumble(float lowFrequency, float highFrequency, uint durationMs);
 
         /// <summary>
-        /// Get a snaphost of the state of the gamepad that is remapped with the informations from the <see cref="InputConfig"/> set via <see cref="SetConfiguration(InputConfig)"/>.
+        /// Get a snaphost of the state of the gamepad that is remapped with the information from the <see cref="InputConfig"/> set via <see cref="SetConfiguration(InputConfig)"/>.
         /// </summary>
         /// <returns>A remapped snaphost of the state of the gamepad.</returns>
         GamepadStateSnapshot GetMappedStateSnapshot();

src/Ryujinx.UI.Common/Configuration/ConfigurationState.cs

@@ -1323,6 +1323,7 @@ namespace Ryujinx.UI.Common.Configuration
                             EnableRumble = false,
                             StrongRumble = 1f,
                             WeakRumble = 1f,
+                            UseHDRumble = false
                         };
                     }
                 }

src/Ryujinx/AppHost.cs

@@ -43,6 +43,7 @@ using Ryujinx.UI.Common.Configuration;
 using Ryujinx.UI.Common.Helper;
 using Silk.NET.Vulkan;
 using SkiaSharp;
+using SPB.Graphics.Exceptions;
 using SPB.Graphics.Vulkan;
 using System;
 using System.Collections.Generic;
@@ -640,8 +641,22 @@ namespace Ryujinx.Ava
 
             if (RendererHost.EmbeddedWindow is EmbeddedWindowOpenGL openGlWindow)
             {
-                // Try to bind the OpenGL context before calling the shutdown event.
+                try
-                openGlWindow.MakeCurrent(false, false);
+                {
+                    // Try to bind the OpenGL context before disposing GPU resources.
+                    openGlWindow.MakeCurrent();
+                }
+                catch (ContextException e) when (_userChannelPersistence.ShouldRestart)
+                {
+                    // ExecuteProgram may detach the old native window before GPU
+                    // disposal. Allow the old context to be released with the window
+                    // and continue the requested program relaunch.
+                    Logger.Warning?.Print(
+                        LogClass.UI,
+                        $"Failed to bind OpenGL context during program relaunch: {e}");
+
+                    return;
+                }
 
                 Device.DisposeGpu();
 
@@ -1051,9 +1066,10 @@ namespace Ryujinx.Ava
         {
             Dispatcher.UIThread.InvokeAsync(() =>
             {
-                if (_viewModel.StartGamesInFullscreen)
+                if (_viewModel.StartGamesInFullscreen && _viewModel.WindowState is not WindowState.FullScreen)
                 {
-                    _viewModel.WindowState = WindowState.FullScreen;
+                    // Use the view model toggle so decoration ordering matches user toggles.
+                    _viewModel.ToggleFullscreen();
                 }
 
                 if (_viewModel.WindowState == WindowState.FullScreen || _viewModel.StartGamesWithoutUI)

src/Ryujinx/Assets/Locales/en_US.json

@@ -455,6 +455,8 @@
   "ControllerSettingsRumble": "Rumble",
   "ControllerSettingsRumbleStrongMultiplier": "Strong Rumble Multiplier",
   "ControllerSettingsRumbleWeakMultiplier": "Weak Rumble Multiplier",
+  "ControllerSettingsRumbleUseHDRumble": "Enable HD Rumble",
+  "HDRumbleTooltip": "EXPERIMENTAL.\n\nSends more data to the controller for better rumble.\n\nCurrently only supports first-party Nintendo Switch controllers.\n\nLeave OFF if unsure.",
   "DialogMessageSaveNotAvailableMessage": "There is no savedata for {0} [{1:x16}]",
   "DialogMessageSaveNotAvailableCreateSaveMessage": "Would you like to create savedata for this game?",
   "DialogConfirmationTitle": "Ryujinx - Confirmation",

src/Ryujinx/Headless/HeadlessRyujinx.Init.cs

@@ -222,6 +222,7 @@ namespace Ryujinx.Headless
                             StrongRumble = 1f,
                             WeakRumble = 1f,
                             EnableRumble = false,
+                            UseHDRumble = true
                         },
                     };
                 }

src/Ryujinx/Input/AvaloniaKeyboard.cs

@@ -1,5 +1,6 @@
 using Ryujinx.Common.Configuration.Hid;
 using Ryujinx.Common.Configuration.Hid.Keyboard;
+using Ryujinx.HLE.HOS.Services.Hid;
 using Ryujinx.Input;
 using System;
 using System.Collections.Generic;
@@ -149,9 +150,20 @@ namespace Ryujinx.Ava.Input
             }
         }
 
-        public void SetTriggerThreshold(float triggerThreshold) { }
+        public void SetTriggerThreshold(float triggerThreshold)
+        {
+            // No operations
+        }
 
-        public void Rumble(float lowFrequency, float highFrequency, uint durationMs) { }
+        public bool HDRumble(VibrationValue left, VibrationValue right)
+        {
+            return false;
+        }
+
+        public bool Rumble(float lowFrequency, float highFrequency, uint durationMs)
+        {
+            return false;
+        }
 
         public Vector3 GetMotionData(MotionInputId inputId) => Vector3.Zero;
 

src/Ryujinx/Input/AvaloniaMouse.cs

@@ -1,4 +1,5 @@
 using Ryujinx.Common.Configuration.Hid;
+using Ryujinx.HLE.HOS.Services.Hid;
 using Ryujinx.Input;
 using System;
 using System.Drawing;
@@ -64,7 +65,12 @@ namespace Ryujinx.Ava.Input
             throw new NotImplementedException();
         }
         
-        public void Rumble(float lowFrequency, float highFrequency, uint durationMs)
+        public bool HDRumble(VibrationValue left, VibrationValue right)
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool Rumble(float lowFrequency, float highFrequency, uint durationMs)
         {
             throw new NotImplementedException();
         }

src/Ryujinx/UI/Helpers/ContentDialogHelper.cs

@@ -121,7 +121,7 @@ namespace Ryujinx.Ava.UI.Helpers
 
                 startedDeferring = true;
 
-                ContentDialogButtonClickDeferral deferral = args.GetDeferral();
+                Deferral deferral = args.GetDeferral();
 
                 sender.PrimaryButtonClick -= DeferClose;
 

src/Ryujinx/UI/Models/Input/GamepadInputConfig.cs

@@ -19,6 +19,7 @@ namespace Ryujinx.Ava.UI.Models.Input
 
         public float WeakRumble { get; set; }
         public float StrongRumble { get; set; }
+        public bool UseHDRumble { get; set; }
 
         public string Id { get; set; }
         public ControllerType ControllerType { get; set; }
@@ -482,6 +483,7 @@ namespace Ryujinx.Ava.UI.Models.Input
                     EnableRumble = controllerInput.Rumble.EnableRumble;
                     WeakRumble = controllerInput.Rumble.WeakRumble;
                     StrongRumble = controllerInput.Rumble.StrongRumble;
+                    UseHDRumble = controllerInput.Rumble.UseHDRumble;
                 }
             }
         }
@@ -539,6 +541,7 @@ namespace Ryujinx.Ava.UI.Models.Input
                     EnableRumble = EnableRumble,
                     WeakRumble = WeakRumble,
                     StrongRumble = StrongRumble,
+                    UseHDRumble = UseHDRumble,
                 },
                 Version = InputConfig.CurrentVersion,
                 DeadzoneLeft = DeadzoneLeft,

src/Ryujinx/UI/ViewModels/Input/InputViewModel.cs

@@ -685,6 +685,7 @@ namespace Ryujinx.Ava.UI.ViewModels.Input
                         StrongRumble = 1f,
                         WeakRumble = 1f,
                         EnableRumble = false,
+                        UseHDRumble = false
                     },
                 };
             }

src/Ryujinx/UI/ViewModels/Input/RumbleInputViewModel.cs

@@ -23,5 +23,16 @@ namespace Ryujinx.Ava.UI.ViewModels.Input
                 OnPropertyChanged();
             }
         }
+
+        private bool _enableHDRumble;
+        public bool EnableHDRumble
+        {
+            get => _enableHDRumble;
+            set
+            {
+                _enableHDRumble = value;
+                OnPropertyChanged();
+            }
+        }
     }
 }

src/Ryujinx/UI/Views/Input/RumbleInputView.axaml

@@ -55,6 +55,15 @@
                     Margin="5,0"
                     Text="{Binding WeakRumble, StringFormat=\{0:0.00\}}" />
             </StackPanel>
+            <CheckBox
+                Margin="5"
+                IsChecked="{Binding EnableHDRumble}">
+                <TextBlock
+                    Margin="0,3,0,0"
+                    VerticalAlignment="Center"
+                    Text="{locale:Locale ControllerSettingsRumbleUseHDRumble}"
+                    ToolTip.Tip="{locale:Locale HDRumbleTooltip}" />
+            </CheckBox>
         </StackPanel>
     </Grid>
 </UserControl>

src/Ryujinx/UI/Views/Input/RumbleInputView.axaml.cs

@@ -24,6 +24,7 @@ namespace Ryujinx.Ava.UI.Views.Input
             {
                 StrongRumble = config.StrongRumble,
                 WeakRumble = config.WeakRumble,
+                EnableHDRumble = config.UseHDRumble
             };
 
             InitializeComponent();
@@ -49,6 +50,7 @@ namespace Ryujinx.Ava.UI.Views.Input
                 GamepadInputConfig config = viewModel.Config;
                 config.StrongRumble = content._viewModel.StrongRumble;
                 config.WeakRumble = content._viewModel.WeakRumble;
+                config.UseHDRumble = content._viewModel.EnableHDRumble;
             };
 
             await contentDialog.ShowAsync();