Merge 5e8af26516 into 131fe71205

add ?

src/Ryujinx.Input.SDL2/SDL2GamepadDriver.cs

@@ -1,3 +1,4 @@
+using Ryujinx.Common.Logging;
 using Ryujinx.SDL2.Common;
 using System;
 using System.Collections.Generic;
@@ -36,6 +37,7 @@ namespace Ryujinx.Input.SDL2
             SDL2Driver.Instance.Initialize();
             SDL2Driver.Instance.OnJoyStickConnected += HandleJoyStickConnected;
             SDL2Driver.Instance.OnJoystickDisconnected += HandleJoyStickDisconnected;
+            SDL2Driver.Instance.OnJoyBatteryUpdated += HandleJoyBatteryUpdated;
 
             // Add already connected gamepads
             int numJoysticks = SDL_NumJoysticks();
@@ -83,19 +85,30 @@ namespace Ryujinx.Input.SDL2
 
         private void HandleJoyStickDisconnected(int joystickInstanceId)
         {
+            bool joyConPairDisconnected = false;
             if (!_gamepadsInstanceIdsMapping.Remove(joystickInstanceId, out string id))
                 return;
 
             lock (_lock)
             {
                 _gamepadsIds.Remove(id);
+                if (!SDL2JoyConPair.IsCombinable(_gamepadsIds))
+                {
+                    _gamepadsIds.Remove(SDL2JoyConPair.Id);
+                    joyConPairDisconnected = true;
+                }
             }
 
             OnGamepadDisconnected?.Invoke(id);
+            if (joyConPairDisconnected)
+            {
+                OnGamepadDisconnected?.Invoke(SDL2JoyConPair.Id);
+            }
         }
 
         private void HandleJoyStickConnected(int joystickDeviceId, int joystickInstanceId)
         {
+            bool joyConPairConnected = false;
             if (SDL_IsGameController(joystickDeviceId) == SDL_bool.SDL_TRUE)
             {
                 if (_gamepadsInstanceIdsMapping.ContainsKey(joystickInstanceId))
@@ -120,13 +133,29 @@ namespace Ryujinx.Input.SDL2
                             _gamepadsIds.Insert(joystickDeviceId, id);
                         else
                             _gamepadsIds.Add(id);
+                        if (SDL2JoyConPair.IsCombinable(_gamepadsIds))
+                        {
+                            _gamepadsIds.Remove(SDL2JoyConPair.Id);
+                            _gamepadsIds.Add(SDL2JoyConPair.Id);
+                            joyConPairConnected = true;
+                        }
                     }
 
                     OnGamepadConnected?.Invoke(id);
+                    if (joyConPairConnected)
+                    {
+                        OnGamepadConnected?.Invoke(SDL2JoyConPair.Id);
+                    }
                 }
             }
         }
 
+        private void HandleJoyBatteryUpdated(int joystickDeviceId, SDL_JoystickPowerLevel powerLevel)
+        {
+            Logger.Info?.Print(LogClass.Hid,
+                $"{SDL_GameControllerNameForIndex(joystickDeviceId)} power level: {powerLevel}");
+        }
+
         protected virtual void Dispose(bool disposing)
         {
             if (disposing)
@@ -157,6 +186,14 @@ namespace Ryujinx.Input.SDL2
 
         public IGamepad GetGamepad(string id)
         {
+            if (id == SDL2JoyConPair.Id)
+            {
+                lock (_lock)
+                {
+                    return SDL2JoyConPair.GetGamepad(_gamepadsIds);
+                }
+            }
+
             int joystickIndex = GetJoystickIndexByGamepadId(id);
 
             if (joystickIndex == -1)
@@ -165,12 +202,16 @@ namespace Ryujinx.Input.SDL2
             }
 
             nint gamepadHandle = SDL_GameControllerOpen(joystickIndex);
-
             if (gamepadHandle == nint.Zero)
             {
                 return null;
             }
 
+            if (SDL_GameControllerName(gamepadHandle).StartsWith(SDL2JoyCon.Prefix))
+            {
+                return new SDL2JoyCon(gamepadHandle, id);    
+            }
+
             return new SDL2Gamepad(gamepadHandle, id);
         }
 

src/Ryujinx.Input.SDL2/SDL2JoyCon.cs

