Add Ryujinx license file to builds (#4057)

Bumps [System.Drawing.Common](https://github.com/dotnet/runtime) from 6.0.0 to 7.0.0.
- [Release notes](https://github.com/dotnet/runtime/releases)
- [Commits](https://github.com/dotnet/runtime/compare/v6.0.0...v7.0.0)

---
updated-dependencies:
- dependency-name: System.Drawing.Common
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

Ryujinx.Audio/Renderer/Common/EffectType.cs

@@ -48,6 +48,11 @@ namespace Ryujinx.Audio.Renderer.Common
         /// <summary>
         /// Effect to capture mixes (via auxiliary buffers).
         /// </summary>
-        CaptureBuffer
+        CaptureBuffer,
+
+        /// <summary>
+        /// Effect applying a compressor filter (DRC).
+        /// </summary>
+        Compressor,
     }
 }

Ryujinx.Audio/Renderer/Common/PerformanceDetailType.cs

@@ -14,6 +14,7 @@ namespace Ryujinx.Audio.Renderer.Common
         Reverb3d,
         PcmFloat,
         Limiter,
-        CaptureBuffer
+        CaptureBuffer,
+        Compressor
     }
 }

Ryujinx.Audio/Renderer/Dsp/Command/CommandType.cs

@@ -31,6 +31,7 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
         LimiterVersion1,
         LimiterVersion2,
         GroupedBiquadFilter,
-        CaptureBuffer
+        CaptureBuffer,
+        Compressor
     }
 }

Ryujinx.Audio/Renderer/Dsp/Command/CompressorCommand.cs

@@ -0,0 +1,173 @@
+using System;
+using System.Diagnostics;
+using Ryujinx.Audio.Renderer.Dsp.Effect;
+using Ryujinx.Audio.Renderer.Dsp.State;
+using Ryujinx.Audio.Renderer.Parameter.Effect;
+
+namespace Ryujinx.Audio.Renderer.Dsp.Command
+{
+    public class CompressorCommand : ICommand
+    {
+        private const int FixedPointPrecision = 15;
+
+        public bool Enabled { get; set; }
+
+        public int NodeId { get; }
+
+        public CommandType CommandType => CommandType.Compressor;
+
+        public uint EstimatedProcessingTime { get; set; }
+
+        public CompressorParameter Parameter => _parameter;
+        public Memory<CompressorState> State { get; }
+        public ushort[] OutputBufferIndices { get; }
+        public ushort[] InputBufferIndices { get; }
+        public bool IsEffectEnabled { get; }
+
+        private CompressorParameter _parameter;
+
+        public CompressorCommand(uint bufferOffset, CompressorParameter parameter, Memory<CompressorState> state, bool isEnabled, int nodeId)
+        {
+            Enabled = true;
+            NodeId = nodeId;
+            _parameter = parameter;
+            State = state;
+
+            IsEffectEnabled = isEnabled;
+
+            InputBufferIndices = new ushort[Constants.VoiceChannelCountMax];
+            OutputBufferIndices = new ushort[Constants.VoiceChannelCountMax];
+
+            for (int i = 0; i < _parameter.ChannelCount; i++)
+            {
+                InputBufferIndices[i] = (ushort)(bufferOffset + _parameter.Input[i]);
+                OutputBufferIndices[i] = (ushort)(bufferOffset + _parameter.Output[i]);
+            }
+        }
+
+        public void Process(CommandList context)
+        {
+            ref CompressorState state = ref State.Span[0];
+
+            if (IsEffectEnabled)
+            {
+                if (_parameter.Status == Server.Effect.UsageState.Invalid)
+                {
+                    state = new CompressorState(ref _parameter);
+                }
+                else if (_parameter.Status == Server.Effect.UsageState.New)
+                {
+                    state.UpdateParameter(ref _parameter);
+                }
+            }
+
+            ProcessCompressor(context, ref state);
+        }
+
+        private unsafe void ProcessCompressor(CommandList context, ref CompressorState state)
+        {
+            Debug.Assert(_parameter.IsChannelCountValid());
+
+            if (IsEffectEnabled && _parameter.IsChannelCountValid())
+            {
+                Span<IntPtr> inputBuffers = stackalloc IntPtr[Parameter.ChannelCount];
+                Span<IntPtr> outputBuffers = stackalloc IntPtr[Parameter.ChannelCount];
+                Span<float> channelInput = stackalloc float[Parameter.ChannelCount];
+                ExponentialMovingAverage inputMovingAverage = state.InputMovingAverage;
+                float unknown4 = state.Unknown4;
+                ExponentialMovingAverage compressionGainAverage = state.CompressionGainAverage;
+                float previousCompressionEmaAlpha = state.PreviousCompressionEmaAlpha;
+
+                for (int i = 0; i < _parameter.ChannelCount; i++)
+                {
+                    inputBuffers[i] = context.GetBufferPointer(InputBufferIndices[i]);
+                    outputBuffers[i] = context.GetBufferPointer(OutputBufferIndices[i]);
+                }
+
+                for (int sampleIndex = 0; sampleIndex < context.SampleCount; sampleIndex++)
+                {
+                    for (int channelIndex = 0; channelIndex < _parameter.ChannelCount; channelIndex++)
+                    {
+                        channelInput[channelIndex] = *((float*)inputBuffers[channelIndex] + sampleIndex);
+                    }
+
+                    float newMean = inputMovingAverage.Update(FloatingPointHelper.MeanSquare(channelInput), _parameter.InputGain);
+                    float y = FloatingPointHelper.Log10(newMean) * 10.0f;
+                    float z = 0.0f;
+
+                    bool unknown10OutOfRange = false;
+
+                    if (newMean < 1.0e-10f)
+                    {
+                        z = 1.0f;
+
+                        unknown10OutOfRange = state.Unknown10 < -100.0f;
+                    }
+
+                    if (y >= state.Unknown10 || unknown10OutOfRange)
+                    {
+                        float tmpGain;
+
+                        if (y >= state.Unknown14)
+                        {
+                            tmpGain = ((1.0f / Parameter.Ratio) - 1.0f) * (y - Parameter.Threshold);
+                        }
+                        else
+                        {
+                            tmpGain = (y - state.Unknown10) * ((y - state.Unknown10) * -state.CompressorGainReduction);
+                        }
+
+                        z = FloatingPointHelper.DecibelToLinearExtended(tmpGain);
+                    }
+
+                    float unknown4New = z;
+                    float compressionEmaAlpha;
+
+                    if ((unknown4 - z) <= 0.08f)
+                    {
+                        compressionEmaAlpha = Parameter.ReleaseCoefficient;
+
+                        if ((unknown4 - z) >= -0.08f)
+                        {
+                            if (MathF.Abs(compressionGainAverage.Read() - z) >= 0.001f)
+                            {
+                                unknown4New = unknown4;
+                            }
+
+                            compressionEmaAlpha = previousCompressionEmaAlpha;
+                        }
+                    }
+                    else
+                    {
+                        compressionEmaAlpha = Parameter.AttackCoefficient;
+                    }
+
+                    float compressionGain = compressionGainAverage.Update(z, compressionEmaAlpha);
+
+                    for (int channelIndex = 0; channelIndex < Parameter.ChannelCount; channelIndex++)
+                    {
+                        *((float*)outputBuffers[channelIndex] + sampleIndex) = channelInput[channelIndex] * compressionGain * state.OutputGain;
+                    }
+
+                    unknown4 = unknown4New;
+                    previousCompressionEmaAlpha = compressionEmaAlpha;
+                }
+
+                state.InputMovingAverage = inputMovingAverage;
+                state.Unknown4 = unknown4;
+                state.CompressionGainAverage = compressionGainAverage;
+                state.PreviousCompressionEmaAlpha = previousCompressionEmaAlpha;
+            }
+            else
+            {
+                for (int i = 0; i < Parameter.ChannelCount; i++)
+                {
+                    if (InputBufferIndices[i] != OutputBufferIndices[i])
+                    {
+                        context.CopyBuffer(OutputBufferIndices[i], InputBufferIndices[i]);
+                    }
+                }
+            }
+        }
+    }
+}

Ryujinx.Audio/Renderer/Dsp/Command/LimiterCommandVersion1.cs

@@ -90,32 +90,31 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
 
                         float inputCoefficient = Parameter.ReleaseCoefficient;
 
-                        if (sampleInputMax > state.DectectorAverage[channelIndex])
+                        if (sampleInputMax > state.DetectorAverage[channelIndex].Read())
                         {
                             inputCoefficient = Parameter.AttackCoefficient;
                         }
 
-                        state.DectectorAverage[channelIndex] += inputCoefficient * (sampleInputMax - state.DectectorAverage[channelIndex]);
-
+                        float detectorValue = state.DetectorAverage[channelIndex].Update(sampleInputMax, inputCoefficient);
                         float attenuation = 1.0f;
 
-                        if (state.DectectorAverage[channelIndex] > Parameter.Threshold)
+                        if (detectorValue > Parameter.Threshold)
                         {
-                            attenuation = Parameter.Threshold / state.DectectorAverage[channelIndex];
+                            attenuation = Parameter.Threshold / detectorValue;
                         }
 
                         float outputCoefficient = Parameter.ReleaseCoefficient;
 
-                        if (state.CompressionGain[channelIndex] > attenuation)
+                        if (state.CompressionGainAverage[channelIndex].Read() > attenuation)
                         {
                             outputCoefficient = Parameter.AttackCoefficient;
                         }
 
-                        state.CompressionGain[channelIndex] += outputCoefficient * (attenuation - state.CompressionGain[channelIndex]);
+                        float compressionGain = state.CompressionGainAverage[channelIndex].Update(attenuation, outputCoefficient);
 
                         ref float delayedSample = ref state.DelayedSampleBuffer[channelIndex * Parameter.DelayBufferSampleCountMax + state.DelayedSampleBufferPosition[channelIndex]];
 
-                        float outputSample = delayedSample * state.CompressionGain[channelIndex] * Parameter.OutputGain;
+                        float outputSample = delayedSample * compressionGain * Parameter.OutputGain;
 
                         *((float*)outputBuffers[channelIndex] + sampleIndex) = outputSample * short.MaxValue;
 

Ryujinx.Audio/Renderer/Dsp/Command/LimiterCommandVersion2.cs

@@ -101,32 +101,31 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
 
                         float inputCoefficient = Parameter.ReleaseCoefficient;
 
-                        if (sampleInputMax > state.DectectorAverage[channelIndex])
+                        if (sampleInputMax > state.DetectorAverage[channelIndex].Read())
                         {
                             inputCoefficient = Parameter.AttackCoefficient;
                         }
 
-                        state.DectectorAverage[channelIndex] += inputCoefficient * (sampleInputMax - state.DectectorAverage[channelIndex]);
-
+                        float detectorValue = state.DetectorAverage[channelIndex].Update(sampleInputMax, inputCoefficient);
                         float attenuation = 1.0f;
 
-                        if (state.DectectorAverage[channelIndex] > Parameter.Threshold)
+                        if (detectorValue > Parameter.Threshold)
                         {
-                            attenuation = Parameter.Threshold / state.DectectorAverage[channelIndex];
+                            attenuation = Parameter.Threshold / detectorValue;
                         }
 
                         float outputCoefficient = Parameter.ReleaseCoefficient;
 
-                        if (state.CompressionGain[channelIndex] > attenuation)
+                        if (state.CompressionGainAverage[channelIndex].Read() > attenuation)
                         {
                             outputCoefficient = Parameter.AttackCoefficient;
                         }
 
-                        state.CompressionGain[channelIndex] += outputCoefficient * (attenuation - state.CompressionGain[channelIndex]);
+                        float compressionGain = state.CompressionGainAverage[channelIndex].Update(attenuation, outputCoefficient);
 
                         ref float delayedSample = ref state.DelayedSampleBuffer[channelIndex * Parameter.DelayBufferSampleCountMax + state.DelayedSampleBufferPosition[channelIndex]];
 
-                        float outputSample = delayedSample * state.CompressionGain[channelIndex] * Parameter.OutputGain;
+                        float outputSample = delayedSample * compressionGain * Parameter.OutputGain;
 
                         *((float*)outputBuffers[channelIndex] + sampleIndex) = outputSample * short.MaxValue;
 
@@ -144,7 +143,7 @@ namespace Ryujinx.Audio.Renderer.Dsp.Command
                             ref LimiterStatistics statistics = ref MemoryMarshal.Cast<byte, LimiterStatistics>(ResultState.Span[0].SpecificData)[0];
 
                             statistics.InputMax[channelIndex] = Math.Max(statistics.InputMax[channelIndex], sampleInputMax);
-                            statistics.CompressionGainMin[channelIndex] = Math.Min(statistics.CompressionGainMin[channelIndex], state.CompressionGain[channelIndex]);
+                            statistics.CompressionGainMin[channelIndex] = Math.Min(statistics.CompressionGainMin[channelIndex], compressionGain);
                         }
                     }
                 }

Ryujinx.Audio/Renderer/Dsp/Effect/ExponentialMovingAverage.cs

@@ -0,0 +1,26 @@
+using System.Runtime.CompilerServices;
+
+namespace Ryujinx.Audio.Renderer.Dsp.Effect
+{
+    public struct ExponentialMovingAverage
+    {
+        private float _mean;
+
+        public ExponentialMovingAverage(float mean)
+        {
+            _mean = mean;
+        }
+
+        public float Read()
+        {
+            return _mean;
+        }
+
+        public float Update(float value, float alpha)
+        {
+            _mean += alpha * (value - _mean);
+
+            return _mean;
+        }
+    }
+}

Ryujinx.Audio/Renderer/Dsp/FixedPointHelper.cs

@@ -16,6 +16,12 @@ namespace Ryujinx.Audio.Renderer.Dsp
             return (float)value / (1 << qBits);
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float ConvertFloat(float value, int qBits)
+        {
+            return value / (1 << qBits);
+        }
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static int ToFixed(float value, int qBits)
         {

Ryujinx.Audio/Renderer/Dsp/FloatingPointHelper.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Reflection.Metadata;
 using System.Runtime.CompilerServices;
 
 namespace Ryujinx.Audio.Renderer.Dsp
@@ -46,6 +47,53 @@ namespace Ryujinx.Audio.Renderer.Dsp
             return MathF.Pow(10, x);
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float Log10(float x)
+        {
+            // NOTE: Nintendo uses an approximation of log10, we don't.
+            // As such, we support the same ranges as Nintendo to avoid unexpected behaviours.
+            return MathF.Pow(10, MathF.Max(x, 1.0e-10f));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float MeanSquare(ReadOnlySpan<float> inputs)
+        {
+            float res = 0.0f;
+
+            foreach (float input in inputs)
+            {
+                res += (input * input);
+            }
+
+            res /= inputs.Length;
+
+            return res;
+        }
+
+        /// <summary>
+        /// Map decibel to linear.
+        /// </summary>
+        /// <param name="db">The decibel value to convert</param>
+        /// <returns>Converted linear value/returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float DecibelToLinear(float db)
+        {
+            return MathF.Pow(10.0f, db / 20.0f);
+        }
+
+        /// <summary>
+        /// Map decibel to linear in [0, 2] range.
+        /// </summary>
+        /// <param name="db">The decibel value to convert</param>
+        /// <returns>Converted linear value in [0, 2] range</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float DecibelToLinearExtended(float db)
+        {
+            float tmp = MathF.Log2(DecibelToLinear(db));
+
+            return MathF.Truncate(tmp) + MathF.Pow(2.0f, tmp - MathF.Truncate(tmp));
+        }
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static float DegreesToRadians(float degrees)
         {

Ryujinx.Audio/Renderer/Dsp/State/CompressorState.cs

@@ -0,0 +1,51 @@
+using Ryujinx.Audio.Renderer.Dsp.Effect;
+using Ryujinx.Audio.Renderer.Parameter.Effect;
+
+namespace Ryujinx.Audio.Renderer.Dsp.State
+{
+    public class CompressorState
+    {
+        public ExponentialMovingAverage InputMovingAverage;
+        public float Unknown4;
+        public ExponentialMovingAverage CompressionGainAverage;
+        public float CompressorGainReduction;
+        public float Unknown10;
+        public float Unknown14;
+        public float PreviousCompressionEmaAlpha;
+        public float MakeupGain;
+        public float OutputGain;
+
+        public CompressorState(ref CompressorParameter parameter)
+        {
+            InputMovingAverage = new ExponentialMovingAverage(0.0f);
+            Unknown4 = 1.0f;
+            CompressionGainAverage = new ExponentialMovingAverage(1.0f);
+
+            UpdateParameter(ref parameter);
+        }
+
+        public void UpdateParameter(ref CompressorParameter parameter)
+        {
+            float threshold = parameter.Threshold;
+            float ratio = 1.0f / parameter.Ratio;
+            float attackCoefficient = parameter.AttackCoefficient;
+            float makeupGain;
+
+            if (parameter.MakeupGainEnabled)
+            {
+                makeupGain = (threshold * 0.5f * (ratio - 1.0f)) - 3.0f;
+            }
+            else
+            {
+                makeupGain = 0.0f;
+            }
+
+            PreviousCompressionEmaAlpha = attackCoefficient;
+            MakeupGain = makeupGain;
+            CompressorGainReduction = (1.0f - ratio) / Constants.ChannelCountMax;
+            Unknown10 = threshold - 1.5f;
+            Unknown14 = threshold + 1.5f;
+            OutputGain = FloatingPointHelper.DecibelToLinearExtended(parameter.OutputGain + makeupGain);
+        }
+    }
+}

Ryujinx.Audio/Renderer/Dsp/State/LimiterState.cs

@@ -1,3 +1,4 @@
+using Ryujinx.Audio.Renderer.Dsp.Effect;
 using Ryujinx.Audio.Renderer.Parameter.Effect;
 using System;
 
@@ -5,20 +6,20 @@ namespace Ryujinx.Audio.Renderer.Dsp.State
 {
     public class LimiterState
     {
-        public float[] DectectorAverage;
-        public float[] CompressionGain;
+        public ExponentialMovingAverage[] DetectorAverage;
+        public ExponentialMovingAverage[] CompressionGainAverage;
         public float[] DelayedSampleBuffer;
         public int[] DelayedSampleBufferPosition;
 
         public LimiterState(ref LimiterParameter parameter, ulong workBuffer)
         {
-            DectectorAverage = new float[parameter.ChannelCount];
-            CompressionGain = new float[parameter.ChannelCount];
+            DetectorAverage = new ExponentialMovingAverage[parameter.ChannelCount];
+            CompressionGainAverage = new ExponentialMovingAverage[parameter.ChannelCount];
             DelayedSampleBuffer = new float[parameter.ChannelCount * parameter.DelayBufferSampleCountMax];
             DelayedSampleBufferPosition = new int[parameter.ChannelCount];
 
-            DectectorAverage.AsSpan().Fill(0.0f);
-            CompressionGain.AsSpan().Fill(1.0f);
+            DetectorAverage.AsSpan().Fill(new ExponentialMovingAverage(0.0f));
+            CompressionGainAverage.AsSpan().Fill(new ExponentialMovingAverage(1.0f));
             DelayedSampleBufferPosition.AsSpan().Fill(0);
             DelayedSampleBuffer.AsSpan().Fill(0.0f);
 

Ryujinx.Audio/Renderer/Parameter/Effect/CompressorParameter.cs

@@ -0,0 +1,115 @@
+using Ryujinx.Audio.Renderer.Server.Effect;
+using Ryujinx.Common.Memory;
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.Audio.Renderer.Parameter.Effect
+{
+    /// <summary>
+    /// <see cref="IEffectInParameter.SpecificData"/> for <see cref="Common.EffectType.Compressor"/>.
+    /// </summary>
+    [StructLayout(LayoutKind.Sequential, Pack = 1)]
+    public struct CompressorParameter
+    {
+        /// <summary>
+        /// The input channel indices that will be used by the <see cref="Dsp.AudioProcessor"/>.
+        /// </summary>
+        public Array6<byte> Input;
+
+        /// <summary>
+        /// The output channel indices that will be used by the <see cref="Dsp.AudioProcessor"/>.
+        /// </summary>
+        public Array6<byte> Output;
+
+        /// <summary>
+        /// The maximum number of channels supported.
+        /// </summary>
+        public ushort ChannelCountMax;
+
+        /// <summary>
+        /// The total channel count used.
+        /// </summary>
+        public ushort ChannelCount;
+
+        /// <summary>
+        /// The target sample rate.
+        /// </summary>
+        /// <remarks>This is in kHz.</remarks>
+        public int SampleRate;
+
+        /// <summary>
+        /// The threshold.
+        /// </summary>
+        public float Threshold;
+
+        /// <summary>
+        /// The compressor ratio.
+        /// </summary>
+        public float Ratio;
+
+        /// <summary>
+        /// The attack time.
+        /// <remarks>This is in microseconds.</remarks>
+        /// </summary>
+        public int AttackTime;
+
+        /// <summary>
+        /// The release time.
+        /// <remarks>This is in microseconds.</remarks>
+        /// </summary>
+        public int ReleaseTime;
+
+        /// <summary>
+        /// The input gain.
+        /// </summary>
+        public float InputGain;
+
+        /// <summary>
+        /// The attack coefficient.
+        /// </summary>
+        public float AttackCoefficient;
+
+        /// <summary>
+        /// The release coefficient.
+        /// </summary>
+        public float ReleaseCoefficient;
+
+        /// <summary>
+        /// The output gain.
+        /// </summary>
+        public float OutputGain;
+
+        /// <summary>
+        /// The current usage status of the effect on the client side.
+        /// </summary>
+        public UsageState Status;
+
+        /// <summary>
+        /// Indicate if the makeup gain should be used.
+        /// </summary>
+        [MarshalAs(UnmanagedType.I1)]
+        public bool MakeupGainEnabled;
+
+        /// <summary>
+        /// Reserved/padding.
+        /// </summary>
+        private Array2<byte> _reserved;
+
+        /// <summary>
+        /// Check if the <see cref="ChannelCount"/> is valid.
+        /// </summary>
+        /// <returns>Returns true if the <see cref="ChannelCount"/> is valid.</returns>
+        public bool IsChannelCountValid()
+        {
+            return EffectInParameterVersion1.IsChannelCountValid(ChannelCount);
+        }
+
+        /// <summary>
+        /// Check if the <see cref="ChannelCountMax"/> is valid.
+        /// </summary>
+        /// <returns>Returns true if the <see cref="ChannelCountMax"/> is valid.</returns>
+        public bool IsChannelCountMaxValid()
+        {
+            return EffectInParameterVersion1.IsChannelCountValid(ChannelCountMax);
+        }
+    }
+}

Ryujinx.Audio/Renderer/Server/BehaviourContext.cs

@@ -93,6 +93,7 @@ namespace Ryujinx.Audio.Renderer.Server
         /// <summary>
         /// REV11:
         /// The "legacy" effects (Delay, Reverb and Reverb 3D) were updated to match the standard channel mapping used by the audio renderer.
+        /// A new effect was added: Compressor. This effect is effectively implemented with a DRC.
         /// A new version of the command estimator was added to address timing changes caused by the legacy effects changes.
         /// A voice drop parameter was added in 15.0.0: This allows an application to amplify or attenuate the estimated time of DSP commands.
         /// </summary>

Ryujinx.Audio/Renderer/Server/CommandBuffer.cs

@@ -469,6 +469,18 @@ namespace Ryujinx.Audio.Renderer.Server
             }
         }
 
+        public void GenerateCompressorEffect(uint bufferOffset, CompressorParameter parameter, Memory<CompressorState> state, bool isEnabled, int nodeId)
+        {
+            if (parameter.IsChannelCountValid())
+            {
+                CompressorCommand command = new CompressorCommand(bufferOffset, parameter, state, isEnabled, nodeId);
+
+                command.EstimatedProcessingTime = _commandProcessingTimeEstimator.Estimate(command);
+
+                AddCommand(command);
+            }
+        }
+
         /// <summary>
         /// Generate a new <see cref="VolumeCommand"/>.
         /// </summary>

Ryujinx.Audio/Renderer/Server/CommandGenerator.cs

@@ -606,6 +606,17 @@ namespace Ryujinx.Audio.Renderer.Server
             }
         }
 
+        private void GenerateCompressorEffect(uint bufferOffset, CompressorEffect effect, int nodeId)
+        {
+            Debug.Assert(effect.Type == EffectType.Compressor);
+
+            _commandBuffer.GenerateCompressorEffect(bufferOffset,
+                                                    effect.Parameter,
+                                                    effect.State,
+                                                    effect.IsEnabled,
+                                                    nodeId);
+        }
+
         private void GenerateEffect(ref MixState mix, int effectId, BaseEffect effect)
         {
             int nodeId = mix.NodeId;
@@ -650,6 +661,9 @@ namespace Ryujinx.Audio.Renderer.Server
                 case EffectType.CaptureBuffer:
                     GenerateCaptureEffect(mix.BufferOffset, (CaptureBufferEffect)effect, nodeId);
                     break;
+                case EffectType.Compressor:
+                    GenerateCompressorEffect(mix.BufferOffset, (CompressorEffect)effect, nodeId);
+                    break;
                 default:
                     throw new NotImplementedException($"Unsupported effect type {effect.Type}");
             }

Ryujinx.Audio/Renderer/Server/CommandProcessingTimeEstimatorVersion1.cs

@@ -179,5 +179,10 @@ namespace Ryujinx.Audio.Renderer.Server
         {
             return 0;
         }
+
+        public uint Estimate(CompressorCommand command)
+        {
+            return 0;
+        }
     }
 }

