Update PT-BR Big Translation & Add DKC Returns HD to compatibility list (#666 )

Today I had a free day to look at and work on the entire Brazilian Portuguese language. Translations that had not been done before have been added Fixed several translations that didn't make sense Translated description of functions that were not translated correctly Words were written as close to the original English Add Donkey Kong Country Returns HD to compatibility list
Gracefully handle errors in socket creation (#662 )
2025-07-30 17:49:57 -06:00 · 2025-02-16 15:39:42 -06:00 · 2025-02-16 02:26:37 -06:00 · 2025-02-16 01:03:44 -06:00 · 2025-02-16 00:58:25 -06:00 · 2025-02-15 20:52:03 -06:00
87 changed files with 4559 additions and 1215 deletions
--- a/.github/workflows/canary.yml
+++ b/.github/workflows/canary.yml
@ -29,7 +29,7 @@ env:
 jobs:
  tag:
    name: Create tag
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-24.04
    steps:
      - name: Get version info
        id: version_info
@ -202,7 +202,7 @@ jobs:

  macos_release:
    name: Release MacOS universal
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-24.04
    steps:
      - uses: actions/checkout@v4

--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@ -18,7 +18,7 @@ env:
 jobs:
  tag:
    name: Create tag
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-24.04
    steps:
      - name: Get version info
        id: version_info
@ -183,7 +183,7 @@ jobs:

  macos_release:
    name: Release MacOS universal
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-24.04
    steps:
      - uses: actions/checkout@v4

--- a/README.md
+++ b/README.md
@ -39,12 +39,12 @@
 <p align="center">
    Click below to join the Discord:
    <br>
-    <a href="https://discord.gg/dHPrkBkkyA">
+    <a href="https://discord.gg/PEuzjrFXUA">
        <img src="https://img.shields.io/discord/1294443224030511104?color=5865F2&label=Ryubing&logo=discord&logoColor=white" alt="Discord">
    </a>
    <br>
    <br>
-    <img src="https://raw.githubusercontent.com/GreemDev/Ryujinx/refs/heads/master/docs/shell.png">
+    <img src="https://raw.githubusercontent.com/Ryubing/Ryujinx/refs/heads/master/docs/shell.png">
 </p>

 ## Usage
--- a/docs/compatibility.csv
+++ b/docs/compatibility.csv
@ -332,6 +332,7 @@
 0100E680149DC000,"Arcaea",,playable,2023-03-16 19:31:21
 01003C2010C78000,"Archaica: The Path Of Light",crash,nothing,2020-10-16 13:22:26
 01004DA012976000,"Area 86",,playable,2020-12-16 16:45:52
+01008d8006a6a000,"Arena of Valor",crash,boots,2025-02-03 22:19:34
 0100691013C46000,"ARIA CHRONICLE",,playable,2022-11-16 13:50:55
 0100D4A00B284000,"ARK: Survival Evolved",gpu;nvdec;online-broken;UE4;ldn-untested,ingame,2024-04-16 00:53:56
 0100C56012C96000,"Arkanoid vs. Space Invaders",services,ingame,2021-01-21 12:50:30
@ -426,6 +427,7 @@
 0100E48013A34000,"Balan Wonderworld Demo",gpu;services;UE4;demo,ingame,2023-02-16 20:05:07
 0100CD801CE5E000,"Balatro",,ingame,2024-04-21 02:01:53
 010010A00DA48000,"Baldur's Gate and Baldur's Gate II: Enhanced Editions",32-bit,playable,2022-09-12 23:52:15
+0100fd1014726000,"Baldur's Gate: Dark Alliance",ldn-untested,ingame,2025-02-03 22:21:00
 0100BC400FB64000,"Balthazar's Dream",,playable,2022-09-13 00:13:22
 01008D30128E0000,"Bamerang",,playable,2022-10-26 00:29:39
 010013C010C5C000,"Banner of the Maid",,playable,2021-06-14 15:23:37
@ -528,6 +530,7 @@
 01005950022EC000,"Blade Strangers",nvdec,playable,2022-07-17 19:02:43
 0100DF0011A6A000,"Bladed Fury",,playable,2022-10-26 11:36:26
 0100CFA00CC74000,"Blades of Time",deadlock;online,boots,2022-07-17 19:19:58
+01003d700dd8a000,"Blades",,boots,2025-02-03 22:22:00
 01006CC01182C000,"Blair Witch",nvdec;UE4,playable,2022-10-01 14:06:16
 010039501405E000,"Blanc",gpu;slow,ingame,2023-02-22 14:00:13
 0100698009C6E000,"Blasphemous",nvdec,playable,2021-03-01 12:15:31
@ -955,7 +958,7 @@
 010012800EBAE000,"Disney TSUM TSUM FESTIVAL",crash,menus,2020-07-14 14:05:28
 01009740120FE000,"DISTRAINT 2",,playable,2020-09-03 16:08:12
 010075B004DD2000,"DISTRAINT: Deluxe Edition",,playable,2020-06-15 23:42:24
-010027400CDC6000,"Divinity: Original Sin 2 - Definitive Edition",services;crash;online-broken;regression,menus,2023-08-13 17:20:03
+010027400CDC6000,"Divinity: Original Sin 2 - Definitive Edition",services;crash;online-broken;regression,ingame,2025-02-03 22:12:30
 01001770115C8000,"Dodo Peak",nvdec;UE4,playable,2022-10-04 16:13:05
 010077B0100DA000,"Dogurai",,playable,2020-10-04 02:40:16
 010048100D51A000,"Dokapon Up! Mugen no Roulette",gpu;Needs Update,menus,2022-12-08 19:39:10
@ -966,6 +969,7 @@
 0100751007ADA000,"Don't Starve: Nintendo Switch Edition",nvdec,playable,2022-02-05 20:43:34
 010088B010DD2000,"Dongo Adventure",,playable,2022-10-04 16:22:26
 0100C1F0051B6000,"Donkey Kong Country™: Tropical Freeze",,playable,2024-08-05 16:46:10
+01009D901BC56000,"Donkey Kong Country™: Returns HD",gpu,ingame,2025-02-16 13:44:12
 0100F2C00F060000,"Doodle Derby",,boots,2020-12-04 22:51:48
 0100416004C00000,"DOOM",gpu;slow;nvdec;online-broken,ingame,2024-09-23 15:40:07
 010018900DD00000,"DOOM (1993)",nvdec;online-broken,menus,2022-09-06 13:32:19
@ -1246,7 +1250,7 @@
 0100A6B00D4EC000,"Furwind",,playable,2021-02-19 19:44:08
 0100ECE00C0C4000,"Fury Unleashed",crash;services,ingame,2020-10-18 11:52:40
 010070000ED9E000,"Fury Unleashed Demo",,playable,2020-10-08 20:09:21
-0100E1F013674000,"FUSER™",nvdec;UE4,playable,2022-10-17 20:58:32
+0100E1F013674000,"FUSER™",nvdec;UE4;slow;gpu,ingame,2025-02-12 16:03:00
 0100A7A015E4C000,"Fushigi no Gensokyo Lotus Labyrinth",Needs Update;audio;gpu;nvdec,ingame,2021-01-20 15:30:02
 01003C300B274000,"Futari de! Nyanko Daisensou",,playable,2024-01-05 22:26:52
 010055801134E000,"FUZE Player",online-broken;vulkan-backend-bug,ingame,2022-10-18 12:23:53
@ -1654,7 +1658,7 @@
 0100A73006E74000,"Legendary Eleven",,playable,2021-06-08 12:09:03
 0100A7700B46C000,"Legendary Fishing",online,playable,2021-04-14 15:08:46
 0100739018020000,"LEGO® 2K Drive",gpu;ldn-works,ingame,2024-04-09 02:05:12
-01003A30012C0000,"LEGO® CITY Undercover",nvdec,playable,2024-09-30 08:44:27
+010085500130a000,"LEGO® CITY Undercover",nvdec,playable,2024-09-30 08:44:27
 010070D009FEC000,"LEGO® DC Super-Villains",,playable,2021-05-27 18:10:37
 010052A00B5D2000,"LEGO® Harry Potter™ Collection",crash,ingame,2024-01-31 10:28:07
 010073C01AF34000,"LEGO® Horizon Adventures™",vulkan-backend-bug;opengl-backend-bug;UE4,ingame,2025-01-07 04:24:56
@ -1913,6 +1917,7 @@
 010073E008E6E000,"Mugsters",,playable,2021-01-28 17:57:17
 0100A8400471A000,"MUJO",,playable,2020-05-08 16:31:04
 0100211005E94000,"Mulaka",,playable,2021-01-28 18:07:20
+01008e2013fb4000,"Multi Quiz",ldn-untested,ingame,2025-02-03 22:26:00
 010038B00B9AE000,"Mummy Pinball",,playable,2022-08-05 16:08:11
 01008E200C5C2000,"Muse Dash",,playable,2020-06-06 14:41:29
 010035901046C000,"Mushroom Quest",,playable,2020-05-17 13:07:08
@ -2028,6 +2033,7 @@
 010003C00B868000,"Ninjin: Clash of Carrots",online-broken,playable,2024-07-10 05:12:26
 0100746010E4C000,"NinNinDays",,playable,2022-11-20 15:17:29
 0100C9A00ECE6000,"Nintendo 64™ – Nintendo Switch Online",gpu;vulkan,ingame,2024-04-23 20:21:07
+0100e0601c632000,"Nintendo 64™ – Nintendo Switch Online: MATURE 17+",,ingame,2025-02-03 22:27:00
 0100D870045B6000,"Nintendo Entertainment System™ - Nintendo Switch Online",online,playable,2022-07-01 15:45:06
 0100C4B0034B2000,"Nintendo Labo Toy-Con 01 Variety Kit",gpu,ingame,2022-08-07 12:56:07
 01001E9003502000,"Nintendo Labo Toy-Con 03 Vehicle Kit",services;crash,menus,2022-08-03 17:20:11
@ -2058,7 +2064,7 @@
 010002700C34C000,"Numbala",,playable,2020-05-11 12:01:07
 010020500C8C8000,"Number Place 10000",gpu,menus,2021-11-24 09:14:23
 010003701002C000,"Nurse Love Syndrome",,playable,2022-10-13 10:05:22
-0000000000000000,"nx-hbmenu",Needs Update;homebrew,boots,2024-04-06 22:05:32
+,"nx-hbmenu",Needs Update;homebrew,boots,2024-04-06 22:05:32
 ,"nxquake2",services;crash;homebrew,nothing,2022-08-04 23:14:04
 010049F00EC30000,"Nyan Cat: Lost in Space",online,playable,2021-06-12 13:22:03
 01002E6014FC4000,"O---O",,playable,2022-10-29 12:12:14
@ -2466,7 +2472,7 @@
 0100AFE00DDAC000,"Royal Roads",,playable,2020-11-17 12:54:38
 0100E2C00B414000,"RPG Maker MV",nvdec,playable,2021-01-05 20:12:01
 01005CD015986000,"rRootage Reloaded",,playable,2022-08-05 23:20:18
-0000000000000000,"RSDKv5u",homebrew,ingame,2024-04-01 16:25:34
+,"RSDKv5u",homebrew,ingame,2024-04-01 16:25:34
 010009B00D33C000,"Rugby Challenge 4",slow;online-broken;UE4,playable,2022-10-06 12:45:53
 01006EC00F2CC000,"RUINER",UE4,playable,2022-10-03 14:11:33
 010074F00DE4A000,"Run the Fan",,playable,2021-02-27 13:36:28
@ -2475,6 +2481,7 @@
 010081C0191D8000,"Rune Factory 3 Special",,playable,2023-10-15 08:32:49
 010051D00E3A4000,"Rune Factory 4 Special",32-bit;crash;nvdec,ingame,2023-05-06 08:49:17
 010014D01216E000,"Rune Factory 5 (JP)",gpu,ingame,2021-06-01 12:00:36
+010071E0145F8000,"Rustler",,playable,2025-02-10 20:17:12
 0100E21013908000,"RWBY: Grimm Eclipse - Definitive Edition",online-broken,playable,2022-11-03 10:44:01
 010012C0060F0000,"RXN -Raijin-",nvdec,playable,2021-01-10 16:05:43
 0100B8B012ECA000,"S.N.I.P.E.R. - Hunter Scope",,playable,2021-04-19 15:58:09
@ -2483,7 +2490,7 @@
 0100A5200C2E0000,"Safety First!",,playable,2021-01-06 09:05:23
 0100A51013530000,"SaGa Frontier Remastered",nvdec,playable,2022-11-03 13:54:56
 010003A00D0B4000,"SaGa SCARLET GRACE: AMBITIONS™",,playable,2022-10-06 13:20:31
-01008D100D43E000,"Saints Row IV®: Re-Elected™",ldn-untested;LAN,playable,2023-12-04 18:33:37
+01008D100D43E000,"Saints Row IV®: Re-Elected™",ldn-untested;LAN;deadlock,ingame,2025-02-02 16:57:53
 0100DE600BEEE000,"SAINTS ROW®: THE THIRD™ - THE FULL PACKAGE",slow;LAN,playable,2023-08-24 02:40:58
 01007F000EB36000,"Sakai and...",nvdec,playable,2022-12-15 13:53:19
 0100B1400E8FE000,"Sakuna: Of Rice and Ruin",,playable,2023-07-24 13:47:13
@ -2532,7 +2539,7 @@
 0100C3E00B700000,"SEGA AGES Space Harrier",,playable,2021-01-11 12:57:40
 010054400D2E6000,"SEGA AGES Virtua Racing",online-broken,playable,2023-01-29 17:08:39
 01001E700AC60000,"SEGA AGES Wonder Boy: Monster Land",online,playable,2021-05-05 16:28:25
-0100B3C014BDA000,"SEGA Genesis™ – Nintendo Switch Online",crash;regression,nothing,2022-04-11 07:27:21
+0100B3C014BDA000,"SEGA Genesis™ – Nintendo Switch Online",crash;regression,ingame,2025-02-03 22:13:30
 0100F7300B24E000,"SEGA Mega Drive Classics",online,playable,2021-01-05 11:08:00
 01009840046BC000,"Semispheres",,playable,2021-01-06 23:08:31
 0100D1800D902000,"SENRAN KAGURA Peach Ball",,playable,2021-06-03 15:12:10
@ -2668,10 +2675,10 @@
 01004F401BEBE000,"Song of Nunu: A League of Legends Story",,ingame,2024-07-12 18:53:44
 0100E5400BF94000,"Songbird Symphony",,playable,2021-02-27 02:44:04
 010031D00A604000,"Songbringer",,playable,2020-06-22 10:42:02
-0000000000000000,"Sonic 1 (2013)",crash;homebrew,ingame,2024-04-06 18:31:20
-0000000000000000,"Sonic 2 (2013)",crash;homebrew,ingame,2024-04-01 16:25:30
-0000000000000000,"Sonic A.I.R",homebrew,ingame,2024-04-01 16:25:32
-0000000000000000,"Sonic CD",crash;homebrew,ingame,2024-04-01 16:25:31
+,"Sonic 1 (2013)",crash;homebrew,ingame,2024-04-06 18:31:20
+,"Sonic 2 (2013)",crash;homebrew,ingame,2024-04-01 16:25:30
+,"Sonic A.I.R",homebrew,ingame,2024-04-01 16:25:32
+,"Sonic CD",crash;homebrew,ingame,2024-04-01 16:25:31
 010040E0116B8000,"Sonic Colors: Ultimate",,playable,2022-11-12 21:24:26
 01001270012B6000,"SONIC FORCES™",,playable,2024-07-28 13:11:21
 01004AD014BF0000,"Sonic Frontiers",gpu;deadlock;amd-vendor-bug;intel-vendor-bug,ingame,2024-09-05 09:18:53
@ -2688,7 +2695,7 @@
 0100707011722000,"Space Elite Force",,playable,2020-11-27 15:21:05
 010047B010260000,"Space Pioneer",,playable,2022-10-20 12:24:37
 010010A009830000,"Space Ribbon",,playable,2022-08-15 17:17:10
-0000000000000000,"SpaceCadetPinball",homebrew,ingame,2024-04-18 19:30:04
+,"SpaceCadetPinball",homebrew,ingame,2024-04-18 19:30:04
 0100D9B0041CE000,"Spacecats with Lasers",,playable,2022-08-15 17:22:44
 010034800FB60000,"Spaceland",,playable,2020-11-01 14:31:56
 010028D0045CE000,"Sparkle 2",,playable,2020-10-19 11:51:39
@ -2833,7 +2840,7 @@
 0100000000010000,"Super Mario Odyssey™",nvdec;intel-vendor-bug;mac-bug,playable,2024-08-25 01:32:34
 010036B0034E4000,"Super Mario Party™",gpu;Needs Update;ldn-works,ingame,2024-06-21 05:10:16
 0100BC0018138000,"Super Mario RPG™",gpu;audio;nvdec,ingame,2024-06-19 17:43:42
-0000000000000000,"Super Mario World",homebrew,boots,2024-06-13 01:40:31
+,"Super Mario World",homebrew,boots,2024-06-13 01:40:31
 010049900F546000,"Super Mario™ 3D All-Stars",services-horizon;slow;vulkan;amd-vendor-bug,ingame,2024-05-07 02:38:16
 010028600EBDA000,"Super Mario™ 3D World + Bowser’s Fury",ldn-works,playable,2024-07-31 10:45:37
 01004F8006A78000,"Super Meat Boy",services,playable,2020-04-02 23:10:07
@ -2964,6 +2971,7 @@
 0100C38004DCC000,"The Flame In The Flood: Complete Edition",gpu;nvdec;UE4,ingame,2022-08-22 16:23:49
 010007700D4AC000,"The Forbidden Arts",,playable,2021-01-26 16:26:24
 010030700CBBC000,"The friends of Ringo Ishikawa",,playable,2022-08-22 16:33:17
+0100b620139d8000,"The Game of Life 2",ldn-untested,ingame,2025-02-03 22:30:00
 01006350148DA000,"The Gardener and the Wild Vines",gpu,ingame,2024-04-29 16:32:10
 0100B13007A6A000,"The Gardens Between",,playable,2021-01-29 16:16:53
 010036E00FB20000,"The Great Ace Attorney Chronicles",,playable,2023-06-22 21:26:29
@ -2981,6 +2989,8 @@
 010015D003EE4000,"The Jackbox Party Pack 2",online-working,playable,2022-08-22 18:23:40
 0100CC80013D6000,"The Jackbox Party Pack 3",slow;online-working,playable,2022-08-22 18:41:06
 0100E1F003EE8000,"The Jackbox Party Pack 4",online-working,playable,2022-08-22 18:56:34
+01006fe0096ac000,"The Jackbox Party Pack 5",slow;online-working,ingame,2025-02-14 05:32:00
+01005a400db52000,"The Jackbox Party Pack 6",slow;online-working,ingame,2025-02-14 05:26:00
 010052C00B184000,"The Journey Down: Chapter One",nvdec,playable,2021-02-24 13:32:41
 01006BC00B188000,"The Journey Down: Chapter Three",nvdec,playable,2021-02-24 13:45:27
 01009AB00B186000,"The Journey Down: Chapter Two",nvdec,playable,2021-02-24 13:32:13
@ -3159,6 +3169,7 @@
 010055E00CA68000,"Trine 4: The Nightmare Prince",gpu,nothing,2025-01-07 05:47:46
 0100D9000A930000,"Trine Enchanted Edition",ldn-untested;nvdec,playable,2021-06-03 11:28:15
 01002D7010A54000,"Trinity Trigger",crash,ingame,2023-03-03 03:09:09
+010020700a5e0000,"TRIVIAL PURSUIT Live!",ldn-untested,ingame,2025-02-03 22:35:00
 0100868013FFC000,"TRIVIAL PURSUIT Live! 2",,boots,2022-12-19 00:04:33
 0100F78002040000,"Troll and I™",gpu;nvdec,ingame,2021-06-04 16:58:50
 0100145011008000,"Trollhunters: Defenders of Arcadia",gpu;nvdec,ingame,2020-11-30 13:27:09
@ -3208,6 +3219,7 @@
 0100AB2010B4C000,"Unlock The King",,playable,2020-09-01 13:58:27
 0100A3E011CB0000,"Unlock the King 2",,playable,2021-06-15 20:43:55
 01005AA00372A000,"UNO® for Nintendo Switch",nvdec;ldn-untested,playable,2022-07-28 14:49:47
+0100b6e012ebe000,"UNO",ldn-untested,ingame,2025-02-03 22:40:00
 0100E5D00CC0C000,"Unravel Two",nvdec,playable,2024-05-23 15:45:05
 010001300CC4A000,"Unruly Heroes",,playable,2021-01-07 18:09:31
 0100B410138C0000,"Unspottable",,playable,2022-10-25 19:28:49
@ -3372,6 +3384,7 @@
 0100F47016F26000,"Yomawari 3",,playable,2022-05-10 08:26:51
 010012F00B6F2000,"Yomawari: The Long Night Collection",,playable,2022-09-03 14:36:59
 0100CC600ABB2000,"Yonder: The Cloud Catcher Chronicles (Retail Only)",,playable,2021-01-28 14:06:25
+0100534009ff2000,"Yonder: The Cloud Catcher Chronicles",,playable,2025-02-03 22:19:13
 0100BE50042F6000,"Yono and the Celestial Elephants",,playable,2021-01-28 18:23:58
 0100F110029C8000,"Yooka-Laylee",,playable,2021-01-28 14:21:45
 010022F00DA66000,"Yooka-Laylee and the Impossible Lair",,playable,2021-03-05 17:32:21
--- a/src/ARMeilleure/Memory/ReservedRegion.cs
+++ b/src/ARMeilleure/Memory/ReservedRegion.cs
@ -7,6 +7,7 @@ namespace ARMeilleure.Memory
        public const int DefaultGranularity = 65536; // Mapping granularity in Windows.

        public IJitMemoryBlock Block { get; }
+        public IJitMemoryAllocator Allocator { get; }

        public nint Pointer => Block.Pointer;

@ -21,6 +22,7 @@ namespace ARMeilleure.Memory
                granularity = DefaultGranularity;
            }

+            Allocator = allocator;
            Block = allocator.Reserve(maxSize);
            _maxSize = maxSize;
            _sizeGranularity = granularity;
--- a/src/ARMeilleure/Translation/Cache/JitCache.cs
+++ b/src/ARMeilleure/Translation/Cache/JitCache.cs
@ -2,6 +2,8 @@ using ARMeilleure.CodeGen;
 using ARMeilleure.CodeGen.Unwinding;
 using ARMeilleure.Memory;
 using ARMeilleure.Native;
+using Humanizer;
+using Ryujinx.Common.Logging;
 using Ryujinx.Memory;
 using System;
 using System.Collections.Generic;
@ -18,9 +20,8 @@ namespace ARMeilleure.Translation.Cache
        private static readonly int _pageMask = _pageSize - 1;

        private const int CodeAlignment = 4; // Bytes.
-        private const int CacheSize = 2047 * 1024 * 1024;
+        private const int CacheSize = 256 * 1024 * 1024;

-        private static ReservedRegion _jitRegion;
        private static JitCacheInvalidation _jitCacheInvalidator;

        private static CacheMemoryAllocator _cacheAllocator;
@ -30,6 +31,9 @@ namespace ARMeilleure.Translation.Cache
        private static readonly Lock _lock = new();
        private static bool _initialized;

+        private static readonly List<ReservedRegion> _jitRegions = new();
+        private static int _activeRegionIndex = 0;
+
        [SupportedOSPlatform("windows")]
        [LibraryImport("kernel32.dll", SetLastError = true)]
        public static partial nint FlushInstructionCache(nint hProcess, nint lpAddress, nuint dwSize);
@ -48,7 +52,9 @@ namespace ARMeilleure.Translation.Cache
                    return;
                }