@@ -0,0 +1,409 @@
+using Ryujinx.Common.Configuration.Hid;
+using Ryujinx.Common.Configuration.Hid.Controller;
+using Ryujinx.Common.Logging;
+using System;
+using System.Collections.Generic;
+using System.Numerics;
+using System.Threading;
+using static SDL2.SDL;
+
+namespace Ryujinx.Input.SDL2
+{
+    internal class SDL2JoyCon : IGamepad
+    {
+        private bool HasConfiguration => _configuration != null;
+
+        private readonly record struct ButtonMappingEntry(GamepadButtonInputId To, GamepadButtonInputId From)
+        {
+            public bool IsValid => To is not GamepadButtonInputId.Unbound && From is not GamepadButtonInputId.Unbound;
+        }
+
+        private StandardControllerInputConfig _configuration;
+
+        private readonly Dictionary<GamepadButtonInputId,SDL_GameControllerButton> _leftButtonsDriverMapping = new()
+        {
+            { GamepadButtonInputId.LeftStick , SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_LEFTSTICK },
+             {GamepadButtonInputId.DpadUp ,SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_Y},
+             {GamepadButtonInputId.DpadDown ,SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_A},
+             {GamepadButtonInputId.DpadLeft ,SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_B},
+             {GamepadButtonInputId.DpadRight ,SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_X},
+             {GamepadButtonInputId.Minus ,SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_START},
+             {GamepadButtonInputId.LeftShoulder,SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_PADDLE2},
+             {GamepadButtonInputId.LeftTrigger,SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_PADDLE4},
+             {GamepadButtonInputId.SingleRightTrigger0,SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_RIGHTSHOULDER},
+             {GamepadButtonInputId.SingleLeftTrigger0,SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_LEFTSHOULDER},
+        };
+        private readonly Dictionary<GamepadButtonInputId,SDL_GameControllerButton> _rightButtonsDriverMapping = new()
+        {
+             {GamepadButtonInputId.RightStick,SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_LEFTSTICK},
+             {GamepadButtonInputId.A,SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_B},
+             {GamepadButtonInputId.B,SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_Y},
+             {GamepadButtonInputId.X,SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_A},
+             {GamepadButtonInputId.Y,SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_X},
+             {GamepadButtonInputId.Plus,SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_START},
+             {GamepadButtonInputId.RightShoulder,SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_PADDLE1},
+             {GamepadButtonInputId.RightTrigger,SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_PADDLE3},
+             {GamepadButtonInputId.SingleRightTrigger1,SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_RIGHTSHOULDER},
+             {GamepadButtonInputId.SingleLeftTrigger1,SDL_GameControllerButton.SDL_CONTROLLER_BUTTON_LEFTSHOULDER}
+        };
+
+        private readonly Dictionary<GamepadButtonInputId, SDL_GameControllerButton> _buttonsDriverMapping;
+        private readonly Lock _userMappingLock = new();
+
+        private readonly List<ButtonMappingEntry> _buttonsUserMapping;
+
+        private readonly StickInputId[] _stickUserMapping = new StickInputId[(int)StickInputId.Count]
+        {
+            StickInputId.Unbound, StickInputId.Left, StickInputId.Right,
+        };
+
+        public GamepadFeaturesFlag Features { get; }
+
+        private nint _gamepadHandle;
+
+        private enum JoyConType
+        {
+            Left, Right
+        }
+
+        public const string Prefix = "Nintendo Switch Joy-Con";
+        public const string LeftName = "Nintendo Switch Joy-Con (L)";
+        public const string RightName = "Nintendo Switch Joy-Con (R)";
+
+        private readonly JoyConType _joyConType;
+
+        public SDL2JoyCon(nint gamepadHandle, string driverId)
+        {
+            _gamepadHandle = gamepadHandle;
+            _buttonsUserMapping = new List<ButtonMappingEntry>(10);
+
+            Name = SDL_GameControllerName(_gamepadHandle);
+            Id = driverId;
+            Features = GetFeaturesFlag();
+
+            // Enable motion tracking
+            if (Features.HasFlag(GamepadFeaturesFlag.Motion))
+            {
+                if (SDL_GameControllerSetSensorEnabled(_gamepadHandle, SDL_SensorType.SDL_SENSOR_ACCEL,
+                        SDL_bool.SDL_TRUE) != 0)
+                {
+                    Logger.Error?.Print(LogClass.Hid,
+                        $"Could not enable data reporting for SensorType {SDL_SensorType.SDL_SENSOR_ACCEL}.");
+                }
+
+                if (SDL_GameControllerSetSensorEnabled(_gamepadHandle, SDL_SensorType.SDL_SENSOR_GYRO,
+                        SDL_bool.SDL_TRUE) != 0)
+                {
+                    Logger.Error?.Print(LogClass.Hid,
+                        $"Could not enable data reporting for SensorType {SDL_SensorType.SDL_SENSOR_GYRO}.");
+                }
+            }
+
+            switch (Name)
+            {
+                case LeftName:
+                    {
+                        _buttonsDriverMapping = _leftButtonsDriverMapping;
+                        _joyConType = JoyConType.Left;
+                        break;
+                    }
+                case RightName:
+                    {
+                        _buttonsDriverMapping = _rightButtonsDriverMapping;
+                        _joyConType = JoyConType.Right;
+                        break;
+                    }
+            }
+        }
+
+        private GamepadFeaturesFlag GetFeaturesFlag()
+        {
+            GamepadFeaturesFlag result = GamepadFeaturesFlag.None;
+
+            if (SDL_GameControllerHasSensor(_gamepadHandle, SDL_SensorType.SDL_SENSOR_ACCEL) == SDL_bool.SDL_TRUE &&
+                SDL_GameControllerHasSensor(_gamepadHandle, SDL_SensorType.SDL_SENSOR_GYRO) == SDL_bool.SDL_TRUE)
+            {
+                result |= GamepadFeaturesFlag.Motion;
+            }
+
+            int error = SDL_GameControllerRumble(_gamepadHandle, 0, 0, 100);
+
+            if (error == 0)
+            {
+                result |= GamepadFeaturesFlag.Rumble;
+            }
+
+            return result;
+        }
+
+        public string Id { get; }
+        public string Name { get; }
+        public bool IsConnected => SDL_GameControllerGetAttached(_gamepadHandle) == SDL_bool.SDL_TRUE;
+
+        protected virtual void Dispose(bool disposing)
+        {
+            if (disposing && _gamepadHandle != nint.Zero)
+            {
+                SDL_GameControllerClose(_gamepadHandle);
+
+                _gamepadHandle = nint.Zero;
+            }
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+        }
+
+
+        public void SetTriggerThreshold(float triggerThreshold)
+        {
+
+        }
+
+        public void Rumble(float lowFrequency, float highFrequency, uint durationMs)
+        {
+            if (!Features.HasFlag(GamepadFeaturesFlag.Rumble))
+                return;
+
+            ushort lowFrequencyRaw = (ushort)(lowFrequency * ushort.MaxValue);
+            ushort highFrequencyRaw = (ushort)(highFrequency * ushort.MaxValue);
+
+            if (durationMs == uint.MaxValue)
+            {
+                if (SDL_GameControllerRumble(_gamepadHandle, lowFrequencyRaw, highFrequencyRaw, SDL_HAPTIC_INFINITY) !=
+                    0)
+                    Logger.Error?.Print(LogClass.Hid, "Rumble is not supported on this game controller.");
+            }
+            else if (durationMs > SDL_HAPTIC_INFINITY)
+            {
+                Logger.Error?.Print(LogClass.Hid, $"Unsupported rumble duration {durationMs}");
+            }
+            else
+            {
+                if (SDL_GameControllerRumble(_gamepadHandle, lowFrequencyRaw, highFrequencyRaw, durationMs) != 0)
+                    Logger.Error?.Print(LogClass.Hid, "Rumble is not supported on this game controller.");
+            }
+        }
+
+        public Vector3 GetMotionData(MotionInputId inputId)
+        {
+            SDL_SensorType sensorType = inputId switch
+            {
+                MotionInputId.Accelerometer => SDL_SensorType.SDL_SENSOR_ACCEL,
+                MotionInputId.Gyroscope => SDL_SensorType.SDL_SENSOR_GYRO,
+                _ => SDL_SensorType.SDL_SENSOR_INVALID
+            };
+
+            if (!Features.HasFlag(GamepadFeaturesFlag.Motion) || sensorType is SDL_SensorType.SDL_SENSOR_INVALID)
+                return Vector3.Zero;
+
+            const int ElementCount = 3;
+
+            unsafe
+            {
+                float* values = stackalloc float[ElementCount];
+
+                int result = SDL_GameControllerGetSensorData(_gamepadHandle, sensorType, (nint)values, ElementCount);
+
+                if (result != 0)
+                    return Vector3.Zero;
+
+                Vector3 value = _joyConType switch
+                {
+                    JoyConType.Left => new Vector3(-values[2], values[1], values[0]),
+                    JoyConType.Right => new Vector3(values[2], values[1], -values[0])
+                };
+
+                return inputId switch
+                {
+                    MotionInputId.Gyroscope => RadToDegree(value),
+                    MotionInputId.Accelerometer => GsToMs2(value),
+                    _ => value
+                };
+            }
+        }
+
+        private static Vector3 RadToDegree(Vector3 rad) => rad * (180 / MathF.PI);
+
+        private static Vector3 GsToMs2(Vector3 gs) => gs / SDL_STANDARD_GRAVITY;
+
+        public void SetConfiguration(InputConfig configuration)
+        {
+            lock (_userMappingLock)
+            {
+                _configuration = (StandardControllerInputConfig)configuration;
+
+                _buttonsUserMapping.Clear();
+
+                // First update sticks
+                _stickUserMapping[(int)StickInputId.Left] = (StickInputId)_configuration.LeftJoyconStick.Joystick;
+                _stickUserMapping[(int)StickInputId.Right] = (StickInputId)_configuration.RightJoyconStick.Joystick;
+
+
+                switch (_joyConType)
+                {
+                    case JoyConType.Left:
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.LeftStick, (GamepadButtonInputId)_configuration.LeftJoyconStick.StickButton));
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.DpadUp, (GamepadButtonInputId)_configuration.LeftJoycon.DpadUp));
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.DpadDown, (GamepadButtonInputId)_configuration.LeftJoycon.DpadDown));
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.DpadLeft, (GamepadButtonInputId)_configuration.LeftJoycon.DpadLeft));
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.DpadRight, (GamepadButtonInputId)_configuration.LeftJoycon.DpadRight));
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.Minus, (GamepadButtonInputId)_configuration.LeftJoycon.ButtonMinus));
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.LeftShoulder, (GamepadButtonInputId)_configuration.LeftJoycon.ButtonL));
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.LeftTrigger, (GamepadButtonInputId)_configuration.LeftJoycon.ButtonZl));
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.SingleRightTrigger0, (GamepadButtonInputId)_configuration.LeftJoycon.ButtonSr));
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.SingleLeftTrigger0, (GamepadButtonInputId)_configuration.LeftJoycon.ButtonSl));
+                        break;
+                    case JoyConType.Right:
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.RightStick, (GamepadButtonInputId)_configuration.RightJoyconStick.StickButton));
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.A, (GamepadButtonInputId)_configuration.RightJoycon.ButtonA));
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.B, (GamepadButtonInputId)_configuration.RightJoycon.ButtonB));
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.X, (GamepadButtonInputId)_configuration.RightJoycon.ButtonX));
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.Y, (GamepadButtonInputId)_configuration.RightJoycon.ButtonY));
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.Plus, (GamepadButtonInputId)_configuration.RightJoycon.ButtonPlus));
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.RightShoulder, (GamepadButtonInputId)_configuration.RightJoycon.ButtonR));
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.RightTrigger, (GamepadButtonInputId)_configuration.RightJoycon.ButtonZr));
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.SingleRightTrigger1, (GamepadButtonInputId)_configuration.RightJoycon.ButtonSr));
+                        _buttonsUserMapping.Add(new ButtonMappingEntry(GamepadButtonInputId.SingleLeftTrigger1, (GamepadButtonInputId)_configuration.RightJoycon.ButtonSl));
+                        break;
+                    default:
+                        throw new ArgumentOutOfRangeException();
+                }
+                
+                SetTriggerThreshold(_configuration.TriggerThreshold);
+            }
+        }
+
+        public GamepadStateSnapshot GetStateSnapshot()
+        {
+            return IGamepad.GetStateSnapshot(this);
+        }
+
+        public GamepadStateSnapshot GetMappedStateSnapshot()
+        {
+            GamepadStateSnapshot rawState = GetStateSnapshot();
+            GamepadStateSnapshot result = default;
+
+            lock (_userMappingLock)
+            {
+                if (_buttonsUserMapping.Count == 0)
+                    return rawState;
+
+
+                // ReSharper disable once ForeachCanBePartlyConvertedToQueryUsingAnotherGetEnumerator
+                foreach (ButtonMappingEntry entry in _buttonsUserMapping)
+                {
+                    if (!entry.IsValid)
+                        continue;
+
+                    // Do not touch state of button already pressed
+                    if (!result.IsPressed(entry.To))
+                    {
+                        result.SetPressed(entry.To, rawState.IsPressed(entry.From));
+                    }
+                }
+
+                (float leftStickX, float leftStickY) = rawState.GetStick(_stickUserMapping[(int)StickInputId.Left]);
+                (float rightStickX, float rightStickY) = rawState.GetStick(_stickUserMapping[(int)StickInputId.Right]);
+
+                result.SetStick(StickInputId.Left, leftStickX, leftStickY);
+                result.SetStick(StickInputId.Right, rightStickX, rightStickY);
+            }
+
+            return result;
+        }
+
+
+        private static float ConvertRawStickValue(short value)
+        {
+            const float ConvertRate = 1.0f / (short.MaxValue + 0.5f);
+
+            return value * ConvertRate;
+        }
+
+        private JoyconConfigControllerStick<GamepadInputId, Common.Configuration.Hid.Controller.StickInputId>
+            GetLogicalJoyStickConfig(StickInputId inputId)
+        {
+            switch (inputId)
+            {
+                case StickInputId.Left:
+                    if (_configuration.RightJoyconStick.Joystick ==
+                        Common.Configuration.Hid.Controller.StickInputId.Left)
+                        return _configuration.RightJoyconStick;
+                    else
+                        return _configuration.LeftJoyconStick;
+                case StickInputId.Right:
+                    if (_configuration.LeftJoyconStick.Joystick ==
+                        Common.Configuration.Hid.Controller.StickInputId.Right)
+                        return _configuration.LeftJoyconStick;
+                    else
+                        return _configuration.RightJoyconStick;
+            }
+
+            return null;
+        }
+
+
+        public (float, float) GetStick(StickInputId inputId)
+        {
+            if (inputId == StickInputId.Unbound)
+                return (0.0f, 0.0f);
+
+            if (inputId == StickInputId.Left && _joyConType == JoyConType.Right || inputId == StickInputId.Right && _joyConType == JoyConType.Left)
+            {
+                return (0.0f, 0.0f);
+            }
+            
+            (short stickX, short stickY) = GetStickXY();
+
+            float resultX = ConvertRawStickValue(stickX);
+            float resultY = -ConvertRawStickValue(stickY);
+
+            if (HasConfiguration)
+            {
+                var joyconStickConfig = GetLogicalJoyStickConfig(inputId);
+
+                if (joyconStickConfig != null)
+                {
+                    if (joyconStickConfig.InvertStickX)
+                        resultX = -resultX;
+
+                    if (joyconStickConfig.InvertStickY)
+                        resultY = -resultY;
+
+                    if (joyconStickConfig.Rotate90CW)
+                    {
+                        float temp = resultX;
+                        resultX = resultY;
+                        resultY = -temp;
+                    }
+                }
+            }
+
+            return inputId switch
+            {
+                StickInputId.Left when _joyConType == JoyConType.Left => (resultY, -resultX),
+                StickInputId.Right when _joyConType == JoyConType.Right => (-resultY, resultX),
+                _ => (0.0f, 0.0f)
+            };
+        }
+
+        private (short, short) GetStickXY()
+        {
+            return (
+                SDL_GameControllerGetAxis(_gamepadHandle, SDL_GameControllerAxis.SDL_CONTROLLER_AXIS_LEFTX),
+                SDL_GameControllerGetAxis(_gamepadHandle, SDL_GameControllerAxis.SDL_CONTROLLER_AXIS_LEFTY));
+        }
+        
+        public bool IsPressed(GamepadButtonInputId inputId)
+        {
+            if (!_buttonsDriverMapping.TryGetValue(inputId, out var button))
+            {
+                return false;
+            }
+
+            return SDL_GameControllerGetButton(_gamepadHandle, button) == 1;
+        }
+    }
+}