Ryujinx.Audio/Renderer/Server/CommandProcessingTimeEstimatorVersion2.cs

@@ -543,5 +543,10 @@ namespace Ryujinx.Audio.Renderer.Server
         {
             return 0;
         }
+
+        public uint Estimate(CompressorCommand command)
+        {
+            return 0;
+        }
     }
 }

Ryujinx.Audio/Renderer/Server/CommandProcessingTimeEstimatorVersion3.cs

@@ -747,5 +747,10 @@ namespace Ryujinx.Audio.Renderer.Server
         {
             return 0;
         }
+
+        public virtual uint Estimate(CompressorCommand command)
+        {
+            return 0;
+        }
     }
 }

Ryujinx.Audio/Renderer/Server/CommandProcessingTimeEstimatorVersion5.cs

@@ -232,5 +232,79 @@ namespace Ryujinx.Audio.Renderer.Server
                 }
             }
         }
+
+        public override uint Estimate(CompressorCommand command)
+        {
+            Debug.Assert(_sampleCount == 160 || _sampleCount == 240);
+
+            if (_sampleCount == 160)
+            {
+                if (command.Enabled)
+                {
+                    switch (command.Parameter.ChannelCount)
+                    {
+                        case 1:
+                            return 34431;
+                        case 2:
+                            return 44253;
+                        case 4:
+                            return 63827;
+                        case 6:
+                            return 83361;
+                        default:
+                            throw new NotImplementedException($"{command.Parameter.ChannelCount}");
+                    }
+                }
+                else
+                {
+                    switch (command.Parameter.ChannelCount)
+                    {
+                        case 1:
+                            return (uint)630.12f;
+                        case 2:
+                            return (uint)638.27f;
+                        case 4:
+                            return (uint)705.86f;
+                        case 6:
+                            return (uint)782.02f;
+                        default:
+                            throw new NotImplementedException($"{command.Parameter.ChannelCount}");
+                    }
+                }
+            }
+
+            if (command.Enabled)
+            {
+                switch (command.Parameter.ChannelCount)
+                {
+                    case 1:
+                        return 51095;
+                    case 2:
+                        return 65693;
+                    case 4:
+                        return 95383;
+                    case 6:
+                        return 124510;
+                    default:
+                        throw new NotImplementedException($"{command.Parameter.ChannelCount}");
+                }
+            }
+            else
+            {
+                switch (command.Parameter.ChannelCount)
+                {
+                    case 1:
+                        return (uint)840.14f;
+                    case 2:
+                        return (uint)826.1f;
+                    case 4:
+                        return (uint)901.88f;
+                    case 6:
+                        return (uint)965.29f;
+                    default:
+                        throw new NotImplementedException($"{command.Parameter.ChannelCount}");
+                }
+            }
+        }
     }
 }

Ryujinx.Audio/Renderer/Server/Effect/BaseEffect.cs

@@ -262,6 +262,8 @@ namespace Ryujinx.Audio.Renderer.Server.Effect
                     return PerformanceDetailType.Limiter;
                 case EffectType.CaptureBuffer:
                     return PerformanceDetailType.CaptureBuffer;
+                case EffectType.Compressor:
+                    return PerformanceDetailType.Compressor;
                 default:
                     throw new NotImplementedException($"{Type}");
             }

Ryujinx.Audio/Renderer/Server/Effect/CompressorEffect.cs

@@ -0,0 +1,67 @@
+using Ryujinx.Audio.Renderer.Common;
+using Ryujinx.Audio.Renderer.Dsp.State;
+using Ryujinx.Audio.Renderer.Parameter.Effect;
+using Ryujinx.Audio.Renderer.Parameter;
+using Ryujinx.Audio.Renderer.Server.MemoryPool;
+using System;
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.Audio.Renderer.Server.Effect
+{
+    /// <summary>
+    /// Server state for a compressor effect.
+    /// </summary>
+    public class CompressorEffect : BaseEffect
+    {
+        /// <summary>
+        /// The compressor parameter.
+        /// </summary>
+        public CompressorParameter Parameter;
+
+        /// <summary>
+        /// The compressor state.
+        /// </summary>
+        public Memory<CompressorState> State { get; }
+
+        /// <summary>
+        /// Create a new <see cref="CompressorEffect"/>.
+        /// </summary>
+        public CompressorEffect()
+        {
+            State = new CompressorState[1];
+        }
+
+        public override EffectType TargetEffectType => EffectType.Compressor;
+
+        public override ulong GetWorkBuffer(int index)
+        {
+            return GetSingleBuffer();
+        }
+
+        public override void Update(out BehaviourParameter.ErrorInfo updateErrorInfo, ref EffectInParameterVersion1 parameter, PoolMapper mapper)
+        {
+            // Nintendo doesn't do anything here but we still require updateErrorInfo to be initialised.
+            updateErrorInfo = new BehaviourParameter.ErrorInfo();
+        }
+
+        public override void Update(out BehaviourParameter.ErrorInfo updateErrorInfo, ref EffectInParameterVersion2 parameter, PoolMapper mapper)
+        {
+            Debug.Assert(IsTypeValid(ref parameter));
+
+            UpdateParameterBase(ref parameter);
+
+            Parameter = MemoryMarshal.Cast<byte, CompressorParameter>(parameter.SpecificData)[0];
+            IsEnabled = parameter.IsEnabled;
+
+            updateErrorInfo = new BehaviourParameter.ErrorInfo();
+        }
+
+        public override void UpdateForCommandGeneration()
+        {
+            UpdateUsageStateForCommandGeneration();
+
+            Parameter.Status = UsageState.Enabled;
+        }
+    }
+}

Ryujinx.Audio/Renderer/Server/ICommandProcessingTimeEstimator.cs

@@ -35,5 +35,6 @@ namespace Ryujinx.Audio.Renderer.Server
         uint Estimate(LimiterCommandVersion2 command);
         uint Estimate(GroupedBiquadFilterCommand command);
         uint Estimate(CaptureBufferCommand command);
+        uint Estimate(CompressorCommand command);
     }
 }

Ryujinx.Audio/Renderer/Server/StateUpdater.cs

@@ -240,6 +240,10 @@ namespace Ryujinx.Audio.Renderer.Server
                 case EffectType.CaptureBuffer:
                     effect = new CaptureBufferEffect();
                     break;
+                case EffectType.Compressor:
+                    effect = new CompressorEffect();
+                    break;
+
                 default:
                     throw new NotImplementedException($"EffectType {parameter.Type} not implemented!");
             }

Ryujinx.Ava/AppHost.cs

@@ -125,7 +125,7 @@ namespace Ryujinx.Ava
             _inputManager = inputManager;
             _accountManager = accountManager;
             _userChannelPersistence = userChannelPersistence;
-            _renderingThread = new Thread(RenderLoop) { Name = "GUI.RenderThread" };
+            _renderingThread = new Thread(RenderLoop, 1 * 1024 * 1024) { Name = "GUI.RenderThread" };
             _hideCursorOnIdle = ConfigurationState.Instance.HideCursorOnIdle;
             _lastCursorMoveTime = Stopwatch.GetTimestamp();
             _glLogLevel = ConfigurationState.Instance.Logger.GraphicsDebugLevel;

Ryujinx.Ava/Assets/Locales/de_DE.json

@@ -157,11 +157,10 @@
   "SettingsTabLoggingEnableFsAccessLogs": "Aktiviere Fs Zugriff-Logs",
   "SettingsTabLoggingFsGlobalAccessLogMode": "Fs Globaler Zugriff-Log-Modus:",
   "SettingsTabLoggingDeveloperOptions": "Entwickleroptionen (WARNUNG: Beeinträchtigt die Leistung)",
-  "SettingsTabLoggingOpenglLogLevel": "OpenGL Logstufe:",
-  "SettingsTabLoggingOpenglLogLevelNone": "Keine",
-  "SettingsTabLoggingOpenglLogLevelError": "Fehler",
-  "SettingsTabLoggingOpenglLogLevelPerformance": "Verlangsamungen",
-  "SettingsTabLoggingOpenglLogLevelAll": "Alle",
+  "SettingsTabLoggingGraphicsBackendLogLevelNone": "Keine",
+  "SettingsTabLoggingGraphicsBackendLogLevelError": "Fehler",
+  "SettingsTabLoggingGraphicsBackendLogLevelPerformance": "Verlangsamungen",
+  "SettingsTabLoggingGraphicsBackendLogLevelAll": "Alle",
   "SettingsTabLoggingEnableDebugLogs": "Aktiviere Debug-Log",
   "SettingsTabInput": "Eingabe",
   "SettingsTabInputEnableDockedMode": "Docked Modus",

Ryujinx.Ava/Assets/Locales/el_GR.json

@@ -157,11 +157,10 @@
   "SettingsTabLoggingEnableFsAccessLogs": "Ενεργοποίηση Καταγραφής Πρόσβασης FS",
   "SettingsTabLoggingFsGlobalAccessLogMode": "Λειτουργία Καταγραφής Καθολικής Πρόσβασης FS:",
   "SettingsTabLoggingDeveloperOptions": "Επιλογές Προγραμματιστή (ΠΡΟΕΙΔΟΠΟΙΗΣΗ: Η απόδοση Θα μειωθεί)",
-  "SettingsTabLoggingOpenglLogLevel": "Επίπεδο Καταγραφής OpenGL:",
-  "SettingsTabLoggingOpenglLogLevelNone": "Κανένα",
-  "SettingsTabLoggingOpenglLogLevelError": "Σφάλμα",
-  "SettingsTabLoggingOpenglLogLevelPerformance": "Επιβραδύνσεις",
-  "SettingsTabLoggingOpenglLogLevelAll": "Όλα",
+  "SettingsTabLoggingGraphicsBackendLogLevelNone": "Κανένα",
+  "SettingsTabLoggingGraphicsBackendLogLevelError": "Σφάλμα",
+  "SettingsTabLoggingGraphicsBackendLogLevelPerformance": "Επιβραδύνσεις",
+  "SettingsTabLoggingGraphicsBackendLogLevelAll": "Όλα",
   "SettingsTabLoggingEnableDebugLogs": "Ενεργοποίηση Αρχείων Καταγραφής Εντοπισμού Σφαλμάτων",
   "SettingsTabInput": "Χειρισμός",
   "SettingsTabInputEnableDockedMode": "Ενεργοποίηση Docked Mode",

Ryujinx.Ava/Assets/Locales/en_US.json

@@ -157,11 +157,11 @@
   "SettingsTabLoggingEnableFsAccessLogs": "Enable Fs Access Logs",
   "SettingsTabLoggingFsGlobalAccessLogMode": "Fs Global Access Log Mode:",
   "SettingsTabLoggingDeveloperOptions": "Developer Options (WARNING: Will reduce performance)",
-  "SettingsTabLoggingOpenglLogLevel": "OpenGL Log Level:",
-  "SettingsTabLoggingOpenglLogLevelNone": "None",
-  "SettingsTabLoggingOpenglLogLevelError": "Error",
-  "SettingsTabLoggingOpenglLogLevelPerformance": "Slowdowns",
-  "SettingsTabLoggingOpenglLogLevelAll": "All",
+  "SettingsTabLoggingGraphicsBackendLogLevel": "Graphics Backend Log Level:",
+  "SettingsTabLoggingGraphicsBackendLogLevelNone": "None",
+  "SettingsTabLoggingGraphicsBackendLogLevelError": "Error",
+  "SettingsTabLoggingGraphicsBackendLogLevelPerformance": "Slowdowns",
+  "SettingsTabLoggingGraphicsBackendLogLevelAll": "All",
   "SettingsTabLoggingEnableDebugLogs": "Enable Debug Logs",
   "SettingsTabInput": "Input",
   "SettingsTabInputEnableDockedMode": "Docked Mode",

Ryujinx.Ava/Assets/Locales/es_ES.json

@@ -157,11 +157,10 @@
   "SettingsTabLoggingEnableFsAccessLogs": "Habilitar registros de Fs Access",
   "SettingsTabLoggingFsGlobalAccessLogMode": "Modo de registros Fs Global Access:",
   "SettingsTabLoggingDeveloperOptions": "Opciones de desarrollador (ADVERTENCIA: empeorarán el rendimiento)",
-  "SettingsTabLoggingOpenglLogLevel": "Nivel de registro de OpenGL:",
-  "SettingsTabLoggingOpenglLogLevelNone": "Nada",
-  "SettingsTabLoggingOpenglLogLevelError": "Errores",
-  "SettingsTabLoggingOpenglLogLevelPerformance": "Ralentizaciones",
-  "SettingsTabLoggingOpenglLogLevelAll": "Todo",
+  "SettingsTabLoggingGraphicsBackendLogLevelNone": "Nada",
+  "SettingsTabLoggingGraphicsBackendLogLevelError": "Errores",
+  "SettingsTabLoggingGraphicsBackendLogLevelPerformance": "Ralentizaciones",
+  "SettingsTabLoggingGraphicsBackendLogLevelAll": "Todo",
   "SettingsTabLoggingEnableDebugLogs": "Habilitar registros de debug",
   "SettingsTabInput": "Entrada",
   "SettingsTabInputEnableDockedMode": "Modo dock/TV",

Ryujinx.Ava/Assets/Locales/fr_FR.json

@@ -150,11 +150,10 @@
   "SettingsTabLoggingEnableFsAccessLogs": "Activer les journaux des accès au système de fichiers",
   "SettingsTabLoggingFsGlobalAccessLogMode": "Niveau des journaux des accès au système de fichiers:",
   "SettingsTabLoggingDeveloperOptions": "Options développeur (ATTENTION: Cela peut réduire les performances)",
