Start building more accurate vertex as compute usage info

- Fixes

Directory.Packages.props

@@ -36,10 +36,8 @@
     <PackageVersion Include="Ryujinx.Graphics.Nvdec.Dependencies.Linux" Version="6.1.4-build6" />
     <PackageVersion Include="Ryujinx.Graphics.Nvdec.Dependencies.macOS" Version="5.0.3-build14" />
     <PackageVersion Include="Ryujinx.Graphics.Nvdec.Dependencies.Windows" Version="6.1.4-build6" />
-    <PackageVersion Include="Ryujinx.Graphics.Vulkan.KosmicKrisp" Version="26.2.1-ryu.1" />
     <PackageVersion Include="Ryujinx.Graphics.Vulkan.MoltenVK" Version="1.4.3-ryujinx.1" />
     <PackageVersion Include="Ryujinx.LibHac" Version="0.21.0-alpha.133" />
-    <PackageVersion Include="Ryujinx.SPB" Version="0.0.5-ryujinx.4" />
     <PackageVersion Include="Ryujinx.SDL3-CS" Version="2026.707.0" />
     <PackageVersion Include="securifybv.ShellLink" Version="0.1.0" />
     <PackageVersion Include="SharpZipLib" Version="1.4.2" />
@@ -49,6 +47,7 @@
     <PackageVersion Include="Silk.NET.Vulkan.Extensions.KHR" Version="2.23.0" />
     <PackageVersion Include="SkiaSharp" Version="3.119.4" />
     <PackageVersion Include="SkiaSharp.NativeAssets.Linux" Version="3.119.4" />
+    <PackageVersion Include="SPB" Version="0.0.4-build32" />
     <PackageVersion Include="System.IO.Hashing" Version="10.0.12" />
     <PackageVersion Include="UnicornEngine.Unicorn" Version="2.1.0" />
   </ItemGroup>

distribution/macos/construct_universal_dylib.py