-                _jitRegion = new ReservedRegion(allocator, CacheSize);
+                ReservedRegion firstRegion = new(allocator, CacheSize);
+                _jitRegions.Add(firstRegion);
+                _activeRegionIndex = 0;

                if (!OperatingSystem.IsWindows() && !OperatingSystem.IsMacOS())
                {
@ -59,7 +65,9 @@ namespace ARMeilleure.Translation.Cache

                if (OperatingSystem.IsWindows())
                {
-                    JitUnwindWindows.InstallFunctionTableHandler(_jitRegion.Pointer, CacheSize, _jitRegion.Pointer + Allocate(_pageSize));
+                    JitUnwindWindows.InstallFunctionTableHandler(
+                        firstRegion.Pointer, CacheSize, firstRegion.Pointer + Allocate(_pageSize)
+                    );
                }

                _initialized = true;
@ -75,8 +83,8 @@ namespace ARMeilleure.Translation.Cache
                Debug.Assert(_initialized);

                int funcOffset = Allocate(code.Length);
-
-                nint funcPtr = _jitRegion.Pointer + funcOffset;
+                ReservedRegion targetRegion = _jitRegions[_activeRegionIndex];
+                nint funcPtr = targetRegion.Pointer + funcOffset;

                if (OperatingSystem.IsMacOS() && RuntimeInformation.ProcessArchitecture == Architecture.Arm64)
                {
@ -90,9 +98,9 @@ namespace ARMeilleure.Translation.Cache
                }
                else
                {
-                    ReprotectAsWritable(funcOffset, code.Length);
+                    ReprotectAsWritable(targetRegion, funcOffset, code.Length);
                    Marshal.Copy(code, 0, funcPtr, code.Length);
-                    ReprotectAsExecutable(funcOffset, code.Length);
+                    ReprotectAsExecutable(targetRegion, funcOffset, code.Length);

                    if (OperatingSystem.IsWindows() && RuntimeInformation.ProcessArchitecture == Architecture.Arm64)
                    {
@ -116,52 +124,83 @@ namespace ARMeilleure.Translation.Cache
            {
                Debug.Assert(_initialized);

-                int funcOffset = (int)(pointer.ToInt64() - _jitRegion.Pointer.ToInt64());
-
-                if (TryFind(funcOffset, out CacheEntry entry, out int entryIndex) && entry.Offset == funcOffset)
+                foreach (ReservedRegion region in _jitRegions)
                {
-                    _cacheAllocator.Free(funcOffset, AlignCodeSize(entry.Size));
-                    _cacheEntries.RemoveAt(entryIndex);
+                    if (pointer.ToInt64() < region.Pointer.ToInt64() ||
+                        pointer.ToInt64() >= (region.Pointer + CacheSize).ToInt64())
+                    {
+                        continue;
+                    }
+
+                    int funcOffset = (int)(pointer.ToInt64() - region.Pointer.ToInt64());
+
+                    if (TryFind(funcOffset, out CacheEntry entry, out int entryIndex) && entry.Offset == funcOffset)
+                    {
+                        _cacheAllocator.Free(funcOffset, AlignCodeSize(entry.Size));
+                        _cacheEntries.RemoveAt(entryIndex);
+                    }
+
+                    return;
                }
            }
        }

-        private static void ReprotectAsWritable(int offset, int size)
+        private static void ReprotectAsWritable(ReservedRegion region, int offset, int size)
        {
            int endOffs = offset + size;
-
            int regionStart = offset & ~_pageMask;
            int regionEnd = (endOffs + _pageMask) & ~_pageMask;

-            _jitRegion.Block.MapAsRwx((ulong)regionStart, (ulong)(regionEnd - regionStart));
+            region.Block.MapAsRwx((ulong)regionStart, (ulong)(regionEnd - regionStart));
        }

-        private static void ReprotectAsExecutable(int offset, int size)
+        private static void ReprotectAsExecutable(ReservedRegion region, int offset, int size)
        {
            int endOffs = offset + size;
-
            int regionStart = offset & ~_pageMask;
            int regionEnd = (endOffs + _pageMask) & ~_pageMask;

-            _jitRegion.Block.MapAsRx((ulong)regionStart, (ulong)(regionEnd - regionStart));
+            region.Block.MapAsRx((ulong)regionStart, (ulong)(regionEnd - regionStart));
        }

        private static int Allocate(int codeSize)
        {
            codeSize = AlignCodeSize(codeSize);

-            int allocOffset = _cacheAllocator.Allocate(codeSize);
-
-            if (allocOffset < 0)
+            for (int i = _activeRegionIndex; i < _jitRegions.Count; i++)
            {
-                throw new OutOfMemoryException("JIT Cache exhausted.");
+                int allocOffset = _cacheAllocator.Allocate(codeSize);
+        
+                if (allocOffset >= 0)
+                {
+                    _jitRegions[i].ExpandIfNeeded((ulong)allocOffset + (ulong)codeSize);
+                    _activeRegionIndex = i;
+                    return allocOffset;
+                }
            }

-            _jitRegion.ExpandIfNeeded((ulong)allocOffset + (ulong)codeSize);
+            int exhaustedRegion = _activeRegionIndex;
+            var newRegion = new ReservedRegion(_jitRegions[0].Allocator, CacheSize);
+            _jitRegions.Add(newRegion);
+            _activeRegionIndex = _jitRegions.Count - 1;
+            
+            int newRegionNumber = _activeRegionIndex;

-            return allocOffset;
+            Logger.Warning?.Print(LogClass.Cpu, $"JIT Cache Region {exhaustedRegion} exhausted, creating new Cache Region {newRegionNumber} ({((long)(newRegionNumber + 1) * CacheSize).Bytes()} Total Allocation).");
+        
+            _cacheAllocator = new CacheMemoryAllocator(CacheSize);
+
+            int allocOffsetNew = _cacheAllocator.Allocate(codeSize);
+            if (allocOffsetNew < 0)
+            {
+                throw new OutOfMemoryException("Failed to allocate in new Cache Region!");
+            }
+
+            newRegion.ExpandIfNeeded((ulong)allocOffsetNew + (ulong)codeSize);
+            return allocOffsetNew;
        }

+
        private static int AlignCodeSize(int codeSize)
        {
            return checked(codeSize + (CodeAlignment - 1)) & ~(CodeAlignment - 1);
@ -185,18 +224,21 @@ namespace ARMeilleure.Translation.Cache
        {
            lock (_lock)
            {
-                int index = _cacheEntries.BinarySearch(new CacheEntry(offset, 0, default));
-
-                if (index < 0)
+                foreach (ReservedRegion _ in _jitRegions)
                {
-                    index = ~index - 1;
-                }
+                    int index = _cacheEntries.BinarySearch(new CacheEntry(offset, 0, default));

-                if (index >= 0)
-                {
-                    entry = _cacheEntries[index];
-                    entryIndex = index;
-                    return true;
+                    if (index < 0)
+                    {
+                        index = ~index - 1;
+                    }
+
+                    if (index >= 0)
+                    {
+                        entry = _cacheEntries[index];
+                        entryIndex = index;
+                        return true;
+                    }
                }
            }

--- a/src/ARMeilleure/Translation/PTC/PtcProfiler.cs
+++ b/src/ARMeilleure/Translation/PTC/PtcProfiler.cs
@ -144,17 +144,15 @@ namespace ARMeilleure.Translation.PTC

        public List<ulong> GetBlacklistedFunctions()
        {
-            List<ulong> funcs = new List<ulong>();
+            List<ulong> funcs = [];

-            foreach (var profiledFunc in ProfiledFuncs)
+            foreach ((ulong ptr, FuncProfile funcProfile) in ProfiledFuncs)
            {
-                if (profiledFunc.Value.Blacklist)
-                {
-                    if (!funcs.Contains(profiledFunc.Key))
-                    {
-                        funcs.Add(profiledFunc.Key);
-                    }
-                }
+                if (!funcProfile.Blacklist)
+                    continue;
+
+                if (!funcs.Contains(ptr)) 
+                    funcs.Add(ptr);
            }

            return funcs;
--- a/src/Ryujinx.Common/Helpers/PlayReportAnalyzer.cs
+++ b/src/Ryujinx.Common/Helpers/PlayReportAnalyzer.cs
@ -1,80 +0,0 @@
-using Gommon;
-using MsgPack;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-
-namespace Ryujinx.Common.Helper
-{
-    public class PlayReportAnalyzer
-    {
-        private readonly List<PlayReportGameSpec> _specs = [];
-
-        public PlayReportAnalyzer AddSpec(string titleId, Func<PlayReportGameSpec, PlayReportGameSpec> transform)
-        {
-            _specs.Add(transform(new PlayReportGameSpec { TitleIdStr = titleId }));
-            return this;
-        }
-        
-        public PlayReportAnalyzer AddSpec(string titleId, Action<PlayReportGameSpec> transform)
-        {
-            _specs.Add(new PlayReportGameSpec { TitleIdStr = titleId }.Apply(transform));
-            return this;
-        }
-
-        public Optional<string> Run(string runningGameId, MessagePackObject playReport)
-        {
-            if (!playReport.IsDictionary) 
-                return Optional<string>.None;
-
-            if (!_specs.TryGetFirst(s => s.TitleIdStr.EqualsIgnoreCase(runningGameId), out PlayReportGameSpec spec))
-                return Optional<string>.None;
-
-            foreach (PlayReportValueFormatterSpec formatSpec in spec.Analyses.OrderBy(x => x.Priority))
-            {
-                if (!playReport.AsDictionary().TryGetValue(formatSpec.ReportKey, out MessagePackObject valuePackObject))
-                    continue;
-
-                return formatSpec.ValueFormatter(valuePackObject.ToObject());
-            }
-            
-            return Optional<string>.None;
-        }
-        
-    }
-
-    public class PlayReportGameSpec
-    {
-        public required string TitleIdStr { get; init; }
-        public List<PlayReportValueFormatterSpec> Analyses { get; } = [];
-
-        public PlayReportGameSpec AddValueFormatter(string reportKey, Func<object, string> valueFormatter)
-        {
-            Analyses.Add(new PlayReportValueFormatterSpec
-            {
-                Priority = Analyses.Count,
-                ReportKey = reportKey, 
-                ValueFormatter = valueFormatter
-            });
-            return this;
-        }
-        
-        public PlayReportGameSpec AddValueFormatter(int priority, string reportKey, Func<object, string> valueFormatter)
-        {
-            Analyses.Add(new PlayReportValueFormatterSpec
-            {
-                Priority = priority,
-                ReportKey = reportKey, 
-                ValueFormatter = valueFormatter
-            });
-            return this;
-        }
-    }
-
-    public struct PlayReportValueFormatterSpec
-    {
-        public required int Priority { get; init; }
-        public required string ReportKey { get; init; }
-        public required Func<object, string> ValueFormatter { get; init; }
-    }
-}
--- a/src/Ryujinx.Common/TitleIDs.cs
+++ b/src/Ryujinx.Common/TitleIDs.cs
@ -47,7 +47,8 @@ namespace Ryujinx.Common
            "01006f8002326000", // Animal Crossings: New Horizons
            "01009bf0072d4000", // Captain Toad: Treasure Tracker
            "01009510001ca000", // Fast RMX
-            "01005CA01580E000", // Persona 5 Royale
+            "01005CA01580E000", // Persona 5 Royal
+            "0100b880154fc000", // Persona 5 The Royal (Japan)
            "010015100b514000", // Super Mario Bros. Wonder
            "0100000000010000", // Super Mario Odyssey

@ -163,15 +164,16 @@ namespace Ryujinx.Common
            "0100ba0018500000", // Splatoon 3: Splatfest World Premiere

                          //NSO Membership games
-            "0100ccf019c8c000", // F-ZERO 99
            "0100c62011050000", // GB - Nintendo Switch Online
            "010012f017576000", // GBA - Nintendo Switch Online
            "0100c9a00ece6000", // N64 - Nintendo Switch Online
            "0100e0601c632000", // N64 - Nintendo Switch Online 18+
            "0100d870045b6000", // NES - Nintendo Switch Online
+            "0100b3c014bda000", // SEGA Genesis - Nintendo Switch Online
+            "01008d300c50c000", // SNES - Nintendo Switch Online
+            "0100ccf019c8c000", // F-ZERO 99
            "0100ad9012510000", // PAC-MAN 99
            "010040600c5ce000", // Tetris 99
-            "01008d300c50c000", // SNES - Nintendo Switch Online
            "0100277011f1a000", // Super Mario Bros. 35

                          //Misc Nintendo 1st party games
@ -217,6 +219,7 @@ namespace Ryujinx.Common
                          //Misc Games
            "010056e00853a000", // A Hat in Time
            "0100fd1014726000", // Baldurs Gate: Dark Alliance
+            "01008c2019598000", // Bluey: The Video Game
            "0100c6800b934000", // Brawlhalla
            "0100dbf01000a000", // Burnout Paradise Remastered
            "0100744001588000", // Cars 3: Driven to Win
--- a/src/Ryujinx.Cpu/LightningJit/Cache/JitCache.cs
+++ b/src/Ryujinx.Cpu/LightningJit/Cache/JitCache.cs
@ -1,4 +1,6 @@
 using ARMeilleure.Memory;
+using Humanizer;
+using Ryujinx.Common.Logging;
 using Ryujinx.Memory;
 using System;
 using System.Collections.Generic;
@ -15,9 +17,8 @@ namespace Ryujinx.Cpu.LightningJit.Cache
        private static readonly int _pageMask = _pageSize - 1;

        private const int CodeAlignment = 4; // Bytes.
-        private const int CacheSize = 2047 * 1024 * 1024;
+        private const int CacheSize = 256 * 1024 * 1024;

-        private static ReservedRegion _jitRegion;
        private static JitCacheInvalidation _jitCacheInvalidator;

        private static CacheMemoryAllocator _cacheAllocator;
@ -26,6 +27,8 @@ namespace Ryujinx.Cpu.LightningJit.Cache

        private static readonly Lock _lock = new();
        private static bool _initialized;
+        private static readonly List<ReservedRegion> _jitRegions = new();
+        private static int _activeRegionIndex = 0;

        [SupportedOSPlatform("windows")]
        [LibraryImport("kernel32.dll", SetLastError = true)]
@ -45,7 +48,9 @@ namespace Ryujinx.Cpu.LightningJit.Cache
                    return;
                }

-                _jitRegion = new ReservedRegion(allocator, CacheSize);
+                ReservedRegion firstRegion = new(allocator, CacheSize);
+                _jitRegions.Add(firstRegion);
+                _activeRegionIndex = 0;

                if (!OperatingSystem.IsWindows() && !OperatingSystem.IsMacOS())
                {
@ -65,8 +70,8 @@ namespace Ryujinx.Cpu.LightningJit.Cache
                Debug.Assert(_initialized);

                int funcOffset = Allocate(code.Length);
-
-                nint funcPtr = _jitRegion.Pointer + funcOffset;
+                ReservedRegion targetRegion = _jitRegions[_activeRegionIndex];
+                nint funcPtr = targetRegion.Pointer + funcOffset;

                if (OperatingSystem.IsMacOS() && RuntimeInformation.ProcessArchitecture == Architecture.Arm64)
                {
@ -80,18 +85,11 @@ namespace Ryujinx.Cpu.LightningJit.Cache
                }
                else
                {
-                    ReprotectAsWritable(funcOffset, code.Length);
-                    code.CopyTo(new Span<byte>((void*)funcPtr, code.Length));
-                    ReprotectAsExecutable(funcOffset, code.Length);
+                    ReprotectAsWritable(targetRegion, funcOffset, code.Length);
+                    Marshal.Copy(code.ToArray(), 0, funcPtr, code.Length);
+                    ReprotectAsExecutable(targetRegion, funcOffset, code.Length);

-                    if (OperatingSystem.IsWindows() && RuntimeInformation.ProcessArchitecture == Architecture.Arm64)
-                    {
-                        FlushInstructionCache(Process.GetCurrentProcess().Handle, funcPtr, (nuint)code.Length);
-                    }
-                    else
-                    {
-                        _jitCacheInvalidator?.Invalidate(funcPtr, (ulong)code.Length);
-                    }
+                    _jitCacheInvalidator?.Invalidate(funcPtr, (ulong)code.Length);
                }

                Add(funcOffset, code.Length);
@ -106,50 +104,80 @@ namespace Ryujinx.Cpu.LightningJit.Cache
            {
                Debug.Assert(_initialized);

-                int funcOffset = (int)(pointer.ToInt64() - _jitRegion.Pointer.ToInt64());
-
-                if (TryFind(funcOffset, out CacheEntry entry, out int entryIndex) && entry.Offset == funcOffset)
+                foreach (ReservedRegion region in _jitRegions)
                {
-                    _cacheAllocator.Free(funcOffset, AlignCodeSize(entry.Size));
-                    _cacheEntries.RemoveAt(entryIndex);
+                    if (pointer.ToInt64() < region.Pointer.ToInt64() ||
+                        pointer.ToInt64() >= (region.Pointer + CacheSize).ToInt64())
+                    {
+                        continue;
+                    }
+
+                    int funcOffset = (int)(pointer.ToInt64() - region.Pointer.ToInt64());
+
+                    if (TryFind(funcOffset, out CacheEntry entry, out int entryIndex) && entry.Offset == funcOffset)
+                    {
+                        _cacheAllocator.Free(funcOffset, AlignCodeSize(entry.Size));
+                        _cacheEntries.RemoveAt(entryIndex);
+                    }
+
+                    return;
                }
            }
        }

-        private static void ReprotectAsWritable(int offset, int size)
+        private static void ReprotectAsWritable(ReservedRegion region, int offset, int size)
        {
            int endOffs = offset + size;
-
            int regionStart = offset & ~_pageMask;
            int regionEnd = (endOffs + _pageMask) & ~_pageMask;

-            _jitRegion.Block.MapAsRwx((ulong)regionStart, (ulong)(regionEnd - regionStart));
+            region.Block.MapAsRwx((ulong)regionStart, (ulong)(regionEnd - regionStart));
        }

-        private static void ReprotectAsExecutable(int offset, int size)
+        private static void ReprotectAsExecutable(ReservedRegion region, int offset, int size)
        {
            int endOffs = offset + size;
-
            int regionStart = offset & ~_pageMask;
            int regionEnd = (endOffs + _pageMask) & ~_pageMask;

-            _jitRegion.Block.MapAsRx((ulong)regionStart, (ulong)(regionEnd - regionStart));
+            region.Block.MapAsRx((ulong)regionStart, (ulong)(regionEnd - regionStart));
        }

        private static int Allocate(int codeSize)
        {
            codeSize = AlignCodeSize(codeSize);

-            int allocOffset = _cacheAllocator.Allocate(codeSize);
-
-            if (allocOffset < 0)
+            for (int i = _activeRegionIndex; i < _jitRegions.Count; i++)
            {
-                throw new OutOfMemoryException("JIT Cache exhausted.");
+                int allocOffset = _cacheAllocator.Allocate(codeSize);
+        
+                if (allocOffset >= 0)
+                {
+                    _jitRegions[i].ExpandIfNeeded((ulong)allocOffset + (ulong)codeSize);
+                    _activeRegionIndex = i;
+                    return allocOffset;
+                }
            }

-            _jitRegion.ExpandIfNeeded((ulong)allocOffset + (ulong)codeSize);
+            int exhaustedRegion = _activeRegionIndex;
+            ReservedRegion newRegion = new(_jitRegions[0].Allocator, CacheSize);
+            _jitRegions.Add(newRegion);
+            _activeRegionIndex = _jitRegions.Count - 1;
+            
+            int newRegionNumber = _activeRegionIndex;

-            return allocOffset;
+            Logger.Warning?.Print(LogClass.Cpu, $"JIT Cache Region {exhaustedRegion} exhausted, creating new Cache Region {newRegionNumber} ({((long)(newRegionNumber + 1) * CacheSize).Bytes()} Total Allocation).");
+        
+            _cacheAllocator = new CacheMemoryAllocator(CacheSize);
+
+            int allocOffsetNew = _cacheAllocator.Allocate(codeSize);
+            if (allocOffsetNew < 0)
+            {
+                throw new OutOfMemoryException("Failed to allocate in new Cache Region!");
+            }
+
+            newRegion.ExpandIfNeeded((ulong)allocOffsetNew + (ulong)codeSize);
+            return allocOffsetNew;
        }

        private static int AlignCodeSize(int codeSize)
--- a/src/Ryujinx.Cpu/LightningJit/Cache/NoWxCache.cs
+++ b/src/Ryujinx.Cpu/LightningJit/Cache/NoWxCache.cs
@ -12,7 +12,7 @@ namespace Ryujinx.Cpu.LightningJit.Cache
    {
        private const int CodeAlignment = 4; // Bytes.
        private const int SharedCacheSize = 2047 * 1024 * 1024;
-        private const int LocalCacheSize = 128 * 1024 * 1024;
+        private const int LocalCacheSize = 256 * 1024 * 1024;

        // How many calls to the same function we allow until we pad the shared cache to force the function to become available there
        // and allow the guest to take the fast path.
--- a/src/Ryujinx.Graphics.Vulkan/Vendor.cs
+++ b/src/Ryujinx.Graphics.Vulkan/Vendor.cs
@ -1,5 +1,4 @@
 using Silk.NET.Vulkan;
-using System.Text.RegularExpressions;

 namespace Ryujinx.Graphics.Vulkan
 {
--- a/src/Ryujinx.HLE/HOS/Applets/Error/ErrorApplet.cs
+++ b/src/Ryujinx.HLE/HOS/Applets/Error/ErrorApplet.cs
@ -15,7 +15,6 @@ using System.IO;
 using System.Linq;
 using System.Runtime.InteropServices;
 using System.Text;
-using System.Text.RegularExpressions;

 namespace Ryujinx.HLE.HOS.Applets.Error
 {
@ -159,13 +158,15 @@ namespace Ryujinx.HLE.HOS.Applets.Error

            string[] buttons = GetButtonsText(module, description, "DlgBtn");

-            bool showDetails = _horizon.Device.UIHandler.DisplayErrorAppletDialog($"Error Code: {module}-{description:0000}", "\n" + message, buttons);
+            (uint Module, uint Description) errorCodeTuple = (module, uint.Parse(description.ToString("0000")));
+            
+            bool showDetails = _horizon.Device.UIHandler.DisplayErrorAppletDialog($"Error Code: {module}-{description:0000}", "\n" + message, buttons, errorCodeTuple);
            if (showDetails)
            {
                message = GetMessageText(module, description, "FlvMsg");
                buttons = GetButtonsText(module, description, "FlvBtn");

-                _horizon.Device.UIHandler.DisplayErrorAppletDialog($"Details: {module}-{description:0000}", "\n" + message, buttons);
+                _horizon.Device.UIHandler.DisplayErrorAppletDialog($"Details: {module}-{description:0000}", "\n" + message, buttons, errorCodeTuple);
            }
        }

--- a/src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/IClient.cs
+++ b/src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/IClient.cs
@ -34,6 +34,10 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd
        {
            if (errorCode != LinuxError.SUCCESS)
            {
+                if (errorCode != LinuxError.EWOULDBLOCK)
+                {
+                    Logger.Warning?.Print(LogClass.ServiceBsd, $"Operation failed with error {errorCode}.");
+                }
                result = -1;
            }

@ -66,6 +70,8 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd
            BsdSocketType type = (BsdSocketType)context.RequestData.ReadInt32();
            ProtocolType protocol = (ProtocolType)context.RequestData.ReadInt32();

+            Logger.Info?.PrintMsg(LogClass.ServiceBsd, $"Creating socket with domain={domain}, type={type}, protocol={protocol}");
+
            BsdSocketCreationFlags creationFlags = (BsdSocketCreationFlags)((int)type >> (int)BsdSocketCreationFlags.FlagsShift);
            type &= BsdSocketType.TypeMask;

@ -95,12 +101,21 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd
                }
            }

-            ISocket newBsdSocket = new ManagedSocket(netDomain, (SocketType)type, protocol, context.Device.Configuration.MultiplayerLanInterfaceId)
-            {
-                Blocking = !creationFlags.HasFlag(BsdSocketCreationFlags.NonBlocking),
-            };
-
            LinuxError errno = LinuxError.SUCCESS;
+            ISocket newBsdSocket;
+
+            try
+            {
+                newBsdSocket = new ManagedSocket(netDomain, (SocketType)type, protocol, context.Device.Configuration.MultiplayerLanInterfaceId)
+                {
+                    Blocking = !creationFlags.HasFlag(BsdSocketCreationFlags.NonBlocking),
+                };
+            }
+            catch (SocketException exception)
+            {
+                LinuxError errNo = WinSockHelper.ConvertError((WsaError)exception.ErrorCode);
+                return WriteBsdResult(context, 0, errNo);
+            }

            int newSockFd = _context.RegisterFileDescriptor(newBsdSocket);

@ -111,6 +126,7 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd

            if (exempt)
            {
+                Logger.Info?.Print(LogClass.ServiceBsd, "Disconnecting exempt socket.");
                newBsdSocket.Disconnect();
            }

@ -797,7 +813,11 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd
            {
                errno = socket.Listen(backlog);
            }
-
+            else
+            {
+                Logger.Warning?.PrintMsg(LogClass.ServiceBsd, $"Invalid socket fd '{socketFd}'.");
+            }
+            
            return WriteBsdResult(context, 0, errno);
        }

--- a/src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Impl/ManagedSocket.cs
+++ b/src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Impl/ManagedSocket.cs
@ -92,18 +92,30 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Impl
            {
                newSocket = new ManagedSocket(Socket.Accept());

+                IPEndPoint remoteEndPoint = newSocket.RemoteEndPoint;
+                bool isPrivateIp = remoteEndPoint.Address.ToString().StartsWith("192.168.");
+                Logger.Info?.PrintMsg(LogClass.ServiceBsd,
+                    isPrivateIp
+                        ? $"Accepted connection from {ProtocolType}/{remoteEndPoint.Address}:{remoteEndPoint.Port}"
+                        : $"Accepted connection from {ProtocolType}/***:{remoteEndPoint.Port}");
+
                return LinuxError.SUCCESS;
            }
            catch (SocketException exception)
            {
                newSocket = null;

+                if (exception.SocketErrorCode != SocketError.WouldBlock)
+                {
+                    Logger.Warning?.Print(LogClass.ServiceBsd, $"Socket Exception: {exception}");
+                }
                return WinSockHelper.ConvertError((WsaError)exception.ErrorCode);
            }
        }

        public LinuxError Bind(IPEndPoint localEndPoint)
        {
+            Logger.Info?.PrintMsg(LogClass.ServiceBsd, $"Socket binding to: {ProtocolType}/{localEndPoint.Port}");
            try
            {
                Socket.Bind(localEndPoint);
@ -112,6 +124,10 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Impl
            }
            catch (SocketException exception)
            {
+                if (exception.SocketErrorCode != SocketError.WouldBlock)
+                {
+                    Logger.Warning?.Print(LogClass.ServiceBsd, $"Socket Exception: {exception}");
+                }
                return WinSockHelper.ConvertError((WsaError)exception.ErrorCode);
            }
        }
@ -123,6 +139,15 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Impl

        public LinuxError Connect(IPEndPoint remoteEndPoint)
        {
+            bool isLDNPrivateIP = remoteEndPoint.Address.ToString().StartsWith("192.168.");
+            if (isLDNPrivateIP)
+            {
+                Logger.Info?.PrintMsg(LogClass.ServiceBsd, $"Connecting to: {ProtocolType}/{remoteEndPoint.Address}:{remoteEndPoint.Port}");
+            }
+            else
+            {
+                Logger.Info?.PrintMsg(LogClass.ServiceBsd, $"Connecting to: {ProtocolType}/***:{remoteEndPoint.Port}");
+            }
            try
            {
                Socket.Connect(remoteEndPoint);
@ -137,6 +162,10 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Impl
                }
                else
                {
+                    if (exception.SocketErrorCode != SocketError.WouldBlock)
+                    {
+                        Logger.Warning?.Print(LogClass.ServiceBsd, $"Socket Exception: {exception}");
+                    }
                    return WinSockHelper.ConvertError((WsaError)exception.ErrorCode);
                }
            }
@ -144,11 +173,13 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Impl

        public void Disconnect()
        {
+            Logger.Info?.Print(LogClass.ServiceBsd, "Socket disconnecting");
            Socket.Disconnect(true);
        }

        public void Dispose()
        {
+            Logger.Info?.Print(LogClass.ServiceBsd, "Socket closed");
            Socket.Close();
            Socket.Dispose();
        }
@ -159,10 +190,16 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Impl
            {
                Socket.Listen(backlog);

+                Logger.Info?.PrintMsg(LogClass.ServiceBsd, $"Socket listening: {ProtocolType}/{(Socket.LocalEndPoint as IPEndPoint).Port}");
+
                return LinuxError.SUCCESS;
            }
            catch (SocketException exception)
            {
+                if (exception.SocketErrorCode != SocketError.WouldBlock)
+                {
+                    Logger.Warning?.Print(LogClass.ServiceBsd, $"Socket Exception: {exception}");
+                }
                return WinSockHelper.ConvertError((WsaError)exception.ErrorCode);
            }
        }
@ -182,11 +219,15 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Impl
            }
            catch (SocketException exception)
            {
+                if (exception.SocketErrorCode != SocketError.WouldBlock)
+                {
+                    Logger.Warning?.Print(LogClass.ServiceBsd, $"Socket Exception: {exception}");
+                }
                return WinSockHelper.ConvertError((WsaError)exception.ErrorCode);
            }
        }

-        bool hasEmittedBlockingWarning = false;
+        private bool _hasEmittedBlockingWarning;

        public LinuxError Receive(out int receiveSize, Span<byte> buffer, BsdSocketFlags flags)
        {
@ -202,10 +243,10 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Impl
                    shouldBlockAfterOperation = true;
                }

-                if (Blocking && !hasEmittedBlockingWarning)
+                if (Blocking && !_hasEmittedBlockingWarning)
                {
                    Logger.Warning?.PrintMsg(LogClass.ServiceBsd, "Blocking socket operations are not yet working properly. Expect network errors.");
-                    hasEmittedBlockingWarning = true;
+                    _hasEmittedBlockingWarning = true;
                }

                receiveSize = Socket.Receive(buffer, ConvertBsdSocketFlags(flags));
@ -214,6 +255,10 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Impl
            }
            catch (SocketException exception)
            {
+                if (exception.SocketErrorCode != SocketError.WouldBlock)
+                {
+                    Logger.Warning?.Print(LogClass.ServiceBsd, $"Socket Exception: {exception}");
+                }
                receiveSize = -1;

                result = WinSockHelper.ConvertError((WsaError)exception.ErrorCode);
@ -245,10 +290,10 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Impl
                    shouldBlockAfterOperation = true;
                }

-                if (Blocking && !hasEmittedBlockingWarning)
+                if (Blocking && !_hasEmittedBlockingWarning)
                {
                    Logger.Warning?.PrintMsg(LogClass.ServiceBsd, "Blocking socket operations are not yet working properly. Expect network errors.");
-                    hasEmittedBlockingWarning = true;
+                    _hasEmittedBlockingWarning = true;
                }

                if (!Socket.IsBound)
@ -265,6 +310,10 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Impl
            }
            catch (SocketException exception)
            {
+                if (exception.SocketErrorCode != SocketError.WouldBlock)
+                {
+                    Logger.Warning?.Print(LogClass.ServiceBsd, $"Socket Exception: {exception}");
+                }
                receiveSize = -1;

                result = WinSockHelper.ConvertError((WsaError)exception.ErrorCode);
@ -288,6 +337,10 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Impl
            }
            catch (SocketException exception)
            {
+                if (exception.SocketErrorCode != SocketError.WouldBlock)
+                {
+                    Logger.Warning?.Print(LogClass.ServiceBsd, $"Socket Exception: {exception}");
+                }
                sendSize = -1;

                return WinSockHelper.ConvertError((WsaError)exception.ErrorCode);
@ -304,6 +357,10 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Impl
            }
            catch (SocketException exception)
            {
+                if (exception.SocketErrorCode != SocketError.WouldBlock)
+                {
+                    Logger.Warning?.Print(LogClass.ServiceBsd, $"Socket Exception: {exception}");
+                }
                sendSize = -1;

                return WinSockHelper.ConvertError((WsaError)exception.ErrorCode);
@ -341,6 +398,10 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Impl
            }
            catch (SocketException exception)
            {
+                if (exception.SocketErrorCode != SocketError.WouldBlock)
+                {
+                    Logger.Warning?.Print(LogClass.ServiceBsd, $"Socket Exception: {exception}");
+                }
                return WinSockHelper.ConvertError((WsaError)exception.ErrorCode);
            }
        }
@ -387,6 +448,10 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Impl
            }
            catch (SocketException exception)
            {
+                if (exception.SocketErrorCode != SocketError.WouldBlock)
+                {
+                    Logger.Warning?.Print(LogClass.ServiceBsd, $"Socket Exception: {exception}");
+                }
                return WinSockHelper.ConvertError((WsaError)exception.ErrorCode);
            }
        }
@ -519,6 +584,10 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Impl
            }
            catch (SocketException exception)
            {
+                if (exception.SocketErrorCode != SocketError.WouldBlock)
+                {
+                    Logger.Warning?.Print(LogClass.ServiceBsd, $"Socket Exception: {exception}");
+                }
                return WinSockHelper.ConvertError((WsaError)exception.ErrorCode);
            }
        }
@ -557,6 +626,10 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Impl
            }
            catch (SocketException exception)
            {
+                if (exception.SocketErrorCode != SocketError.WouldBlock)
+                {
+                    Logger.Warning?.Print(LogClass.ServiceBsd, $"Socket Exception: {exception}");
+                }
                return WinSockHelper.ConvertError((WsaError)exception.ErrorCode);
            }
        }
--- a/src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Impl/WinSockHelper.cs
+++ b/src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Impl/WinSockHelper.cs
@ -150,6 +150,7 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Impl
            { BsdSocketOption.SoLinger,      SocketOptionName.Linger },
            { BsdSocketOption.SoOobInline,   SocketOptionName.OutOfBandInline },
            { BsdSocketOption.SoReusePort,   SocketOptionName.ReuseAddress },
+            { BsdSocketOption.SoNoSigpipe,   SocketOptionName.DontLinger },
            { BsdSocketOption.SoSndBuf,      SocketOptionName.SendBuffer },
            { BsdSocketOption.SoRcvBuf,      SocketOptionName.ReceiveBuffer },
            { BsdSocketOption.SoSndLoWat,    SocketOptionName.SendLowWater },
--- a/src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Proxy/SocketHelpers.cs
+++ b/src/Ryujinx.HLE/HOS/Services/Sockets/Bsd/Proxy/SocketHelpers.cs
@ -1,4 +1,6 @@
+using Ryujinx.Common.Logging;
 using Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnRyu.Proxy;
+using Ryujinx.HLE.HOS.Services.Sockets.Bsd.Types;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@ -64,10 +66,18 @@ namespace Ryujinx.HLE.HOS.Services.Sockets.Bsd.Proxy
            {
                if (_proxy.Supported(domain, type, protocol))
                {
+                    Logger.Info?.PrintMsg(LogClass.ServiceBsd, $"Socket is using LDN proxy");
                    return new LdnProxySocket(domain, type, protocol, _proxy);
                }
+                else
+                {
+                    Logger.Warning?.PrintMsg(LogClass.ServiceBsd, $"LDN proxy does not support socket {domain}, {type}, {protocol}");
+                }
+            }
+            else
+            {
+                Logger.Info?.PrintMsg(LogClass.ServiceBsd, $"Opening socket using host networking stack");
            }
-
            return new DefaultSocket(domain, type, protocol, lanInterfaceId);
        }
    }
--- a/src/Ryujinx.HLE/UI/IHostUIHandler.cs
+++ b/src/Ryujinx.HLE/UI/IHostUIHandler.cs
@ -45,10 +45,12 @@ namespace Ryujinx.HLE.UI
        /// <param name="value">The value associated to the <paramref name="kind"/>.</param>
        void ExecuteProgram(Switch device, ProgramSpecifyKind kind, ulong value);

+        /// <summary>
        /// Displays a Message Dialog box specific to Error Applet and blocks until it is closed.
        /// </summary>
        /// <returns>False when OK is pressed, True when another button (Details) is pressed.</returns>
-        bool DisplayErrorAppletDialog(string title, string message, string[] buttonsText);
+        // ReSharper disable once UnusedParameter.Global
+        bool DisplayErrorAppletDialog(string title, string message, string[] buttonsText, (uint Module, uint Description)? errorCode = null);

        /// <summary>
        /// Creates a handler to process keyboard inputs into text strings.
--- a/src/Ryujinx.Horizon/HorizonStatic.cs
+++ b/src/Ryujinx.Horizon/HorizonStatic.cs
@ -1,36 +1,37 @@
-using MsgPack;
 using Ryujinx.Horizon.Common;
+using Ryujinx.Horizon.Prepo.Types;
 using Ryujinx.Memory;
 using System;
+using System.Threading;

 namespace Ryujinx.Horizon
 {
    public static class HorizonStatic
    {
-        internal static void HandlePlayReport(MessagePackObject report) => PlayReportPrinted?.Invoke(report);
+        internal static void HandlePlayReport(PlayReport report) => 
+            new Thread(() => PlayReport?.Invoke(report))
+            {
+                Name = "HLE.PlayReportEvent", 
+                IsBackground = true,
+                Priority = ThreadPriority.AboveNormal
+            }.Start();
        
-        public static event Action<MessagePackObject> PlayReportPrinted;
-        
-        [ThreadStatic]
-        private static HorizonOptions _options;
+        public static event Action<PlayReport> PlayReport;

-        [ThreadStatic]
-        private static ISyscallApi _syscall;
+        [field: ThreadStatic]
+        public static HorizonOptions Options { get; private set; }

-        [ThreadStatic]
-        private static IVirtualMemoryManager _addressSpace;
+        [field: ThreadStatic]
+        public static ISyscallApi Syscall { get; private set; }

-        [ThreadStatic]
-        private static IThreadContext _threadContext;
+        [field: ThreadStatic]
+        public static IVirtualMemoryManager AddressSpace { get; private set; }

-        [ThreadStatic]
-        private static int _threadHandle;
+        [field: ThreadStatic]
+        public static IThreadContext ThreadContext { get; private set; }

-        public static HorizonOptions Options => _options;
-        public static ISyscallApi Syscall => _syscall;
-        public static IVirtualMemoryManager AddressSpace => _addressSpace;
-        public static IThreadContext ThreadContext => _threadContext;
-        public static int CurrentThreadHandle => _threadHandle;
+        [field: ThreadStatic]
+        public static int CurrentThreadHandle { get; private set; }

        public static void Register(
            HorizonOptions options,
@ -39,11 +40,11 @@ namespace Ryujinx.Horizon
            IThreadContext threadContext,
            int threadHandle)
        {
-            _options = options;
-            _syscall = syscallApi;
-            _addressSpace = addressSpace;
-            _threadContext = threadContext;
-            _threadHandle = threadHandle;
+            Options = options;
+            Syscall = syscallApi;
+            AddressSpace = addressSpace;
+            ThreadContext = threadContext;
+            CurrentThreadHandle = threadHandle;
        }
    }
 }
--- a/src/Ryujinx.Horizon/Prepo/Ipc/PrepoService.cs
+++ b/src/Ryujinx.Horizon/Prepo/Ipc/PrepoService.cs
@ -17,12 +17,6 @@ namespace Ryujinx.Horizon.Prepo.Ipc
 {
    partial class PrepoService : IPrepoService
    {
-        enum PlayReportKind
-        {
-            Normal,
-            System,
-        }
-
        private readonly ArpApi _arp;
        private readonly PrepoServicePermissionLevel _permissionLevel;
        private ulong _systemSessionId;
@ -194,10 +188,17 @@ namespace Ryujinx.Horizon.Prepo.Ipc
            {
                return PrepoResult.InvalidBufferSize;
            }
-
+            
            StringBuilder builder = new();
            MessagePackObject deserializedReport = MessagePackSerializer.UnpackMessagePackObject(reportBuffer.ToArray());

+            PlayReport playReport = new()
+            {
+                Kind = playReportKind, 
+                Room = gameRoom,
+                ReportData = deserializedReport
+            };
+            
            builder.AppendLine();
            builder.AppendLine("PlayReport log:");
            builder.AppendLine($" Kind: {playReportKind}");
@ -207,10 +208,12 @@ namespace Ryujinx.Horizon.Prepo.Ipc
            if (pid != 0)
            {
                builder.AppendLine($" Pid: {pid}");
+                playReport.Pid = pid;
            }
            else
            {
                builder.AppendLine($" ApplicationId: {applicationId}");
+                playReport.AppId = applicationId;
            }

            Result result = _arp.GetApplicationInstanceId(out ulong applicationInstanceId, pid);
@ -221,17 +224,20 @@ namespace Ryujinx.Horizon.Prepo.Ipc

            _arp.GetApplicationLaunchProperty(out ApplicationLaunchProperty applicationLaunchProperty, applicationInstanceId).AbortOnFailure();

+            playReport.Version = applicationLaunchProperty.Version;
+            
            builder.AppendLine($" ApplicationVersion: {applicationLaunchProperty.Version}");

            if (!userId.IsNull)
            {
                builder.AppendLine($" UserId: {userId}");
+                playReport.UserId = userId;
            }

            builder.AppendLine($" Room: {gameRoom}");
            builder.AppendLine($" Report: {MessagePackObjectFormatter.Format(deserializedReport)}");
            
-            HorizonStatic.HandlePlayReport(deserializedReport);
+            HorizonStatic.HandlePlayReport(playReport);

            Logger.Info?.Print(LogClass.ServicePrepo, builder.ToString());

--- a/src/Ryujinx.Horizon/Prepo/Types/PlayReport.cs
+++ b/src/Ryujinx.Horizon/Prepo/Types/PlayReport.cs
@ -0,0 +1,24 @@
+using MsgPack;
+using Ryujinx.Horizon.Sdk.Account;
+using Ryujinx.Horizon.Sdk.Ncm;
+
+namespace Ryujinx.Horizon.Prepo.Types
+{
+    public struct PlayReport
+    {
+        public PlayReportKind Kind { get; init; }
+        public string Room { get; init; }
+        public MessagePackObject ReportData { get; init; }
+        
+        public ApplicationId? AppId;
+        public ulong? Pid;
+        public uint Version;
+        public Uid? UserId;
+    }
+    
+    public enum PlayReportKind
+    {
+        Normal,
+        System,
+    }
+}
--- a/src/Ryujinx.Input/HLE/NpadManager.cs
+++ b/src/Ryujinx.Input/HLE/NpadManager.cs
@ -185,6 +185,15 @@ namespace Ryujinx.Input.HLE
            }
        }

+        public bool InputUpdatesBlocked
+        {
+            get
+            {
+                lock (_lock)
+                    return _blockInputUpdates;
+            }
+        }
+
        public void BlockInputUpdates()
        {
            lock (_lock)
--- a/src/Ryujinx/AppHost.cs
+++ b/src/Ryujinx/AppHost.cs
@ -517,7 +517,7 @@ namespace Ryujinx.Ava
            Device?.System.ChangeDockedModeState(e.NewValue);
        }