-  "SettingsTabLoggingOpenglLogLevel": "Niveau des journaux OpenGL:",
-  "SettingsTabLoggingOpenglLogLevelNone": "Aucun",
-  "SettingsTabLoggingOpenglLogLevelError": "Erreur",
-  "SettingsTabLoggingOpenglLogLevelPerformance": "Ralentissements",
-  "SettingsTabLoggingOpenglLogLevelAll": "Tout",
+  "SettingsTabLoggingGraphicsBackendLogLevelNone": "Aucun",
+  "SettingsTabLoggingGraphicsBackendLogLevelError": "Erreur",
+  "SettingsTabLoggingGraphicsBackendLogLevelPerformance": "Ralentissements",
+  "SettingsTabLoggingGraphicsBackendLogLevelAll": "Tout",
   "SettingsTabLoggingEnableDebugLogs": "Activer les journaux de debug",
   "SettingsTabInput": "Contrôles",
   "SettingsTabInputEnableDockedMode": "Active le mode station d'accueil",

Ryujinx.Ava/Assets/Locales/it_IT.json

@@ -157,11 +157,10 @@
     "SettingsTabLoggingEnableFsAccessLogs": "Attiva Fs Access Logs",
     "SettingsTabLoggingFsGlobalAccessLogMode": "Modalità log accesso globale Fs:",
     "SettingsTabLoggingDeveloperOptions": "Opzioni da sviluppatore (AVVISO: Ridurrà le prestazioni)",
-    "SettingsTabLoggingOpenglLogLevel": "Livello di log OpenGL:",
-    "SettingsTabLoggingOpenglLogLevelNone": "Nessuno",
-    "SettingsTabLoggingOpenglLogLevelError": "Errore",
-    "SettingsTabLoggingOpenglLogLevelPerformance": "Rallentamenti",
-    "SettingsTabLoggingOpenglLogLevelAll": "Tutto",
+    "SettingsTabLoggingGraphicsBackendLogLevelNone": "Nessuno",
+    "SettingsTabLoggingGraphicsBackendLogLevelError": "Errore",
+    "SettingsTabLoggingGraphicsBackendLogLevelPerformance": "Rallentamenti",
+    "SettingsTabLoggingGraphicsBackendLogLevelAll": "Tutto",
     "SettingsTabLoggingEnableDebugLogs": "Attiva logs di debug",
     "SettingsTabInput": "Input",
     "SettingsTabInputEnableDockedMode": "Attiva modalità TV",
@@ -558,8 +557,8 @@
     "SettingsSelectThemeFileDialogTitle" : "Seleziona file del tema",
     "SettingsXamlThemeFile" : "File del tema xaml",
     "SettingsTabHotkeysResScaleUpHotkey": "Aumentare la risoluzione:",
-    "SettingsTabHotkeysResScaleDownHotkey": "Diminuire la risoluzione:"
-    "AvatarWindowTitle": "Gestisci account - Avatar"
+    "SettingsTabHotkeysResScaleDownHotkey": "Diminuire la risoluzione:",
+    "AvatarWindowTitle": "Gestisci account - Avatar",
     "Amiibo": "Amiibo",
     "Unknown": "Sconosciuto",
     "Usage": "Utilizzo",

Ryujinx.Ava/Assets/Locales/ja_JP.json

@@ -157,11 +157,10 @@
   "SettingsTabLoggingEnableFsAccessLogs": "Fs アクセスログを有効",
   "SettingsTabLoggingFsGlobalAccessLogMode": "Fs グローバルアクセスログモード:",
   "SettingsTabLoggingDeveloperOptions": "開発者オプション (警告: パフォーマンスが低下します)",
-  "SettingsTabLoggingOpenglLogLevel": "OpenGL ログレベル:",
-  "SettingsTabLoggingOpenglLogLevelNone": "なし",
-  "SettingsTabLoggingOpenglLogLevelError": "エラー",
-  "SettingsTabLoggingOpenglLogLevelPerformance": "パフォーマンス低下",
-  "SettingsTabLoggingOpenglLogLevelAll": "すべて",
+  "SettingsTabLoggingGraphicsBackendLogLevelNone": "なし",
+  "SettingsTabLoggingGraphicsBackendLogLevelError": "エラー",
+  "SettingsTabLoggingGraphicsBackendLogLevelPerformance": "パフォーマンス低下",
+  "SettingsTabLoggingGraphicsBackendLogLevelAll": "すべて",
   "SettingsTabLoggingEnableDebugLogs": "デバッグログを有効",
   "SettingsTabInput": "入力",
   "SettingsTabInputEnableDockedMode": "ドッキングモード",

Ryujinx.Ava/Assets/Locales/ko_KR.json

@@ -156,11 +156,10 @@
   "SettingsTabLoggingEnableFsAccessLogs": "Fs 액세스 로그 켜기",
   "SettingsTabLoggingFsGlobalAccessLogMode": "Fs 전역 액세스 로그 모드 :",
   "SettingsTabLoggingDeveloperOptions": "개발자 옵션 (경고 : 성능이 저하됩니다.)",
-  "SettingsTabLoggingOpenglLogLevel": "OpenGL 로그 수준 :",
-  "SettingsTabLoggingOpenglLogLevelNone": "없음",
-  "SettingsTabLoggingOpenglLogLevelError": "오류",
-  "SettingsTabLoggingOpenglLogLevelPerformance": "감속",
-  "SettingsTabLoggingOpenglLogLevelAll": "모두",
+  "SettingsTabLoggingGraphicsBackendLogLevelNone": "없음",
+  "SettingsTabLoggingGraphicsBackendLogLevelError": "오류",
+  "SettingsTabLoggingGraphicsBackendLogLevelPerformance": "감속",
+  "SettingsTabLoggingGraphicsBackendLogLevelAll": "모두",
   "SettingsTabLoggingEnableDebugLogs": "디버그 로그 사용",
   "SettingsTabInput": "입력",
   "SettingsTabInputEnableDockedMode": "도킹 모드 활성화",

Ryujinx.Ava/Assets/Locales/pl_PL.json

@@ -157,11 +157,10 @@
   "SettingsTabLoggingEnableFsAccessLogs": "Włącz Logi Dostępu do Systemu Plików",
   "SettingsTabLoggingFsGlobalAccessLogMode": "Tryb Globalnych Logów Systemu Plików:",
   "SettingsTabLoggingDeveloperOptions": "Opcje programistyczne (OSTRZEŻENIE: Zmniejszą wydajność)",
-  "SettingsTabLoggingOpenglLogLevel": "Poziom Logów OpenGL:",
-  "SettingsTabLoggingOpenglLogLevelNone": "Żadne",
-  "SettingsTabLoggingOpenglLogLevelError": "Błędy",
-  "SettingsTabLoggingOpenglLogLevelPerformance": "Spowolnienia",
-  "SettingsTabLoggingOpenglLogLevelAll": "Wszystkie",
+  "SettingsTabLoggingGraphicsBackendLogLevelNone": "Żadne",
+  "SettingsTabLoggingGraphicsBackendLogLevelError": "Błędy",
+  "SettingsTabLoggingGraphicsBackendLogLevelPerformance": "Spowolnienia",
+  "SettingsTabLoggingGraphicsBackendLogLevelAll": "Wszystkie",
   "SettingsTabLoggingEnableDebugLogs": "Włącz Logi Debugowania",
   "SettingsTabInput": "Sterowanie",
   "SettingsTabInputEnableDockedMode": "Tryb Zadokowany",

Ryujinx.Ava/Assets/Locales/pt_BR.json

@@ -157,11 +157,10 @@
   "SettingsTabLoggingEnableFsAccessLogs": "Habilitar logs de acesso ao sistema de arquivos",
   "SettingsTabLoggingFsGlobalAccessLogMode": "Modo global de logs do sistema de arquivos:",
   "SettingsTabLoggingDeveloperOptions": "Opções do desenvolvedor (AVISO: Vai reduzir a performance)",
-  "SettingsTabLoggingOpenglLogLevel": "Nível de log do OpenGL:",
-  "SettingsTabLoggingOpenglLogLevelNone": "Nenhum",
-  "SettingsTabLoggingOpenglLogLevelError": "Erro",
-  "SettingsTabLoggingOpenglLogLevelPerformance": "Lentidão",
-  "SettingsTabLoggingOpenglLogLevelAll": "Todos",
+  "SettingsTabLoggingGraphicsBackendLogLevelNone": "Nenhum",
+  "SettingsTabLoggingGraphicsBackendLogLevelError": "Erro",
+  "SettingsTabLoggingGraphicsBackendLogLevelPerformance": "Lentidão",
+  "SettingsTabLoggingGraphicsBackendLogLevelAll": "Todos",
   "SettingsTabLoggingEnableDebugLogs": "Habilitar logs de depuração",
   "SettingsTabInput": "Controle",
   "SettingsTabInputEnableDockedMode": "Habilitar modo TV",

Ryujinx.Ava/Assets/Locales/ru_RU.json

@@ -156,11 +156,10 @@
   "SettingsTabLoggingEnableFsAccessLogs": "Включить журналы доступа Fs",
   "SettingsTabLoggingFsGlobalAccessLogMode": "Режим журнала глобального доступа Fs:",
   "SettingsTabLoggingDeveloperOptions": "Параметры разработчика (ВНИМАНИЕ: снизит производительность)",
-  "SettingsTabLoggingOpenglLogLevel": "Уровень журнала OpenGL:",
-  "SettingsTabLoggingOpenglLogLevelNone": "Ничего",
-  "SettingsTabLoggingOpenglLogLevelError": "Ошибка",
-  "SettingsTabLoggingOpenglLogLevelPerformance": "Замедления",
-  "SettingsTabLoggingOpenglLogLevelAll": "Всё",
+  "SettingsTabLoggingGraphicsBackendLogLevelNone": "Ничего",
+  "SettingsTabLoggingGraphicsBackendLogLevelError": "Ошибка",
+  "SettingsTabLoggingGraphicsBackendLogLevelPerformance": "Замедления",
+  "SettingsTabLoggingGraphicsBackendLogLevelAll": "Всё",
   "SettingsTabLoggingEnableDebugLogs": "Включить журналы отладки",
   "SettingsTabInput": "Управление",
   "SettingsTabInputEnableDockedMode": "Включить режим закрепления",

Ryujinx.Ava/Assets/Locales/tr_TR.json

@@ -157,11 +157,10 @@
   "SettingsTabLoggingEnableFsAccessLogs": "Fs Erişim Loglarını Etkinleştir",
   "SettingsTabLoggingFsGlobalAccessLogMode": "Fs Evrensel Erişim Log Modu:",
   "SettingsTabLoggingDeveloperOptions": "Geliştirici Seçenekleri (UYARI: Performansı düşürecektir)",
-  "SettingsTabLoggingOpenglLogLevel": "OpenGL Log Seviyesi:",
-  "SettingsTabLoggingOpenglLogLevelNone": "Hiç",
-  "SettingsTabLoggingOpenglLogLevelError": "Hata",
-  "SettingsTabLoggingOpenglLogLevelPerformance": "Yavaşlamalar",
-  "SettingsTabLoggingOpenglLogLevelAll": "Her Şey",
+  "SettingsTabLoggingGraphicsBackendLogLevelNone": "Hiç",
+  "SettingsTabLoggingGraphicsBackendLogLevelError": "Hata",
+  "SettingsTabLoggingGraphicsBackendLogLevelPerformance": "Yavaşlamalar",
+  "SettingsTabLoggingGraphicsBackendLogLevelAll": "Her Şey",
   "SettingsTabLoggingEnableDebugLogs": "Hata Ayıklama Loglarını Etkinleştir",
   "SettingsTabInput": "Giriş Yöntemi",
   "SettingsTabInputEnableDockedMode": "Docked Modunu Etkinleştir",

Ryujinx.Ava/Assets/Locales/zh_CN.json

@@ -157,11 +157,10 @@
   "SettingsTabLoggingEnableFsAccessLogs": "记录文件访问",
   "SettingsTabLoggingFsGlobalAccessLogMode": "记录全局文件访问模式:",
   "SettingsTabLoggingDeveloperOptions": "开发者选项 (警告: 会降低性能)",
-  "SettingsTabLoggingOpenglLogLevel": "OpenGL日志级别:",
-  "SettingsTabLoggingOpenglLogLevelNone": "无",
-  "SettingsTabLoggingOpenglLogLevelError": "错误",
-  "SettingsTabLoggingOpenglLogLevelPerformance": "减速",
-  "SettingsTabLoggingOpenglLogLevelAll": "全部",
+  "SettingsTabLoggingGraphicsBackendLogLevelNone": "无",
+  "SettingsTabLoggingGraphicsBackendLogLevelError": "错误",
+  "SettingsTabLoggingGraphicsBackendLogLevelPerformance": "减速",
+  "SettingsTabLoggingGraphicsBackendLogLevelAll": "全部",
   "SettingsTabLoggingEnableDebugLogs": "启用调试日志",
   "SettingsTabInput": "输入",
   "SettingsTabInputEnableDockedMode": "主机模式",

Ryujinx.Ava/Assets/Locales/zh_TW.json

@@ -157,11 +157,10 @@
   "SettingsTabLoggingEnableFsAccessLogs": "記錄檔案存取",
   "SettingsTabLoggingFsGlobalAccessLogMode": "記錄全域檔案存取模式:",
   "SettingsTabLoggingDeveloperOptions": "開發者選項 (警告: 會降低效能)",
-  "SettingsTabLoggingOpenglLogLevel": "OpenGL 日誌級別:",
-  "SettingsTabLoggingOpenglLogLevelNone": "無",
-  "SettingsTabLoggingOpenglLogLevelError": "錯誤",
-  "SettingsTabLoggingOpenglLogLevelPerformance": "減速",
-  "SettingsTabLoggingOpenglLogLevelAll": "全部",
+  "SettingsTabLoggingGraphicsBackendLogLevelNone": "無",
+  "SettingsTabLoggingGraphicsBackendLogLevelError": "錯誤",
+  "SettingsTabLoggingGraphicsBackendLogLevelPerformance": "減速",
+  "SettingsTabLoggingGraphicsBackendLogLevelAll": "全部",
   "SettingsTabLoggingEnableDebugLogs": "啟用除錯日誌",
   "SettingsTabInput": "輸入",
   "SettingsTabInputEnableDockedMode": "Docked 模式",

Ryujinx.Ava/Helper/MetalHelper.cs

@@ -0,0 +1,127 @@
+using System;
+using System.Runtime.Versioning;
+using System.Runtime.InteropServices;
+using Avalonia;
+
+namespace Ryujinx.Ava.Ui.Helper
+{
+    public delegate void UpdateBoundsCallbackDelegate(Rect rect);
+
+    [SupportedOSPlatform("macos")]
+    static class MetalHelper
+    {
+        private const string LibObjCImport = "/usr/lib/libobjc.A.dylib";
+
+        private struct Selector
+        {
+            public readonly IntPtr NativePtr;
+
+            public unsafe Selector(string value)
+            {
+                int size = System.Text.Encoding.UTF8.GetMaxByteCount(value.Length);
+                byte* data = stackalloc byte[size];
+
+                fixed (char* pValue = value)
+                {
+                    System.Text.Encoding.UTF8.GetBytes(pValue, value.Length, data, size);
+                }
+
+                NativePtr = sel_registerName(data);
+            }
+
+            public static implicit operator Selector(string value) => new Selector(value);
+        }
+
+        private static unsafe IntPtr GetClass(string value)
+        {
+            int size = System.Text.Encoding.UTF8.GetMaxByteCount(value.Length);
+            byte* data = stackalloc byte[size];
+
+            fixed (char* pValue = value)
+            {
+                System.Text.Encoding.UTF8.GetBytes(pValue, value.Length, data, size);
+            }
+
+            return objc_getClass(data);
+        }
+
+        private struct NSPoint
+        {
+            public double X;
+            public double Y;
+
+            public NSPoint(double x, double y)
+            {
+                X = x;
+                Y = y;
+            }
+        }
+
+        private struct NSRect
+        {
+            public NSPoint Pos;
+            public NSPoint Size;
+
+            public NSRect(double x, double y, double width, double height)
+            {
+                Pos = new NSPoint(x, y);
+                Size = new NSPoint(width, height);
+            }
+        }
+
+        public static IntPtr GetMetalLayer(out IntPtr nsView, out UpdateBoundsCallbackDelegate updateBounds)
+        {
+            // Create a new CAMetalLayer.
+            IntPtr layerClass = GetClass("CAMetalLayer");
+            IntPtr metalLayer = IntPtr_objc_msgSend(layerClass, "alloc");
+            objc_msgSend(metalLayer, "init");
+
+            // Create a child NSView to render into.
+            IntPtr nsViewClass = GetClass("NSView");
+            IntPtr child = IntPtr_objc_msgSend(nsViewClass, "alloc");
+            objc_msgSend(child, "init", new NSRect(0, 0, 0, 0));
+
+            // Make its renderer our metal layer.
+            objc_msgSend(child, "setWantsLayer:", (byte)1);
+            objc_msgSend(child, "setLayer:", metalLayer);
+            objc_msgSend(metalLayer, "setContentsScale:", Program.DesktopScaleFactor);
+
+            // Ensure the scale factor is up to date.
+            updateBounds = (Rect rect) => {
+                objc_msgSend(metalLayer, "setContentsScale:", Program.DesktopScaleFactor);
+            };
+
+            nsView = child;
+            return metalLayer;
+        }
+
+        public static void DestroyMetalLayer(IntPtr nsView, IntPtr metalLayer)
+        {
+            // TODO
+        }
+
+        [DllImport(LibObjCImport)]
+        private static unsafe extern IntPtr sel_registerName(byte* data);
+
+        [DllImport(LibObjCImport)]
+        private static unsafe extern IntPtr objc_getClass(byte* data);
+
+        [DllImport(LibObjCImport)]
+        private static extern void objc_msgSend(IntPtr receiver, Selector selector);
+
+        [DllImport(LibObjCImport)]
+        private static extern void objc_msgSend(IntPtr receiver, Selector selector, byte value);
+
+        [DllImport(LibObjCImport)]
+        private static extern void objc_msgSend(IntPtr receiver, Selector selector, IntPtr value);
+
+        [DllImport(LibObjCImport)]
+        private static extern void objc_msgSend(IntPtr receiver, Selector selector, NSRect point);
+
+        [DllImport(LibObjCImport)]
+        private static extern void objc_msgSend(IntPtr receiver, Selector selector, double value);
+
+        [DllImport(LibObjCImport, EntryPoint = "objc_msgSend")]
+        private static extern IntPtr IntPtr_objc_msgSend(IntPtr receiver, Selector selector);
+    }
+}

Ryujinx.Ava/Input/AvaloniaKeyboard.cs

@@ -4,7 +4,6 @@ using Ryujinx.Input;
 using System;
 using System.Collections.Generic;
 using System.Numerics;
-
 using ConfigKey = Ryujinx.Common.Configuration.Hid.Key;
 using Key = Ryujinx.Input.Key;
 