@@ -48,7 +48,7 @@ def get_new_name(
     return Path(os.path.join(output_directory, input_component))
 
 def get_archs(dylib_path: Path) -> list[str]:
-    res = subprocess.check_output([LIPO, "-info", str(dylib_path.absolute())]).decode("utf-8")
+    res = subprocess.check_output([LIPO, "-info", str(dylib_path)]).decode("utf-8")
     if res.startswith("Non-fat file"):
         return [res.split(":")[-1].strip()]
     else:

distribution/macos/create_app_bundle.sh

@@ -18,18 +18,14 @@ mkdir "$APP_BUNDLE_DIRECTORY/Contents/Resources"
 cp "$PUBLISH_DIRECTORY/Ryujinx" "$APP_BUNDLE_DIRECTORY/Contents/MacOS/Ryujinx"
 chmod u+x "$APP_BUNDLE_DIRECTORY/Contents/MacOS/Ryujinx"
 
-# List all dylibs in PUBLISH_DIRECTORY
-ls -la "$PUBLISH_DIRECTORY"/*.dylib
-
 # Then all libraries
-find "$PUBLISH_DIRECTORY" -name "*.dylib" -exec cp {} "$APP_BUNDLE_DIRECTORY/Contents/Frameworks" \;
+cp "$PUBLISH_DIRECTORY"/*.dylib "$APP_BUNDLE_DIRECTORY/Contents/Frameworks"
 
 # Then resources
 cp Info.plist "$APP_BUNDLE_DIRECTORY/Contents"
 cp Ryujinx.icns "$APP_BUNDLE_DIRECTORY/Contents/Resources/Ryujinx.icns"
 cp updater.sh "$APP_BUNDLE_DIRECTORY/Contents/Resources/updater.sh"
 cp Assets.car "$APP_BUNDLE_DIRECTORY/Contents/Resources/Assets.car"
-cp -r vulkan "$APP_BUNDLE_DIRECTORY/Contents/Resources"
 cp -r "$PUBLISH_DIRECTORY/THIRDPARTY.md" "$APP_BUNDLE_DIRECTORY/Contents/Resources"
 
 echo -n "APPL????" > "$APP_BUNDLE_DIRECTORY/Contents/PkgInfo"

distribution/macos/create_macos_build_ava.sh

@@ -47,7 +47,7 @@ EXECUTABLE_SUB_PATH=Contents/MacOS/Ryujinx
 rm -rf "$TEMP_DIRECTORY"
 mkdir -p "$TEMP_DIRECTORY"
 
-DOTNET_COMMON_ARGS=(-p:DebugType=embedded -p:Version="$VERSION" -p:SourceRevisionId="$SOURCE_REVISION_ID" -p:UseSharedCompilation=false --self-contained true $EXTRA_ARGS)
+DOTNET_COMMON_ARGS=(-p:DebugType=embedded -p:Version="$VERSION" -p:SourceRevisionId="$SOURCE_REVISION_ID" --self-contained true $EXTRA_ARGS)
 
 dotnet restore
 dotnet build -c "$CONFIGURATION" src/Ryujinx
@@ -76,9 +76,6 @@ rm "$UNIVERSAL_APP_BUNDLE/$EXECUTABLE_SUB_PATH"
 # Make it libraries universal
 python3 "$BASE_DIR/distribution/macos/construct_universal_dylib.py" "$ARM64_APP_BUNDLE" "$X64_APP_BUNDLE" "$UNIVERSAL_APP_BUNDLE" "**/*.dylib"
 
-# Copy arm64-only libraries to UNIVERSAL_APP_BUNDLE
-cp "$ARM64_APP_BUNDLE/Contents/Frameworks/libvulkan_kosmickrisp.dylib" "$UNIVERSAL_APP_BUNDLE/Contents/Frameworks/libvulkan_kosmickrisp.dylib"
-
 if ! [ -x "$(command -v lipo)" ];
 then
     if ! [ -x "$(command -v llvm-lipo-17)" ];

distribution/macos/vulkan/icd.d/MoltenVK_icd-flat.json

@@ -1,8 +0,0 @@
-{
-    "file_format_version" : "1.0.0",
-    "ICD": {
-        "library_path": "./libMoltenVK.dylib",
-        "api_version" : "1.4.0",
-        "is_portability_driver" : true
-    }
-}

distribution/macos/vulkan/icd.d/MoltenVK_icd.json

@@ -1,8 +0,0 @@
-{
-    "file_format_version" : "1.0.0",
-    "ICD": {
-        "library_path": "../../../Frameworks/libMoltenVK.dylib",
-        "api_version" : "1.4.0",
-        "is_portability_driver" : true
-    }
-}

distribution/macos/vulkan/icd.d/libkosmickrisp_icd-flat.json

@@ -1,7 +0,0 @@
-{
-    "ICD": {
-        "api_version": "1.3.0",
-        "library_path": "./libvulkan_kosmickrisp.dylib"
-    },
-    "file_format_version": "1.0.1"
-}

distribution/macos/vulkan/icd.d/libkosmickrisp_icd.json

@@ -1,7 +0,0 @@
-{
-    "ICD": {
-        "api_version": "1.3.0",
-        "library_path": "../../../Frameworks/libvulkan_kosmickrisp.dylib"
-    },
-    "file_format_version": "1.0.1"
-}

nuget.config

@@ -2,7 +2,6 @@
 <configuration>
     <packageSources>
         <clear />
-        <add key="local" value="nuget" />
         <add key="nuget.org" value="https://api.nuget.org/v3/index.json" />
         <!-- Only needed when using pre-release versions of Ryujinx.LibHac. -->
         <add key="LibHacAlpha" value="https://git.ryujinx.app/api/packages/projects/nuget/index.json" />
@@ -11,9 +10,6 @@
     <packageSourceMapping>
         <!-- key value for <packageSource> should match key values from <packageSources> element -->
         <!-- These are defined and .NET still yells about multiple package sources with no mappings. Not sure what to do, this is in the docs lol -->
-        <packageSource key="local">
-            <package pattern="Ryujinx.Graphics.Vulkan.KosmicKrisp" />
-        </packageSource>
         <packageSource key="nuget.org">
             <package pattern="*" />
         </packageSource>

src/ARMeilleure/Translation/Translator.cs

@@ -413,6 +413,10 @@ namespace ARMeilleure.Translation
 
                         context.CurrOp = opCode;
 
+                        Operand nativeContext = context.LoadArgument(OperandType.I64, 0);
+                        Operand dispAddressAddr = context.Add(nativeContext, Const((ulong)NativeContext.GetDispatchAddressOffset()));
+                        context.Store(dispAddressAddr, Const(opCode.Address));
+
                         bool isLastOp = opcIndex == block.OpCodes.Count - 1;
 
                         if (isLastOp)

src/Ryujinx.Common/Configuration/TranslationLayer.cs

@@ -1,11 +0,0 @@
-using System.Text.Json.Serialization;
-
-namespace Ryujinx.Common.Configuration
-{
-    [JsonConverter(typeof(JsonStringEnumConverter<TranslationLayer>))]
-    public enum TranslationLayer 
-    {
-        MoltenVK,
-        KosmicKrisp,
-    }
-}

src/Ryujinx.Cpu/LightningJit/Arm32/Decoder.cs

@@ -8,7 +8,7 @@ namespace Ryujinx.Cpu.LightningJit.Arm32
 {
     static class Decoder<T> where T : IInstEmit
     {
-        public static MultiBlock DecodeMulti(CpuPreset cpuPreset, IMemoryManager memoryManager, ulong address, bool isThumb)
+        public static MultiBlock DecodeMulti(CpuPreset cpuPreset, IMemoryManager memoryManager, ulong address, bool singleBlock, bool isThumb)
         {
             List<Block> blocks = [];
             List<ulong> branchTargets = [];
@@ -24,7 +24,7 @@ namespace Ryujinx.Cpu.LightningJit.Arm32
 
                 blocks.Add(block);
 
-                if (block.IsTruncated || !HasNextBlock(block, block.EndAddress - 4UL, branchTargets))
+                if (block.IsTruncated || (singleBlock && block.EndsWithBranch) || !HasNextBlock(block, block.EndAddress - 4UL, branchTargets))
                 {
                     break;
                 }

src/Ryujinx.Cpu/LightningJit/Arm32/Target/Arm64/Compiler.cs

@@ -227,7 +227,7 @@ namespace Ryujinx.Cpu.LightningJit.Arm32.Target.Arm64
 
         public static CompiledFunction Compile(CpuPreset cpuPreset, IMemoryManager memoryManager, ulong address, IAddressTable<ulong> funcTable, nint dispatchStubPtr, bool isThumb)
         {
-            MultiBlock multiBlock = Decoder<InstEmit>.DecodeMulti(cpuPreset, memoryManager, address, isThumb);
+            MultiBlock multiBlock = Decoder<InstEmit>.DecodeMulti(cpuPreset, memoryManager, address, singleBlock: true, isThumb);
 
             Dictionary<ulong, int> targets = new();
 

src/Ryujinx.Cpu/LightningJit/Arm64/Target/Arm64/Compiler.cs

@@ -305,7 +305,7 @@ namespace Ryujinx.Cpu.LightningJit.Arm64.Target.Arm64
 
         public static CompiledFunction Compile(CpuPreset cpuPreset, IMemoryManager memoryManager, ulong address, IAddressTable<ulong> funcTable, nint dispatchStubPtr)
         {
-            MultiBlock multiBlock = Decoder.DecodeMulti(cpuPreset, memoryManager, address);
+            MultiBlock multiBlock = Decoder.DecodeMulti(cpuPreset, memoryManager, address, singleBlock: true);
 
             Dictionary<ulong, int> targets = new();
             List<PendingBranch> pendingBranches = [];

src/Ryujinx.Cpu/LightningJit/Arm64/Target/Arm64/Decoder.cs

@@ -13,7 +13,7 @@ namespace Ryujinx.Cpu.LightningJit.Arm64.Target.Arm64
         private const uint NzcvFlags = 0xfu << 28;
         private const uint CFlag = 0x1u << 29;
 
-        public static MultiBlock DecodeMulti(CpuPreset cpuPreset, IMemoryManager memoryManager, ulong address)
+        public static MultiBlock DecodeMulti(CpuPreset cpuPreset, IMemoryManager memoryManager, ulong address, bool singleBlock)
         {
             List<Block> blocks = [];
             List<ulong> branchTargets = [];
@@ -35,7 +35,7 @@ namespace Ryujinx.Cpu.LightningJit.Arm64.Target.Arm64
 
                 blocks.Add(block);
 
-                if (block.IsTruncated || !HasNextBlock(block, block.EndAddress - 4UL, branchTargets))
+                if (block.IsTruncated || (singleBlock && block.EndsWithBranch) || !HasNextBlock(block, block.EndAddress - 4UL, branchTargets))
                 {
                     break;
                 }

src/Ryujinx.Graphics.GAL/Capabilities.cs

@@ -32,6 +32,7 @@ namespace Ryujinx.Graphics.GAL
         public readonly bool SupportsGeometryShader;
         public readonly bool SupportsGeometryShaderPassthrough;
         public readonly bool SupportsTransformFeedback;
+        public readonly bool SupportsImageBufferPixelAlignment;
         public readonly bool SupportsImageLoadFormatted;
         public readonly bool SupportsLayerVertexTessellation;
         public readonly bool SupportsMismatchingViewFormat;
@@ -43,6 +44,7 @@ namespace Ryujinx.Graphics.GAL
         public readonly bool SupportsShaderBarrierDivergence;
         public readonly bool SupportsShaderFloat64;
         public readonly bool SupportsShaderNonUniformIndexing;
+        public readonly bool SupportsTextureBufferPixelAlignment;
         public readonly bool SupportsTextureGatherOffsets;
         public readonly bool SupportsTextureShadowLod;
         public readonly bool SupportsVertexStoreAndAtomics;
@@ -101,6 +103,7 @@ namespace Ryujinx.Graphics.GAL
             bool supportsGeometryShader,
             bool supportsGeometryShaderPassthrough,
             bool supportsTransformFeedback,
+            bool supportsImageBufferPixelAlignment,
             bool supportsImageLoadFormatted,
             bool supportsLayerVertexTessellation,
             bool supportsMismatchingViewFormat,
@@ -112,6 +115,7 @@ namespace Ryujinx.Graphics.GAL
             bool supportsShaderBarrierDivergence,
             bool supportsShaderFloat64,
             bool supportsShaderNonUniformIndexing,
+            bool supportsTextureBufferPixelAlignment,
             bool supportsTextureGatherOffsets,
             bool supportsTextureShadowLod,
             bool supportsVertexStoreAndAtomics,
@@ -164,6 +168,7 @@ namespace Ryujinx.Graphics.GAL
             SupportsGeometryShader = supportsGeometryShader;
             SupportsGeometryShaderPassthrough = supportsGeometryShaderPassthrough;
             SupportsTransformFeedback = supportsTransformFeedback;
+            SupportsImageBufferPixelAlignment = supportsImageBufferPixelAlignment;
             SupportsImageLoadFormatted = supportsImageLoadFormatted;
             SupportsLayerVertexTessellation = supportsLayerVertexTessellation;
             SupportsMismatchingViewFormat = supportsMismatchingViewFormat;
@@ -175,6 +180,7 @@ namespace Ryujinx.Graphics.GAL
             SupportsShaderBarrierDivergence = supportsShaderBarrierDivergence;
             SupportsShaderFloat64 = supportsShaderFloat64;
             SupportsShaderNonUniformIndexing = supportsShaderNonUniformIndexing;
+            SupportsTextureBufferPixelAlignment = supportsTextureBufferPixelAlignment;
             SupportsTextureGatherOffsets = supportsTextureGatherOffsets;
             SupportsTextureShadowLod = supportsTextureShadowLod;
             SupportsVertexStoreAndAtomics = supportsVertexStoreAndAtomics;

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

@@ -466,6 +466,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
 
             engine.UpdateState(ulong.MaxValue & ~(1UL << StateUpdater.ShaderStateIndex));
 
+            _channel.TextureManager.SignalRenderTargetsModifiable();
             _channel.TextureManager.UpdateRenderTargets();
 
             int textureId = _state.State.DrawTextureTextureId;
@@ -803,7 +804,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
             int index = (argument >> 6) & 0xf;
             int layer = (argument >> 10) & 0x3ff;
 
-            RenderTargetUpdateFlags updateFlags = RenderTargetUpdateFlags.SingleColor;
+            RenderTargetUpdateFlags updateFlags = RenderTargetUpdateFlags.SingleColor | RenderTargetUpdateFlags.ForClear;
 
             if (layer != 0 || layerCount > 1)
             {

src/Ryujinx.Graphics.Gpu/Engine/Threed/RenderTargetUpdateFlags.cs

@@ -38,6 +38,11 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
         /// </summary>
         DiscardClip = 1 << 4,
 
+        /// <summary>
+        /// Indicates that the render target will be used for a clear operation.
+        /// </summary>
+        ForClear = 1 << 5,
+
         /// <summary>
         /// Default update flags for draw.
         /// </summary>

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

@@ -45,6 +45,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
         private ProgramPipelineState _pipeline;
 
         private bool _fsReadsFragCoord;
+        private bool _fsAlwaysDiscards;
         private bool _vsUsesDrawParameters;
         private bool _vtgWritesRtLayer;
         private byte _vsClipDistancesWritten;
@@ -491,6 +492,8 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
 
             Span<RtColorState> rtColorStateSpan = _state.State.RtColorState.AsSpan();
 
+            bool rtModifiable = updateFlags.HasFlag(RenderTargetUpdateFlags.ForClear) || !_fsAlwaysDiscards;
+
             for (int index = 0; index < Constants.TotalRenderTargets; index++)
             {
                 int rtIndex = useControl ? rtControl.UnpackPermutationIndex(index) : index;
@@ -499,7 +502,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
 
                 if (index >= count || !IsRtEnabled(colorState) || (singleColor && index != singleUse))
                 {
-                    changedScale |= _channel.TextureManager.SetRenderTargetColor(index, null);
+                    changedScale |= _channel.TextureManager.SetRenderTargetColor(index, null, rtModifiable);
 
                     continue;
                 }
@@ -518,7 +521,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
                     samplesInY,
                     sizeHint);
 
-                changedScale |= _channel.TextureManager.SetRenderTargetColor(index, color);
+                changedScale |= _channel.TextureManager.SetRenderTargetColor(index, color, rtModifiable);
 
                 if (color != null)
                 {
@@ -572,7 +575,7 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
                 }
             }
 
-            changedScale |= _channel.TextureManager.SetRenderTargetDepthStencil(depthStencil);
+            changedScale |= _channel.TextureManager.SetRenderTargetDepthStencil(depthStencil, rtModifiable);
 
             if (changedScale)
             {
@@ -774,6 +777,11 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
                 float width = scaleX * 2;
                 float height = scaleY * 2;
 
+                if (yNegate)
+                {
+                    y += _state.State.ScreenScissorState.Height - MathF.Abs(height);
+                }
+
                 float scale = _channel.TextureManager.RenderTargetScale;
                 if (scale != 1f)
                 {
@@ -1517,20 +1525,38 @@ namespace Ryujinx.Graphics.Gpu.Engine.Threed
                 _currentProgramInfo[stageIndex] = info;
             }
 
-            if (gs.Shaders[5]?.Info.UsesFragCoord == true)
-            {
-                // Make sure we update the viewport size on the support buffer if it will be consumed on the new shader.
+            _fsReadsFragCoord = false;
 
-                if (!_fsReadsFragCoord && (_state.State.YControl & YControl.NegateY) != 0)
+            ShaderProgramInfo fragmentShaderInfo = gs.Shaders[5]?.Info;
+
+            if (fragmentShaderInfo != null)
+            {
+                if (fragmentShaderInfo.UsesFragCoord)
                 {
-                    UpdateSupportBufferViewportSize();
+                    // Make sure we update the viewport size on the support buffer if it will be consumed on the new shader.
+
+                    if (!_fsReadsFragCoord && (_state.State.YControl & YControl.NegateY) != 0)
+                    {
+                        UpdateSupportBufferViewportSize();
+                    }
+
+                    _fsReadsFragCoord = true;
                 }
 
-                _fsReadsFragCoord = true;
+                if (_fsAlwaysDiscards != fragmentShaderInfo.HasUnconditionalDiscard)
+                {
+                    _fsAlwaysDiscards = fragmentShaderInfo.HasUnconditionalDiscard;
+
+                    if (!_fsAlwaysDiscards)
+                    {
+                        _channel.TextureManager.RefreshModifiedTextures();
+                        _channel.TextureManager.SignalRenderTargetsModifiable();
+                    }
+                }
             }
             else
             {
-                _fsReadsFragCoord = false;
+                _fsAlwaysDiscards = false;
             }
 
             if (gs.VertexAsCompute != null)

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

@@ -1572,11 +1572,6 @@ namespace Ryujinx.Graphics.Gpu.Image
         /// <param name="bound">True if the texture has been bound, false if it has been unbound</param>
         public void SignalModifying(bool bound)
         {
-            if (bound)
-            {
-                _scaledSetScore = Math.Max(0, _scaledSetScore - 1);
-            }
-
             if (_modifiedStale || Group.HasCopyDependencies || Group.HasFlushBuffer)
             {
                 _modifiedStale = false;
@@ -1584,9 +1579,18 @@ namespace Ryujinx.Graphics.Gpu.Image
             }
 
             _physicalMemory.TextureCache.Lift(this);
+        }
 
+        /// <summary>
+        /// Signals that a render target texture has been either bound or unbound.
+        /// </summary>
+        /// <param name="bound">True if the texture has been bound, false if it has been unbound</param>
+        public void SignalBindingChange(bool bound)
+        {
             if (bound)
             {
+                _scaledSetScore = Math.Max(0, _scaledSetScore - 1);
+
                 IncrementReferenceCount();
             }
             else

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

@@ -4,6 +4,7 @@ using Ryujinx.Graphics.Gpu.Engine.Types;
 using Ryujinx.Graphics.Gpu.Memory;
 using Ryujinx.Graphics.Gpu.Shader;
 using Ryujinx.Graphics.Shader;
+using Ryujinx.Memory.Range;
 using System;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
@@ -67,6 +68,9 @@ namespace Ryujinx.Graphics.Gpu.Image
 
         private int _lastFragmentTotal;
 
+        private readonly int _bufferTextureAlignment;
+        private readonly int _bufferImageAlignment;
+
         /// <summary>
         /// Constructs a new instance of the texture bindings manager.
         /// </summary>
@@ -108,6 +112,10 @@ namespace Ryujinx.Graphics.Gpu.Image
             }
 
             _textureCounts = [];
+
+            int alignment = context.Capabilities.TextureBufferOffsetAlignment;
+            _bufferTextureAlignment = context.Capabilities.SupportsTextureBufferPixelAlignment ? 0 : alignment;
+            _bufferImageAlignment = context.Capabilities.SupportsImageBufferPixelAlignment ? 0 : alignment;
         }
 
         /// <summary>
@@ -521,10 +529,12 @@ namespace Ryujinx.Graphics.Gpu.Image
 
                 if (hostTexture != null && texture.Target == Target.TextureBuffer)
                 {
+                    MultiRange range = GetAlignedBufferTextureRange(texture, index, stageIndex, false);
+
                     // Ensure that the buffer texture is using the correct buffer as storage.
                     // Buffers are frequently re-created to accommodate larger data, so we need to re-bind
                     // to ensure we're not using a old buffer that was already deleted.
-                    _channel.BufferManager.SetBufferTextureStorage(stage, hostTexture, texture.Range, bindingInfo, false);
+                    _channel.BufferManager.SetBufferTextureStorage(stage, hostTexture, range, bindingInfo, false);
 
                     // Cache is not used for buffer texture, it must always rebind.
                     state.CachedTexture = null;
@@ -659,7 +669,9 @@ namespace Ryujinx.Graphics.Gpu.Image
                     // Buffers are frequently re-created to accommodate larger data, so we need to re-bind
                     // to ensure we're not using a old buffer that was already deleted.
 
-                    _channel.BufferManager.SetBufferTextureStorage(stage, hostTexture, texture.Range, bindingInfo, true);
+                    MultiRange range = GetAlignedBufferTextureRange(texture, index, stageIndex, true);
+
+                    _channel.BufferManager.SetBufferTextureStorage(stage, hostTexture, range, bindingInfo, true);
 
                     // Cache is not used for buffer texture, it must always rebind.
                     state.CachedTexture = null;
@@ -692,6 +704,61 @@ namespace Ryujinx.Graphics.Gpu.Image
             return specStateMatches;
         }
 
+        /// <summary>
+        /// Gets the aligned address of the texture according to the host requirements.
+        /// </summary>
+        /// <param name="texture">Texture to have its address aligned</param>
+        /// <param name="index">Index of the texture in the shader</param>
+        /// <param name="stageIndex">Index of the shader stage</param>
+        /// <param name="isImage">True if the texture is bound as image, false for sampled textures</param>
+        /// <returns>Aligned address and size of the buffer texture</returns>
+        private MultiRange GetAlignedBufferTextureRange(Texture texture, int index, int stageIndex, bool isImage)
+        {
+            MultiRange range = texture.Range;
+            int alignment = isImage ? _bufferImageAlignment : _bufferTextureAlignment;
+
+            if (alignment != 0)
+            {
+                MemoryRange firstRange = range.GetSubRange(0);
+                ulong misalign = firstRange.Address & ((ulong)alignment - 1);
+                int offset = misalign != 0 ? (int)misalign / texture.Info.FormatInfo.BytesPerPixel : 0;
+
+                if (misalign != 0)
+                {
+                    firstRange = new MemoryRange(firstRange.Address - misalign, firstRange.Size + misalign);
+
+                    if (range.Count > 1)
+                    {
+                        MemoryRange[] ranges = new MemoryRange[range.Count];
+
+                        ranges[0] = firstRange;
+
+                        for (int i = 1; i < range.Count; i++)
+                        {
+                            ranges[i] = range.GetSubRange(i);
+                        }
+
+                        range = new MultiRange(ranges);
+                    }
+                    else
+                    {
+                        range = new MultiRange(firstRange.Address, firstRange.Size);
+                    }
+                }
+
+                if (isImage)
+                {
+                    _context.SupportBufferUpdater.UpdateBufferImageOffset(stageIndex, index, offset);
+                }
+                else
+                {
+                    _context.SupportBufferUpdater.UpdateBufferTextureOffset(stageIndex, index, offset);
+                }
+            }
+
+            return range;
+        }
+
         /// <summary>
         /// Gets the texture descriptor for a given texture handle.
         /// </summary>

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

@@ -19,12 +19,39 @@ namespace Ryujinx.Graphics.Gpu.Image
         private readonly TexturePoolCache _texturePoolCache;
         private readonly SamplerPoolCache _samplerPoolCache;
 
+        /// <summary>
+        /// Bound render target texture modification report state.
+        /// </summary>
+        [Flags]
+        private enum BindState : byte
+        {
+            /// <summary>
+            /// Render target texture has not been signalled for modification, and can't be modified on the next render operations.
+            /// </summary>
+            None = 0,
+
+            /// <summary>
+            /// Render target texture has been signalled for modification.
+            /// </summary>
+            Bound = 1 << 0,
+
+            /// <summary>
+            /// Render target texture might be modified on the next render operations.
+            /// </summary>
+            Modified = 1 << 1,
+
+            /// <summary>
+            /// Render target texture has been signalled for modification and might be modified on the next render operations.
+            /// </summary>
+            BoundModified = Bound | Modified,
+        }
+
         private readonly Texture[] _rtColors;
         private readonly ITexture[] _rtHostColors;
-        private readonly bool[] _rtColorsBound;
+        private readonly BindState[] _rtColorsBound;
         private Texture _rtDepthStencil;
         private ITexture _rtHostDs;
-        private bool _rtDsBound;
+        private BindState _rtDsBound;
 
         public int ClipRegionWidth { get; private set; }
         public int ClipRegionHeight { get; private set; }
@@ -55,7 +82,7 @@ namespace Ryujinx.Graphics.Gpu.Image
 
             _rtColors = new Texture[Constants.TotalRenderTargets];
             _rtHostColors = new ITexture[Constants.TotalRenderTargets];
-            _rtColorsBound = new bool[Constants.TotalRenderTargets];
+            _rtColorsBound = new BindState[Constants.TotalRenderTargets];
         }
 
         /// <summary>
@@ -151,27 +178,39 @@ namespace Ryujinx.Graphics.Gpu.Image
         /// </summary>
         /// <param name="index">The index of the color buffer to set (up to 8)</param>
         /// <param name="color">The color buffer texture</param>
+        /// <param name="modified">Indicates if the following render operations will modidify <paramref name="color"/> contents</param>
         /// <returns>True if render target scale must be updated.</returns>
-        public bool SetRenderTargetColor(int index, Texture color)
+        public bool SetRenderTargetColor(int index, Texture color, bool modified)
         {
             bool hasValue = color != null;
             bool changesScale = (hasValue != (_rtColors[index] != null)) || (hasValue && RenderTargetScale != color.ScaleFactor);
 
             if (_rtColors[index] != color)
             {
-                if (_rtColorsBound[index])
+                Texture oldColor = _rtColors[index];
+
+                if (oldColor != null)
                 {
-                    _rtColors[index]?.SignalModifying(false);
-                }
-                else
-                {
-                    _rtColorsBound[index] = true;
+                    if (_rtColorsBound[index].HasFlag(BindState.Bound))
+                    {
+                        oldColor.SignalModifying(false);
+                    }
+
+                    oldColor.SignalBindingChange(false);
                 }
 
+                _rtColorsBound[index] = modified ? BindState.BoundModified : BindState.None;
+
                 if (color != null)
                 {
                     color.SynchronizeMemory();
-                    color.SignalModifying(true);
+
+                    if (modified)
+                    {
+                        color.SignalModifying(true);
+                    }
+
+                    color.SignalBindingChange(true);
                 }
 
                 _rtColors[index] = color;
@@ -184,27 +223,39 @@ namespace Ryujinx.Graphics.Gpu.Image
         /// Sets the render target depth-stencil buffer.
         /// </summary>
         /// <param name="depthStencil">The depth-stencil buffer texture</param>
+        /// <param name="modified">Indicates if the following render operations will modidify <paramref name="depthStencil"/> contents</param>
         /// <returns>True if render target scale must be updated.</returns>
-        public bool SetRenderTargetDepthStencil(Texture depthStencil)
+        public bool SetRenderTargetDepthStencil(Texture depthStencil, bool modified)
         {
             bool hasValue = depthStencil != null;
             bool changesScale = (hasValue != (_rtDepthStencil != null)) || (hasValue && RenderTargetScale != depthStencil.ScaleFactor);
 
             if (_rtDepthStencil != depthStencil)
             {
-                if (_rtDsBound)
+                Texture oldDepthStencil = _rtDepthStencil;
+
+                if (oldDepthStencil != null)
                 {
-                    _rtDepthStencil?.SignalModifying(false);
-                }
-                else
-                {
-                    _rtDsBound = true;
+                    if (_rtDsBound.HasFlag(BindState.Bound))
+                    {
+                        oldDepthStencil.SignalModifying(false);
+                    }
+
+                    oldDepthStencil.SignalBindingChange(false);
                 }
 
+                _rtDsBound = modified ? BindState.BoundModified : BindState.None;
+
                 if (depthStencil != null)
                 {
                     depthStencil.SynchronizeMemory();
-                    depthStencil.SignalModifying(true);
+
+                    if (modified)
+                    {
+                        depthStencil.SignalModifying(true);
+                    }
+
+                    depthStencil.SignalBindingChange(true);
                 }
 
                 _rtDepthStencil = depthStencil;
@@ -443,10 +494,10 @@ namespace Ryujinx.Graphics.Gpu.Image
             {
                 hostDsTexture = dsTexture.HostTexture;
 
-                if (!_rtDsBound)
+                if (_rtDsBound == BindState.Modified)
                 {
                     dsTexture.SignalModifying(true);
-                    _rtDsBound = true;
+                    _rtDsBound |= BindState.Bound;
                 }
             }
 
@@ -470,10 +521,10 @@ namespace Ryujinx.Graphics.Gpu.Image
                 {
                     hostTexture = texture.HostTexture;
 
-                    if (!_rtColorsBound[index])
+                    if (_rtColorsBound[index] == BindState.Modified)
                     {
                         texture.SignalModifying(true);
-                        _rtColorsBound[index] = true;
+                        _rtColorsBound[index] |= BindState.Bound;
                     }
                 }
 
@@ -518,24 +569,37 @@ namespace Ryujinx.Graphics.Gpu.Image
         {
             Texture dsTexture = _rtDepthStencil;
 
-            if (dsTexture != null && _rtDsBound)
+            if (dsTexture != null && _rtDsBound.HasFlag(BindState.Bound))
             {
                 dsTexture.SignalModifying(false);
-                _rtDsBound = false;
+                _rtDsBound &= ~BindState.Bound;
             }
 
             for (int index = 0; index < _rtColors.Length; index++)
             {
                 Texture texture = _rtColors[index];
 
-                if (texture != null && _rtColorsBound[index])
+                if (texture != null && _rtColorsBound[index].HasFlag(BindState.Bound))
                 {
                     texture.SignalModifying(false);
-                    _rtColorsBound[index] = false;
+                    _rtColorsBound[index] &= ~BindState.Bound;
                 }
             }
         }
 
+        /// <summary>
+        /// Indicates that the currently bound render targets might be modified, if they are used on the next render operation.
+        /// </summary>
+        public void SignalRenderTargetsModifiable()
+        {
+            _rtDsBound |= BindState.Modified;
+
+            for (int index = 0; index < _rtColorsBound.Length; index++)
+            {
+                _rtColorsBound[index] |= BindState.Modified;
+            }
+        }
+
         /// <summary>
         /// Forces the texture and sampler pools to be re-loaded from the cache on next use.
         /// </summary>
@@ -572,19 +636,11 @@ namespace Ryujinx.Graphics.Gpu.Image
 
             for (int i = 0; i < _rtColors.Length; i++)
             {
-                if (_rtColorsBound[i])
-                {
-                    _rtColors[i]?.DecrementReferenceCount();
-                }
-
+                _rtColors[i]?.DecrementReferenceCount();
                 _rtColors[i] = null;
             }
 
-            if (_rtDsBound)
-            {
-                _rtDepthStencil?.DecrementReferenceCount();
-            }
-
+            _rtDepthStencil?.DecrementReferenceCount();
             _rtDepthStencil = null;
         }
     }

src/Ryujinx.Graphics.Gpu/Memory/SupportBufferUpdater.cs

@@ -129,6 +129,38 @@ namespace Ryujinx.Graphics.Gpu.Memory
             }
         }
 
+        /// <summary>
+        /// Updates the offset used for accessing buffer textures that are not aligned to the host requirements.
+        /// </summary>
+        /// <param name="stageIndex">Index of the shader stage where the texture is used</param>
+        /// <param name="bindingIndex">Index of the texture binding in the shader</param>
+        /// <param name="offset">Offset for the misaligned part of the address</param>
+        public void UpdateBufferTextureOffset(int stageIndex, int bindingIndex, int offset)
+        {
+            if (_data.BufferTextureOffset[stageIndex][bindingIndex].X != offset)
+            {
+                _data.BufferTextureOffset[stageIndex][bindingIndex].X = offset;
+                int index = stageIndex * SupportBuffer.TextureCount + bindingIndex;
+                MarkDirty(SupportBuffer.BufferTextureOffsetOffset + index * sizeof(int) * 4, sizeof(int));
+            }
+        }
+
+        /// <summary>
+        /// Updates the offset used for accessing buffer images that are not aligned to the host requirements.
+        /// </summary>
+        /// <param name="stageIndex">Index of the shader stage where the image is used</param>
+        /// <param name="bindingIndex">Index of the image binding in the shader</param>
+        /// <param name="offset">Offset for the misaligned part of the address</param>
+        public void UpdateBufferImageOffset(int stageIndex, int bindingIndex, int offset)
+        {
+            if (_data.BufferTextureOffset[stageIndex][bindingIndex].Y != offset)
+            {
+                _data.BufferTextureOffset[stageIndex][bindingIndex].Y = offset;
+                int index = stageIndex * SupportBuffer.TextureCount + bindingIndex;
+                MarkDirty(SupportBuffer.BufferTextureOffsetOffset + index * sizeof(int) * 4 + sizeof(int), sizeof(int));
+            }
+        }
+
         /// <summary>
         /// Sets whether the format of a given render target is a BGRA format.
         /// </summary>

src/Ryujinx.Graphics.Gpu/Shader/DiskCache/DiskCacheHostStorage.cs

@@ -22,7 +22,7 @@ namespace Ryujinx.Graphics.Gpu.Shader.DiskCache
         private const ushort FileFormatVersionMajor = 1;
         private const ushort FileFormatVersionMinor = 2;
         private const uint FileFormatVersionPacked = ((uint)FileFormatVersionMajor << 16) | FileFormatVersionMinor;
-        private const uint CodeGenVersion = 7354;
+        private const uint CodeGenVersion = 6371;
 
         private const string SharedTocFileName = "shared.toc";
         private const string SharedDataFileName = "shared.data";
@@ -170,6 +170,11 @@ namespace Ryujinx.Graphics.Gpu.Shader.DiskCache
             /// </summary>
             public bool UsesRtLayer;
 
+            /// <summary>
+            /// Indicates that the fragment shader always discards the fragment, not producing any output for the bound render targets.
+            /// </summary>
+            public bool HasUnconditionalDiscard;
+
             /// <summary>
             /// Bit mask with the clip distances written on the vertex stage.
             /// </summary>
@@ -806,6 +811,7 @@ namespace Ryujinx.Graphics.Gpu.Shader.DiskCache
                 dataInfo.UsesInstanceId,
                 dataInfo.UsesDrawParameters,
                 dataInfo.UsesRtLayer,
+                dataInfo.HasUnconditionalDiscard,
                 dataInfo.ClipDistancesWritten,
                 dataInfo.FragmentOutputMap);
         }
@@ -836,6 +842,7 @@ namespace Ryujinx.Graphics.Gpu.Shader.DiskCache
                 UsesInstanceId = info.UsesInstanceId,
                 UsesDrawParameters = info.UsesDrawParameters,
                 UsesRtLayer = info.UsesRtLayer,
+                HasUnconditionalDiscard = info.HasUnconditionalDiscard,
                 ClipDistancesWritten = info.ClipDistancesWritten,
                 FragmentOutputMap = info.FragmentOutputMap,
             };

src/Ryujinx.Graphics.Gpu/Shader/GpuAccessorBase.cs

@@ -207,6 +207,10 @@ namespace Ryujinx.Graphics.Gpu.Shader
 
         public bool QueryHostSupportsBgraFormat() => _context.Capabilities.SupportsBgraFormat;
 
+        public bool QueryHostSupportsBufferImagePixelAlignment() => _context.Capabilities.SupportsImageBufferPixelAlignment;
+
+        public bool QueryHostSupportsBufferTexturePixelAlignment() => _context.Capabilities.SupportsTextureBufferPixelAlignment;
+
         public bool QueryHostSupportsFragmentShaderInterlock() => _context.Capabilities.SupportsFragmentShaderInterlock;
 
         public bool QueryHostSupportsFragmentShaderOrderingIntel() => _context.Capabilities.SupportsFragmentShaderOrderingIntel;

src/Ryujinx.Graphics.Gpu/Shader/ShaderCache.cs

@@ -430,7 +430,8 @@ namespace Ryujinx.Graphics.Gpu.Shader
 
                             TranslatorContext lastInVertexPipeline = geometryToCompute ? translatorContexts[4] ?? currentStage : currentStage;
 
-                            program = lastInVertexPipeline.GenerateVertexPassthroughForCompute();
+                            (program, ShaderProgramInfo vacInfo) = lastInVertexPipeline.GenerateVertexPassthroughForCompute();
+                            infoBuilder.AddStageInfoVac(vacInfo);
                         }
                         else
                         {
@@ -535,7 +536,7 @@ namespace Ryujinx.Graphics.Gpu.Shader
         private ShaderAsCompute CreateHostVertexAsComputeProgram(ShaderProgram program, TranslatorContext context, bool tfEnabled)
         {
             ShaderSource source = new(program.Code, program.BinaryCode, ShaderStage.Compute, program.Language);
-            ShaderInfo info = ShaderInfoBuilder.BuildForVertexAsCompute(_context, program.Info, tfEnabled);
+            ShaderInfo info = ShaderInfoBuilder.BuildForVertexAsCompute(_context, program.Info, context.GetVertexAsComputeInfo(), tfEnabled);
 
             return new(_context.Renderer.CreateProgram([source], info), program.Info, context.GetResourceReservations());
         }

src/Ryujinx.Graphics.Gpu/Shader/ShaderInfoBuilder.cs

@@ -95,7 +95,7 @@ namespace Ryujinx.Graphics.Gpu.Shader
         private void PopulateDescriptorAndUsages(ResourceStages stages, ResourceType type, int setIndex, int start, int count, bool write = false)
         {
             AddDescriptor(stages, type, setIndex, start, count);
-            AddUsage(stages, type, setIndex, start, count, write);
+            // AddUsage(stages, type, setIndex, start, count, write);
         }
 
         /// <summary>
@@ -159,6 +159,25 @@ namespace Ryujinx.Graphics.Gpu.Shader
             AddUsage(info.Images, stages, isImage: true);
         }
 
+        public void AddStageInfoVac(ShaderProgramInfo info)
+        {
+            ResourceStages stages = info.Stage switch
+            {
+                ShaderStage.Compute => ResourceStages.Compute,
+                ShaderStage.Vertex => ResourceStages.Vertex,
+                ShaderStage.TessellationControl => ResourceStages.TessellationControl,
+                ShaderStage.TessellationEvaluation => ResourceStages.TessellationEvaluation,
+                ShaderStage.Geometry => ResourceStages.Geometry,
+                ShaderStage.Fragment => ResourceStages.Fragment,
+                _ => ResourceStages.None,
+            };
+
+            AddUsage(info.CBuffers, stages, isStorage: false);
+            AddUsage(info.SBuffers, stages, isStorage: true);
+            AddUsage(info.Textures, stages, isImage: false);
+            AddUsage(info.Images, stages, isImage: true);
+        }
+
         /// <summary>
         /// Adds a resource descriptor to the list of descriptors.
         /// </summary>
@@ -422,10 +441,11 @@ namespace Ryujinx.Graphics.Gpu.Shader
         /// <param name="tfEnabled">Indicates if the graphics shader is used with transform feedback enabled</param>
         /// <param name="fromCache">True if the compute shader comes from a disk cache, false otherwise</param>
         /// <returns>Shader information</returns>
-        public static ShaderInfo BuildForVertexAsCompute(GpuContext context, ShaderProgramInfo info, bool tfEnabled, bool fromCache = false)
+        public static ShaderInfo BuildForVertexAsCompute(GpuContext context, ShaderProgramInfo info, ShaderProgramInfo info2, bool tfEnabled, bool fromCache = false)
         {
             ShaderInfoBuilder builder = new(context, tfEnabled, vertexAsCompute: true);
 
+            builder.AddStageInfoVac(info2);
             builder.AddStageInfo(info, vertexAsCompute: true);
 
             return builder.Build(null, fromCache);

src/Ryujinx.Graphics.OpenGL/OpenGLRenderer.cs

@@ -174,6 +174,7 @@ namespace Ryujinx.Graphics.OpenGL
                 supportsGeometryShader: true,
                 supportsGeometryShaderPassthrough: HwCapabilities.SupportsGeometryShaderPassthrough,
                 supportsTransformFeedback: true,
+                supportsImageBufferPixelAlignment: false,
                 supportsImageLoadFormatted: HwCapabilities.SupportsImageLoadFormatted,
                 supportsLayerVertexTessellation: HwCapabilities.SupportsShaderViewportLayerArray,
                 supportsMismatchingViewFormat: HwCapabilities.SupportsMismatchingViewFormat,
@@ -185,6 +186,7 @@ namespace Ryujinx.Graphics.OpenGL
                 supportsShaderBarrierDivergence: !(intelWindows || intelUnix),
                 supportsShaderFloat64: true,
                 supportsShaderNonUniformIndexing: false,
+                supportsTextureBufferPixelAlignment: false,
                 supportsTextureGatherOffsets: true,
                 supportsTextureShadowLod: HwCapabilities.SupportsTextureShadowLod,
                 supportsVertexStoreAndAtomics: true,

src/Ryujinx.Graphics.Shader/Decoders/InstDecoders.cs

@@ -522,6 +522,7 @@ namespace Ryujinx.Graphics.Shader.Decoders
 
     enum PMode
     {
+        Idx = 0,
         F4e = 1,
         B4e = 2,
         Rc8 = 3,

src/Ryujinx.Graphics.Shader/IGpuAccessor.cs

@@ -234,6 +234,24 @@ namespace Ryujinx.Graphics.Shader
             return true;
         }
 
+        /// <summary>
+        /// Queries host support for buffer image access with the buffer offset aligned to a single pixel rather than a fixed alignment.
+        /// </summary>
+        /// <returns>True if the host supports buffer image access with pixel alignment, false otherwise</returns>
+        bool QueryHostSupportsBufferImagePixelAlignment()
+        {
+            return true;
+        }
+
+        /// <summary>
+        /// Queries host support for buffer texture access with the buffer offset aligned to a single pixel rather than a fixed alignment.
+        /// </summary>
+        /// <returns>True if the host supports buffer texture access with pixel alignment, false otherwise</returns>
+        bool QueryHostSupportsBufferTexturePixelAlignment()
+        {
+            return true;
+        }
+
         /// <summary>
         /// Queries host support for fragment shader ordering critical sections on the shader code.
         /// </summary>

src/Ryujinx.Graphics.Shader/Instructions/InstEmit.cs

@@ -215,34 +215,6 @@ namespace Ryujinx.Graphics.Shader.Instructions
             context.TranslatorContext.GpuAccessor.Log("Shader instruction Pret is not implemented.");
         }
 
-        public static void PrmtR(EmitterContext context)
-        {
-            context.GetOp<InstPrmtR>();
-
-            context.TranslatorContext.GpuAccessor.Log("Shader instruction PrmtR is not implemented.");
-        }
-
-        public static void PrmtI(EmitterContext context)
-        {
-            context.GetOp<InstPrmtI>();
-
-            context.TranslatorContext.GpuAccessor.Log("Shader instruction PrmtI is not implemented.");
-        }
-
-        public static void PrmtC(EmitterContext context)
-        {
-            context.GetOp<InstPrmtC>();
-
-            context.TranslatorContext.GpuAccessor.Log("Shader instruction PrmtC is not implemented.");
-        }
-
-        public static void PrmtRc(EmitterContext context)
-        {
-            context.GetOp<InstPrmtRc>();
-
-            context.TranslatorContext.GpuAccessor.Log("Shader instruction PrmtRc is not implemented.");
-        }
-
         public static void R2b(EmitterContext context)
         {
             context.GetOp<InstR2b>();

src/Ryujinx.Graphics.Shader/Instructions/InstEmitMove.cs

@@ -1,7 +1,7 @@
 using Ryujinx.Graphics.Shader.Decoders;
 using Ryujinx.Graphics.Shader.IntermediateRepresentation;
 using Ryujinx.Graphics.Shader.Translation;
-
+using System;
 using static Ryujinx.Graphics.Shader.Instructions.InstEmitHelper;
 using static Ryujinx.Graphics.Shader.IntermediateRepresentation.OperandHelper;
 
@@ -37,6 +37,38 @@ namespace Ryujinx.Graphics.Shader.Instructions
             context.Copy(GetDest(op.Dest), GetSrcImm(context, op.Imm32));
         }
 
+        public static void PrmtR(EmitterContext context)
+        {
+            context.GetOp<InstPrmtR>();
+
+            context.TranslatorContext.GpuAccessor.Log("Shader instruction PrmtR is not implemented.");
+        }
+
+        public static void PrmtI(EmitterContext context)
+        {
+            InstPrmtI op = context.GetOp<InstPrmtI>();
+
+            Operand op1 = GetSrcReg(context, op.SrcA);
+            Operand control = GetSrcImm(context, op.Imm20);
+            Operand op2 = GetSrcReg(context, op.SrcC);
+
+            EmitPrmt(context, op1, control, op2, op.PMode, op.Dest);
+        }
+
+        public static void PrmtC(EmitterContext context)
+        {
+            context.GetOp<InstPrmtC>();
+
+            context.TranslatorContext.GpuAccessor.Log("Shader instruction PrmtC is not implemented.");
+        }
+
+        public static void PrmtRc(EmitterContext context)
+        {
+            context.GetOp<InstPrmtRc>();
+
+            context.TranslatorContext.GpuAccessor.Log("Shader instruction PrmtRc is not implemented.");
+        }
+
         public static void R2pR(EmitterContext context)
         {
             InstR2pR op = context.GetOp<InstR2pR>();
@@ -169,6 +201,39 @@ namespace Ryujinx.Graphics.Shader.Instructions
             context.Copy(GetDest(op.Dest), src);
         }
 
+        public static void SelR(EmitterContext context)
+        {
+            InstSelR op = context.GetOp<InstSelR>();
+
+            Operand srcA = GetSrcReg(context, op.SrcA);
+            Operand srcB = GetSrcReg(context, op.SrcB);
+            Operand srcPred = GetPredicate(context, op.SrcPred, op.SrcPredInv);
+
+            EmitSel(context, srcA, srcB, srcPred, op.Dest);
+        }
+
+        public static void SelI(EmitterContext context)
+        {
+            InstSelI op = context.GetOp<InstSelI>();
+
+            Operand srcA = GetSrcReg(context, op.SrcA);
+            Operand srcB = GetSrcImm(context, Imm20ToSInt(op.Imm20));
+            Operand srcPred = GetPredicate(context, op.SrcPred, op.SrcPredInv);
+
+            EmitSel(context, srcA, srcB, srcPred, op.Dest);
+        }
+
+        public static void SelC(EmitterContext context)
+        {
+            InstSelC op = context.GetOp<InstSelC>();
+
+            Operand srcA = GetSrcReg(context, op.SrcA);
+            Operand srcB = GetSrcCbuf(context, op.CbufSlot, op.CbufOffset);
+            Operand srcPred = GetPredicate(context, op.SrcPred, op.SrcPredInv);
+
+            EmitSel(context, srcA, srcB, srcPred, op.Dest);
+        }
+
         private static Operand EmitLoadSubgroupLaneId(EmitterContext context)
         {
             if (context.TranslatorContext.GpuAccessor.QueryHostSubgroupSize() <= 32)
@@ -215,37 +280,34 @@ namespace Ryujinx.Graphics.Shader.Instructions
             }
         }
 
-        public static void SelR(EmitterContext context)
+        private static void EmitPrmt(EmitterContext context, Operand op1, Operand control, Operand op2, PMode pMode, int rd)
         {
-            InstSelR op = context.GetOp<InstSelR>();
+            if (pMode == PMode.Idx)
+            {
+                Operand res = Const(0);
 
-            Operand srcA = GetSrcReg(context, op.SrcA);
-            Operand srcB = GetSrcReg(context, op.SrcB);
-            Operand srcPred = GetPredicate(context, op.SrcPred, op.SrcPredInv);
+                for (int b = 0; b < 4; b++)
+                {
+                    Operand sel = context.ShiftRightU32(control, Const(b * 4));
+                    Operand byteSel = context.BitwiseAnd(sel, Const(7));
+                    Operand copySign = context.BitwiseAnd(sel, Const(8));
 
-            EmitSel(context, srcA, srcB, srcPred, op.Dest);
-        }
+                    Operand srcOp = context.ConditionalSelect(context.BitwiseAnd(byteSel, Const(4)), op2, op1);
+                    Operand srcValue = context.ShiftRightU32(srcOp, context.ShiftLeft(context.BitwiseAnd(byteSel, Const(3)), Const(3)));
+                    Operand srcSign = context.ShiftRightS32(context.ShiftLeft(srcValue, Const(24)), Const(31));
 
-        public static void SelI(EmitterContext context)
-        {
-            InstSelI op = context.GetOp<InstSelI>();
+                    srcValue = context.ConditionalSelect(copySign, srcSign, srcValue);
+                    srcValue = context.BitwiseAnd(srcValue, Const(0xff));
 
-            Operand srcA = GetSrcReg(context, op.SrcA);
-            Operand srcB = GetSrcImm(context, Imm20ToSInt(op.Imm20));
-            Operand srcPred = GetPredicate(context, op.SrcPred, op.SrcPredInv);
+                    res = context.BitfieldInsert(res, srcValue, Const(b * 8), Const(8));
+                }
 
-            EmitSel(context, srcA, srcB, srcPred, op.Dest);
-        }
-
-        public static void SelC(EmitterContext context)
-        {
-            InstSelC op = context.GetOp<InstSelC>();
-
-            Operand srcA = GetSrcReg(context, op.SrcA);
-            Operand srcB = GetSrcCbuf(context, op.CbufSlot, op.CbufOffset);
-            Operand srcPred = GetPredicate(context, op.SrcPred, op.SrcPredInv);
-
-            EmitSel(context, srcA, srcB, srcPred, op.Dest);
+                context.Copy(GetDest(rd), res);
+            }
+            else
+            {
+                throw new NotImplementedException(pMode.ToString());
+            }
         }
 
         private static void EmitR2p(EmitterContext context, Operand value, Operand mask, ByteSel byteSel, bool ccpr)

src/Ryujinx.Graphics.Shader/IntermediateRepresentation/BasicBlock.cs

@@ -23,6 +23,7 @@ namespace Ryujinx.Graphics.Shader.IntermediateRepresentation
             set => _branch = AddSuccessor(_branch, value);
         }
 
+        public bool HasSuccessor => _branch != null || _next != null;
         public bool HasBranch => _branch != null;
         public bool Reachable => Index == 0 || Predecessors.Count != 0;
 

src/Ryujinx.Graphics.Shader/ShaderProgramInfo.cs

@@ -18,6 +18,7 @@ namespace Ryujinx.Graphics.Shader
         public bool UsesInstanceId { get; }
         public bool UsesDrawParameters { get; }
         public bool UsesRtLayer { get; }
+        public bool HasUnconditionalDiscard { get; }
         public byte ClipDistancesWritten { get; }
         public int FragmentOutputMap { get; }
 
@@ -34,6 +35,7 @@ namespace Ryujinx.Graphics.Shader
             bool usesInstanceId,
             bool usesDrawParameters,
             bool usesRtLayer,
+            bool hasUnconditionalDiscard,
             byte clipDistancesWritten,
             int fragmentOutputMap)
         {
@@ -50,6 +52,7 @@ namespace Ryujinx.Graphics.Shader
             UsesInstanceId = usesInstanceId;
             UsesDrawParameters = usesDrawParameters;
             UsesRtLayer = usesRtLayer;
+            HasUnconditionalDiscard = hasUnconditionalDiscard;
             ClipDistancesWritten = clipDistancesWritten;
             FragmentOutputMap = fragmentOutputMap;
         }