-        private void UpdateAudioVolumeState(object sender, ReactiveEventArgs<float> e)
+        public void UpdateAudioVolumeState(object sender, ReactiveEventArgs<float> e)
        {
            Device?.SetVolume(e.NewValue);

@ -938,7 +938,9 @@ namespace Ryujinx.Ava
                ConfigurationState.Instance.System.EnableInternetAccess,
                ConfigurationState.Instance.System.EnableFsIntegrityChecks ? IntegrityCheckLevel.ErrorOnInvalid : IntegrityCheckLevel.None,
                ConfigurationState.Instance.System.FsGlobalAccessLogMode,
-                ConfigurationState.Instance.System.SystemTimeOffset,
+                ConfigurationState.Instance.System.MatchSystemTime 
+                    ? 0 
+                    : ConfigurationState.Instance.System.SystemTimeOffset,
                ConfigurationState.Instance.System.TimeZone,
                ConfigurationState.Instance.System.MemoryManagerMode,
                ConfigurationState.Instance.System.IgnoreMissingServices,
@ -1039,6 +1041,7 @@ namespace Ryujinx.Ava
                if (_viewModel.StartGamesInFullscreen)
                {
                    _viewModel.WindowState = WindowState.FullScreen;
+                    _viewModel.Window.TitleBar.ExtendsContentIntoTitleBar = true;
                }

                if (_viewModel.WindowState is WindowState.FullScreen || _viewModel.StartGamesWithoutUI)
--- a/src/Ryujinx/Assets/locales.json
+++ b/src/Ryujinx/Assets/locales.json
--- a/src/Ryujinx/Common/ThemeManager.cs
+++ b/src/Ryujinx/Common/ThemeManager.cs
@ -1,14 +0,0 @@
-using System;
-
-namespace Ryujinx.Ava.Common
-{
-    public static class ThemeManager
-    {
-        public static event Action ThemeChanged;
-
-        public static void OnThemeChanged()
-        {
-            ThemeChanged?.Invoke();
-        }
-    }
-}
--- a/src/Ryujinx/DiscordIntegrationModule.cs
+++ b/src/Ryujinx/DiscordIntegrationModule.cs
@ -1,19 +1,15 @@
 using DiscordRPC;
 using Gommon;
-using MsgPack;
 using Ryujinx.Ava.Utilities;
 using Ryujinx.Ava.Utilities.AppLibrary;
 using Ryujinx.Ava.Utilities.Configuration;
+using Ryujinx.Ava.Utilities.PlayReport;
 using Ryujinx.Common;
-using Ryujinx.Common.Helper;
 using Ryujinx.Common.Logging;
 using Ryujinx.HLE;
 using Ryujinx.HLE.Loaders.Processes;
 using Ryujinx.Horizon;
-using System;
-using System.Collections.Generic;
-using System.Collections.ObjectModel;
-using System.Linq;
+using Ryujinx.Horizon.Prepo.Types;
 using System.Text;

 namespace Ryujinx.Ava
@ -28,7 +24,7 @@ namespace Ryujinx.Ava

        private static readonly string _description =
            ReleaseInformation.IsValid
-                ? $"{VersionString} {ReleaseInformation.ReleaseChannelOwner}/{ReleaseInformation.ReleaseChannelSourceRepo}@{ReleaseInformation.BuildGitHash}"
+                ? $"{VersionString} {ReleaseInformation.ReleaseChannelOwner}/{ReleaseInformation.ReleaseChannelSourceRepo}"
                : "dev build";

        private const string ApplicationId = "1293250299716173864";
@ -39,6 +35,10 @@ namespace Ryujinx.Ava
        private static DiscordRpcClient _discordClient;
        private static RichPresence _discordPresenceMain;
        private static RichPresence _discordPresencePlaying;
+        private static ApplicationMetadata _currentApp;
+
+        public static bool HasAssetImage(string titleId) => TitleIDs.DiscordGameAssetKeys.ContainsIgnoreCase(titleId);
+        public static bool HasAnalyzer(string titleId) => PlayReports.Analyzer.TitleIds.ContainsIgnoreCase(titleId);

        public static void Initialize()
        {
@ -55,7 +55,8 @@ namespace Ryujinx.Ava

            ConfigurationState.Instance.EnableDiscordIntegration.Event += Update;
            TitleIDs.CurrentApplication.Event += (_, e) => Use(e.NewValue);
-            HorizonStatic.PlayReportPrinted += HandlePlayReport;
+            HorizonStatic.PlayReport += HandlePlayReport;
+            PlayReports.Initialize();
        }

        private static void Update(object sender, ReactiveEventArgs<bool> evnt)
@ -113,37 +114,37 @@ namespace Ryujinx.Ava
        private static void SwitchToPlayingState(ApplicationMetadata appMeta, ProcessResult procRes)
        {
            _discordClient?.SetPresence(_discordPresencePlaying ??= CreatePlayingState(appMeta, procRes));
-        }
-
-        private static void UpdatePlayingState()
-        {
-            _discordClient?.SetPresence(_discordPresencePlaying);
+            _currentApp = appMeta;
        }

        private static void SwitchToMainState()
        {
            _discordClient?.SetPresence(_discordPresenceMain);
            _discordPresencePlaying = null;
+            _currentApp = null;
        }
-        
-        private static readonly PlayReportAnalyzer _playReportAnalyzer = new PlayReportAnalyzer()
-            .AddSpec( // Breath of the Wild
-                "01007ef00011e000",
-                gameSpec =>
-                    gameSpec.AddValueFormatter("IsHardMode", val => val is 1 ? "Playing Master Mode" : "Playing Normal Mode")
-            );

-        private static void HandlePlayReport(MessagePackObject playReport)
+        private static void HandlePlayReport(PlayReport playReport)
        {
+            if (_discordClient is null) return;
            if (!TitleIDs.CurrentApplication.Value.HasValue) return;
            if (_discordPresencePlaying is null) return;

-            Optional<string> details = _playReportAnalyzer.Run(TitleIDs.CurrentApplication.Value, playReport);
+            FormattedValue formattedValue =
+                PlayReports.Analyzer.Format(TitleIDs.CurrentApplication.Value, _currentApp, playReport);

-            if (!details.HasValue) return;
-            
-            _discordPresencePlaying.Details = details;
-            UpdatePlayingState();
+            if (!formattedValue.Handled) return;
+
+            _discordPresencePlaying.Details = TruncateToByteLength(
+                formattedValue.Reset
+                    ? $"Playing {_currentApp.Title}"
+                    : formattedValue.FormattedString
+            );
+
+            if (_discordClient.CurrentPresence.Details.Equals(_discordPresencePlaying.Details))
+                return; //don't trigger an update if the set presence Details are identical to current
+
+            _discordClient.SetPresence(_discordPresencePlaying);
            Logger.Info?.Print(LogClass.UI, "Updated Discord RPC based on a supported play report.");
        }

--- a/src/Ryujinx/Headless/Options.cs
+++ b/src/Ryujinx/Headless/Options.cs
@ -148,7 +148,7 @@ namespace Ryujinx.Headless
                IgnoreMissingServices = configurationState.System.IgnoreMissingServices;
            
            if (NeedsOverride(nameof(IgnoreControllerApplet)))
-                IgnoreControllerApplet = configurationState.System.IgnoreApplet;
+                IgnoreControllerApplet = configurationState.System.IgnoreControllerApplet;
            
            return;
            
@ -387,7 +387,7 @@ namespace Ryujinx.Headless
        [Option("graphics-shaders-dump-path", Required = false, HelpText = "Dumps shaders in this local directory. (Developer only)")]
        public string GraphicsShadersDumpPath { get; set; }

-        [Option("graphics-backend", Required = false, Default = GraphicsBackend.OpenGl, HelpText = "Change Graphics Backend to use.")]
+        [Option("graphics-backend", Required = false, Default = GraphicsBackend.Vulkan, HelpText = "Change Graphics Backend to use.")]
        public GraphicsBackend GraphicsBackend { get; set; }

        [Option("preferred-gpu-vendor", Required = false, Default = "", HelpText = "When using the Vulkan backend, prefer using the GPU from the specified vendor.")]
--- a/src/Ryujinx/Headless/Windows/WindowBase.cs
+++ b/src/Ryujinx/Headless/Windows/WindowBase.cs
@ -513,7 +513,7 @@ namespace Ryujinx.Headless
            Exit();
        }

-        public bool DisplayErrorAppletDialog(string title, string message, string[] buttonsText)
+        public bool DisplayErrorAppletDialog(string title, string message, string[] buttonsText, (uint Module, uint Description)? errorCode = null)
        {
            SDL_MessageBoxData data = new()
            {
@ -521,7 +521,7 @@ namespace Ryujinx.Headless
                message = message,
                buttons = new SDL_MessageBoxButtonData[buttonsText.Length],
                numbuttons = buttonsText.Length,
-                window = WindowHandle,
+                window = WindowHandle
            };

            for (int i = 0; i < buttonsText.Length; i++)
--- a/src/Ryujinx/RyujinxApp.axaml.cs
+++ b/src/Ryujinx/RyujinxApp.axaml.cs
@ -22,6 +22,8 @@ namespace Ryujinx.Ava
 {
    public class RyujinxApp : Application
    {
+        public static event Action ThemeChanged;
+        
        internal static string FormatTitle(LocaleKeys? windowTitleKey = null, bool includeVersion = true)
            => windowTitleKey is null
                ? $"{FullAppName}{(includeVersion ? $" {Program.Version}" : string.Empty)}"
@ -32,6 +34,9 @@ namespace Ryujinx.Ava
        public static MainWindow MainWindow => Current!
            .ApplicationLifetime.Cast<IClassicDesktopStyleApplicationLifetime>()
            .MainWindow.Cast<MainWindow>();
+        
+        public static IClassicDesktopStyleApplicationLifetime AppLifetime => Current!
+            .ApplicationLifetime.Cast<IClassicDesktopStyleApplicationLifetime>();

        public static bool IsClipboardAvailable(out IClipboard clipboard)
        {
@ -109,7 +114,7 @@ namespace Ryujinx.Ava
                    baseStyle = ConfigurationState.Instance.UI.BaseStyle;
                }

-                ThemeManager.OnThemeChanged();
+                ThemeChanged?.Invoke();

                RequestedThemeVariant = baseStyle switch
                {
--- a/src/Ryujinx/UI/Applet/AvaHostUIHandler.cs
+++ b/src/Ryujinx/UI/Applet/AvaHostUIHandler.cs
@ -41,7 +41,7 @@ namespace Ryujinx.Ava.UI.Applet

            bool okPressed = false;

-            if (ConfigurationState.Instance.System.IgnoreApplet)
+            if (ConfigurationState.Instance.System.IgnoreControllerApplet)
                return false;

            Dispatcher.UIThread.InvokeAsync(async () =>
@ -75,31 +75,32 @@ namespace Ryujinx.Ava.UI.Applet
                    bool opened = false;

                    UserResult response = await ContentDialogHelper.ShowDeferredContentDialog(_parent,
-                       title,
-                       message,
-                       string.Empty,
-                       LocaleManager.Instance[LocaleKeys.DialogOpenSettingsWindowLabel],
-                       string.Empty,
-                       LocaleManager.Instance[LocaleKeys.SettingsButtonClose],
-                       (int)Symbol.Important,
-                       deferEvent,
-                       async window =>
-                       {
-                           if (opened)
-                           {
-                               return;
-                           }
+                        title,
+                        message,
+                        string.Empty,
+                        LocaleManager.Instance[LocaleKeys.DialogOpenSettingsWindowLabel],
+                        string.Empty,
+                        LocaleManager.Instance[LocaleKeys.SettingsButtonClose],
+                        (int)Symbol.Important,
+                        deferEvent,
+                        async window =>
+                        {
+                            if (opened)
+                            {
+                                return;
+                            }

-                           opened = true;
+                            opened = true;

-                           _parent.SettingsWindow = new SettingsWindow(_parent.VirtualFileSystem, _parent.ContentManager);
+                            _parent.SettingsWindow =
+                                new SettingsWindow(_parent.VirtualFileSystem, _parent.ContentManager);

-                           await _parent.SettingsWindow.ShowDialog(window);
+                            await _parent.SettingsWindow.ShowDialog(window);

-                           _parent.SettingsWindow = null;
+                            _parent.SettingsWindow = null;

-                           opened = false;
-                       });
+                            opened = false;
+                        });

                    if (response == UserResult.Ok)
                    {
@ -110,7 +111,9 @@ namespace Ryujinx.Ava.UI.Applet
                }
                catch (Exception ex)
                {
-                    await ContentDialogHelper.CreateErrorDialog(LocaleManager.Instance.UpdateAndGetDynamicValue(LocaleKeys.DialogMessageDialogErrorExceptionMessage, ex));
+                    await ContentDialogHelper.CreateErrorDialog(
+                        LocaleManager.Instance.UpdateAndGetDynamicValue(
+                            LocaleKeys.DialogMessageDialogErrorExceptionMessage, ex));

                    dialogCloseEvent.Set();
                }
@ -134,7 +137,9 @@ namespace Ryujinx.Ava.UI.Applet
                try
                {
                    _parent.ViewModel.AppHost.NpadManager.BlockInputUpdates();
-                    (UserResult result, string userInput) = await SwkbdAppletDialog.ShowInputDialog(LocaleManager.Instance[LocaleKeys.SoftwareKeyboard], args);
+                    (UserResult result, string userInput) =
+                        await SwkbdAppletDialog.ShowInputDialog(LocaleManager.Instance[LocaleKeys.SoftwareKeyboard],
+                            args);

                    if (result == UserResult.Ok)
                    {
@ -146,7 +151,9 @@ namespace Ryujinx.Ava.UI.Applet
                {
                    error = true;

-                    await ContentDialogHelper.CreateErrorDialog(LocaleManager.Instance.UpdateAndGetDynamicValue(LocaleKeys.DialogSoftwareKeyboardErrorExceptionMessage, ex));
+                    await ContentDialogHelper.CreateErrorDialog(
+                        LocaleManager.Instance.UpdateAndGetDynamicValue(
+                            LocaleKeys.DialogSoftwareKeyboardErrorExceptionMessage, ex));
                }
                finally
                {
@ -177,7 +184,8 @@ namespace Ryujinx.Ava.UI.Applet
                    args.InitialText = "Ryujinx";
                    args.StringLengthMin = 1;
                    args.StringLengthMax = 25;
-                    (UserResult result, string userInput) = await SwkbdAppletDialog.ShowInputDialog(LocaleManager.Instance[LocaleKeys.CabinetDialog], args);
+                    (UserResult result, string userInput) =
+                        await SwkbdAppletDialog.ShowInputDialog(LocaleManager.Instance[LocaleKeys.CabinetDialog], args);
                    if (result == UserResult.Ok)
                    {
                        inputText = userInput;
@ -201,11 +209,13 @@ namespace Ryujinx.Ava.UI.Applet
            Dispatcher.UIThread.InvokeAsync(async () =>
            {
                dialogCloseEvent.Set();
-                await ContentDialogHelper.CreateInfoDialog(LocaleManager.Instance[LocaleKeys.CabinetScanDialog],
-                string.Empty,
-                LocaleManager.Instance[LocaleKeys.InputDialogOk],
-                string.Empty,
-                LocaleManager.Instance[LocaleKeys.CabinetTitle]);
+                await ContentDialogHelper.CreateInfoDialog(
+                    LocaleManager.Instance[LocaleKeys.CabinetScanDialog],
+                    string.Empty,
+                    LocaleManager.Instance[LocaleKeys.InputDialogOk],
+                    string.Empty,
+                    LocaleManager.Instance[LocaleKeys.CabinetTitle]
+                );
            });
            dialogCloseEvent.WaitOne();
        }
@ -217,7 +227,8 @@ namespace Ryujinx.Ava.UI.Applet
            _parent.ViewModel.AppHost?.Stop();
        }

-        public bool DisplayErrorAppletDialog(string title, string message, string[] buttons)
+        public bool DisplayErrorAppletDialog(string title, string message, string[] buttons,
+            (uint Module, uint Description)? errorCode = null)
        {
            ManualResetEvent dialogCloseEvent = new(false);

@ -229,9 +240,7 @@ namespace Ryujinx.Ava.UI.Applet
                {
                    ErrorAppletWindow msgDialog = new(_parent, buttons, message)
                    {
-                        Title = title,
-                        WindowStartupLocation = WindowStartupLocation.CenterScreen,
-                        Width = 400
+                        Title = title, WindowStartupLocation = WindowStartupLocation.CenterScreen, Width = 400
                    };

                    object response = await msgDialog.Run();
@ -249,7 +258,9 @@ namespace Ryujinx.Ava.UI.Applet
                {
                    dialogCloseEvent.Set();

-                    await ContentDialogHelper.CreateErrorDialog(LocaleManager.Instance.UpdateAndGetDynamicValue(LocaleKeys.DialogErrorAppletErrorExceptionMessage, ex));
+                    await ContentDialogHelper.CreateErrorDialog(
+                        LocaleManager.Instance.UpdateAndGetDynamicValue(
+                            LocaleKeys.DialogErrorAppletErrorExceptionMessage, ex));
                }
            });

@ -259,38 +270,36 @@ namespace Ryujinx.Ava.UI.Applet
        }

        public IDynamicTextInputHandler CreateDynamicTextInputHandler() => new AvaloniaDynamicTextInputHandler(_parent);
-        
+
        public UserProfile ShowPlayerSelectDialog()
        {
            UserId selected = UserId.Null;
            byte[] defaultGuestImage = EmbeddedResources.Read("Ryujinx.HLE/HOS/Services/Account/Acc/GuestUserImage.jpg");
            UserProfile guest = new(new UserId("00000000000000000000000000000080"), "Guest", defaultGuestImage);
-    
+
            ManualResetEvent dialogCloseEvent = new(false);
-    
+
            Dispatcher.UIThread.InvokeAsync(async () =>
            {
                ObservableCollection<BaseModel> profiles = [];
                NavigationDialogHost nav = new();
-                
+
                _parent.AccountManager.GetAllUsers()
                    .OrderBy(x => x.Name)
                    .ForEach(profile => profiles.Add(new Models.UserProfile(profile, nav)));
-                
+
                profiles.Add(new Models.UserProfile(guest, nav));
-                UserSelectorDialogViewModel viewModel = new()
+                ProfileSelectorDialogViewModel viewModel = new()
                {
-                    Profiles = profiles, 
-                    SelectedUserId = _parent.AccountManager.LastOpenedUser.UserId
+                    Profiles = profiles, SelectedUserId = _parent.AccountManager.LastOpenedUser.UserId
                };
-                UserSelectorDialog content = new(viewModel);
-                (selected, _) = await UserSelectorDialog.ShowInputDialog(content);
-        
+                (selected, _) = await ProfileSelectorDialog.ShowInputDialog(viewModel);
+
                dialogCloseEvent.Set();
            });
-    
+
            dialogCloseEvent.WaitOne();
-            
+
            UserProfile profile = _parent.AccountManager.LastOpenedUser;
            if (selected == guest.UserId)
            {
@ -311,6 +320,7 @@ namespace Ryujinx.Ava.UI.Applet
                    }
                }
            }
+
            return profile;
        }
    }
--- a/src/Ryujinx/UI/Applet/ProfileSelectorDialog.axaml
+++ b/src/Ryujinx/UI/Applet/ProfileSelectorDialog.axaml
@ -1,5 +1,5 @@
 <UserControl
-    x:Class="Ryujinx.Ava.UI.Applet.UserSelectorDialog"
+    x:Class="Ryujinx.Ava.UI.Applet.ProfileSelectorDialog"
    xmlns="https://github.com/avaloniaui"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
@ -12,9 +12,9 @@
    d:DesignWidth="800"
    mc:Ignorable="d"
    Focusable="True"
-    x:DataType="viewModels:UserSelectorDialogViewModel">
+    x:DataType="viewModels:ProfileSelectorDialogViewModel">
    <Design.DataContext>
-        <viewModels:UserSelectorDialogViewModel />
+        <viewModels:ProfileSelectorDialogViewModel />
    </Design.DataContext>
    
    <Grid HorizontalAlignment="Stretch" VerticalAlignment="Stretch">
--- a/src/Ryujinx/UI/Applet/ProfileSelectorDialog.axaml.cs
+++ b/src/Ryujinx/UI/Applet/ProfileSelectorDialog.axaml.cs
@ -16,15 +16,15 @@ using UserProfileSft = Ryujinx.HLE.HOS.Services.Account.Acc.UserProfile;

 namespace Ryujinx.Ava.UI.Applet
 {
-    public partial class UserSelectorDialog : UserControl, INotifyPropertyChanged
+    public partial class ProfileSelectorDialog : UserControl
    {
-        public UserSelectorDialogViewModel ViewModel { get; set; }
+        public ProfileSelectorDialogViewModel ViewModel { get; set; }

-        public UserSelectorDialog(UserSelectorDialogViewModel viewModel)
+        public ProfileSelectorDialog(ProfileSelectorDialogViewModel viewModel)
        {
+            DataContext = ViewModel = viewModel;
+            
            InitializeComponent();
-            ViewModel = viewModel;
-            DataContext = ViewModel;
        }
        
        private void Grid_PointerEntered(object sender, PointerEventArgs e)
@ -54,7 +54,7 @@ namespace Ryujinx.Ava.UI.Applet
                    if (ViewModel.Profiles[selectedIndex] is UserProfile userProfile)
                    {
                        ViewModel.SelectedUserId = userProfile.UserId;
-                        Logger.Info?.Print(LogClass.UI, $"Selected user: {userProfile.UserId}");
+                        Logger.Info?.Print(LogClass.UI, $"Selected: {userProfile.UserId}", "ProfileSelector");

                        ObservableCollection<BaseModel> newProfiles = [];

@ -79,7 +79,7 @@ namespace Ryujinx.Ava.UI.Applet
            }
        }

-        public static async Task<(UserId Id, bool Result)> ShowInputDialog(UserSelectorDialog content)
+        public static async Task<(UserId Id, bool Result)> ShowInputDialog(ProfileSelectorDialogViewModel viewModel)
        {
            ContentDialog contentDialog = new()
            {
@ -87,22 +87,25 @@ namespace Ryujinx.Ava.UI.Applet
                PrimaryButtonText = LocaleManager.Instance[LocaleKeys.Continue],
                SecondaryButtonText = string.Empty,
                CloseButtonText = LocaleManager.Instance[LocaleKeys.Cancel],
-                Content = content,
+                Content = new ProfileSelectorDialog(viewModel),
                Padding = new Thickness(0)
            };

            UserId result = UserId.Null;
            bool input = false;
+            
+            contentDialog.Closed += Handler;

+            await ContentDialogHelper.ShowAsync(contentDialog);
+
+            return (result, input);
+            
            void Handler(ContentDialog sender, ContentDialogClosedEventArgs eventArgs)
            {
                if (eventArgs.Result == ContentDialogResult.Primary)
                {
-                    if (contentDialog.Content is UserSelectorDialog view)
-                    {
-                        result = view.ViewModel.SelectedUserId;
-                        input = true;
-                    }
+                    result = viewModel.SelectedUserId;
+                    input = true;
                }
                else
                {
@ -110,12 +113,6 @@ namespace Ryujinx.Ava.UI.Applet
                    input = false;
                }
            }
-
-            contentDialog.Closed += Handler;
-
-            await ContentDialogHelper.ShowAsync(contentDialog);
-
-            return (result, input);
        }
    }
 }
--- a/src/Ryujinx/UI/Controls/ApplicationContextMenu.axaml
+++ b/src/Ryujinx/UI/Controls/ApplicationContextMenu.axaml
@ -19,6 +19,17 @@
        Header="{ext:Locale GameListContextMenuCreateShortcut}"
        Icon="{ext:Icon fa-solid fa-bookmark}"
        ToolTip.Tip="{OnPlatform Default={ext:Locale GameListContextMenuCreateShortcutToolTip}, macOS={ext:Locale GameListContextMenuCreateShortcutToolTipMacOS}}" />
+    <MenuItem
+        IsVisible="{Binding HasCompatibilityEntry}"
+        Click="OpenApplicationCompatibility_Click"
+        Header="{ext:Locale GameListContextMenuShowCompatEntry}"
+        Icon="{ext:Icon mdi-gamepad}"
+        ToolTip.Tip="{ext:Locale GameListContextMenuShowCompatEntryToolTip}"/>
+    <MenuItem
+        Click="OpenApplicationData_Click"
+        Header="{ext:Locale GameListContextMenuShowGameData}"
+        Icon="{ext:Icon mdi-chart-line}"
+        ToolTip.Tip="{ext:Locale GameListContextMenuShowGameDataToolTip}"/>
    <Separator />
    <MenuItem
        Click="OpenUserSaveDirectory_Click"
@ -74,7 +85,6 @@
 		Header="{ext:Locale GameListContextMenuTrimXCI}"
        IsEnabled="{Binding TrimXCIEnabled}"
 		ToolTip.Tip="{ext:Locale GameListContextMenuTrimXCIToolTip}" />
-    <Separator />
    <MenuItem Header="{ext:Locale GameListContextMenuCacheManagement}" Icon="{ext:Icon mdi-cached}">
        <MenuItem
            Click="PurgePtcCache_Click"
@ -112,6 +122,7 @@
            Header="{ext:Locale GameListContextMenuExtractDataRomFS}"
            ToolTip.Tip="{ext:Locale GameListContextMenuExtractDataRomFSToolTip}" />
        <MenuItem
+            IsVisible="{Binding HasDlc}"
            Click="ExtractAocRomFs_Click"
            Header="{ext:Locale GameListContextMenuExtractDataAocRomFS}"
            ToolTip.Tip="{ext:Locale GameListContextMenuExtractDataAocRomFSToolTip}" />
--- a/src/Ryujinx/UI/Controls/ApplicationContextMenu.axaml.cs
+++ b/src/Ryujinx/UI/Controls/ApplicationContextMenu.axaml.cs
@ -12,6 +12,7 @@ using Ryujinx.Ava.UI.ViewModels;
 using Ryujinx.Ava.UI.Windows;
 using Ryujinx.Ava.Utilities;
 using Ryujinx.Ava.Utilities.AppLibrary;
+using Ryujinx.Ava.Utilities.Compat;
 using Ryujinx.Common.Configuration;
 using Ryujinx.Common.Helper;
 using Ryujinx.HLE.HOS;
@ -333,7 +334,7 @@ namespace Ryujinx.Ava.UI.Controls
            if (sender is not MenuItem { DataContext: MainWindowViewModel { SelectedApplication: not null } viewModel })
                return;

-            DownloadableContentModel selectedDlc = await DlcSelectView.Show(viewModel.SelectedApplication.IdBase, viewModel.ApplicationLibrary);
+            DownloadableContentModel selectedDlc = await DlcSelectView.Show(viewModel.SelectedApplication.Id, viewModel.ApplicationLibrary);
            
            if (selectedDlc is not null)
            {
@ -385,6 +386,18 @@ namespace Ryujinx.Ava.UI.Controls
                    viewModel.SelectedApplication.Icon
                );
        }
+        
+        public async void OpenApplicationCompatibility_Click(object sender, RoutedEventArgs args)
+        {
+            if (sender is MenuItem { DataContext: MainWindowViewModel { SelectedApplication: not null } viewModel })
+                await CompatibilityList.Show(viewModel.SelectedApplication.IdString);
+        }
+        
+        public async void OpenApplicationData_Click(object sender, RoutedEventArgs args)
+        {
+            if (sender is MenuItem { DataContext: MainWindowViewModel { SelectedApplication: not null } viewModel })
+                await ApplicationDataView.Show(viewModel.SelectedApplication);
+        }

        public async void RunApplication_Click(object sender, RoutedEventArgs args)
        {
@ -394,12 +407,8 @@ namespace Ryujinx.Ava.UI.Controls

        public async void TrimXCI_Click(object sender, RoutedEventArgs args)
        {
-            MainWindowViewModel viewModel = (sender as MenuItem)?.DataContext as MainWindowViewModel;
-
-            if (viewModel?.SelectedApplication != null)
-            {
+            if (sender is MenuItem { DataContext: MainWindowViewModel { SelectedApplication: not null } viewModel })
                await viewModel.TrimXCIFile(viewModel.SelectedApplication.Path);
-            }
        }
    }
 }
--- a/src/Ryujinx/UI/Controls/ApplicationDataView.axaml
+++ b/src/Ryujinx/UI/Controls/ApplicationDataView.axaml
@ -0,0 +1,189 @@
+<UserControl xmlns="https://github.com/avaloniaui"
+             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:ext="using:Ryujinx.Ava.Common.Markup"
+             xmlns:viewModels="using:Ryujinx.Ava.UI.ViewModels"
+             xmlns:ui="using:FluentAvalonia.UI.Controls"
+             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="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}}"
+                                TextAlignment="Start"
+                                TextWrapping="Wrap">
+                                <ToolTip.Tip>
+                                    <StackPanel Orientation="Vertical">
+                                        <TextBlock 
+                                            Text="{Binding AppData.LocalizedStatusTooltip}" />
+                                        <Separator 
+                                            Margin="0, 10, 0, 10" 
+                                            IsVisible="{Binding AppData.HasCompatibilityLabels}" />
+                                        <TextBlock 
+                                            IsVisible="{Binding AppData.HasCompatibilityLabels}"
+                                            Text="{Binding AppData.FormattedCompatibilityLabels}" />
+                                    </StackPanel>
+                                </ToolTip.Tip>
+                            </TextBlock>
+                            <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" />
+            <StackPanel Orientation="Vertical" Spacing="5">
+                <StackPanel Orientation="Horizontal" Spacing="5">
+                    <ui:SymbolIcon Foreground="ForestGreen" Symbol="Checkmark" IsVisible="{Binding AppData.HasRichPresenceAsset}"/>
+                    <TextBlock
+                        Foreground="ForestGreen"
+                        HorizontalAlignment="Stretch"
+                        IsVisible="{Binding AppData.HasRichPresenceAsset}"
+                        Text="{ext:Locale GameInfoRpcImage}"
+                        TextAlignment="Start"
+                        TextWrapping="Wrap" >
+                    </TextBlock>
+                    <ui:SymbolIcon Foreground="Red" Symbol="Cancel" IsVisible="{Binding !AppData.HasRichPresenceAsset}"/>
+                    <TextBlock
+                        Foreground="Red"
+                        HorizontalAlignment="Stretch"
+                        IsVisible="{Binding !AppData.HasRichPresenceAsset}"
+                        Text="{ext:Locale GameInfoRpcImage}"
+                        TextAlignment="Start"
+                        TextWrapping="Wrap" >
+                    </TextBlock>
+                </StackPanel>
+                <StackPanel Orientation="Horizontal" Spacing="5" ToolTip.Tip="{Binding DynamicRichPresenceDescription}">
+                    <ui:SymbolIcon 
+                        Foreground="ForestGreen" 
+                        Symbol="Checkmark" 
+                        IsVisible="{Binding AppData.HasDynamicRichPresenceSupport}"/>
+                    <TextBlock
+                        Foreground="ForestGreen"
+                        HorizontalAlignment="Stretch"
+                        IsVisible="{Binding AppData.HasDynamicRichPresenceSupport}"
+                        Text="{ext:Locale GameInfoRpcDynamic}"
+                        TextAlignment="Start"
+                        TextWrapping="Wrap">
+                    </TextBlock>
+                    <ui:SymbolIcon 
+                        Foreground="Red" 
+                        Symbol="Cancel" 
+                        IsVisible="{Binding !AppData.HasDynamicRichPresenceSupport}"/>
+                    <TextBlock
+                        Foreground="Red"
+                        HorizontalAlignment="Stretch"
+                        IsVisible="{Binding !AppData.HasDynamicRichPresenceSupport}"
+                        Text="{ext:Locale GameInfoRpcDynamic}"
+                        TextAlignment="Start"
+                        TextWrapping="Wrap" >
+                    </TextBlock>
+                </StackPanel>
+            </StackPanel>
+            <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 Orientation="Vertical" Spacing="5">
+                <Grid 
+                    ColumnDefinitions="Auto,*,Auto">
+                    <TextBlock 
+                        Grid.Column="0"
+                        Text="{ext:Locale GameListHeaderLastPlayed}"
+                        VerticalAlignment="Top"
+                        TextAlignment="Start"
+                        TextWrapping="NoWrap" />
+                    <TextBlock 
+                        Grid.Column="2"
+                        Text="{Binding AppData.LastPlayedString}"
+                        TextAlignment="End"
+                        TextWrapping="Wrap" />
+                </Grid>
+                <Grid 
+                    ColumnDefinitions="Auto,*,Auto"
+                    IsVisible="{Binding AppData.HasPlayedPreviously}">
+                    <TextBlock 
+                        Grid.Column="0"
+                        Text="{ext:Locale GameListHeaderTimePlayed}"
+                        VerticalAlignment="Top"
+                        TextAlignment="Start"
+                        TextWrapping="NoWrap" />
+                    <TextBlock Grid.Column="2"
+                        Text="{Binding AppData.TimePlayedString}"
+                        TextAlignment="End"
+                        TextWrapping="Wrap" />
+                </Grid>
+            </StackPanel>
+        </StackPanel>
+    </StackPanel>
+</UserControl>
--- a/src/Ryujinx/UI/Controls/ApplicationDataView.axaml.cs
+++ b/src/Ryujinx/UI/Controls/ApplicationDataView.axaml.cs
@ -0,0 +1,83 @@
+using Avalonia.Controls;
+using Avalonia.Input.Platform;
+using Avalonia.Interactivity;
+using Avalonia.Styling;
+using FluentAvalonia.UI.Controls;
+using Ryujinx.Ava.Common.Locale;
+using Ryujinx.Ava.UI.Helpers;
+using Ryujinx.Ava.UI.ViewModels;
+using Ryujinx.Ava.UI.Windows;
+using Ryujinx.Ava.Utilities.AppLibrary;
+using Ryujinx.Ava.Utilities.Compat;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace Ryujinx.Ava.UI.Controls
+{
+    public partial class ApplicationDataView : UserControl
+    {
+        public static async Task Show(ApplicationData appData)
+        {
+            ContentDialog contentDialog = new()
+            {
+                Title = appData.Name,
+                PrimaryButtonText = string.Empty,
+                SecondaryButtonText = string.Empty,
+                CloseButtonText = LocaleManager.Instance[LocaleKeys.SettingsButtonClose],
+                MinWidth = 256,
+                Content = new ApplicationDataView { DataContext = new ApplicationDataViewModel(appData) }
+            };
+
+            Style closeButton = new(x => x.Name("CloseButton"));
+            closeButton.Setters.Add(new Setter(WidthProperty, 160d));
+
+            Style closeButtonParent = new(x => x.Name("CommandSpace"));
+            closeButtonParent.Setters.Add(new Setter(HorizontalAlignmentProperty,
+                Avalonia.Layout.HorizontalAlignment.Center));
+
+            contentDialog.Styles.Add(closeButton);
+            contentDialog.Styles.Add(closeButtonParent);
+
+            await ContentDialogHelper.ShowAsync(contentDialog);
+        }
+        
+        public ApplicationDataView()
+        {
+            InitializeComponent();
+        }
+        
+        private async void PlayabilityStatus_OnClick(object sender, RoutedEventArgs e)
+        {
+            if (sender is not Button { Content: TextBlock playabilityLabel })
+                return;
+
+            if (RyujinxApp.AppLifetime.Windows.TryGetFirst(x => x is ContentDialogOverlayWindow, out Window window))
+                window.Close(ContentDialogResult.None);
+            
+            await CompatibilityList.Show((string)playabilityLabel.Tag);
+        }
+
+        private async void IdString_OnClick(object sender, RoutedEventArgs e)
+        {
+            if (DataContext is not MainWindowViewModel mwvm)
+                return;
+            
+            if (sender is not Button { Content: TextBlock idText })
+                return;
+
+            if (!RyujinxApp.IsClipboardAvailable(out IClipboard clipboard))
+                return;
+            
+            ApplicationData appData = mwvm.Applications.FirstOrDefault(it => it.IdString == idText.Text);
+            if (appData is null)
+                return;
+            
+            await clipboard.SetTextAsync(appData.IdString);
+                
+            NotificationHelper.ShowInformation(
+                "Copied Title ID", 
+                $"{appData.Name} ({appData.IdString})");
+        }
+    }
+}
+
--- a/src/Ryujinx/UI/Controls/ApplicationListView.axaml
+++ b/src/Ryujinx/UI/Controls/ApplicationListView.axaml
@ -86,6 +86,41 @@
                                            Text="{Binding Version}"
                                            TextAlignment="Start"
                                            TextWrapping="Wrap" />
+                                        <Button 
+                                            Click="PlayabilityStatus_OnClick" 
+                                            HorizontalContentAlignment="Left"
+                                            VerticalAlignment="Center"
+                                            IsVisible="{Binding HasPlayabilityInfo}"
+                                            Background="{DynamicResource AppListBackgroundColor}"
+                                            Margin="-1, 0, 0, 0"
+                                            Padding="0">
+                                            <ToolTip.Tip>
+                                                <StackPanel Orientation="Vertical">
+                                                    <TextBlock 
+                                                        Text="{Binding LocalizedStatusTooltip}" />
+                                                    <Separator 
+                                                        Margin="0, 10, 0, 10" 
+                                                        IsVisible="{Binding HasCompatibilityLabels}" />
+                                                    <TextBlock 
+                                                        IsVisible="{Binding HasCompatibilityLabels}"
+                                                        Text="{Binding FormattedCompatibilityLabels}" />
+                                                </StackPanel>
+                                            </ToolTip.Tip>
+                                            <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>
                                    </StackPanel>
                                </Border>
                                <StackPanel
@ -117,7 +152,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>
--- a/src/Ryujinx/UI/Controls/ApplicationListView.axaml.cs
+++ b/src/Ryujinx/UI/Controls/ApplicationListView.axaml.cs
@ -5,6 +5,7 @@ using Avalonia.Interactivity;
 using Ryujinx.Ava.UI.Helpers;
 using Ryujinx.Ava.UI.ViewModels;
 using Ryujinx.Ava.Utilities.AppLibrary;
+using Ryujinx.Ava.Utilities.Compat;
 using System;
 using System.Linq;

@ -28,6 +29,17 @@ namespace Ryujinx.Ava.UI.Controls
            if (sender is ListBox { SelectedItem: ApplicationData selected })
                RaiseEvent(new ApplicationOpenedEventArgs(selected, ApplicationOpenedEvent));
        }
+        
+        private async void PlayabilityStatus_OnClick(object sender, RoutedEventArgs e)
+        {
+            if (DataContext is not MainWindowViewModel mwvm)
+                return;
+            
+            if (sender is not Button { Content: TextBlock playabilityLabel })
+                return;
+
+            await CompatibilityList.Show((string)playabilityLabel.Tag);
+        }

        private async void IdString_OnClick(object sender, RoutedEventArgs e)
        {
--- a/src/Ryujinx/UI/Helpers/Converters/MultiplayerInfoConverter.cs
+++ b/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;
        }
    }
 }