src/Ryujinx.Input.SDL2/SDL2JoyConPair.cs

@@ -0,0 +1,142 @@
+using Ryujinx.Common.Configuration.Hid;
+using Ryujinx.Common.Configuration.Hid.Controller;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Numerics;
+using static SDL2.SDL;
+
+namespace Ryujinx.Input.SDL2
+{
+    internal class SDL2JoyConPair(IGamepad left, IGamepad right) : IGamepad
+    {
+        private StandardControllerInputConfig _configuration;
+
+        private readonly StickInputId[] _stickUserMapping =
+        [
+            StickInputId.Unbound,
+            StickInputId.Left,
+            StickInputId.Right
+        ];
+
+        public GamepadFeaturesFlag Features => (left?.Features ?? GamepadFeaturesFlag.None) |
+                                               (right?.Features ?? GamepadFeaturesFlag.None);
+
+        public const string Id = "JoyConPair";
+        string IGamepad.Id => Id;
+
+        public string Name => "* Nintendo Switch Joy-Con (L/R)";
+        public bool IsConnected => left is { IsConnected: true } && right is { IsConnected: true };
+
+        public void Dispose()
+        {
+            left?.Dispose();
+            right?.Dispose();
+        }
+
+        public GamepadStateSnapshot GetMappedStateSnapshot()
+        {
+            return GetStateSnapshot();
+        }
+
+        public Vector3 GetMotionData(MotionInputId inputId)
+        {
+            return inputId switch
+            {
+                MotionInputId.Accelerometer or
+                    MotionInputId.Gyroscope => left.GetMotionData(inputId),
+                MotionInputId.SecondAccelerometer => right.GetMotionData(MotionInputId.Accelerometer),
+                MotionInputId.SecondGyroscope => right.GetMotionData(MotionInputId.Gyroscope),
+                _ => Vector3.Zero
+            };
+        }
+
+        public GamepadStateSnapshot GetStateSnapshot()
+        {
+            return IGamepad.GetStateSnapshot(this);
+        }
+
+        public (float, float) GetStick(StickInputId inputId)
+        {
+            return inputId switch
+            {
+                StickInputId.Left => left.GetStick(StickInputId.Left),
+                StickInputId.Right => right.GetStick(StickInputId.Right),
+                _ => (0, 0)
+            };
+        }
+
+        public bool IsPressed(GamepadButtonInputId inputId)
+        {
+            return left.IsPressed(inputId) || right.IsPressed(inputId);
+        }
+
+        public void Rumble(float lowFrequency, float highFrequency, uint durationMs)
+        {
+            if (lowFrequency != 0)
+            {
+                right.Rumble(lowFrequency, lowFrequency, durationMs);
+            }
+
+            if (highFrequency != 0)
+            {
+                left.Rumble(highFrequency, highFrequency, durationMs);
+            }
+
+            if (lowFrequency == 0 && highFrequency == 0)
+            {
+                left.Rumble(0, 0, durationMs);
+                right.Rumble(0, 0, durationMs);
+            }
+        }
+
+        public void SetConfiguration(InputConfig configuration)
+        {
+            left.SetConfiguration(configuration);
+            right.SetConfiguration(configuration);
+        }
+
+        public void SetTriggerThreshold(float triggerThreshold)
+        {
+            left.SetTriggerThreshold(triggerThreshold);
+            right.SetTriggerThreshold(triggerThreshold);
+        }
+
+        public static bool IsCombinable(List<string> gamepadsIds)
+        {
+            (int leftIndex, int rightIndex) = DetectJoyConPair(gamepadsIds);
+            return leftIndex >= 0 && rightIndex >= 0;
+        }
+
+        private static (int leftIndex, int rightIndex) DetectJoyConPair(List<string> gamepadsIds)
+        {
+            var gamepadNames = gamepadsIds.Where(gamepadId => gamepadId != Id)
+                .Select((_, index) => SDL_GameControllerNameForIndex(index)).ToList();
+            int leftIndex = gamepadNames.IndexOf(SDL2JoyCon.LeftName);
+            int rightIndex = gamepadNames.IndexOf(SDL2JoyCon.RightName);
+
+            return (leftIndex, rightIndex);
+        }
+
+        public static IGamepad GetGamepad(List<string> gamepadsIds)
+        {
+            (int leftIndex, int rightIndex) = DetectJoyConPair(gamepadsIds);
+            if (leftIndex == -1 || rightIndex == -1)
+            {
+                return null;
+            }
+
+            nint leftGamepadHandle = SDL_GameControllerOpen(leftIndex);
+            nint rightGamepadHandle = SDL_GameControllerOpen(rightIndex);
+
+            if (leftGamepadHandle == nint.Zero || rightGamepadHandle == nint.Zero)
+            {
+                return null;
+            }
+
+
+            return new SDL2JoyConPair(new SDL2JoyCon(leftGamepadHandle, gamepadsIds[leftIndex]),
+                new SDL2JoyCon(rightGamepadHandle, gamepadsIds[rightIndex]));
+        }
+    }
+}

src/Ryujinx.Input/HLE/NpadController.cs

@@ -269,6 +269,7 @@ namespace Ryujinx.Input.HLE
             if (motionConfig.MotionBackend != MotionInputBackendType.CemuHook)
             {
                 _leftMotionInput = new MotionInput();
+                _rightMotionInput = new MotionInput();
             }
             else
             {
@@ -301,7 +302,20 @@ namespace Ryujinx.Input.HLE
 
                             if (controllerConfig.ControllerType == ConfigControllerType.JoyconPair)
                             {
-                                _rightMotionInput = _leftMotionInput;
+                                if (gamepad.Id== "JoyConPair")
+                                {
+                                    Vector3 rightAccelerometer = gamepad.GetMotionData(MotionInputId.SecondAccelerometer);
+                                    Vector3 rightGyroscope = gamepad.GetMotionData(MotionInputId.SecondGyroscope);
+
+                                    rightAccelerometer = new Vector3(rightAccelerometer.X, -rightAccelerometer.Z, rightAccelerometer.Y);
+                                    rightGyroscope = new Vector3(rightGyroscope.X, -rightGyroscope.Z, rightGyroscope.Y);
+
+                                    _rightMotionInput.Update(rightAccelerometer, rightGyroscope, (ulong)PerformanceCounter.ElapsedNanoseconds / 1000, controllerConfig.Motion.Sensitivity, (float)controllerConfig.Motion.GyroDeadzone);
+                                }
+                                else
+                                {
+                                    _rightMotionInput = _leftMotionInput;
+                                }
                             }
                         }
                     }
@@ -336,6 +350,7 @@ namespace Ryujinx.Input.HLE
                 // Reset states
                 State = default;
                 _leftMotionInput = null;
+                _rightMotionInput = null;
             }
         }
 

src/Ryujinx.Input/MotionInputId.cs

@@ -21,5 +21,17 @@ namespace Ryujinx.Input
         /// </summary>
         /// <remarks>Values are in degrees</remarks>
         Gyroscope,
+
+        /// <summary>
+        /// Second accelerometer.
+        /// </summary>
+        /// <remarks>Values are in m/s^2</remarks>
+        SecondAccelerometer,
+
+        /// <summary>
+        /// Second gyroscope.
+        /// </summary>
+        /// <remarks>Values are in degrees</remarks>
+        SecondGyroscope
     }
 }

src/Ryujinx.SDL2.Common/SDL2Driver.cs

@@ -25,14 +25,17 @@ namespace Ryujinx.SDL2.Common
 
         public static Action<Action> MainThreadDispatcher { get; set; }
 
-        private const uint SdlInitFlags = SDL_INIT_EVENTS | SDL_INIT_GAMECONTROLLER | SDL_INIT_JOYSTICK | SDL_INIT_AUDIO | SDL_INIT_VIDEO;
+        private const uint SdlInitFlags = SDL_INIT_EVENTS | SDL_INIT_GAMECONTROLLER | SDL_INIT_JOYSTICK |
+                                          SDL_INIT_AUDIO | SDL_INIT_VIDEO;
 
         private bool _isRunning;
         private uint _refereceCount;
         private Thread _worker;
 
+        private const uint SDL_JOYBATTERYUPDATED = 1543;
         public event Action<int, int> OnJoyStickConnected;
         public event Action<int> OnJoystickDisconnected;
+        public event Action<int, SDL_JoystickPowerLevel> OnJoyBatteryUpdated;
 
         private ConcurrentDictionary<uint, Action<SDL_Event>> _registeredWindowHandlers;
 
@@ -78,12 +81,14 @@ namespace Ryujinx.SDL2.Common
                 // First ensure that we only enable joystick events (for connected/disconnected).
                 if (SDL_GameControllerEventState(SDL_IGNORE) != SDL_IGNORE)
                 {
-                    Logger.Error?.PrintMsg(LogClass.Application, "Couldn't change the state of game controller events.");
+                    Logger.Error?.PrintMsg(LogClass.Application,
+                        "Couldn't change the state of game controller events.");
                 }
 
                 if (SDL_JoystickEventState(SDL_ENABLE) < 0)
                 {
-                    Logger.Error?.PrintMsg(LogClass.Application, $"Failed to enable joystick event polling: {SDL_GetError()}");
+                    Logger.Error?.PrintMsg(LogClass.Application,
+                        $"Failed to enable joystick event polling: {SDL_GetError()}");
                 }
 
                 // Disable all joysticks information, we don't need them no need to flood the event queue for that.
@@ -143,7 +148,12 @@ namespace Ryujinx.SDL2.Common
 
                 OnJoystickDisconnected?.Invoke(evnt.cbutton.which);
             }