src/Ryujinx.Graphics.Shader/SupportBuffer.cs

@@ -24,6 +24,7 @@ namespace Ryujinx.Graphics.Shader
         RenderScale,
         TfeOffset,
         TfeVertexCount,
+        BufferTextureOffset,
     }
 
     public struct SupportBuffer
@@ -42,10 +43,13 @@ namespace Ryujinx.Graphics.Shader
         public static readonly int ComputeRenderScaleOffset;
         public static readonly int TfeOffsetOffset;
         public static readonly int TfeVertexCountOffset;
+        public static readonly int BufferTextureOffsetOffset;
 
         public const int FragmentIsBgraCount = 8;
+        public const int TextureCount = 64;
+
         // One for the render target, 64 for the textures, and 8 for the images.
-        public const int RenderScaleMaxCount = 1 + 64 + 8;
+        public const int RenderScaleMaxCount = 1 + TextureCount + 8;
 
         private static int OffsetOf<T>(ref SupportBuffer storage, ref T target)
         {
@@ -68,6 +72,7 @@ namespace Ryujinx.Graphics.Shader
             ComputeRenderScaleOffset = GraphicsRenderScaleOffset + FieldSize;
             TfeOffsetOffset = OffsetOf(ref instance, ref instance.TfeOffset);
             TfeVertexCountOffset = OffsetOf(ref instance, ref instance.TfeVertexCount);
+            BufferTextureOffsetOffset = OffsetOf(ref instance, ref instance.BufferTextureOffset);
         }
 
         internal static StructureType GetStructureType()