--- a/src/Ryujinx/UI/Helpers/Converters/PlayabilityStatusConverter.cs
+++ b/src/Ryujinx/UI/Helpers/Converters/PlayabilityStatusConverter.cs
@ -18,7 +18,7 @@ namespace Ryujinx.Ava.UI.Helpers
                LocaleKeys.CompatibilityListNothing or 
                    LocaleKeys.CompatibilityListBoots or 
                    LocaleKeys.CompatibilityListMenus => Brushes.Red,
-                LocaleKeys.CompatibilityListIngame => Brushes.Yellow,
+                LocaleKeys.CompatibilityListIngame => Brushes.DarkOrange,
                _ => Brushes.ForestGreen
            };

--- a/src/Ryujinx/UI/Helpers/LoggerAdapter.cs
+++ b/src/Ryujinx/UI/Helpers/LoggerAdapter.cs
@ -1,6 +1,7 @@
 using Avalonia.Logging;
 using Avalonia.Utilities;
 using Gommon;
+using Ryujinx.Ava.Utilities.Configuration;
 using Ryujinx.Common.Logging;
 using System;
 using System.Text;
@ -14,13 +15,19 @@ namespace Ryujinx.Ava.UI.Helpers

    internal class LoggerAdapter : ILogSink
    {
+        private static bool _avaloniaLogsEnabled = ConfigurationState.Instance.Logger.EnableAvaloniaLog; 
+        
        public static void Register()
        {
            AvaLogger.Sink = new LoggerAdapter();
+            ConfigurationState.Instance.Logger.EnableAvaloniaLog.Event 
+                += (_, e) => _avaloniaLogsEnabled = e.NewValue;
        }

        private static RyuLogger.Log? GetLog(AvaLogLevel level, string area)
        {
+            if (!_avaloniaLogsEnabled) return null;
+            
            return level switch
            {
                AvaLogLevel.Verbose => RyuLogger.Debug,
--- a/src/Ryujinx/UI/ViewModels/AboutWindowViewModel.cs
+++ b/src/Ryujinx/UI/ViewModels/AboutWindowViewModel.cs
@ -2,6 +2,7 @@ using Avalonia.Media.Imaging;
 using Avalonia.Styling;
 using Avalonia.Threading;
 using CommunityToolkit.Mvvm.ComponentModel;
+using Gommon;
 using Ryujinx.Ava.Common;
 using Ryujinx.Ava.Common.Locale;
 using Ryujinx.Ava.Utilities.Configuration;
@ -24,30 +25,35 @@ namespace Ryujinx.Ava.UI.ViewModels
            Version = RyujinxApp.FullAppName + "\n" + Program.Version;
            UpdateLogoTheme(ConfigurationState.Instance.UI.BaseStyle.Value);

-            ThemeManager.ThemeChanged += ThemeManager_ThemeChanged;
+            RyujinxApp.ThemeChanged += Ryujinx_ThemeChanged;
        }

-        private void ThemeManager_ThemeChanged()
+        private void Ryujinx_ThemeChanged()
        {
            Dispatcher.UIThread.Post(() => UpdateLogoTheme(ConfigurationState.Instance.UI.BaseStyle.Value));
        }

+        private const string LogoPathFormat = "resm:Ryujinx.Assets.UIImages.Logo_{0}_{1}.png?assembly=Ryujinx";
+
        private void UpdateLogoTheme(string theme)
        {
            bool isDarkTheme = theme == "Dark" || (theme == "Auto" && RyujinxApp.DetectSystemTheme() == ThemeVariant.Dark);
+            
+            string themeName = isDarkTheme ? "Dark" : "Light";

-            string basePath = "resm:Ryujinx.Assets.UIImages.";
-            string themeSuffix = isDarkTheme ? "Dark.png" : "Light.png";
-
-            GithubLogo = LoadBitmap($"{basePath}Logo_GitHub_{themeSuffix}?assembly=Ryujinx");
-            DiscordLogo = LoadBitmap($"{basePath}Logo_Discord_{themeSuffix}?assembly=Ryujinx");
+            GithubLogo = LoadBitmap(LogoPathFormat.Format("GitHub", themeName));
+            DiscordLogo = LoadBitmap(LogoPathFormat.Format("Discord", themeName));
        }

        private static Bitmap LoadBitmap(string uri) => new(Avalonia.Platform.AssetLoader.Open(new Uri(uri)));

        public void Dispose()
        {
-            ThemeManager.ThemeChanged -= ThemeManager_ThemeChanged;
+            RyujinxApp.ThemeChanged -= Ryujinx_ThemeChanged;
+            
+            GithubLogo.Dispose();
+            DiscordLogo.Dispose();
+            
            GC.SuppressFinalize(this);
        }
    }
--- a/src/Ryujinx/UI/ViewModels/AmiiboWindowViewModel.cs
+++ b/src/Ryujinx/UI/ViewModels/AmiiboWindowViewModel.cs
@ -264,7 +264,7 @@ namespace Ryujinx.Ava.UI.ViewModels
                    Logger.Error?.Print(LogClass.Application, $"Couldn't get valid amiibo data: {exception}");

                    // Neither local or remote files are valid JSON, close window.
-                    ShowInfoDialog();
+                    await ShowInfoDialog();
                    Close();
                }
                else if (!remoteIsValid)
@ -273,7 +273,7 @@ namespace Ryujinx.Ava.UI.ViewModels

                    // Only the local file is valid, the local one should be used
                    // but the user should be warned.
-                    ShowInfoDialog();
+                    await ShowInfoDialog();
                }
            }

@ -525,7 +525,7 @@ namespace Ryujinx.Ava.UI.ViewModels
            AmiiboImage = bitmap;
        }

-        private static async void ShowInfoDialog()
+        private static async Task ShowInfoDialog()
        {
            await ContentDialogHelper.CreateInfoDialog(LocaleManager.Instance[LocaleKeys.DialogAmiiboApiTitle],
                LocaleManager.Instance[LocaleKeys.DialogAmiiboApiConnectErrorMessage],
--- a/src/Ryujinx/UI/ViewModels/ApplicationDataViewModel.cs
+++ b/src/Ryujinx/UI/ViewModels/ApplicationDataViewModel.cs
@ -0,0 +1,29 @@
+using Gommon;
+using Ryujinx.Ava.Common.Locale;
+using Ryujinx.Ava.Utilities.AppLibrary;
+using Ryujinx.Ava.Utilities.PlayReport;
+
+namespace Ryujinx.Ava.UI.ViewModels
+{
+    public class ApplicationDataViewModel : BaseModel
+    {
+        public ApplicationData AppData { get; }
+
+        public ApplicationDataViewModel(ApplicationData appData) => AppData = appData;
+
+        public string DynamicRichPresenceDescription =>
+            AppData.HasDynamicRichPresenceSupport
+                ? AppData.RichPresenceSpec.Value.Description
+                : GameSpec.DefaultDescription;
+
+        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 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)}";
+    }
+}
--- a/src/Ryujinx/UI/ViewModels/DlcSelectViewModel.cs
+++ b/src/Ryujinx/UI/ViewModels/DlcSelectViewModel.cs
@ -14,9 +14,7 @@ namespace Ryujinx.Ava.UI.ViewModels
        
        public DlcSelectViewModel(ulong titleId, ApplicationLibrary appLibrary)
        {
-            _dlcs = appLibrary.DownloadableContents.Items
-                .Where(x => x.Dlc.TitleIdBase == titleId)
-                .Select(x => x.Dlc)
+            _dlcs = appLibrary.FindDlcsFor(titleId)
                .OrderBy(it => it.IsBundled ? 0 : 1)
                .ThenBy(it => it.TitleId)
                .ToArray();
--- a/src/Ryujinx/UI/ViewModels/DownloadableContentManagerViewModel.cs
+++ b/src/Ryujinx/UI/ViewModels/DownloadableContentManagerViewModel.cs
@ -69,8 +69,7 @@ namespace Ryujinx.Ava.UI.ViewModels

        private void LoadDownloadableContents()
        {
-            IEnumerable<(DownloadableContentModel Dlc, bool IsEnabled)> dlcs = _applicationLibrary.DownloadableContents.Items
-                .Where(it => it.Dlc.TitleIdBase == _applicationData.IdBase);
+            (DownloadableContentModel Dlc, bool IsEnabled)[] dlcs = _applicationLibrary.FindDlcConfigurationFor(_applicationData.Id);

            bool hasBundledContent = false;
            foreach ((DownloadableContentModel dlc, bool isEnabled) in dlcs)
--- a/src/Ryujinx/UI/ViewModels/MainWindowViewModel.cs
+++ b/src/Ryujinx/UI/ViewModels/MainWindowViewModel.cs
@ -7,6 +7,7 @@ using Avalonia.Media.Imaging;
 using Avalonia.Platform.Storage;
 using Avalonia.Threading;
 using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
 using DynamicData;
 using DynamicData.Binding;
 using FluentAvalonia.UI.Controls;
@ -104,6 +105,13 @@ namespace Ryujinx.Ava.UI.ViewModels
        [ObservableProperty] private bool _isSubMenuOpen;
        [ObservableProperty] private ApplicationContextMenu _listAppContextMenu;
        [ObservableProperty] private ApplicationContextMenu _gridAppContextMenu;
+        [ObservableProperty] private bool _updateAvailable;
+
+        public static AsyncRelayCommand UpdateCommand { get; } = Commands.Create(async () =>
+        {
+            if (Updater.CanUpdate(true))
+                await Updater.BeginUpdateAsync(true);
+        });
        
        private bool _showLoadProgress;
        private bool _isGameRunning;
@ -349,6 +357,10 @@ namespace Ryujinx.Ava.UI.ViewModels
            }
        }

+        public bool HasCompatibilityEntry => SelectedApplication.HasPlayabilityInfo;
+
+        public bool HasDlc => ApplicationLibrary.HasDlcs(SelectedApplication.Id);
+
        public bool OpenUserSaveDirectoryEnabled => SelectedApplication.HasControlHolder && SelectedApplication.ControlHolder.Value.UserAccountSaveDataSize > 0;

        public bool OpenDeviceSaveDirectoryEnabled => SelectedApplication.HasControlHolder && SelectedApplication.ControlHolder.Value.DeviceSaveDataSize > 0;
@ -629,15 +641,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,
                };
            }
@ -1143,10 +1155,10 @@ namespace Ryujinx.Ava.UI.ViewModels
                List<string> dirs = result.Select(it => it.Path.LocalPath).ToList();
                int numAdded = onDirsSelected(dirs, out int numRemoved);

-                string msg = String.Join("\r\n", new string[] {
+                string msg = string.Join("\n",
                    string.Format(LocaleManager.Instance[localeMessageRemovedKey], numRemoved),
                    string.Format(LocaleManager.Instance[localeMessageAddedKey], numAdded)
-                });
+                );

                await Dispatcher.UIThread.InvokeAsync(async () =>
                {
@ -1335,6 +1347,25 @@ namespace Ryujinx.Ava.UI.ViewModels
            OpenHelper.OpenFolder(AppDataManager.BaseDirPath);
        }

+        public void OpenScreenshotsFolder()
+        {
+            string screenshotsDir = Path.Combine(AppDataManager.BaseDirPath, "screenshots");
+
+            try
+            {
+                if (!Directory.Exists(screenshotsDir))
+                    Directory.CreateDirectory(screenshotsDir);
+            }
+            catch (Exception ex)
+            {
+                Logger.Error?.Print(LogClass.Application, $"Failed to create directory at path {screenshotsDir}. Error : {ex.GetType().Name}", "Screenshot");
+
+                return;
+            }
+            
+            OpenHelper.OpenFolder(screenshotsDir);
+        }
+
        public void OpenLogsFolder()
        {
            string logPath = AppDataManager.GetOrCreateLogsDir();
--- a/src/Ryujinx/UI/ViewModels/ProfileSelectorDialogViewModel.cs
+++ b/src/Ryujinx/UI/ViewModels/ProfileSelectorDialogViewModel.cs
@ -4,7 +4,7 @@ using System.Collections.ObjectModel;

 namespace Ryujinx.Ava.UI.ViewModels
 {
-    public partial class UserSelectorDialogViewModel : BaseModel
+    public partial class ProfileSelectorDialogViewModel : BaseModel
    {

        [ObservableProperty] private UserId _selectedUserId;
--- a/src/Ryujinx/UI/ViewModels/SettingsViewModel.cs
+++ b/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;
@ -13,6 +13,7 @@ using Ryujinx.Ava.UI.Models.Input;
 using Ryujinx.Ava.UI.Windows;
 using Ryujinx.Ava.Utilities.Configuration;
 using Ryujinx.Ava.Utilities.Configuration.System;
+using Ryujinx.Ava.Utilities.Configuration.UI;
 using Ryujinx.Common.Configuration;
 using Ryujinx.Common.Configuration.Multiplayer;
 using Ryujinx.Common.GraphicsDriver;
@ -28,8 +29,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;

@ -50,8 +49,7 @@ namespace Ryujinx.Ava.UI.ViewModels
        private int _graphicsBackendMultithreadingIndex;
        private float _volume;
        [ObservableProperty] private bool _isVulkanAvailable = true;
-        [ObservableProperty] private bool _gameDirectoryChanged;
-        [ObservableProperty] private bool _autoloadDirectoryChanged;
+        [ObservableProperty] private bool _gameListNeedsRefresh;
        private readonly List<string> _gpuIds = [];
        private int _graphicsBackendIndex;
        private int _scalingFilter;
@ -116,10 +114,6 @@ namespace Ryujinx.Ava.UI.ViewModels

        public bool IsOpenGLAvailable => !OperatingSystem.IsMacOS();

-        public bool IsAppleSiliconMac => OperatingSystem.IsMacOS() && RuntimeInformation.ProcessArchitecture == Architecture.Arm64;
-
-        public bool IsMacOS => OperatingSystem.IsMacOS();
-
        public bool EnableDiscordIntegration { get; set; }
        public bool CheckUpdatesOnStart { get; set; }
        public bool ShowConfirmExit { get; set; }
@ -127,9 +121,14 @@ namespace Ryujinx.Ava.UI.ViewModels
        public bool RememberWindowState { get; set; }
        public bool ShowTitleBar { get; set; }
        public int HideCursor { get; set; }
+        public int UpdateCheckerType { get; set; }
        public bool EnableDockedMode { get; set; }
        public bool EnableKeyboard { get; set; }
        public bool EnableMouse { get; set; }
+        public bool DisableInputWhenOutOfFocus { get; set; }
+        
+        public int FocusLostActionType { get; set; }
+        
        public VSyncMode VSyncMode
        {
            get => _vSyncMode;
@ -201,7 +200,7 @@ namespace Ryujinx.Ava.UI.ViewModels
        public bool EnableTextureRecompression { get; set; }
        public bool EnableMacroHLE { get; set; }
        public bool EnableColorSpacePassthrough { get; set; }
-        public bool ColorSpacePassthroughAvailable => IsMacOS;
+        public bool ColorSpacePassthroughAvailable => RunningPlatform.IsMacOS;
        public bool EnableFileLog { get; set; }
        public bool EnableStub { get; set; }
        public bool EnableInfo { get; set; }
@ -210,6 +209,7 @@ namespace Ryujinx.Ava.UI.ViewModels
        public bool EnableTrace { get; set; }
        public bool EnableGuest { get; set; }
        public bool EnableFsAccessLog { get; set; }
+        public bool EnableAvaloniaLog { get; set; }
        public bool EnableDebug { get; set; }
        public bool IsOpenAlEnabled { get; set; }
        public bool IsSoundIoEnabled { get; set; }
@ -297,6 +297,8 @@ namespace Ryujinx.Ava.UI.ViewModels
            }
        }

+        [ObservableProperty] private bool _matchSystemTime;
+
        public DateTimeOffset CurrentDate { get; set; }

        public TimeSpan CurrentTime { get; set; }
@ -412,17 +414,6 @@ namespace Ryujinx.Ava.UI.ViewModels
            Dispatcher.UIThread.Post(() => OnPropertyChanged(nameof(PreferredGpuIndex)));
        }

-        public void MatchSystemTime()
-        {
-            (DateTimeOffset dto, TimeSpan timeOfDay) = DateTimeOffset.Now.Extract();
-            
-            CurrentDate = dto;
-            CurrentTime = timeOfDay;
-            
-            OnPropertyChanged(nameof(CurrentDate));
-            OnPropertyChanged(nameof(CurrentTime));
-        }
-
        public async Task LoadTimeZones()
        {
            _timeZoneContentManager = new TimeZoneContentManager();
@ -490,6 +481,8 @@ namespace Ryujinx.Ava.UI.ViewModels
            RememberWindowState = config.RememberWindowState;
            ShowTitleBar = config.ShowTitleBar;
            HideCursor = (int)config.HideCursor.Value;
+            UpdateCheckerType = (int)config.UpdateCheckerType.Value;
+            FocusLostActionType = (int)config.FocusLostActionType.Value;

            GameDirectories.Clear();
            GameDirectories.AddRange(config.UI.GameDirs.Value);
@ -509,6 +502,7 @@ namespace Ryujinx.Ava.UI.ViewModels
            EnableDockedMode = config.System.EnableDockedMode;
            EnableKeyboard = config.Hid.EnableKeyboard;
            EnableMouse = config.Hid.EnableMouse;
+            DisableInputWhenOutOfFocus = config.Hid.DisableInputWhenOutOfFocus;

            // Keyboard Hotkeys
            KeyboardHotkey = new HotkeyConfig(config.Hid.Hotkeys.Value);
@ -524,13 +518,15 @@ namespace Ryujinx.Ava.UI.ViewModels
            CurrentDate = currentDateTime.Date;
            CurrentTime = currentDateTime.TimeOfDay;

-            EnableCustomVSyncInterval = config.Graphics.EnableCustomVSyncInterval.Value;
+            MatchSystemTime = config.System.MatchSystemTime;
+
+            EnableCustomVSyncInterval = config.Graphics.EnableCustomVSyncInterval;
            CustomVSyncInterval = config.Graphics.CustomVSyncInterval;
            VSyncMode = config.Graphics.VSyncMode;
            EnableFsIntegrityChecks = config.System.EnableFsIntegrityChecks;
            DramSize = config.System.DramSize;
            IgnoreMissingServices = config.System.IgnoreMissingServices;
-            IgnoreApplet = config.System.IgnoreApplet;
+            IgnoreApplet = config.System.IgnoreControllerApplet;

            // CPU
            EnablePptc = config.System.EnablePtc;
@ -573,6 +569,7 @@ namespace Ryujinx.Ava.UI.ViewModels
            EnableGuest = config.Logger.EnableGuest;
            EnableDebug = config.Logger.EnableDebug;
            EnableFsAccessLog = config.Logger.EnableFsAccessLog;
+            EnableAvaloniaLog = config.Logger.EnableAvaloniaLog;
            FsGlobalAccessLogMode = config.System.FsGlobalAccessLogMode;
            OpenglDebugLevel = (int)config.Logger.GraphicsDebugLevel.Value;

@ -593,16 +590,10 @@ namespace Ryujinx.Ava.UI.ViewModels
            config.RememberWindowState.Value = RememberWindowState;
            config.ShowTitleBar.Value = ShowTitleBar;
            config.HideCursor.Value = (HideCursorMode)HideCursor;
-
-            if (GameDirectoryChanged)
-            {
-                config.UI.GameDirs.Value = [..GameDirectories];
-            }
-
-            if (AutoloadDirectoryChanged)
-            {
-                config.UI.AutoloadDirs.Value = [..AutoloadDirectories];
-            }
+            config.UpdateCheckerType.Value = (UpdaterType)UpdateCheckerType;
+            config.FocusLostActionType.Value = (FocusLostType)FocusLostActionType;
+            config.UI.GameDirs.Value = [..GameDirectories];
+            config.UI.AutoloadDirs.Value = [..AutoloadDirectories];

            config.UI.BaseStyle.Value = BaseStyleIndex switch
            {
@ -616,24 +607,29 @@ namespace Ryujinx.Ava.UI.ViewModels
            config.System.EnableDockedMode.Value = EnableDockedMode;
            config.Hid.EnableKeyboard.Value = EnableKeyboard;
            config.Hid.EnableMouse.Value = EnableMouse;
+            config.Hid.DisableInputWhenOutOfFocus.Value = DisableInputWhenOutOfFocus;

            // Keyboard Hotkeys
            config.Hid.Hotkeys.Value = KeyboardHotkey.GetConfig();

            // System
            config.System.Region.Value = (Region)Region;
+            
+            if (config.System.Language.Value != (Language)Language)
+                GameListNeedsRefresh = true;
+            
            config.System.Language.Value = (Language)Language;
-
            if (_validTzRegions.Contains(TimeZone))
            {
                config.System.TimeZone.Value = TimeZone;
            }

+            config.System.MatchSystemTime.Value = MatchSystemTime;
            config.System.SystemTimeOffset.Value = Convert.ToInt64((CurrentDate.ToUnixTimeSeconds() + CurrentTime.TotalSeconds) - DateTimeOffset.Now.ToUnixTimeSeconds());
            config.System.EnableFsIntegrityChecks.Value = EnableFsIntegrityChecks;
            config.System.DramSize.Value = DramSize;
            config.System.IgnoreMissingServices.Value = IgnoreMissingServices;
-            config.System.IgnoreApplet.Value = IgnoreApplet;
+            config.System.IgnoreControllerApplet.Value = IgnoreApplet;

            // CPU
            config.System.EnablePtc.Value = EnablePptc;
@ -691,6 +687,7 @@ namespace Ryujinx.Ava.UI.ViewModels
            config.Logger.EnableGuest.Value = EnableGuest;
            config.Logger.EnableDebug.Value = EnableDebug;
            config.Logger.EnableFsAccessLog.Value = EnableFsAccessLog;
+            config.Logger.EnableAvaloniaLog.Value = EnableAvaloniaLog;
            config.System.FsGlobalAccessLogMode.Value = FsGlobalAccessLogMode;
            config.Logger.GraphicsDebugLevel.Value = (GraphicsDebugLevel)OpenglDebugLevel;

@ -712,8 +709,7 @@ namespace Ryujinx.Ava.UI.ViewModels

            SaveSettingsEvent?.Invoke();

-            GameDirectoryChanged = false;
-            AutoloadDirectoryChanged = false;
+            GameListNeedsRefresh = false;
        }

        private static void RevertIfNotSaved()
@ -732,6 +728,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();
--- a/src/Ryujinx/UI/ViewModels/TitleUpdateViewModel.cs
+++ b/src/Ryujinx/UI/ViewModels/TitleUpdateViewModel.cs
@ -41,8 +41,7 @@ namespace Ryujinx.Ava.UI.ViewModels

        private void LoadUpdates()
        {
-            IEnumerable<(TitleUpdateModel TitleUpdate, bool IsSelected)> updates = ApplicationLibrary.TitleUpdates.Items
-                .Where(it => it.TitleUpdate.TitleIdBase == ApplicationData.IdBase);
+            (TitleUpdateModel TitleUpdate, bool IsSelected)[] updates = ApplicationLibrary.FindUpdateConfigurationFor(ApplicationData.Id);

            bool hasBundledContent = false;
            SelectedUpdate = new TitleUpdateViewModelNoUpdate();
--- a/src/Ryujinx/UI/Views/Main/MainMenuBarView.axaml
+++ b/src/Ryujinx/UI/Views/Main/MainMenuBarView.axaml
@ -66,6 +66,10 @@
                    Command="{Binding OpenRyujinxFolder}"
                    Header="{ext:Locale MenuBarFileOpenEmuFolder}"
                    ToolTip.Tip="{ext:Locale OpenRyujinxFolderTooltip}" />
+                <MenuItem
+                    Command="{Binding OpenScreenshotsFolder}"
+                    Header="{ext:Locale MenuBarFileOpenScreenshotsFolder}"
+                    ToolTip.Tip="{ext:Locale OpenScreenshotFolderTooltip}"/>
                <MenuItem
                    Command="{Binding OpenLogsFolder}"
                    Header="{ext:Locale MenuBarFileOpenLogsFolder}"
--- a/src/Ryujinx/UI/Views/Main/MainMenuBarView.axaml.cs
+++ b/src/Ryujinx/UI/Views/Main/MainMenuBarView.axaml.cs
@ -50,13 +50,9 @@ namespace Ryujinx.Ava.UI.Views.Main
            UninstallFileTypesMenuItem.Command = Commands.Create(UninstallFileTypes);
            XciTrimmerMenuItem.Command = Commands.Create(XCITrimmerWindow.Show);
            AboutWindowMenuItem.Command = Commands.Create(AboutWindow.Show);
-            CompatibilityListMenuItem.Command = Commands.Create(CompatibilityList.Show);
-            
-            UpdateMenuItem.Command = Commands.Create(async () =>
-            {
-                if (Updater.CanUpdate(true))
-                    await Updater.BeginUpdateAsync(true);
-            });
+            CompatibilityListMenuItem.Command = Commands.Create(() => CompatibilityList.Show());
+
+            UpdateMenuItem.Command = MainWindowViewModel.UpdateCommand;

            FaqMenuItem.Command = 
                SetupGuideMenuItem.Command = 
--- a/src/Ryujinx/UI/Views/Main/MainStatusBarView.axaml
+++ b/src/Ryujinx/UI/Views/Main/MainStatusBarView.axaml
@ -23,7 +23,7 @@
        Background="{DynamicResource ThemeContentBackgroundColor}"
        DockPanel.Dock="Bottom"
        IsVisible="{Binding ShowMenuAndStatusBar}"
-        ColumnDefinitions="Auto,Auto,*,Auto,Auto">
+        ColumnDefinitions="Auto,Auto,*,Auto,Auto,Auto">
        <StackPanel
            Grid.Column="0"
            Margin="5"
@ -280,9 +280,31 @@
                Text="{Binding GpuNameText}"
                TextAlignment="Start" />
        </StackPanel>
-        <StackPanel
+        <StackPanel 
            Grid.Column="4"
            Margin="0,0,5,0"
+            Orientation="Horizontal">
+            <StackPanel.IsVisible>
+                <MultiBinding Converter="{x:Static BoolConverters.And}">
+                    <Binding Path="EnableNonGameRunningControls" />
+                    <Binding Path="UpdateAvailable" />
+                </MultiBinding>
+            </StackPanel.IsVisible>
+            <Button Margin="0, 0, 5, -2"
+                    Command="{Binding UpdateCommand}"
+                    Background="{DynamicResource SystemAccentColor}">
+                <TextBlock
+                    Margin="-5"
+                    Foreground="{StaticResource SystemColorButtonTextColor}"
+                    HorizontalAlignment="Right"
+                    VerticalAlignment="Center"
+                    Text="{ext:Locale UpdaterBackgroundStatusBarButtonText}" />
+            </Button>
+            <controls:MiniVerticalSeparator Margin="5,0,0,0"/>
+        </StackPanel>
+        <StackPanel
+            Grid.Column="5"
+            Margin="0,0,5,0"
            VerticalAlignment="Center"
            IsVisible="{Binding ShowFirmwareStatus}"
            Orientation="Horizontal">
--- a/src/Ryujinx/UI/Views/Main/MainViewControls.axaml
+++ b/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" />
--- a/src/Ryujinx/UI/Views/Settings/SettingsCPUView.axaml
+++ b/src/Ryujinx/UI/Views/Settings/SettingsCPUView.axaml
@ -6,6 +6,7 @@
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    xmlns:ext="clr-namespace:Ryujinx.Ava.Common.Markup"
    xmlns:viewModels="clr-namespace:Ryujinx.Ava.UI.ViewModels"
+    xmlns:helper="clr-namespace:Ryujinx.Common.Helper;assembly=Ryujinx.Common"
    mc:Ignorable="d"
    x:DataType="viewModels:SettingsViewModel">
    <Design.DataContext>
@ -69,7 +70,7 @@
                        </ComboBox>
                    </StackPanel>
                    <CheckBox IsChecked="{Binding UseHypervisor}"
-                              IsVisible="{Binding IsAppleSiliconMac}"
+                              IsVisible="{x:Static helper:RunningPlatform.IsArmMac}"
                              ToolTip.Tip="{ext:Locale UseHypervisorTooltip}">
                        <TextBlock Text="{ext:Locale SettingsTabSystemUseHypervisor}"
                                   ToolTip.Tip="{ext:Locale UseHypervisorTooltip}" />
--- a/src/Ryujinx/UI/Views/Settings/SettingsGraphicsView.axaml
+++ b/src/Ryujinx/UI/Views/Settings/SettingsGraphicsView.axaml
@ -8,6 +8,7 @@
    xmlns:ui="clr-namespace:FluentAvalonia.UI.Controls;assembly=FluentAvalonia"
    xmlns:ext="clr-namespace:Ryujinx.Ava.Common.Markup"
    xmlns:viewModels="clr-namespace:Ryujinx.Ava.UI.ViewModels"
+    xmlns:helper="clr-namespace:Ryujinx.Common.Helper;assembly=Ryujinx.Common"
    Design.Width="1000"
    mc:Ignorable="d"
    x:DataType="viewModels:SettingsViewModel">
@ -48,7 +49,7 @@
                            <ComboBoxItem IsEnabled="{Binding IsOpenGLAvailable}">
                                <TextBlock Text="OpenGL" />
                            </ComboBoxItem>
-                            <ComboBoxItem IsEnabled="{Binding IsAppleSiliconMac}">
+                            <ComboBoxItem IsEnabled="{x:Static helper:RunningPlatform.IsArmMac}">
                                <TextBlock Text="Metal (ARM Mac only, Experimental)" />
                            </ComboBoxItem>
                        </ComboBox>
--- a/src/Ryujinx/UI/Views/Settings/SettingsLoggingView.axaml
+++ b/src/Ryujinx/UI/Views/Settings/SettingsLoggingView.axaml
@ -74,6 +74,10 @@
                                  ToolTip.Tip="{ext:Locale DebugLogTooltip}">
                            <TextBlock Text="{ext:Locale SettingsTabLoggingEnableDebugLogs}" />
                        </CheckBox>
+                        <CheckBox IsChecked="{Binding EnableAvaloniaLog}"
+                                  ToolTip.Tip="{ext:Locale AvaloniaLogTooltip}">
+                            <TextBlock Text="{ext:Locale SettingsTabLoggingEnableAvaloniaLogs}" />
+                        </CheckBox>
                        <StackPanel Margin="0,10,0,0" Orientation="Horizontal" VerticalAlignment="Stretch">
                            <TextBlock VerticalAlignment="Center"
                                    ToolTip.Tip="{ext:Locale FSAccessLogModeTooltip}"
--- a/src/Ryujinx/UI/Views/Settings/SettingsSystemView.axaml
+++ b/src/Ryujinx/UI/Views/Settings/SettingsSystemView.axaml
@ -170,7 +170,8 @@
                            ToolTip.Tip="{ext:Locale TimeTooltip}"
                            Width="250"/>
                        <DatePicker
-                            VerticalAlignment="Center" 
+                            VerticalAlignment="Center"
+                            IsEnabled="{Binding !MatchSystemTime}"
                            SelectedDate="{Binding CurrentDate}"
                            ToolTip.Tip="{ext:Locale TimeTooltip}"
                            Width="350" />
@ -181,17 +182,21 @@
                        <TimePicker
                            VerticalAlignment="Center"
                            ClockIdentifier="24HourClock"
+                            IsEnabled="{Binding !MatchSystemTime}"
                            SelectedTime="{Binding CurrentTime}"
                            Width="350"
                            ToolTip.Tip="{ext:Locale TimeTooltip}" />
-                        <Button
-                            Margin="10, 0, 0, 0"
+                    </StackPanel>
+                    <StackPanel Orientation="Horizontal">
+                        <TextBlock
                            VerticalAlignment="Center"
-                            Click="MatchSystemTime_OnClick"
-                            Background="{DynamicResource SystemAccentColor}"
-                            ToolTip.Tip="{ext:Locale MatchTimeTooltip}">
-                            <TextBlock Text="{ext:Locale SettingsTabSystemSystemTimeMatch}" />
-                        </Button>
+                            Text="{ext:Locale SettingsTabSystemSystemTimeMatch}"
+                            ToolTip.Tip="{ext:Locale MatchTimeTooltip}"
+                            Width="250"/>
+                        <CheckBox
+                            VerticalAlignment="Center"
+                            IsChecked="{Binding MatchSystemTime}"
+                            ToolTip.Tip="{ext:Locale MatchTimeTooltip}"/>
                    </StackPanel>
                    <Separator />
                    <StackPanel Margin="0,10,0,10"
@ -311,8 +316,8 @@
                    </CheckBox>
                    <CheckBox 
                        IsChecked="{Binding IgnoreApplet}"
-                        ToolTip.Tip="{ext:Locale IgnoreAppletTooltip}">
-                        <TextBlock Text="{ext:Locale SettingsTabSystemIgnoreApplet}" />
+                        ToolTip.Tip="{ext:Locale IgnoreControllerAppletTooltip}">
+                        <TextBlock Text="{ext:Locale SettingsTabSystemIgnoreControllerApplet}" />
                    </CheckBox>
                    <CheckBox
                        IsChecked="{Binding EnableCustomVSyncInterval}"
--- a/src/Ryujinx/UI/Views/Settings/SettingsSystemView.axaml.cs
+++ b/src/Ryujinx/UI/Views/Settings/SettingsSystemView.axaml.cs
@ -1,5 +1,4 @@
 using Avalonia.Controls;
-using Avalonia.Interactivity;
 using Ryujinx.Ava.UI.ViewModels;
 using TimeZone = Ryujinx.Ava.UI.Models.TimeZone;

@ -34,7 +33,5 @@ namespace Ryujinx.Ava.UI.Views.Settings
                ViewModel.ValidateAndSetTimeZone(timeZone.Location);
            }
        }
-
-        private void MatchSystemTime_OnClick(object sender, RoutedEventArgs e) => ViewModel.MatchSystemTime();
    }
 }
--- a/src/Ryujinx/UI/Views/Settings/SettingsUIView.axaml
+++ b/src/Ryujinx/UI/Views/Settings/SettingsUIView.axaml
@ -6,6 +6,7 @@
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    xmlns:ext="clr-namespace:Ryujinx.Ava.Common.Markup"
    xmlns:viewModels="clr-namespace:Ryujinx.Ava.UI.ViewModels"
+    xmlns:helper="clr-namespace:Ryujinx.Common.Helper;assembly=Ryujinx.Common"
    mc:Ignorable="d"
    x:DataType="viewModels:SettingsViewModel">
    <Design.DataContext>
@ -30,18 +31,57 @@
                                   ToolTip.Tip="{ext:Locale ToggleDiscordTooltip}"
                                   Text="{ext:Locale SettingsTabGeneralEnableDiscordRichPresence}" />
                    </CheckBox>
-                    <CheckBox IsChecked="{Binding CheckUpdatesOnStart}">
-                        <TextBlock Text="{ext:Locale SettingsTabGeneralCheckUpdatesOnLaunch}" />
-                    </CheckBox>
                    <CheckBox IsChecked="{Binding ShowConfirmExit}">
                        <TextBlock Text="{ext:Locale SettingsTabGeneralShowConfirmExitDialog}" />
                    </CheckBox>
                    <CheckBox IsChecked="{Binding RememberWindowState}">
                        <TextBlock Text="{ext:Locale SettingsTabGeneralRememberWindowState}" />
                    </CheckBox>