-            else if (evnt.type is SDL_EventType.SDL_WINDOWEVENT or SDL_EventType.SDL_MOUSEBUTTONDOWN or SDL_EventType.SDL_MOUSEBUTTONUP)
+            else if ((uint)evnt.type == SDL_JOYBATTERYUPDATED)
+            {
+                OnJoyBatteryUpdated?.Invoke(evnt.cbutton.which, (SDL_JoystickPowerLevel)evnt.user.code);
+            }
+            else if (evnt.type is SDL_EventType.SDL_WINDOWEVENT or SDL_EventType.SDL_MOUSEBUTTONDOWN
+                     or SDL_EventType.SDL_MOUSEBUTTONUP)
             {
                 if (_registeredWindowHandlers.TryGetValue(evnt.window.windowID, out Action<SDL_Event> handler))
                 {

src/Ryujinx/Assets/locales.json

@@ -584,7 +584,7 @@
         "he_IL": "",
         "it_IT": "",
         "ja_JP": "",
-        "ko_KR": "",
+        "ko_KR": "UI를 숨긴 상태에서 게임 시작",
         "no_NO": "",
         "pl_PL": "",
         "pt_BR": "",
@@ -1524,6 +1524,156 @@
     },
     {
       "ID": "GameListHeaderDeveloper",
+      "Translations": {
+        "ar_SA": "",
+        "de_DE": "",
+        "el_GR": "",
+        "en_US": "Developed by {0}",
+        "es_ES": "",
+        "fr_FR": "",
+        "he_IL": "",
+        "it_IT": "",
+        "ja_JP": "",
+        "ko_KR": "",
+        "no_NO": "",
+        "pl_PL": "",
+        "pt_BR": "",
+        "ru_RU": "",
+        "sv_SE": "",
+        "th_TH": "",
+        "tr_TR": "",
+        "uk_UA": "",
+        "zh_CN": "",
+        "zh_TW": ""
+      }
+    },
+    {
+      "ID": "GameListHeaderVersion",
+      "Translations": {
+        "ar_SA": "",
+        "de_DE": "",
+        "el_GR": "Έκδοση: {0}",
+        "en_US": "Version: {0}",
+        "es_ES": "Versión: {0}",
+        "fr_FR": "",
+        "he_IL": "",
+        "it_IT": "Versione: {0}",
+        "ja_JP": "バージョン: {0}",
+        "ko_KR": "버전: {0}",
+        "no_NO": "Versjon: {0}",
+        "pl_PL": "Wersja: {0}",
+        "pt_BR": "Versão: {0}",
+        "ru_RU": "Версия: {0}",
+        "sv_SE": "",
+        "th_TH": "เวอร์ชั่น: {0}",
+        "tr_TR": "Sürüm: {0}",
+        "uk_UA": "Версія: {0}",
+        "zh_CN": "版本: {0}",
+        "zh_TW": "版本: {0}"
+      }
+    },
+    {
+      "ID": "GameListHeaderTimePlayed",
+      "Translations": {
+        "ar_SA": "",
+        "de_DE": "Spielzeit: {0}",
+        "el_GR": "Χρόνος: {0}",
+        "en_US": "Play Time: {0}",
+        "es_ES": "Tiempo jugado: {0}",
+        "fr_FR": "Temps de jeu: {0}",
+        "he_IL": "",
+        "it_IT": "Tempo di gioco: {0}",
+        "ja_JP": "プレイ時間: {0}",
+        "ko_KR": "플레이 타임: {0}",
+        "no_NO": "Spilletid: {0}",
+        "pl_PL": "Czas w grze: {0}",
+        "pt_BR": "Tempo de jogo: {0}",
+        "ru_RU": "Время в игре: {0}",
+        "sv_SE": "Speltid: {0}",
+        "th_TH": "เล่นไปแล้ว: {0}",
+        "tr_TR": "Oynama Süresi: {0}",
+        "uk_UA": "Зіграно часу: {0}",
+        "zh_CN": "游玩时长: {0}",
+        "zh_TW": "遊玩時數: {0}"
+      }
+    },
+    {
+      "ID": "GameListHeaderLastPlayed",
+      "Translations": {
+        "ar_SA": "",
+        "de_DE": "Zuletzt gespielt: {0}",
+        "el_GR": "Παίχτηκε: {0}",
+        "en_US": "Last Played: {0}",
+        "es_ES": "Jugado por última vez: {0}",
+        "fr_FR": "Dernière partie jouée: {0}",
+        "he_IL": "",
+        "it_IT": "Ultima partita: {0}",
+        "ja_JP": "最終プレイ日時: {0}",
+        "ko_KR": "마지막 플레이: {0}",
+        "no_NO": "Sist Spilt: {0}",
+        "pl_PL": "Ostatnio grane: {0}",
+        "pt_BR": "Último jogo: {0}",
+        "ru_RU": "Последний запуск: {0}",
+        "sv_SE": "Senast spelad: {0}",
+        "th_TH": "เล่นล่าสุด: {0}",
+        "tr_TR": "Son Oynama Tarihi: {0}",
+        "uk_UA": "Востаннє зіграно: {0}",
+        "zh_CN": "最近游玩: {0}",
+        "zh_TW": "最近遊玩: {0}"
+      }
+    },
+    {
+      "ID": "GameListHeaderFileExtension",
+      "Translations": {
+        "ar_SA": "",
+        "de_DE": "Dateiformat: {0}",
+        "el_GR": "Κατάληξη: {0}",
+        "en_US": "Extension: {0}",
+        "es_ES": "Extensión: {0}",
+        "fr_FR": "Extension du Fichier: {0}",
+        "he_IL": "",
+        "it_IT": "Estensione: {0}",
+        "ja_JP": "ファイル拡張子: {0}",
+        "ko_KR": "파일 확장자: {0}",
+        "no_NO": "Fil Eks.: {0}",
+        "pl_PL": "Rozszerzenie pliku: {0}",
+        "pt_BR": "Extensão: {0}",
+        "ru_RU": "Расширение файла: {0}",
+        "sv_SE": "Filänd: {0}",
+        "th_TH": "นามสกุลไฟล์: {0}",
+        "tr_TR": "Dosya Uzantısı: {0}",
+        "uk_UA": "Розширення файлу: {0}",
+        "zh_CN": "扩展名: {0}",
+        "zh_TW": "副檔名: {0}"
+      }
+    },
+    {
+      "ID": "GameListHeaderFileSize",
+      "Translations": {
+        "ar_SA": "",
+        "de_DE": "Dateigröße: {0}",
+        "el_GR": "Μέγεθος Αρχείου: {0}",
+        "en_US": "File Size: {0}",
+        "es_ES": "Tamaño del archivo: {0}",
+        "fr_FR": "Taille du Fichier: {0}",
+        "he_IL": "",
+        "it_IT": "Dimensione file: {0}",
+        "ja_JP": "ファイルサイズ: {0}",
+        "ko_KR": "파일 크기: {0}",
+        "no_NO": "Fil Størrelse: {0}",
+        "pl_PL": "Rozmiar pliku: {0}",
+        "pt_BR": "Tamanho: {0}",
+        "ru_RU": "Размер файла: {0}",
+        "sv_SE": "Filstorlek: {0}",
+        "th_TH": "ขนาดไฟล์: {0}",
+        "tr_TR": "Dosya Boyutu: {0}",
+        "uk_UA": "Розмір файлу: {0}",
+        "zh_CN": "大小: {0}",
+        "zh_TW": "檔案大小: {0}"
+      }
+    },
+    {
+      "ID": "GameListSortDeveloper",
       "Translations": {
         "ar_SA": "المطور",
         "de_DE": "Entwickler",
@@ -1548,32 +1698,7 @@
       }
     },
     {
-      "ID": "GameListHeaderVersion",
-      "Translations": {
-        "ar_SA": "الإصدار",
-        "de_DE": "",
-        "el_GR": "Έκδοση",
-        "en_US": "Version",
-        "es_ES": "Versión",
-        "fr_FR": "",
-        "he_IL": "גרסה",
-        "it_IT": "Versione",
-        "ja_JP": "バージョン",
-        "ko_KR": "버전",
-        "no_NO": "Versjon",
-        "pl_PL": "Wersja",
-        "pt_BR": "Versão",
-        "ru_RU": "Версия",
-        "sv_SE": "",
-        "th_TH": "เวอร์ชั่น",
-        "tr_TR": "Sürüm",
-        "uk_UA": "Версія",
-        "zh_CN": "版本",
-        "zh_TW": "版本"
-      }
-    },
-    {
-      "ID": "GameListHeaderTimePlayed",
+      "ID": "GameListSortTimePlayed",
       "Translations": {
         "ar_SA": "وقت اللعب",
         "de_DE": "Spielzeit",
@@ -1598,7 +1723,7 @@
       }
     },
     {
-      "ID": "GameListHeaderLastPlayed",
+      "ID": "GameListSortLastPlayed",
       "Translations": {
         "ar_SA": "آخر مرة لُعبت",
         "de_DE": "Zuletzt gespielt",
@@ -1623,7 +1748,7 @@
       }
     },
     {
-      "ID": "GameListHeaderFileExtension",
+      "ID": "GameListSortFileExtension",
       "Translations": {
         "ar_SA": "صيغة الملف",
         "de_DE": "Dateiformat",
@@ -1648,7 +1773,7 @@
       }
     },
     {
-      "ID": "GameListHeaderFileSize",
+      "ID": "GameListSortFileSize",
       "Translations": {
         "ar_SA": "حجم الملف",
         "de_DE": "Dateigröße",
@@ -1673,7 +1798,7 @@
       }
     },
     {
-      "ID": "GameListHeaderPath",
+      "ID": "GameListSortPath",
       "Translations": {
         "ar_SA": "المسار",
         "de_DE": "Pfad",
@@ -1697,6 +1822,106 @@
         "zh_TW": "路徑"
       }
     },
+    {
+      "ID": "GameListHeaderCompatibilityStatus",
+      "Translations": {
+        "ar_SA": "",
+        "de_DE": "",
+        "el_GR": "",
+        "en_US": "Compatibility:",
+        "es_ES": "",
+        "fr_FR": "",
+        "he_IL": "",
+        "it_IT": "",
+        "ja_JP": "",
+        "ko_KR": "",
+        "no_NO": "",
+        "pl_PL": "",
+        "pt_BR": "",
+        "ru_RU": "",
+        "sv_SE": "",
+        "th_TH": "",
+        "tr_TR": "",
+        "uk_UA": "",
+        "zh_CN": "",
+        "zh_TW": ""
+      }
+    },
+    {
+      "ID": "GameListHeaderTitleId",
+      "Translations": {
+        "ar_SA": "",
+        "de_DE": "",
+        "el_GR": "",
+        "en_US": "Title ID:",
+        "es_ES": "",
+        "fr_FR": "",
+        "he_IL": "",
+        "it_IT": "",
+        "ja_JP": "",
+        "ko_KR": "",
+        "no_NO": "",
+        "pl_PL": "",
+        "pt_BR": "",
+        "ru_RU": "",
+        "sv_SE": "",
+        "th_TH": "",
+        "tr_TR": "",
+        "uk_UA": "",
+        "zh_CN": "",
+        "zh_TW": ""
+      }
+    },
+    {
+      "ID": "GameListHeaderHostedGames",
+      "Translations": {
+        "ar_SA": "",
+        "de_DE": "",
+        "el_GR": "",
+        "en_US": "Hosted Games: {0}",
+        "es_ES": "",
+        "fr_FR": "",
+        "he_IL": "",
+        "it_IT": "",
+        "ja_JP": "",
+        "ko_KR": "",
+        "no_NO": "",
+        "pl_PL": "",
+        "pt_BR": "",
+        "ru_RU": "",
+        "sv_SE": "",
+        "th_TH": "",
+        "tr_TR": "",
+        "uk_UA": "",
+        "zh_CN": "",
+        "zh_TW": ""
+      }
+    },
+    {
+      "ID": "GameListHeaderPlayerCount",
+      "Translations": {
+        "ar_SA": "",
+        "de_DE": "",
+        "el_GR": "",
+        "en_US": "Online Players: {0}",
+        "es_ES": "",
+        "fr_FR": "",
+        "he_IL": "",
+        "it_IT": "",
+        "ja_JP": "",
+        "ko_KR": "",
+        "no_NO": "",
+        "pl_PL": "",
+        "pt_BR": "",
+        "ru_RU": "",
+        "sv_SE": "",
+        "th_TH": "",
+        "tr_TR": "",
+        "uk_UA": "",
+        "zh_CN": "",
+        "zh_TW": ""
+      }
+    },
     {
       "ID": "GameListContextMenuOpenUserSaveDirectory",
       "Translations": {
@@ -2034,7 +2259,7 @@
         "he_IL": "",
         "it_IT": "",
         "ja_JP": "",
-        "ko_KR": "",
+        "ko_KR": "PPTC 캐시 제거",
         "no_NO": "",
         "pl_PL": "",
         "pt_BR": "",
@@ -2059,7 +2284,7 @@
         "he_IL": "",
         "it_IT": "",
         "ja_JP": "",
-        "ko_KR": "",
+        "ko_KR": "앱의 모든 PPTC 캐시 파일 삭제",
         "no_NO": "",
         "pl_PL": "",
         "pt_BR": "",
@@ -2384,7 +2609,7 @@
         "he_IL": "",
         "it_IT": "",
         "ja_JP": "",
-        "ko_KR": "",
+        "ko_KR": "선택한 DLC 파일에서 RomFS 추출",
         "no_NO": "Pakk ut RomFS filene fra valgt DLC fil",
         "pl_PL": "",
         "pt_BR": "",
@@ -2534,7 +2759,7 @@
         "he_IL": "",
         "it_IT": "",
         "ja_JP": "",
-        "ko_KR": "",
+        "ko_KR": "호환성 항목 표시",
         "no_NO": "",
         "pl_PL": "",
         "pt_BR": "",
@@ -2559,7 +2784,7 @@
         "he_IL": "",
         "it_IT": "",
         "ja_JP": "",
-        "ko_KR": "",
+        "ko_KR": "일반적으로 도움말 메뉴를 통해 접근할 수 있는 호환성 목록에 선택한 게임을 표시합니다.",
         "no_NO": "",
         "pl_PL": "",
         "pt_BR": "",
@@ -2578,13 +2803,13 @@
         "ar_SA": "",
         "de_DE": "",
         "el_GR": "",
-        "en_US": "Show Game Stats",
+        "en_US": "Show Game Info",
         "es_ES": "",
         "fr_FR": "",
         "he_IL": "",
         "it_IT": "",
         "ja_JP": "",
-        "ko_KR": "",
+        "ko_KR": "게임 통계 표시",
         "no_NO": "",
         "pl_PL": "",
         "pt_BR": "",
@@ -2603,13 +2828,13 @@
         "ar_SA": "",
         "de_DE": "",
         "el_GR": "",
-        "en_US": "Show the other various information about the currently selected game that is missing from the Grid view layout.",
+        "en_US": "Show stats & details about the currently selected game.",
         "es_ES": "",
         "fr_FR": "",
         "he_IL": "",
         "it_IT": "",
         "ja_JP": "",
-        "ko_KR": "",
+        "ko_KR": "그리드 보기 레이아웃에서 누락된 현재 선택된 게임에 대한 다양한 정보를 표시합니다.",
         "no_NO": "",
         "pl_PL": "",
         "pt_BR": "",
@@ -3384,7 +3609,7 @@
         "he_IL": "",
         "it_IT": "Aggiornamenti e DLC che fanno riferimento a file mancanti verranno disabilitati automaticamente",
         "ja_JP": "",
-        "ko_KR": "누락된 파일을 참조하는 DLC 및 업데이트가 자동으로 언로드",
+        "ko_KR": "누락된 파일을 참조하는 DLC 및 업데이트가 자동으로 불러오기 취소",
         "no_NO": "DLC og oppdateringer som henviser til manglende filer, vil bli lastet ned automatisk",
         "pl_PL": "",
         "pt_BR": "DLCs e Atualizações que se referem a arquivos ausentes serão descarregadas automaticamente",
@@ -4159,7 +4384,7 @@
         "he_IL": "",
         "it_IT": "",
         "ja_JP": "",
-        "ko_KR": "",
+        "ko_KR": "스웨덴어",
         "no_NO": "",
         "pl_PL": "",
         "pt_BR": "",
@@ -4184,7 +4409,7 @@
         "he_IL": "",
         "it_IT": "",
         "ja_JP": "",
-        "ko_KR": "",
+        "ko_KR": "노르웨이어",
         "no_NO": "Norsk",
         "pl_PL": "",
         "pt_BR": "",
@@ -4259,7 +4484,7 @@
         "he_IL": "",
         "it_IT": "",
         "ja_JP": "",
-        "ko_KR": "",
+        "ko_KR": "매치 시스템 시간",
         "no_NO": "",
         "pl_PL": "",
         "pt_BR": "",
@@ -5897,6 +6122,56 @@
         "zh_TW": "關閉"
       }
     },
+    {
+      "ID": "SettingsButtonReset",
+      "Translations": {
+        "ar_SA": "",
+        "de_DE": "",
+        "el_GR": "",
+        "en_US": "Reset Settings",
+        "es_ES": "",
+        "fr_FR": "",
+        "he_IL": "",
+        "it_IT": "",
+        "ja_JP": "",
+        "ko_KR": "",
+        "no_NO": "",
+        "pl_PL": "",
+        "pt_BR": "",
+        "ru_RU": "",
+        "sv_SE": "",
+        "th_TH": "",
+        "tr_TR": "",
+        "uk_UA": "",
+        "zh_CN": "",
+        "zh_TW": ""
+      }
+    },
+    {
+      "ID": "SettingsButtonResetConfirm",
+      "Translations": {
+        "ar_SA": "",
+        "de_DE": "",
+        "el_GR": "",
+        "en_US": "I want to reset my settings.",
+        "es_ES": "",
+        "fr_FR": "",
+        "he_IL": "",
+        "it_IT": "",
+        "ja_JP": "",
+        "ko_KR": "",
+        "no_NO": "",
+        "pl_PL": "",
+        "pt_BR": "",
+        "ru_RU": "",
+        "sv_SE": "",
+        "th_TH": "",
+        "tr_TR": "",
+        "uk_UA": "",
+        "zh_CN": "",
+        "zh_TW": ""
+      }
+    },
     {
       "ID": "SettingsButtonOk",
       "Translations": {
@@ -7809,7 +8084,7 @@
         "he_IL": "",
         "it_IT": "",
         "ja_JP": "",
-        "ko_KR": "",
+        "ko_KR": "비활성화",
         "no_NO": "",
         "pl_PL": "",
         "pt_BR": "",
@@ -7834,7 +8109,7 @@
         "he_IL": "",
         "it_IT": "",
         "ja_JP": "",
-        "ko_KR": "",
+        "ko_KR": "레인보우",
         "no_NO": "",
         "pl_PL": "",
         "pt_BR": "",
@@ -7859,7 +8134,7 @@
         "he_IL": "",
         "it_IT": "",
         "ja_JP": "",
-        "ko_KR": "",
+        "ko_KR": "레인보우 속도",
         "no_NO": "",
         "pl_PL": "",
         "pt_BR": "",
@@ -7884,7 +8159,7 @@
         "he_IL": "",
         "it_IT": "",
         "ja_JP": "",
-        "ko_KR": "",
+        "ko_KR": "색상",
         "no_NO": "",
         "pl_PL": "",
         "pt_BR": "",
@@ -13134,7 +13409,7 @@
         "he_IL": "",
         "it_IT": "",
         "ja_JP": "",
-        "ko_KR": "",
+        "ko_KR": "다음에서 모든 PPTC 데이터를 제거하려고 합니다:\n\n{0}\n\n계속하시겠습니까?",
         "no_NO": "",
         "pl_PL": "",
         "pt_BR": "",
@@ -19134,7 +19409,7 @@
         "he_IL": "",
         "it_IT": "",
         "ja_JP": "",
-        "ko_KR": "",
+        "ko_KR": "LED 설정",
         "no_NO": "",
         "pl_PL": "",
         "pt_BR": "",
@@ -22059,7 +22334,7 @@
         "he_IL": "ממשק רשת",
         "it_IT": "Interfaccia di rete:",
         "ja_JP": "ネットワークインタフェース:",
-        "ko_KR": "네트워크 인터페이스:",
+        "ko_KR": "네트워크 인터페이스 :",
         "no_NO": "Nettverksgrensesnitt",
         "pl_PL": "Interfejs sieci:",
         "pt_BR": "Interface de rede:",
@@ -23034,7 +23309,7 @@
         "he_IL": "",
         "it_IT": "",
         "ja_JP": "",
-        "ko_KR": "",
+        "ko_KR": "최종 업데이트 : {0}",
         "no_NO": "Sist oppdatert: {0}",
         "pl_PL": "",
         "pt_BR": "",
@@ -23272,6 +23547,131 @@
         "zh_TW": "無法啟動"
       }
     },
+    {
+      "ID": "CompatibilityListPlayableTooltip",
+      "Translations": {
+        "ar_SA": "",
+        "de_DE": "",
+        "el_GR": "",
+        "en_US": "Boots and plays without any crashes or GPU bugs of any kind, and at a speed fast enough to reasonably enjoy on an average PC.",
+        "es_ES": "",
+        "fr_FR": "",
+        "he_IL": "",
+        "it_IT": "",
+        "ja_JP": "",
+        "ko_KR": "",
+        "no_NO": "",
+        "pl_PL": "",
+        "pt_BR": "",
+        "ru_RU": "",
+        "sv_SE": "",
+        "th_TH": "",
+        "tr_TR": "",
+        "uk_UA": "",
+        "zh_CN": "",
+        "zh_TW": ""
+      }
+    },
+    {
+      "ID": "CompatibilityListIngameTooltip",
+      "Translations": {
+        "ar_SA": "",
+        "de_DE": "",
+        "el_GR": "",
+        "en_US": "Boots and goes in-game but suffers from one or more of the following: crashes, deadlocks, GPU bugs, distractingly bad audio, or is simply too slow. Game still might able to be played all the way through, but not as the game is intended to play.",
+        "es_ES": "",
+        "fr_FR": "",
+        "he_IL": "",
+        "it_IT": "",
+        "ja_JP": "",
+        "ko_KR": "",
+        "no_NO": "",
+        "pl_PL": "",
+        "pt_BR": "",
+        "ru_RU": "",
+        "sv_SE": "",
+        "th_TH": "",
+        "tr_TR": "",
+        "uk_UA": "",
+        "zh_CN": "",
+        "zh_TW": ""
+      }
+    },
+    {
+      "ID": "CompatibilityListMenusTooltip",
+      "Translations": {
+        "ar_SA": "",
+        "de_DE": "",
+        "el_GR": "",
+        "en_US": "Boots and goes past the title screen but does not make it into main gameplay.",
+        "es_ES": "",
+        "fr_FR": "",
+        "he_IL": "",
+        "it_IT": "",
+        "ja_JP": "",
+        "ko_KR": "",
+        "no_NO": "",
+        "pl_PL": "",
+        "pt_BR": "",
+        "ru_RU": "",
+        "sv_SE": "",
+        "th_TH": "",
+        "tr_TR": "",
+        "uk_UA": "",
+        "zh_CN": "",
+        "zh_TW": ""
+      }
+    },
+    {
+      "ID": "CompatibilityListBootsTooltip",
+      "Translations": {
+        "ar_SA": "",
+        "de_DE": "",
+        "el_GR": "",
+        "en_US": "Boots but does not make it past the title screen.",
+        "es_ES": "",
+        "fr_FR": "",
+        "he_IL": "",
+        "it_IT": "",
+        "ja_JP": "",
+        "ko_KR": "",
+        "no_NO": "",
+        "pl_PL": "",
+        "pt_BR": "",
+        "ru_RU": "",
+        "sv_SE": "",
+        "th_TH": "",
+        "tr_TR": "",
+        "uk_UA": "",
+        "zh_CN": "",
+        "zh_TW": ""
+      }
+    },
+    {
+      "ID": "CompatibilityListNothingTooltip",
+      "Translations": {
+        "ar_SA": "",
+        "de_DE": "",
+        "el_GR": "",
+        "en_US": "Does not boot or shows no signs of activity.",
+        "es_ES": "",
+        "fr_FR": "",
+        "he_IL": "",
+        "it_IT": "",
+        "ja_JP": "",
+        "ko_KR": "",
+        "no_NO": "",
+        "pl_PL": "",
+        "pt_BR": "",
+        "ru_RU": "",
+        "sv_SE": "",
+        "th_TH": "",
+        "tr_TR": "",
+        "uk_UA": "",
+        "zh_CN": "",
+        "zh_TW": ""
+      }
+    },
     {
       "ID": "ExtractAocListHeader",
       "Translations": {
@@ -23284,7 +23684,7 @@
         "he_IL": "",
         "it_IT": "",
         "ja_JP": "",
-        "ko_KR": "",
+        "ko_KR": "추출할 DLC 선택",
         "no_NO": "Velg en DLC og hente ut",
         "pl_PL": "",
         "pt_BR": "",
@@ -23298,4 +23698,4 @@
       }
     }
   ]