@@ -80,7 +85,8 @@ namespace Ryujinx.Graphics.Shader
                 new StructureField(AggregateType.S32, "frag_scale_count"),
                 new StructureField(AggregateType.Array | AggregateType.FP32, "render_scale", RenderScaleMaxCount),
                 new StructureField(AggregateType.Vector4 | AggregateType.S32, "tfe_offset"),
-                new StructureField(AggregateType.S32, "tfe_vertex_count")
+                new StructureField(AggregateType.S32, "tfe_vertex_count"),
+                new StructureField(AggregateType.Array | AggregateType.Vector2 | AggregateType.S32, "buffer_texture_offset")
             ]);
         }
 
@@ -95,5 +101,7 @@ namespace Ryujinx.Graphics.Shader
 
         public Vector4<int> TfeOffset;
         public Vector4<int> TfeVertexCount;
+
+        public Array5<Array64<Vector4<int>>> BufferTextureOffset;
     }
 }

src/Ryujinx.Graphics.Shader/Translation/FeatureFlags.cs

@@ -26,5 +26,6 @@ namespace Ryujinx.Graphics.Shader.Translation
         SharedMemory = 1 << 11,
         Store = 1 << 12,
         VtgAsCompute = 1 << 13,
+        UnconditionalDiscard = 1 << 14,
     }
 }

src/Ryujinx.Graphics.Shader/Translation/FeatureIdentification.cs

@@ -0,0 +1,38 @@
+using Ryujinx.Graphics.Shader.IntermediateRepresentation;
+
+namespace Ryujinx.Graphics.Shader.Translation
+{
+    static class FeatureIdentification
+    {
+        public static void RunPass(BasicBlock[] blocks, ShaderStage stage, ref FeatureFlags usedFeatures)
+        {
+            if (stage == ShaderStage.Fragment)
+            {
+                bool endsWithDiscardOnly = true;
+
+                for (int blockIndex = 0; blockIndex < blocks.Length; blockIndex++)
+                {
+                    BasicBlock block = blocks[blockIndex];
+
+                    if (block.HasSuccessor)
+                    {
+                        continue;
+                    }
+
+                    if (block.Operations.Count == 0 ||
+                        block.Operations.Last.Value is not Operation operation ||
+                        operation.Inst != Instruction.Discard)
+                    {
+                        endsWithDiscardOnly = false;
+                        break;
+                    }
+                }
+
+                if (endsWithDiscardOnly)
+                {
+                    usedFeatures |= FeatureFlags.UnconditionalDiscard;
+                }
+            }
+        }
+    }
+}

src/Ryujinx.Graphics.Shader/Translation/ResourceManager.cs

@@ -43,6 +43,11 @@ namespace Ryujinx.Graphics.Shader.Translation
         private readonly Dictionary<TextureInfo, TextureMeta> _usedTextures;
         private readonly Dictionary<TextureInfo, TextureMeta> _usedImages;
 
+        private readonly List<BufferDefinition> _vacConstantBuffers;
+        private readonly List<BufferDefinition> _vacStorageBuffers;
+        private readonly List<TextureDefinition> _vacTextures;
+        private readonly List<TextureDefinition> _vacImages;
+
         public int LocalMemoryId { get; private set; }
         public int SharedMemoryId { get; private set; }
 
@@ -78,6 +83,11 @@ namespace Ryujinx.Graphics.Shader.Translation
             _usedTextures = new();
             _usedImages = new();
 
+            _vacConstantBuffers = new();
+            _vacStorageBuffers = new();
+            _vacTextures = new();
+            _vacImages = new();
+
             Properties.AddOrUpdateConstantBuffer(new(BufferLayout.Std140, 0, SupportBuffer.Binding, "support_buffer", SupportBuffer.GetStructureType()));
 
             LocalMemoryId = -1;
@@ -563,6 +573,76 @@ namespace Ryujinx.Graphics.Shader.Translation
             return descriptors.ToArray();
         }
 
+        public ShaderProgramInfo GetVertexAsComputeInfo(bool isVertex = false)
+        {
+            var cbDescriptors = new BufferDescriptor[_vacConstantBuffers.Count];
+            int cbDescriptorIndex = 0;
+
+            foreach (BufferDefinition definition in _vacConstantBuffers)
+            {
+                cbDescriptors[cbDescriptorIndex++] = new BufferDescriptor(definition.Set, definition.Binding, 0, 0, 0, BufferUsageFlags.None);
+            }
+
+            var sbDescriptors = new BufferDescriptor[_vacStorageBuffers.Count];
+            int sbDescriptorIndex = 0;
+
+            foreach (BufferDefinition definition in _vacStorageBuffers)
+            {
+                sbDescriptors[sbDescriptorIndex++] = new BufferDescriptor(definition.Set, definition.Binding, 0, 0, 0, BufferUsageFlags.Write);
+            }
+
+            var tDescriptors = new TextureDescriptor[_vacTextures.Count];
+            int tDescriptorIndex = 0;
+
+            foreach (TextureDefinition definition in _vacTextures)
+            {
+                tDescriptors[tDescriptorIndex++] = new TextureDescriptor(
+                    definition.Set,
+                    definition.Binding,
+                    definition.Type,
+                    definition.Format,
+                    0,
+                    0,
+                    definition.ArrayLength,
+                    definition.Separate,
+                    definition.Flags);
+            }
+
+            var iDescriptors = new TextureDescriptor[_vacImages.Count];
+            int iDescriptorIndex = 0;
+
+            foreach (TextureDefinition definition in _vacImages)
+            {
+                iDescriptors[iDescriptorIndex++] = new TextureDescriptor(
+                    definition.Set,
+                    definition.Binding,
+                    definition.Type,
+                    definition.Format,
+                    0,
+                    0,
+                    definition.ArrayLength,
+                    definition.Separate,
+                    definition.Flags);
+            }
+
+            return new ShaderProgramInfo(
+                cbDescriptors,
+                sbDescriptors,
+                tDescriptors,
+                iDescriptors,
+                isVertex ? ShaderStage.Vertex : ShaderStage.Compute,
+                0,
+                0,
+                0,
+                false,
+                false,
+                false,
+                false,
+                false,
+                0,
+                0);
+        }
+
         public bool TryGetCbufSlotAndHandleForTexture(int binding, out int cbufSlot, out int handle)
         {
             foreach ((TextureInfo info, TextureMeta meta) in _usedTextures)
@@ -627,6 +707,30 @@ namespace Ryujinx.Graphics.Shader.Translation
             Properties.AddOrUpdateStorageBuffer(new(BufferLayout.Std430, setIndex, binding, name, type));
         }
 
+        public void AddVertexAsComputeConstantBuffer(BufferDefinition definition)
+        {
+            _vacConstantBuffers.Add(definition);
+            Properties.AddOrUpdateConstantBuffer(definition);
+        }
+
+        public void AddVertexAsComputeStorageBuffer(BufferDefinition definition)
+        {
+            _vacStorageBuffers.Add(definition);
+            Properties.AddOrUpdateStorageBuffer(definition);
+        }
+
+        public void AddVertexAsComputeTexture(TextureDefinition definition)
+        {
+            _vacTextures.Add(definition);
+            Properties.AddOrUpdateTexture(definition);
+        }
+
+        public void AddVertexAsComputeImage(TextureDefinition definition)
+        {
+            _vacImages.Add(definition);
+            Properties.AddOrUpdateImage(definition);
+        }
+
         public static string GetShaderStagePrefix(ShaderStage stage)
         {
             uint index = (uint)stage;

src/Ryujinx.Graphics.Shader/Translation/Transforms/TexturePass.cs

@@ -1,4 +1,5 @@
 using Ryujinx.Graphics.Shader.IntermediateRepresentation;
+using Ryujinx.Graphics.Shader.Translation.Optimizations;
 using System.Collections.Generic;
 using System.Linq;
 using static Ryujinx.Graphics.Shader.IntermediateRepresentation.OperandHelper;
@@ -27,7 +28,19 @@ namespace Ryujinx.Graphics.Shader.Translation.Transforms
 
                     if (texOp.Type == SamplerType.TextureBuffer && !context.GpuAccessor.QueryHostSupportsSnormBufferTextureFormat())
                     {
-                        node = InsertSnormNormalization(node, context.ResourceManager, context.GpuAccessor);
+                        if (!context.GpuAccessor.QueryHostSupportsSnormBufferTextureFormat())
+                        {
+                            node = InsertSnormNormalization(node, context.ResourceManager, context.GpuAccessor);
+                        }
+
+                        if (!context.GpuAccessor.QueryHostSupportsBufferTexturePixelAlignment())
+                        {
+                            node = InsertCoordOffset(node, context.ResourceManager, context.Stage, isImage: false);
+                        }
+                    }
+                    else if (!context.GpuAccessor.QueryHostSupportsBufferTexturePixelAlignment() && texOp.Inst.IsImage())
+                    {
+                        node = InsertCoordOffset(node, context.ResourceManager, context.Stage, isImage: true);
                     }
                 }
             }
@@ -278,6 +291,87 @@ namespace Ryujinx.Graphics.Shader.Translation.Transforms
             return node;
         }
 
+        private static LinkedListNode<INode> InsertCoordOffset(LinkedListNode<INode> node, ResourceManager resourceManager, ShaderStage stage, bool isImage)
+        {
+            // Some GPUs have fixed alignment requirements for buffer textures.
+            // For those cases, we bind the aligned buffer offset, and apply the remaining offset on the shader.
+
+            TextureOperation texOp = (TextureOperation)node.Value;
+
+            if ((texOp.Type & SamplerType.Mask) != SamplerType.TextureBuffer)
+            {
+                return node;
+            }
+
+            Operand[] sources = new Operand[texOp.SourcesCount];
+
+            for (int i = 0; i < texOp.SourcesCount; i++)
+            {
+                sources[i] = texOp.GetSource(i);
+            }
+
+            bool isBindless = (texOp.Flags & TextureFlags.Bindless) != 0;
+            bool isIndexed = resourceManager.IsArrayOfTexturesOrImages(texOp.Binding, isImage);
+
+            int coordsIndex = isBindless || isIndexed ? 1 : 0;
+
+            Operand[] dests = new Operand[texOp.DestsCount];
+
+            for (int i = 0; i < texOp.DestsCount; i++)
+            {
+                dests[i] = texOp.GetDest(i);
+            }
+
+            LinkedListNode<INode> oldNode = node;
+
+            Operand source = sources[coordsIndex];
+            Operand offset = Local();
+            Operand coordPlusOffset = Local();
+
+            int stageIndex = stage switch
+            {
+                ShaderStage.TessellationControl => 1,
+                ShaderStage.TessellationEvaluation => 2,
+                ShaderStage.Geometry => 3,
+                ShaderStage.Fragment => 4,
+                _ => 0,
+            };
+
+            int bindingIndex = isImage
+                ? resourceManager.FindImageDescriptorIndex(texOp.Binding)
+                : resourceManager.FindTextureDescriptorIndex(texOp.Binding);
+
+            node.List.AddBefore(node, new Operation(
+                Instruction.Load,
+                StorageKind.ConstantBuffer,
+                offset,
+                Const(SupportBuffer.Binding),
+                Const((int)SupportBufferField.BufferTextureOffset),
+                Const(stageIndex * SupportBuffer.TextureCount + bindingIndex),
+                Const(isImage ? 1 : 0)));
+
+            node.List.AddBefore(node, new Operation(Instruction.Add, coordPlusOffset, source, offset));
+
+            sources[coordsIndex] = coordPlusOffset;
+
+            TextureOperation newTexOp = new(
+                texOp.Inst,
+                texOp.Type,
+                texOp.Format,
+                texOp.Flags,
+                texOp.Set,
+                texOp.Binding,
+                texOp.Index,
+                dests,
+                sources);
+
+            node = node.List.AddBefore(node, newTexOp);
+
+            Utils.DeleteNode(oldNode, texOp);
+
+            return node;
+        }
+
         private static LinkedListNode<INode> InsertConstOffsets(LinkedListNode<INode> node, ResourceManager resourceManager, IGpuAccessor gpuAccessor, ShaderStage stage)
         {
             // Non-constant texture offsets are not allowed (according to the spec),

src/Ryujinx.Graphics.Shader/Translation/TranslatorContext.cs

@@ -301,6 +301,11 @@ namespace Ryujinx.Graphics.Shader.Translation
 
                     Optimizer.RunPass(context);
                     TransformPasses.RunPass(context);
+
+                    if (i == 0)
+                    {
+                        FeatureIdentification.RunPass(cfg.Blocks, Definitions.Stage, ref usedFeatures);
+                    }
                 }
 
                 funcs[i] = new Function(cfg.Blocks, $"fun{i}", false, inArgumentsCount, outArgumentsCount);