-                    <CheckBox IsChecked="{Binding ShowTitleBar}" Name="ShowTitleBarBox">
+                    <CheckBox IsChecked="{Binding ShowTitleBar}" IsVisible="{x:Static helper:RunningPlatform.IsWindows}">
                        <TextBlock Text="{ext:Locale SettingsTabGeneralShowTitleBar}" />
                    </CheckBox>
+                    <StackPanel Margin="0, 15, 0, 0" Orientation="Horizontal">
+                        <TextBlock VerticalAlignment="Center"
+                                   Text="{ext:Locale SettingsTabGeneralFocusLossType}"
+                                   Width="150" />
+                        <ComboBox SelectedIndex="{Binding FocusLostActionType}"
+                                  HorizontalContentAlignment="Left"
+                                  MinWidth="100">
+                            <ComboBoxItem>
+                                <TextBlock Text="{ext:Locale SettingsTabGeneralFocusLossTypeDoNothing}" />
+                            </ComboBoxItem>
+                            <ComboBoxItem>
+                                <TextBlock Text="{ext:Locale SettingsTabGeneralFocusLossTypeBlockInput}" />
+                            </ComboBoxItem>
+                            <ComboBoxItem>
+                                <TextBlock Text="{ext:Locale SettingsTabGeneralFocusLossTypeMuteAudio}" />
+                            </ComboBoxItem>
+                            <ComboBoxItem>
+                                <TextBlock Text="{ext:Locale SettingsTabGeneralFocusLossTypeBlockInputAndMuteAudio}" />
+                            </ComboBoxItem>
+                            <ComboBoxItem>
+                                <TextBlock Text="{ext:Locale SettingsTabGeneralFocusLossTypePauseEmulation}" />
+                            </ComboBoxItem>
+                        </ComboBox>
+                    </StackPanel>
+                    <StackPanel Margin="0, 15, 0, 0" Orientation="Horizontal">
+                        <TextBlock VerticalAlignment="Center"
+                                   Text="{ext:Locale SettingsTabGeneralCheckUpdatesOnLaunch}"
+                                   Width="150" />
+                        <ComboBox SelectedIndex="{Binding UpdateCheckerType}"
+                                  HorizontalContentAlignment="Left"
+                                  MinWidth="100">
+                            <ComboBoxItem>
+                                <TextBlock Text="{ext:Locale SettingsTabGeneralCheckUpdatesOnLaunchOff}" />
+                            </ComboBoxItem>
+                            <ComboBoxItem>
+                                <TextBlock Text="{ext:Locale SettingsTabGeneralCheckUpdatesOnLaunchPromptAtStartup}" />
+                            </ComboBoxItem>
+                            <ComboBoxItem>
+                                <TextBlock Text="{ext:Locale SettingsTabGeneralCheckUpdatesOnLaunchBackground}" />
+                            </ComboBoxItem>
+                        </ComboBox>
+                    </StackPanel>
                    <StackPanel Margin="0, 15, 0, 0" Orientation="Horizontal">
                        <TextBlock VerticalAlignment="Center"
                                   Text="{ext:Locale SettingsTabGeneralHideCursor}"
--- a/src/Ryujinx/UI/Views/Settings/SettingsUIView.axaml.cs
+++ b/src/Ryujinx/UI/Views/Settings/SettingsUIView.axaml.cs
@ -21,7 +21,6 @@ namespace Ryujinx.Ava.UI.Views.Settings
        public SettingsUiView()
        {
            InitializeComponent();
-            ShowTitleBarBox.IsVisible = OperatingSystem.IsWindows();
            AddGameDirButton.Command =
                Commands.Create(() => AddDirButton(GameDirPathBox, ViewModel.GameDirectories, true));
            AddAutoloadDirButton.Command =
@ -37,11 +36,8 @@ namespace Ryujinx.Ava.UI.Views.Settings
                directories.Add(path);
                
                addDirBox.Clear();
-                
-                if (isGameList)
-                    ViewModel.GameDirectoryChanged = true;
-                else
-                    ViewModel.AutoloadDirectoryChanged = true;
+
+                ViewModel.GameListNeedsRefresh = true;
            }
            else
            {
@ -51,10 +47,7 @@ namespace Ryujinx.Ava.UI.Views.Settings
                {
                    directories.Add(folder.Value.Path.LocalPath);
                        
-                    if (isGameList)
-                        ViewModel.GameDirectoryChanged = true;
-                    else
-                        ViewModel.AutoloadDirectoryChanged = true;
+                    ViewModel.GameListNeedsRefresh = true;
                }
            }
        }
@ -66,7 +59,7 @@ namespace Ryujinx.Ava.UI.Views.Settings
            foreach (string path in new List<string>(GameDirsList.SelectedItems.Cast<string>()))
            {
                ViewModel.GameDirectories.Remove(path);
-                ViewModel.GameDirectoryChanged = true;
+                ViewModel.GameListNeedsRefresh = true;
            }

            if (GameDirsList.ItemCount > 0)
@ -82,7 +75,7 @@ namespace Ryujinx.Ava.UI.Views.Settings
            foreach (string path in new List<string>(AutoloadDirsList.SelectedItems.Cast<string>()))
            {
                ViewModel.AutoloadDirectories.Remove(path);
-                ViewModel.AutoloadDirectoryChanged = true;
+                ViewModel.GameListNeedsRefresh = true;
            }

            if (AutoloadDirsList.ItemCount > 0)
--- a/src/Ryujinx/UI/Windows/AboutWindow.axaml
+++ b/src/Ryujinx/UI/Windows/AboutWindow.axaml
@ -125,7 +125,7 @@
                        Background="Transparent"
                        Click="Button_OnClick"
                        CornerRadius="15"
-                        Tag="https://discord.gg/dHPrkBkkyA"
+                        Tag="https://discord.gg/PEuzjrFXUA"
                        ToolTip.Tip="{ext:Locale AboutDiscordUrlTooltipMessage}">
                        <Image Source="{Binding DiscordLogo}" />
                    </Button>
@ -142,42 +142,40 @@
        <Grid
            Grid.Column="2"
            HorizontalAlignment="Stretch"
-            VerticalAlignment="Stretch" RowDefinitions="Auto,Auto">
+            VerticalAlignment="Stretch" RowDefinitions="Auto,Auto,Auto">
            <StackPanel
                Grid.Row="0"
-                Margin="0,10,0,0"
                Spacing="2">
                <TextBlock
-                    FontSize="15"
+                    Classes="h1"
                    FontWeight="Bold"
                    Text="{ext:Locale AboutRyujinxAboutTitle}" />
                <TextBlock
-                    FontSize="10"
                    Text="{ext:Locale AboutRyujinxAboutContent}"
                    TextWrapping="Wrap" />
            </StackPanel>
+            <Separator Grid.Row="1" Margin="0,20" />
            <StackPanel
-                Grid.Row="1"
-                Margin="0,10,0,0"
+                Grid.Row="2"
                Spacing="2">
                <TextBlock
-                    FontSize="15"
+                    Classes="h1"
                    FontWeight="Bold"
                    Text="{ext:Locale AboutRyujinxMaintainersTitle}" />
                <TextBlock
-                    FontSize="10"
                    Margin="0, 0, 0, 5"
                    TextWrapping="Wrap"
                    Text="{Binding Developers}"/>
                <TextBlock
-                    FontSize="15"
+                    Classes="h1"
                    FontWeight="Bold"
                    Text="{ext:Locale AboutRyujinxFormerMaintainersTitle}" />
                <TextBlock
-                    FontSize="10"
+                    FontSize="11"
                    Text="{Binding FormerDevelopers}"
                    TextWrapping="Wrap" />
                <Button
+                    Margin="0, 5, 0, 0"
                    Padding="5"
                    HorizontalAlignment="Left"
                    Background="Transparent"
--- a/src/Ryujinx/UI/Windows/AboutWindow.axaml.cs
+++ b/src/Ryujinx/UI/Windows/AboutWindow.axaml.cs
@ -18,8 +18,6 @@ namespace Ryujinx.Ava.UI.Windows
    {
        public AboutWindow()
        {
-            DataContext = new AboutWindowViewModel();
-
            InitializeComponent();

            GitHubRepoButton.Tag =
@ -28,12 +26,14 @@ namespace Ryujinx.Ava.UI.Windows

        public static async Task Show()
        {
+            using AboutWindowViewModel viewModel = new();
+            
            ContentDialog contentDialog = new()
            {
                PrimaryButtonText = string.Empty,
                SecondaryButtonText = string.Empty,
                CloseButtonText = LocaleManager.Instance[LocaleKeys.UserProfilesClose],
-                Content = new AboutWindow()
+                Content = new AboutWindow { DataContext = viewModel }
            };

            Style closeButton = new(x => x.Name("CloseButton"));
--- a/src/Ryujinx/UI/Windows/MainWindow.axaml
+++ b/src/Ryujinx/UI/Windows/MainWindow.axaml
@ -21,7 +21,9 @@
    x:DataType="viewModels:MainWindowViewModel"
    mc:Ignorable="d"
    WindowStartupLocation="Manual"
-    Focusable="True">
+    Focusable="True"
+    GotFocus="InputElement_OnGotFocus"
+    LostFocus="InputElement_OnLostFocus">
    <Window.Styles>
        <Style Selector="TitleBar:fullscreen">
            <Setter Property="Background" Value="#000000" />
--- a/src/Ryujinx/UI/Windows/MainWindow.axaml.cs
+++ b/src/Ryujinx/UI/Windows/MainWindow.axaml.cs
@ -1,6 +1,7 @@
 using Avalonia;
 using Avalonia.Controls;
 using Avalonia.Controls.Primitives;
+using Avalonia.Input;
 using Avalonia.Interactivity;
 using Avalonia.Platform;
 using Avalonia.Threading;
@ -19,6 +20,7 @@ using Ryujinx.Ava.UI.ViewModels;
 using Ryujinx.Ava.Utilities;
 using Ryujinx.Ava.Utilities.AppLibrary;
 using Ryujinx.Ava.Utilities.Configuration;
+using Ryujinx.Ava.Utilities.Configuration.UI;
 using Ryujinx.Common;
 using Ryujinx.Common.Helper;
 using Ryujinx.Common.Logging;
@ -400,10 +402,21 @@ namespace Ryujinx.Ava.UI.Windows
                await Dispatcher.UIThread.InvokeAsync(async () => await UserErrorDialog.ShowUserErrorDialog(UserError.NoKeys));
            }

-            if (ConfigurationState.Instance.CheckUpdatesOnStart && !CommandLineState.HideAvailableUpdates && Updater.CanUpdate())
+            if (!Updater.CanUpdate() || CommandLineState.HideAvailableUpdates)
+                return;
+
+            switch (ConfigurationState.Instance.UpdateCheckerType.Value)
            {
-                await Updater.BeginUpdateAsync()
-                    .Catch(task => Logger.Error?.Print(LogClass.Application, $"Updater Error: {task.Exception}"));
+                case UpdaterType.PromptAtStartup:
+                    await Updater.BeginUpdateAsync()
+                        .Catch(task => Logger.Error?.Print(LogClass.Application, $"Updater Error: {task.Exception}"));
+                    break;
+                case UpdaterType.CheckInBackground:
+                    if ((await Updater.CheckVersionAsync()).TryGet(out (Version Current, Version Incoming) versions))
+                    {
+                        Dispatcher.UIThread.Post(() => RyujinxApp.MainWindow.ViewModel.UpdateAvailable = versions.Current < versions.Incoming);
+                    }
+                    break;
            }
        }

@ -749,5 +762,119 @@ namespace Ryujinx.Ava.UI.Windows

            _intelMacWarningShown = true;
        }
+        
+        private void InputElement_OnGotFocus(object sender, GotFocusEventArgs e)
+        {
+            if (ViewModel.AppHost is null) return;
+            
+            if (!_focusLoss.Active) 
+                return;
+
+            switch (_focusLoss.Type)
+            {
+                case FocusLostType.BlockInput:
+                    {
+                        if (!ViewModel.AppHost.NpadManager.InputUpdatesBlocked)
+                        {
+                            _focusLoss = default;
+                            return;
+                        }
+
+                        ViewModel.AppHost.NpadManager.UnblockInputUpdates();
+                        _focusLoss = default;
+                        break;
+                    }
+                case FocusLostType.MuteAudio:
+                    {
+                        if (!ViewModel.AppHost.Device.IsAudioMuted())
+                        {
+                            _focusLoss = default;
+                            return;
+                        }
+                        
+                        ViewModel.AppHost.Device.SetVolume(ViewModel.VolumeBeforeMute);
+                        
+                        _focusLoss = default;
+                        break;
+                    }
+                case FocusLostType.BlockInputAndMuteAudio:
+                    {
+                        if (!ViewModel.AppHost.Device.IsAudioMuted())
+                            goto case FocusLostType.BlockInput;
+                        
+                        ViewModel.AppHost.Device.SetVolume(ViewModel.VolumeBeforeMute);
+                        ViewModel.AppHost.NpadManager.UnblockInputUpdates();
+                        
+                        _focusLoss = default;
+                        break;
+                    }
+                case FocusLostType.PauseEmulation:
+                    {
+                        if (!ViewModel.AppHost.Device.System.IsPaused)
+                        {
+                            _focusLoss = default;
+                            return;
+                        }
+                        
+                        ViewModel.AppHost.Resume();
+                        
+                        _focusLoss = default;
+                        break;
+                    }
+            }
+        }
+        
+        private (FocusLostType Type, bool Active) _focusLoss;
+
+        private void InputElement_OnLostFocus(object sender, RoutedEventArgs e)
+        {
+            if (ConfigurationState.Instance.FocusLostActionType.Value is FocusLostType.DoNothing)
+                return;
+
+            if (ViewModel.AppHost is null) return;
+
+            switch (ConfigurationState.Instance.FocusLostActionType.Value)
+            {
+                case FocusLostType.BlockInput:
+                    {
+                        if (ViewModel.AppHost.NpadManager.InputUpdatesBlocked)
+                            return;
+            
+                        ViewModel.AppHost.NpadManager.BlockInputUpdates();
+                        _focusLoss = (FocusLostType.BlockInput, ViewModel.AppHost.NpadManager.InputUpdatesBlocked);
+                        break;
+                    }
+                case FocusLostType.MuteAudio:
+                    {
+                        if (ViewModel.AppHost.Device.GetVolume() is 0)
+                            return;
+
+                        ViewModel.VolumeBeforeMute = ViewModel.AppHost.Device.GetVolume();
+                        ViewModel.AppHost.Device.SetVolume(0);
+                        _focusLoss = (FocusLostType.MuteAudio, ViewModel.AppHost.Device.GetVolume() is 0f);
+                        break;
+                    }
+                case FocusLostType.BlockInputAndMuteAudio:
+                    {
+                        if (ViewModel.AppHost.Device.GetVolume() is 0)
+                            goto case FocusLostType.BlockInput;
+
+                        ViewModel.VolumeBeforeMute = ViewModel.AppHost.Device.GetVolume();
+                        ViewModel.AppHost.Device.SetVolume(0);
+                        ViewModel.AppHost.NpadManager.BlockInputUpdates();
+                        _focusLoss = (FocusLostType.BlockInputAndMuteAudio, ViewModel.AppHost.Device.GetVolume() is 0f && ViewModel.AppHost.NpadManager.InputUpdatesBlocked);
+                        break;
+                    }
+                case FocusLostType.PauseEmulation:
+                    {
+                        if (ViewModel.AppHost.Device.System.IsPaused)
+                            return;
+                        
+                        ViewModel.AppHost.Pause();
+                        _focusLoss = (FocusLostType.PauseEmulation, ViewModel.AppHost.Device.System.IsPaused);
+                        break;
+                    }
+            }
+        }
    }
 }
--- a/src/Ryujinx/UI/Windows/SettingsWindow.axaml
+++ b/src/Ryujinx/UI/Windows/SettingsWindow.axaml
@ -10,6 +10,7 @@
    xmlns:viewModels="clr-namespace:Ryujinx.Ava.UI.ViewModels"
    xmlns:settings="clr-namespace:Ryujinx.Ava.UI.Views.Settings"
    xmlns:helpers="clr-namespace:Ryujinx.Ava.UI.Helpers"
+    xmlns:helper="clr-namespace:Ryujinx.Common.Helper;assembly=Ryujinx.Common"
    Width="1100"
    Height="768"
    MinWidth="800"
@ -107,24 +108,36 @@
                </Style>
            </ui:NavigationView.Styles>
        </ui:NavigationView>
-        <ReversibleStackPanel
-            Grid.Row="2"
-            Margin="10"
-            Spacing="10"
-            Orientation="Horizontal"
-            HorizontalAlignment="Right"
-            ReverseOrder="{Binding 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>
--- a/src/Ryujinx/UI/Windows/SettingsWindow.axaml.cs
+++ b/src/Ryujinx/UI/Windows/SettingsWindow.axaml.cs
@ -45,7 +45,7 @@ namespace Ryujinx.Ava.UI.Windows
        {
            InputPage.InputView?.SaveCurrentProfile();

-            if (Owner is MainWindow window && (ViewModel.GameDirectoryChanged || ViewModel.AutoloadDirectoryChanged))
+            if (Owner is MainWindow window && ViewModel.GameListNeedsRefresh)
            {
                window.LoadApplications();
            }
--- a/src/Ryujinx/Updater.cs
+++ b/src/Ryujinx/Updater.cs
@ -43,7 +43,18 @@ namespace Ryujinx.Ava
        private const int ConnectionCount = 4;

        private static string _buildVer;
-        private static string _platformExt;
+
+        private static readonly string _platformExt = 
+            RunningPlatform.IsMacOS 
+                ? "macos_universal.app.tar.gz"
+                : RunningPlatform.IsWindows
+                    ? "win_x64.zip"
+                    : RunningPlatform.IsX64Linux
+                        ? "linux_x64.tar.gz"
+                        : RunningPlatform.IsArmLinux
+                            ? "linux_arm64.tar.gz"
+                            : throw new PlatformNotSupportedException();
+        
        private static string _buildUrl;
        private static long _buildSize;
        private static bool _updateSuccessful;
@ -51,30 +62,8 @@ namespace Ryujinx.Ava

        private static readonly string[] _windowsDependencyDirs = [];

-        public static async Task BeginUpdateAsync(bool showVersionUpToDate = false)
+        public static async Task<Optional<(Version Current, Version Incoming)>> CheckVersionAsync(bool showVersionUpToDate = false)
        {
-            if (_running)
-            {
-                return;
-            }
-
-            _running = true;
-
-            // Detect current platform
-            if (OperatingSystem.IsMacOS())
-            {
-                _platformExt = "macos_universal.app.tar.gz";
-            }
-            else if (OperatingSystem.IsWindows())
-            {
-                _platformExt = "win_x64.zip";
-            }
-            else if (OperatingSystem.IsLinux())
-            {
-                string arch = RuntimeInformation.OSArchitecture == Architecture.Arm64 ? "arm64" : "x64";
-                _platformExt = $"linux_{arch}.tar.gz";
-            }
-
            if (!Version.TryParse(Program.Version, out Version currentVersion))
            {
                Logger.Error?.Print(LogClass.Application, $"Failed to convert the current {RyujinxApp.FullAppName} version!");
@ -85,7 +74,7 @@ namespace Ryujinx.Ava

                _running = false;

-                return;
+                return default;
            }
            
            Logger.Info?.Print(LogClass.Application, "Checking for updates.");
@ -123,7 +112,7 @@ namespace Ryujinx.Ava

                            _running = false;

-                            return;
+                            return default;
                        }

                        break;
@ -149,7 +138,7 @@ namespace Ryujinx.Ava

                    _running = false;

-                    return;
+                    return default;
                }
            }
            catch (Exception exception)
@ -161,7 +150,7 @@ namespace Ryujinx.Ava

                _running = false;

-                return;
+                return default;
            }

            if (!Version.TryParse(_buildVer, out Version newVersion))
@ -174,9 +163,27 @@ namespace Ryujinx.Ava

                _running = false;

+                return default;
+            }
+
+            return (currentVersion, newVersion);
+        }
+        
+        public static async Task BeginUpdateAsync(bool showVersionUpToDate = false)
+        {
+            if (_running)
+            {
                return;
            }

+            _running = true;
+
+            Optional<(Version, Version)> versionTuple = await CheckVersionAsync(showVersionUpToDate);
+
+            if (_running is false || !versionTuple.HasValue) return;
+
+            (Version currentVersion, Version newVersion) = versionTuple.Value;
+
            if (newVersion <= currentVersion)
            {
                if (showVersionUpToDate)
--- a/src/Ryujinx/Utilities/AppLibrary/ApplicationData.cs
+++ b/src/Ryujinx/Utilities/AppLibrary/ApplicationData.cs
@ -1,3 +1,4 @@
+using Gommon;
 using LibHac.Common;
 using LibHac.Fs;
 using LibHac.Fs.Fsa;
@ -7,11 +8,15 @@ using LibHac.Ns;
 using LibHac.Tools.Fs;
 using LibHac.Tools.FsSystem;
 using LibHac.Tools.FsSystem.NcaUtils;
+using Ryujinx.Ava.Common.Locale;
+using Ryujinx.Ava.Utilities.Compat;
+using Ryujinx.Ava.Utilities.PlayReport;
 using Ryujinx.Common.Logging;
 using Ryujinx.HLE.FileSystem;
 using Ryujinx.HLE.Loaders.Processes.Extensions;
 using System;
 using System.IO;
+using System.Text;
 using System.Text.Json.Serialization;

 namespace Ryujinx.Ava.Utilities.AppLibrary
@ -21,11 +26,34 @@ namespace Ryujinx.Ava.Utilities.AppLibrary
        public bool Favorite { get; set; }
        public byte[] Icon { get; set; }
        public string Name { get; set; } = "Unknown";
-        public ulong Id { get; set; }
+
+        private ulong _id;
+
+        public ulong Id
+        {
+            get => _id;
+            set
+            {
+                _id = value;
+
+                Compatibility = CompatibilityCsv.Find(value);
+                RichPresenceSpec = PlayReports.Analyzer.TryGetSpec(IdString, out GameSpec gameSpec) 
+                    ? gameSpec 
+                    : default(Optional<GameSpec>);
+            }
+        }
+        public Optional<GameSpec> RichPresenceSpec { get; set; }
+        
        public string Developer { get; set; } = "Unknown";
        public string Version { get; set; } = "0";
        public int PlayerCount { get; set; }
        public int GameCount { get; set; }
+
+        public bool HasLdnGames => PlayerCount != 0 && GameCount != 0;
+
+        public bool HasRichPresenceAsset => DiscordIntegrationModule.HasAssetImage(IdString);
+        public bool HasDynamicRichPresenceSupport => RichPresenceSpec.HasValue;
+        
        public TimeSpan TimePlayed { get; set; }
        public DateTime? LastPlayed { get; set; }
        public string FileExtension { get; set; }
@ -37,11 +65,39 @@ namespace Ryujinx.Ava.Utilities.AppLibrary

        public string TimePlayedString => ValueFormatUtils.FormatTimeSpan(TimePlayed);

-        public bool HasPlayedPreviously => TimePlayedString != string.Empty;
+        public bool HasPlayedPreviously => TimePlayed.TotalSeconds > 1;

        public string LastPlayedString => ValueFormatUtils.FormatDateTime(LastPlayed)?.Replace(" ", "\n");

        public string FileSizeString => ValueFormatUtils.FormatFileSize(FileSize);
+        
+        public Optional<CompatibilityEntry> Compatibility { get; private set; }
+        
+        public bool HasPlayabilityInfo => Compatibility.HasValue;
+
+        public string LocalizedStatus => Compatibility.Convert(x => x.LocalizedStatus);
+
+        public bool HasCompatibilityLabels => !FormattedCompatibilityLabels.Equals(string.Empty);
+        
+        public string FormattedCompatibilityLabels
+            => Compatibility.Convert(x => x.FormattedIssueLabels).OrElse(string.Empty);
+            
+        public LocaleKeys? PlayabilityStatus => Compatibility.Convert(x => x.Status).OrElse(null);
+
+        public string LocalizedStatusTooltip =>
+            Compatibility.Convert(x => 
+#pragma warning disable CS8509 // It is exhaustive for all possible values this can contain.
+                LocaleManager.Instance[x.Status 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,
+                }]
+            ).OrElse(string.Empty);
+        

        [JsonIgnore] public string IdString => Id.ToString("x16");

@ -51,16 +107,16 @@ namespace Ryujinx.Ava.Utilities.AppLibrary

        public static string GetBuildId(VirtualFileSystem virtualFileSystem, IntegrityCheckLevel checkLevel, string titleFilePath)
        {
-            using FileStream file = new(titleFilePath, FileMode.Open, FileAccess.Read);
-
-            Nca mainNca = null;
-            Nca patchNca = null;
-
            if (!System.IO.Path.Exists(titleFilePath))
            {
                Logger.Error?.Print(LogClass.Application, $"File \"{titleFilePath}\" does not exist.");
                return string.Empty;
            }
+            
+            using FileStream file = new(titleFilePath, FileMode.Open, FileAccess.Read);
+
+            Nca mainNca = null;
+            Nca patchNca = null;

            string extension = System.IO.Path.GetExtension(titleFilePath).ToLower();

--- a/src/Ryujinx/Utilities/AppLibrary/ApplicationLibrary.cs
+++ b/src/Ryujinx/Utilities/AppLibrary/ApplicationLibrary.cs
@ -128,13 +128,50 @@ namespace Ryujinx.Ava.Utilities.AppLibrary
            DynamicData.Kernel.Optional<ApplicationData> appData = Applications.Lookup(id);
            if (appData.HasValue)
                return appData.Value.Name;
-            
-            if (DownloadableContents.Keys.FindFirst(x => x.TitleId == id).TryGet(out DownloadableContentModel dlcData))
-                return Path.GetFileNameWithoutExtension(dlcData.FileName);

-            return id.ToString("X16");
+            if (!DownloadableContents.Keys.FindFirst(x => x.TitleId == id).TryGet(out DownloadableContentModel dlcData))
+                return id.ToString("X16");
+            
+            string name = Path.GetFileNameWithoutExtension(dlcData.FileName)!;
+            int idx = name.IndexOf('[');
+            if (idx != -1)
+                name = name[..idx];
+
+            return name;
        }

+        public bool FindApplication(ulong id, out ApplicationData foundData)
+        {
+            DynamicData.Kernel.Optional<ApplicationData> appData = Applications.Lookup(id);
+            foundData = appData.HasValue ? appData.Value : null;
+
+            return appData.HasValue;
+        }
+        
+        public bool FindUpdate(ulong id, out TitleUpdateModel foundData)
+        {
+            Gommon.Optional<TitleUpdateModel> appData = 
+                TitleUpdates.Keys.FindFirst(x => x.TitleId == id);
+            foundData = appData.HasValue ? appData.Value : null;
+
+            return appData.HasValue;
+        }
+        
+        public TitleUpdateModel[] FindUpdatesFor(ulong id)
+            => TitleUpdates.Keys.Where(x => x.TitleIdBase == (id & ~0x1FFFUL)).ToArray();
+        
+        public (TitleUpdateModel TitleUpdate, bool IsSelected)[] FindUpdateConfigurationFor(ulong id)
+            => TitleUpdates.Items.Where(x => x.TitleUpdate.TitleIdBase == (id & ~0x1FFFUL)).ToArray();
+        
+        public DownloadableContentModel[] FindDlcsFor(ulong id)
+            => DownloadableContents.Keys.Where(x => x.TitleIdBase == (id & ~0x1FFFUL)).ToArray();
+        
+        public (DownloadableContentModel Dlc, bool IsEnabled)[] FindDlcConfigurationFor(ulong id)
+            => DownloadableContents.Items.Where(x => x.Dlc.TitleIdBase == (id & ~0x1FFFUL)).ToArray();
+        
+        public bool HasDlcs(ulong id)
+            => DownloadableContents.Keys.Any(x => x.TitleIdBase == (id & ~0x1FFFUL));
+
        /// <exception cref="LibHac.Common.Keys.MissingKeyException">The configured key set is missing a key.</exception>
        /// <exception cref="InvalidDataException">The NCA header could not be decrypted.</exception>
        /// <exception cref="NotSupportedException">The NCA version is not supported.</exception>
--- a/src/Ryujinx/Utilities/AppletMetadata.cs
+++ b/src/Ryujinx/Utilities/AppletMetadata.cs
@ -45,7 +45,7 @@ namespace Ryujinx.Ava.Utilities
            if (string.IsNullOrEmpty(contentPath)) 
                goto BadData;

-            appData = new() { Name = Name, Id = ProgramId, Path = GetContentPath(contentManager) };
+            appData = new() { Name = Name, Id = ProgramId, Path = contentPath };
            appControl = StructHelpers.CreateCustomNacpData(Name, Version);
            return true;
            
--- a/src/Ryujinx/Utilities/Compat/CompatibilityCsv.cs
+++ b/src/Ryujinx/Utilities/Compat/CompatibilityCsv.cs
@ -47,11 +47,6 @@ namespace Ryujinx.Ava.Utilities.Compat
            Logger.Debug?.Print(LogClass.UI, "Compatibility CSV loaded.", "LoadCompatibility");
        }

-        public static void Unload()
-        {
-            _entries = null;
-        }
-
        private static CompatibilityEntry[] _entries;
        
        public static CompatibilityEntry[] Entries 
@ -64,6 +59,22 @@ namespace Ryujinx.Ava.Utilities.Compat
                return _entries;
            }
        }
+
+        public static CompatibilityEntry Find(string titleId)
+            => Entries.FirstOrDefault(x => x.TitleId.HasValue && x.TitleId.Value.EqualsIgnoreCase(titleId));
+        
+        public static CompatibilityEntry Find(ulong titleId)
+            => Find(titleId.ToString("X16"));
+        
+        public static LocaleKeys? GetStatus(string titleId)
+            => Find(titleId)?.Status;
+        
+        public static LocaleKeys? GetStatus(ulong titleId) => GetStatus(titleId.ToString("X16"));
+        
+        public static string GetLabels(string titleId)
+            => Find(titleId)?.FormattedIssueLabels;
+        
+        public static string GetLabels(ulong titleId) => GetLabels(titleId.ToString("X16"));
    }

    public class CompatibilityEntry
@ -100,12 +111,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));

@ -113,20 +137,17 @@ namespace Ryujinx.Ava.Utilities.Compat
            .Select(FormatLabelName)
            .JoinToString(", ");

-        public override string ToString()
-        {
-            StringBuilder sb = new("CompatibilityEntry: {");
-            sb.Append($"{nameof(GameName)}=\"{GameName}\", ");
-            sb.Append($"{nameof(TitleId)}={TitleId}, ");
-            sb.Append($"{nameof(Labels)}={
-                Labels.FormatCollection(it => $"\"{it}\"", separator: ", ", prefix: "[", suffix: "]")
-            }, ");
-            sb.Append($"{nameof(Status)}=\"{Status}\", ");
-            sb.Append($"{nameof(LastUpdated)}=\"{LastUpdated}\"");
-            sb.Append('}');
-
-            return sb.ToString();
-        }
+        public override string ToString() =>
+            new StringBuilder("CompatibilityEntry: {")
+                .Append($"{nameof(GameName)}=\"{GameName}\", ")
+                .Append($"{nameof(TitleId)}={TitleId}, ")
+                .Append($"{nameof(Labels)}={
+                    Labels.FormatCollection(it => $"\"{it}\"", separator: ", ", prefix: "[", suffix: "]")
+                }, ")
+                .Append($"{nameof(Status)}=\"{Status}\", ")
+                .Append($"{nameof(LastUpdated)}=\"{LastUpdated}\"")
+                .Append('}')
+                .ToString();

        public static string FormatLabelName(string labelName) => labelName.ToLower() switch
        {
--- a/src/Ryujinx/Utilities/Compat/CompatibilityList.axaml
+++ b/src/Ryujinx/Utilities/Compat/CompatibilityList.axaml
@ -34,7 +34,7 @@
                Text="{ext:Locale CompatibilityListWarning}" />
        </Grid>
        <Grid Grid.Row="1" ColumnDefinitions="*,Auto,Auto">
-            <TextBox Grid.Column="0" HorizontalAlignment="Stretch" Watermark="{ext:Locale CompatibilityListSearchBoxWatermark}" TextChanged="TextBox_OnTextChanged" />
+            <TextBox Name="SearchBox" Grid.Column="0" HorizontalAlignment="Stretch" Watermark="{ext:Locale CompatibilityListSearchBoxWatermark}" TextChanged="TextBox_OnTextChanged" />
            <CheckBox Grid.Column="1" Margin="7, 0, 0, 0" IsChecked="{Binding OnlyShowOwnedGames}" />
            <TextBlock Grid.Column="2" Margin="-10, 0, 0, 0" Text="{ext:Locale CompatibilityListOnlyShowOwnedGames}" />
        </Grid>
@ -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"
--- a/src/Ryujinx/Utilities/Compat/CompatibilityList.axaml.cs
+++ b/src/Ryujinx/Utilities/Compat/CompatibilityList.axaml.cs
@ -9,7 +9,7 @@ namespace Ryujinx.Ava.Utilities.Compat
 {
    public partial class CompatibilityList : UserControl
    {
-        public static async Task Show()
+        public static async Task Show(string titleId = null)
        {
            ContentDialog contentDialog = new()
            {
@ -18,7 +18,10 @@ namespace Ryujinx.Ava.Utilities.Compat
                CloseButtonText = LocaleManager.Instance[LocaleKeys.SettingsButtonClose],
                Content = new CompatibilityList
                {
-                    DataContext = new CompatibilityViewModel(RyujinxApp.MainWindow.ViewModel.ApplicationLibrary)
+                    DataContext = new CompatibilityViewModel(RyujinxApp.MainWindow.ViewModel.ApplicationLibrary), 
+                    SearchBox = {
+                        Text = titleId ?? ""
+                    }
                }
            };

@ -32,8 +35,6 @@ namespace Ryujinx.Ava.Utilities.Compat
            contentDialog.Styles.Add(closeButtonParent);

            await ContentDialogHelper.ShowAsync(contentDialog);
-            
-            CompatibilityCsv.Unload();
        }
        
        public CompatibilityList()
--- a/src/Ryujinx/Utilities/Configuration/ConfigurationFileFormat.cs
+++ b/src/Ryujinx/Utilities/Configuration/ConfigurationFileFormat.cs
@ -15,7 +15,7 @@ namespace Ryujinx.Ava.Utilities.Configuration
        /// <summary>
        /// The current version of the file format
        /// </summary>
-        public const int CurrentVersion = 62;
+        public const int CurrentVersion = 67;

        /// <summary>
        /// Version of the configuration file format
@ -111,6 +111,11 @@ namespace Ryujinx.Ava.Utilities.Configuration
        /// Enables printing FS access log messages
        /// </summary>
        public bool LoggingEnableFsAccessLog { get; set; }
+        
+        /// <summary>
+        /// Enables log messages from Avalonia
+        /// </summary>
+        public bool LoggingEnableAvalonia { get; set; }

        /// <summary>
        /// Controls which log messages are written to the log targets
@ -141,6 +146,11 @@ namespace Ryujinx.Ava.Utilities.Configuration
        /// Change System Time Offset in seconds
        /// </summary>
        public long SystemTimeOffset { get; set; }
+        
+        /// <summary>
+        /// Instead of setting the time via configuration, use the values provided by the system.
+        /// </summary>
+        public bool MatchSystemTime { get; set; }

        /// <summary>
        /// Enables or disables Docked Mode
@ -153,9 +163,19 @@ namespace Ryujinx.Ava.Utilities.Configuration
        public bool EnableDiscordIntegration { get; set; }

        /// <summary>
-        /// Checks for updates when Ryujinx starts when enabled
+        /// DEPRECATED: Checks for updates when Ryujinx starts when enabled
        /// </summary>
        public bool CheckUpdatesOnStart { get; set; }
+        
+        /// <summary>
+        /// Checks for updates when Ryujinx starts when enabled, either prompting when an update is found or just showing a notification.
+        /// </summary>
+        public UpdaterType UpdateCheckerType { get; set; }
+        
+        /// <summary>
+        /// How the emulator should behave when you click off/on the window.
+        /// </summary>
+        public FocusLostType FocusLostActionType { get; set; }

        /// <summary>
        /// Show "Confirm Exit" Dialog
@ -163,7 +183,7 @@ namespace Ryujinx.Ava.Utilities.Configuration
        public bool ShowConfirmExit { get; set; }

        /// <summary>
-        /// ignore "Applet" dialog
+        /// Ignore Controller Applet dialog
        /// </summary>
        public bool IgnoreApplet { get; set; }

@ -368,6 +388,11 @@ namespace Ryujinx.Ava.Utilities.Configuration
        /// Enable or disable mouse support (Independent from controllers binding)
        /// </summary>
        public bool EnableMouse { get; set; }
+        
+        /// <summary>
+        /// Enable/disable the ability to control Ryujinx when it's not the currently focused window.
+        /// </summary>
+        public bool DisableInputWhenOutOfFocus { get; set; }

        /// <summary>
        /// Hotkey Keyboard Bindings
--- a/src/Ryujinx/Utilities/Configuration/ConfigurationState.Migration.cs
+++ b/src/Ryujinx/Utilities/Configuration/ConfigurationState.Migration.cs
@ -45,6 +45,8 @@ namespace Ryujinx.Ava.Utilities.Configuration
            
            EnableDiscordIntegration.Value = cff.EnableDiscordIntegration;
            CheckUpdatesOnStart.Value = cff.CheckUpdatesOnStart;
+            UpdateCheckerType.Value = cff.UpdateCheckerType;
+            FocusLostActionType.Value = cff.FocusLostActionType;
            ShowConfirmExit.Value = cff.ShowConfirmExit;
            RememberWindowState.Value = cff.RememberWindowState;
            ShowTitleBar.Value = cff.ShowTitleBar;
@ -86,6 +88,7 @@ namespace Ryujinx.Ava.Utilities.Configuration
            System.Region.Value = cff.SystemRegion;
            System.TimeZone.Value = cff.SystemTimeZone;
            System.SystemTimeOffset.Value = cff.SystemTimeOffset;
+            System.MatchSystemTime.Value = cff.MatchSystemTime;
            System.EnableDockedMode.Value = cff.DockedMode;
            System.EnablePtc.Value = cff.EnablePtc;
            System.EnableLowPowerPtc.Value = cff.EnableLowPowerPtc;
@ -97,7 +100,7 @@ namespace Ryujinx.Ava.Utilities.Configuration
            System.MemoryManagerMode.Value = cff.MemoryManagerMode;
            System.DramSize.Value = cff.DramSize;
            System.IgnoreMissingServices.Value = cff.IgnoreMissingServices;
-            System.IgnoreApplet.Value = cff.IgnoreApplet;
+            System.IgnoreControllerApplet.Value = cff.IgnoreApplet;
            System.UseHypervisor.Value = cff.UseHypervisor;
            
            UI.GuiColumns.FavColumn.Value = cff.GuiColumns.FavColumn;
@ -138,6 +141,7 @@ namespace Ryujinx.Ava.Utilities.Configuration
            
            Hid.EnableKeyboard.Value = cff.EnableKeyboard;
            Hid.EnableMouse.Value = cff.EnableMouse;
+            Hid.DisableInputWhenOutOfFocus.Value = cff.DisableInputWhenOutOfFocus;
            Hid.Hotkeys.Value = cff.Hotkeys;
            Hid.InputConfig.Value = cff.InputConfig ?? [];
            Hid.RainbowSpeed.Value = cff.RainbowSpeed;
@ -429,7 +433,12 @@ namespace Ryujinx.Ava.Utilities.Configuration
                        };
                    }
                }),