-}
+}

src/Ryujinx/UI/Controls/ApplicationContextMenu.axaml

@@ -26,7 +26,6 @@
         Icon="{ext:Icon mdi-gamepad}"
         ToolTip.Tip="{ext:Locale GameListContextMenuShowCompatEntryToolTip}"/>
     <MenuItem
-        IsVisible="{Binding IsGrid}"
         Click="OpenApplicationData_Click"
         Header="{ext:Locale GameListContextMenuShowGameData}"
         Icon="{ext:Icon mdi-chart-line}"

src/Ryujinx/UI/Controls/ApplicationDataView.axaml

@@ -2,115 +2,113 @@
              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
              xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
              xmlns:helpers="clr-namespace:Ryujinx.Ava.UI.Helpers"
-             xmlns:ui="clr-namespace:FluentAvalonia.UI.Controls;assembly=FluentAvalonia"
-             xmlns:appLibrary="using:Ryujinx.Ava.Utilities.AppLibrary"
+             xmlns:ext="using:Ryujinx.Ava.Common.Markup"
+             xmlns:viewModels="using:Ryujinx.Ava.UI.ViewModels"
              xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
              mc:Ignorable="d" d:DesignWidth="800" d:DesignHeight="450"
              x:Class="Ryujinx.Ava.UI.Controls.ApplicationDataView"