@@ -353,6 +358,7 @@ namespace Ryujinx.Graphics.Shader.Translation
                 usedFeatures.HasFlag(FeatureFlags.InstanceId),
                 usedFeatures.HasFlag(FeatureFlags.DrawParameters),
                 usedFeatures.HasFlag(FeatureFlags.RtLayer),
+                usedFeatures.HasFlag(FeatureFlags.UnconditionalDiscard),
                 clipDistancesWritten,
                 originalDefinitions.OmapTargets);
 
@@ -393,7 +399,7 @@ namespace Ryujinx.Graphics.Shader.Translation
                 {
                     int binding = resourceManager.Reservations.GetTfeBufferStorageBufferBinding(i);
                     BufferDefinition tfeDataBuffer = new(BufferLayout.Std430, 1, binding, $"tfe_data{i}", tfeDataStruct);
-                    resourceManager.Properties.AddOrUpdateStorageBuffer(tfeDataBuffer);
+                    resourceManager.AddVertexAsComputeStorageBuffer(tfeDataBuffer);
                 }
             }
 
@@ -401,7 +407,7 @@ namespace Ryujinx.Graphics.Shader.Translation
             {
                 int vertexInfoCbBinding = resourceManager.Reservations.VertexInfoConstantBufferBinding;
                 BufferDefinition vertexInfoBuffer = new(BufferLayout.Std140, 0, vertexInfoCbBinding, "vb_info", VertexInfoBuffer.GetStructureType());
-                resourceManager.Properties.AddOrUpdateConstantBuffer(vertexInfoBuffer);
+                resourceManager.AddVertexAsComputeConstantBuffer(vertexInfoBuffer);
 
                 StructureType vertexOutputStruct = new([
                     new StructureField(AggregateType.Array | AggregateType.FP32, "data", 0)
@@ -409,13 +415,13 @@ namespace Ryujinx.Graphics.Shader.Translation
 
                 int vertexOutputSbBinding = resourceManager.Reservations.VertexOutputStorageBufferBinding;
                 BufferDefinition vertexOutputBuffer = new(BufferLayout.Std430, 1, vertexOutputSbBinding, "vertex_output", vertexOutputStruct);
-                resourceManager.Properties.AddOrUpdateStorageBuffer(vertexOutputBuffer);
+                resourceManager.AddVertexAsComputeStorageBuffer(vertexOutputBuffer);
 
                 if (Stage == ShaderStage.Vertex)
                 {
                     SetBindingPair ibSetAndBinding = resourceManager.Reservations.GetIndexBufferTextureSetAndBinding();
                     TextureDefinition indexBuffer = new(ibSetAndBinding.SetIndex, ibSetAndBinding.Binding, "ib_data", SamplerType.TextureBuffer);
-                    resourceManager.Properties.AddOrUpdateTexture(indexBuffer);
+                    resourceManager.AddVertexAsComputeTexture(indexBuffer);
 
                     int inputMap = _program.AttributeUsage.UsedInputAttributes;
 
@@ -424,7 +430,7 @@ namespace Ryujinx.Graphics.Shader.Translation
                         int location = BitOperations.TrailingZeroCount(inputMap);
                         SetBindingPair setAndBinding = resourceManager.Reservations.GetVertexBufferTextureSetAndBinding(location);
                         TextureDefinition vaBuffer = new(setAndBinding.SetIndex, setAndBinding.Binding, $"vb_data{location}", SamplerType.TextureBuffer);
-                        resourceManager.Properties.AddOrUpdateTexture(vaBuffer);
+                        resourceManager.AddVertexAsComputeTexture(vaBuffer);
 
                         inputMap &= ~(1 << location);
                     }
@@ -433,11 +439,11 @@ namespace Ryujinx.Graphics.Shader.Translation
                 {
                     SetBindingPair trbSetAndBinding = resourceManager.Reservations.GetTopologyRemapBufferTextureSetAndBinding();
                     TextureDefinition remapBuffer = new(trbSetAndBinding.SetIndex, trbSetAndBinding.Binding, "trb_data", SamplerType.TextureBuffer);
-                    resourceManager.Properties.AddOrUpdateTexture(remapBuffer);
+                    resourceManager.AddVertexAsComputeTexture(remapBuffer);
 
                     int geometryVbOutputSbBinding = resourceManager.Reservations.GeometryVertexOutputStorageBufferBinding;
                     BufferDefinition geometryVbOutputBuffer = new(BufferLayout.Std430, 1, geometryVbOutputSbBinding, "geometry_vb_output", vertexOutputStruct);
-                    resourceManager.Properties.AddOrUpdateStorageBuffer(geometryVbOutputBuffer);
+                    resourceManager.AddVertexAsComputeStorageBuffer(geometryVbOutputBuffer);
 
                     StructureType geometryIbOutputStruct = new([
                         new StructureField(AggregateType.Array | AggregateType.U32, "data", 0)
@@ -445,7 +451,7 @@ namespace Ryujinx.Graphics.Shader.Translation
 
                     int geometryIbOutputSbBinding = resourceManager.Reservations.GeometryIndexOutputStorageBufferBinding;
                     BufferDefinition geometryIbOutputBuffer = new(BufferLayout.Std430, 1, geometryIbOutputSbBinding, "geometry_ib_output", geometryIbOutputStruct);
-                    resourceManager.Properties.AddOrUpdateStorageBuffer(geometryIbOutputBuffer);
+                    resourceManager.AddVertexAsComputeStorageBuffer(geometryIbOutputBuffer);
                 }
 
                 resourceManager.SetVertexAsComputeLocalMemories(Definitions.Stage, Definitions.InputTopology);
@@ -478,12 +484,17 @@ namespace Ryujinx.Graphics.Shader.Translation
             return new ResourceReservations(GpuAccessor, IsTransformFeedbackEmulated, vertexAsCompute: true, _vertexOutput, ioUsage);
         }
 
+        public ShaderProgramInfo GetVertexAsComputeInfo()
+        {
+            return CreateResourceManager(true).GetVertexAsComputeInfo();
+        }
+
         public void SetVertexOutputMapForGeometryAsCompute(TranslatorContext vertexContext)
         {
             _vertexOutput = vertexContext._program.GetIoUsage();
         }
 
-        public ShaderProgram GenerateVertexPassthroughForCompute()
+        public (ShaderProgram, ShaderProgramInfo) GenerateVertexPassthroughForCompute()
         {
             AttributeUsage attributeUsage = new(GpuAccessor);
             ResourceManager resourceManager = new(ShaderStage.Vertex, GpuAccessor);
@@ -495,7 +506,7 @@ namespace Ryujinx.Graphics.Shader.Translation
             if (Stage == ShaderStage.Vertex)
             {
                 BufferDefinition vertexInfoBuffer = new(BufferLayout.Std140, 0, vertexInfoCbBinding, "vb_info", VertexInfoBuffer.GetStructureType());
-                resourceManager.Properties.AddOrUpdateConstantBuffer(vertexInfoBuffer);
+                resourceManager.AddVertexAsComputeConstantBuffer(vertexInfoBuffer);
             }
 
             StructureType vertexInputStruct = new([
@@ -504,7 +515,7 @@ namespace Ryujinx.Graphics.Shader.Translation
 
             int vertexDataSbBinding = reservations.VertexOutputStorageBufferBinding;
             BufferDefinition vertexOutputBuffer = new(BufferLayout.Std430, 1, vertexDataSbBinding, "vb_input", vertexInputStruct);
-            resourceManager.Properties.AddOrUpdateStorageBuffer(vertexOutputBuffer);
+            resourceManager.AddVertexAsComputeStorageBuffer(vertexOutputBuffer);
 
             EmitterContext context = new();
 
@@ -562,14 +573,14 @@ namespace Ryujinx.Graphics.Shader.Translation
                 LastInVertexPipeline = true
             };
 
-            return Generate(
+            return (Generate(
                 [function],
                 attributeUsage,
                 definitions,
                 definitions,
                 resourceManager,
                 FeatureFlags.None,
-                0);
+                0), resourceManager.GetVertexAsComputeInfo(isVertex: true));
         }
 
         public ShaderProgram GenerateGeometryPassthrough()

src/Ryujinx.Graphics.Vulkan/BackgroundResources.cs

@@ -36,6 +36,7 @@ namespace Ryujinx.Graphics.Vulkan
                         queueLock,
                         _gd.QueueFamilyIndex,
                         _gd.IsQualcommProprietary,
+                        _gd.IsTurnip,
                         isLight: true);
                 }
             }

src/Ryujinx.Graphics.Vulkan/CommandBufferPool.cs

@@ -19,6 +19,7 @@ namespace Ryujinx.Graphics.Vulkan
         private readonly Queue _queue;
         private readonly Lock _queueLock;
         private readonly bool _concurrentFenceWaitUnsupported;
+        private readonly bool _fenceAlwaysWaits;
         private readonly CommandPool _pool;
         private readonly Thread _owner;
 
@@ -66,6 +67,7 @@ namespace Ryujinx.Graphics.Vulkan
             Lock queueLock,
             uint queueFamilyIndex,
             bool concurrentFenceWaitUnsupported,
+            bool fenceAlwaysWaits,
             bool isLight = false)
         {
             _api = api;
@@ -73,6 +75,7 @@ namespace Ryujinx.Graphics.Vulkan
             _queue = queue;
             _queueLock = queueLock;
             _concurrentFenceWaitUnsupported = concurrentFenceWaitUnsupported;
+            _fenceAlwaysWaits = fenceAlwaysWaits;
             _owner = Thread.CurrentThread;
 
             CommandPoolCreateInfo commandPoolCreateInfo = new()
@@ -207,7 +210,7 @@ namespace Ryujinx.Graphics.Vulkan
 
                 ref ReservedCommandBuffer entry = ref _commandBuffers[index];
 
-                if (wait || !entry.InConsumption || entry.Fence.IsSignaled())
+                if (wait || !entry.InConsumption || entry.Fence.IsSignaledLazy())
                 {
                     WaitAndDecrementRef(index);
 
@@ -349,7 +352,7 @@ namespace Ryujinx.Graphics.Vulkan
 
             if (refreshFence)
             {
-                entry.Fence = new FenceHolder(_api, _device, _concurrentFenceWaitUnsupported);
+                entry.Fence = new FenceHolder(_api, _device, _concurrentFenceWaitUnsupported, _fenceAlwaysWaits);
             }
             else
             {

src/Ryujinx.Graphics.Vulkan/FenceHolder.cs

@@ -12,13 +12,15 @@ namespace Ryujinx.Graphics.Vulkan
         private int _referenceCount;
         private int _lock;
         private readonly bool _concurrentWaitUnsupported;
+        private readonly bool _alwaysWaits;
         private bool _disposed;
 
-        public unsafe FenceHolder(Vk api, Device device, bool concurrentWaitUnsupported)
+        public unsafe FenceHolder(Vk api, Device device, bool concurrentWaitUnsupported, bool alwaysWaits)
         {
             _api = api;
             _device = device;
             _concurrentWaitUnsupported = concurrentWaitUnsupported;
+            _alwaysWaits = alwaysWaits;
 
             FenceCreateInfo fenceCreateInfo = new()
             {
@@ -123,6 +125,16 @@ namespace Ryujinx.Graphics.Vulkan
             }
         }
 
+        public bool IsSignaledLazy()
+        {
+            if (_alwaysWaits)
+            {
+                return false;
+            }
+
+            return IsSignaled();
+        }
+
         public bool IsSignaled()
         {
             if (_concurrentWaitUnsupported)

src/Ryujinx.Graphics.Vulkan/MoltenVK/MVKConfiguration.cs

@@ -0,0 +1,104 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.Graphics.Vulkan.MoltenVK
+{
+    enum MVKConfigLogLevel
+    {
+        None = 0,
+        Error = 1,
+        Warning = 2,
+        Info = 3,
+        Debug = 4,
+    }
+
+    enum MVKConfigTraceVulkanCalls
+    {
+        None = 0,
+        Enter = 1,
+        EnterExit = 2,
+        Duration = 3,
+    }
+
+    enum MVKConfigAutoGPUCaptureScope
+    {
+        None = 0,
+        Device = 1,
+        Frame = 2,
+    }
+
+    [Flags]
+    enum MVKConfigAdvertiseExtensions
+    {
+        All = 0x00000001,
+        MoltenVK = 0x00000002,
+        WSI = 0x00000004,
+        Portability = 0x00000008,
+    }
+
+    enum MVKVkSemaphoreSupportStyle
+    {
+        MVK_CONFIG_VK_SEMAPHORE_SUPPORT_STYLE_SINGLE_QUEUE = 0,
+        MVK_CONFIG_VK_SEMAPHORE_SUPPORT_STYLE_METAL_EVENTS_WHERE_SAFE = 1,
+        MVK_CONFIG_VK_SEMAPHORE_SUPPORT_STYLE_METAL_EVENTS = 2,
+        MVK_CONFIG_VK_SEMAPHORE_SUPPORT_STYLE_CALLBACK = 3,
+        MVK_CONFIG_VK_SEMAPHORE_SUPPORT_STYLE_MAX_ENUM = 0x7FFFFFFF,
+    }
+
+    readonly struct Bool32
+    {
+        uint Value { get; }
+
+        public Bool32(uint value)
+        {
+            Value = value;
+        }
+
+        public Bool32(bool value)
+        {
+            Value = value ? 1u : 0u;
+        }
+
+        public static implicit operator bool(Bool32 val) => val.Value == 1;
+        public static implicit operator Bool32(bool val) => new(val);
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    struct MVKConfiguration
+    {
+        public Bool32 DebugMode;
+        public Bool32 ShaderConversionFlipVertexY;
+        public Bool32 SynchronousQueueSubmits;
+        public Bool32 PrefillMetalCommandBuffers;
+        public uint MaxActiveMetalCommandBuffersPerQueue;
+        public Bool32 SupportLargeQueryPools;
+        public Bool32 PresentWithCommandBuffer;
+        public Bool32 SwapchainMagFilterUseNearest;
+        public ulong MetalCompileTimeout;
+        public Bool32 PerformanceTracking;
+        public uint PerformanceLoggingFrameCount;
+        public Bool32 DisplayWatermark;
+        public Bool32 SpecializedQueueFamilies;
+        public Bool32 SwitchSystemGPU;
+        public Bool32 FullImageViewSwizzle;
+        public uint DefaultGPUCaptureScopeQueueFamilyIndex;
+        public uint DefaultGPUCaptureScopeQueueIndex;
+        public Bool32 FastMathEnabled;
+        public MVKConfigLogLevel LogLevel;
+        public MVKConfigTraceVulkanCalls TraceVulkanCalls;
+        public Bool32 ForceLowPowerGPU;
+        public Bool32 SemaphoreUseMTLFence;
+        public MVKVkSemaphoreSupportStyle SemaphoreSupportStyle;
+        public MVKConfigAutoGPUCaptureScope AutoGPUCaptureScope;
+        public nint AutoGPUCaptureOutputFilepath;
+        public Bool32 Texture1DAs2D;
+        public Bool32 PreallocateDescriptors;
+        public Bool32 UseCommandPooling;
+        public Bool32 UseMTLHeap;
+        public Bool32 LogActivityPerformanceInline;
+        public uint ApiVersionToAdvertise;
+        public MVKConfigAdvertiseExtensions AdvertiseExtensions;
+        public Bool32 ResumeLostDevice;
+        public Bool32 UseMetalArgumentBuffers;
+    }
+}

src/Ryujinx.Graphics.Vulkan/MoltenVK/MVKInitialization.cs

@@ -0,0 +1,51 @@
+using Silk.NET.Core.Loader;
+using Silk.NET.Vulkan;
+using System;
+using System.Runtime.InteropServices;
+using System.Runtime.Versioning;
+
+namespace Ryujinx.Graphics.Vulkan.MoltenVK
+{
+    [SupportedOSPlatform("macos")]
+    public static partial class MVKInitialization
+    {
+        private const string VulkanLib = "libvulkan.dylib";
+
+        [LibraryImport("libMoltenVK.dylib")]
+        private static partial Result vkGetMoltenVKConfigurationMVK(nint unusedInstance, out MVKConfiguration config, in nint configSize);
+
+        [LibraryImport("libMoltenVK.dylib")]
+        private static partial Result vkSetMoltenVKConfigurationMVK(nint unusedInstance, in MVKConfiguration config, in nint configSize);
+
+        public static void Initialize()
+        {
+            IntPtr configSize = (nint)Marshal.SizeOf<MVKConfiguration>();
+
+            vkGetMoltenVKConfigurationMVK(nint.Zero, out MVKConfiguration config, configSize);
+
+            config.UseMetalArgumentBuffers = true;
+
+            config.SemaphoreSupportStyle = MVKVkSemaphoreSupportStyle.MVK_CONFIG_VK_SEMAPHORE_SUPPORT_STYLE_SINGLE_QUEUE;
+            config.SynchronousQueueSubmits = false;
+
+            config.ResumeLostDevice = true;
+
+            vkSetMoltenVKConfigurationMVK(nint.Zero, config, configSize);
+        }
+
+        private static string[] Resolver(string path)
+        {
+            if (path.EndsWith(VulkanLib))
+            {
+                path = path[..^VulkanLib.Length] + "libMoltenVK.dylib";
+                return [path];
+            }
+            return [];
+        }
+
+        public static void InitializeResolver()
+        {
+            ((DefaultPathResolver)PathResolver.Default).Resolvers.Insert(0, Resolver);
+        }
+    }
+}

src/Ryujinx.Graphics.Vulkan/Ryujinx.Graphics.Vulkan.csproj

@@ -44,7 +44,6 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Ryujinx.SPB" />
     <PackageReference Include="Silk.NET.Shaderc" ExcludeAssets="native" />
     <PackageReference Include="Silk.NET.Vulkan" />
     <PackageReference Include="Silk.NET.Vulkan.Extensions.EXT" />

src/Ryujinx.Graphics.Vulkan/ShaderCollection.cs

@@ -60,7 +60,7 @@ namespace Ryujinx.Graphics.Vulkan
 
         private ProgramPipelineState _state;
         private DisposableRenderPass _dummyRenderPass;
-        private readonly Task _compileTask;
+        private ShaderCompilationRequest _compileRequest;
         private bool _firstBackgroundUse;
 
         public ShaderCollection(
@@ -139,7 +139,7 @@ namespace Ryujinx.Graphics.Vulkan
             // Updating buffer texture bindings using template updates crashes the Adreno driver on Windows.
             UpdateTexturesWithoutTemplate = gd.IsQualcommProprietary && usesBufferTextures;
 
-            _compileTask = Task.CompletedTask;
+            _compileRequest = new ShaderCompilationRequest(Task.CompletedTask);
             _firstBackgroundUse = false;
         }
 
@@ -153,7 +153,9 @@ namespace Ryujinx.Graphics.Vulkan
         {
             _state = state;
 
-            _compileTask = BackgroundCompilation();
+            _compileRequest = gd.ShaderCompilationQueue != null
+                ? gd.ShaderCompilationQueue.Add(BackgroundCompilation)
+                : new ShaderCompilationRequest(BackgroundCompilationAsync());
             _firstBackgroundUse = !fromCache;
         }
 
@@ -458,10 +460,25 @@ namespace Ryujinx.Graphics.Vulkan
             return (buffer, texture);
         }
 
-        private async Task BackgroundCompilation()
+        private async Task BackgroundCompilationAsync()
         {
             await Task.WhenAll(_shaders.Select(shader => shader.CompileTask));
 
+            BackgroundCompilationImpl();
+        }
+
+        private void BackgroundCompilation()
+        {
+            foreach (var shader in _shaders)
+            {
+                shader.CompileTask.Wait();
+            }
+
+            BackgroundCompilationImpl();
+        }
+
+        private void BackgroundCompilationImpl()
+        {
             if (Array.Exists(_shaders, shader => shader.CompileStatus == ProgramLinkStatus.Failure))
             {
                 LinkStatus = ProgramLinkStatus.Failure;
@@ -604,11 +621,11 @@ namespace Ryujinx.Graphics.Vulkan
                     }
                 }
 
-                if (!_compileTask.IsCompleted)
+                if (!_compileRequest.IsCompleted)
                 {
                     if (blocking)
                     {
-                        _compileTask.Wait();
+                        _compileRequest.Wait();
 
                         if (LinkStatus == ProgramLinkStatus.Failure)
                         {

src/Ryujinx.Graphics.Vulkan/ShaderCompilationQueue.cs

@@ -0,0 +1,131 @@
+using System;
+using System.Collections.Concurrent;
+using System.Threading;
+
+namespace Ryujinx.Graphics.Vulkan
+{
+    class ShaderCompilationQueue
+    {
+        private const int MaxParallelCompilations = 8;
+        private const int MaxThreadStackSize = 2 * 1024 * 1024; // MB
+
+        private struct Request
+        {
+            public readonly ulong Id;
+            public readonly Action Callback;
+
+            public Request(ulong id, Action callback)
+            {
+                Id = id;
+                Callback = callback;
+            }
+        }
+
+        private readonly Thread[] _workerThreads;
+        private readonly CancellationTokenSource _cts;
+        private readonly BlockingCollection<Request>[] _queues;
+        private readonly ulong[] _finishedIds;
+        private ulong _currentId;
+        private int _currentQueueIndex;
+
+        public ShaderCompilationQueue()
+        {
+            _workerThreads = new Thread[MaxParallelCompilations];
+            _queues = new BlockingCollection<Request>[MaxParallelCompilations];
+            _finishedIds = new ulong[MaxParallelCompilations];
+
+            _cts = new CancellationTokenSource();
+
+            for (int i = 0; i < MaxParallelCompilations; i++)
+            {
+                _queues[i] = new BlockingCollection<Request>();
+
+                Thread thread = new Thread(DoWork, MaxThreadStackSize) { Name = $"BackgroundShaderCompiler.{i}" };
+                thread.IsBackground = true;
+                thread.Start(i);
+
+                _workerThreads[i] = thread;
+            }
+        }
+
+        private void DoWork(object threadId)
+        {
+            int queueIndex = (int)threadId;
+
+            try
+            {
+                var queue = _queues[queueIndex];
+
+                foreach (var request in queue.GetConsumingEnumerable(_cts.Token))
+                {
+                    request.Callback();
+
+                    lock (queue)
+                    {
+                        _finishedIds[queueIndex] = request.Id;
+
+                        Monitor.PulseAll(queue);
+                    }
+                }
+            }
+            catch (OperationCanceledException)
+            {
+            }
+        }
+
+        public ShaderCompilationRequest Add(Action callback)
+        {
+            ulong newId = Interlocked.Increment(ref _currentId);
+
+            // Let's keep rotating between the queues to increase the chances
+            // that the selected queue thread is currently idle.
+            int queueIndex = Interlocked.Increment(ref _currentQueueIndex) % MaxParallelCompilations;
+
+            _queues[queueIndex].Add(new Request(newId, callback));
+
+            return new ShaderCompilationRequest(this, queueIndex, newId);
+        }
+
+        public void Wait(int queueIndex, ulong id)
+        {
+            var queue = _queues[queueIndex];
+
+            lock (queue)
+            {
+                while (_finishedIds[queueIndex] < id)
+                {
+                    Monitor.Wait(queue);
+                }
+            }
+        }
+
+        public bool IsCompleted(int queueIndex, ulong id)
+        {
+            var queue = _queues[queueIndex];
+
+            lock (queue)
+            {
+                return _finishedIds[queueIndex] >= id;
+            }
+        }
+
+        public void Dispose()
+        {
+            for (int i = 0; i < MaxParallelCompilations; i++)
+            {
+                _queues[i].CompleteAdding();
+            }
+
+            _cts.Cancel();
+
+            for (int i = 0; i < MaxParallelCompilations; i++)
+            {
+                _workerThreads[i].Join();
+
+                _queues[i].Dispose();
+            }
+
+            _cts.Dispose();
+        }
+    }
+}

src/Ryujinx.Graphics.Vulkan/ShaderCompilationRequest.cs

@@ -0,0 +1,55 @@
+using System.Threading.Tasks;
+
+namespace Ryujinx.Graphics.Vulkan
+{
+    struct ShaderCompilationRequest
+    {
+        private readonly Task _task;
+        private readonly ShaderCompilationQueue _queue;
+        private readonly int _queueIndex;
+        private readonly ulong _requestId;
+
+        public bool IsCompleted
+        {
+            get
+            {
+                if (_task != null)
+                {
+                    return _task.IsCompleted;
+                }
+                else
+                {
+                    return _queue.IsCompleted(_queueIndex, _requestId);
+                }
+            }
+        }
+
+        public ShaderCompilationRequest(Task task)
+        {
+            _task = task;
+            _queue = null;
+            _queueIndex = 0;
+            _requestId = 0;
+        }
+
+        public ShaderCompilationRequest(ShaderCompilationQueue queue, int queueIndex, ulong requestId)
+        {
+            _task = null;
+            _queue = queue;
+            _queueIndex = queueIndex;
+            _requestId = requestId;
+        }
+
+        public void Wait()
+        {
+            if (_task != null)
+            {
+                _task.Wait();
+            }
+            else
+            {
+                _queue.Wait(_queueIndex, _requestId);
+            }
+        }
+    }
+}

src/Ryujinx.Graphics.Vulkan/StagingBuffer.cs

@@ -266,7 +266,7 @@ namespace Ryujinx.Graphics.Vulkan
         public void FreeCompleted()
         {
             FenceHolder signalledFence = null;
-            while (_pendingCopies.TryPeek(out PendingCopy pc) && pc.Fence != null && (pc.Fence == signalledFence || pc.Fence.IsSignaled()))
+            while (_pendingCopies.TryPeek(out PendingCopy pc) && pc.Fence != null && (pc.Fence == signalledFence || pc.Fence.IsSignaledLazy()))
             {
                 signalledFence = pc.Fence; // Already checked - don't need to do it again.
                 PendingCopy dequeued = _pendingCopies.Dequeue();

src/Ryujinx.Graphics.Vulkan/Vendor.cs

@@ -99,7 +99,6 @@ namespace Ryujinx.Graphics.Vulkan
                 DriverId.MesaNvk => "NVK",
                 DriverId.ImaginationOpenSourceMesa => "Imagination (Open)",
                 DriverId.MesaHoneykrisp => "Honeykrisp",
-                DriverId.MesaKosmickrisp => "KosmicKrisp",
                 _ => id.ToString(),
             };
         }

src/Ryujinx.Graphics.Vulkan/VulkanDriver.cs

@@ -1,54 +0,0 @@
-using System;
-using System.IO;
-using System.Runtime.Versioning;
-
-namespace Ryujinx.Graphics.Vulkan
-{
-    [SupportedOSPlatform("macos")]
-    public static class VulkanDriver
-    {
-        private static string GetIcdPath(string fileName)
-        {
-            string baseDir = AppContext.BaseDirectory.TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
-            string contentsDir = Path.GetDirectoryName(baseDir)!;
-            string[] searchPaths =
-            [
-                // .app bundle:
-                Path.Combine(contentsDir, "Resources", "vulkan", "icd.d", fileName),
-
-                // Local build:
-                Path.Combine(contentsDir, fileName)
-            ];
-
-            foreach (string icdPath in searchPaths)
-            {
-                if (File.Exists(icdPath))
-                {
-                    return icdPath;
-                }
-            }
-
-            throw new FileNotFoundException(
-                $"{fileName} not found. Searched:\n{string.Join(Environment.NewLine, searchPaths)}");
-        }
-
-        public static void MoltenVK()
-        {
-            Environment.SetEnvironmentVariable("MVK_CONFIG_USE_METAL_ARGUMENT_BUFFERS", "1");
-            Environment.SetEnvironmentVariable("MVK_CONFIG_VK_SEMAPHORE_SUPPORT_STYLE", "0");
-            Environment.SetEnvironmentVariable("MVK_CONFIG_SYNCHRONOUS_QUEUE_SUBMITS", "0");
-            Environment.SetEnvironmentVariable("MVK_CONFIG_RESUME_LOST_DEVICE", "1");
-
-            Environment.SetEnvironmentVariable("VK_DRIVER_FILES", GetIcdPath("MoltenVK_icd.json"));
-
-            Console.WriteLine($"[MoltenVK] VK_DRIVER_FILES just set to: {Environment.GetEnvironmentVariable("VK_DRIVER_FILES")}");
-        }
-
-        public static void KosmicKrisp()
-        {
-            Environment.SetEnvironmentVariable("VK_DRIVER_FILES", GetIcdPath("libkosmickrisp_icd.json"));
-
-            Console.WriteLine($"[KosmicKrisp] VK_DRIVER_FILES just set to: {Environment.GetEnvironmentVariable("VK_DRIVER_FILES")}");
-        }
-    }
-}

src/Ryujinx.Graphics.Vulkan/VulkanInitialization.cs

@@ -5,6 +5,7 @@ using Silk.NET.Core;
 using Silk.NET.Vulkan;
 using Silk.NET.Vulkan.Extensions.EXT;
 using Silk.NET.Vulkan.Extensions.KHR;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Runtime.InteropServices;
@@ -13,11 +14,10 @@ namespace Ryujinx.Graphics.Vulkan
 {
     public unsafe static class VulkanInitialization
     {
-        private static Version32 Version14 => new(1, 4, 0);
-
         private const uint InvalidIndex = uint.MaxValue;
         private static readonly uint _minimalVulkanVersion = Vk.Version11.Value;
-        private static readonly uint _maximumVulkanVersion = Version14.Value;
+        private static readonly uint _minimalInstanceVulkanVersion = Vk.Version12.Value;
+        private static readonly uint _maximumVulkanVersion = Vk.Version12.Value;
         private const string AppName = "Ryujinx.Graphics.Vulkan";
         private const int QueuesCount = 2;
 
@@ -59,7 +59,7 @@ namespace Ryujinx.Graphics.Vulkan
 
         internal static VulkanInstance CreateInstance(Vk api, GraphicsDebugLevel logLevel, string[] requiredExtensions)
         {
-            List<string> enabledLayers = [];
+            List<string> enabledLayers = new();
 
             IReadOnlySet<string> instanceExtensions = VulkanInstance.GetInstanceExtensions(api);
             IReadOnlySet<string> instanceLayers = VulkanInstance.GetInstanceLayers(api);
@@ -88,7 +88,7 @@ namespace Ryujinx.Graphics.Vulkan
                 enabledExtensions = enabledExtensions.Append(ExtDebugUtils.ExtensionName).ToArray();
             }
 
-            nint appName = Marshal.StringToHGlobalAnsi(AppName);
+            IntPtr appName = Marshal.StringToHGlobalAnsi(AppName);
 
             ApplicationInfo applicationInfo = new()
             {
@@ -168,7 +168,7 @@ namespace Ryujinx.Graphics.Vulkan
 
         internal static DeviceInfo[] GetSuitablePhysicalDevices(Vk api)
         {
-            nint appName = Marshal.StringToHGlobalAnsi(AppName);
+            IntPtr appName = Marshal.StringToHGlobalAnsi(AppName);
 
             ApplicationInfo applicationInfo = new()
             {
@@ -197,6 +197,13 @@ namespace Ryujinx.Graphics.Vulkan
 
             using VulkanInstance instance = rawInstance;
 
+            // We currently assume that the instance is compatible with Vulkan 1.2
+            // TODO: Remove this once we relax our initialization codepaths.
+            if (instance.InstanceVersion < _minimalInstanceVulkanVersion)
+            {
+                return [];
+            }
+
             instance.EnumeratePhysicalDevices(out VulkanPhysicalDevice[] physicalDevices).ThrowOnError();
 
             List<DeviceInfo> deviceInfos = [];
@@ -379,7 +386,7 @@ namespace Ryujinx.Graphics.Vulkan
                 features2.PNext = &supportedFeaturesDynamicAttachmentFeedbackLoopLayout;
             }
 
-            PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT supportedFeaturesPageableDeviceLocalMemory = new()
+            PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT supportedPageableDeviceLocalMemoryFeatures = new()
             {
                 SType = StructureType.PhysicalDevicePageableDeviceLocalMemoryFeaturesExt,
                 PNext = features2.PNext,
@@ -387,10 +394,10 @@ namespace Ryujinx.Graphics.Vulkan
 
             if (physicalDevice.IsDeviceExtensionPresent(ExtPageableDeviceLocalMemory.ExtensionName))
             {
-                features2.PNext = &supportedFeaturesPageableDeviceLocalMemory;
+                features2.PNext = &supportedPageableDeviceLocalMemoryFeatures;
             }
 
-            PhysicalDeviceMemoryPriorityFeaturesEXT supportedFeaturesDeviceMemoryPriority = new()
+            PhysicalDeviceMemoryPriorityFeaturesEXT supportedDeviceMemoryPriorityFeatures = new()
             {
                 SType = StructureType.PhysicalDeviceMemoryPriorityFeaturesExt,
                 PNext = features2.PNext,
@@ -398,7 +405,7 @@ namespace Ryujinx.Graphics.Vulkan
 
             if (physicalDevice.IsDeviceExtensionPresent("VK_EXT_memory_priority"))
             {
-                features2.PNext = &supportedFeaturesDeviceMemoryPriority;
+                features2.PNext = &supportedDeviceMemoryPriorityFeatures;
             }
 
             PhysicalDeviceVulkan12Features supportedPhysicalDeviceVulkan12Features = new()
@@ -409,22 +416,6 @@ namespace Ryujinx.Graphics.Vulkan
 
             features2.PNext = &supportedPhysicalDeviceVulkan12Features;
 
-            PhysicalDeviceVulkan13Features supportedPhysicalDeviceVulkan13Features = new()
-            {
-                SType = StructureType.PhysicalDeviceVulkan13Features,
-                PNext = features2.PNext,
-            };
-
-            features2.PNext = &supportedPhysicalDeviceVulkan13Features;
-
-            PhysicalDeviceVulkan14Features supportedPhysicalDeviceVulkan14Features = new()
-            {
-                SType = StructureType.PhysicalDeviceVulkan14Features,
-                PNext = features2.PNext,
-            };
-
-            features2.PNext = &supportedPhysicalDeviceVulkan14Features;
-
             api.GetPhysicalDeviceFeatures2(physicalDevice.PhysicalDevice, &features2);
 
             PhysicalDeviceFeatures supportedFeatures = features2.Features;
@@ -528,24 +519,6 @@ namespace Ryujinx.Graphics.Vulkan
 
             pExtendedFeatures = &featuresVk12;
 
-            PhysicalDeviceVulkan13Features featuresVk13 = new()
-            {
-                SType = StructureType.PhysicalDeviceVulkan13Features,
-                PNext = pExtendedFeatures,
-                /* Vulkan 1.3 features here */
-            };
-
-            pExtendedFeatures = &featuresVk13;
-
-            PhysicalDeviceVulkan13Features featuresVk14 = new()
-            {
-                SType = StructureType.PhysicalDeviceVulkan14Features,
-                PNext = pExtendedFeatures,
-                /* Vulkan 1.4 features here */
-            };
-
-            pExtendedFeatures = &featuresVk14;
-
             if (physicalDevice.IsDeviceExtensionPresent("VK_EXT_index_type_uint8"))
             {
                 PhysicalDeviceIndexTypeUint8FeaturesEXT featuresIndexU8 = new()
@@ -625,7 +598,7 @@ namespace Ryujinx.Graphics.Vulkan
             }
             
             if (physicalDevice.IsDeviceExtensionPresent(ExtPageableDeviceLocalMemory.ExtensionName) &&
-                supportedFeaturesPageableDeviceLocalMemory.PageableDeviceLocalMemory)
+                supportedPageableDeviceLocalMemoryFeatures.PageableDeviceLocalMemory)
             {
                 PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT featuresPageableDeviceLocalMemory = new()
                 {
@@ -638,16 +611,16 @@ namespace Ryujinx.Graphics.Vulkan
             }
 
             if (physicalDevice.IsDeviceExtensionPresent("VK_EXT_memory_priority") &&
-                supportedFeaturesDeviceMemoryPriority.MemoryPriority)
+                supportedDeviceMemoryPriorityFeatures.MemoryPriority)
             {
-                PhysicalDeviceMemoryPriorityFeaturesEXT featuresMemoryPriority = new()
+                PhysicalDeviceMemoryPriorityFeaturesEXT featuresDeviceMemoryPriority = new()
                 {
                     SType = StructureType.PhysicalDeviceMemoryPriorityFeaturesExt,
                     PNext = pExtendedFeatures,
                     MemoryPriority = true,
                 };
 
-                pExtendedFeatures = &featuresMemoryPriority;
+                pExtendedFeatures = &featuresDeviceMemoryPriority;
             }
 
             string[] enabledExtensions = _requiredExtensions.Union(_desirableExtensions.Intersect(physicalDevice.DeviceExtensions)).ToArray();

src/Ryujinx.Graphics.Vulkan/VulkanInstance.cs

@@ -13,6 +13,7 @@ namespace Ryujinx.Graphics.Vulkan
     {
         private readonly Vk _api;
         public readonly Instance Instance;
+        public readonly Version32 InstanceVersion;
 
         private bool _disposed;
 
@@ -20,6 +21,22 @@ namespace Ryujinx.Graphics.Vulkan
         {
             _api = api;
             Instance = instance;
+
+            if (api.GetInstanceProcAddr(instance, "vkEnumerateInstanceVersion") == nint.Zero)
+            {
+                InstanceVersion = Vk.Version10;
+            }
+            else
+            {
+                uint rawInstanceVersion = 0;
+
+                if (api.EnumerateInstanceVersion(ref rawInstanceVersion) != Result.Success)
+                {
+                    rawInstanceVersion = Vk.Version11.Value;
+                }
+
+                InstanceVersion = (Version32)rawInstanceVersion;
+            }
         }
 
         public static Result Create(Vk api, ref InstanceCreateInfo createInfo, out VulkanInstance instance)

src/Ryujinx.Graphics.Vulkan/VulkanRenderer.cs

@@ -3,6 +3,7 @@ using Ryujinx.Common.Logging;
 using Ryujinx.Graphics.GAL;
 using Ryujinx.Graphics.Shader;
 using Ryujinx.Graphics.Shader.Translation;
+using Ryujinx.Graphics.Vulkan.MoltenVK;
 using Ryujinx.Graphics.Vulkan.Queries;
 using Silk.NET.Vulkan;
 using Silk.NET.Vulkan.Extensions.EXT;
@@ -54,6 +55,7 @@ namespace Ryujinx.Graphics.Vulkan
         internal CommandBufferPool CommandBufferPool { get; private set; }
         internal PipelineLayoutCache PipelineLayoutCache { get; private set; }
         internal BackgroundResources BackgroundResources { get; private set; }
+        internal ShaderCompilationQueue ShaderCompilationQueue { get; private set; }
         internal Action<Action> InterruptAction { get; private set; }
         internal SyncManager SyncManager { get; private set; }
 
@@ -95,8 +97,8 @@ namespace Ryujinx.Graphics.Vulkan
         internal bool IsNvidiaPreTuring { get; private set; }
         internal bool IsIntelArc { get; private set; }
         internal bool IsQualcommProprietary { get; private set; }
+        internal bool IsTurnip { get; private set; }
         internal bool IsMoltenVk { get; private set; }
-        internal bool IsKosmicKrisp { get; private set; }
         internal bool SupportsMTL31 { get; private set; }
         internal bool IsTBDR { get; private set; }
         internal bool IsSharedMemory { get; private set; }
@@ -111,7 +113,7 @@ namespace Ryujinx.Graphics.Vulkan
 
         public event EventHandler<ScreenCaptureImageInfo> ScreenCaptured;
 
-        public VulkanRenderer(Vk api, Func<Instance, Vk, SurfaceKHR> surfaceFunc, Func<string[]> requiredExtensionsFunc, string preferredGpuId, TranslationLayer translationLayer)
+        public VulkanRenderer(Vk api, Func<Instance, Vk, SurfaceKHR> surfaceFunc, Func<string[]> requiredExtensionsFunc, string preferredGpuId)
         {
             _getSurface = surfaceFunc;
             _getRequiredExtensions = requiredExtensionsFunc;
@@ -121,20 +123,18 @@ namespace Ryujinx.Graphics.Vulkan
             Textures = [];
             Samplers = [];
 
-            // MoltenVK is required for any device running < macOS 26, even Intel and AMD vendors.
-            // KosmicKrisp, a Vulkan conformant implementation running on top of Metal 4, requires macOS 26.
             if (OperatingSystem.IsMacOS())
             {
-                if (translationLayer == TranslationLayer.MoltenVK)
-                {
-                    VulkanDriver.MoltenVK();
-                    IsMoltenVk = true;
-                }
-                if (translationLayer == TranslationLayer.KosmicKrisp)
-                {
-                    VulkanDriver.KosmicKrisp();
-                    IsKosmicKrisp = true;
-                }
+                MVKInitialization.Initialize();
+
+                // Any device running on MacOS is using MoltenVK, even Intel and AMD vendors.
+                IsMoltenVk = true;
+
+                // The default thread stack size on MacOS is low, and can cause stack overflow
+                // on SPIR-V Cross during shader compilation.
+                // As a workaround, we use this custom queue which allows us to specify the stack
+                // size of the threads used for compilation.
+                ShaderCompilationQueue = new ShaderCompilationQueue();
             }
 
             SupportsMTL31 = OperatingSystem.IsMacOSVersionAtLeast(14);
@@ -404,6 +404,8 @@ namespace Ryujinx.Graphics.Vulkan
 
             IsFeedbackLoopDevice = IsAmdRdna3;
 
+            IsTurnip = GpuRenderer.StartsWith("Turnip");
+
             if (Vendor == Vendor.Nvidia)
             {
                 Match match = VendorUtils.NvidiaConsumerClassRegex().Match(GpuRenderer);
@@ -484,7 +486,7 @@ namespace Ryujinx.Graphics.Vulkan
             Api.TryGetDeviceExtension(_instance.Instance, _device, out ExtExternalMemoryHost hostMemoryApi);
             HostMemoryAllocator = new HostMemoryAllocator(MemoryAllocator, Api, hostMemoryApi, _device);
 
-            CommandBufferPool = new CommandBufferPool(Api, _device, Queue, QueueLock, queueFamilyIndex, IsQualcommProprietary);
+            CommandBufferPool = new CommandBufferPool(Api, _device, Queue, QueueLock, queueFamilyIndex, IsQualcommProprietary, IsTurnip);
 
             PipelineLayoutCache = new PipelineLayoutCache();
 
@@ -785,6 +787,7 @@ namespace Ryujinx.Graphics.Vulkan
                 supportsGeometryShader: Capabilities.SupportsGeometryShader,
                 supportsGeometryShaderPassthrough: Capabilities.SupportsGeometryShaderPassthrough,
                 supportsTransformFeedback: Capabilities.SupportsTransformFeedback,
+                supportsImageBufferPixelAlignment: false,
                 supportsImageLoadFormatted: features2.Features.ShaderStorageImageReadWithoutFormat,
                 supportsLayerVertexTessellation: featuresVk12.ShaderOutputLayer,
                 supportsMismatchingViewFormat: true,
@@ -798,6 +801,7 @@ namespace Ryujinx.Graphics.Vulkan
                 supportsShaderNonUniformIndexing:
                     featuresVk12.ShaderSampledImageArrayNonUniformIndexing &&
                     featuresVk12.ShaderStorageImageArrayNonUniformIndexing,
+                supportsTextureBufferPixelAlignment: false,
                 supportsTextureGatherOffsets: features2.Features.ShaderImageGatherExtended,
                 supportsTextureShadowLod: false,
                 supportsVertexStoreAndAtomics: features2.Features.VertexPipelineStoresAndAtomics,
@@ -850,14 +854,14 @@ namespace Ryujinx.Graphics.Vulkan
 
         /// <summary>
         /// Gets the available Vulkan devices using the default Vulkan API
-        /// object returned by <see cref="VulkanSpbApi.GetApiFromSpb()"/>
+        /// object returned by <see cref="Vk.GetApi()"/>
         /// </summary>
         /// <returns></returns>
         public static DeviceInfo[] GetPhysicalDevices()
         {
             try
             {
-                return VulkanInitialization.GetSuitablePhysicalDevices(VulkanSpbApi.GetApiFromSpb());
+                return VulkanInitialization.GetSuitablePhysicalDevices(Vk.GetApi());
             }
             catch (Exception ex)
             {
@@ -1120,6 +1124,8 @@ namespace Ryujinx.Graphics.Vulkan
 
             SurfaceApi.DestroySurface(_instance.Instance, _surface, null);
 
+            ShaderCompilationQueue?.Dispose();
+
             Api.DestroyDevice(_device, null);
 
             _debugMessenger.Dispose();

src/Ryujinx.Graphics.Vulkan/VulkanSpbApi.cs

@@ -1,34 +0,0 @@
-using Silk.NET.Core.Contexts;
-using Silk.NET.Vulkan;
-using SPB.Graphics.Vulkan;
-
-namespace Ryujinx.Graphics.Vulkan
-{
-    public static class VulkanSpbApi
-    {
-        public static Vk GetApiFromSpb()
-        {
-            LamdaNativeContext baseCtx = new(VulkanHelper.GetProcAddress);
-            MultiNativeContext ctx = new(baseCtx, null);
-            Vk ret = new(ctx);
-
-            ctx.Contexts[1] = new LamdaNativeContext(x =>
-            {
-                if (x.EndsWith("ProcAddr"))
-                {
-                    return default;
-                }
-
-                nint ptr = ret.GetDeviceProcAddr(ret.CurrentDevice.GetValueOrDefault(), x);
-                if (ptr != default)
-                {
-                    return ptr;
-                }
-
-                return ret.GetInstanceProcAddr(ret.CurrentInstance.GetValueOrDefault(), x);
-            });
-
-            return ret;
-        }
-    }
-}

src/Ryujinx.ShaderTools/Program.cs

@@ -116,7 +116,7 @@ namespace Ryujinx.ShaderTools
 
             if (options.VertexPassthrough)
             {
-                program = translatorContext.GenerateVertexPassthroughForCompute();
+                (program, _) = translatorContext.GenerateVertexPassthroughForCompute();
             }
             else
             {

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

@@ -439,11 +439,6 @@ namespace Ryujinx.UI.Common.Configuration
         /// </summary>
         public GraphicsBackend GraphicsBackend { get; set; }
 
-        /// <summary>
-        /// Vulkan translation layer
-        /// </summary>
-        public TranslationLayer TranslationLayer { get; set; }
-
         /// <summary>
         /// Preferred GPU
         /// </summary>

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

@@ -587,11 +587,6 @@ namespace Ryujinx.UI.Common.Configuration
             /// </summary>
             public ReactiveObject<GraphicsBackend> GraphicsBackend { get; private set; }
 
-            /// <summary>
-            /// Vulkan translation layer
-            /// </summary>
-            public ReactiveObject<TranslationLayer> TranslationLayer { get; private set; }
-
             /// <summary>
             /// Applies anti-aliasing to the renderer.
             /// </summary>
@@ -644,8 +639,6 @@ namespace Ryujinx.UI.Common.Configuration
                 EnableTextureRecompression.Event += static (_, e) => LogValueChange(e, nameof(EnableTextureRecompression));
                 GraphicsBackend = new ReactiveObject<GraphicsBackend>();
                 GraphicsBackend.Event += static (_, e) => LogValueChange(e, nameof(GraphicsBackend));
-                TranslationLayer = new ReactiveObject<TranslationLayer>();
-                TranslationLayer.Event += static (_, e) => LogValueChange(e, nameof(TranslationLayer));
                 PreferredGpu = new ReactiveObject<string>();
                 PreferredGpu.Event += static (_, e) => LogValueChange(e, nameof(PreferredGpu));
                 EnableMacroHLE = new ReactiveObject<bool>();
@@ -942,7 +935,6 @@ namespace Ryujinx.UI.Common.Configuration
                 ControllerConfig = [],
                 InputConfig = Hid.InputConfig,
                 GraphicsBackend = Graphics.GraphicsBackend,
-                TranslationLayer = Graphics.TranslationLayer,
                 PreferredGpu = Graphics.PreferredGpu,
                 MultiplayerLanInterfaceId = Multiplayer.LanInterfaceId,
                 MultiplayerMode = Multiplayer.Mode,
@@ -966,7 +958,6 @@ namespace Ryujinx.UI.Common.Configuration
             Graphics.MaxAnisotropy.Value = -1.0f;
             Graphics.AspectRatio.Value = AspectRatio.Fixed16x9;
             Graphics.GraphicsBackend.Value = DefaultGraphicsBackend();
-            Graphics.TranslationLayer.Value = TranslationLayer.MoltenVK;
             Graphics.PreferredGpu.Value = "";
             Graphics.ShadersDumpPath.Value = "";
             Graphics.TexturesDumpPath.Value = "";
@@ -1815,15 +1806,6 @@ namespace Ryujinx.UI.Common.Configuration
                 configurationFileUpdated = true;
             }
 
-            if (configurationFileFormat.Version < 62)
-            {
-                Ryujinx.Common.Logging.Logger.Warning?.Print(LogClass.Application, $"Outdated configuration version {configurationFileFormat.Version}, migrating to version 62.");
-
-                configurationFileFormat.TranslationLayer = TranslationLayer.MoltenVK;
-
-                configurationFileUpdated = true;
-            }
-
             Logger.EnableFileLog.Value = configurationFileFormat.EnableFileLog;
             Graphics.ResScale.Value = configurationFileFormat.ResScale;
             Graphics.ResScaleCustom.Value = configurationFileFormat.ResScaleCustom;
@@ -1836,7 +1818,6 @@ namespace Ryujinx.UI.Common.Configuration
             Graphics.EnableTextureRealTimeEdit.Value = configurationFileFormat.GraphicsEnableTextureRealTimeEdit;
             Graphics.BackendThreading.Value = configurationFileFormat.BackendThreading;
             Graphics.GraphicsBackend.Value = configurationFileFormat.GraphicsBackend;
-            Graphics.TranslationLayer.Value = configurationFileFormat.TranslationLayer;
             Graphics.PreferredGpu.Value = configurationFileFormat.PreferredGpu;
             Graphics.AntiAliasing.Value = configurationFileFormat.AntiAliasing;
             Graphics.ScalingFilter.Value = configurationFileFormat.ScalingFilter;

src/Ryujinx.UI.Common/Helper/CommandLineState.cs

@@ -12,7 +12,6 @@ namespace Ryujinx.UI.Common.Helper
         public static bool? OverrideDockedMode { get; private set; }
         public static bool? OverrideHardwareAcceleration { get; private set; }
         public static string OverrideGraphicsBackend { get; private set; }
-        public static string OverrideTranslationLayer { get; private set; }
         public static string OverrideBackendThreading { get; private set; }
         public static string OverrideHideCursor { get; private set; }
         public static string BaseDirPathArg { get; private set; }
@@ -110,16 +109,6 @@ namespace Ryujinx.UI.Common.Helper
 
                         OverrideGraphicsBackend = args[++i];
                         break;
-                    case "--translation-layer":
-                        if (i + 1 >= args.Length)
-                        {
-                            Logger.Error?.Print(LogClass.Application, $"Invalid option '{arg}'");
-
-                            continue;
-                        }
-
-                        OverrideTranslationLayer = args[++i];
-                        break;
                     case "--backend-threading":
                         if (i + 1 >= args.Length)
                         {

src/Ryujinx/AppHost.cs

@@ -43,6 +43,7 @@ using Ryujinx.UI.App.Common;
 using Ryujinx.UI.Common;
 using Ryujinx.UI.Common.Configuration;
 using Ryujinx.UI.Common.Helper;
+using Silk.NET.Vulkan;
 using SkiaSharp;
 using SPB.Graphics.Exceptions;
 using SPB.Graphics.Vulkan;
@@ -938,11 +939,10 @@ namespace Ryujinx.Ava
             if (ConfigurationState.Instance.Graphics.GraphicsBackend.Value == GraphicsBackend.Vulkan)
             {
                 renderer = new VulkanRenderer(
-                    VulkanSpbApi.GetApiFromSpb(),
+                    Vk.GetApi(),
                     ((EmbeddedWindowVulkan)RendererHost.EmbeddedWindow).CreateSurface,
                     VulkanHelper.GetRequiredInstanceExtensions,
-                    ConfigurationState.Instance.Graphics.PreferredGpu.Value,
-                    ConfigurationState.Instance.Graphics.TranslationLayer.Value);
+                    ConfigurationState.Instance.Graphics.PreferredGpu.Value);
             }
             else
             {
@@ -1183,12 +1183,7 @@ namespace Ryujinx.Ava
         {
             _viewModel.BackendText = ConfigurationState.Instance.Graphics.GraphicsBackend.Value switch
             {
-                GraphicsBackend.Vulkan when !OperatingSystem.IsMacOS() => "Vulkan",
-                GraphicsBackend.Vulkan when Environment.GetEnvironmentVariable("VK_DRIVER_FILES")!.Contains("MoltenVK")
-                    => "MoltenVK",
-                GraphicsBackend.Vulkan when
-                    Environment.GetEnvironmentVariable("VK_DRIVER_FILES")!.Contains("kosmickrisp") => "KosmicKrisp",
-                GraphicsBackend.Vulkan => _viewModel.BackendText,
+                GraphicsBackend.Vulkan => "Vulkan",
                 GraphicsBackend.OpenGl => "OpenGL",
                 _ => throw new NotImplementedException()
             };

src/Ryujinx/Assets/Locales/en_US.json

@@ -189,8 +189,6 @@
   "SettingsTabSystemIgnoreControllerApplet": "Ignore Controller Applet",
   "SettingsTabGraphics": "Graphics",
   "SettingsTabGraphicsAPI": "Graphics API",
-  "SettingsTabTranslationLayer": "Translation Layer (Vulkan):",
-  "SettingsTabTranslationLayerTooltip": "MoltenVK is a Vulkan Portability implementation, enabling Vulkan applications to run on macOS.\n\nKosmicKrisp is a Vulkan (1.3) conformant Vulkan-on-Metal driver and the eventual successor to MoltenVK.\n\nKosmicKrisp is not yet feature-complete, meaning that games *may* not render correctly or possibly even crash.\n\nUse MoltenVK if unsure.",
   "SettingsTabGraphicsEnableShaderCache": "Enable Shader Cache",
   "SettingsTabGraphicsAnisotropicFiltering": "Anisotropic Filtering:",
   "SettingsTabGraphicsAnisotropicFilteringAuto": "Auto",

src/Ryujinx/Headless/HeadlessRyujinx.Init.cs

@@ -289,7 +289,7 @@ namespace Ryujinx.Headless
             if (options.GraphicsBackend == GraphicsBackend.Vulkan && window is VulkanWindow vulkanWindow)
             {
                 string preferredGpuId = string.Empty;
-                Vk api = VulkanSpbApi.GetApiFromSpb();
+                Vk api = Vk.GetApi();
 
                 if (!string.IsNullOrEmpty(options.PreferredGPUVendor))
                 {
@@ -310,8 +310,7 @@ namespace Ryujinx.Headless
                     api,
                     (instance, _) => new SurfaceKHR((ulong)(vulkanWindow.CreateWindowSurface(instance.Handle))),
                     VulkanWindow.GetRequiredInstanceExtensions,
-                    preferredGpuId,
-                    options.TranslationLayer);
+                    preferredGpuId);
             }
 
             return new OpenGLRenderer();

src/Ryujinx/Headless/HeadlessRyujinx.cs

@@ -12,6 +12,7 @@ using Ryujinx.Cpu;
 using Ryujinx.Graphics.GAL;
 using Ryujinx.Graphics.Gpu;
 using Ryujinx.Graphics.Gpu.Shader;
+using Ryujinx.Graphics.Vulkan.MoltenVK;
 using Ryujinx.HLE;
 using Ryujinx.HLE.FileSystem;
 using Ryujinx.HLE.HOS;
@@ -73,6 +74,11 @@ namespace Ryujinx.Headless
                 };
             }
 
+            if (OperatingSystem.IsMacOS())
+            {
+                MVKInitialization.InitializeResolver();
+            }
+
             Parser.Default.ParseArguments<Options>(args)
             .WithParsed(options => Load(args, options))
             .WithNotParsed(errors => errors.Output());

src/Ryujinx/Headless/Options.cs

@@ -131,10 +131,7 @@ namespace Ryujinx.Headless
             
             if (NeedsOverride(nameof(GraphicsBackend)))
                 GraphicsBackend = configurationState.Graphics.GraphicsBackend;
-
-            if (NeedsOverride(nameof(TranslationLayer)))
-                TranslationLayer = configurationState.Graphics.TranslationLayer;
-
+            
             if (NeedsOverride(nameof(AntiAliasing)))
                 AntiAliasing = configurationState.Graphics.AntiAliasing;
             
@@ -373,9 +370,6 @@ namespace Ryujinx.Headless
         [Option("graphics-backend", Required = false, Default = GraphicsBackend.Vulkan, HelpText = "Change Graphics Backend to use.")]
         public GraphicsBackend GraphicsBackend { get; set; }
 
-        [Option("translation-layer", Required = false, Default = TranslationLayer.MoltenVK, HelpText = "Change Translation Layer to use.")]
-        public TranslationLayer TranslationLayer { get; set; }
-
         [Option("preferred-gpu-vendor", Required = false, Default = "", HelpText = "When using the Vulkan backend, prefer using the GPU from the specified vendor.")]
         public string PreferredGPUVendor { get; set; }
 

src/Ryujinx/Program.cs

@@ -8,6 +8,8 @@ using Ryujinx.Common.GraphicsDriver;
 using Ryujinx.Common.Logging;
 using Ryujinx.Common.SystemInterop;
 using Ryujinx.Common.Utilities;
+using Ryujinx.Graphics.RenderDocApi;
+using Ryujinx.Graphics.Vulkan.MoltenVK;
 using Ryujinx.Headless;
 using Ryujinx.Modules;
 using Ryujinx.SDL3.Common;
@@ -25,6 +27,7 @@ namespace Ryujinx.Ava
 {
     internal partial class Program
     {
+        //
         public static double WindowScaleFactor { get; set; }
         public static double DesktopScaleFactor { get; set; } = 1.0;
         public static string Version { get; private set; }
@@ -112,6 +115,11 @@ namespace Ryujinx.Ava
             // Parse arguments
             CommandLineState.ParseArguments(args);
 
+            if (OperatingSystem.IsMacOS())
+            {
+                MVKInitialization.InitializeResolver();
+            }
+
             // Delete backup files after updating.
             Task.Run(Updater.CleanupUpdate);
 
@@ -211,31 +219,18 @@ namespace Ryujinx.Ava
 
             UseHardwareAcceleration = ConfigurationState.Instance.EnableHardwareAcceleration.Value;
 
-            // Change graphics backend from OpenGL to Vulkan on macOS
-            if (OperatingSystem.IsMacOS() && (ConfigurationState.Instance.Graphics.GraphicsBackend.Value == GraphicsBackend.OpenGl))
-            {
-                ConfigurationState.Instance.Graphics.GraphicsBackend.Value = GraphicsBackend.Vulkan;
-            }
-
             // Check if graphics backend was overridden
-            if (CommandLineState.OverrideGraphicsBackend is not null)
+            if (CommandLineState.OverrideGraphicsBackend != null)
             {
-                ConfigurationState.Instance.Graphics.GraphicsBackend.Value = CommandLineState.OverrideGraphicsBackend.ToLower() switch
-                    {
-                        "opengl" => GraphicsBackend.OpenGl,
-                        "vulkan" => GraphicsBackend.Vulkan,
-                        _ => ConfigurationState.Instance.Graphics.GraphicsBackend.Value
-                    };
-            }
-
-            // Check if translation layer was overridden
-            if (CommandLineState.OverrideTranslationLayer is not null)
-                ConfigurationState.Instance.Graphics.TranslationLayer.Value = CommandLineState.OverrideTranslationLayer.ToLower() switch
+                if (CommandLineState.OverrideGraphicsBackend.ToLower() == "opengl")
                 {
-                    "moltenvk" => TranslationLayer.MoltenVK,
-                    "kosmickrisp" => TranslationLayer.KosmicKrisp,
-                    _ => ConfigurationState.Instance.Graphics.TranslationLayer.Value
-                };
+                    ConfigurationState.Instance.Graphics.GraphicsBackend.Value = GraphicsBackend.OpenGl;
+                }
+                else if (CommandLineState.OverrideGraphicsBackend.ToLower() == "vulkan")
+                {
+                    ConfigurationState.Instance.Graphics.GraphicsBackend.Value = GraphicsBackend.Vulkan;
+                }
+            }
 
             // Check if backend threading was overridden
             if (CommandLineState.OverrideBackendThreading is not null)

src/Ryujinx/Ryujinx.csproj

@@ -47,12 +47,11 @@
     <PackageReference Include="Ryujinx.Graphics.Nvdec.Dependencies.Linux" Condition="'$(RuntimeIdentifier)' == 'linux-x64' OR '$(RuntimeIdentifier)' == 'linux-arm64'" />
     <PackageReference Include="Ryujinx.Graphics.Nvdec.Dependencies.macOS" Condition="'$(RuntimeIdentifier)' == 'osx-x64' OR '$(RuntimeIdentifier)' == 'osx-arm64'" />
     <PackageReference Include="Ryujinx.Graphics.Nvdec.Dependencies.Windows" Condition="'$(RuntimeIdentifier)' == 'win-x64' OR '$(RuntimeIdentifier)' == 'win-arm64'" />
-    <PackageReference Include="Ryujinx.Graphics.Vulkan.KosmicKrisp" Condition="'$(RuntimeIdentifier)' != 'linux-x64' AND '$(RuntimeIdentifier)' != 'linux-arm64' AND '$(RuntimeIdentifier)' != 'win-x64' AND '$(RuntimeIdentifier)' != 'win-arm64' AND '$(RuntimeIdentifier)' != 'osx-x64'" />
-    <PackageReference Include="Ryujinx.SPB" />
     <PackageReference Include="Ryujinx.Graphics.Vulkan.MoltenVK" Condition="'$(RuntimeIdentifier)' == 'osx-x64' OR '$(RuntimeIdentifier)' == 'osx-arm64'" />
     <PackageReference Include="Silk.NET.Vulkan" />
     <PackageReference Include="Silk.NET.Vulkan.Extensions.EXT" />
     <PackageReference Include="Silk.NET.Vulkan.Extensions.KHR" />
+    <PackageReference Include="SPB" />
     <PackageReference Include="SharpZipLib" />
   </ItemGroup>
 
@@ -91,20 +90,6 @@
     </Content>
   </ItemGroup>
 
-  <ItemGroup Condition="'$(RuntimeIdentifier)' == 'osx-arm64' OR '$(RuntimeIdentifier)' == 'osx-x64'">
-    <Content Include="..\..\distribution\macos\vulkan\icd.d\MoltenVK_icd-flat.json">
-      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-      <TargetPath>MoltenVK_icd.json</TargetPath>
-    </Content>
-  </ItemGroup>
-
-  <ItemGroup Condition="'$(RuntimeIdentifier)' == 'osx-arm64'">
-    <Content Include="..\..\distribution\macos\vulkan\icd.d\libkosmickrisp_icd-flat.json">
-      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-      <TargetPath>libkosmickrisp_icd.json</TargetPath>
-    </Content>
-  </ItemGroup>
-  
   <ItemGroup Condition="'$(RuntimeIdentifier)' == 'linux-x64' OR '$(RuntimeIdentifier)' == 'linux-arm64'" >
     <Content Include="..\..\distribution\linux\Ryujinx.sh">
       <CopyToOutputDirectory>Always</CopyToOutputDirectory>

src/Ryujinx/UI/ViewModels/SettingsViewModel.cs

@@ -118,8 +118,6 @@ namespace Ryujinx.Ava.UI.ViewModels
 
         public bool IsHypervisorAvailable => OperatingSystem.IsMacOS() && RuntimeInformation.ProcessArchitecture == Architecture.Arm64;
 
-        public bool IsKosmicKrispAvailable => OperatingSystem.IsMacOSVersionAtLeast(15);
-
         public bool GameDirectoryChanged
         {
             get => _gameDirectoryChanged;
@@ -315,23 +313,13 @@ namespace Ryujinx.Ava.UI.ViewModels
         public int BaseStyleIndex { get; set; }
 
         public int GraphicsBackendIndex
-        {
-            get;
-            set
-            {
-                field = IsMacOS ? 0 : value;
-                OnPropertyChanged();
-                OnPropertyChanged(nameof(IsVulkanSelected));
-            }
-        }
-
-        public int TranslationLayerIndex
         {
             get;
             set
             {
                 field = value;
                 OnPropertyChanged();
+                OnPropertyChanged(nameof(IsVulkanSelected));
             }
         }
 
@@ -638,7 +626,6 @@ namespace Ryujinx.Ava.UI.ViewModels
 
             // Graphics
             GraphicsBackendIndex = (int)config.Graphics.GraphicsBackend.Value;
-            TranslationLayerIndex = (int)config.Graphics.TranslationLayer.Value;
             // Physical devices are queried asynchronously hence the preferred index config value is loaded in LoadAvailableGpus().
             EnableShaderCache = config.Graphics.EnableShaderCache;
             EnableTextureRecompression = config.Graphics.EnableTextureRecompression;
@@ -759,7 +746,6 @@ namespace Ryujinx.Ava.UI.ViewModels
 
             // Graphics
             config.Graphics.GraphicsBackend.Value = (GraphicsBackend)GraphicsBackendIndex;
-            config.Graphics.TranslationLayer.Value = (TranslationLayer)TranslationLayerIndex;
             config.Graphics.PreferredGpu.Value = _gpuIds.ElementAtOrDefault(PreferredGpuIndex);
             config.Graphics.EnableShaderCache.Value = EnableShaderCache;
             config.Graphics.EnableTextureRecompression.Value = EnableTextureRecompression;

src/Ryujinx/UI/Views/Settings/SettingsGraphicsView.axaml

@@ -28,7 +28,7 @@
                 Spacing="10">
                 <TextBlock Classes="h1" Text="{locale:Locale SettingsTabGraphicsAPI}" />
                 <StackPanel Margin="10,0,0,0" Orientation="Vertical" Spacing="10">
-                    <StackPanel Orientation="Horizontal" IsVisible="{Binding !IsMacOS}">
+                    <StackPanel Orientation="Horizontal">
                         <TextBlock VerticalAlignment="Center"
                                 ToolTip.Tip="{locale:Locale SettingsTabGraphicsBackendTooltip}"
                                 Text="{locale:Locale SettingsTabGraphicsBackend}"
@@ -45,22 +45,6 @@
                                 Content="OpenGL" />
                         </ComboBox>
                     </StackPanel>
-                    <StackPanel Orientation="Horizontal" IsVisible="{Binding IsMacOS}">
-                        <TextBlock VerticalAlignment="Center"
-                                   ToolTip.Tip="{locale:Locale SettingsTabTranslationLayerTooltip}"
-                                   Text="{locale:Locale SettingsTabTranslationLayer}"
-                                   Width="250" />
-                        <ComboBox Width="350"
-                                  HorizontalContentAlignment="Left"
-                                  ToolTip.Tip="{locale:Locale SettingsTabTranslationLayerTooltip}"
-                                  SelectedIndex="{Binding TranslationLayerIndex}">
-                            <ComboBoxItem
-                                Content="MoltenVK" />
-                            <ComboBoxItem
-                                IsEnabled="{Binding IsKosmicKrispAvailable}"
-                                Content="KosmicKrisp" />
-                        </ComboBox>
-                    </StackPanel>
                     <StackPanel Orientation="Horizontal" IsVisible="{Binding IsVulkanSelected}">
                         <TextBlock VerticalAlignment="Center"
                                 ToolTip.Tip="{locale:Locale SettingsTabGraphicsPreferredGpuTooltip}"
@@ -72,24 +56,7 @@
                                 SelectedIndex="{Binding PreferredGpuIndex}"
                                 ItemsSource="{Binding AvailableGpus}"/>
                     </StackPanel>
-                        <StackPanel Orientation="Horizontal">
-                            <TextBlock VerticalAlignment="Center"
-                                       ToolTip.Tip="{locale:Locale GraphicsBackendThreadingTooltip}"
-                                       Text="{locale:Locale SettingsTabGraphicsBackendMultithreading}"
-                                       Width="250" />
-                            <ComboBox Width="350"
-                                      HorizontalContentAlignment="Left"
-                                      ToolTip.Tip="{locale:Locale GalThreadingTooltip}"
-                                      SelectedIndex="{Binding GraphicsBackendMultithreadingIndex}">
-                                <ComboBoxItem
-                                    Content="{locale:Locale CommonAuto}" />
-                                <ComboBoxItem
-                                    Content="{locale:Locale CommonOff}" />
-                                <ComboBoxItem
-                                    Content="{locale:Locale CommonOn}" />
-                            </ComboBox>
-                        </StackPanel>
-                    </StackPanel>
+                </StackPanel>
                 <Separator Height="1" />
                 <TextBlock Classes="h1" Text="{locale:Locale SettingsTabGraphicsFeatures}" />
                 <StackPanel Margin="10,0,0,0" Orientation="Vertical" Spacing="10">