-                (62, static cff => cff.RainbowSpeed = 1f)
+                (62, static cff => cff.RainbowSpeed = 1f),
+                (63, static cff => cff.MatchSystemTime = false),
+                (64, static cff => cff.LoggingEnableAvalonia = false),
+                (65, static cff => cff.UpdateCheckerType = cff.CheckUpdatesOnStart ? UpdaterType.PromptAtStartup : UpdaterType.Off),
+                (66, static cff => cff.DisableInputWhenOutOfFocus = false),
+                (67, static cff => cff.FocusLostActionType = cff.DisableInputWhenOutOfFocus ? FocusLostType.BlockInput : FocusLostType.DoNothing)
            );
    }
 }
--- a/src/Ryujinx/Utilities/Configuration/ConfigurationState.Model.cs
+++ b/src/Ryujinx/Utilities/Configuration/ConfigurationState.Model.cs
@ -1,6 +1,7 @@
 using ARMeilleure;
 using Gommon;
 using Ryujinx.Ava.Utilities.Configuration.System;
+using Ryujinx.Ava.Utilities.Configuration.UI;
 using Ryujinx.Common;
 using Ryujinx.Common.Configuration;
 using Ryujinx.Common.Configuration.Hid;
@ -254,6 +255,11 @@ namespace Ryujinx.Ava.Utilities.Configuration
            /// Enables printing FS access log messages
            /// </summary>
            public ReactiveObject<bool> EnableFsAccessLog { get; private set; }
+            
+            /// <summary>
+            /// Enables log messages from Avalonia
+            /// </summary>
+            public ReactiveObject<bool> EnableAvaloniaLog { get; private set; }

            /// <summary>
            /// Controls which log messages are written to the log targets
@ -281,6 +287,7 @@ namespace Ryujinx.Ava.Utilities.Configuration
                EnableTrace = new ReactiveObject<bool>();
                EnableGuest = new ReactiveObject<bool>();
                EnableFsAccessLog = new ReactiveObject<bool>();
+                EnableAvaloniaLog = new ReactiveObject<bool>();
                FilteredClasses = new ReactiveObject<LogClass[]>();
                EnableFileLog = new ReactiveObject<bool>();
                EnableFileLog.LogChangesToValue(nameof(EnableFileLog));
@ -312,6 +319,11 @@ namespace Ryujinx.Ava.Utilities.Configuration
            /// System Time Offset in Seconds
            /// </summary>
            public ReactiveObject<long> SystemTimeOffset { get; private set; }
+            
+            /// <summary>
+            /// Instead of setting the time via configuration, use the values provided by the system.
+            /// </summary>
+            public ReactiveObject<bool> MatchSystemTime { get; private set; }

            /// <summary>
            /// Enables or disables Docked Mode
@ -371,7 +383,7 @@ namespace Ryujinx.Ava.Utilities.Configuration
            /// <summary>
            ///  Ignore Controller Applet
            /// </summary>
-            public ReactiveObject<bool> IgnoreApplet { get; private set; }
+            public ReactiveObject<bool> IgnoreControllerApplet { get; private set; }

            /// <summary>
            /// Uses Hypervisor over JIT if available
@ -388,6 +400,8 @@ namespace Ryujinx.Ava.Utilities.Configuration
                TimeZone.LogChangesToValue(nameof(TimeZone));
                SystemTimeOffset = new ReactiveObject<long>();
                SystemTimeOffset.LogChangesToValue(nameof(SystemTimeOffset));
+                MatchSystemTime = new ReactiveObject<bool>();
+                MatchSystemTime.LogChangesToValue(nameof(MatchSystemTime));
                EnableDockedMode = new ReactiveObject<bool>();
                EnableDockedMode.LogChangesToValue(nameof(EnableDockedMode));
                EnablePtc = new ReactiveObject<bool>();
@ -410,8 +424,8 @@ namespace Ryujinx.Ava.Utilities.Configuration
                DramSize.LogChangesToValue(nameof(DramSize));
                IgnoreMissingServices = new ReactiveObject<bool>();
                IgnoreMissingServices.LogChangesToValue(nameof(IgnoreMissingServices));
-                IgnoreApplet = new ReactiveObject<bool>();
-                IgnoreApplet.LogChangesToValue(nameof(IgnoreApplet));
+                IgnoreControllerApplet = new ReactiveObject<bool>();
+                IgnoreControllerApplet.LogChangesToValue(nameof(IgnoreControllerApplet));
                AudioVolume = new ReactiveObject<float>();
                AudioVolume.LogChangesToValue(nameof(AudioVolume));
                UseHypervisor = new ReactiveObject<bool>();
@ -433,6 +447,11 @@ namespace Ryujinx.Ava.Utilities.Configuration
            /// Enable or disable mouse support (Independent from controllers binding)
            /// </summary>
            public ReactiveObject<bool> EnableMouse { get; private set; }
+            
+            /// <summary>
+            /// Enable/disable the ability to control Ryujinx when it's not the currently focused window.
+            /// </summary>
+            public ReactiveObject<bool> DisableInputWhenOutOfFocus { get; private set; }

            /// <summary>
            /// Hotkey Keyboard Bindings