-             x:DataType="appLibrary:ApplicationData">
-    <StackPanel Orientation="Vertical">
-        <Grid
-            RowDefinitions="Auto, Auto, Auto, Auto"
-            ColumnDefinitions="*">
-            <TextBlock Grid.Row="0"
-                       HorizontalAlignment="Center"
-                       Padding="0, -2, 0, 5" 
-                       Classes="h1" 
-                       Text="{Binding Name}" />
-            <TextBlock Grid.Row="1"
-                       HorizontalAlignment="Center"
-                       Text="{Binding Version}"
-                       TextAlignment="Start"
-                       TextWrapping="Wrap" />
-            <TextBlock Grid.Row="2"
-                       HorizontalAlignment="Center"
-                       Text="{Binding Developer}"
-                       TextAlignment="Start"
-                       TextWrapping="Wrap" />
-            <StackPanel Grid.ColumnSpan="2" Grid.Row="3" 
-                        HorizontalAlignment="Center" 
-                        Orientation="Horizontal" Margin="0 10, 0, 0" 
-                        Spacing="5">
-                <Button
-                    Click="PlayabilityStatus_OnClick"
-                    HorizontalContentAlignment="Left"
-                    VerticalAlignment="Center"
-                    IsVisible="{Binding HasPlayabilityInfo}"
-                    Background="{DynamicResource AppListBackgroundColor}"
-                    Padding="0">
-                    <TextBlock
-                        Margin="1.5"
-                        Tag="{Binding IdString}"
-                        Text="{Binding LocalizedStatus}"
-                        Foreground="{Binding PlayabilityStatus, Converter={x:Static helpers:PlayabilityStatusConverter.Shared}}"
-                        TextAlignment="Start"
-                        TextWrapping="Wrap" />
-                    <Button.Styles>
-                        <Style Selector="Button">
-                            <Setter Property="MinWidth"
-                                    Value="0" />
-                            <!-- avoids very wide buttons from the overall project avalonia style -->
-                        </Style>
-                    </Button.Styles>
-                </Button>
-                <Button
-                    Click="IdString_OnClick"
-                    HorizontalContentAlignment="Left"
-                    VerticalAlignment="Center"
-                    Background="{DynamicResource AppListBackgroundColor}"
-                    Padding="0">
-                    <TextBlock
-                        Margin="1.5"
-                        HorizontalAlignment="Stretch"
-                        Text="{Binding IdString}"
-                        TextAlignment="Start"
-                        TextWrapping="Wrap" />
-                </Button>
-            </StackPanel>
-        </Grid>
-        <Separator Margin="0, 10, 0, 10" />
-        <Grid ColumnDefinitions="Auto,*,Auto">
-            <StackPanel Grid.Column="0"
-                        Margin="10,0,0,0"
-                        HorizontalAlignment="Left"
-                        VerticalAlignment="Top"
-                        Orientation="Vertical"
-                        Spacing="5">
-                <TextBlock
-                    HorizontalAlignment="Stretch"
-                    Text="{Binding FileExtension}"
-                    TextAlignment="Start"
-                    TextWrapping="Wrap" />
-                <TextBlock
-                    HorizontalAlignment="Stretch"
-                    Text="{Binding Converter={helpers:MultiplayerInfoConverter}}"
-                    TextAlignment="Start"
-                    TextWrapping="Wrap" />
-            </StackPanel>
+             x:DataType="viewModels:ApplicationDataViewModel">
+    <StackPanel Orientation="Horizontal">
+        <Image Margin="0"
+               MaxWidth="256"
+               MinWidth="256"
+               Source="{Binding AppData.Icon, Converter={x:Static helpers:BitmapArrayValueConverter.Instance}}" />
+        <Border Margin="5, 0" Width="1" Height="256" BorderBrush="Gray" Background="Gray" />
+        <StackPanel Orientation="Vertical">
+            <Grid
+                RowDefinitions="Auto,Auto,Auto"
+                ColumnDefinitions="*">
+                <StackPanel Grid.Row="0">
+                    <TextBlock HorizontalAlignment="Left"
+                               Text="{Binding FormattedVersion}"
+                               TextAlignment="Start"
+                               TextWrapping="Wrap" />
+                    <TextBlock HorizontalAlignment="Left"
+                               Text="{Binding FormattedDeveloper}"
+                               TextAlignment="Start"
+                               TextWrapping="Wrap" />
+                    <TextBlock HorizontalAlignment="Stretch"
+                               Text="{Binding FormattedFileExtension}"
+                               TextAlignment="Start"
+                               TextWrapping="Wrap" />
+                    <TextBlock HorizontalAlignment="Stretch"
+                               Text="{Binding FormattedFileSize}"
+                               TextAlignment="Start"
+                               TextWrapping="Wrap" />
+                </StackPanel>
+                <Separator Grid.Row="1" Margin="0, 10, 0, 10" Height="1" BorderBrush="Gray" Background="Gray" />
+                <StackPanel Grid.Row="2"
+                            HorizontalAlignment="Left"
+                            Orientation="Vertical"
+                            Spacing="5">
+                    <StackPanel Orientation="Horizontal" IsVisible="{Binding AppData.HasPlayabilityInfo}">
+                        <TextBlock Padding="0, 0, 5, 0" Text="{ext:Locale GameListHeaderCompatibilityStatus}" />
+                        <Button
+                            Click="PlayabilityStatus_OnClick"
+                            HorizontalContentAlignment="Left"
+                            VerticalAlignment="Center"
+                            Background="{DynamicResource AppListBackgroundColor}"
+                            Padding="0">
+                            <TextBlock
+                                Margin="1.5"
+                                Tag="{Binding AppData.IdString}"
+                                Text="{Binding AppData.LocalizedStatus}"
+                                Foreground="{Binding AppData.PlayabilityStatus, Converter={x:Static helpers:PlayabilityStatusConverter.Shared}}"
+                                ToolTip.Tip="{Binding AppData.LocalizedStatusTooltip}"
+                                TextAlignment="Start"
+                                TextWrapping="Wrap" />
+                            <Button.Styles>
+                                <Style Selector="Button">
+                                    <Setter Property="MinWidth"
+                                            Value="0" />
+                                    <!-- avoids very wide buttons from the overall project avalonia style -->
+                                </Style>
+                            </Button.Styles>
+                        </Button>
+                    </StackPanel>
+                    <StackPanel Orientation="Horizontal">
+                        <TextBlock Padding="0, 0, 5, 0" Text="{ext:Locale GameListHeaderTitleId}" />
+                        <Button
+                            Click="IdString_OnClick"
+                            HorizontalContentAlignment="Left"
+                            VerticalAlignment="Center"
+                            Background="{DynamicResource AppListBackgroundColor}"
+                            Padding="0">
+                            <TextBlock
+                                Margin="1.5"
+                                HorizontalAlignment="Stretch"
+                                Text="{Binding AppData.IdString}"
+                                TextAlignment="Start"
+                                TextWrapping="Wrap" />
+                        </Button>
+                    </StackPanel>
+                </StackPanel>
+            </Grid>
+            <Separator Margin="0, 10, 0, 10" Height="1" BorderBrush="Gray" Background="Gray" />
+            <TextBlock
+                HorizontalAlignment="Stretch"
+                IsVisible="{Binding AppData.HasLdnGames}"
+                Text="{Binding FormattedLdnInfo}"
+                TextAlignment="Start"
+                TextWrapping="Wrap" />
+            <Separator IsVisible="{Binding AppData.HasLdnGames}" Margin="0, 10, 0, 10" Height="1" BorderBrush="Gray" Background="Gray" />
             <StackPanel