@@ -14,30 +13,37 @@ namespace Ryujinx.Ava.Input
     {
         private readonly List<ButtonMappingEntry> _buttonsUserMapping;
         private readonly AvaloniaKeyboardDriver   _driver;
-
-        private readonly object _userMappingLock = new();
-
         private StandardKeyboardInputConfig       _configuration;
 
-        private bool HasConfiguration => _configuration != null;
+        private readonly object _userMappingLock = new();
 
         public string Id   { get; }
         public string Name { get; }
 
         public bool                IsConnected => true;
-
         public GamepadFeaturesFlag Features    => GamepadFeaturesFlag.None;
 
+        private class ButtonMappingEntry
+        {
+            public readonly Key                  From;
+            public readonly GamepadButtonInputId To;
+
+            public ButtonMappingEntry(GamepadButtonInputId to, Key from)
+            {
+                To   = to;
+                From = from;
+            }
+        }
+
         public AvaloniaKeyboard(AvaloniaKeyboardDriver driver, string id, string name)
         {
+            _buttonsUserMapping = new List<ButtonMappingEntry>();
+
             _driver = driver;
             Id      = id;
             Name    = name;
-            _buttonsUserMapping = new List<ButtonMappingEntry>();
         }
 
-        public void Dispose() { }
-
         public KeyboardStateSnapshot GetKeyboardStateSnapshot()
         {
             return IKeyboard.GetStateSnapshot(this);
@@ -50,7 +56,7 @@ namespace Ryujinx.Ava.Input
 
             lock (_userMappingLock)
             {
-                if (!HasConfiguration)
+                if (_configuration == null)
                 {
                     return result;
                 }
@@ -62,7 +68,7 @@ namespace Ryujinx.Ava.Input
                         continue;
                     }
 
-                    // Do not touch state of the button already pressed
+                    // NOTE: Do not touch state of the button already pressed.
                     if (!result.IsPressed(entry.To))
                     {
                         result.SetPressed(entry.To, rawState.IsPressed(entry.From));
@@ -114,7 +120,7 @@ namespace Ryujinx.Ava.Input
 
                 _buttonsUserMapping.Clear();
 
-                // Left joycon
+                // Left JoyCon
                 _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.LeftStick,           (Key)_configuration.LeftJoyconStick.StickButton));
                 _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.DpadUp,              (Key)_configuration.LeftJoycon.DpadUp));
                 _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.DpadDown,            (Key)_configuration.LeftJoycon.DpadDown));
@@ -126,7 +132,7 @@ namespace Ryujinx.Ava.Input
                 _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.SingleRightTrigger0, (Key)_configuration.LeftJoycon.ButtonSr));
                 _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.SingleLeftTrigger0,  (Key)_configuration.LeftJoycon.ButtonSl));
 
-                // Finally right joycon
+                // Right JoyCon
                 _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.RightStick,          (Key)_configuration.RightJoyconStick.StickButton));
                 _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.A,                   (Key)_configuration.RightJoycon.ButtonA));
                 _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.B,                   (Key)_configuration.RightJoycon.ButtonB));
@@ -190,16 +196,6 @@ namespace Ryujinx.Ava.Input
             _driver?.ResetKeys();
         }
 
-        private class ButtonMappingEntry
-        {
-            public readonly Key From;
-            public readonly GamepadButtonInputId To;
-
-            public ButtonMappingEntry(GamepadButtonInputId to, Key from)
-            {
-                To = to;
-                From = from;
-            }
-        }
+        public void Dispose() { }
     }
 }

Ryujinx.Ava/Input/AvaloniaKeyboardDriver.cs

@@ -4,7 +4,6 @@ using Ryujinx.Ava.Common.Locale;
 using Ryujinx.Input;
 using System;
 using System.Collections.Generic;
-
 using AvaKey = Avalonia.Input.Key;
 using Key = Ryujinx.Input.Key;
 
@@ -20,8 +19,7 @@ namespace Ryujinx.Ava.Input
         public event EventHandler<KeyEventArgs> KeyRelease;
         public event EventHandler<string>       TextInput;
 
-        public string DriverName => "Avalonia";
-
+        public string               DriverName  => "AvaloniaKeyboardDriver";
         public ReadOnlySpan<string> GamepadsIds => _keyboardIdentifers;
 
         public AvaloniaKeyboardDriver(Control control)
@@ -51,11 +49,6 @@ namespace Ryujinx.Ava.Input
             remove { }
         }
 
-        public void Dispose()
-        {
-            Dispose(true);
-        }
-
         public IGamepad GetGamepad(string id)
         {
             if (!_keyboardIdentifers[0].Equals(id))
@@ -77,8 +70,6 @@ namespace Ryujinx.Ava.Input
 
         protected void OnKeyPress(object sender, KeyEventArgs args)
         {
-            AvaKey key = args.Key;
-
             _pressedKeys.Add(args.Key);
 
             KeyPressed?.Invoke(this, args);
@@ -98,7 +89,7 @@ namespace Ryujinx.Ava.Input
                 return false;
             }
 
-            AvaloniaMappingHelper.TryGetAvaKey(key, out var nativeKey);
+            AvaloniaKeyboardMappingHelper.TryGetAvaKey(key, out var nativeKey);
 
             return _pressedKeys.Contains(nativeKey);
         }
@@ -107,5 +98,10 @@ namespace Ryujinx.Ava.Input
         {
             _pressedKeys.Clear();
         }
+
+        public void Dispose()
+        {
+            Dispose(true);
+        }
     }
 }

Ryujinx.Ava/Input/AvaloniaKeyboardMappingHelper.cs