@ -455,6 +474,7 @@ namespace Ryujinx.Ava.Utilities.Configuration
            {
                EnableKeyboard = new ReactiveObject<bool>();
                EnableMouse = new ReactiveObject<bool>();
+                DisableInputWhenOutOfFocus = new ReactiveObject<bool>();
                Hotkeys = new ReactiveObject<KeyboardHotkeys>();
                InputConfig = new ReactiveObject<List<InputConfig>>();
                RainbowSpeed = new ReactiveObject<float>();
@ -754,6 +774,16 @@ namespace Ryujinx.Ava.Utilities.Configuration
        /// Checks for updates when Ryujinx starts when enabled
        /// </summary>
        public ReactiveObject<bool> CheckUpdatesOnStart { get; private set; }
+        
+        /// <summary>
+        /// Checks for updates when Ryujinx starts when enabled, either prompting when an update is found or just showing a notification.
+        /// </summary>
+        public ReactiveObject<UpdaterType> UpdateCheckerType { get; private set; }
+        
+        /// <summary>
+        /// How the emulator should behave when you click off/on the window.
+        /// </summary>
+        public ReactiveObject<FocusLostType> FocusLostActionType { get; private set; }

        /// <summary>
        /// Show "Confirm Exit" Dialog
@ -791,6 +821,8 @@ namespace Ryujinx.Ava.Utilities.Configuration
            Hacks = new HacksSection();
            EnableDiscordIntegration = new ReactiveObject<bool>();
            CheckUpdatesOnStart = new ReactiveObject<bool>();
+            UpdateCheckerType = new ReactiveObject<UpdaterType>();
+            FocusLostActionType = new ReactiveObject<FocusLostType>();
            ShowConfirmExit = new ReactiveObject<bool>();
            RememberWindowState = new ReactiveObject<bool>();
            ShowTitleBar = new ReactiveObject<bool>();
--- a/src/Ryujinx/Utilities/Configuration/ConfigurationState.cs
+++ b/src/Ryujinx/Utilities/Configuration/ConfigurationState.cs
@ -46,15 +46,19 @@ namespace Ryujinx.Ava.Utilities.Configuration
                LoggingEnableTrace = Logger.EnableTrace,
                LoggingEnableGuest = Logger.EnableGuest,
                LoggingEnableFsAccessLog = Logger.EnableFsAccessLog,
+                LoggingEnableAvalonia = Logger.EnableAvaloniaLog,
                LoggingFilteredClasses = Logger.FilteredClasses,
                LoggingGraphicsDebugLevel = Logger.GraphicsDebugLevel,
                SystemLanguage = System.Language,
                SystemRegion = System.Region,
                SystemTimeZone = System.TimeZone,
                SystemTimeOffset = System.SystemTimeOffset,
+                MatchSystemTime = System.MatchSystemTime,
                DockedMode = System.EnableDockedMode,
                EnableDiscordIntegration = EnableDiscordIntegration,
                CheckUpdatesOnStart = CheckUpdatesOnStart,
+                UpdateCheckerType = UpdateCheckerType,
+                FocusLostActionType = FocusLostActionType,
                ShowConfirmExit = ShowConfirmExit,
                RememberWindowState = RememberWindowState,
                ShowTitleBar = ShowTitleBar,
@ -77,7 +81,7 @@ namespace Ryujinx.Ava.Utilities.Configuration
                MemoryManagerMode = System.MemoryManagerMode,
                DramSize = System.DramSize,
                IgnoreMissingServices = System.IgnoreMissingServices,
-                IgnoreApplet = System.IgnoreApplet,
+                IgnoreApplet = System.IgnoreControllerApplet,
                UseHypervisor = System.UseHypervisor,
                GuiColumns = new GuiColumns
                {
@ -129,6 +133,7 @@ namespace Ryujinx.Ava.Utilities.Configuration
                ShowConsole = UI.ShowConsole,
                EnableKeyboard = Hid.EnableKeyboard,
                EnableMouse = Hid.EnableMouse,
+                DisableInputWhenOutOfFocus = Hid.DisableInputWhenOutOfFocus,
                Hotkeys = Hid.Hotkeys,
                InputConfig = Hid.InputConfig,
                RainbowSpeed = Hid.RainbowSpeed,
@ -165,6 +170,7 @@ namespace Ryujinx.Ava.Utilities.Configuration
            Logger.EnableTrace.Value = false;
            Logger.EnableGuest.Value = true;
            Logger.EnableFsAccessLog.Value = false;
+            Logger.EnableAvaloniaLog.Value = false;
            Logger.FilteredClasses.Value = [];
            Logger.GraphicsDebugLevel.Value = GraphicsDebugLevel.None;
            System.Language.Value = Language.AmericanEnglish;
@ -173,7 +179,8 @@ namespace Ryujinx.Ava.Utilities.Configuration
            System.SystemTimeOffset.Value = 0;
            System.EnableDockedMode.Value = true;
            EnableDiscordIntegration.Value = true;
-            CheckUpdatesOnStart.Value = true;
+            UpdateCheckerType.Value = UpdaterType.PromptAtStartup;
+            FocusLostActionType.Value = FocusLostType.DoNothing;
            ShowConfirmExit.Value = true;
            RememberWindowState.Value = true;
            ShowTitleBar.Value = !OperatingSystem.IsWindows();
@ -198,7 +205,7 @@ namespace Ryujinx.Ava.Utilities.Configuration
            System.MemoryManagerMode.Value = MemoryManagerMode.HostMappedUnsafe;
            System.DramSize.Value = MemoryConfiguration.MemoryConfiguration4GiB;
            System.IgnoreMissingServices.Value = false;
-            System.IgnoreApplet.Value = false;
+            System.IgnoreControllerApplet.Value = false;
            System.UseHypervisor.Value = true;
            Multiplayer.LanInterfaceId.Value = "0";
            Multiplayer.Mode.Value = MultiplayerMode.Disabled;
@ -242,6 +249,7 @@ namespace Ryujinx.Ava.Utilities.Configuration
            UI.WindowStartup.WindowMaximized.Value = false;
            Hid.EnableKeyboard.Value = false;
            Hid.EnableMouse.Value = false;
+            Hid.DisableInputWhenOutOfFocus.Value = false;
            Hid.Hotkeys.Value = new KeyboardHotkeys
            {
                ToggleVSyncMode = Key.F1,
--- a/src/Ryujinx/Utilities/Configuration/UI/FocusLostType.cs
+++ b/src/Ryujinx/Utilities/Configuration/UI/FocusLostType.cs
@ -0,0 +1,15 @@
+using Ryujinx.Common.Utilities;
+using System.Text.Json.Serialization;
+
+namespace Ryujinx.Ava.Utilities.Configuration.UI
+{
+    [JsonConverter(typeof(TypedStringEnumConverter<FocusLostType>))]
+    public enum FocusLostType
+    {
+        DoNothing,
+        BlockInput,
+        MuteAudio,
+        BlockInputAndMuteAudio,
+        PauseEmulation
+    }
+}
--- a/src/Ryujinx/Utilities/Configuration/UI/UpdaterType.cs
+++ b/src/Ryujinx/Utilities/Configuration/UI/UpdaterType.cs
@ -0,0 +1,13 @@
+using Ryujinx.Common.Utilities;
+using System.Text.Json.Serialization;
+
+namespace Ryujinx.Ava.Utilities.Configuration.UI
+{
+    [JsonConverter(typeof(TypedStringEnumConverter<UpdaterType>))]
+    public enum UpdaterType
+    {
+        Off,
+        PromptAtStartup,
+        CheckInBackground
+    }
+}
--- a/src/Ryujinx/Utilities/PlayReport/Analyzer.cs
+++ b/src/Ryujinx/Utilities/PlayReport/Analyzer.cs
@ -0,0 +1,151 @@
+using Gommon;
+using Ryujinx.Ava.Utilities.AppLibrary;
+using Ryujinx.Common.Logging;
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Globalization;
+using System.Linq;
+
+namespace Ryujinx.Ava.Utilities.PlayReport
+{
+    /// <summary>
+    /// The entrypoint for the Play Report analysis system.
+    /// </summary>
+    public class Analyzer
+    {
+        private readonly List<GameSpec> _specs = [];
+
+        public string[] TitleIds => Specs.SelectMany(x => x.TitleIds).ToArray();
+
+        public IReadOnlyList<GameSpec> Specs => new ReadOnlyCollection<GameSpec>(_specs);
+
+        public GameSpec GetSpec(string titleId) => _specs.First(x => x.TitleIds.ContainsIgnoreCase(titleId));
+
+        public bool TryGetSpec(string titleId, out GameSpec gameSpec)
+            => (gameSpec = _specs.FirstOrDefault(x => x.TitleIds.ContainsIgnoreCase(titleId))) != null;
+
+        /// <summary>
+        /// Add an analysis spec matching a specific game by title ID, with the provided spec configuration.
+        /// </summary>
+        /// <param name="titleId">The ID of the game to listen to Play Reports in.</param>
+        /// <param name="transform">The configuration function for the analysis spec.</param>
+        /// <returns>The current <see cref="Analyzer"/>, for chaining convenience.</returns>
+        public Analyzer AddSpec(string titleId, Func<GameSpec, GameSpec> transform)
+        {
+            if (ulong.TryParse(titleId, NumberStyles.HexNumber, null, out _))
+                return AddSpec(transform(GameSpec.Create(titleId)));
+
+            Logger.Notice.PrintMsg(LogClass.Application,
+                $"Tried to add a {nameof(GameSpec)} with a non-hexadecimal title ID value. Input: '{titleId}'");
+            return this;
+        }
+
+        /// <summary>
+        /// Add an analysis spec matching a specific game by title ID, with the provided spec configuration.
+        /// </summary>
+        /// <param name="titleId">The ID of the game to listen to Play Reports in.</param>
+        /// <param name="transform">The configuration function for the analysis spec.</param>
+        /// <returns>The current <see cref="Analyzer"/>, for chaining convenience.</returns>
+        public Analyzer AddSpec(string titleId, Action<GameSpec> transform)
+        {
+            if (ulong.TryParse(titleId, NumberStyles.HexNumber, null, out _))
+                return AddSpec(GameSpec.Create(titleId).Apply(transform));
+
+            Logger.Notice.PrintMsg(LogClass.Application,
+                $"Tried to add a {nameof(GameSpec)} with a non-hexadecimal title ID value. Input: '{titleId}'");
+            return this;
+        }
+
+        /// <summary>
+        /// Add an analysis spec matching a specific set of games by title IDs, with the provided spec configuration.
+        /// </summary>
+        /// <param name="titleIds">The IDs of the games to listen to Play Reports in.</param>
+        /// <param name="transform">The configuration function for the analysis spec.</param>
+        /// <returns>The current <see cref="Analyzer"/>, for chaining convenience.</returns>
+        public Analyzer AddSpec(IEnumerable<string> titleIds,
+            Func<GameSpec, GameSpec> transform)
+        {
+            string[] tids = titleIds.ToArray();
+            if (tids.All(x => ulong.TryParse(x, NumberStyles.HexNumber, null, out _) && !string.IsNullOrEmpty(x)))
+                return AddSpec(transform(GameSpec.Create(tids)));
+
+            Logger.Notice.PrintMsg(LogClass.Application,
+                $"Tried to add a {nameof(GameSpec)} with a non-hexadecimal title ID value. Input: '{
+                    tids.FormatCollection(
+                        x => x,
+                        separator: ", ",
+                        prefix: "[",
+                        suffix: "]"
+                    )
+                }'");
+            return this;
+        }
+
+        /// <summary>
+        /// Add an analysis spec matching a specific set of games by title IDs, with the provided spec configuration.
+        /// </summary>
+        /// <param name="titleIds">The IDs of the games to listen to Play Reports in.</param>
+        /// <param name="transform">The configuration function for the analysis spec.</param>
+        /// <returns>The current <see cref="Analyzer"/>, for chaining convenience.</returns>
+        public Analyzer AddSpec(IEnumerable<string> titleIds, Action<GameSpec> transform)
+        {
+            string[] tids = titleIds.ToArray();
+            if (tids.All(x => ulong.TryParse(x, NumberStyles.HexNumber, null, out _) && !string.IsNullOrEmpty(x)))
+                return AddSpec(GameSpec.Create(tids).Apply(transform));
+
+            Logger.Notice.PrintMsg(LogClass.Application,
+                $"Tried to add a {nameof(GameSpec)} with a non-hexadecimal title ID value. Input: '{
+                    tids.FormatCollection(
+                        x => x,
+                        separator: ", ",
+                        prefix: "[",
+                        suffix: "]"
+                    )
+                }'");
+            return this;
+        }
+
+        /// <summary>
+        /// Add an analysis spec matching a specific game by title ID, with the provided pre-configured spec.
+        /// </summary>
+        /// <param name="spec">The <see cref="GameSpec"/> to add.</param>
+        /// <returns>The current <see cref="Analyzer"/>, for chaining convenience.</returns>
+        public Analyzer AddSpec(GameSpec spec)
+        {
+            _specs.Add(spec);
+            return this;
+        }
+
+
+        /// <summary>
+        /// Runs the configured <see cref="FormatterSpec"/> for the specified game title ID.
+        /// </summary>
+        /// <param name="runningGameId">The game currently running.</param>
+        /// <param name="appMeta">The Application metadata information, including localized game name and play time information.</param>
+        /// <param name="playReport">The Play Report received from HLE.</param>
+        /// <returns>A struct representing a possible formatted value.</returns>
+        public FormattedValue Format(
+            string runningGameId,
+            ApplicationMetadata appMeta,
+            Horizon.Prepo.Types.PlayReport playReport
+        )
+        {
+            if (!playReport.ReportData.IsDictionary)
+                return FormattedValue.Unhandled;
+            
+            if (!TryGetSpec(runningGameId, out GameSpec spec))
+                return FormattedValue.Unhandled;
+
+            foreach (FormatterSpecBase formatSpec in spec.ValueFormatters.OrderBy(x => x.Priority))
+            {
+                if (!formatSpec.TryFormat(appMeta, playReport, out FormattedValue value))
+                    continue;
+
+                return value;
+            }
+
+            return FormattedValue.Unhandled;
+        }
+    }
+}
--- a/src/Ryujinx/Utilities/PlayReport/Delegates.cs
+++ b/src/Ryujinx/Utilities/PlayReport/Delegates.cs
@ -0,0 +1,40 @@
+namespace Ryujinx.Ava.Utilities.PlayReport
+{
+    /// <summary>
+    /// The delegate type that powers single value formatters.<br/>
+    /// Takes in the result value from the Play Report, and outputs:
+    /// <br/>
+    /// a formatted string,
+    /// <br/>
+    /// a signal that nothing was available to handle it,
+    /// <br/>
+    /// OR a signal to reset the value that the caller is using the <see cref="Analyzer"/> for. 
+    /// </summary>
+    public delegate FormattedValue SingleValueFormatter(SingleValue value);
+
+    /// <summary>
+    /// The delegate type that powers multiple value formatters.<br/>
+    /// Takes in the result values from the Play Report, and outputs:
+    /// <br/>
+    /// a formatted string,
+    /// <br/>
+    /// a signal that nothing was available to handle it,
+    /// <br/>
+    /// OR a signal to reset the value that the caller is using the <see cref="Analyzer"/> for. 
+    /// </summary>
+    public delegate FormattedValue MultiValueFormatter(MultiValue value);
+
+    /// <summary>
+    /// The delegate type that powers multiple value formatters.
+    /// The dictionary passed to this delegate is sparsely populated;
+    /// that is, not every key specified in the Play Report needs to match for this to be used.<br/>
+    /// Takes in the result values from the Play Report, and outputs:
+    /// <br/>
+    /// a formatted string,
+    /// <br/>
+    /// a signal that nothing was available to handle it,
+    /// <br/>
+    /// OR a signal to reset the value that the caller is using the <see cref="Analyzer"/> for. 
+    /// </summary>
+    public delegate FormattedValue SparseMultiValueFormatter(SparseMultiValue value);
+}
--- a/src/Ryujinx/Utilities/PlayReport/MatchedValues.cs
+++ b/src/Ryujinx/Utilities/PlayReport/MatchedValues.cs
@ -0,0 +1,73 @@
+using MsgPack;
+using Ryujinx.Ava.Utilities.AppLibrary;
+using System.Collections.Generic;
+
+namespace Ryujinx.Ava.Utilities.PlayReport
+{
+    public abstract class MatchedValue<T>
+    {
+        protected MatchedValue(T matched)
+        {
+            Matched = matched;
+        }
+        
+        /// <summary>
+        /// The currently running application's <see cref="ApplicationMetadata"/>.
+        /// </summary>
+        public ApplicationMetadata Application { get; init; }
+        
+        /// <summary>
+        /// The entire play report.
+        /// </summary>
+        public Horizon.Prepo.Types.PlayReport PlayReport { get; init; }
+
+        /// <summary>
+        /// The matched value from the Play Report.
+        /// </summary>
+        public T Matched { get; init; }
+    }
+    
+    /// <summary>
+    /// The input data to a <see cref="SingleValueFormatter"/>,
+    /// containing the currently running application's <see cref="ApplicationMetadata"/>,
+    /// and the matched <see cref="MessagePackObject"/> from the Play Report.
+    /// </summary>
+    public class SingleValue : MatchedValue<Value>
+    {
+        public SingleValue(Value matched) : base(matched)
+        {
+        }
+    }
+
+    /// <summary>
+    /// The input data to a <see cref="MultiValueFormatter"/>,
+    /// containing the currently running application's <see cref="ApplicationMetadata"/>,
+    /// and the matched <see cref="MessagePackObject"/>s from the Play Report.
+    /// </summary>
+    public class MultiValue : MatchedValue<Value[]>
+    {
+        public MultiValue(Value[] matched) : base(matched)
+        {
+        }
+
+        public MultiValue(IEnumerable<MessagePackObject> matched) : base(Value.ConvertPackedObjects(matched))
+        {
+        }
+    }
+
+    /// <summary>
+    /// The input data to a <see cref="SparseMultiValueFormatter"/>,
+    /// containing the currently running application's <see cref="ApplicationMetadata"/>,
+    /// and the matched <see cref="MessagePackObject"/>s from the Play Report.
+    /// </summary>
+    public class SparseMultiValue : MatchedValue<Dictionary<string, Value>>
+    {
+        public SparseMultiValue(Dictionary<string, Value> matched) : base(matched)
+        {
+        }
+        
+        public SparseMultiValue(Dictionary<string, MessagePackObject> matched) : base(Value.ConvertPackedObjectMap(matched))
+        {
+        }
+    }
+}
--- a/src/Ryujinx/Utilities/PlayReport/PlayReports.Formatters.cs
+++ b/src/Ryujinx/Utilities/PlayReport/PlayReports.Formatters.cs
@ -0,0 +1,636 @@
+using Gommon;
+using Humanizer;
+using System;
+using System.Buffers.Binary;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Ryujinx.Ava.Utilities.PlayReport
+{
+    public partial class PlayReports
+    {
+        private static FormattedValue BreathOfTheWild_MasterMode(SingleValue value)
+            => value.Matched.BoxedValue is 1 ? "Playing Master Mode" : FormattedValue.ForceReset;
+
+        private static FormattedValue TearsOfTheKingdom_CurrentField(SingleValue value) =>
+            value.Matched.DoubleValue switch
+            {
+                > 800d => "Exploring the Sky Islands",
+                < -201d => "Exploring the Depths",
+                _ => "Roaming Hyrule"
+            };
+        
+        private static FormattedValue SkywardSwordHD_Rupees(SingleValue value)
+            => "rupee".ToQuantity(value.Matched.IntValue);
+
+        private static FormattedValue SuperMarioOdyssey_AssistMode(SingleValue value)
+            => value.Matched.BoxedValue is 1 ? "Playing in Assist Mode" : "Playing in Regular Mode";
+
+        private static FormattedValue SuperMarioOdysseyChina_AssistMode(SingleValue value)
+            => value.Matched.BoxedValue is 1 ? "Playing in 帮助模式" : "Playing in 普通模式";
+
+        private static FormattedValue SuperMario3DWorldOrBowsersFury(SingleValue value)
+            => value.Matched.BoxedValue is 0 ? "Playing Super Mario 3D World" : "Playing Bowser's Fury";
+
+        private static FormattedValue MarioKart8Deluxe_Mode(SingleValue value)
+            => value.Matched.StringValue switch
+            {
+                // Single Player
+                "Single" => "Single Player",
+                // Multiplayer
+                "Multi-2players" => "Multiplayer 2 Players",
+                "Multi-3players" => "Multiplayer 3 Players",
+                "Multi-4players" => "Multiplayer 4 Players",
+                // Wireless/LAN Play
+                "Local-Single" => "Wireless/LAN Play",
+                "Local-2players" => "Wireless/LAN Play 2 Players",
+                // CC Classes
+                "50cc" => "50cc",
+                "100cc" => "100cc",
+                "150cc" => "150cc",
+                "Mirror" => "Mirror (150cc)",
+                "200cc" => "200cc",
+                // Modes
+                "GrandPrix" => "Grand Prix",
+                "TimeAttack" => "Time Trials",
+                "VS" => "VS Races",
+                "Battle" => "Battle Mode",
+                "RaceStart" => "Selecting a Course",
+                "Race" => "Racing",
+                _ => FormattedValue.ForceReset
+            };
+
+        private static FormattedValue PokemonSVUnionCircle(SingleValue value)
+            => value.Matched.BoxedValue is 0 ? "Playing Alone" : "Playing in a group";
+
+        private static FormattedValue PokemonSVArea(SingleValue value)
+            => value.Matched.StringValue switch
+            {
+                // Base Game Locations
+                "a_w01" => "South Area One",
+                "a_w02" => "Mesagoza",
+                "a_w03" => "The Pokemon League",
+                "a_w04" => "South Area Two",
+                "a_w05" => "South Area Four",
+                "a_w06" => "South Area Six",
+                "a_w07" => "South Area Five",
+                "a_w08" => "South Area Three",
+                "a_w09" => "West Area One",
+                "a_w10" => "Asado Desert",
+                "a_w11" => "West Area Two",
+                "a_w12" => "Medali",
+                "a_w13" => "Tagtree Thicket",
+                "a_w14" => "East Area Three",
+                "a_w15" => "Artazon",
+                "a_w16" => "East Area Two",
+                "a_w18" => "Casseroya Lake",
+                "a_w19" => "Glaseado Mountain",
+                "a_w20" => "North Area Three",
+                "a_w21" => "North Area One",
+                "a_w22" => "North Area Two",
+                "a_w23" => "The Great Crater of Paldea",
+                "a_w24" => "South Paldean Sea",
+                "a_w25" => "West Paldean Sea",
+                "a_w26" => "East Paldean Sea",
+                "a_w27" => "Nouth Paldean Sea",
+                //TODO DLC Locations
+                _ => FormattedValue.ForceReset
+            };
+
+        private static FormattedValue SuperSmashBrosUltimate_Mode(SparseMultiValue values)
+        {
+            // Check if the PlayReport is for a challenger approach or an achievement.
+            if (values.Matched.TryGetValue("fighter", out Value fighter) && values.Matched.ContainsKey("reason"))
+            {
+                return $"Challenger Approaches - {SuperSmashBrosUltimate_Character(fighter)}";
+            }
+
+            if (values.Matched.TryGetValue("fighter", out fighter) && values.Matched.ContainsKey("challenge_count"))
+            {
+                return $"Fighter Unlocked - {SuperSmashBrosUltimate_Character(fighter)}";
+            }
+
+            if (values.Matched.TryGetValue("anniversary", out Value anniversary))
+            {
+                return $"Achievement Unlocked - ID: {anniversary}";
+            }
+
+            if (values.Matched.ContainsKey("adv_slot"))
+            {
+                return
+                    "Playing Adventure Mode"; // Doing this as it can be a placeholder until we can grab the character.
+            }
+
+            // Check if we have a match_mode at this point, if not, go to default.
+            if (!values.Matched.TryGetValue("match_mode", out Value matchMode))
+            {
+                return "Smashing";
+            }
+
+            return matchMode.BoxedValue switch
+            {
+                0 when values.Matched.TryGetValue("player_1_fighter", out Value player) &&
+                       values.Matched.TryGetValue("player_2_fighter", out Value challenger)
+                    => $"Last Smashed: {SuperSmashBrosUltimate_Character(challenger)}'s Fighter Challenge - {SuperSmashBrosUltimate_Character(player)}",
+                1 => $"Last Smashed: Normal Battle - {SuperSmashBrosUltimate_PlayerListing(values)}",
+                2 when values.Matched.TryGetValue("player_1_rank", out Value team)
+                    => team.BoxedValue is 0
+                        ? "Last Smashed: Squad Strike - Red Team Wins"
+                        : "Last Smashed: Squad Strike - Blue Team Wins",
+                3 => $"Last Smashed: Custom Smash - {SuperSmashBrosUltimate_PlayerListing(values)}",
+                4 => $"Last Smashed: Super Sudden Death - {SuperSmashBrosUltimate_PlayerListing(values)}",
+                5 => $"Last Smashed: Smashdown - {SuperSmashBrosUltimate_PlayerListing(values)}",
+                6 => $"Last Smashed: Tourney Battle - {SuperSmashBrosUltimate_PlayerListing(values)}",
+                7 when values.Matched.TryGetValue("player_1_fighter", out Value player)
+                    => $"Last Smashed: Spirit Board Battle as {SuperSmashBrosUltimate_Character(player)}",
+                8 when values.Matched.TryGetValue("player_1_fighter", out Value player)
+                    => $"Playing Adventure Mode as {SuperSmashBrosUltimate_Character(player)}",
+                10 when values.Matched.TryGetValue("match_submode", out Value battle) &&
+                        values.Matched.TryGetValue("player_1_fighter", out Value player)
+                    => $"Last Smashed: Classic Mode, Battle {(int)battle.BoxedValue + 1}/8 as {SuperSmashBrosUltimate_Character(player)}",
+                12 => $"Last Smashed: Century Smash - {SuperSmashBrosUltimate_PlayerListing(values)}",
+                13 => $"Last Smashed: All-Star Smash - {SuperSmashBrosUltimate_PlayerListing(values)}",
+                14 => $"Last Smashed: Cruel Smash - {SuperSmashBrosUltimate_PlayerListing(values)}",
+                15 when values.Matched.TryGetValue("player_1_fighter", out Value player)
+                    => $"Last Smashed: Home-Run Contest - {SuperSmashBrosUltimate_Character(player)}",
+                16 when values.Matched.TryGetValue("player_1_fighter", out Value player1) &&
+                        values.Matched.TryGetValue("player_2_fighter", out Value player2)
+                    => $"Last Smashed: Home-Run Content (Co-op) - {SuperSmashBrosUltimate_Character(player1)} and {SuperSmashBrosUltimate_Character(player2)}",
+                17 => $"Last Smashed: Home-Run Contest (Versus) - {SuperSmashBrosUltimate_PlayerListing(values)}",
+                18 when values.Matched.TryGetValue("player_1_fighter", out Value player1) &&
+                        values.Matched.TryGetValue("player_2_fighter", out Value player2)
+                    => $"Fresh out of Training mode - {SuperSmashBrosUltimate_Character(player1)} with {SuperSmashBrosUltimate_Character(player2)}",
+                58 => $"Last Smashed: LDN Battle - {SuperSmashBrosUltimate_PlayerListing(values)}",
+                63 when values.Matched.TryGetValue("player_1_fighter", out Value player)
+                    => $"Last Smashed: DLC Spirit Board Battle as {SuperSmashBrosUltimate_Character(player)}",
+                _ => "Smashing"
+            };
+        }
+
+        private static string SuperSmashBrosUltimate_Character(Value value) =>
+            BinaryPrimitives.ReverseEndianness(
+                    BitConverter.ToInt64(((MsgPack.MessagePackExtendedTypeObject)value.BoxedValue).GetBody(), 0)) switch
+                {
+                    0x0 => "Mario",
+                    0x1 => "Donkey Kong",
+                    0x2 => "Link",
+                    0x3 => "Samus",
+                    0x4 => "Dark Samus",
+                    0x5 => "Yoshi",
+                    0x6 => "Kirby",
+                    0x7 => "Fox",
+                    0x8 => "Pikachu",
+                    0x9 => "Luigi",
+                    0xA => "Ness",
+                    0xB => "Captain Falcon",
+                    0xC => "Jigglypuff",
+                    0xD => "Peach",
+                    0xE => "Daisy",
+                    0xF => "Bowser",
+                    0x10 => "Ice Climbers",
+                    0x11 => "Sheik",
+                    0x12 => "Zelda",
+                    0x13 => "Dr. Mario",
+                    0x14 => "Pichu",
+                    0x15 => "Falco",
+                    0x16 => "Marth",
+                    0x17 => "Lucina",
+                    0x18 => "Young Link",
+                    0x19 => "Ganondorf",
+                    0x1A => "Mewtwo",
+                    0x1B => "Roy",
+                    0x1C => "Chrom",
+                    0x1D => "Mr Game & Watch",
+                    0x1E => "Meta Knight",
+                    0x1F => "Pit",
+                    0x20 => "Dark Pit",
+                    0x21 => "Zero Suit Samus",
+                    0x22 => "Wario",
+                    0x23 => "Snake",
+                    0x24 => "Ike",
+                    0x25 => "Pokémon Trainer",
+                    0x26 => "Diddy Kong",
+                    0x27 => "Lucas",
+                    0x28 => "Sonic",
+                    0x29 => "King Dedede",
+                    0x2A => "Olimar",
+                    0x2B => "Lucario",
+                    0x2C => "R.O.B.",
+                    0x2D => "Toon Link",
+                    0x2E => "Wolf",
+                    0x2F => "Villager",
+                    0x30 => "Mega Man",
+                    0x31 => "Wii Fit Trainer",
+                    0x32 => "Rosalina & Luma",
+                    0x33 => "Little Mac",
+                    0x34 => "Greninja",
+                    0x35 => "Palutena",
+                    0x36 => "Pac-Man",
+                    0x37 => "Robin",
+                    0x38 => "Shulk",
+                    0x39 => "Bowser Jr.",
+                    0x3A => "Duck Hunt",
+                    0x3B => "Ryu",
+                    0x3C => "Ken",
+                    0x3D => "Cloud",
+                    0x3E => "Corrin",
+                    0x3F => "Bayonetta",
+                    0x40 => "Richter",
+                    0x41 => "Inkling",
+                    0x42 => "Ridley",
+                    0x43 => "King K. Rool",
+                    0x44 => "Simon",
+                    0x45 => "Isabelle",
+                    0x46 => "Incineroar",
+                    0x47 => "Mii Brawler",
+                    0x48 => "Mii Swordfighter",
+                    0x49 => "Mii Gunner",
+                    0x4A => "Piranha Plant",
+                    0x4B => "Joker",
+                    0x4C => "Hero",
+                    0x4D => "Banjo",
+                    0x4E => "Terry",
+                    0x4F => "Byleth",
+                    0x50 => "Min Min",
+                    0x51 => "Steve",
+                    0x52 => "Sephiroth",
+                    0x53 => "Pyra/Mythra",
+                    0x54 => "Kazuya",
+                    0x55 => "Sora",
+                    0xFE => "Random",
+                    0xFF => "Scripted Entity",
+                    _ => "Unknown"
+                };
+
+        private static string SuperSmashBrosUltimate_PlayerListing(SparseMultiValue values)
+        {
+            List<(string Character, int PlayerNumber, int? Rank)> players = [];
+
+            foreach (KeyValuePair<string, Value> player in values.Matched)
+            {
+                if (player.Key.StartsWith("player_") && player.Key.EndsWith("_fighter") &&
+                    player.Value.BoxedValue is not null)
+                {
+                    if (!int.TryParse(player.Key.Split('_')[1], out int playerNumber))
+                        continue;
+
+                    string character = SuperSmashBrosUltimate_Character(player.Value);
+                    int? rank = values.Matched.TryGetValue($"player_{playerNumber}_rank", out Value rankValue)
+                        ? rankValue.IntValue
+                        : null;
+
+                    players.Add((character, playerNumber, rank));
+                }
+            }
+
+            players = players.OrderBy(p => p.Rank ?? int.MaxValue).ToList();
+
+            return players.Count > 4
+                ? $"{players.Count} Players - {
+                    players.Take(3)
+                        .Select(p => $"{p.Character}({p.PlayerNumber}){RankMedal(p.Rank)}")
+                        .JoinToString(", ")
+                }"
+                : players
+                    .Select(p => $"{p.Character}({p.PlayerNumber}){RankMedal(p.Rank)}")
+                    .JoinToString(", ");
+
+            string RankMedal(int? rank) => rank switch
+            {
+                0 => "🥇",
+                1 => "🥈",
+                2 => "🥉",
+                _ => ""
+            };
+        }
+
+        private static FormattedValue NsoEmulator_LaunchedGame(SingleValue value) => value.Matched.StringValue switch
+        {
+            #region SEGA Genesis
+
+            "m_0054_e" => Playing("Alien Soldier"),
+            "m_3978_e" => Playing("Alien Storm"),
+            "m_5234_e" => Playing("ALISIA DRAGOON"),
+            "m_5003_e" => Playing("Streets of Rage 2"),
+            "m_4843_e" => Playing("Kid Chameleon"),
+            "m_2874_e" => Playing("Columns"),
+            "m_3167_e" => Playing("Comix Zone"),
+            "m_5007_e" => Playing("Contra: Hard Corps"),
+            "m_0865_e" => Playing("Ghouls 'n Ghosts"),
+            "m_0935_e" => Playing("Dynamite Headdy"),
+            "m_8314_e" => Playing("Earthworm Jim"),
+            "m_5012_e" => Playing("Ecco the Dolphin"),
+            "m_2207_e" => Playing("Flicky"),
+            "m_9432_e" => Playing("Golden Axe II"),
+            "m_5015_e" => Playing("Golden Axe"),
+            "m_5017_e" => Playing("Gunstar Heroes"),
+            "m_0732_e" => Playing("Altered Beast"),
+            "m_2245_e" or "m_2245_pd" or "m_2245_pf" => Playing("Landstalker"),
+            "m_1654_e" => Playing("Target Earth"),
+            "m_7050_e" => Playing("Light Crusader"),
+            "m_5027_e" => Playing("M.U.S.H.A."),
+            "m_5028_e" => Playing("Phantasy Star IV"),
+            "m_9155_e" => Playing("Pulseman"),
+            "m_5030_e" => Playing("Dr. Robotnik's Mean Bean Machine"),
+            "m_0098_e" => Playing("Crusader of Centy"),
+            "m_0098_k" => Playing("신창세기 라그나센티"),
+            "m_0098_pd" or "m_0098_pf" or "m_0098_ps" => Playing("Soleil"),
+            "m_5033_e" => Playing("Ristar"),
+            "m_1987_e" => Playing("MEGA MAN: THE WILY WARS"),
+            "m_2609_e" => Playing("WOLF OF THE BATTLEFIELD: MERCS"),
+            "m_3353_e" => Playing("Shining Force II"),
+            "m_5036_e" => Playing("Shining Force"),
+            "m_9866_e" => Playing("Sonic The Hedgehog Spinball"),
+            "m_5041_e" => Playing("Sonic The Hedgehog 2"),
+            "m_5523_e" => Playing("Space Harrier II"),
+            "m_0041_e" => Playing("STREET FIGHTER II' : SPECIAL CHAMPION EDITION"),
+            "m_5044_e" => Playing("STRIDER"),
+            "m_6353_e" => Playing("Super Fantasy Zone"),
+            "m_9569_e" => Playing("Beyond Oasis"),
+            "m_9569_k" => Playing("스토리 오브 도어"),
+            "m_9569_pd" or "m_9569_ps" => Playing("The Story of Thor"),
+            "m_9569_pf" => Playing("La Légende de Thor"),
+            "m_5049_e" => Playing("Shinobi III: Return of the Ninja Master"),
+            "m_6811_e" => Playing("The Revenge of Shinobi"),
+            "m_4372_e" => Playing("Thunder Force II"),
+            "m_1535_e" => Playing("ToeJam & Earl in Panic on Funkotron"),
+            "m_0432_e" => Playing("ToeJam & Earl"),
+            "m_5052_e" => Playing("Castlevania: BLOODLINES"),
+            "m_3626_e" => Playing("VectorMan"),
+            "m_7955_e" => Playing("Sword of Vermilion"),
+            "m_0394_e" => Playing("Virtua Fighter 2"),
+            "m_9417_e" => Playing("Zero Wing"),
+
+            #endregion
+            
+            #region Nintendo 64
+
+            "n_1653_e" or "n_1653_p" => Playing("1080º ™ Snowboarding"),
+            "n_4868_e" or "n_4868_p" => Playing("Banjo Kazooie™"),
+            "n_1226_e" or "n_1226_p" => Playing("Banjo-Tooie™"),
+            "n_3083_e" or "n_3083_p" => Playing("Blast Corps"),
+            "n_3007_e" => Playing("Dr. Mario™ 64"),
+            "n_4238_e" => Playing("Excitebike™ 64"),
+            "n_1870_e" => Playing("Extreme G"),
+            "n_2456_e" => Playing("F-Zero™ X"),
+            "n_4631_e" => Playing("GoldenEye 007"),
+            "n_1635_e" => Playing("Harvest Moon 64"),
+            "n_2225_e" => Playing("Iggy’s Reckin’ Balls"),
+            "n_1625_e" or "n_1625_p" => Playing("JET FORCE GEMINI™"),
+            "n_3052_e" => Playing("Kirby 64™: The Crystal Shards"),
+            "n_4371_e" => Playing("Mario Golf™"),
+            "n_3013_e" => Playing("Mario Kart™ 64"),
+            "n_1053_e" or "n_1053_p" => Playing("Mario Party™ 2"),
+            "n_2965_e" or "n_2965_p" => Playing("Mario Party™ 3"),
+            "n_4737_e" or "n_4737_p" => Playing("Mario Party™"),
+            "n_3017_e" => Playing("Mario Tennis™"),
+            "n_2992_e" or "n_2992_p" => Playing("Paper Mario™"),
+            "n_3783_e" or "n_3783_p" => Playing("Pilotwings™ 64"),
+            "n_1848_e" or "n_1848_pd" or "n_1848_pf" => Playing("Pokémon™ Puzzle League"),
+            "n_3240_e" or "n_3240_pd" or "n_3240_pf" or "n_3240_pi" or "n_3240_ps" => Playing("Pokémon Snap™"),
+            "n_4590_e" or "n_4590_pd" or "n_4590_pf" or "n_4590_pi" or "n_4590_ps" => Playing("Pokémon Stadium™"),
+            "n_3309_e" or "n_3309_pd" or "n_3309_pf" or "n_3309_pi" or "n_3309_ps" => Playing("Pokémon Stadium 2™"),
+            "n_3029_e" => Playing("Sin & Punishment™"),
+            "n_3030_e" => Playing("Star Fox™ 64"),
+            "n_3030_p" => Playing("Lylat Wars™"),
+            "n_3031_e" or "n_3031_p" => Playing("Super Mario 64™"),
+            "n_4813_e" or "n_4813_p" => Playing("Wave Race™ 64"),
+            "n_3034_e" => Playing("WIN BACK: COVERT OPERATIONS"),
+            "n_3034_p" => Playing("OPERATION: WIN BACK"),
+            "n_3036_e" or "n_3036_p" => Playing("Yoshi's Story™"),
+            "n_1407_e" or "n_1407_p" => Playing("The Legend of Zelda™: Majora's Mask™"),
+            "n_3038_e" or "n_3038_p" => Playing("The Legend of Zelda™: Ocarina of Time™"),
+
+            #endregion
+
+            #region NES
+
+            "clv_p_naaae" => Playing("Super Mario Bros.™"),
+            "clv_p_naabe" => Playing("Super Mario Bros.™: The Lost Levels"),
+            "clv_p_naace" or "clv_p_naace_sp1" => Playing("Super Mario Bros.™ 3"),
+            "clv_p_naade" => Playing("Super Mario Bros.™ 2"),
+            "clv_p_naaee" => Playing("Donkey Kong™"),
+            "clv_p_naafe" => Playing("Donkey Kong Jr.™"),
+            "clv_p_naage" => Playing("Donkey Kong™ 3"),
+            "clv_p_naahe" => Playing("Excitebike™"),
+            "clv_p_naaje" => Playing("EarthBound Beginnings"),
+            "clv_p_naame" => Playing("NES™ Open Tournament Golf"),
+            "clv_p_naane" or "clv_p_naane_sp1" => Playing("The Legend of Zelda™"),
+            "clv_p_naape" or "clv_p_naape_sp1" => Playing("Kirby's Adventure™"),
+            "clv_p_naaqe" or "clv_p_naaqe_sp1" or "clv_p_naaqe_sp2" => Playing("Metroid™"),
+            "clv_p_naare" => Playing("Balloon Fight™"),
+            "clv_p_naase" or "clv_p_naase_sp1" => Playing("Zelda II - The Adventure of Link™"),
+            "clv_p_naate" => Playing("Punch-Out!!™ Featuring Mr. Dream"),
+            "clv_p_naaue" => Playing("Ice Climber™"),
+            "clv_p_naave" or "clv_p_naave_sp1" => Playing("Kid Icarus™"),
+            "clv_p_naawe" => Playing("Mario Bros.™"),
+            "clv_p_naaxe" or "clv_p_naaxe_sp1" => Playing("Dr. Mario™"),
+            "clv_p_naaye" => Playing("Yoshi™"),
+            "clv_p_naaze" => Playing("StarTropics™"),
+            "clv_p_nabce" or "clv_p_nabce_sp1" => Playing("Ghosts'n Goblins™"),
+            "clv_p_nabre" or "clv_p_nabre_sp1" or "clv_p_nabre_sp2" => Playing("Gradius"),
+            "clv_p_nacbe" or "clv_p_nacbe_sp1" => Playing("Ninja Gaiden"),
+            "clv_p_nacce" => Playing("Solomon's Key"),
+            "clv_p_nacde" => Playing("Tecmo Bowl"),
+            "clv_p_nacfe" => Playing("Double Dragon"),
+            "clv_p_nache" => Playing("Double Dragon II: The Revenge"),
+            "clv_p_nacje" => Playing("River City Ransom"),
+            "clv_p_nacke" => Playing("Super Dodge Ball"),
+            "clv_p_nacle" => Playing("Downtown Nekketsu March Super-Awesome Field Day!"),
+            "clv_p_nacpe" => Playing("The Mystery of Atlantis"),
+            "clv_p_nacre" => Playing("Soccer"),
+            "clv_p_nacse" or "clv_p_nacse_sp1" => Playing("Ninja JaJaMaru-kun"),
+            "clv_p_nacte" => Playing("Ice Hockey"),
+            "clv_p_nacue" or "clv_p_nacue_sp1" => Playing("Blaster Master"),
+            "clv_p_nacwe" => Playing("ADVENTURES OF LOLO"),
+            "clv_p_nacxe" => Playing("Wario's Woods™"),
+            "clv_p_nacye" => Playing("Tennis"),
+            "clv_p_nacze" => Playing("Wrecking Crew™"),
+            "clv_p_nadbe" => Playing("Joy Mech Fight™"),
+            "clv_p_nadde" or "clv_p_nadde_sp1" => Playing("Star Soldier"),
+            "clv_p_nadke" => Playing("Tetris®"),
+            "clv_p_nadle" => Playing("Pro Wrestling"),
+            "clv_p_nadpe" => Playing("Baseball"),
+            "clv_p_nadte" or "clv_p_nadte_sp1" => Playing("TwinBee"),
+            "clv_p_nadue" or "clv_p_nadue_sp1" => Playing("Mighty Bomb Jack"),
+            "clv_p_nadve" => Playing("Kung-Fu Heroes"),
+            "clv_p_nadxe" => Playing("City Connection"),
+            "clv_p_nadye" => Playing("Rygar"),
+            "clv_p_naeae" => Playing("Crystalis"),
+            "clv_p_naece" => Playing("Vice: Project Doom"),
+            "clv_p_naehe" => Playing("Clu Clu Land™"),
+            "clv_p_naeie" => Playing("VS. Excitebike™"),
+            "clv_p_naeje" => Playing("Volleyball™"),
+            "clv_p_naeke" => Playing("JOURNEY TO SILIUS"),
+            "clv_p_naele" => Playing("S.C.A.T.: Special Cybernetic Attack Team"),
+            "clv_p_naeme" => Playing("Shadow of the Ninja"),
+            "clv_p_naene" => Playing("Nightshade"),
+            "clv_p_naepe" => Playing("The Immortal"),
+            "clv_p_naeqe" => Playing("Eliminator Boat Duel"),
+            "clv_p_naere" => Playing("Fire 'n Ice"),
+            "clv_p_nafce" => Playing("XEVIOUS"),
+            "clv_p_nagpe" => Playing("DAIVA STORY 6 IMPERIAL OF NIRSARTIA"),
+            "clv_p_nagqe" => Playing("DIG DUGⅡ"),
+            "clv_p_nague" => Playing("MAPPY-LAND"),
+            "clv_p_nahhe" => Playing("Mach Rider™"),
+            "clv_p_nahje" => Playing("Pinball"),
+            "clv_p_nahre" => Playing("Mystery Tower"),
+            "clv_p_nahte" => Playing("Urban Champion™"),
+            "clv_p_nahue" => Playing("Donkey Kong Jr.™ Math"),
+            "clv_p_nahve" => Playing("The Mysterious Murasame Castle"),
+            "clv_p_najae" => Playing("DEVIL WORLD™"),
+            "clv_p_najbe" => Playing("Golf"),
+            "clv_p_najpe" => Playing("R.C. PRO-AM™"),
+            "clv_p_najre" => Playing("COBRA TRIANGLE™"),
+            "clv_p_najse" => Playing("SNAKE RATTLE N ROLL™"),
+            "clv_p_najte" => Playing("SOLAR® JETMAN"),
+
+            #endregion
+
+            #region SNES
+
+            "s_2180_e" => Playing("BATTLETOADS™ DOUBLE DRAGON™"),
+            "s_2179_e" => Playing("BATTLETOADS™ IN BATTLEMANIACS"),
+            "s_2182_e" => Playing("BIG RUN"),
+            "s_2156_e" => Playing("Bombuzal"),
+            "s_2002_e" => Playing("BRAWL BROTHERS"),
+            "s_2025_e" => Playing("Breath of Fire II"),
+            "s_2003_e" => Playing("Breath Of Fire"),
+            "s_2163_e" => Playing("Claymates"),
+            "s_2150_e" => Playing("Congo's Caper"),
+            "s_2171_e" => Playing("COSMO GANG THE PUZZLE"),
+            "s_2004_e" => Playing("Demon's Crest"),
+            "s_2026_e" => Playing("Kunio-kun no Dodgeball da yo Zen'in Shūgō!"),
+            "s_2060_e" => Playing("Donkey Kong Country 2: Diddy's Kong Quest"),
+            "s_2061_e" => Playing("Donkey Kong Country 3: Dixie Kong's Double Trouble!"),
+            "s_2055_e" => Playing("Donkey Kong Country"),
+            "s_2139_e" => Playing("DOOMSDAY WARRIOR"),
+            "s_2051_e" => Playing("EarthBound"),
+            "s_2162_e" => Playing("Earthworm Jim™ 2"),
+            "s_2005_e" => Playing("F-ZERO™"),
+            "s_2183_e" => Playing("FATAL FURY 2"),
+            "s_2174_e" => Playing("Fighter's History"),
+            "s_2037_e" => Playing("Harvest Moon"),
+            "s_2161_e" => Playing("Jelly Boy"),
+            "s_2006_e" => Playing("Joe & Mac 2: Lost in the Tropics"),
+            "s_2169_e" => Playing("Caveman Ninja"),
+            "s_2181_e" => Playing("KILLER INSTINCT™"),
+            "s_2029_e" or "s_2029_e_sp1" => Playing("Kirby Super Star™"),
+            "s_2121_e" => Playing("Kirby's Avalanche™"),
+            "s_2007_e" or "s_2007_e_sp1" => Playing("Kirby's Dream Course™"),
+            "s_2008_e" or "s_2008_e_sp1" => Playing("Kirby's Dream Land™ 3"),
+            "s_2172_e" => Playing("Kirby’s Star Stacker™"),
+            "s_2151_e" => Playing("Magical Drop2"),
+            "s_2044_e" => Playing("Mario's Super Picross"),
+            "s_2038_e" => Playing("Natsume Championship Wrestling"),
+            "s_2140_e" => Playing("Operation Logic Bomb"),
+            "s_2034_e" => Playing("Panel de Pon"),
+            "s_2009_e" => Playing("Pilotwings™"),
+            "s_2010_e" => Playing("Pop'n TwinBee"),
+            "s_2157_e" => Playing("Prehistorik Man"),
+            "s_2145_e" => Playing("Psycho Dream"),
+            "s_2141_e" => Playing("Rival Turf!"),
+            "s_2152_e" => Playing("SIDE POCKET"),
+            "s_2158_e" => Playing("Spanky’s™ Quest"),
+            "s_2031_e" => Playing("Star Fox™ 2"),
+            "s_2011_e" => Playing("Star Fox™"),
+            "s_2012_e" => Playing("Stunt Race FX™"),
+            "s_2032_e" => Playing("Amazing Hebereke"),
+            "s_2159_e" => Playing("Super Baseball Simulator 1.000"),
+            "s_2013_e" => Playing("SUPER E.D.F. EARTH DEFENSE FORCE"),
+            "s_2014_e" => Playing("Smash Tennis"),
+            "s_2015_e" => Playing("Super Ghouls'n Ghosts™"),
+            "s_2033_e" => Playing("Super Mario All-Stars™"),
+            "s_2016_e" or "s_2016_e_sp1" => Playing("Super Mario Kart™"),
+            "s_2017_e" or "s_2017_e_sp1" => Playing("Super Mario World™"),
+            "s_2018_e" or "s_2018_e_sp1" => Playing("Super Metroid™"),
+            "s_2184_e" => Playing("Super Ninja Boy"),
+            "s_2019_e" or "s_2019_e_sp1" => Playing("Super Punch-Out!!™"),
+            "s_2020_e" => Playing("Super Puyo Puyo 2"),
+            "s_2133_e" => Playing("SUPER R-TYPE"),
+            "s_2021_e" => Playing("Super Soccer"),
+            "s_2022_e" => Playing("Super Tennis"),
+            "s_2136_e" => Playing("Sutte Hakkun"),
+            "s_2142_e" => Playing("The Ignition Factor"),
+            "s_2143_e" => Playing("The Peace Keepers"),
+            "s_2146_e" => Playing("Tuff E Nuff"),
+            "s_2144_e" => Playing("SUPER VALIS Ⅳ"),
+            "s_2049_e" => Playing("Wild Guns"),
+            "s_2096_e" => Playing("Wrecking Crew™ '98"),
+            "s_2023_e" => Playing("Super Mario World™ 2: Yoshi's Island™"),
+            "s_2024_e" => Playing("The Legend of Zelda™: A Link to the Past™"),
+
+            #endregion
+
+            #region GameBoy
+
+            "c_7224_e" or "c_7224_p" => Playing("Alone in the Dark: The New Nightmare"),
+            "c_5022_e" => Playing("Blaster Master: Enemy Below"),
+            "c_3381_e" => Playing("Game & Watch™ Gallery 3"),
+            "c_0282_e" => Playing("Kirby Tilt ‘n’ Tumble™"),
+            "c_4471_e" or "c_4471_p" => Playing("Mario Golf™"),
+            "c_9947_e" => Playing("Mario Tennis™"),
+            "c_3191_e" or "c_3191_p" or "c_3191_x" => Playing("Pokémon™ Trading Card Game"),
+            "c_8914_e" or "c_8914_p" => Playing("Quest for Camelot™"),
+            "c_2648_e" => Playing("Tetris® DX"),
+            "c_5928_e" => Playing("Wario Land™ 3"),
+            "c_3996_e" or "c_3996_pd" or "c_3996_pf" => Playing("The Legend of Zelda™: Link's Awakening DX™"),
+            "c_8852_e" or "c_8852_p" => Playing("The Legend of Zelda™: Oracle of Ages™"),
+            "c_9130_e" or "c_9130_p" => Playing("The Legend of Zelda™: Oracle of Seasons™"),
+            "d_6879_e" => Playing("Alleyway™"),
+            "d_7618_e" => Playing("Baseball"),
+            "d_6005_e" => Playing("BurgerTime Deluxe"),
+            "d_7120_e" => Playing("Castlevania Legends"),
+            "d_2744_e" => Playing("Dr. Mario™"),
+            "d_1593_e" => Playing("Donkey Kong Land 2™"),
+            "d_7216_e" => Playing("Donkey Kong Land III™"),
+            "d_4971_e" => Playing("Donkey Kong Land™"),
+            "d_7984_e" => Playing("GARGOYLE'S QUEST"),
+            "d_8212_e" => Playing("Kirby's Dream Land™ 2"),
+            "d_5661_e" => Playing("Kirby's Dream Land™"),
+            "d_3837_e" => Playing("MEGA MAN II"),
+            "d_1965_e" => Playing("MEGA MAN III"),
+            "d_0194_e" => Playing("MEGA MAN IV"),
+            "d_1425_e" => Playing("MEGA MAN V"),
+            "d_9324_e" => Playing("MEGA MAN: DR. WILY'S REVENGE"),
+            "d_1577_e" => Playing("Metroid™ II - Return of Samus™"),
+            "d_5124_e" => Playing("Super Mario Land™ 2 - 6 Golden Coins™"),
+            "d_7970_e" => Playing("Super Mario Land™"),
+            "d_8484_e" => Playing("Tetris®"),
+
+            #endregion
+
+            #region GameBoy Advance
+
+            "a_9694_e" => Playing("Densetsu no Starfy 1"),
+            "a_5600_e" => Playing("Densetsu no Starfy 2"),
+            "a_7565_e" => Playing("Densetsu no Starfy 3"),
+            "a_6553_e" => Playing("F-ZERO CLIMAX"),
+            "a_7842_e" or "a_7842_p" => Playing("F-Zero™- GP Legend"),
+            "a_9283_e" => Playing("F-Zero™ Maximum Velocity"),
+            "a_3744_e" or "a_3744_x" or "a_3744_y" => Playing("Fire Emblem™"),
+            "a_8978_d" or "a_8978_e" or "a_8978_f" or "a_8978_i" or "a_8978_s" => Playing("Golden Sun™: The Lost Age"),
+            "a_3108_d" or "a_3108_e" or "a_3108_f" or "a_3108_i" or "a_3108_s" => Playing("Golden Sun™"),
+            "a_3654_e" or "a_3654_p" => Playing("Kirby™ & The Amazing Mirror"),
+            "a_7279_p" => Playing("Kuru Kuru Kururin™"),
+            "a_7311_e" or "a_7311_p" => Playing("Mario & Luigi™: Superstar Saga"),
+            "a_6845_e" => Playing("Mario Kart™: Super Circuit™"),
+            "a_4139_e" or "a_4139_p" => Playing("Metroid™ Fusion"),
+            "a_6834_e" or "a_6834_p" => Playing("Metroid™: Zero Mission"),
+            "a_8989_e" or "a_8989_p" => Playing("Pokémon™ Mystery Dungeon: Red Rescue Team"),
+            "a_9444_e" => Playing("Super Mario™ Advance"),
+            "a_9901_e" or "a_9901_p" => Playing("Super Mario™ Advance 4: Super Mario Bros.™ 3"),
+            "a_2939_e" => Playing("Super Mario World™: Super Mario Advance 2"),
+            "a_2939_p" => Playing("Super Mario World™: Super Mario Advance 2™"),
+            "a_1302_e" => Playing("WarioWare™, Inc.: Mega Microgame$!"),
+            "a_1302_p" => Playing("WarioWare™, Inc.: Minigame Mania."),
+            "a_6960_e" or "a_6960_p" => Playing("Yoshi's Island™: Super Mario™ Advance 3"),
+            "a_5190_e" or "a_5190_p" => Playing("The Legend of Zelda™: A Link to the Past™ Four Swords"),
+            "a_8665_e" or "a_8665_p" => Playing("The Legend of Zelda™: The Minish Cap"),
+
+            #endregion
+
+            _ => FormattedValue.ForceReset
+        };
+    }
+}
--- a/src/Ryujinx/Utilities/PlayReport/PlayReports.cs
+++ b/src/Ryujinx/Utilities/PlayReport/PlayReports.cs
@ -0,0 +1,99 @@
+using System;
+
+namespace Ryujinx.Ava.Utilities.PlayReport
+{
+    public static partial class PlayReports
+    {
+        public static void Initialize()
+        {
+            // init lazy value
+            _ = Analyzer;
+        }
+
+        public static Analyzer Analyzer => _analyzerLazy.Value;
+
+        private static readonly Lazy<Analyzer> _analyzerLazy = new(() => new Analyzer()
+            .AddSpec(
+                "01007ef00011e000",
+                spec => spec
+                    .WithDescription("based on being in Master Mode.")
+                    .AddValueFormatter("IsHardMode", BreathOfTheWild_MasterMode)
+                    // reset to normal status when switching between normal & master mode in title screen
+                    .AddValueFormatter("AoCVer", FormattedValue.SingleAlwaysResets)
+            )
+            .AddSpec(
+                "0100f2c0115b6000",
+                spec => spec
+                    .WithDescription("based on where you are in Hyrule (Depths, Surface, Sky).")
+                    .AddValueFormatter("PlayerPosY", TearsOfTheKingdom_CurrentField))
+            .AddSpec(
+                "01002da013484000",
+                spec => spec
+                    .WithDescription("based on how many Rupees you have.")
+                    .AddValueFormatter("rupees", SkywardSwordHD_Rupees))
+            .AddSpec(
+                "0100000000010000",
+                spec => spec
+                    .WithDescription("based on if you're playing with Assist Mode.")
+                    .AddValueFormatter("is_kids_mode", SuperMarioOdyssey_AssistMode)
+            )
+            .AddSpec(
+                "010075000ecbe000",
+                spec => spec
+                    .WithDescription("based on if you're playing with Assist Mode.")
+                    .AddValueFormatter("is_kids_mode", SuperMarioOdysseyChina_AssistMode)
+            )
+            .AddSpec(
+                "010028600ebda000",
+                spec => spec
+                    .WithDescription("based on being in either Super Mario 3D World or Bowser's Fury.")
+                    .AddValueFormatter("mode", SuperMario3DWorldOrBowsersFury)
+            )
+            .AddSpec( // Global & China IDs
+                ["0100152000022000", "010075100e8ec000"],
+                spec => spec
+                    .WithDescription(
+                        "based on what modes you're selecting in the menu & whether or not you're in a race.")
+                    .AddValueFormatter("To", MarioKart8Deluxe_Mode)
+            )
+            .AddSpec(
+                ["0100a3d008c5c000", "01008f6008c5e000"],
+                spec => spec
+                    .WithDescription("based on what area of Paldea you're exploring.")
+                    .AddValueFormatter("area_no", PokemonSVArea)
+                    .AddValueFormatter("team_circle", PokemonSVUnionCircle)
+            )
+            .AddSpec(
+                "01006a800016e000",
+                spec => spec
+                    .WithDescription("based on what mode you're playing, who won, and what characters were present.")
+                    .AddSparseMultiValueFormatter(
+                        [
+                            // Metadata to figure out what PlayReport we have.
+                            "match_mode", "match_submode", "anniversary", "fighter", "reason", "challenge_count",
+                            "adv_slot",
+                            // List of Fighters
+                            "player_1_fighter", "player_2_fighter", "player_3_fighter", "player_4_fighter",
+                            "player_5_fighter", "player_6_fighter", "player_7_fighter", "player_8_fighter",
+                            // List of rankings/placements
+                            "player_1_rank", "player_2_rank", "player_3_rank", "player_4_rank", "player_5_rank",
+                            "player_6_rank", "player_7_rank", "player_8_rank"
+                        ],
+                        SuperSmashBrosUltimate_Mode
+                    )
+            )
+            .AddSpec(
+                [
+                    "0100c9a00ece6000", "01008d300c50c000", "0100d870045b6000",
+                    "010012f017576000", "0100c62011050000", "0100b3c014bda000"
+                ],
+                spec => spec
+                    .WithDescription(
+                        "based on what game you first launch.\n\nNSO emulators do not print any Play Report information past the first game launch so it's all we got.")
+                    .AddValueFormatter("launch_title_id", NsoEmulator_LaunchedGame)
+            )
+        );
+
+        private static string Playing(string game) => $"Playing {game}";
+    }
+}
--- a/src/Ryujinx/Utilities/PlayReport/Specs.cs
+++ b/src/Ryujinx/Utilities/PlayReport/Specs.cs
@ -0,0 +1,249 @@
+using MsgPack;
+using Ryujinx.Ava.Utilities.AppLibrary;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Ryujinx.Ava.Utilities.PlayReport
+{
+    /// <summary>
+    /// A mapping of title IDs to value formatter specs.
+    ///
+    /// <remarks>Generally speaking, use the <see cref="Analyzer"/>.AddSpec(...) methods instead of creating this class yourself.</remarks>
+    /// </summary>
+    public class GameSpec
+    {
+        public static GameSpec Create(string requiredTitleId, params IEnumerable<string> otherTitleIds)
+            => new() { TitleIds = otherTitleIds.Prepend(requiredTitleId).ToArray() };
+
+        public static GameSpec Create(IEnumerable<string> titleIds)
+            => new() { TitleIds = titleIds.ToArray() };
+
+        private int _lastPriority;
+
+        public required string[] TitleIds { get; init; }
+
+        public const string DefaultDescription = "Formats the details on your Discord presence based on logged data from the game.";
+
+        private string _valueDescription;
+
+        public string Description => _valueDescription ?? DefaultDescription;
+
+        public GameSpec WithDescription(string description)
+        {
+            _valueDescription = description != null
+                ? $"Formats the details on your Discord presence {description}"
+                : null;
+            return this;
+        }
+        
+        public List<FormatterSpecBase> ValueFormatters { get; } = [];
+
+
+        /// <summary>
+        /// Add a value formatter to the current <see cref="GameSpec"/>
+        /// matching a specific key that could exist in a Play Report for the previously specified title IDs.
+        /// </summary>
+        /// <param name="reportKey">The key name to match.</param>
+        /// <param name="valueFormatter">The function which can return a potential formatted value.</param>
+        /// <returns>The current <see cref="GameSpec"/>, for chaining convenience.</returns>
+        public GameSpec AddValueFormatter(
+            string reportKey,
+            SingleValueFormatter valueFormatter
+        ) => AddValueFormatter(_lastPriority++, reportKey, valueFormatter);
+
+        /// <summary>
+        /// Add a value formatter at a specific priority to the current <see cref="GameSpec"/>
+        /// matching a specific key that could exist in a Play Report for the previously specified title IDs.
+        /// </summary>
+        /// <param name="priority">The resolution priority of this value formatter. Higher resolves sooner.</param>
+        /// <param name="reportKey">The key name to match.</param>
+        /// <param name="valueFormatter">The function which can return a potential formatted value.</param>
+        /// <returns>The current <see cref="GameSpec"/>, for chaining convenience.</returns>
+        public GameSpec AddValueFormatter(
+            int priority,
+            string reportKey,
+            SingleValueFormatter valueFormatter
+        ) => AddValueFormatter(new FormatterSpec
+        {
+            Priority = priority, ReportKeys = [reportKey], Formatter = valueFormatter
+        });
+
+        /// <summary>
+        /// Add a multi-value formatter to the current <see cref="GameSpec"/>
+        /// matching a specific set of keys that could exist in a Play Report for the previously specified title IDs.
+        /// </summary>
+        /// <param name="reportKeys">The key names to match.</param>
+        /// <param name="valueFormatter">The function which can format the values.</param>
+        /// <returns>The current <see cref="GameSpec"/>, for chaining convenience.</returns>
+        public GameSpec AddMultiValueFormatter(
+            string[] reportKeys,
+            MultiValueFormatter valueFormatter
+        ) => AddMultiValueFormatter(_lastPriority++, reportKeys, valueFormatter);
+
+        /// <summary>
+        /// Add a multi-value formatter at a specific priority to the current <see cref="GameSpec"/>
+        /// matching a specific set of keys that could exist in a Play Report for the previously specified title IDs.
+        /// </summary>
+        /// <param name="priority">The resolution priority of this value formatter. Higher resolves sooner.</param>
+        /// <param name="reportKeys">The key names to match.</param>
+        /// <param name="valueFormatter">The function which can format the values.</param>
+        /// <returns>The current <see cref="GameSpec"/>, for chaining convenience.</returns>
+        public GameSpec AddMultiValueFormatter(
+            int priority,
+            string[] reportKeys,
+            MultiValueFormatter valueFormatter
+        ) => AddValueFormatter(new MultiFormatterSpec
+        {
+            Priority = priority, ReportKeys = reportKeys, Formatter = valueFormatter
+        });
+
+        /// <summary>
+        /// Add a multi-value formatter to the current <see cref="GameSpec"/>
+        /// matching a specific set of keys that could exist in a Play Report for the previously specified title IDs.
+        /// <br/><br/>
+        /// The 'Sparse' multi-value formatters do not require every key to be present.
+        /// If you need this requirement, use <see cref="AddMultiValueFormatter(string[], Ryujinx.Ava.Utilities.PlayReport.MultiValueFormatter)"/>.
+        /// </summary>
+        /// <param name="reportKeys">The key names to match.</param>
+        /// <param name="valueFormatter">The function which can format the values.</param>
+        /// <returns>The current <see cref="GameSpec"/>, for chaining convenience.</returns>
+        public GameSpec AddSparseMultiValueFormatter(
+            string[] reportKeys,
+            SparseMultiValueFormatter valueFormatter
+        ) => AddSparseMultiValueFormatter(_lastPriority++, reportKeys, valueFormatter);
+
+        /// <summary>
+        /// Add a multi-value formatter at a specific priority to the current <see cref="GameSpec"/>
+        /// matching a specific set of keys that could exist in a Play Report for the previously specified title IDs.
+        /// <br/><br/>
+        /// The 'Sparse' multi-value formatters do not require every key to be present.
+        /// If you need this requirement, use <see cref="AddMultiValueFormatter(int, string[], Ryujinx.Ava.Utilities.PlayReport.MultiValueFormatter)"/>.
+        /// </summary>
+        /// <param name="priority">The resolution priority of this value formatter. Higher resolves sooner.</param>
+        /// <param name="reportKeys">The key names to match.</param>
+        /// <param name="valueFormatter">The function which can format the values.</param>
+        /// <returns>The current <see cref="GameSpec"/>, for chaining convenience.</returns>
+        public GameSpec AddSparseMultiValueFormatter(
+            int priority,
+            string[] reportKeys,
+            SparseMultiValueFormatter valueFormatter
+        ) => AddValueFormatter(new SparseMultiFormatterSpec
+        {
+            Priority = priority, ReportKeys = reportKeys, Formatter = valueFormatter
+        });
+
+        private GameSpec AddValueFormatter<T>(T formatterSpec) where T : FormatterSpecBase
+        {
+            ValueFormatters.Add(formatterSpec);
+            return this;
+        }
+    }
+
+    /// <summary>
+    /// A struct containing the data for a mapping of a key in a Play Report to a formatter for its potential value.
+    /// </summary>
+    public class FormatterSpec : FormatterSpecBase
+    {
+        public override bool GetData(Horizon.Prepo.Types.PlayReport playReport, out object result)
+        {
+            if (!playReport.ReportData.AsDictionary().TryGetValue(ReportKeys[0], out MessagePackObject valuePackObject))
+            {
+                result = null;
+                return false;
+            }
+
+            result = valuePackObject;
+            return true;
+        }
+    }
+
+    /// <summary>
+    /// A struct containing the data for a mapping of an arbitrary key set in a Play Report to a formatter for their potential values.
+    /// </summary>
+    public class MultiFormatterSpec : FormatterSpecBase
+    {
+        public override bool GetData(Horizon.Prepo.Types.PlayReport playReport, out object result)
+        {
+            List<MessagePackObject> packedObjects = [];
+            foreach (string reportKey in ReportKeys)
+            {
+                if (!playReport.ReportData.AsDictionary().TryGetValue(reportKey, out MessagePackObject valuePackObject))
+                {
+                    result = null;
+                    return false;
+                }
+
+                packedObjects.Add(valuePackObject);
+            }
+
+            result = packedObjects;
+            return true;
+        }
+    }
+
+    /// <summary>
+    /// A struct containing the data for a mapping of an arbitrary key set in a Play Report to a formatter for their sparsely populated potential values.
+    /// </summary>
+    public class SparseMultiFormatterSpec : FormatterSpecBase
+    {
+        public override bool GetData(Horizon.Prepo.Types.PlayReport playReport, out object result)
+        {
+            Dictionary<string, MessagePackObject> packedObjects = [];
+            foreach (string reportKey in ReportKeys)
+            {
+                if (!playReport.ReportData.AsDictionary().TryGetValue(reportKey, out MessagePackObject valuePackObject))
+                    continue;
+
+                packedObjects.Add(reportKey, valuePackObject);
+            }
+
+            result = packedObjects;
+            return true;
+        }
+    }
+
+    public abstract class FormatterSpecBase
+    {
+        public abstract bool GetData(Horizon.Prepo.Types.PlayReport playReport, out object data);
+
+        public int Priority { get; init; }
+        public string[] ReportKeys { get; init; }
+        public Delegate Formatter { get; init; }
+
+        public bool TryFormat(ApplicationMetadata appMeta, Horizon.Prepo.Types.PlayReport playReport,
+            out FormattedValue formattedValue)
+        {
+            formattedValue = default;
+            if (!GetData(playReport, out object data))
+                return false;
+
+            if (data is FormattedValue fv)
+            {
+                formattedValue = fv;
+                return true;
+            }
+
+            switch (Formatter)
+            {
+                case SingleValueFormatter svf when data is MessagePackObject match:
+                    formattedValue = svf(
+                        new SingleValue(match) { Application = appMeta, PlayReport = playReport }
+                    );
+                    return true;
+                case MultiValueFormatter mvf when data is List<MessagePackObject> matches:
+                    formattedValue = mvf(
+                        new MultiValue(matches) { Application = appMeta, PlayReport = playReport }
+                    );
+                    return true;
+                case SparseMultiValueFormatter smvf when data is Dictionary<string, MessagePackObject> sparseMatches:
+                    formattedValue = smvf(
+                        new SparseMultiValue(sparseMatches) { Application = appMeta, PlayReport = playReport }
+                    );
+                    return true;
+                default:
+                    throw new InvalidOperationException("Formatter delegate is not of a known type!");
+            }
+        }
+    }
+}
--- a/src/Ryujinx/Utilities/PlayReport/Value.cs
+++ b/src/Ryujinx/Utilities/PlayReport/Value.cs
@ -0,0 +1,160 @@
+using MsgPack;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Ryujinx.Ava.Utilities.PlayReport
+{
+    /// <summary>
+    /// The base input data to a ValueFormatter delegate,
+    /// and the matched <see cref="MessagePackObject"/> from the Play Report.
+    /// </summary>
+    public readonly struct Value
+    {
+        public Value(MessagePackObject packedValue)
+        {
+            PackedValue = packedValue;
+        }
+
+        /// <summary>
+        /// The matched value from the Play Report.
+        /// </summary>
+        public MessagePackObject PackedValue { get; init; }
+
+        /// <summary>
+        /// Access the <see cref="PackedValue"/> as its underlying .NET type.<br/>
+        /// 
+        /// Does not seem to work well with comparing numeric types,
+        /// so use XValue properties for that.
+        /// </summary>
+        public object BoxedValue => PackedValue.ToObject();
+
+        public override string ToString()
+        {
+            object boxed = BoxedValue;
+            return boxed == null
+                ? "null"
+                : boxed.ToString();
+        }
+
+        public static implicit operator Value(MessagePackObject matched) => new(matched);
+
+        public static Value[] ConvertPackedObjects(IEnumerable<MessagePackObject> packObjects)
+            => packObjects.Select(packObject => new Value(packObject)).ToArray();
+
+        public static Dictionary<string, Value> ConvertPackedObjectMap(Dictionary<string, MessagePackObject> packObjects)
+            => packObjects.ToDictionary(
+                x => x.Key,
+                x => new Value(x.Value)
+            );
+
+        #region AsX accessors
+
+        public bool BooleanValue => PackedValue.AsBoolean();
+        public byte ByteValue => PackedValue.AsByte();
+        public sbyte SByteValue => PackedValue.AsSByte();
+        public short ShortValue => PackedValue.AsInt16();
+        public ushort UShortValue => PackedValue.AsUInt16();
+        public int IntValue => PackedValue.AsInt32();
+        public uint UIntValue => PackedValue.AsUInt32();
+        public long LongValue => PackedValue.AsInt64();
+        public ulong ULongValue => PackedValue.AsUInt64();
+        public float FloatValue => PackedValue.AsSingle();
+        public double DoubleValue => PackedValue.AsDouble();
+        public string StringValue => PackedValue.AsString();
+        public Span<byte> BinaryValue => PackedValue.AsBinary();
+
+        #endregion
+    }
+
+    /// <summary>
+    /// A potential formatted value returned by a ValueFormatter delegate.
+    /// </summary>
+    public readonly struct FormattedValue
+    {
+        /// <summary>
+        /// Was any handler able to match anything in the Play Report?
+        /// </summary>
+        public bool Handled { get; private init; }
+
+        /// <summary>
+        /// Did the handler request the caller of the <see cref="Analyzer"/> to reset the existing value?
+        /// </summary>
+        public bool Reset { get; private init; }
+
+        /// <summary>
+        /// The formatted value, only present if <see cref="Handled"/> is true, and <see cref="Reset"/> is false.
+        /// </summary>
+        public string FormattedString { get; private init; }
+
+        /// <summary>
+        /// The intended path of execution for having a string to return: simply return the string.
+        /// This implicit conversion will make the struct for you.<br/><br/>
+        ///
+        /// If the input is null, <see cref="Unhandled"/> is returned.
+        /// </summary>
+        /// <param name="formattedValue">The formatted string value.</param>
+        /// <returns>The automatically constructed <see cref="FormattedValue"/> struct.</returns>
+        public static implicit operator FormattedValue(string formattedValue)
+            => formattedValue is not null
+                ? new FormattedValue { Handled = true, FormattedString = formattedValue }
+                : Unhandled;
+
+        public override string ToString()
+        {
+            if (!Handled)
+                return "<Unhandled>";
+
+            if (Reset)
+                return "<Reset>";
+
+            return FormattedString;
+        }
+
+        /// <summary>
+        /// Return this to tell the caller there is no value to return.
+        /// </summary>
+        public static readonly FormattedValue Unhandled = default;
+
+        /// <summary>
+        /// Return this to suggest the caller reset the value it's using the <see cref="Analyzer"/> for.
+        /// </summary>
+        public static readonly FormattedValue ForceReset = new() { Handled = true, Reset = true };
+
+        /// <summary>
+        /// A delegate singleton you can use to always return <see cref="ForceReset"/> in a <see cref="SingleValueFormatter"/>.
+        /// </summary>
+        public static readonly SingleValueFormatter SingleAlwaysResets = _ => ForceReset;
+
+        /// <summary>
+        /// A delegate singleton you can use to always return <see cref="ForceReset"/> in a <see cref="MultiValueFormatter"/>.
+        /// </summary>
+        public static readonly MultiValueFormatter MultiAlwaysResets = _ => ForceReset;
+        
+        /// <summary>
+        /// A delegate singleton you can use to always return <see cref="ForceReset"/> in a <see cref="SparseMultiValueFormatter"/>.
+        /// </summary>
+        public static readonly SparseMultiValueFormatter SparseMultiAlwaysResets = _ => ForceReset;
+
+        /// <summary>
+        /// A delegate factory you can use to always return the specified
+        /// <paramref name="formattedValue"/> in a <see cref="SingleValueFormatter"/>.
+        /// </summary>
+        /// <param name="formattedValue">The string to always return for this delegate instance.</param>
+        public static SingleValueFormatter SingleAlwaysReturns(string formattedValue) => _ => formattedValue;
+        
+        /// <summary>
+        /// A delegate factory you can use to always return the specified
+        /// <paramref name="formattedValue"/> in a <see cref="MultiValueFormatter"/>.
+        /// </summary>
+        /// <param name="formattedValue">The string to always return for this delegate instance.</param>
+        public static MultiValueFormatter MultiAlwaysReturns(string formattedValue) => _ => formattedValue;
+        
+        /// <summary>
+        /// A delegate factory you can use to always return the specified
+        /// <paramref name="formattedValue"/> in a <see cref="SparseMultiValueFormatter"/>.
+        /// </summary>
+        /// <param name="formattedValue">The string to always return for this delegate instance.</param>
+        public static SparseMultiValueFormatter SparseMultiAlwaysReturns(string formattedValue) => _ => formattedValue;
+    }
+}
Author	SHA1	Message	Date
Willians	b16b844760	Update PT-BR Big Translation & Add DKC Returns HD to compatibility list (#666 ) Today I had a free day to look at and work on the entire Brazilian Portuguese language. Translations that had not been done before have been added Fixed several translations that didn't make sense Translated description of functions that were not translated correctly Words were written as close to the original English Add Donkey Kong Country Returns HD to compatibility list	2025-02-16 15:39:42 -06:00
Vudjun	bc07bc482d	Gracefully handle errors in socket creation (#662 ) In all other calls, exceptions are handled within the ManagedSocket class, this can't easily be done here as the exception is thrown from the constructor, so the exception is handled in ISocket and the correct error is passed to the application. This should fix #660	2025-02-16 02:26:37 -06:00
Vudjun	61975ca44d	Add logging in socket implementation (#661 ) Adds logging to most Socket calls to help with debugging network issues. Shouldn't affect any functionality. There's a small chance it could spam the log in some games.	2025-02-16 01:03:44 -06:00
Evan Husted	66054dd225	UI: RPC: Remove git hash from RPC ryujinx logo hover information	2025-02-16 00:58:25 -06:00
Evan Husted	b1f61e5143	misc: chore: [ci skip] Reformat PlayReports.cs	2025-02-15 20:52:03 -06:00
Evan Husted	0d7d0e8092	UI: Add descriptions of what each dynamic RPC formatter actually shows when hovering whether it has support in the game info popup	2025-02-15 20:45:27 -06:00
Evan Husted	aa2178dbe5	UI: Button to open screenshots folder in File menu	2025-02-15 20:25:17 -06:00
Evan Husted	f92d09711b	misc: chore: rewrite PlayReports.Analyzer creation to use Lazy and create the value alongside DiscordIntegrationModule init	2025-02-15 19:02:53 -06:00
Evan Husted	45ee8cd0e8	misc: Play Report Analyzer: Skyward Sword HD rupee count	2025-02-15 19:02:04 -06:00
Evan Husted	395bbd144a	misc: chore: Change Analyzer AddSpec logic to log the non-hexadecimal value and ignore the added entry instead of throwing an exception	2025-02-15 19:01:24 -06:00
Evan Husted	744d813b87	misc: i18n: change localization of Ignore Applet to Ignore Controller Applet & redo tooltip	2025-02-15 00:40:18 -06:00
Evan Husted	7d59ada798	misc: chore: rename IgnoreApplet to IgnoreControllerApplet	2025-02-15 00:25:28 -06:00
Evan Husted	a4b5304935	UI: Refresh game list when emulated Switch language is changed (to show different logos/names)	2025-02-15 00:20:01 -06:00
Evan Husted	0965ee905d	misc: Fix Match System Time not persisting between emulator launches	2025-02-14 22:18:15 -06:00
FluffyOMC	855161b23b	Prevent log from showing negative JIT cache sizes (32bit-int overflow) (#664 ) ![image](https://github.com/user-attachments/assets/5820ce7b-cbfe-4908-8f5e-7ee82040ee1a)	2025-02-14 21:37:19 -06:00
Daenorth	6b55d158b7	Norwegian locale update & update Jackbox 5 & 6 compat (#658 )	2025-02-13 22:38:55 -06:00
Daniel Nylander	91f73a4891	Updated Swedish translation (#594 )	2025-02-13 19:28:39 -06:00
Evan Husted	883d4d863a	i18n: chore: [ci skip] missing closing single quote in translation (not JSON breaking)	2025-02-13 19:16:05 -06:00
Dennis	ca5de909a1	Updated German translation (#626 )	2025-02-13 19:14:02 -06:00
Willians	5172567b08	Update Brazilian Translation PT-BR (#633 ) I updated the Brazilian Portuguese translation, I added the texts that were not translated.	2025-02-13 19:08:48 -06:00
heihei123456780	6fe4cee7c0	Update zh_CN translation (#650 )	2025-02-13 18:16:12 -06:00
Evan Husted	8623452abc	docs: new discord invite	2025-02-13 03:23:02 -06:00
Evan Husted	17e8ae1d9a	UI: More advanced customization for what happens when Ryujinx loses focus	2025-02-13 01:57:08 -06:00
Evan Husted	7591b07fce	infra: Update workflows to ubuntu 24.04 (20.04 will be deprecated soon)	2025-02-12 16:21:03 -06:00
Evan Husted	89b4389ed2	docs: compat: [ci skip] forgot to update time for FUSER	2025-02-12 16:03:26 -06:00
Evan Husted	d9ee729199	docs: compat: FUSER is now Ingame	2025-02-12 15:21:19 -06:00
Evan Husted	ba0cd13cff	misc: chore: fix warning [ci skip]	2025-02-11 22:54:24 -06:00
Evan Husted	501b199e24	UI: setting: Disable Input when Out of Focus	2025-02-11 22:12:05 -06:00
Evan Husted	8aecccadb8	misc: chore: Format AvaHostUIHandler	2025-02-11 21:23:04 -06:00
Evan Husted	e23d610f49	UI: Change Update Available button text color to white	2025-02-11 21:18:05 -06:00
Evan Husted	f6822f7358	misc: chore: add direct error code tuple to DisplayErrorAppletDialog for use when i find the list of error codes -> causes	2025-02-11 21:09:55 -06:00
Evan Husted	d3f84a1305	misc: chore: Rename UserSelectorDialog to ProfileSelectorDialog	2025-02-11 20:50:06 -06:00
Evan Husted	06d34a5992	misc: chore: optimize UserSelectorDialog closed handler	2025-02-11 20:36:11 -06:00
Evan Husted	e8e1dc6619	misc: chore: this isn't even bound to a XAML element, why was this an async void	2025-02-11 20:30:46 -06:00
Evan Husted	c5603d4c36	UI: Make about window text bigger and add a separator in the right side	2025-02-11 20:22:29 -06:00
Evan Husted	05b56730d6	docs: compat: remove title ID column from compat entries for homebrew	2025-02-11 20:22:09 -06:00
Evan Husted	43f7b000ca	misc: chore: Optimize AboutWindowViewModel resource disposal	2025-02-11 20:08:38 -06:00
Evan Husted	ad89cf39b6	UI: Change the Discord invite to link to the rules channel When next stable comes out the old one will be invalidated	2025-02-11 18:21:12 -06:00
Evan Husted	96c33a0b92	misc: chore: [ci skip] AppletMetadata: Use previously retrieved content path	2025-02-11 12:20:52 -06:00
Evan Husted	e0db55df46	UI: When starting games in fullscreen, change ExtendsContentIntoTitleBar to true.	2025-02-11 12:04:34 -06:00
Evan Husted	30fef8e96e	misc: chore: Use UpdateCommand instance for the normal Check for Updates button	2025-02-11 00:47:39 -06:00
Evan Husted	9cb5f5689b	UI: Show Update Available button in the system accent color	2025-02-11 00:21:58 -06:00
Evan Husted	a205ec374b	UI: More advanced IsVisible binding for update available button (idk why it's always showing)	2025-02-10 22:42:57 -06:00
themantim486	aab9b58542	compat: "Rustler": Playable (#649 )	2025-02-10 22:32:39 -06:00
Evan Husted	daa648dc40	UI: Correct visibility for new background update button	2025-02-10 22:25:04 -06:00
Evan Husted	1024aa8757	UI: Change the background updater notification to a persistent button on the status bar when not in a game	2025-02-10 22:13:58 -06:00
Evan Husted	13388e972a	UI: RPC: add image asset for Bluey: The Video Game	2025-02-10 20:00:59 -06:00
Evan Husted	1eb78872d8	misc: chore: annoyed I missed this, it's very obvious	2025-02-10 19:51:28 -06:00
Evan Husted	fe9fe2a10f	UI: Added option to check for updates in the background	2025-02-10 19:28:46 -06:00
Evan Husted	6ab899f621	misc: chore: [ci skip] Use explicit types & target-typed new	2025-02-10 16:44:26 -06:00
FluffyOMC	faacec9801	JIT Cache Regions + HLE SoNoSigpipe BSD socket mapping (#615 ) Instead of one big 2048MB JIT Cache that'd crash the emulator when maxed out, we now have it where we add 256MB JIT Cache regions when needed, helping reduce allocated memory where games don't use the JIT cache for it, and helping bigger games that DO need JIT cache bigger than 2048MB! ![image](https://github.com/user-attachments/assets/ff17dc48-6028-4377-8c73-746ab21ab83b) (SSBU goes past the 2048MB JIT Cache limit that would normally crash Ryujinx ^) Also I added a BSD socket that Baba is You's networking for downloading custom levels uses.	2025-02-10 15:53:44 -06:00
Evan Husted	55fdb3f6b2	headless: Default to Vulkan	2025-02-10 15:45:09 -06:00
Evan Husted	1129ab0e8c	misc: chore: Remove unused property in ApplicationData	2025-02-10 15:44:58 -06:00
Evan Husted	b6b391b2cf	misc: chore: [ci skip] Remove unused 'using' directives from solution	2025-02-10 14:34:12 -06:00
Evan Husted	f3cf03495d	misc: add the ability to ignore UI logs when using trace & debug log levels	2025-02-10 14:25:47 -06:00
Evan Husted	7bce8206d5	misc: chore: small cleanups	2025-02-10 13:59:25 -06:00
Evan Husted	efa0cc7554	UI: Show issue labels of games in the tooltip on playability status	2025-02-09 21:15:38 -06:00
Evan Husted	1c0813d09d	misc: chore: [ci skip] shorten lines in FormatterSpecBase.Format & consistently format them	2025-02-09 00:50:11 -06:00
Evan Husted	8bec09d7ff	Merge remote-tracking branch 'origin/master'	2025-02-09 00:45:54 -06:00
Evan Husted	e4b4e94b56	misc: chore: cleanup Specs.cs	2025-02-09 00:45:46 -06:00
Evan Husted	764c9e9d4e	misc: chore: unify GameSpec creation	2025-02-09 00:37:54 -06:00
Evan Husted	05e991db87	misc: chore: collapse all NSO emulator formatters into one method	2025-02-09 00:37:35 -06:00
shinyoyo	2cd876b1cb	Update Zh-CN Simplified Chinese (#642 )	2025-02-08 21:33:20 -06:00
Evan Husted	93a298523f	Dynamic Presence support for every NSO emulator	2025-02-08 16:52:07 -06:00
FluffyOMC	253cbb2810	Initial Implementation of SSBU PlayReport usage! (#638 ) Currently, this has as many game modes as I could find to implement, along with a list of all the characters in the game and their code ID.	2025-02-08 16:23:24 -06:00
Evan Husted	9c226dcc7a	misc: chore: [ci skip] rename ValueFormatter to SingleValueFormatter and some minor cleanups	2025-02-08 01:34:44 -06:00
Evan Husted	30a534edcd	misc: chore: [ci skip] generify Formatter Specs to be able to run formatters of different types at interleaving priorities	2025-02-08 01:26:23 -06:00
Evan Husted	1d88771d1b	Play Report Analyzer v4 You can now access the entire play report data in any given value formatter. The input types have been restructured and, notably, not every instance of Value has an ApplicationMetadata on it. It's now on the container type that also contains the matched values and the entire play report.	2025-02-08 00:22:34 -06:00
Evan Husted	4e8157688e	UI: See what games do/don't have an image & dynamic RPC support in the Game Info popup	2025-02-07 18:34:11 -06:00
Evan Husted	5085af0050	UI: Changed the color of "Ingame" from yellow to orange to stand out better in light mode	2025-02-07 18:28:32 -06:00
Evan Husted	2c8edaf89e	PlayReport: Add Sparse Multi Value formatters	2025-02-07 15:43:50 -06:00
Evan Husted	aa8ba8b503	Merge remote-tracking branch 'origin/master'	2025-02-06 22:56:33 -06:00
Evan Husted	a4211fec33	UI: Properly space the play time & last play date in the game info popup	2025-02-06 22:56:25 -06:00
Daenorth	54b233dd78	Updated the compat list. (#618 )	2025-02-06 04:46:23 -06:00
Evan Husted	d1da937fce	misc: chore: [ci skip] XMLdocs on new Play Report Analyzer members	2025-02-05 19:51:43 -06:00
Evan Husted	4a8f98126f	[ci skip] remove test	2025-02-05 19:45:29 -06:00
Evan Husted	e55629a908	misc: chore: [ci skip] Play Report Analyzer: Added Multi Value formatters	2025-02-05 19:42:36 -06:00
Evan Husted	c638a7daf8	misc: chore: Move Play Report analyzer into a dedicated namespace and remove the PlayReport name prefix on types	2025-02-05 19:27:44 -06:00
Piplup	5e5e180fea	PlayReportAnalyzer: Added Pokemon Scarlet and Violet (#630 ) Every base game location excluding buildings are done, DLC locations will be added at a later point	2025-02-05 18:32:27 -06:00
Hack茶ん	131fe71205	Update Korean translation (#624 )	2025-02-05 02:40:37 -06:00
Evan Husted	6af388c623	misc: chore: [ci skip] oops forgot to localize the reset button & confirmation	2025-02-05 02:01:33 -06:00
Evan Husted	45cec4e7cf	UI: In-app Configuration resetting	2025-02-05 01:42:27 -06:00
FluffyOMC	479b38f035	Add tooltips to game status (#625 )	2025-02-05 00:42:20 -06:00
Evan Husted	3ecc7819cc	UI: Fix the app list sort types using the newly changed localization keys	2025-02-04 23:47:24 -06:00
Evan Husted	4b1d94ccd8	misc: chore: [ci skip] use MultiplayerInfoConverter instance instead of constructing for every use	2025-02-04 23:36:36 -06:00
Evan Husted	4ae9f1c0d2	UI: Use Hosted Games & Player Count localization keys in list view too	2025-02-04 23:31:31 -06:00
Evan Husted	717851985e	UI: Reorganize Game Info dialog popup + localization	2025-02-04 23:28:37 -06:00
Evan Husted	bd08a111a8	UI: Show what each value is in the Game Info dialog, add game icon	2025-02-04 22:47:12 -06:00
Evan Husted	1972a47f39	UI: Game stats button on right click for Grid view users	2025-02-04 19:32:17 -06:00
Evan Husted	222ceb818b	misc: chore: Use ApplicationLibrary helpers for getting DLCs & Updates for a game	2025-02-04 18:21:49 -06:00
Evan Husted	b0fcc5bee1	misc: chore: Simplify HasCompatibilityEntry (Totally didn't realize that SelectedApplication is already an ApplicationData)	2025-02-04 18:21:24 -06:00
Evan Husted	820e8f7375	[ci skip] UI: Strip dumped file information out of the DLC name	2025-02-04 18:10:28 -06:00
Evan Husted	e8a7d5b0b7	UI: Only show DLC RomFS button under Extract Data when DLCs are available. Also convert the constructor of DlcSelectViewModel to expect a normal title id and not one already converted to the base ID.	2025-02-04 17:21:54 -06:00
Evan Husted	fafb99c702	misc: chore: [ci skip] don't even bother looking up the application; the tag present on the control is a valid title ID and can't reasonably change in between the tag being set and playability information being requested. Even if it does, worst case scenario the compat list that pops up has no results.	2025-02-04 15:57:32 -06:00
Evan Husted	df9e6e4812	UI: Added the ability to view Compat information on right click, and on clicking the status itself like the title ID button.	2025-02-04 15:51:27 -06:00
Evan Husted	566f3d079a	misc: chore: Play Report analyzer code simplification	2025-02-04 00:56:59 -06:00
Evan Husted	d7707d4176	UI: RPC: Only update presence if a value is actually different from the current presence	2025-02-03 23:12:50 -06:00
Evan Husted	7a9b62884a	misc: chore: type-specific value accessors on PlayReportValue	2025-02-03 19:56:02 -06:00
Evan Husted	de9faf183a	misc: chore: [ci skip] wrong element order	2025-02-03 19:45:05 -06:00
Evan Husted	0bf7c5dfa2	misc: chore: [ci skip] AlwaysReturn factory function to go with the AlwaysResets singleton one.	2025-02-03 19:23:47 -06:00
Evan Husted	11bc32d98e	UI: RPC: Reset Details when switching between Master Mode and Normal Mode on the title screen.	2025-02-03 19:19:17 -06:00
Evan Husted	063430ea16	misc: chore: Use .Match	2025-02-03 19:18:31 -06:00
Evan Husted	65f08caaa3	misc: chore: .Match helper method on PlayReportAnalyzer.FormattedValue.	2025-02-03 19:18:17 -06:00
Evan Husted	f225b18c05	misc: chore: XMLDocs on PlayReportAnalyzer system. - Change PlayReportValue to a basic class passed normally instead of a struct passed by reference	2025-02-03 18:54:38 -06:00
Evan Husted	d8549f687b	misc: chore: convert split ThreadStatic fields & property getter/setters into a single property with [field: ThreadStatic]	2025-02-03 17:04:11 -06:00
Evan Husted	5ab50680b4	HLE: Run Play Report event handlers in a dedicated .NET thread	2025-02-03 17:01:44 -06:00
Evan Husted	a0edc5c2b0	UI: RPC: Small change to how values are passed to hopefully detect the player pos better	2025-02-03 15:46:39 -06:00
Evan Husted	158ea7b4d6	misc: chore: logged coordinate is a decimal not a whole number	2025-02-03 15:33:12 -06:00
Evan Husted	8bc3de8303	UI: RPC: Add TOTK current world layer to RPC based on logged player y pos	2025-02-03 14:54:34 -06:00
Evan Husted	c812106611	UI: Show playability information under game version in List view	2025-02-03 13:49:56 -06:00
shinra-electric	11e4d8f970	Add the JP version of P5R to the list of Metal games (#612 )	2025-02-03 01:36:58 -06:00
Evan Husted	774edb7b29	UI: Match System Time is now an active setting which you can toggle on/off.	2025-02-02 23:46:55 -06:00
Evan Husted	55536f5d78	misc: chore: Early exit HandlePlayReport if RPC is not enabled	2025-02-02 22:14:43 -06:00
Evan Husted	b2eecd28ce	UI: RPC: Value Formatter V3 - Allows the ability to bind a single PlayReportGameSpec to multiple title IDs, like for MK8D - Allows the ability for the value formatters to tell the caller of the analyzer that they should reset the value, and also added the ability to explicitly not handle a value format.	2025-02-02 22:10:49 -06:00
Evan Husted	fe43c32e60	UI: The argument to Play Report value formatters is now a struct containing the current ApplicationMetadata & the BoxedValue that was the only argument previously. This allows for the title of Mario Kart to be localized when one of the value checkers doesn't match.	2025-02-02 20:47:42 -06:00
Evan Husted	8117e160c2	misc: chore: [ci skip] Move the play report analyzer definition into a PlayReport static class to avoid polluting the Discord integration module	2025-02-02 20:32:01 -06:00
Piplup	bf713a80d6	PlayReportAnalyzer: Added Games (#614 ) Added Super Mario Odyssey, Super Mario Odyssey (China), Super Mario 3D World + Bowser's Fury, Mario Kart 8 Deluxe and Mario Kart 8 Deluxe (China)	2025-02-02 20:29:00 -06:00
Evan Husted	b38b5a1e70	docs: compat: Saints Row IV: Playable -> Ingame Deadlock label added. Game sometimes just stops loading in loading screens. Game continues like its doing something but you'll be sitting there for minutes wondering why nothing is happening. Considering the game isn't crashing, this might be an emulator-side mutex issue. I've seen that before.	2025-02-02 16:59:06 -06:00