-                Grid.Column="2"
-                Margin="0,0,10,0"
-                HorizontalAlignment="Right"
+                HorizontalAlignment="Left"
                 VerticalAlignment="Top"
                 Orientation="Vertical"
                 Spacing="5">
                 <TextBlock
                     HorizontalAlignment="Stretch"
-                    Text="{Binding LastPlayedString}"
-                    TextAlignment="End"
+                    Text="{Binding FormattedLastPlayed}"
+                    TextAlignment="Start"
                     TextWrapping="Wrap" />
                 <TextBlock
                     HorizontalAlignment="Stretch"
-                    Text="{Binding TimePlayedString}"
-                    IsVisible="{Binding HasPlayedPreviously}"
-                    TextAlignment="End"
-                    TextWrapping="Wrap" />
-                <TextBlock
-                    HorizontalAlignment="Stretch"
-                    Text="{Binding FileSizeString}"
-                    TextAlignment="End"
+                    Text="{Binding FormattedPlayTime}"
+                    IsVisible="{Binding AppData.HasPlayedPreviously}"
+                    TextAlignment="Start"
                     TextWrapping="Wrap" />
             </StackPanel>
-        </Grid>
+        </StackPanel>
     </StackPanel>
 </UserControl>

src/Ryujinx/UI/Controls/ApplicationDataView.axaml.cs

@@ -23,10 +23,12 @@ namespace Ryujinx.Ava.UI.Controls
         {
             ContentDialog contentDialog = new()
             {
+                Title = appData.Name,
                 PrimaryButtonText = string.Empty,
                 SecondaryButtonText = string.Empty,
                 CloseButtonText = LocaleManager.Instance[LocaleKeys.SettingsButtonClose],
-                Content = new ApplicationDataView { DataContext = appData }
+                MinWidth = 256,
+                Content = new ApplicationDataView { DataContext = new ApplicationDataViewModel(appData) }
             };
 
             Style closeButton = new(x => x.Name("CloseButton"));

src/Ryujinx/UI/Controls/ApplicationListView.axaml

@@ -93,7 +93,8 @@
                                             IsVisible="{Binding HasPlayabilityInfo}"
                                             Background="{DynamicResource AppListBackgroundColor}"
                                             Margin="-1, 0, 0, 0"
-                                            Padding="0" >
+                                            Padding="0"
+                                            ToolTip.Tip="{Binding LocalizedStatusTooltip}">
                                             <TextBlock
                                                 Margin="1.5"
                                                 Tag="{Binding IdString}"
@@ -140,7 +141,8 @@
                                         TextWrapping="Wrap" />
                                     <TextBlock
                                         HorizontalAlignment="Stretch"
-                                        Text="{Binding Converter={helpers:MultiplayerInfoConverter}}"
+                                        IsVisible="{Binding HasLdnGames}"
+                                        Text="{Binding Converter={x:Static helpers:MultiplayerInfoConverter.Instance}}"
                                         TextAlignment="Start"
                                         TextWrapping="Wrap"/>
                                 </StackPanel>

src/Ryujinx/UI/Helpers/Converters/MultiplayerInfoConverter.cs

@@ -1,27 +1,31 @@
 using Avalonia.Data.Converters;
 using Avalonia.Markup.Xaml;
+using Gommon;
+using Ryujinx.Ava.Common.Locale;
 using Ryujinx.Ava.Utilities.AppLibrary;
 using System;
 using System.Globalization;
+using System.Text;
 
 namespace Ryujinx.Ava.UI.Helpers
 {
     internal class MultiplayerInfoConverter : MarkupExtension, IValueConverter
     {
-        private static readonly MultiplayerInfoConverter _instance = new();
+        public static readonly MultiplayerInfoConverter Instance = new();
 
         public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
         {
-            if (value is ApplicationData applicationData)
-            {
-                if (applicationData.PlayerCount != 0 && applicationData.GameCount != 0)
-                {
-                    return $"Hosted Games: {applicationData.GameCount}\nOnline Players: {applicationData.PlayerCount}";
-                }
-            }
-            
-            return "";
+            if (value is not ApplicationData { HasLdnGames: true } applicationData)
+                return "";
             
+            return new StringBuilder()
+                .AppendLine(
+                    LocaleManager.Instance[LocaleKeys.GameListHeaderHostedGames]
+                        .Format(applicationData.GameCount))
+                .Append(
+                    LocaleManager.Instance[LocaleKeys.GameListHeaderPlayerCount]
+                        .Format(applicationData.PlayerCount))
+                .ToString();
         }
 
         public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
@@ -31,7 +35,7 @@ namespace Ryujinx.Ava.UI.Helpers
 
         public override object ProvideValue(IServiceProvider serviceProvider)
         {
-            return _instance;
+            return Instance;
         }
     }
 }

src/Ryujinx/UI/ViewModels/ApplicationDataViewModel.cs

@@ -0,0 +1,26 @@
+using Gommon;
+using Ryujinx.Ava.Common.Locale;
+using Ryujinx.Ava.Utilities.AppLibrary;
+
+namespace Ryujinx.Ava.UI.ViewModels
+{
+    public class ApplicationDataViewModel : BaseModel
+    {
+        public ApplicationData AppData { get; }
+
+        public ApplicationDataViewModel(ApplicationData appData) => AppData = appData;
+
+        public string FormattedVersion => LocaleManager.Instance[LocaleKeys.GameListHeaderVersion].Format(AppData.Version);
+        public string FormattedDeveloper => LocaleManager.Instance[LocaleKeys.GameListHeaderDeveloper].Format(AppData.Developer);
+        
+        public string FormattedFileExtension => LocaleManager.Instance[LocaleKeys.GameListHeaderFileExtension].Format(AppData.FileExtension);
+        public string FormattedLastPlayed => LocaleManager.Instance[LocaleKeys.GameListHeaderLastPlayed].Format(AppData.LastPlayedString);
+        public string FormattedPlayTime => LocaleManager.Instance[LocaleKeys.GameListHeaderTimePlayed].Format(AppData.TimePlayedString);
+        public string FormattedFileSize => LocaleManager.Instance[LocaleKeys.GameListHeaderFileSize].Format(AppData.FileSizeString);
+        
+        public string FormattedLdnInfo => 
+            $"{LocaleManager.Instance[LocaleKeys.GameListHeaderHostedGames].Format(AppData.GameCount)}" +
+            $"\n" +
+            $"{LocaleManager.Instance[LocaleKeys.GameListHeaderPlayerCount].Format(AppData.PlayerCount)}";
+    }
+}

src/Ryujinx/UI/ViewModels/MainWindowViewModel.cs

@@ -633,15 +633,15 @@ namespace Ryujinx.Ava.UI.ViewModels
             {
                 return SortMode switch
                 {
-                    ApplicationSort.Title => LocaleManager.Instance[LocaleKeys.GameListHeaderApplication],
-                    ApplicationSort.Developer => LocaleManager.Instance[LocaleKeys.GameListHeaderDeveloper],
-                    ApplicationSort.LastPlayed => LocaleManager.Instance[LocaleKeys.GameListHeaderLastPlayed],
-                    ApplicationSort.TotalTimePlayed => LocaleManager.Instance[LocaleKeys.GameListHeaderTimePlayed],
-                    ApplicationSort.FileType => LocaleManager.Instance[LocaleKeys.GameListHeaderFileExtension],
-                    ApplicationSort.FileSize => LocaleManager.Instance[LocaleKeys.GameListHeaderFileSize],
-                    ApplicationSort.Path => LocaleManager.Instance[LocaleKeys.GameListHeaderPath],
                     ApplicationSort.Favorite => LocaleManager.Instance[LocaleKeys.CommonFavorite],
                     ApplicationSort.TitleId => LocaleManager.Instance[LocaleKeys.DlcManagerTableHeadingTitleIdLabel],
+                    ApplicationSort.Title => LocaleManager.Instance[LocaleKeys.GameListHeaderApplication],
+                    ApplicationSort.Developer => LocaleManager.Instance[LocaleKeys.GameListSortDeveloper],
+                    ApplicationSort.LastPlayed => LocaleManager.Instance[LocaleKeys.GameListSortLastPlayed],
+                    ApplicationSort.TotalTimePlayed => LocaleManager.Instance[LocaleKeys.GameListSortTimePlayed],
+                    ApplicationSort.FileType => LocaleManager.Instance[LocaleKeys.GameListSortFileExtension],
+                    ApplicationSort.FileSize => LocaleManager.Instance[LocaleKeys.GameListSortFileSize],
+                    ApplicationSort.Path => LocaleManager.Instance[LocaleKeys.GameListSortPath],
                     _ => string.Empty,
                 };
             }

src/Ryujinx/UI/ViewModels/SettingsViewModel.cs

@@ -2,7 +2,7 @@ using Avalonia.Collections;
 using Avalonia.Controls;
 using Avalonia.Threading;
 using CommunityToolkit.Mvvm.ComponentModel;
-using Gommon;
+using CommunityToolkit.Mvvm.Input;
 using LibHac.Tools.FsSystem;
 using Ryujinx.Audio.Backends.OpenAL;
 using Ryujinx.Audio.Backends.SDL2;
@@ -28,8 +28,6 @@ using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Linq;
 using System.Net.NetworkInformation;
-using System.Runtime.InteropServices;
-using System.Text.RegularExpressions;
 using System.Threading.Tasks;
 using TimeZone = Ryujinx.Ava.UI.Models.TimeZone;
 
@@ -722,6 +720,25 @@ namespace Ryujinx.Ava.UI.ViewModels
             CloseWindow?.Invoke();
         }
 