@@ -5,7 +5,7 @@ using AvaKey = Avalonia.Input.Key;
 
 namespace Ryujinx.Ava.Input
 {
-    internal static class AvaloniaMappingHelper
+    internal static class AvaloniaKeyboardMappingHelper
     {
         private static readonly AvaKey[] _keyMapping = new AvaKey[(int)Key.Count]
         {
@@ -149,11 +149,11 @@ namespace Ryujinx.Ava.Input
 
         private static readonly Dictionary<AvaKey, Key> _avaKeyMapping;
 
-        static AvaloniaMappingHelper()
+        static AvaloniaKeyboardMappingHelper()
         {
             var inputKeys = Enum.GetValues(typeof(Key));
 
-            // Avalonia.Input.Key is not contiguous and quite large, so use a dictionary instead of an array.
+            // NOTE: Avalonia.Input.Key is not contiguous and quite large, so use a dictionary instead of an array.
             _avaKeyMapping = new Dictionary<AvaKey, Key>();
 
             foreach (var key in inputKeys)
@@ -167,15 +167,13 @@ namespace Ryujinx.Ava.Input
 
         public static bool TryGetAvaKey(Key key, out AvaKey avaKey)
         {
-            var keyExist = (int)key < _keyMapping.Length;
+            avaKey = AvaKey.None;
+
+            bool keyExist = (int)key < _keyMapping.Length;
             if (keyExist)
             {
                 avaKey = _keyMapping[(int)key];
             }
-            else
-            {
-                avaKey = AvaKey.None;
-            }
 
             return keyExist;
         }

Ryujinx.Ava/Input/AvaloniaMouse.cs

@@ -10,14 +10,11 @@ namespace Ryujinx.Ava.Input
     {
         private AvaloniaMouseDriver _driver;
 
-        public GamepadFeaturesFlag Features => throw new NotImplementedException();
-
         public string Id   => "0";
-
         public string Name => "AvaloniaMouse";
 
         public bool                IsConnected => true;
-
+        public GamepadFeaturesFlag Features    => throw new NotImplementedException();
         public bool[]              Buttons     => _driver.PressedButtons;
 
         public AvaloniaMouse(AvaloniaMouseDriver driver)

Ryujinx.Ava/Input/AvaloniaMouseDriver.cs

@@ -17,10 +17,12 @@ namespace Ryujinx.Ava.Input
         private readonly Window _window;
 
         public bool[]  PressedButtons  { get; }
-
         public Vector2 CurrentPosition { get; private set; }
         public Vector2 Scroll          { get; private set; }
 
+        public string               DriverName  => "AvaloniaMouseDriver";
+        public ReadOnlySpan<string> GamepadsIds => new[] { "0" };
+
         public AvaloniaMouseDriver(Window window, Control parent)
         {
             _widget = parent;
@@ -39,7 +41,20 @@ namespace Ryujinx.Ava.Input
             PressedButtons = new bool[(int)MouseButton.Count];
 
             _size = new Size((int)parent.Bounds.Width, (int)parent.Bounds.Height);
-            parent.GetObservable(Control.BoundsProperty).Subscribe(Resized);
+
+            parent.GetObservable(Visual.BoundsProperty).Subscribe(Resized);
+        }
+
+        public event Action<string> OnGamepadConnected
+        {
+            add    { }
+            remove { }
+        }
+
+        public event Action<string> OnGamepadDisconnected
+        {
+            add    { }
+            remove { }
         }
 
         private void Resized(Rect rect)
@@ -59,14 +74,12 @@ namespace Ryujinx.Ava.Input
 
         private void Parent_PointerPressEvent(object o, PointerPressedEventArgs args)
         {
-            var pointerProperties = args.GetCurrentPoint(_widget).Properties;
-
-            PressedButtons[(int)pointerProperties.PointerUpdateKind] = true;
+            PressedButtons[(int)args.GetCurrentPoint(_widget).Properties.PointerUpdateKind] = true;
         }
 
         private void Parent_PointerMovedEvent(object o, PointerEventArgs args)
         {
-            var position = args.GetPosition(_widget);
+            Point position = args.GetPosition(_widget);
 
             CurrentPosition = new Vector2((float)position.X, (float)position.Y);
         }
@@ -96,22 +109,6 @@ namespace Ryujinx.Ava.Input
             return _size;
         }
 
-        public string DriverName => "Avalonia";
-
-        public event Action<string> OnGamepadConnected
-        {
-            add { }
-            remove { }
-        }
-
-        public event Action<string> OnGamepadDisconnected
-        {
-            add { }
-            remove { }
-        }
-
-        public ReadOnlySpan<string> GamepadsIds => new[] { "0" };
-
         public IGamepad GetGamepad(string id)
         {
             return new AvaloniaMouse(this);

Ryujinx.Ava/Program.cs

@@ -23,6 +23,7 @@ namespace Ryujinx.Ava
     internal class Program
     {
         public static double WindowScaleFactor  { get; set; }
+        public static double DesktopScaleFactor { get; set; } = 1.0;
         public static string Version            { get; private set; }
         public static string ConfigurationPath  { get; private set; }
         public static bool   PreviewerDetached {  get; private set; }

Ryujinx.Ava/Ryujinx.Ava.csproj

@@ -28,11 +28,13 @@
     <PackageReference Include="jp2masa.Avalonia.Flexbox" Version="0.2.0" />
     <PackageReference Include="DynamicData" Version="7.12.8" />
     <PackageReference Include="FluentAvaloniaUI" Version="1.4.5" />
-    <PackageReference Include="XamlNameReferenceGenerator" Version="1.4.2" />
+    <PackageReference Include="XamlNameReferenceGenerator" Version="1.5.1" />
 
     <PackageReference Include="OpenTK.Core" Version="4.7.5" />
-    <PackageReference Include="Ryujinx.Audio.OpenAL.Dependencies" Version="1.21.0.1" Condition="'$(RuntimeIdentifier)' != 'linux-x64' AND '$(RuntimeIdentifier)' != 'osx-x64'" />
-    <PackageReference Include="Ryujinx.Graphics.Nvdec.Dependencies" Version="5.0.1-build10" Condition="'$(RuntimeIdentifier)' != 'linux-x64' AND '$(RuntimeIdentifier)' != 'osx-x64'" />
+    <PackageReference Include="Ryujinx.Audio.OpenAL.Dependencies" Version="1.21.0.1" Condition="'$(RuntimeIdentifier)' != 'linux-x64' AND '$(RuntimeIdentifier)' != 'osx-x64' AND '$(RuntimeIdentifier)' != 'osx-arm64'" />
+    <PackageReference Include="Ryujinx.Graphics.Nvdec.Dependencies" Version="5.0.1-build10" Condition="'$(RuntimeIdentifier)' != 'linux-x64' AND '$(RuntimeIdentifier)' != 'osx-x64' AND '$(RuntimeIdentifier)' != 'osx-arm64'" />
+    <PackageReference Include="Ryujinx.Graphics.Nvdec.Dependencies.osx" Version="5.0.1" Condition="'$(RuntimeIdentifier)' != 'linux-x64' AND '$(RuntimeIdentifier)' != 'win10-x64'" />
+    <PackageReference Include="Ryujinx.Graphics.Vulkan.Dependencies.MoltenVK" Version="1.2.0" Condition="'$(RuntimeIdentifier)' != 'linux-x64' AND '$(RuntimeIdentifier)' != 'win10-x64'" />
     <PackageReference Include="Silk.NET.Vulkan" Version="2.16.0" />
     <PackageReference Include="Silk.NET.Vulkan.Extensions.EXT" Version="2.16.0" />
     <PackageReference Include="Silk.NET.Vulkan.Extensions.KHR" Version="2.16.0" />
@@ -57,14 +59,18 @@
   </ItemGroup>
 
   <ItemGroup>
-    <ContentWithTargetPath Include="..\distribution\windows\alsoft.ini" Condition="'$(RuntimeIdentifier)' != 'linux-x64' AND '$(RuntimeIdentifier)' != 'osx-x64'">
+    <Content Include="..\distribution\windows\alsoft.ini" Condition="'$(RuntimeIdentifier)' != 'linux-x64' AND '$(RuntimeIdentifier)' != 'osx-x64'">
       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
       <TargetPath>alsoft.ini</TargetPath>
-    </ContentWithTargetPath>
-    <ContentWithTargetPath Include="..\distribution\legal\THIRDPARTY.md">
+    </Content>
+    <Content Include="..\distribution\legal\THIRDPARTY.md">
       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
       <TargetPath>THIRDPARTY.md</TargetPath>
-    </ContentWithTargetPath>
+    </Content>
+    <Content Include="..\LICENSE.txt">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+      <TargetPath>LICENSE.txt</TargetPath>
+    </Content>
   </ItemGroup>
 
   <ItemGroup>

Ryujinx.Ava/Ui/Applet/AvaloniaDynamicTextInputHandler.cs

@@ -68,7 +68,7 @@ namespace Ryujinx.Ava.Ui.Applet
 
         private void AvaloniaDynamicTextInputHandler_KeyRelease(object sender, Avalonia.Input.KeyEventArgs e)
         {
-            var key = (HidKey)AvaloniaMappingHelper.ToInputKey(e.Key);
+            var key = (HidKey)AvaloniaKeyboardMappingHelper.ToInputKey(e.Key);
 
             if (!(KeyReleasedEvent?.Invoke(key)).GetValueOrDefault(true))
             {
@@ -88,7 +88,7 @@ namespace Ryujinx.Ava.Ui.Applet
 
         private void AvaloniaDynamicTextInputHandler_KeyPressed(object sender, KeyEventArgs e)
         {
-            var key = (HidKey)AvaloniaMappingHelper.ToInputKey(e.Key);
+            var key = (HidKey)AvaloniaKeyboardMappingHelper.ToInputKey(e.Key);
 
             if (!(KeyPressedEvent?.Invoke(key)).GetValueOrDefault(true))
             {

Ryujinx.Ava/Ui/Controls/EmbeddedWindow.cs

@@ -2,11 +2,10 @@ using Avalonia;
 using Avalonia.Controls;
 using Avalonia.Input;
 using Avalonia.Platform;
+using Ryujinx.Ava.Ui.Helper;
 using SPB.Graphics;
 using SPB.Platform;
 using SPB.Platform.GLX;
-using SPB.Platform.X11;
-using SPB.Windowing;
 using System;
 using System.Runtime.InteropServices;
 using System.Runtime.Versioning;
@@ -23,6 +22,10 @@ namespace Ryujinx.Ava.Ui.Controls
         protected GLXWindow X11Window { get; set; }
         protected IntPtr WindowHandle { get; set; }
         protected IntPtr X11Display { get; set; }
+        protected IntPtr NsView { get; set; }
+        protected IntPtr MetalLayer { get; set; }
+
+        private UpdateBoundsCallbackDelegate _updateBoundsCallback;
 
         public event EventHandler<IntPtr> WindowCreated;
         public event EventHandler<Size> SizeChanged;
@@ -58,6 +61,7 @@ namespace Ryujinx.Ava.Ui.Controls
         private void StateChanged(Rect rect)
         {
             SizeChanged?.Invoke(this, rect.Size);
+            _updateBoundsCallback?.Invoke(rect);
         }
 
         protected override IPlatformHandle CreateNativeControlCore(IPlatformHandle parent)
@@ -70,6 +74,11 @@ namespace Ryujinx.Ava.Ui.Controls
             {
                 return CreateWin32(parent);
             }
+            else if (OperatingSystem.IsMacOS())
+            {
+                return CreateMacOs(parent);
+            }
+
             return base.CreateNativeControlCore(parent);
         }
 
@@ -85,6 +94,10 @@ namespace Ryujinx.Ava.Ui.Controls
             {
                 DestroyWin32(control);
             }
+            else if (OperatingSystem.IsMacOS())
+            {
+                DestroyMacOS();
+            }
             else
             {
                 base.DestroyNativeControlCore(control);
@@ -187,6 +200,16 @@ namespace Ryujinx.Ava.Ui.Controls
             return DefWindowProc(hWnd, msg, (IntPtr)wParam, (IntPtr)lParam);
         }
 
+        [SupportedOSPlatform("macos")]
+        IPlatformHandle CreateMacOs(IPlatformHandle parent)
+        {
+            MetalLayer = MetalHelper.GetMetalLayer(out IntPtr nsView, out _updateBoundsCallback);
+
+            NsView = nsView;
+
+            return new PlatformHandle(nsView, "NSView");
+        }
+
         void DestroyLinux()
         {
             X11Window?.Dispose();
@@ -198,5 +221,11 @@ namespace Ryujinx.Ava.Ui.Controls
             DestroyWindow(handle.Handle);
             UnregisterClass(_className, GetModuleHandle(null));
         }
+
+        [SupportedOSPlatform("macos")]
+        void DestroyMacOS()
+        {
+            MetalHelper.DestroyMetalLayer(NsView, MetalLayer);
+        }
     }
 }

Ryujinx.Ava/Ui/Controls/VulkanEmbeddedWindow.cs

@@ -3,6 +3,7 @@ using Ryujinx.Ava.Ui.Controls;
 using Silk.NET.Vulkan;
 using SPB.Graphics.Vulkan;
 using SPB.Platform.GLX;
+using SPB.Platform.Metal;
 using SPB.Platform.Win32;
 using SPB.Platform.X11;
 using SPB.Windowing;
@@ -37,6 +38,10 @@ namespace Ryujinx.Ava.Ui
             {
                 _window = new SimpleX11Window(new NativeHandle(X11Display), new NativeHandle(WindowHandle));
             }
+            else if (OperatingSystem.IsMacOS())
+            {
+                _window = new SimpleMetalWindow(new NativeHandle(NsView), new NativeHandle(MetalLayer));
+            }
             else
             {
                 throw new PlatformNotSupportedException();

Ryujinx.Ava/Ui/Models/FileSizeSortComparer.cs

@@ -1,45 +0,0 @@
-using Ryujinx.Ui.App.Common;
-using System.Collections;
-
-namespace Ryujinx.Ava.Ui.Models
-{
-    internal class FileSizeSortComparer : IComparer
-    {
-        public int Compare(object x, object y)
-        {
-            string aValue = (x as ApplicationData).TimePlayed;
-            string bValue = (y as ApplicationData).TimePlayed;
-
-            if (aValue[^3..] == "GiB")
-            {
-                aValue = (float.Parse(aValue[0..^3]) * 1024).ToString();
-            }
-            else
-            {
-                aValue = aValue[0..^3];
-            }
-
-            if (bValue[^3..] == "GiB")
-            {
-                bValue = (float.Parse(bValue[0..^3]) * 1024).ToString();
-            }
-            else
-            {
-                bValue = bValue[0..^3];
-            }
-
-            if (float.Parse(aValue) > float.Parse(bValue))
-            {
-                return -1;
-            }
-            else if (float.Parse(bValue) > float.Parse(aValue))
-            {
-                return 1;
-            }
-            else
-            {
-                return 0;
-            }
-        }
-    }
-}

Ryujinx.Ava/Ui/Models/Generic/FileSizeSortComparer.cs

@@ -1,50 +0,0 @@
-using Ryujinx.Ui.App.Common;
-using System.Collections.Generic;
-
-namespace Ryujinx.Ava.Ui.Models.Generic
-{
-    internal class FileSizeSortComparer : IComparer<ApplicationData>
-    {
-        public FileSizeSortComparer() { }
-        public FileSizeSortComparer(bool isAscending) { _order = isAscending ? 1 : -1; }
-
-        private int _order;
-
-        public int Compare(ApplicationData x, ApplicationData y)
-        {
-            string aValue = x.FileSize;
-            string bValue = y.FileSize;
-
-            if (aValue[^3..] == "GiB")
-            {
-                aValue = (float.Parse(aValue[0..^3]) * 1024).ToString();
-            }
-            else
-            {
-                aValue = aValue[0..^3];
-            }
-
-            if (bValue[^3..] == "GiB")
-            {
-                bValue = (float.Parse(bValue[0..^3]) * 1024).ToString();
-            }
-            else
-            {
-                bValue = bValue[0..^3];
-            }
-
-            if (float.Parse(aValue) > float.Parse(bValue))
-            {
-                return -1 * _order;
-            }
-            else if (float.Parse(bValue) > float.Parse(aValue))
-            {
-                return 1 * _order;
-            }
-            else
-            {
-                return 0;
-            }
-        }
-    }
-}

Ryujinx.Ava/Ui/Models/Generic/TimePlayedSortComparer.cs

@@ -1,66 +0,0 @@
-using Ryujinx.Ui.App.Common;
-using System.Collections.Generic;
-
-namespace Ryujinx.Ava.Ui.Models.Generic
-{
-    internal class TimePlayedSortComparer : IComparer<ApplicationData>
-    {
-        public TimePlayedSortComparer() { }
-        public TimePlayedSortComparer(bool isAscending) { _order = isAscending ? 1 : -1; }
-
-        private int _order;
-
-        public int Compare(ApplicationData x, ApplicationData y)
-        {
-            string aValue = x.TimePlayed;
-            string bValue = y.TimePlayed;
-
-            if (aValue.Length > 4 && aValue[^4..] == "mins")
-            {
-                aValue = (float.Parse(aValue[0..^5]) * 60).ToString();
-            }
-            else if (aValue.Length > 3 && aValue[^3..] == "hrs")
-            {
-                aValue = (float.Parse(aValue[0..^4]) * 3600).ToString();
-            }
-            else if (aValue.Length > 4 && aValue[^4..] == "days")
-            {
-                aValue = (float.Parse(aValue[0..^5]) * 86400).ToString();
-            }
-            else
-            {
-                aValue = aValue[0..^1];
-            }
-
-            if (bValue.Length > 4 && bValue[^4..] == "mins")
-            {
-                bValue = (float.Parse(bValue[0..^5]) * 60).ToString();
-            }
-            else if (bValue.Length > 3 && bValue[^3..] == "hrs")
-            {
-                bValue = (float.Parse(bValue[0..^4]) * 3600).ToString();
-            }
-            else if (bValue.Length > 4 && bValue[^4..] == "days")
-            {
-                bValue = (float.Parse(bValue[0..^5]) * 86400).ToString();
-            }
-            else
-            {
-                bValue = bValue[0..^1];
-            }
-
-            if (float.Parse(aValue) > float.Parse(bValue))
-            {
-                return -1 * _order;
-            }
-            else if (float.Parse(bValue) > float.Parse(aValue))
-            {
-                return 1 * _order;
-            }
-            else
-            {
-                return 0;
-            }
-        }
-    }
-}

Ryujinx.Ava/Ui/Models/LastPlayedSortComparer.cs

@@ -1,27 +0,0 @@
-using Ryujinx.Ui.App.Common;
-using System;
-using System.Collections;
-
-namespace Ryujinx.Ava.Ui.Models
-{
-    internal class LastPlayedSortComparer : IComparer
-    {
-        public int Compare(object x, object y)
-        {
-            string aValue = (x as ApplicationData).LastPlayed;
-            string bValue = (y as ApplicationData).LastPlayed;
-
-            if (aValue == "Never")
-            {
-                aValue = DateTime.UnixEpoch.ToString();
-            }
-
-            if (bValue == "Never")
-            {
-                bValue = DateTime.UnixEpoch.ToString();
-            }
-
-            return DateTime.Compare(DateTime.Parse(bValue), DateTime.Parse(aValue));
-        }
-    }
-}

Ryujinx.Ava/Ui/Models/TimePlayedSortComparer.cs

@@ -1,61 +0,0 @@
-using Ryujinx.Ui.App.Common;
-using System.Collections;
-
-namespace Ryujinx.Ava.Ui.Models
-{
-    internal class TimePlayedSortComparer : IComparer
-    {
-        public int Compare(object x, object y)
-        {
-            string aValue = (x as ApplicationData).TimePlayed;
-            string bValue = (y as ApplicationData).TimePlayed;
-
-            if (aValue.Length > 4 && aValue[^4..] == "mins")
-            {
-                aValue = (float.Parse(aValue[0..^5]) * 60).ToString();
-            }
-            else if (aValue.Length > 3 && aValue[^3..] == "hrs")
-            {
-                aValue = (float.Parse(aValue[0..^4]) * 3600).ToString();
-            }
-            else if (aValue.Length > 4 && aValue[^4..] == "days")
-            {
-                aValue = (float.Parse(aValue[0..^5]) * 86400).ToString();
-            }
-            else
-            {
-                aValue = aValue[0..^1];
-            }
-
-            if (bValue.Length > 4 && bValue[^4..] == "mins")
-            {
-                bValue = (float.Parse(bValue[0..^5]) * 60).ToString();
-            }
-            else if (bValue.Length > 3 && bValue[^3..] == "hrs")
-            {
-                bValue = (float.Parse(bValue[0..^4]) * 3600).ToString();
-            }
-            else if (bValue.Length > 4 && bValue[^4..] == "days")
-            {
-                bValue = (float.Parse(bValue[0..^5]) * 86400).ToString();
-            }
-            else
-            {
-                bValue = bValue[0..^1];
-            }
-
-            if (float.Parse(aValue) > float.Parse(bValue))
-            {
-                return -1;
-            }
-            else if (float.Parse(bValue) > float.Parse(aValue))
-            {
-                return 1;
-            }
-            else
-            {
-                return 0;
-            }
-        }
-    }
-}

Ryujinx.Ava/Ui/ViewModels/MainWindowViewModel.cs

@@ -502,8 +502,10 @@ namespace Ryujinx.Ava.Ui.ViewModels
             return SortMode switch
             {
                 ApplicationSort.LastPlayed      => new Models.Generic.LastPlayedSortComparer(IsAscending),
-                ApplicationSort.FileSize        => new Models.Generic.FileSizeSortComparer(IsAscending),
-                ApplicationSort.TotalTimePlayed => new Models.Generic.TimePlayedSortComparer(IsAscending),
+                ApplicationSort.FileSize        => IsAscending  ? SortExpressionComparer<ApplicationData>.Ascending(app  => app.FileSizeBytes)
+                                                                : SortExpressionComparer<ApplicationData>.Descending(app => app.FileSizeBytes),
+                ApplicationSort.TotalTimePlayed => IsAscending  ? SortExpressionComparer<ApplicationData>.Ascending(app  => app.TimePlayedNum)
+                                                                : SortExpressionComparer<ApplicationData>.Descending(app => app.TimePlayedNum),
                 ApplicationSort.Title           => IsAscending  ? SortExpressionComparer<ApplicationData>.Ascending(app  => app.TitleName)
                                                                 : SortExpressionComparer<ApplicationData>.Descending(app => app.TitleName),
                 ApplicationSort.Favorite        => !IsAscending ? SortExpressionComparer<ApplicationData>.Ascending(app  => app.Favorite)
@@ -881,17 +883,17 @@ namespace Ryujinx.Ava.Ui.ViewModels
 
         public void LoadConfigurableHotKeys()
         {
-            if (AvaloniaMappingHelper.TryGetAvaKey((Ryujinx.Input.Key)ConfigurationState.Instance.Hid.Hotkeys.Value.ShowUi, out var showUiKey))
+            if (AvaloniaKeyboardMappingHelper.TryGetAvaKey((Ryujinx.Input.Key)ConfigurationState.Instance.Hid.Hotkeys.Value.ShowUi, out var showUiKey))
             {
                 ShowUiKey = new KeyGesture(showUiKey, KeyModifiers.None);
             }
 
-            if (AvaloniaMappingHelper.TryGetAvaKey((Ryujinx.Input.Key)ConfigurationState.Instance.Hid.Hotkeys.Value.Screenshot, out var screenshotKey))
+            if (AvaloniaKeyboardMappingHelper.TryGetAvaKey((Ryujinx.Input.Key)ConfigurationState.Instance.Hid.Hotkeys.Value.Screenshot, out var screenshotKey))
             {
                 ScreenshotKey = new KeyGesture(screenshotKey, KeyModifiers.None);
             }
 
-            if (AvaloniaMappingHelper.TryGetAvaKey((Ryujinx.Input.Key)ConfigurationState.Instance.Hid.Hotkeys.Value.Pause, out var pauseKey))
+            if (AvaloniaKeyboardMappingHelper.TryGetAvaKey((Ryujinx.Input.Key)ConfigurationState.Instance.Hid.Hotkeys.Value.Pause, out var pauseKey))
             {
                 PauseKey = new KeyGesture(pauseKey, KeyModifiers.None);
             }

Ryujinx.Ava/Ui/ViewModels/SettingsViewModel.cs

@@ -108,6 +108,8 @@ namespace Ryujinx.Ava.Ui.ViewModels
             }
         }
 
+        public bool IsOpenGLAvailable => !OperatingSystem.IsMacOS();
+
         public bool DirectoryChanged
         {
             get => _directoryChanged;

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

@@ -154,6 +154,12 @@ namespace Ryujinx.Ava.Ui.Windows
             }
         }
 
+        protected override void HandleScalingChanged(double scale)
+        {
+            Program.DesktopScaleFactor = scale;
+            base.HandleScalingChanged(scale);
+        }
+
         public void Application_Opened(object sender, ApplicationOpenedEventArgs args)
         {
             if (args.Application != null)

Ryujinx.Ava/Ui/Windows/SettingsWindow.axaml

@@ -540,7 +540,7 @@
                                     <ComboBoxItem IsVisible="{Binding IsVulkanAvailable}">
                                         <TextBlock Text="Vulkan" />
                                     </ComboBoxItem>
-                                    <ComboBoxItem>
+                                    <ComboBoxItem IsEnabled="{Binding IsOpenGLAvailable}">
                                         <TextBlock Text="OpenGL" />
                                     </ComboBoxItem>
                                 </ComboBox>
@@ -876,7 +876,7 @@
                                 </StackPanel>
                                 <StackPanel Margin="0,10,0,0" Orientation="Horizontal">
                                     <TextBlock VerticalAlignment="Center"
-                                            Text="{locale:Locale SettingsTabLoggingOpenglLogLevel}"
+                                            Text="{locale:Locale SettingsTabLoggingGraphicsBackendLogLevel}"
                                             ToolTip.Tip="{locale:Locale OpenGlLogLevel}"
                                             Width="285" />
                                     <ComboBox SelectedIndex="{Binding OpenglDebugLevel}"
@@ -884,17 +884,17 @@
                                             HorizontalContentAlignment="Left"
                                             ToolTip.Tip="{locale:Locale OpenGlLogLevel}">
                                         <ComboBoxItem>
-                                            <TextBlock Text="{locale:Locale SettingsTabLoggingOpenglLogLevelNone}" />
+                                            <TextBlock Text="{locale:Locale SettingsTabLoggingGraphicsBackendLogLevelNone}" />
                                         </ComboBoxItem>
                                         <ComboBoxItem>
-                                            <TextBlock Text="{locale:Locale SettingsTabLoggingOpenglLogLevelError}" />
+                                            <TextBlock Text="{locale:Locale SettingsTabLoggingGraphicsBackendLogLevelError}" />
                                         </ComboBoxItem>
                                         <ComboBoxItem>
                                             <TextBlock
-                                                Text="{locale:Locale SettingsTabLoggingOpenglLogLevelPerformance}" />
+                                                Text="{locale:Locale SettingsTabLoggingGraphicsBackendLogLevelPerformance}" />
                                         </ComboBoxItem>
                                         <ComboBoxItem>
-                                            <TextBlock Text="{locale:Locale SettingsTabLoggingOpenglLogLevelAll}" />
+                                            <TextBlock Text="{locale:Locale SettingsTabLoggingGraphicsBackendLogLevelAll}" />
                                         </ComboBoxItem>
                                     </ComboBox>
                                 </StackPanel>

Ryujinx.Common/Configuration/AppDataManager.cs

@@ -45,7 +45,14 @@ namespace Ryujinx.Common.Configuration
 
         public static void Initialize(string baseDirPath)
         {
-            string userProfilePath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), DefaultBaseDir);
+            string appDataPath = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
+
+            if (appDataPath.Length == 0)
+            {
+                appDataPath = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
+            }
+
+            string userProfilePath = Path.Combine(appDataPath, DefaultBaseDir);
             string portablePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, DefaultPortableDir);
 
             if (Directory.Exists(portablePath))

Ryujinx.Common/Memory/PartialUnmaps/NativeReaderWriterLock.cs

@@ -8,7 +8,7 @@ namespace Ryujinx.Common.Memory.PartialUnmaps
     /// <summary>
     /// A simple implementation of a ReaderWriterLock which can be used from native code.
     /// </summary>
-    [StructLayout(LayoutKind.Sequential, Pack = 1)]
+    [StructLayout(LayoutKind.Sequential, Pack = 4)]
     public struct NativeReaderWriterLock
     {
         public int WriteLock;

Ryujinx.Common/Ryujinx.Common.csproj

@@ -7,7 +7,7 @@
 
   <ItemGroup>
     <PackageReference Include="MsgPack.Cli" Version="1.0.1" />
-    <PackageReference Include="System.Drawing.Common" Version="6.0.0" />
+    <PackageReference Include="System.Drawing.Common" Version="7.0.0" />
     <PackageReference Include="System.Management" Version="7.0.0" />
   </ItemGroup>
 

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 = 4011;
+        private const uint CodeGenVersion = 4028;
 
         private const string SharedTocFileName = "shared.toc";
         private const string SharedDataFileName = "shared.data";

Ryujinx.Graphics.Shader/Translation/GlobalMemory.cs

@@ -48,5 +48,10 @@ namespace Ryujinx.Graphics.Shader.Translation
                 _ => 0
             };
         }
+
+        public static int GetConstantUbeOffset(int slot)
+        {
+            return UbeBaseOffset + slot * StorageDescSize;
+        }
     }
 }

Ryujinx.Graphics.Shader/Translation/Optimizations/GlobalToStorage.cs

@@ -8,11 +8,14 @@ namespace Ryujinx.Graphics.Shader.Translation.Optimizations
 {
     static class GlobalToStorage
     {
-        public static void RunPass(BasicBlock block, ShaderConfig config, ref int sbUseMask)
+        public static void RunPass(BasicBlock block, ShaderConfig config, ref int sbUseMask, ref int ubeUseMask)
         {
             int sbStart = GetStorageBaseCbOffset(config.Stage);
             int sbEnd = sbStart + StorageDescsSize;
 
+            int ubeStart = UbeBaseOffset;
+            int ubeEnd = UbeBaseOffset + UbeDescsSize;
+
             for (LinkedListNode<INode> node = block.Operations.First; node != null; node = node.Next)
             {
                 for (int index = 0; index < node.Value.SourcesCount; index++)
@@ -25,6 +28,16 @@ namespace Ryujinx.Graphics.Shader.Translation.Optimizations
                     {
                         sbUseMask |= 1 << storageIndex;
                     }
+
+                    if (config.Stage == ShaderStage.Compute)
+                    {
+                        int constantIndex = GetStorageIndex(src, ubeStart, ubeEnd);
+
+                        if (constantIndex >= 0)
+                        {
+                            ubeUseMask |= 1 << constantIndex;
+                        }
+                    }
                 }
 
                 if (!(node.Value is Operation operation))
@@ -54,7 +67,7 @@ namespace Ryujinx.Graphics.Shader.Translation.Optimizations
                         // so NVN "emulates" more constant buffers using global memory access.
                         // Here we try to replace the global access back to a constant buffer
                         // load.
-                        storageIndex = SearchForStorageBase(block, source, UbeBaseOffset, UbeBaseOffset + UbeDescsSize);
+                        storageIndex = SearchForStorageBase(block, source, ubeStart, ubeStart + ubeEnd);
 
                         if (storageIndex >= 0)
                         {
@@ -64,7 +77,7 @@ namespace Ryujinx.Graphics.Shader.Translation.Optimizations
                 }
             }
 
-            config.SetAccessibleStorageBuffersMask(sbUseMask);
+            config.SetAccessibleBufferMasks(sbUseMask, ubeUseMask);
         }
 
         private static LinkedListNode<INode> ReplaceGlobalWithStorage(BasicBlock block, LinkedListNode<INode> node, ShaderConfig config, int storageIndex)

Ryujinx.Graphics.Shader/Translation/Optimizations/Optimizer.cs

@@ -12,16 +12,17 @@ namespace Ryujinx.Graphics.Shader.Translation.Optimizations
             RunOptimizationPasses(blocks);
 
             int sbUseMask = 0;
+            int ubeUseMask = 0;
 
             // Those passes are looking for specific patterns and only needs to run once.
             for (int blkIndex = 0; blkIndex < blocks.Length; blkIndex++)
             {
-                GlobalToStorage.RunPass(blocks[blkIndex], config, ref sbUseMask);
+                GlobalToStorage.RunPass(blocks[blkIndex], config, ref sbUseMask, ref ubeUseMask);
                 BindlessToIndexed.RunPass(blocks[blkIndex], config);
                 BindlessElimination.RunPass(blocks[blkIndex], config);
             }
 
-            config.SetAccessibleStorageBuffersMask(sbUseMask);
+            config.SetAccessibleBufferMasks(sbUseMask, ubeUseMask);
 
             // Run optimizations one last time to remove any code that is now optimizable after above passes.
             RunOptimizationPasses(blocks);

Ryujinx.Graphics.Shader/Translation/Rewriter.cs

@@ -1,3 +1,4 @@
+using Ryujinx.Graphics.Shader.Decoders;
 using Ryujinx.Graphics.Shader.IntermediateRepresentation;
 using System.Collections.Generic;
 using System.Diagnostics;
@@ -21,10 +22,11 @@ namespace Ryujinx.Graphics.Shader.Translation
             {
                 BasicBlock block = blocks[blkIndex];
 
-                for (LinkedListNode<INode> node = block.Operations.First; node != null; node = node.Next)
+                for (LinkedListNode<INode> node = block.Operations.First; node != null;)
                 {
                     if (node.Value is not Operation operation)
                     {
+                        node = node.Next;
                         continue;
                     }
 
@@ -43,10 +45,7 @@ namespace Ryujinx.Graphics.Shader.Translation
                         }
                     }
 
-                    if (UsesGlobalMemory(operation.Inst))
-                    {
-                        node = RewriteGlobalAccess(node, config);
-                    }
+                    LinkedListNode<INode> nextNode = node.Next;
 
                     if (operation is TextureOperation texOp)
                     {
@@ -59,7 +58,15 @@ namespace Ryujinx.Graphics.Shader.Translation
                                 node = InsertSnormNormalization(node, config);
                             }
                         }
+
+                        nextNode = node.Next;
                     }
+                    else if (UsesGlobalMemory(operation.Inst))
+                    {
+                        nextNode = RewriteGlobalAccess(node, config)?.Next ?? nextNode;
+                    }
+
+                    node = nextNode;
                 }
             }
         }
@@ -72,7 +79,7 @@ namespace Ryujinx.Graphics.Shader.Translation
             bool isStg16Or8 = operation.Inst == Instruction.StoreGlobal16 || operation.Inst == Instruction.StoreGlobal8;
             bool isWrite = isAtomic || operation.Inst == Instruction.StoreGlobal || isStg16Or8;
 
-            Operation storageOp;
+            Operation storageOp = null;
 
             Operand PrependOperation(Instruction inst, params Operand[] sources)
             {
@@ -83,12 +90,42 @@ namespace Ryujinx.Graphics.Shader.Translation
                 return local;
             }
 
+            Operand PrependExistingOperation(Operation operation)
+            {
+                Operand local = Local();
+
+                operation.Dest = local;
+                node.List.AddBefore(node, operation);
+
+                return local;
+            }
+
             Operand addrLow  = operation.GetSource(0);
             Operand addrHigh = operation.GetSource(1);
 
             Operand sbBaseAddrLow = Const(0);
             Operand sbSlot        = Const(0);
 
+            Operand alignMask = Const(-config.GpuAccessor.QueryHostStorageBufferOffsetAlignment());
+
+            Operand BindingRangeCheck(int cbOffset, out Operand baseAddrLow)
+            {
+                baseAddrLow = Cbuf(0, cbOffset);
+                Operand baseAddrHigh = Cbuf(0, cbOffset + 1);
+                Operand size = Cbuf(0, cbOffset + 2);
+
+                Operand offset = PrependOperation(Instruction.Subtract, addrLow, baseAddrLow);
+                Operand borrow = PrependOperation(Instruction.CompareLessU32, addrLow, baseAddrLow);
+
+                Operand inRangeLow = PrependOperation(Instruction.CompareLessU32, offset, size);
+
+                Operand addrHighBorrowed = PrependOperation(Instruction.Add, addrHigh, borrow);
+
+                Operand inRangeHigh = PrependOperation(Instruction.CompareEqual, addrHighBorrowed, baseAddrHigh);
+
+                return PrependOperation(Instruction.BitwiseAnd, inRangeLow, inRangeHigh);
+            }
+
             int sbUseMask = config.AccessibleStorageBuffersMask;
 
             while (sbUseMask != 0)
@@ -101,27 +138,14 @@ namespace Ryujinx.Graphics.Shader.Translation
 
                 int cbOffset = GetStorageCbOffset(config.Stage, slot);
 
-                Operand baseAddrLow  = Cbuf(0, cbOffset);
-                Operand baseAddrHigh = Cbuf(0, cbOffset + 1);
-                Operand size         = Cbuf(0, cbOffset + 2);
-
-                Operand offset = PrependOperation(Instruction.Subtract,       addrLow, baseAddrLow);
-                Operand borrow = PrependOperation(Instruction.CompareLessU32, addrLow, baseAddrLow);
-
-                Operand inRangeLow = PrependOperation(Instruction.CompareLessU32, offset, size);
-
-                Operand addrHighBorrowed = PrependOperation(Instruction.Add, addrHigh, borrow);
-
-                Operand inRangeHigh = PrependOperation(Instruction.CompareEqual, addrHighBorrowed, baseAddrHigh);
-
-                Operand inRange = PrependOperation(Instruction.BitwiseAnd, inRangeLow, inRangeHigh);
+                Operand inRange = BindingRangeCheck(cbOffset, out Operand baseAddrLow);
 
                 sbBaseAddrLow = PrependOperation(Instruction.ConditionalSelect, inRange, baseAddrLow, sbBaseAddrLow);
                 sbSlot        = PrependOperation(Instruction.ConditionalSelect, inRange, Const(slot), sbSlot);
             }
 
-            Operand alignMask = Const(-config.GpuAccessor.QueryHostStorageBufferOffsetAlignment());
-
+            if (config.AccessibleStorageBuffersMask != 0)
+            {
                 Operand baseAddrTrunc = PrependOperation(Instruction.BitwiseAnd, sbBaseAddrLow, alignMask);
                 Operand byteOffset    = PrependOperation(Instruction.Subtract, addrLow, baseAddrTrunc);
 
@@ -164,6 +188,51 @@ namespace Ryujinx.Graphics.Shader.Translation
 
                     storageOp = new Operation(storeInst, null, sources);
                 }
+            }
+            else if (operation.Dest != null)
+            {
+                storageOp = new Operation(Instruction.Copy, operation.Dest, Const(0));
+            }
+
+            if (operation.Inst == Instruction.LoadGlobal)
+            {
+                int cbeUseMask = config.AccessibleConstantBuffersMask;
+
+                while (cbeUseMask != 0)
+                {
+                    int slot = BitOperations.TrailingZeroCount(cbeUseMask);
+                    int cbSlot = UbeFirstCbuf + slot;
+
+                    cbeUseMask &= ~(1 << slot);
+
+                    config.SetUsedConstantBuffer(cbSlot);
+
+                    Operand previousResult = PrependExistingOperation(storageOp);
+
+                    int cbOffset = GetConstantUbeOffset(slot);
+
+                    Operand inRange = BindingRangeCheck(cbOffset, out Operand baseAddrLow);
+
+                    Operand baseAddrTruncConst = PrependOperation(Instruction.BitwiseAnd, baseAddrLow, alignMask);
+                    Operand byteOffsetConst = PrependOperation(Instruction.Subtract, addrLow, baseAddrTruncConst);
+
+                    Operand cbIndex = PrependOperation(Instruction.ShiftRightU32, byteOffsetConst, Const(2));
+
+                    Operand[] sourcesCb = new Operand[operation.SourcesCount];
+
+                    sourcesCb[0] = Const(cbSlot);
+                    sourcesCb[1] = cbIndex;
+
+                    for (int index = 2; index < operation.SourcesCount; index++)
+                    {
+                        sourcesCb[index] = operation.GetSource(index);
+                    }
+
+                    Operand ldcResult = PrependOperation(Instruction.LoadConstant, sourcesCb);
+
+                    storageOp = new Operation(Instruction.ConditionalSelect, operation.Dest, inRange, ldcResult, previousResult);
+                }
+            }
 
             for (int index = 0; index < operation.SourcesCount; index++)
             {
@@ -171,10 +240,18 @@ namespace Ryujinx.Graphics.Shader.Translation
             }
 
             LinkedListNode<INode> oldNode = node;
+            LinkedList<INode> oldNodeList = oldNode.List;
 
+            if (storageOp != null)
+            {
                 node = node.List.AddBefore(node, storageOp);
+            }
+            else
+            {
+                node = null;
+            }
 
-            node.List.Remove(oldNode);
+            oldNodeList.Remove(oldNode);
 
             return node;
         }

Ryujinx.Graphics.Shader/Translation/ShaderConfig.cs

@@ -66,6 +66,7 @@ namespace Ryujinx.Graphics.Shader.Translation
         public UInt128 ThisInputAttributesComponents { get; private set; }
 
         public int AccessibleStorageBuffersMask { get; private set; }
+        public int AccessibleConstantBuffersMask { get; private set; }
 
         private int _usedConstantBuffers;
         private int _usedStorageBuffers;
@@ -101,6 +102,7 @@ namespace Ryujinx.Graphics.Shader.Translation
             Options     = options;
 
             AccessibleStorageBuffersMask  = (1 << GlobalMemory.StorageMaxCount) - 1;
+            AccessibleConstantBuffersMask = (1 << GlobalMemory.UbeMaxCount) - 1;
 
             UsedInputAttributesPerPatch  = new HashSet<int>();
             UsedOutputAttributesPerPatch = new HashSet<int>();
@@ -121,6 +123,11 @@ namespace Ryujinx.Graphics.Shader.Translation
             OutputTopology           = outputTopology;
             MaxOutputVertices        = maxOutputVertices;
             TransformFeedbackEnabled = gpuAccessor.QueryTransformFeedbackEnabled();
+
+            if (Stage != ShaderStage.Compute)
+            {
+                AccessibleConstantBuffersMask = 0;
+            }
         }
 
         public ShaderConfig(ShaderHeader header, IGpuAccessor gpuAccessor, TranslationOptions options) : this(gpuAccessor, options)
@@ -404,9 +411,10 @@ namespace Ryujinx.Graphics.Shader.Translation
             UsedFeatures |= flags;
         }
 
-        public void SetAccessibleStorageBuffersMask(int mask)
+        public void SetAccessibleBufferMasks(int sbMask, int ubeMask)
         {
-            AccessibleStorageBuffersMask = mask;
+            AccessibleStorageBuffersMask = sbMask;
+            AccessibleConstantBuffersMask = ubeMask;
         }
 
         public void SetUsedConstantBuffer(int slot)

Ryujinx.Graphics.Vulkan/VulkanInitialization.cs

@@ -1,4 +1,4 @@
-using Ryujinx.Common.Configuration;
+using Ryujinx.Common.Configuration;
 using Ryujinx.Common.Logging;
 using Ryujinx.Graphics.GAL;
 using Silk.NET.Vulkan;
@@ -21,6 +21,7 @@ namespace Ryujinx.Graphics.Vulkan
         {
             ExtConditionalRendering.ExtensionName,
             ExtExtendedDynamicState.ExtensionName,
+            ExtTransformFeedback.ExtensionName,
             KhrDrawIndirectCount.ExtensionName,
             KhrPushDescriptor.ExtensionName,
             "VK_EXT_custom_border_color",
@@ -36,8 +37,7 @@ namespace Ryujinx.Graphics.Vulkan
 
         public static string[] RequiredExtensions { get; } = new string[]
         {
-            KhrSwapchain.ExtensionName,
-            ExtTransformFeedback.ExtensionName
+            KhrSwapchain.ExtensionName
         };
 
         private static string[] _excludedMessages = new string[]
@@ -382,12 +382,12 @@ namespace Ryujinx.Graphics.Vulkan
                 DepthClamp = true,
                 DualSrcBlend = true,
                 FragmentStoresAndAtomics = true,
-                GeometryShader = true,
+                GeometryShader = supportedFeatures.GeometryShader,
                 ImageCubeArray = true,
                 IndependentBlend = true,
-                LogicOp = true,
+                LogicOp = supportedFeatures.LogicOp,
                 MultiViewport = true,
-                PipelineStatisticsQuery = true,
+                PipelineStatisticsQuery = supportedFeatures.PipelineStatisticsQuery,
                 SamplerAnisotropy = true,
                 ShaderClipDistance = true,
                 ShaderFloat64 = supportedFeatures.ShaderFloat64,

Ryujinx.HLE/FileSystem/ContentManager.cs

@@ -39,13 +39,11 @@ namespace Ryujinx.HLE.FileSystem
         {
             public readonly string ContainerPath;
             public readonly string NcaPath;
-            public bool Enabled;
 
-            public AocItem(string containerPath, string ncaPath, bool enabled)
+            public AocItem(string containerPath, string ncaPath)
             {
                 ContainerPath = containerPath;
                 NcaPath = ncaPath;
-                Enabled = enabled;
             }
         }
 
@@ -53,7 +51,7 @@ namespace Ryujinx.HLE.FileSystem
 
         private VirtualFileSystem _virtualFileSystem;
 
-        private readonly object _lock = new object();
+        private readonly object _lock = new();
 
         public ContentManager(VirtualFileSystem virtualFileSystem)
         {
@@ -226,27 +224,21 @@ namespace Ryujinx.HLE.FileSystem
                 pfs0.OpenFile(ref cnmtFile.Ref(), pfs0.EnumerateEntries().Single().FullPath.ToU8Span(), OpenMode.Read);
 
                 var cnmt = new Cnmt(cnmtFile.Get.AsStream());
-
                 if (cnmt.Type != ContentMetaType.AddOnContent || (cnmt.TitleId & 0xFFFFFFFFFFFFE000) != aocBaseId)
                 {
                     continue;
                 }
 
                 string ncaId = BitConverter.ToString(cnmt.ContentEntries[0].NcaId).Replace("-", "").ToLower();
-                if (!_aocData.TryAdd(cnmt.TitleId, new AocItem(containerPath, $"{ncaId}.nca", true)))
-                {
-                    Logger.Warning?.Print(LogClass.Application, $"Duplicate AddOnContent detected. TitleId {cnmt.TitleId:X16}");
-                }
-                else
-                {
-                    Logger.Info?.Print(LogClass.Application, $"Found AddOnContent with TitleId {cnmt.TitleId:X16}");
-                }
+
+                AddAocItem(cnmt.TitleId, containerPath, $"{ncaId}.nca", true);
             }
         }
 
-        public void AddAocItem(ulong titleId, string containerPath, string ncaPath, bool enabled)
+        public void AddAocItem(ulong titleId, string containerPath, string ncaPath, bool mergedToContainer = false)
         {
-            if (!_aocData.TryAdd(titleId, new AocItem(containerPath, ncaPath, enabled)))
+            // TODO: Check Aoc version.
+            if (!_aocData.TryAdd(titleId, new AocItem(containerPath, ncaPath)))
             {
                 Logger.Warning?.Print(LogClass.Application, $"Duplicate AddOnContent detected. TitleId {titleId:X16}");
             }
@@ -254,25 +246,27 @@ namespace Ryujinx.HLE.FileSystem
             {
                 Logger.Info?.Print(LogClass.Application, $"Found AddOnContent with TitleId {titleId:X16}");
 
-                using (FileStream fileStream = File.OpenRead(containerPath))
-                using (PartitionFileSystem pfs = new PartitionFileSystem(fileStream.AsStorage()))
+                if (!mergedToContainer)
                 {
-                    _virtualFileSystem.ImportTickets(pfs);
+                    using FileStream          fileStream          = File.OpenRead(containerPath);
+                    using PartitionFileSystem partitionFileSystem = new(fileStream.AsStorage());
+
+                    _virtualFileSystem.ImportTickets(partitionFileSystem);
                 }
             }
         }
 
         public void ClearAocData() => _aocData.Clear();
 
-        public int GetAocCount() => _aocData.Where(e => e.Value.Enabled).Count();
+        public int GetAocCount() => _aocData.Count;
 