+        [ObservableProperty] private bool _wantsToReset;
+
+        public AsyncRelayCommand ResetButton => Commands.Create(async () =>
+        {
+            if (!WantsToReset) return;
+            
+            CloseWindow?.Invoke();
+            ConfigurationState.Instance.LoadDefault();
+            ConfigurationState.Instance.ToFileFormat().SaveConfig(Program.ConfigurationPath);
+            RyujinxApp.MainWindow.LoadApplications();
+
+            await ContentDialogHelper.CreateInfoDialog(
+                $"Your {RyujinxApp.FullAppName} configuration has been reset.",
+                "",
+                string.Empty,
+                LocaleManager.Instance[LocaleKeys.SettingsButtonClose],
+                "Configuration Reset");
+        });
+
         public void CancelButton()
         {
             RevertIfNotSaved();

src/Ryujinx/UI/Views/Main/MainViewControls.axaml

@@ -113,37 +113,37 @@
                                 Tag="TitleId" />
                             <RadioButton
                                 Checked="Sort_Checked"
-                                Content="{ext:Locale GameListHeaderDeveloper}"
+                                Content="{ext:Locale GameListSortDeveloper}"
                                 GroupName="Sort"
                                 IsChecked="{Binding IsSortedByDeveloper, Mode=OneTime}"
                                 Tag="Developer" />
                             <RadioButton
                                 Checked="Sort_Checked"
-                                Content="{ext:Locale GameListHeaderTimePlayed}"
+                                Content="{ext:Locale GameListSortTimePlayed}"
                                 GroupName="Sort"
                                 IsChecked="{Binding IsSortedByTimePlayed, Mode=OneTime}"
                                 Tag="TotalTimePlayed" />
                             <RadioButton
                                 Checked="Sort_Checked"
-                                Content="{ext:Locale GameListHeaderLastPlayed}"
+                                Content="{ext:Locale GameListSortLastPlayed}"
                                 GroupName="Sort"
                                 IsChecked="{Binding IsSortedByLastPlayed, Mode=OneTime}"
                                 Tag="LastPlayed" />
                             <RadioButton
                                 Checked="Sort_Checked"
-                                Content="{ext:Locale GameListHeaderFileExtension}"
+                                Content="{ext:Locale GameListSortFileExtension}"
                                 GroupName="Sort"
                                 IsChecked="{Binding IsSortedByType, Mode=OneTime}"
                                 Tag="FileType" />
                             <RadioButton
                                 Checked="Sort_Checked"
-                                Content="{ext:Locale GameListHeaderFileSize}"
+                                Content="{ext:Locale GameListSortFileSize}"
                                 GroupName="Sort"
                                 IsChecked="{Binding IsSortedBySize, Mode=OneTime}"
                                 Tag="FileSize" />
                             <RadioButton
                                 Checked="Sort_Checked"
-                                Content="{ext:Locale GameListHeaderPath}"
+                                Content="{ext:Locale GameListSortPath}"
                                 GroupName="Sort"
                                 IsChecked="{Binding IsSortedByPath, Mode=OneTime}"
                                 Tag="Path" />

src/Ryujinx/UI/Windows/SettingsWindow.axaml

@@ -108,24 +108,36 @@
                 </Style>
             </ui:NavigationView.Styles>
         </ui:NavigationView>
-        <ReversibleStackPanel
-            Grid.Row="2"
-            Margin="10"
-            Spacing="10"
-            Orientation="Horizontal"
-            HorizontalAlignment="Right"
-            ReverseOrder="{x:Static helper:RunningPlatform.IsMacOS}">
-            <Button
-                Classes="accent"
-                Content="{ext:Locale SettingsButtonOk}"
-                Command="{Binding OkButton}" />
-            <Button
-                HotKey="Escape"
-                Content="{ext:Locale SettingsButtonCancel}"
-                Command="{Binding CancelButton}" />
-            <Button
-                Content="{ext:Locale SettingsButtonApply}"
-                Command="{Binding ApplyButton}" />
-        </ReversibleStackPanel>
+        <Grid Grid.Row="2"
+              ColumnDefinitions="Auto,*,Auto">
+            <StackPanel Grid.Column="0" Orientation="Horizontal">
+                <Button
+                    IsEnabled="{Binding WantsToReset}"
+                    Margin="10"
+                    Content="{ext:Locale SettingsButtonReset}"
+                    Command="{Binding ResetButton}" />
+                <CheckBox IsChecked="{Binding WantsToReset}"/>
+                <TextBlock Text="{ext:Locale SettingsButtonResetConfirm}"/>
+            </StackPanel>
+            <ReversibleStackPanel
+                Grid.Column="2"
+                Margin="10"
+                Spacing="10"
+                Orientation="Horizontal"
+                HorizontalAlignment="Right"
+                ReverseOrder="{x:Static helper:RunningPlatform.IsMacOS}">
+                <Button
+                    Classes="accent"
+                    Content="{ext:Locale SettingsButtonOk}"
+                    Command="{Binding OkButton}" />
+                <Button
+                    HotKey="Escape"
+                    Content="{ext:Locale SettingsButtonCancel}"
+                    Command="{Binding CancelButton}" />
+                <Button
+                    Content="{ext:Locale SettingsButtonApply}"
+                    Command="{Binding ApplyButton}" />
+            </ReversibleStackPanel>
+        </Grid>
     </Grid>
 </window:StyleableAppWindow>

src/Ryujinx/Utilities/AppLibrary/ApplicationData.cs

@@ -46,9 +46,24 @@ namespace Ryujinx.Ava.Utilities.AppLibrary
                 : string.Empty;
 
         public LocaleKeys? PlayabilityStatus { get; set; }
-        
+        public string LocalizedStatusTooltip =>
+            PlayabilityStatus.HasValue 
+#pragma warning disable CS8509 // It is exhaustive for any value this property can contain.
+                ? LocaleManager.Instance[PlayabilityStatus!.Value switch
+#pragma warning restore CS8509
+                {
+                    LocaleKeys.CompatibilityListPlayable => LocaleKeys.CompatibilityListPlayableTooltip,
+                    LocaleKeys.CompatibilityListIngame => LocaleKeys.CompatibilityListIngameTooltip,
+                    LocaleKeys.CompatibilityListMenus => LocaleKeys.CompatibilityListMenusTooltip,
+                    LocaleKeys.CompatibilityListBoots => LocaleKeys.CompatibilityListBootsTooltip,
+                    LocaleKeys.CompatibilityListNothing => LocaleKeys.CompatibilityListNothingTooltip,
+                }]
+                : string.Empty;
         public int PlayerCount { get; set; }
         public int GameCount { get; set; }
+
+        public bool HasLdnGames => PlayerCount != 0 && GameCount != 0;
+        
         public TimeSpan TimePlayed { get; set; }
         public DateTime? LastPlayed { get; set; }
         public string FileExtension { get; set; }

src/Ryujinx/Utilities/Compat/CompatibilityCsv.cs

@@ -100,12 +100,25 @@ namespace Ryujinx.Ava.Utilities.Compat
         public Optional<string> TitleId { get; }
         public string[] Labels { get; }
         public LocaleKeys? Status { get; }
+
+        public LocaleKeys? StatusDescription
+            => Status switch
+            {
+                LocaleKeys.CompatibilityListPlayable => LocaleKeys.CompatibilityListPlayableTooltip,
+                LocaleKeys.CompatibilityListIngame => LocaleKeys.CompatibilityListIngameTooltip,
+                LocaleKeys.CompatibilityListMenus => LocaleKeys.CompatibilityListMenusTooltip,
+                LocaleKeys.CompatibilityListBoots => LocaleKeys.CompatibilityListBootsTooltip,
+                LocaleKeys.CompatibilityListNothing => LocaleKeys.CompatibilityListNothingTooltip,
+                _ => null
+            };
+        
         public DateTime LastUpdated { get; }
 
         public string LocalizedLastUpdated =>
             LocaleManager.FormatDynamicValue(LocaleKeys.CompatibilityListLastUpdated, LastUpdated.Humanize());
-
+        
         public string LocalizedStatus => LocaleManager.Instance[Status!.Value];
+        public string LocalizedStatusDescription => LocaleManager.Instance[StatusDescription!.Value];
         public string FormattedTitleId => TitleId
             .OrElse(new string(' ', 16));
 

src/Ryujinx/Utilities/Compat/CompatibilityList.axaml

@@ -64,6 +64,8 @@
                                            VerticalAlignment="Center"
                                            Text="{Binding LocalizedStatus}"
                                            Width="85"
+                                           Background="Transparent"
+                                           ToolTip.Tip="{Binding LocalizedStatusDescription}"
                                            Foreground="{Binding Status, Converter={x:Static helpers:PlayabilityStatusConverter.Shared}}"
                                            TextWrapping="NoWrap" />
                                 <TextBlock Grid.Column="3"