-        public IList<ulong> GetAocTitleIds() => _aocData.Where(e => e.Value.Enabled).Select(e => e.Key).ToList();
+        public IList<ulong> GetAocTitleIds() => _aocData.Select(e => e.Key).ToList();
 
         public bool GetAocDataStorage(ulong aocTitleId, out IStorage aocStorage, IntegrityCheckLevel integrityCheckLevel)
         {
             aocStorage = null;
 
-            if (_aocData.TryGetValue(aocTitleId, out AocItem aoc) && aoc.Enabled)
+            if (_aocData.TryGetValue(aocTitleId, out AocItem aoc))
             {
                 var file = new FileStream(aoc.ContainerPath, FileMode.Open, FileAccess.Read);
                 using var ncaFile = new UniqueRef<IFile>();

Ryujinx.HLE/HOS/Applets/SoftwareKeyboard/SoftwareKeyboardRendererBase.cs

@@ -11,7 +11,6 @@ using System.Numerics;
 using System.Reflection;
 using System.Runtime.InteropServices;
 using SixLabors.ImageSharp.PixelFormats;
-using Ryujinx.Common;
 
 namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
 {
@@ -68,8 +67,8 @@ namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
         {
             int ryujinxLogoSize = 32;
 
-            Stream logoStream = EmbeddedResources.GetStream("Ryujinx.Ui.Common/Resources/Logo_Ryujinx.png");
-            _ryujinxLogo = LoadResource(logoStream, ryujinxLogoSize, ryujinxLogoSize);
+            string ryujinxIconPath = "Ryujinx.HLE.HOS.Applets.SoftwareKeyboard.Resources.Logo_Ryujinx.png";
+            _ryujinxLogo = LoadResource(Assembly.GetExecutingAssembly(), ryujinxIconPath, ryujinxLogoSize, ryujinxLogoSize);
 
             string padAcceptIconPath = "Ryujinx.HLE.HOS.Applets.SoftwareKeyboard.Resources.Icon_BtnA.png";
             string padCancelIconPath = "Ryujinx.HLE.HOS.Applets.SoftwareKeyboard.Resources.Icon_BtnB.png";
@@ -117,7 +116,8 @@ namespace Ryujinx.HLE.HOS.Applets.SoftwareKeyboard
                 uiThemeFontFamily,
                 "Liberation Sans",
                 "FreeSans",
-                "DejaVu Sans"
+                "DejaVu Sans",
+                "Lucida Grande"
             };
 
             foreach (string fontFamily in availableFonts)

Ryujinx.HLE/HOS/ApplicationLoader.cs

@@ -426,9 +426,9 @@ namespace Ryujinx.HLE.HOS
                 {
                     foreach (DownloadableContentNca downloadableContentNca in downloadableContentContainer.DownloadableContentNcaList)
                     {
-                        if (File.Exists(downloadableContentContainer.ContainerPath))
+                        if (File.Exists(downloadableContentContainer.ContainerPath) && downloadableContentNca.Enabled)
                         {
-                            _device.Configuration.ContentManager.AddAocItem(downloadableContentNca.TitleId, downloadableContentContainer.ContainerPath, downloadableContentNca.FullPath, downloadableContentNca.Enabled);
+                            _device.Configuration.ContentManager.AddAocItem(downloadableContentNca.TitleId, downloadableContentContainer.ContainerPath, downloadableContentNca.FullPath);
                         }
                         else
                         {

Ryujinx.HLE/Ryujinx.HLE.csproj

@@ -26,7 +26,7 @@
     <PackageReference Include="MsgPack.Cli" Version="1.0.1" />
     <PackageReference Include="SixLabors.ImageSharp" Version="1.0.4" />
     <PackageReference Include="SixLabors.ImageSharp.Drawing" Version="1.0.0-beta11" />
-    <PackageReference Include="System.IdentityModel.Tokens.Jwt" Version="6.25.0" />
+    <PackageReference Include="System.IdentityModel.Tokens.Jwt" Version="6.25.1" />
   </ItemGroup>
 
   <!-- Due to Concentus. -->
@@ -36,6 +36,7 @@
 
   <ItemGroup>
     <None Remove="Homebrew.npdm" />
+    <None Remove="HOS\Applets\SoftwareKeyboard\Resources\Logo_Ryujinx.png" />
     <None Remove="HOS\Applets\SoftwareKeyboard\Resources\Icon_BtnA.png" />
     <None Remove="HOS\Applets\SoftwareKeyboard\Resources\Icon_BtnB.png" />
     <None Remove="HOS\Applets\SoftwareKeyboard\Resources\Icon_KeyF6.png" />
@@ -44,6 +45,7 @@
 
   <ItemGroup>
     <EmbeddedResource Include="Homebrew.npdm" />
+    <EmbeddedResource Include="HOS\Applets\SoftwareKeyboard\Resources\Logo_Ryujinx.png" />
     <EmbeddedResource Include="HOS\Applets\SoftwareKeyboard\Resources\Icon_BtnA.png" />
     <EmbeddedResource Include="HOS\Applets\SoftwareKeyboard\Resources\Icon_BtnB.png" />
     <EmbeddedResource Include="HOS\Applets\SoftwareKeyboard\Resources\Icon_KeyF6.png" />

Ryujinx.Headless.SDL2/Program.cs

@@ -77,6 +77,26 @@ namespace Ryujinx.Headless.SDL2
             _accountManager = new AccountManager(_libHacHorizonManager.RyujinxClient);
             _userChannelPersistence = new UserChannelPersistence();
 
+            if (OperatingSystem.IsMacOS())
+            {
+                AutoResetEvent invoked = new AutoResetEvent(false);
+
+                // MacOS must perform SDL polls from the main thread.
+                Ryujinx.SDL2.Common.SDL2Driver.MainThreadDispatcher = (Action action) =>
+                {
+                    invoked.Reset();
+
+                    WindowBase.QueueMainThreadAction(() =>
+                    {
+                        action();
+
+                        invoked.Set();
+                    });
+
+                    invoked.WaitOne();
+                };
+            }
+
             _inputManager = new InputManager(new SDL2KeyboardDriver(), new SDL2GamepadDriver());
 
             GraphicsConfig.EnableShaderCache = true;

Ryujinx.Headless.SDL2/Ryujinx.Headless.SDL2.csproj

@@ -12,7 +12,8 @@
 
   <ItemGroup>
     <PackageReference Include="OpenTK.Core" Version="4.7.5" />
-    <PackageReference Include="Ryujinx.Graphics.Nvdec.Dependencies" Version="5.0.1-build10" Condition="'$(RuntimeIdentifier)' != 'linux-x64' AND '$(RuntimeIdentifier)' != 'osx-x64'" />
+    <PackageReference Include="Ryujinx.Graphics.Nvdec.Dependencies" Version="5.0.1-build10" Condition="'$(RuntimeIdentifier)' != 'linux-x64' AND '$(RuntimeIdentifier)' != 'osx-x64' AND '$(RuntimeIdentifier)' != 'osx-arm64'" />
+    <PackageReference Include="Ryujinx.Graphics.Nvdec.Dependencies.osx" Version="5.0.1" Condition="'$(RuntimeIdentifier)' != 'linux-x64' AND '$(RuntimeIdentifier)' != 'win10-x64'" />
   </ItemGroup>
 
   <ItemGroup>
@@ -32,10 +33,14 @@
   </ItemGroup>
 
 	<ItemGroup>
-		<ContentWithTargetPath Include="..\distribution\legal\THIRDPARTY.md">
+      <Content Include="..\distribution\legal\THIRDPARTY.md">
         <CopyToOutputDirectory>Always</CopyToOutputDirectory>
         <TargetPath>THIRDPARTY.md</TargetPath>
-		</ContentWithTargetPath>
+      </Content>
+      <Content Include="..\LICENSE.txt">
+        <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+        <TargetPath>LICENSE.txt</TargetPath>
+      </Content>
 	</ItemGroup>
 
   <!-- Due to .net core 3.1 embedded resource loading -->

Ryujinx.Headless.SDL2/Vulkan/VulkanWindow.cs

@@ -1,6 +1,7 @@
 using Ryujinx.Common.Configuration;
 using Ryujinx.Common.Logging;
 using Ryujinx.Input.HLE;
+using Ryujinx.SDL2.Common;
 using System;
 using System.Runtime.InteropServices;
 using static SDL2.SDL;
@@ -26,9 +27,18 @@ namespace Ryujinx.Headless.SDL2.Vulkan
             MouseDriver.SetClientSize(DefaultWidth, DefaultHeight);
         }
 
+        private void BasicInvoke(Action action)
+        {
+            action();
+        }
+
         public unsafe IntPtr CreateWindowSurface(IntPtr instance)
         {
-            if (SDL_Vulkan_CreateSurface(WindowHandle, instance, out ulong surfaceHandle) == SDL_bool.SDL_FALSE)
+            ulong surfaceHandle = 0;
+
+            Action createSurface = () =>
+            {
+                if (SDL_Vulkan_CreateSurface(WindowHandle, instance, out surfaceHandle) == SDL_bool.SDL_FALSE)
                 {
                     string errorMessage = $"SDL_Vulkan_CreateSurface failed with error \"{SDL_GetError()}\"";
 
@@ -36,6 +46,16 @@ namespace Ryujinx.Headless.SDL2.Vulkan
 
                     throw new Exception(errorMessage);
                 }
+            };
+
+            if (SDL2Driver.MainThreadDispatcher != null)
+            {
+                SDL2Driver.MainThreadDispatcher(createSurface);
+            }
+            else
+            {
+                createSurface();
+            }
 
             return (IntPtr)surfaceHandle;
         }

Ryujinx.Headless.SDL2/WindowBase.cs

@@ -11,6 +11,7 @@ using Ryujinx.Input;
 using Ryujinx.Input.HLE;
 using Ryujinx.SDL2.Common;
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Threading;
@@ -26,6 +27,13 @@ namespace Ryujinx.Headless.SDL2
         private const SDL_WindowFlags DefaultFlags = SDL_WindowFlags.SDL_WINDOW_ALLOW_HIGHDPI | SDL_WindowFlags.SDL_WINDOW_RESIZABLE | SDL_WindowFlags.SDL_WINDOW_INPUT_FOCUS | SDL_WindowFlags.SDL_WINDOW_SHOWN;
         private const int TargetFps = 60;
 
+        private static ConcurrentQueue<Action> MainThreadActions = new ConcurrentQueue<Action>();
+
+        public static void QueueMainThreadAction(Action action)
+        {
+            MainThreadActions.Enqueue(action);
+        }
+
         public NpadManager NpadManager { get; }
         public TouchScreenManager TouchScreenManager { get; }
         public Switch Device { get; private set; }
@@ -168,6 +176,14 @@ namespace Ryujinx.Headless.SDL2
 
         public void Render()
         {
+            InitializeWindowRenderer();
+
+            Device.Gpu.Renderer.Initialize(_glLogLevel);
+
+            InitializeRenderer();
+
+            _gpuVendorName = GetGpuVendorName();
+
             Device.Gpu.Renderer.RunLoop(() =>
             {
                 Device.Gpu.SetGpuThread();
@@ -241,6 +257,14 @@ namespace Ryujinx.Headless.SDL2
             _exitEvent.Dispose();
         }
 
+        public void ProcessMainThreadQueue()
+        {
+            while (MainThreadActions.TryDequeue(out Action action))
+            {
+                action();
+            }
+        }
+
         public void MainLoop()
         {
             while (_isActive)
@@ -249,6 +273,8 @@ namespace Ryujinx.Headless.SDL2
 
                 SDL_PumpEvents();
 
+                ProcessMainThreadQueue();
+
                 // Polling becomes expensive if it's not slept
                 Thread.Sleep(1);
             }
@@ -315,14 +341,6 @@ namespace Ryujinx.Headless.SDL2
 
             InitializeWindow();
 
-            InitializeWindowRenderer();
-
-            Device.Gpu.Renderer.Initialize(_glLogLevel);
-
-            InitializeRenderer();
-
-            _gpuVendorName = GetGpuVendorName();
-
             Thread renderLoopThread = new Thread(Render)
             {
                 Name = "GUI.RenderLoop"

Ryujinx.Horizon.Generators/Ryujinx.Horizon.Generators.csproj

@@ -9,7 +9,7 @@
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.2.0" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.4.0" />
   </ItemGroup>
 
 </Project>

Ryujinx.Memory/MemoryManagerUnixHelper.cs

@@ -153,7 +153,8 @@ namespace Ryujinx.Memory
 
             if (OperatingSystem.IsMacOSVersionAtLeast(10, 14))
             {
-                result |= MAP_JIT_DARWIN;
+                // Only to be used with the Hardened Runtime.
+                // result |= MAP_JIT_DARWIN;
             }
 
             return result;

Ryujinx.Tests/Audio/Renderer/Parameter/Effect/CompressorParameterTests.cs

@@ -0,0 +1,16 @@
+using NUnit.Framework;
+using Ryujinx.Audio.Renderer.Parameter.Effect;
+using System.Runtime.CompilerServices;
+
+namespace Ryujinx.Tests.Audio.Renderer.Parameter.Effect
+{
+    class CompressorParameterTests
+    {
+        [Test]
+        public void EnsureTypeSize()
+        {
+            Assert.AreEqual(0x38, Unsafe.SizeOf<CompressorParameter>());
+        }
+    }
+}
+

Ryujinx.Ui.Common/App/ApplicationData.cs

@@ -12,9 +12,11 @@ namespace Ryujinx.Ui.App.Common
         public string Developer     { get; set; }
         public string Version       { get; set; }
         public string TimePlayed    { get; set; }
+        public double TimePlayedNum { get; set; }
         public string LastPlayed    { get; set; }
         public string FileExtension { get; set; }
         public string FileSize      { get; set; }
+        public double FileSizeBytes { get; set; }
         public string Path          { get; set; }
         public BlitStruct<ApplicationControlProperty> ControlHolder { get; set; }
     }

Ryujinx.Ui.Common/App/ApplicationLibrary.cs

@@ -465,9 +465,11 @@ namespace Ryujinx.Ui.App.Common
                         Developer = developer,
                         Version = version,
                         TimePlayed = ConvertSecondsToReadableString(appMetadata.TimePlayed),
+                        TimePlayedNum = appMetadata.TimePlayed,
                         LastPlayed = appMetadata.LastPlayed,
                         FileExtension = Path.GetExtension(applicationPath).ToUpper().Remove(0, 1),
                         FileSize = (fileSize < 1) ? (fileSize * 1024).ToString("0.##") + " MiB" : fileSize.ToString("0.##") + " GiB",
+                        FileSizeBytes = fileSize,
                         Path = applicationPath,
                         ControlHolder = controlHolder
                     };

Ryujinx.Ui.Common/Configuration/ConfigurationState.cs

@@ -680,7 +680,7 @@ namespace Ryujinx.Ui.Common.Configuration
             Hid.EnableMouse.Value                     = false;
             Hid.Hotkeys.Value = new KeyboardHotkeys
             {
-                ToggleVsync = Key.Tab,
+                ToggleVsync = Key.F1,
                 ToggleMute = Key.F2,
                 Screenshot = Key.F8,
                 ShowUi = Key.F4,
@@ -818,7 +818,7 @@ namespace Ryujinx.Ui.Common.Configuration
 
                 configurationFileFormat.Hotkeys = new KeyboardHotkeys
                 {
-                    ToggleVsync = Key.Tab
+                    ToggleVsync = Key.F1
                 };
 
                 configurationFileUpdated = true;
@@ -999,7 +999,7 @@ namespace Ryujinx.Ui.Common.Configuration
 
                 configurationFileFormat.Hotkeys = new KeyboardHotkeys
                 {
-                    ToggleVsync = Key.Tab,
+                    ToggleVsync = Key.F1,
                     Screenshot = Key.F8
                 };
 
@@ -1012,7 +1012,7 @@ namespace Ryujinx.Ui.Common.Configuration
 
                 configurationFileFormat.Hotkeys = new KeyboardHotkeys
                 {
-                    ToggleVsync = Key.Tab,
+                    ToggleVsync = Key.F1,
                     Screenshot = Key.F8,
                     ShowUi = Key.F4
                 };

Ryujinx/Modules/Updater/UpdateDialog.cs

@@ -25,7 +25,7 @@ namespace Ryujinx.Modules
 
         public UpdateDialog(MainWindow mainWindow, Version newVersion, string buildUrl) : this(new Builder("Ryujinx.Modules.Updater.UpdateDialog.glade"), mainWindow, newVersion, buildUrl) { }
 
-        private UpdateDialog(Builder builder, MainWindow mainWindow, Version newVersion, string buildUrl) : base(builder.GetObject("UpdateDialog").Handle)
+        private UpdateDialog(Builder builder, MainWindow mainWindow, Version newVersion, string buildUrl) : base(builder.GetRawOwnedObject("UpdateDialog"))
         {
             builder.Autoconnect(this);
 

Ryujinx/Program.cs

@@ -16,6 +16,7 @@ using Ryujinx.Ui.Widgets;
 using SixLabors.ImageSharp.Formats.Jpeg;
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.IO;
 using System.Runtime.InteropServices;
 using System.Threading.Tasks;
@@ -40,6 +41,12 @@ namespace Ryujinx
         [DllImport("user32.dll", SetLastError = true)]
         public static extern int MessageBoxA(IntPtr hWnd, string text, string caption, uint type);
 
+        [DllImport("libc", SetLastError = true)]
+        static extern int setenv(string name, string value, int overwrite);
+
+        [DllImport("libc")]
+        static extern IntPtr getenv(string name);
+
         private const uint MB_ICONWARNING = 0x30;
 
         static Program()
@@ -97,6 +104,35 @@ namespace Ryujinx
                 XInitThreads();
             }
 
+            if (OperatingSystem.IsMacOS())
+            {
+                string baseDirectory = Path.GetDirectoryName(AppDomain.CurrentDomain.BaseDirectory);
+                string resourcesDataDir;
+
+                if (Path.GetFileName(baseDirectory) == "MacOS")
+                {
+                    resourcesDataDir = Path.Combine(Directory.GetParent(baseDirectory).FullName, "Resources");
+                }
+                else
+                {
+                    resourcesDataDir = baseDirectory;
+                }
+
+                void SetEnvironmentVariableNoCaching(string key, string value)
+                {
+                    int res = setenv(key, value, 1);
+                    Debug.Assert(res != -1);
+                }
+
+                // On macOS, GTK3 needs XDG_DATA_DIRS to be set, otherwise it will try searching for "gschemas.compiled" in system directories.
+                SetEnvironmentVariableNoCaching("XDG_DATA_DIRS", Path.Combine(resourcesDataDir, "share"));
+
+                // On macOS, GTK3 needs GDK_PIXBUF_MODULE_FILE to be set, otherwise it will try searching for "loaders.cache" in system directories.
+                SetEnvironmentVariableNoCaching("GDK_PIXBUF_MODULE_FILE", Path.Combine(resourcesDataDir, "lib", "gdk-pixbuf-2.0", "2.10.0", "loaders.cache"));
+
+                SetEnvironmentVariableNoCaching("GTK_IM_MODULE_FILE", Path.Combine(resourcesDataDir, "lib", "gtk-3.0", "3.0.0", "immodules.cache"));
+            }
+
             string systemPath = Environment.GetEnvironmentVariable("Path", EnvironmentVariableTarget.Machine);
             Environment.SetEnvironmentVariable("Path", $"{Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "bin")};{systemPath}");
 

Ryujinx/Ryujinx.csproj

@@ -19,10 +19,13 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="GtkSharp" Version="3.22.25.128" />
-    <PackageReference Include="GtkSharp.Dependencies" Version="1.1.1" Condition="'$(RuntimeIdentifier)' != 'linux-x64' AND '$(RuntimeIdentifier)' != 'osx-x64'" />
-    <PackageReference Include="Ryujinx.Graphics.Nvdec.Dependencies" Version="5.0.1-build10" Condition="'$(RuntimeIdentifier)' != 'linux-x64' AND '$(RuntimeIdentifier)' != 'osx-x64'" />
-    <PackageReference Include="Ryujinx.Audio.OpenAL.Dependencies" Version="1.21.0.1" Condition="'$(RuntimeIdentifier)' != 'linux-x64' AND '$(RuntimeIdentifier)' != 'osx-x64'" />
+    <PackageReference Include="Ryujinx.GtkSharp" Version="3.24.24.59-ryujinx" />
+    <PackageReference Include="GtkSharp.Dependencies" Version="1.1.1" Condition="'$(RuntimeIdentifier)' != 'linux-x64' AND '$(RuntimeIdentifier)' != 'osx-x64' AND '$(RuntimeIdentifier)' != 'osx-arm64'" />
+    <PackageReference Include="GtkSharp.Dependencies.osx" Version="0.0.5" Condition="'$(RuntimeIdentifier)' == 'osx-x64' OR '$(RuntimeIdentifier)' == 'osx-arm64'" />
+    <PackageReference Include="Ryujinx.Graphics.Nvdec.Dependencies" Version="5.0.1-build10" Condition="'$(RuntimeIdentifier)' != 'linux-x64' AND '$(RuntimeIdentifier)' != 'osx-x64' AND '$(RuntimeIdentifier)' != 'osx-arm64'" />
+    <PackageReference Include="Ryujinx.Graphics.Nvdec.Dependencies.osx" Version="5.0.1" Condition="'$(RuntimeIdentifier)' != 'linux-x64' AND '$(RuntimeIdentifier)' != 'win10-x64'" />
+    <PackageReference Include="Ryujinx.Audio.OpenAL.Dependencies" Version="1.21.0.1" Condition="'$(RuntimeIdentifier)' != 'linux-x64' AND '$(RuntimeIdentifier)' != 'osx-x64' AND '$(RuntimeIdentifier)' != 'osx-arm64'" />
+    <PackageReference Include="Ryujinx.Graphics.Vulkan.Dependencies.MoltenVK" Version="1.2.0" Condition="'$(RuntimeIdentifier)' != 'linux-x64' AND '$(RuntimeIdentifier)' != 'win10-x64'" />
     <PackageReference Include="OpenTK.Core" Version="4.7.5" />
     <PackageReference Include="OpenTK.Graphics" Version="4.7.5" />
     <PackageReference Include="SPB" Version="0.0.4-build28" />
@@ -46,14 +49,18 @@
   </ItemGroup>
 
   <ItemGroup>
-    <ContentWithTargetPath Include="..\distribution\windows\alsoft.ini" Condition="'$(RuntimeIdentifier)' != 'linux-x64' AND '$(RuntimeIdentifier)' != 'osx-x64'">
+    <Content Include="..\distribution\windows\alsoft.ini" Condition="'$(RuntimeIdentifier)' != 'linux-x64' AND '$(RuntimeIdentifier)' != 'osx-x64'">
       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
       <TargetPath>alsoft.ini</TargetPath>
-    </ContentWithTargetPath>
-    <ContentWithTargetPath Include="..\distribution\legal\THIRDPARTY.md">
+    </Content>
+    <Content Include="..\distribution\legal\THIRDPARTY.md">
       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
       <TargetPath>THIRDPARTY.md</TargetPath>
-    </ContentWithTargetPath>
+    </Content>
+    <Content Include="..\LICENSE.txt">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+      <TargetPath>LICENSE.txt</TargetPath>
+    </Content>
   </ItemGroup>
 
   <!-- Due to .net core 3.1 embedded resource loading -->
@@ -62,10 +69,6 @@
     <ApplicationIcon>Ryujinx.ico</ApplicationIcon>
   </PropertyGroup>
 
-  <PropertyGroup Condition="'$(RuntimeIdentifier)' == 'osx-x64'">
-    <DefineConstants>$(DefineConstants);MACOS_BUILD</DefineConstants>
-  </PropertyGroup>
-
   <ItemGroup>
     <None Remove="Ui\MainWindow.glade" />
     <None Remove="Ui\Widgets\ProfileDialog.glade" />

Ryujinx/Ui/Helper/MetalHelper.cs

@@ -0,0 +1,134 @@
+using Gdk;
+using System;
+using System.Runtime.Versioning;
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.Ui.Helper
+{
+    public delegate void UpdateBoundsCallbackDelegate(Window window);
+
+    [SupportedOSPlatform("macos")]
+    static class MetalHelper
+    {
+        private const string LibObjCImport = "/usr/lib/libobjc.A.dylib";
+
+        private struct Selector
+        {
+            public readonly IntPtr NativePtr;
+
+            public unsafe Selector(string value)
+            {
+                int size = System.Text.Encoding.UTF8.GetMaxByteCount(value.Length);
+                byte* data = stackalloc byte[size];
+
+                fixed (char* pValue = value)
+                {
+                    System.Text.Encoding.UTF8.GetBytes(pValue, value.Length, data, size);
+                }
+
+                NativePtr = sel_registerName(data);
+            }
+
+            public static implicit operator Selector(string value) => new Selector(value);
+        }
+
+        private static unsafe IntPtr GetClass(string value)
+        {
+            int size = System.Text.Encoding.UTF8.GetMaxByteCount(value.Length);
+            byte* data = stackalloc byte[size];
+
+            fixed (char* pValue = value)
+            {
+                System.Text.Encoding.UTF8.GetBytes(pValue, value.Length, data, size);
+            }
+
+            return objc_getClass(data);
+        }
+
+        private struct NSPoint
+        {
+            public double X;
+            public double Y;
+
+            public NSPoint(double x, double y)
+            {
+                X = x;
+                Y = y;
+            }
+        }
+
+        private struct NSRect
+        {
+            public NSPoint Pos;
+            public NSPoint Size;
+
+            public NSRect(double x, double y, double width, double height)
+            {
+                Pos = new NSPoint(x, y);
+                Size = new NSPoint(width, height);
+            }
+        }
+
+        public static IntPtr GetMetalLayer(Display display, Window window, out IntPtr nsView, out UpdateBoundsCallbackDelegate updateBounds)
+        {
+            nsView = gdk_quartz_window_get_nsview(window.Handle);
+
+            // Create a new CAMetalLayer.
+            IntPtr layerClass = GetClass("CAMetalLayer");
+            IntPtr metalLayer = IntPtr_objc_msgSend(layerClass, "alloc");
+            objc_msgSend(metalLayer, "init");
+
+            // Create a child NSView to render into.
+            IntPtr nsViewClass = GetClass("NSView");
+            IntPtr child = IntPtr_objc_msgSend(nsViewClass, "alloc");
+            objc_msgSend(child, "init", new NSRect());
+
+            // Add it as a child.
+            objc_msgSend(nsView, "addSubview:", child);
+
+            // Make its renderer our metal layer.
+            objc_msgSend(child, "setWantsLayer:", (byte)1);
+            objc_msgSend(child, "setLayer:", metalLayer);
+            objc_msgSend(metalLayer, "setContentsScale:", (double)display.GetMonitorAtWindow(window).ScaleFactor);
+
+            // Set the frame position/location.
+            updateBounds = (Window window) => {
+                window.GetPosition(out int x, out int y);
+                int width = window.Width;
+                int height = window.Height;
+                objc_msgSend(child, "setFrame:", new NSRect(x, y, width, height));
+            };
+
+            updateBounds(window);
+
+            return metalLayer;
+        }
+
+        [DllImport(LibObjCImport)]
+        private static unsafe extern IntPtr sel_registerName(byte* data);
+
+        [DllImport(LibObjCImport)]
+        private static unsafe extern IntPtr objc_getClass(byte* data);
+
+        [DllImport(LibObjCImport)]
+        private static extern void objc_msgSend(IntPtr receiver, Selector selector);
+
+        [DllImport(LibObjCImport)]
+        private static extern void objc_msgSend(IntPtr receiver, Selector selector, byte value);
+
+        [DllImport(LibObjCImport)]
+        private static extern void objc_msgSend(IntPtr receiver, Selector selector, IntPtr value);
+
+        [DllImport(LibObjCImport)]
+        private static extern void objc_msgSend(IntPtr receiver, Selector selector, NSRect point);
+
+        [DllImport(LibObjCImport)]
+        private static extern void objc_msgSend(IntPtr receiver, Selector selector, double value);
+
+        [DllImport(LibObjCImport, EntryPoint = "objc_msgSend")]
+        private static extern IntPtr IntPtr_objc_msgSend(IntPtr receiver, Selector selector);
+
+        [DllImport("libgdk-3.0.dylib")]
+        private static extern IntPtr gdk_quartz_window_get_nsview(IntPtr gdkWindow);
+    }
+}

Ryujinx/Ui/Helper/SortHelper.cs

@@ -9,46 +9,56 @@ namespace Ryujinx.Ui.Helper
         {
             string aValue = model.GetValue(a, 5).ToString();
             string bValue = model.GetValue(b, 5).ToString();
+            float aFloat;
+            float bFloat;
 
-            if (aValue.Length > 4 && aValue[^4..] == "mins")
+            if (aValue.Length > 7 && aValue[^7..] == "minutes")
             {
-                aValue = (float.Parse(aValue[0..^5]) * 60).ToString();
+                aValue = aValue.Replace("minutes", "");
+                aFloat = (float.Parse(aValue) * 60);
             }
-            else if (aValue.Length > 3 && aValue[^3..] == "hrs")
+            else if (aValue.Length > 5 && aValue[^5..] == "hours")
             {
-                aValue = (float.Parse(aValue[0..^4]) * 3600).ToString();
+                aValue = aValue.Replace("hours", "");
+                aFloat = (float.Parse(aValue) * 3600);
             }
             else if (aValue.Length > 4 && aValue[^4..] == "days")
             {
-                aValue = (float.Parse(aValue[0..^5]) * 86400).ToString();
+                aValue = aValue.Replace("days", "");
+                aFloat = (float.Parse(aValue) * 86400);
             }
             else
             {
-                aValue = aValue[0..^1];
+                aValue = aValue.Replace("seconds", "");
+                aFloat = float.Parse(aValue);
             }
 
-            if (bValue.Length > 4 && bValue[^4..] == "mins")
+            if (bValue.Length > 7 && bValue[^7..] == "minutes")
             {
-                bValue = (float.Parse(bValue[0..^5]) * 60).ToString();
+                bValue = bValue.Replace("minutes", "");
+                bFloat = (float.Parse(bValue) * 60);
             }
-            else if (bValue.Length > 3 && bValue[^3..] == "hrs")
+            else if (bValue.Length > 5 && bValue[^5..] == "hours")
             {
-                bValue = (float.Parse(bValue[0..^4]) * 3600).ToString();
+                bValue = bValue.Replace("hours", "");
+                bFloat = (float.Parse(bValue) * 3600);
             }
             else if (bValue.Length > 4 && bValue[^4..] == "days")
             {
-                bValue = (float.Parse(bValue[0..^5]) * 86400).ToString();
+                bValue =  bValue.Replace("days", "");
+                bFloat = (float.Parse(bValue) * 86400);
             }
             else
             {
-                bValue = bValue[0..^1];
+                bValue = bValue[0..^8];
+                bFloat = float.Parse(bValue);
             }
 
-            if (float.Parse(aValue) > float.Parse(bValue))
+            if (aFloat > bFloat)
             {
                 return -1;
             }
-            else if (float.Parse(bValue) > float.Parse(aValue))
+            else if (bFloat > aFloat)
             {
                 return 1;
             }

Ryujinx/Ui/MainWindow.cs

@@ -142,7 +142,7 @@ namespace Ryujinx.Ui
 
         public MainWindow() : this(new Builder("Ryujinx.Ui.MainWindow.glade")) { }
 
-        private MainWindow(Builder builder) : base(builder.GetObject("_mainWin").Handle)
+        private MainWindow(Builder builder) : base(builder.GetRawOwnedObject("_mainWin"))
         {
             builder.Autoconnect(this);
 
@@ -846,9 +846,7 @@ namespace Ryujinx.Ui
                 _deviceExitStatus.Reset();
 
                 Translator.IsReadyForTranslation.Reset();
-#if MACOS_BUILD
-                CreateGameWindow();
-#else
+
                 Thread windowThread = new Thread(() =>
                 {
                     CreateGameWindow();
@@ -858,7 +856,6 @@ namespace Ryujinx.Ui
                 };
 
                 windowThread.Start();
-#endif
 
                 _gameLoaded           = true;
                 _actionMenu.Sensitive = true;

Ryujinx/Ui/VKRenderer.cs

@@ -1,9 +1,11 @@
 using Gdk;
 using Ryujinx.Common.Configuration;
 using Ryujinx.Input.HLE;
+using Ryujinx.Ui.Helper;
 using SPB.Graphics.Vulkan;
 using SPB.Platform.Win32;
 using SPB.Platform.X11;
+using SPB.Platform.Metal;
 using SPB.Windowing;
 using System;
 using System.Runtime.InteropServices;
@@ -13,6 +15,7 @@ namespace Ryujinx.Ui
     public class VKRenderer : RendererWidgetBase
     {
         public NativeWindowBase NativeWindow { get; private set; }
+        private UpdateBoundsCallbackDelegate _updateBoundsCallback;
 
         public VKRenderer(InputManager inputManager, GraphicsDebugLevel glLogLevel) : base(inputManager, glLogLevel) { }
 
@@ -31,6 +34,12 @@ namespace Ryujinx.Ui
 
                 return new SimpleX11Window(new NativeHandle(displayHandle), new NativeHandle(windowHandle));
             }
+            else if (OperatingSystem.IsMacOS())
+            {
+                IntPtr metalLayer = MetalHelper.GetMetalLayer(Display, Window, out IntPtr nsView, out _updateBoundsCallback);
+
+                return new SimpleMetalWindow(new NativeHandle(nsView), new NativeHandle(metalLayer));
+            }
 
             throw new NotImplementedException();
         }
@@ -53,7 +62,11 @@ namespace Ryujinx.Ui
                 WaitEvent.Set();
             }
 
-            return base.OnConfigureEvent(evnt);
+            bool result = base.OnConfigureEvent(evnt);
+
+            _updateBoundsCallback?.Invoke(Window);
+
+            return result;
         }
 
         public unsafe IntPtr CreateWindowSurface(IntPtr instance)

Ryujinx/Ui/Widgets/ProfileDialog.cs

@@ -18,7 +18,7 @@ namespace Ryujinx.Ui.Widgets
 
         public ProfileDialog() : this(new Builder("Ryujinx.Ui.Widgets.ProfileDialog.glade")) { }
 
-        private ProfileDialog(Builder builder) : base(builder.GetObject("_profileDialog").Handle)
+        private ProfileDialog(Builder builder) : base(builder.GetRawOwnedObject("_profileDialog"))
         {
             builder.Autoconnect(this);
             Icon = new Gdk.Pixbuf(Assembly.GetAssembly(typeof(ConfigurationState)), "Ryujinx.Ui.Common.Resources.Logo_Ryujinx.png");

Ryujinx/Ui/Windows/AvatarWindow.cs

@@ -46,7 +46,7 @@ namespace Ryujinx.Ui.Windows
             SetDefaultSize(740, 400);
             SetPosition(WindowPosition.Center);
 
-            VBox vbox = new VBox(false, 0);
+            Box vbox = new(Orientation.Vertical, 0);
             Add(vbox);
 
             ScrolledWindow scrolledWindow = new ScrolledWindow
@@ -55,7 +55,7 @@ namespace Ryujinx.Ui.Windows
             };
             scrolledWindow.SetPolicy(PolicyType.Automatic, PolicyType.Automatic);
 
-            HBox hbox = new HBox(false, 0);
+            Box hbox = new(Orientation.Horizontal, 0);
 
             Button chooseButton = new Button()
             {

Ryujinx/Ui/Windows/CheatWindow.cs

@@ -23,7 +23,7 @@ namespace Ryujinx.Ui.Windows
 
         public CheatWindow(VirtualFileSystem virtualFileSystem, ulong titleId, string titleName) : this(new Builder("Ryujinx.Ui.Windows.CheatWindow.glade"), virtualFileSystem, titleId, titleName) { }
 
-        private CheatWindow(Builder builder, VirtualFileSystem virtualFileSystem, ulong titleId, string titleName) : base(builder.GetObject("_cheatWindow").Handle)
+        private CheatWindow(Builder builder, VirtualFileSystem virtualFileSystem, ulong titleId, string titleName) : base(builder.GetRawOwnedObject("_cheatWindow"))
         {
             builder.Autoconnect(this);
             _baseTitleInfoLabel.Text = $"Cheats Available for {titleName} [{titleId:X16}]";

Ryujinx/Ui/Windows/ControllerWindow.cs

@@ -119,7 +119,7 @@ namespace Ryujinx.Ui.Windows
 
         public ControllerWindow(MainWindow mainWindow, PlayerIndex controllerId) : this(mainWindow, new Builder("Ryujinx.Ui.Windows.ControllerWindow.glade"), controllerId) { }
 
-        private ControllerWindow(MainWindow mainWindow, Builder builder, PlayerIndex controllerId) : base(builder.GetObject("_controllerWin").Handle)
+        private ControllerWindow(MainWindow mainWindow, Builder builder, PlayerIndex controllerId) : base(builder.GetRawOwnedObject("_controllerWin"))
         {
             _mainWindow = mainWindow;
             _selectedGamepad = null;
@@ -379,6 +379,8 @@ namespace Ryujinx.Ui.Windows
                     break;
             }
 
+            if (!OperatingSystem.IsMacOS())
+            {
                 _controllerImage.Pixbuf = _controllerType.ActiveId switch
                 {
                     "ProController" => new Gdk.Pixbuf(Assembly.GetAssembly(typeof(ConfigurationState)), "Ryujinx.Ui.Common.Resources.Controller_ProCon.svg", 400, 400),
@@ -387,6 +389,7 @@ namespace Ryujinx.Ui.Windows
                     _               => new Gdk.Pixbuf(Assembly.GetAssembly(typeof(ConfigurationState)), "Ryujinx.Ui.Common.Resources.Controller_JoyConPair.svg", 400, 500),
                 };
             }
+        }
 
         private void ClearValues()
         {

Ryujinx/Ui/Windows/DlcWindow.cs

@@ -34,7 +34,7 @@ namespace Ryujinx.Ui.Windows
 
         public DlcWindow(VirtualFileSystem virtualFileSystem, string titleId, string titleName) : this(new Builder("Ryujinx.Ui.Windows.DlcWindow.glade"), virtualFileSystem, titleId, titleName) { }
 
-        private DlcWindow(Builder builder, VirtualFileSystem virtualFileSystem, string titleId, string titleName) : base(builder.GetObject("_dlcWindow").Handle)
+        private DlcWindow(Builder builder, VirtualFileSystem virtualFileSystem, string titleId, string titleName) : base(builder.GetRawOwnedObject("_dlcWindow"))
         {
             builder.Autoconnect(this);
 

Ryujinx/Ui/Windows/SettingsWindow.cs

@@ -113,7 +113,7 @@ namespace Ryujinx.Ui.Windows
 
         public SettingsWindow(MainWindow parent, VirtualFileSystem virtualFileSystem, ContentManager contentManager) : this(parent, new Builder("Ryujinx.Ui.Windows.SettingsWindow.glade"), virtualFileSystem, contentManager) { }
 
-        private SettingsWindow(MainWindow parent, Builder builder, VirtualFileSystem virtualFileSystem, ContentManager contentManager) : base(builder.GetObject("_settingsWin").Handle)
+        private SettingsWindow(MainWindow parent, Builder builder, VirtualFileSystem virtualFileSystem, ContentManager contentManager) : base(builder.GetRawOwnedObject("_settingsWin"))
         {
             Icon = new Gdk.Pixbuf(Assembly.GetAssembly(typeof(ConfigurationState)), "Ryujinx.Ui.Common.Resources.Logo_Ryujinx.png");
 
@@ -422,7 +422,7 @@ namespace Ryujinx.Ui.Windows
             Task.Run(() =>
             {
                 openAlIsSupported  = OpenALHardwareDeviceDriver.IsSupported;
-                soundIoIsSupported = SoundIoHardwareDeviceDriver.IsSupported;
+                soundIoIsSupported = !OperatingSystem.IsMacOS() && SoundIoHardwareDeviceDriver.IsSupported;
                 sdl2IsSupported    = SDL2HardwareDeviceDriver.IsSupported;
             });
 
@@ -438,6 +438,15 @@ namespace Ryujinx.Ui.Windows
                     _ => throw new ArgumentOutOfRangeException()
                 };
             });
+
+            if (OperatingSystem.IsMacOS())
+            {
+                var store = (_graphicsBackend.Model as ListStore);
+                store.GetIter(out TreeIter openglIter, new TreePath(new int[] {1}));
+                store.Remove(ref openglIter);
+
+                _graphicsBackend.Model = store;
+            }
         }
 
         private void UpdatePreferredGpuComboBox()

Ryujinx/Ui/Windows/TitleUpdateWindow.cs

@@ -40,7 +40,7 @@ namespace Ryujinx.Ui.Windows
 
         public TitleUpdateWindow(MainWindow parent, VirtualFileSystem virtualFileSystem, string titleId, string titleName) : this(new Builder("Ryujinx.Ui.Windows.TitleUpdateWindow.glade"), parent, virtualFileSystem, titleId, titleName) { }
 
-        private TitleUpdateWindow(Builder builder, MainWindow parent, VirtualFileSystem virtualFileSystem, string titleId, string titleName) : base(builder.GetObject("_titleUpdateWindow").Handle)
+        private TitleUpdateWindow(Builder builder, MainWindow parent, VirtualFileSystem virtualFileSystem, string titleId, string titleName) : base(builder.GetRawOwnedObject("_titleUpdateWindow"))
         {
             _parent = parent;
 

Ryujinx/Ui/Windows/UserProfilesManagerWindow.Designer.cs

@@ -52,7 +52,8 @@ namespace Ryujinx.Ui.Windows
             _selectedLabel = new Label("Selected User Profile:")
             {
                 Margin     = 15,
-                Attributes = new AttrList()
+                Attributes = new AttrList(),
+                Halign     = Align.Start
             };
             _selectedLabel.Attributes.Insert(new Pango.AttrWeight(Weight.Bold));
 
@@ -136,7 +137,8 @@ namespace Ryujinx.Ui.Windows
             _availableUsersLabel = new Label("Available User Profiles:")
             {
                 Margin     = 15,
-                Attributes = new AttrList()
+                Attributes = new AttrList(),
+                Halign     = Align.Start
             };
             _availableUsersLabel.Attributes.Insert(new Pango.AttrWeight(Weight.Bold));
 
@@ -226,10 +228,9 @@ namespace Ryujinx.Ui.Windows
             _usersTreeViewWindow.Add(_usersTreeView);
 
             _usersTreeViewBox.Add(_usersTreeViewWindow);
-
-            _bottomBox.PackStart(new Gtk.Alignment(-1, 0, 0, 0) { _addButton }, false, false, 0);
-            _bottomBox.PackStart(new Gtk.Alignment(-1, 0, 0, 0) { _deleteButton }, false, false, 0);
-            _bottomBox.PackEnd(new Gtk.Alignment(1, 0, 0, 0) { _closeButton }, false, false, 0);
+            _bottomBox.PackStart(_addButton, false, false, 0);
+            _bottomBox.PackStart(_deleteButton, false, false, 0);
+            _bottomBox.PackEnd(_closeButton, false, false, 0);
 
             _selectedUserInfoBox.Add(_selectedUserNameEntry);
             _selectedUserInfoBox.Add(_selectedUserIdLabel);
@@ -238,12 +239,12 @@ namespace Ryujinx.Ui.Windows
             _selectedUserButtonsBox.Add(_changeProfileImageButton);
 
             _selectedUserBox.Add(_selectedUserImage);
-            _selectedUserBox.PackStart(new Gtk.Alignment(-1, 0, 0, 0) { _selectedUserInfoBox }, true, true, 0);
-            _selectedUserBox.Add(_selectedUserButtonsBox);
+            _selectedUserBox.PackStart(_selectedUserInfoBox, false, false, 0);
+            _selectedUserBox.PackEnd(_selectedUserButtonsBox, false, false, 0);
 
-            _mainBox.PackStart(new Gtk.Alignment(-1, 0, 0, 0) { _selectedLabel }, false, false, 0);
+            _mainBox.PackStart(_selectedLabel, false, false, 0);
             _mainBox.PackStart(_selectedUserBox, false, true, 0);
-            _mainBox.PackStart(new Gtk.Alignment(-1, 0, 0, 0) { _availableUsersLabel }, false, false, 0);
+            _mainBox.PackStart(_availableUsersLabel, false, false, 0);
             _mainBox.Add(_usersTreeViewBox);
             _mainBox.Add(_bottomBox);