Move solution and projects to src

src/Ryujinx/Ui/Windows/AboutWindow.Designer.cs

@@ -0,0 +1,493 @@
+using Gtk;
+using Pango;
+using Ryujinx.Ui.Common.Configuration;
+using System.Reflection;
+
+namespace Ryujinx.Ui.Windows
+{
+    public partial class AboutWindow : Window
+    {
+        private Box            _mainBox;
+        private Box            _leftBox;
+        private Box            _logoBox;
+        private Image          _ryujinxLogo;
+        private Box            _logoTextBox;
+        private Label          _ryujinxLabel;
+        private Label          _ryujinxPhoneticLabel;
+        private EventBox       _ryujinxLink;
+        private Label          _ryujinxLinkLabel;
+        private Label          _versionLabel;
+        private Label          _disclaimerLabel;
+        private EventBox       _amiiboApiLink;
+        private Label          _amiiboApiLinkLabel;
+        private Box            _socialBox;
+        private EventBox       _patreonEventBox;
+        private Box            _patreonBox;
+        private Image          _patreonLogo;
+        private Label          _patreonLabel;
+        private EventBox       _githubEventBox;
+        private Box            _githubBox;
+        private Image          _githubLogo;
+        private Label          _githubLabel;
+        private Box            _discordBox;
+        private EventBox       _discordEventBox;
+        private Image          _discordLogo;
+        private Label          _discordLabel;
+        private EventBox       _twitterEventBox;
+        private Box            _twitterBox;
+        private Image          _twitterLogo;
+        private Label          _twitterLabel;
+        private Separator      _separator;
+        private Box            _rightBox;
+        private Label          _aboutLabel;
+        private Label          _aboutDescriptionLabel;
+        private Label          _createdByLabel;
+        private TextView       _createdByText;
+        private EventBox       _contributorsEventBox;
+        private Label          _contributorsLinkLabel;
+        private Label          _patreonNamesLabel;
+        private ScrolledWindow _patreonNamesScrolled;
+        private TextView       _patreonNamesText;
+
+        private void InitializeComponent()
+        {
+
+#pragma warning disable CS0612
+
+            //
+            // AboutWindow
+            //
+            CanFocus       = false;
+            Resizable      = false;
+            Modal          = true;
+            WindowPosition = WindowPosition.Center;
+            DefaultWidth   = 800;
+            DefaultHeight  = 450;
+            TypeHint       = Gdk.WindowTypeHint.Dialog;
+
+            //
+            // _mainBox
+            //
+            _mainBox = new Box(Orientation.Horizontal, 0);
+
+            //
+            // _leftBox
+            //
+            _leftBox = new Box(Orientation.Vertical, 0)
+            {
+                Margin      = 15,
+                MarginLeft  = 30,
+                MarginRight = 0
+            };
+
+            //
+            // _logoBox
+            //
+            _logoBox = new Box(Orientation.Horizontal, 0);
+
+            //
+            // _ryujinxLogo
+            //
+            _ryujinxLogo = new Image(new Gdk.Pixbuf(Assembly.GetAssembly(typeof(ConfigurationState)), "Ryujinx.Ui.Common.Resources.Logo_Ryujinx.png", 100, 100))
+            {
+                Margin     = 10,
+                MarginLeft = 15
+            };
+
+            //
+            // _logoTextBox
+            //
+            _logoTextBox = new Box(Orientation.Vertical, 0);
+
+            //
+            // _ryujinxLabel
+            //
+            _ryujinxLabel = new Label("Ryujinx")
+            {
+                MarginTop  = 15,
+                Justify    = Justification.Center,
+                Attributes = new AttrList()
+            };
+            _ryujinxLabel.Attributes.Insert(new Pango.AttrScale(2.7f));
+
+            //
+            // _ryujinxPhoneticLabel
+            //
+            _ryujinxPhoneticLabel = new Label("(REE-YOU-JINX)")
+            {
+                Justify = Justification.Center
+            };
+
+            //
+            // _ryujinxLink
+            //
+            _ryujinxLink = new EventBox()
+            {
+                Margin = 5
+            };
+            _ryujinxLink.ButtonPressEvent += RyujinxButton_Pressed;
+
+            //
+            // _ryujinxLinkLabel
+            //
+            _ryujinxLinkLabel = new Label("www.ryujinx.org")
+            {
+                TooltipText = "Click to open the Ryujinx website in your default browser.",
+                Justify     = Justification.Center,
+                Attributes  = new AttrList()
+            };
+            _ryujinxLinkLabel.Attributes.Insert(new Pango.AttrUnderline(Underline.Single));
+
+            //
+            // _versionLabel
+            //
+            _versionLabel = new Label(Program.Version)
+            {
+                Expand  = true,
+                Justify = Justification.Center,
+                Margin  = 5
+            };
+
+            //
+            // _disclaimerLabel
+            //
+            _disclaimerLabel = new Label("Ryujinx is not affiliated with Nintendo™,\nor any of its partners, in any way.")
+            {
+                Expand     = true,
+                Justify    = Justification.Center,
+                Margin     = 5,
+                Attributes = new AttrList()
+            };
+            _disclaimerLabel.Attributes.Insert(new Pango.AttrScale(0.8f));
+
+            //
+            // _amiiboApiLink
+            //
+            _amiiboApiLink = new EventBox()
+            {
+                Margin = 5
+            };
+            _amiiboApiLink.ButtonPressEvent += AmiiboApiButton_Pressed;
+
+            //
+            // _amiiboApiLinkLabel
+            //
+            _amiiboApiLinkLabel = new Label("AmiiboAPI (www.amiiboapi.com) is used\nin our Amiibo emulation.")
+            {
+                TooltipText = "Click to open the AmiiboAPI website in your default browser.",
+                Justify     = Justification.Center,
+                Attributes  = new AttrList()
+            };
+            _amiiboApiLinkLabel.Attributes.Insert(new Pango.AttrScale(0.9f));
+
+            //
+            // _socialBox
+            //
+            _socialBox = new Box(Orientation.Horizontal, 0)
+            {
+                Margin       = 25,
+                MarginBottom = 10
+            };
+
+            //
+            // _patreonEventBox
+            //
+            _patreonEventBox = new EventBox()
+            {
+                TooltipText = "Click to open the Ryujinx Patreon page in your default browser."
+            };
+            _patreonEventBox.ButtonPressEvent += PatreonButton_Pressed;
+
+            //
+            // _patreonBox
+            //
+            _patreonBox = new Box(Orientation.Vertical, 0);
+
+            //
+            // _patreonLogo
+            //
+            _patreonLogo = new Image(new Gdk.Pixbuf(Assembly.GetAssembly(typeof(ConfigurationState)), "Ryujinx.Ui.Common.Resources.Logo_Patreon_Light.png", 30, 30))
+            {
+                Margin = 10
+            };
+
+            //
+            // _patreonLabel
+            //
+            _patreonLabel = new Label("Patreon")
+            {
+                Justify = Justification.Center
+            };
+
+            //
+            // _githubEventBox
+            //
+            _githubEventBox = new EventBox()
+            {
+                TooltipText = "Click to open the Ryujinx GitHub page in your default browser."
+            };
+            _githubEventBox.ButtonPressEvent += GitHubButton_Pressed;
+
+            //
+            // _githubBox
+            //
+            _githubBox = new Box(Orientation.Vertical, 0);
+
+            //
+            // _githubLogo
+            //
+            _githubLogo = new Image(new Gdk.Pixbuf(Assembly.GetAssembly(typeof(ConfigurationState)), "Ryujinx.Ui.Common.Resources.Logo_GitHub_Light.png", 30, 30))
+            {
+                Margin = 10
+            };
+
+            //
+            // _githubLabel
+            //
+            _githubLabel = new Label("GitHub")
+            {
+                Justify = Justification.Center
+            };
+
+            //
+            // _discordBox
+            //
+            _discordBox = new Box(Orientation.Vertical, 0);
+
+            //
+            // _discordEventBox
+            //
+            _discordEventBox = new EventBox()
+            {
+                TooltipText = "Click to open an invite to the Ryujinx Discord server in your default browser."
+            };
+            _discordEventBox.ButtonPressEvent += DiscordButton_Pressed;
+
+            //
+            // _discordLogo
+            //
+            _discordLogo = new Image(new Gdk.Pixbuf(Assembly.GetAssembly(typeof(ConfigurationState)), "Ryujinx.Ui.Common.Resources.Logo_Discord_Light.png", 30, 30))
+            {
+                Margin = 10
+            };
+
+            //
+            // _discordLabel
+            //
+            _discordLabel = new Label("Discord")
+            {
+                Justify = Justification.Center
+            };
+
+            //
+            // _twitterEventBox
+            //
+            _twitterEventBox = new EventBox()
+            {
+                TooltipText = "Click to open the Ryujinx Twitter page in your default browser."
+            };
+            _twitterEventBox.ButtonPressEvent += TwitterButton_Pressed;
+
+            //
+            // _twitterBox
+            //
+            _twitterBox = new Box(Orientation.Vertical, 0);
+
+            //
+            // _twitterLogo
+            //
+            _twitterLogo = new Image(new Gdk.Pixbuf(Assembly.GetAssembly(typeof(ConfigurationState)), "Ryujinx.Ui.Common.Resources.Logo_Twitter_Light.png", 30, 30))
+            {
+                Margin = 10
+            };
+
+            //
+            // _twitterLabel
+            //
+            _twitterLabel = new Label("Twitter")
+            {
+                Justify = Justification.Center
+            };
+
+            //
+            // _separator
+            //
+            _separator = new Separator(Orientation.Vertical)
+            {
+                Margin = 15
+            };
+
+            //
+            // _rightBox
+            //
+            _rightBox = new Box(Orientation.Vertical, 0)
+            {
+                Margin    = 15,
+                MarginTop = 40
+            };
+
+            //
+            // _aboutLabel
+            //
+            _aboutLabel = new Label("About :")
+            {
+                Halign     = Align.Start,
+                Attributes = new AttrList()
+            };
+            _aboutLabel.Attributes.Insert(new Pango.AttrWeight(Weight.Bold));
+            _aboutLabel.Attributes.Insert(new Pango.AttrUnderline(Underline.Single));
+
+            //
+            // _aboutDescriptionLabel
+            //
+            _aboutDescriptionLabel = new Label("Ryujinx is an emulator for the Nintendo Switch™.\n" +
+                                               "Please support us on Patreon.\n" +
+                                               "Get all the latest news on our Twitter or Discord.\n" +
+                                               "Developers interested in contributing can find out more on our GitHub or Discord.")
+            {
+                Margin = 15,
+                Halign = Align.Start
+            };
+
+            //
+            // _createdByLabel
+            //
+            _createdByLabel = new Label("Maintained by :")
+            {
+                Halign     = Align.Start,
+                Attributes = new AttrList()
+            };
+            _createdByLabel.Attributes.Insert(new Pango.AttrWeight(Weight.Bold));
+            _createdByLabel.Attributes.Insert(new Pango.AttrUnderline(Underline.Single));
+
+            //
+            // _createdByText
+            //
+            _createdByText = new TextView()
+            {
+                WrapMode      = Gtk.WrapMode.Word,
+                Editable      = false,
+                CursorVisible = false,
+                Margin        = 15,
+                MarginRight   = 30
+            };
+            _createdByText.Buffer.Text = "gdkchan, Ac_K, Thog, rip in peri peri, LDj3SNuD, emmaus, Thealexbarney, Xpl0itR, GoffyDude, »jD« and more...";
+
+            //
+            // _contributorsEventBox
+            //
+            _contributorsEventBox = new EventBox();
+            _contributorsEventBox.ButtonPressEvent += ContributorsButton_Pressed;
+
+            //
+            // _contributorsLinkLabel
+            //
+            _contributorsLinkLabel = new Label("See All Contributors...")
+            {
+                TooltipText = "Click to open the Contributors page in your default browser.",
+                MarginRight = 30,
+                Halign      = Align.End,
+                Attributes  = new AttrList()
+            };
+            _contributorsLinkLabel.Attributes.Insert(new Pango.AttrUnderline(Underline.Single));
+
+            //
+            // _patreonNamesLabel
+            //
+            _patreonNamesLabel = new Label("Supported on Patreon by :")
+            {
+                Halign     = Align.Start,
+                Attributes = new AttrList()
+            };
+            _patreonNamesLabel.Attributes.Insert(new Pango.AttrWeight(Weight.Bold));
+            _patreonNamesLabel.Attributes.Insert(new Pango.AttrUnderline(Underline.Single));
+
+            //
+            // _patreonNamesScrolled
+            //
+            _patreonNamesScrolled = new ScrolledWindow()
+            {
+                Margin      = 15,
+                MarginRight = 30,
+                Expand      = true,
+                ShadowType  = ShadowType.In
+            };
+            _patreonNamesScrolled.SetPolicy(PolicyType.Never, PolicyType.Automatic);
+
+            //
+            // _patreonNamesText
+            //
+            _patreonNamesText = new TextView()
+            {
+                WrapMode = Gtk.WrapMode.Word
+            };
+            _patreonNamesText.Buffer.Text = "Loading...";
+            _patreonNamesText.SetProperty("editable", new GLib.Value(false));
+
+#pragma warning restore CS0612
+
+            ShowComponent();
+        }
+
+        private void ShowComponent()
+        {
+            _logoBox.Add(_ryujinxLogo);
+
+            _ryujinxLink.Add(_ryujinxLinkLabel);
+
+            _logoTextBox.Add(_ryujinxLabel);
+            _logoTextBox.Add(_ryujinxPhoneticLabel);
+            _logoTextBox.Add(_ryujinxLink);
+
+            _logoBox.Add(_logoTextBox);
+
+            _amiiboApiLink.Add(_amiiboApiLinkLabel);
+
+            _patreonBox.Add(_patreonLogo);
+            _patreonBox.Add(_patreonLabel);
+            _patreonEventBox.Add(_patreonBox);
+
+            _githubBox.Add(_githubLogo);
+            _githubBox.Add(_githubLabel);
+            _githubEventBox.Add(_githubBox);
+
+            _discordBox.Add(_discordLogo);
+            _discordBox.Add(_discordLabel);
+            _discordEventBox.Add(_discordBox);
+
+            _twitterBox.Add(_twitterLogo);
+            _twitterBox.Add(_twitterLabel);
+            _twitterEventBox.Add(_twitterBox);
+
+            _socialBox.Add(_patreonEventBox);
+            _socialBox.Add(_githubEventBox);
+            _socialBox.Add(_discordEventBox);
+            _socialBox.Add(_twitterEventBox);
+
+            _leftBox.Add(_logoBox);
+            _leftBox.Add(_versionLabel);
+            _leftBox.Add(_disclaimerLabel);
+            _leftBox.Add(_amiiboApiLink);
+            _leftBox.Add(_socialBox);
+
+            _contributorsEventBox.Add(_contributorsLinkLabel);
+            _patreonNamesScrolled.Add(_patreonNamesText);
+
+            _rightBox.Add(_aboutLabel);
+            _rightBox.Add(_aboutDescriptionLabel);
+            _rightBox.Add(_createdByLabel);
+            _rightBox.Add(_createdByText);
+            _rightBox.Add(_contributorsEventBox);
+            _rightBox.Add(_patreonNamesLabel);
+            _rightBox.Add(_patreonNamesScrolled);
+
+            _mainBox.Add(_leftBox);
+            _mainBox.Add(_separator);
+            _mainBox.Add(_rightBox);
+
+            Add(_mainBox);
+
+            ShowAll();
+        }
+    }
+}

src/Ryujinx/Ui/Windows/AboutWindow.cs

@@ -0,0 +1,80 @@
+using Gtk;
+using Ryujinx.Common.Utilities;
+using Ryujinx.Ui.Common.Helper;
+using System.Net.Http;
+using System.Net.NetworkInformation;
+using System.Reflection;
+using System.Threading.Tasks;
+
+namespace Ryujinx.Ui.Windows
+{
+    public partial class AboutWindow : Window
+    {
+        public AboutWindow() : base($"Ryujinx {Program.Version} - About")
+        {
+            Icon = new Gdk.Pixbuf(Assembly.GetAssembly(typeof(OpenHelper)), "Ryujinx.Ui.Common.Resources.Logo_Ryujinx.png");
+            InitializeComponent();
+
+            _ = DownloadPatronsJson();
+        }
+
+        private async Task DownloadPatronsJson()
+        {
+            if (!NetworkInterface.GetIsNetworkAvailable())
+            {
+                _patreonNamesText.Buffer.Text = "Connection Error.";
+            }
+
+            HttpClient httpClient = new HttpClient();
+
+            try
+            {
+                string patreonJsonString = await httpClient.GetStringAsync("https://patreon.ryujinx.org/");
+
+                _patreonNamesText.Buffer.Text = string.Join(", ", JsonHelper.Deserialize(patreonJsonString, CommonJsonContext.Default.StringArray));
+            }
+            catch
+            {
+                _patreonNamesText.Buffer.Text = "API Error.";
+            }
+        }
+
+        //
+        // Events
+        //
+        private void RyujinxButton_Pressed(object sender, ButtonPressEventArgs args)
+        {
+            OpenHelper.OpenUrl("https://ryujinx.org");
+        }
+
+        private void AmiiboApiButton_Pressed(object sender, ButtonPressEventArgs args)
+        {
+            OpenHelper.OpenUrl("https://amiiboapi.com");
+        }
+
+        private void PatreonButton_Pressed(object sender, ButtonPressEventArgs args)
+        {
+            OpenHelper.OpenUrl("https://www.patreon.com/ryujinx");
+        }
+
+        private void GitHubButton_Pressed(object sender, ButtonPressEventArgs args)
+        {
+            OpenHelper.OpenUrl("https://github.com/Ryujinx/Ryujinx");
+        }
+
+        private void DiscordButton_Pressed(object sender, ButtonPressEventArgs args)
+        {
+            OpenHelper.OpenUrl("https://discordapp.com/invite/N2FmfVc");
+        }
+
+        private void TwitterButton_Pressed(object sender, ButtonPressEventArgs args)
+        {
+            OpenHelper.OpenUrl("https://twitter.com/RyujinxEmu");
+        }
+
+        private void ContributorsButton_Pressed(object sender, ButtonPressEventArgs args)
+        {
+            OpenHelper.OpenUrl("https://github.com/Ryujinx/Ryujinx/graphs/contributors?type=a");
+        }
+    }
+}

src/Ryujinx/Ui/Windows/AmiiboWindow.Designer.cs

@@ -0,0 +1,194 @@
+using Gtk;
+
+namespace Ryujinx.Ui.Windows
+{
+    public partial class AmiiboWindow : Window
+    {
+        private Box          _mainBox;
+        private ButtonBox    _buttonBox;
+        private Button       _scanButton;
+        private Button       _cancelButton;
+        private CheckButton  _randomUuidCheckBox;
+        private Box          _amiiboBox;
+        private Box          _amiiboHeadBox;
+        private Box          _amiiboSeriesBox;
+        private Label        _amiiboSeriesLabel;
+        private ComboBoxText _amiiboSeriesComboBox;
+        private Box          _amiiboCharsBox;
+        private Label        _amiiboCharsLabel;
+        private ComboBoxText _amiiboCharsComboBox;
+        private CheckButton  _showAllCheckBox;
+        private Image        _amiiboImage;
+        private Label        _gameUsageLabel;
+
+        private void InitializeComponent()
+        {
+#pragma warning disable CS0612
+
+            //
+            // AmiiboWindow
+            //
+            CanFocus       = false;
+            Resizable      = false;
+            Modal          = true;
+            WindowPosition = WindowPosition.Center;
+            DefaultWidth   = 600;
+            DefaultHeight  = 470;
+            TypeHint       = Gdk.WindowTypeHint.Dialog;
+
+            //
+            // _mainBox
+            //
+            _mainBox = new Box(Orientation.Vertical, 2);
+
+            //
+            // _buttonBox
+            //
+            _buttonBox = new ButtonBox(Orientation.Horizontal)
+            {
+                Margin      = 20,
+                LayoutStyle = ButtonBoxStyle.End
+            };
+
+            //
+            // _scanButton
+            //
+            _scanButton = new Button()
+            {
+                Label           = "Scan It!",
+                CanFocus        = true,
+                ReceivesDefault = true,
+                MarginLeft      = 10
+            };
+            _scanButton.Clicked += ScanButton_Pressed;
+
+            //
+            // _randomUuidCheckBox
+            //
+            _randomUuidCheckBox = new CheckButton()
+            {
+                Label       = "Hack: Use Random Tag Uuid",
+                TooltipText = "This allows multiple scans of a single Amiibo.\n(used in The Legend of Zelda: Breath of the Wild)"
+            };
+
+            //
+            // _cancelButton
+            //
+            _cancelButton = new Button()
+            {
+                Label           = "Cancel",
+                CanFocus        = true,
+                ReceivesDefault = true,
+                MarginLeft      = 10
+            };
+            _cancelButton.Clicked += CancelButton_Pressed;
+
+            //
+            // _amiiboBox
+            //
+            _amiiboBox = new Box(Orientation.Vertical, 0);
+
+            //
+            // _amiiboHeadBox
+            //
+            _amiiboHeadBox = new Box(Orientation.Horizontal, 0)
+            {
+                Margin = 20,
+                Hexpand = true
+            };
+
+            //
+            // _amiiboSeriesBox
+            //
+            _amiiboSeriesBox = new Box(Orientation.Horizontal, 0)
+            {
+                Hexpand = true
+            };
+
+            //
+            // _amiiboSeriesLabel
+            //
+            _amiiboSeriesLabel = new Label("Amiibo Series:");
+
+            //
+            // _amiiboSeriesComboBox
+            //
+            _amiiboSeriesComboBox = new ComboBoxText();
+
+            //
+            // _amiiboCharsBox
+            //
+            _amiiboCharsBox = new Box(Orientation.Horizontal, 0)
+            {
+                Hexpand = true
+            };
+
+            //
+            // _amiiboCharsLabel
+            //
+            _amiiboCharsLabel = new Label("Character:");
+
+            //
+            // _amiiboCharsComboBox
+            //
+            _amiiboCharsComboBox = new ComboBoxText();
+
+            //
+            // _showAllCheckBox
+            //
+            _showAllCheckBox = new CheckButton()
+            {
+                Label = "Show All Amiibo"
+            };
+
+            //
+            // _amiiboImage
+            //
+            _amiiboImage = new Image()
+            {
+                HeightRequest = 350,
+                WidthRequest  = 350
+            };
+
+            //
+            // _gameUsageLabel
+            //
+            _gameUsageLabel = new Label("")
+            {
+                MarginTop = 20
+            };
+
+#pragma warning restore CS0612
+
+            ShowComponent();
+        }
+
+        private void ShowComponent()
+        {
+            _buttonBox.Add(_showAllCheckBox);
+            _buttonBox.Add(_randomUuidCheckBox);
+            _buttonBox.Add(_scanButton);
+            _buttonBox.Add(_cancelButton);
+
+            _amiiboSeriesBox.Add(_amiiboSeriesLabel);
+            _amiiboSeriesBox.Add(_amiiboSeriesComboBox);
+
+            _amiiboCharsBox.Add(_amiiboCharsLabel);
+            _amiiboCharsBox.Add(_amiiboCharsComboBox);
+
+            _amiiboHeadBox.Add(_amiiboSeriesBox);
+            _amiiboHeadBox.Add(_amiiboCharsBox);
+
+            _amiiboBox.PackStart(_amiiboHeadBox, true, true, 0);
+            _amiiboBox.PackEnd(_gameUsageLabel, false, false, 0);
+            _amiiboBox.PackEnd(_amiiboImage, false, false, 0);
+
+            _mainBox.Add(_amiiboBox);
+            _mainBox.PackEnd(_buttonBox, false, false, 0);
+
+            Add(_mainBox);
+
+            ShowAll();
+        }
+    }
+}

src/Ryujinx/Ui/Windows/AmiiboWindow.cs

@@ -0,0 +1,387 @@
+using Gtk;
+using Ryujinx.Common;
+using Ryujinx.Common.Configuration;
+using Ryujinx.Common.Logging;
+using Ryujinx.Common.Utilities;
+using Ryujinx.Ui.Common.Configuration;
+using Ryujinx.Ui.Common.Models.Amiibo;
+using Ryujinx.Ui.Widgets;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Net.Http;
+using System.Reflection;
+using System.Text;
+using System.Threading.Tasks;
+using AmiiboApi = Ryujinx.Ui.Common.Models.Amiibo.AmiiboApi;
+using AmiiboJsonSerializerContext = Ryujinx.Ui.Common.Models.Amiibo.AmiiboJsonSerializerContext;
+
+namespace Ryujinx.Ui.Windows
+{
+    public partial class AmiiboWindow : Window
+    {
+        private const string DEFAULT_JSON = "{ \"amiibo\": [] }";
+
+        public string AmiiboId { get; private set; }
+
+        public int    DeviceId                 { get; set; }
+        public string TitleId                  { get; set; }
+        public string LastScannedAmiiboId      { get; set; }
+        public bool   LastScannedAmiiboShowAll { get; set; }
+
+        public ResponseType Response { get; private set; }
+
+        public bool UseRandomUuid
+        {
+            get
+            {
+                return _randomUuidCheckBox.Active;
+            }
+        }
+
+        private readonly HttpClient _httpClient;
+        private readonly string     _amiiboJsonPath;
+
+        private readonly byte[] _amiiboLogoBytes;
+
+        private List<AmiiboApi> _amiiboList;
+
+        private static readonly AmiiboJsonSerializerContext SerializerContext = new(JsonHelper.GetDefaultSerializerOptions());
+
+        public AmiiboWindow() : base($"Ryujinx {Program.Version} - Amiibo")
+        {
+            Icon = new Gdk.Pixbuf(Assembly.GetAssembly(typeof(ConfigurationState)), "Ryujinx.Ui.Common.Resources.Logo_Ryujinx.png");
+
+            InitializeComponent();
+
+            _httpClient = new HttpClient()
+            {
+                Timeout = TimeSpan.FromSeconds(30)
+            };
+
+            Directory.CreateDirectory(System.IO.Path.Join(AppDataManager.BaseDirPath, "system", "amiibo"));
+
+            _amiiboJsonPath = System.IO.Path.Join(AppDataManager.BaseDirPath, "system", "amiibo", "Amiibo.json");
+            _amiiboList     = new List<AmiiboApi>();
+
+            _amiiboLogoBytes    = EmbeddedResources.Read("Ryujinx.Ui.Common/Resources/Logo_Amiibo.png");
+            _amiiboImage.Pixbuf = new Gdk.Pixbuf(_amiiboLogoBytes);
+
+            _scanButton.Sensitive         = false;
+            _randomUuidCheckBox.Sensitive = false;
+
+            _ = LoadContentAsync();
+        }
+
+        private async Task LoadContentAsync()
+        {
+            string amiiboJsonString = DEFAULT_JSON;
+
+            if (File.Exists(_amiiboJsonPath))
+            {
+                amiiboJsonString = await File.ReadAllTextAsync(_amiiboJsonPath);
+
+                if (await NeedsUpdate(JsonHelper.Deserialize(amiiboJsonString, SerializerContext.AmiiboJson).LastUpdated))
+                {
+                    amiiboJsonString = await DownloadAmiiboJson();
+                }
+            }
+            else
+            {
+                try
+                {
+                    amiiboJsonString = await DownloadAmiiboJson();
+                }
+                catch (Exception ex)
+                {
+                    Logger.Error?.Print(LogClass.Application, $"Failed to download amiibo data: {ex}");
+
+                    ShowInfoDialog();
+
+                    Close();
+                }
+            }
+
+            _amiiboList = JsonHelper.Deserialize(amiiboJsonString, SerializerContext.AmiiboJson).Amiibo;
+            _amiiboList = _amiiboList.OrderBy(amiibo => amiibo.AmiiboSeries).ToList();
+
+            if (LastScannedAmiiboShowAll)
+            {
+                _showAllCheckBox.Click();
+            }
+
+            ParseAmiiboData();
+
+            _showAllCheckBox.Clicked += ShowAllCheckBox_Clicked;
+        }
+
+        private void ParseAmiiboData()
+        {
+            List<string> comboxItemList = new List<string>();
+
+            for (int i = 0; i < _amiiboList.Count; i++)
+            {
+                if (!comboxItemList.Contains(_amiiboList[i].AmiiboSeries))
+                {
+                    if (!_showAllCheckBox.Active)
+                    {
+                        foreach (var game in _amiiboList[i].GamesSwitch)
+                        {
+                            if (game != null)
+                            {
+                                if (game.GameId.Contains(TitleId))
+                                {
+                                    comboxItemList.Add(_amiiboList[i].AmiiboSeries);
+                                    _amiiboSeriesComboBox.Append(_amiiboList[i].AmiiboSeries, _amiiboList[i].AmiiboSeries);
+
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                    else
+                    {
+                        comboxItemList.Add(_amiiboList[i].AmiiboSeries);
+                        _amiiboSeriesComboBox.Append(_amiiboList[i].AmiiboSeries, _amiiboList[i].AmiiboSeries);
+                    }
+                }
+            }
+
+            _amiiboSeriesComboBox.Changed += SeriesComboBox_Changed;
+            _amiiboCharsComboBox.Changed  += CharacterComboBox_Changed;
+
+            if (LastScannedAmiiboId != "")
+            {
+                SelectLastScannedAmiibo();
+            }
+            else
+            {
+                _amiiboSeriesComboBox.Active = 0;
+            }
+        }
+
+        private void SelectLastScannedAmiibo()
+        {
+            bool isSet = _amiiboSeriesComboBox.SetActiveId(_amiiboList.FirstOrDefault(amiibo => amiibo.Head + amiibo.Tail == LastScannedAmiiboId).AmiiboSeries);
+            isSet = _amiiboCharsComboBox.SetActiveId(LastScannedAmiiboId);
+
+            if (isSet == false)
+            {
+                _amiiboSeriesComboBox.Active = 0;
+            }
+        }
+
+        private async Task<bool> NeedsUpdate(DateTime oldLastModified)
+        {
+            try
+            {
+                HttpResponseMessage response = await _httpClient.SendAsync(new HttpRequestMessage(HttpMethod.Head, "https://amiibo.ryujinx.org/"));
+
+                if (response.IsSuccessStatusCode)
+                {
+                    return response.Content.Headers.LastModified != oldLastModified;
+                }
+
+                return false;
+            }
+            catch (Exception ex)
+            {
+                Logger.Error?.Print(LogClass.Application, $"Failed to check for amiibo updates: {ex}");
+
+                ShowInfoDialog();
+
+                return false;
+            }
+        }
+
+        private async Task<string> DownloadAmiiboJson()
+        {
+            HttpResponseMessage response = await _httpClient.GetAsync("https://amiibo.ryujinx.org/");
+
+            if (response.IsSuccessStatusCode)
+            {
+                string amiiboJsonString = await response.Content.ReadAsStringAsync();
+
+                using (FileStream dlcJsonStream = File.Create(_amiiboJsonPath, 4096, FileOptions.WriteThrough))
+                {
+                    dlcJsonStream.Write(Encoding.UTF8.GetBytes(amiiboJsonString));
+                }
+
+                return amiiboJsonString;
+            }
+            else
+            {
+                Logger.Error?.Print(LogClass.Application, $"Failed to download amiibo data. Response status code: {response.StatusCode}");
+
+                GtkDialog.CreateInfoDialog($"Amiibo API", "An error occured while fetching information from the API.");
+
+                Close();
+            }
+
+            return DEFAULT_JSON;
+        }
+
+        private async Task UpdateAmiiboPreview(string imageUrl)
+        {
+            HttpResponseMessage response = await _httpClient.GetAsync(imageUrl);
+
+            if (response.IsSuccessStatusCode)
+            {
+                byte[]     amiiboPreviewBytes = await response.Content.ReadAsByteArrayAsync();
+                Gdk.Pixbuf amiiboPreview      = new Gdk.Pixbuf(amiiboPreviewBytes);
+
+                float ratio = Math.Min((float)_amiiboImage.AllocatedWidth  / amiiboPreview.Width,
+                                       (float)_amiiboImage.AllocatedHeight / amiiboPreview.Height);
+
+                int resizeHeight = (int)(amiiboPreview.Height * ratio);
+                int resizeWidth  = (int)(amiiboPreview.Width  * ratio);
+
+                _amiiboImage.Pixbuf = amiiboPreview.ScaleSimple(resizeWidth, resizeHeight, Gdk.InterpType.Bilinear);
+            }
+            else
+            {
+                Logger.Error?.Print(LogClass.Application, $"Failed to get amiibo preview. Response status code: {response.StatusCode}");
+            }
+        }
+
+        private void ShowInfoDialog()
+        {
+            GtkDialog.CreateInfoDialog($"Amiibo API", "Unable to connect to Amiibo API server. The service may be down or you may need to verify your internet connection is online.");
+        }
+
+        //
+        // Events
+        //
+        private void SeriesComboBox_Changed(object sender, EventArgs args)
+        {
+            _amiiboCharsComboBox.Changed -= CharacterComboBox_Changed;
+
+            _amiiboCharsComboBox.RemoveAll();
+
+            List<AmiiboApi> amiiboSortedList = _amiiboList.Where(amiibo => amiibo.AmiiboSeries == _amiiboSeriesComboBox.ActiveId).OrderBy(amiibo => amiibo.Name).ToList();
+
+            List<string> comboxItemList = new List<string>();
+
+            for (int i = 0; i < amiiboSortedList.Count; i++)
+            {
+                if (!comboxItemList.Contains(amiiboSortedList[i].Head + amiiboSortedList[i].Tail))
+                {
+                    if (!_showAllCheckBox.Active)
+                    {
+                        foreach (var game in amiiboSortedList[i].GamesSwitch)
+                        {
+                            if (game != null)
+                            {
+                                if (game.GameId.Contains(TitleId))
+                                {
+                                    comboxItemList.Add(amiiboSortedList[i].Head + amiiboSortedList[i].Tail);
+                                    _amiiboCharsComboBox.Append(amiiboSortedList[i].Head + amiiboSortedList[i].Tail, amiiboSortedList[i].Name);
+
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                    else
+                    {
+                        comboxItemList.Add(amiiboSortedList[i].Head + amiiboSortedList[i].Tail);
+                        _amiiboCharsComboBox.Append(amiiboSortedList[i].Head + amiiboSortedList[i].Tail, amiiboSortedList[i].Name);
+                    }
+                }
+            }
+
+            _amiiboCharsComboBox.Changed += CharacterComboBox_Changed;
+
+            _amiiboCharsComboBox.Active = 0;
+
+            _scanButton.Sensitive         = true;
+            _randomUuidCheckBox.Sensitive = true;
+        }
+
+        private void CharacterComboBox_Changed(object sender, EventArgs args)
+        {
+            AmiiboId = _amiiboCharsComboBox.ActiveId;
+
+            _amiiboImage.Pixbuf = new Gdk.Pixbuf(_amiiboLogoBytes);
+
+            string imageUrl = _amiiboList.FirstOrDefault(amiibo => amiibo.Head + amiibo.Tail == _amiiboCharsComboBox.ActiveId).Image;
+
+            var usageStringBuilder = new StringBuilder();
+
+            for (int i = 0; i < _amiiboList.Count; i++)
+            {
+                if (_amiiboList[i].Head + _amiiboList[i].Tail == _amiiboCharsComboBox.ActiveId)
+                {
+                    bool writable = false;
+
+                    foreach (var item in _amiiboList[i].GamesSwitch)
+                    {
+                        if (item.GameId.Contains(TitleId))
+                        {
+                            foreach (AmiiboApiUsage usageItem in item.AmiiboUsage)
+                            {
+                                usageStringBuilder.Append(Environment.NewLine);
+                                usageStringBuilder.Append($"- {usageItem.Usage.Replace("/", Environment.NewLine + "-")}");
+
+                                writable = usageItem.Write;
+                            }
+                        }
+                    }
+
+                    if (usageStringBuilder.Length == 0)
+                    {
+                        usageStringBuilder.Append("Unknown.");
+                    }
+
+                    _gameUsageLabel.Text = $"Usage{(writable ? " (Writable)" : "")} : {usageStringBuilder}";
+                }
+            }
+
+            _ = UpdateAmiiboPreview(imageUrl);
+        }
+
+        private void ShowAllCheckBox_Clicked(object sender, EventArgs e)
+        {
+            _amiiboImage.Pixbuf = new Gdk.Pixbuf(_amiiboLogoBytes);
+
+            _amiiboSeriesComboBox.Changed -= SeriesComboBox_Changed;
+            _amiiboCharsComboBox.Changed  -= CharacterComboBox_Changed;
+
+            _amiiboSeriesComboBox.RemoveAll();
+            _amiiboCharsComboBox.RemoveAll();
+
+            _scanButton.Sensitive         = false;
+            _randomUuidCheckBox.Sensitive = false;
+
+            new Task(() => ParseAmiiboData()).Start();
+        }
+
+        private void ScanButton_Pressed(object sender, EventArgs args)
+        {
+            LastScannedAmiiboShowAll = _showAllCheckBox.Active;
+
+            Response = ResponseType.Ok;
+
+            Close();
+        }
+
+        private void CancelButton_Pressed(object sender, EventArgs args)
+        {
+            AmiiboId                 = "";
+            LastScannedAmiiboId      = "";
+            LastScannedAmiiboShowAll = false;
+
+            Response = ResponseType.Cancel;
+
+            Close();
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            _httpClient.Dispose();
+
+            base.Dispose(disposing);
+        }
+    }
+}

src/Ryujinx/Ui/Windows/AvatarWindow.cs

@@ -0,0 +1,294 @@
+using Gtk;
+using LibHac.Common;
+using LibHac.Fs;
+using LibHac.Fs.Fsa;
+using LibHac.FsSystem;
+using LibHac.Ncm;
+using LibHac.Tools.FsSystem;
+using LibHac.Tools.FsSystem.NcaUtils;
+using Ryujinx.Common.Memory;
+using Ryujinx.HLE.FileSystem;
+using Ryujinx.Ui.Common.Configuration;
+using SixLabors.ImageSharp;
+using SixLabors.ImageSharp.Formats.Png;
+using SixLabors.ImageSharp.PixelFormats;
+using SixLabors.ImageSharp.Processing;
+using System;
+using System.Buffers.Binary;
+using System.Collections.Generic;
+using System.IO;
+using System.Reflection;
+
+using Image = SixLabors.ImageSharp.Image;
+
+namespace Ryujinx.Ui.Windows
+{
+    public class AvatarWindow : Window
+    {
+        public byte[] SelectedProfileImage;
+        public bool   NewUser;
+
+        private static Dictionary<string, byte[]> _avatarDict = new Dictionary<string, byte[]>();
+
+        private ListStore _listStore;
+        private IconView  _iconView;
+        private Button    _setBackgroungColorButton;
+        private Gdk.RGBA  _backgroundColor;
+
+        public AvatarWindow() : base($"Ryujinx {Program.Version} - Manage Accounts - Avatar")
+        {
+            Icon = new Gdk.Pixbuf(Assembly.GetAssembly(typeof(ConfigurationState)), "Ryujinx.Ui.Common.Resources.Logo_Ryujinx.png");
+
+            CanFocus  = false;
+            Resizable = false;
+            Modal     = true;
+            TypeHint  = Gdk.WindowTypeHint.Dialog;
+
+            SetDefaultSize(740, 400);
+            SetPosition(WindowPosition.Center);
+
+            Box vbox = new(Orientation.Vertical, 0);
+            Add(vbox);
+
+            ScrolledWindow scrolledWindow = new ScrolledWindow
+            {
+                ShadowType = ShadowType.EtchedIn
+            };
+            scrolledWindow.SetPolicy(PolicyType.Automatic, PolicyType.Automatic);
+
+            Box hbox = new(Orientation.Horizontal, 0);
+
+            Button chooseButton = new Button()
+            {
+                Label           = "Choose",
+                CanFocus        = true,
+                ReceivesDefault = true
+            };
+            chooseButton.Clicked += ChooseButton_Pressed;
+
+            _setBackgroungColorButton = new Button()
+            {
+                Label    = "Set Background Color",
+                CanFocus = true
+            };
+            _setBackgroungColorButton.Clicked += SetBackgroungColorButton_Pressed;
+
+            _backgroundColor.Red   = 1;
+            _backgroundColor.Green = 1;
+            _backgroundColor.Blue  = 1;
+            _backgroundColor.Alpha = 1;
+
+            Button closeButton = new Button()
+            {
+                Label           = "Close",
+                CanFocus        = true
+            };
+            closeButton.Clicked += CloseButton_Pressed;
+
+            vbox.PackStart(scrolledWindow,            true,  true,  0);
+            hbox.PackStart(chooseButton,              true,  true,  0);
+            hbox.PackStart(_setBackgroungColorButton, true,  true,  0);
+            hbox.PackStart(closeButton,               true,  true,  0);
+            vbox.PackStart(hbox,                      false, false, 0);
+
+            _listStore = new ListStore(typeof(string), typeof(Gdk.Pixbuf));
+            _listStore.SetSortColumnId(0, SortType.Ascending);
+
+            _iconView              = new IconView(_listStore);
+            _iconView.ItemWidth    = 64;
+            _iconView.ItemPadding  = 10;
+            _iconView.PixbufColumn = 1;
+
+            _iconView.SelectionChanged += IconView_SelectionChanged;
+
+            scrolledWindow.Add(_iconView);
+
+            _iconView.GrabFocus();
+
+            ProcessAvatars();
+
+            ShowAll();
+        }
+
+        public static void PreloadAvatars(ContentManager contentManager, VirtualFileSystem virtualFileSystem)
+        {
+            if (_avatarDict.Count > 0)
+            {
+                return;
+            }
+
+            string contentPath = contentManager.GetInstalledContentPath(0x010000000000080A, StorageId.BuiltInSystem, NcaContentType.Data);
+            string avatarPath  = virtualFileSystem.SwitchPathToSystemPath(contentPath);
+
+            if (!string.IsNullOrWhiteSpace(avatarPath))
+            {
+                using (IStorage ncaFileStream = new LocalStorage(avatarPath, FileAccess.Read, FileMode.Open))
+                {
+                    Nca         nca   = new Nca(virtualFileSystem.KeySet, ncaFileStream);
+                    IFileSystem romfs = nca.OpenFileSystem(NcaSectionType.Data, IntegrityCheckLevel.ErrorOnInvalid);
+
+                    foreach (var item in romfs.EnumerateEntries())
+                    {
+                        // TODO: Parse DatabaseInfo.bin and table.bin files for more accuracy.
+
+                        if (item.Type == DirectoryEntryType.File && item.FullPath.Contains("chara") && item.FullPath.Contains("szs"))
+                        {
+                            using var file = new UniqueRef<IFile>();
+
+                            romfs.OpenFile(ref file.Ref, ("/" + item.FullPath).ToU8Span(), OpenMode.Read).ThrowIfFailure();
+
+                            using (MemoryStream stream    = MemoryStreamManager.Shared.GetStream())
+                            using (MemoryStream streamPng = MemoryStreamManager.Shared.GetStream())
+                            {
+                                file.Get.AsStream().CopyTo(stream);
+
+                                stream.Position = 0;
+
+                                Image avatarImage = Image.LoadPixelData<Rgba32>(DecompressYaz0(stream), 256, 256);
+
+                                avatarImage.SaveAsPng(streamPng);
+
+                                _avatarDict.Add(item.FullPath, streamPng.ToArray());
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        private void ProcessAvatars()
+        {
+            _listStore.Clear();
+
+            foreach (var avatar in _avatarDict)
+            {
+                _listStore.AppendValues(avatar.Key, new Gdk.Pixbuf(ProcessImage(avatar.Value), 96, 96));
+            }
+
+            _iconView.SelectPath(new TreePath(new int[] { 0 }));
+        }
+
+        private byte[] ProcessImage(byte[] data)
+        {
+            using (MemoryStream streamJpg = MemoryStreamManager.Shared.GetStream())
+            {
+                Image avatarImage = Image.Load(data, new PngDecoder());
+
+                avatarImage.Mutate(x => x.BackgroundColor(new Rgba32((byte)(_backgroundColor.Red   * 255),
+                                                                     (byte)(_backgroundColor.Green * 255),
+                                                                     (byte)(_backgroundColor.Blue  * 255),
+                                                                     (byte)(_backgroundColor.Alpha * 255))));
+                avatarImage.SaveAsJpeg(streamJpg);
+
+                return streamJpg.ToArray();
+            }
+        }
+
+        private void CloseButton_Pressed(object sender, EventArgs e)
+        {
+            SelectedProfileImage = null;
+
+            Close();
+        }
+
+        private void IconView_SelectionChanged(object sender, EventArgs e)
+        {
+            if (_iconView.SelectedItems.Length > 0)
+            {
+                _listStore.GetIter(out TreeIter iter, _iconView.SelectedItems[0]);
+
+                SelectedProfileImage = ProcessImage(_avatarDict[(string)_listStore.GetValue(iter, 0)]);
+            }
+        }
+
+        private void SetBackgroungColorButton_Pressed(object sender, EventArgs e)
+        {
+            using (ColorChooserDialog colorChooserDialog = new ColorChooserDialog("Set Background Color", this))
+            {
+                colorChooserDialog.UseAlpha = false;
+                colorChooserDialog.Rgba     = _backgroundColor;
+                
+                if (colorChooserDialog.Run() == (int)ResponseType.Ok)
+                {
+                    _backgroundColor = colorChooserDialog.Rgba;
+
+                    ProcessAvatars();
+                }
+
+                colorChooserDialog.Hide();
+            }
+        }
+
+        private void ChooseButton_Pressed(object sender, EventArgs e)
+        {
+            Close();
+        }
+
+        private static byte[] DecompressYaz0(Stream stream)
+        {
+            using (BinaryReader reader = new BinaryReader(stream))
+            {
+                reader.ReadInt32(); // Magic
+                
+                uint decodedLength = BinaryPrimitives.ReverseEndianness(reader.ReadUInt32());
+
+                reader.ReadInt64(); // Padding
+
+                byte[] input = new byte[stream.Length - stream.Position];
+                stream.Read(input, 0, input.Length);
+
+                long inputOffset = 0;
+
+                byte[] output       = new byte[decodedLength];
+                long   outputOffset = 0;
+
+                ushort mask   = 0;
+                byte   header = 0;
+
+                while (outputOffset < decodedLength)
+                {
+                    if ((mask >>= 1) == 0)
+                    {
+                        header = input[inputOffset++];
+                        mask   = 0x80;
+                    }
+
+                    if ((header & mask) > 0)
+                    {
+                        if (outputOffset == output.Length)
+                        {
+                            break;
+                        }
+
+                        output[outputOffset++] = input[inputOffset++];
+                    }
+                    else
+                    {
+                        byte byte1 = input[inputOffset++];
+                        byte byte2 = input[inputOffset++];
+
+                        int dist     = ((byte1 & 0xF) << 8) | byte2;
+                        int position = (int)outputOffset - (dist + 1);
+
+                        int length = byte1 >> 4;
+                        if (length == 0)
+                        {
+                            length = input[inputOffset++] + 0x12;
+                        }
+                        else
+                        {
+                            length += 2;
+                        }
+
+                        while (length-- > 0)
+                        {
+                            output[outputOffset++] = output[position++];
+                        }
+                    }
+                }
+
+                return output;
+            }
+        }
+    }
+}

src/Ryujinx/Ui/Windows/CheatWindow.cs

@@ -0,0 +1,154 @@
+using Gtk;
+using Ryujinx.HLE.FileSystem;
+using Ryujinx.HLE.HOS;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+
+using GUI = Gtk.Builder.ObjectAttribute;
+
+namespace Ryujinx.Ui.Windows
+{
+    public class CheatWindow : Window
+    {
+        private readonly string _enabledCheatsPath;
+        private readonly bool _noCheatsFound;
+
+#pragma warning disable CS0649, IDE0044
+        [GUI] Label    _baseTitleInfoLabel;
+        [GUI] TreeView _cheatTreeView;
+        [GUI] Button   _saveButton;
+#pragma warning restore CS0649, IDE0044
+
+        public CheatWindow(VirtualFileSystem virtualFileSystem, ulong titleId, string titleName) : this(new Builder("Ryujinx.Ui.Windows.CheatWindow.glade"), virtualFileSystem, titleId, titleName) { }
+
+        private CheatWindow(Builder builder, VirtualFileSystem virtualFileSystem, ulong titleId, string titleName) : base(builder.GetRawOwnedObject("_cheatWindow"))
+        {
+            builder.Autoconnect(this);
+            _baseTitleInfoLabel.Text = $"Cheats Available for {titleName} [{titleId:X16}]";
+
+            string modsBasePath  = virtualFileSystem.ModLoader.GetModsBasePath();
+            string titleModsPath = virtualFileSystem.ModLoader.GetTitleDir(modsBasePath, titleId.ToString("X16"));
+
+            _enabledCheatsPath = System.IO.Path.Combine(titleModsPath, "cheats", "enabled.txt");
+
+            _cheatTreeView.Model = new TreeStore(typeof(bool), typeof(string), typeof(string), typeof(string));
+
+            CellRendererToggle enableToggle = new CellRendererToggle();
+            enableToggle.Toggled += (sender, args) =>
+            {
+                _cheatTreeView.Model.GetIter(out TreeIter treeIter, new TreePath(args.Path));
+                bool newValue = !(bool)_cheatTreeView.Model.GetValue(treeIter, 0);
+                _cheatTreeView.Model.SetValue(treeIter, 0, newValue);
+
+                if (_cheatTreeView.Model.IterChildren(out TreeIter childIter, treeIter))
+                {
+                    do
+                    {
+                        _cheatTreeView.Model.SetValue(childIter, 0, newValue);
+                    }
+                    while (_cheatTreeView.Model.IterNext(ref childIter));
+                }
+            };
+
+            _cheatTreeView.AppendColumn("Enabled", enableToggle, "active", 0);
+            _cheatTreeView.AppendColumn("Name", new CellRendererText(), "text", 1);
+            _cheatTreeView.AppendColumn("Path", new CellRendererText(), "text", 2);
+
+            var buildIdColumn = _cheatTreeView.AppendColumn("Build Id", new CellRendererText(), "text", 3);
+            buildIdColumn.Visible = false;
+
+            string[] enabled = { };
+
+            if (File.Exists(_enabledCheatsPath))
+            {
+                enabled = File.ReadAllLines(_enabledCheatsPath);
+            }
+
+            int cheatAdded = 0;
+
+            var mods = new ModLoader.ModCache();
+
+            ModLoader.QueryContentsDir(mods, new DirectoryInfo(System.IO.Path.Combine(modsBasePath, "contents")), titleId);
+
+            string currentCheatFile = string.Empty;
+            string buildId = string.Empty;
+            TreeIter parentIter = default;
+
+            foreach (var cheat in mods.Cheats)
+            {
+                if (cheat.Path.FullName != currentCheatFile)
+                {
+                    currentCheatFile = cheat.Path.FullName;
+                    string parentPath = currentCheatFile.Replace(titleModsPath, "");
+
+                    buildId = System.IO.Path.GetFileNameWithoutExtension(currentCheatFile).ToUpper();
+                    parentIter = ((TreeStore)_cheatTreeView.Model).AppendValues(false, buildId, parentPath, "");
+                }
+
+                string cleanName = cheat.Name.Substring(1, cheat.Name.Length - 8);
+                ((TreeStore)_cheatTreeView.Model).AppendValues(parentIter, enabled.Contains($"{buildId}-{cheat.Name}"), cleanName, "", buildId);
+
+                cheatAdded++;
+            }
+
+            if (cheatAdded == 0)
+            {
+                ((TreeStore)_cheatTreeView.Model).AppendValues(false, "No Cheats Found", "", "");
+                _cheatTreeView.GetColumn(0).Visible = false;
+
+                _noCheatsFound = true;
+
+                _saveButton.Visible = false;
+            }
+
+            _cheatTreeView.ExpandAll();
+        }
+
+        private void SaveButton_Clicked(object sender, EventArgs args)
+        {
+            if (_noCheatsFound)
+            {
+                return;
+            }
+
+            List<string> enabledCheats = new List<string>();
+
+            if (_cheatTreeView.Model.GetIterFirst(out TreeIter parentIter))
+            {
+                do
+                {
+                    if (_cheatTreeView.Model.IterChildren(out TreeIter childIter, parentIter))
+                    {
+                        do
+                        {
+                            var enabled = (bool)_cheatTreeView.Model.GetValue(childIter, 0);
+
+                            if (enabled)
+                            {
+                                var name = _cheatTreeView.Model.GetValue(childIter, 1).ToString();
+                                var buildId = _cheatTreeView.Model.GetValue(childIter, 3).ToString();
+
+                                enabledCheats.Add($"{buildId}-<{name} Cheat>");
+                            }
+                        }
+                        while (_cheatTreeView.Model.IterNext(ref childIter));
+                    }
+                }
+                while (_cheatTreeView.Model.IterNext(ref parentIter));
+            }
+
+            Directory.CreateDirectory(System.IO.Path.GetDirectoryName(_enabledCheatsPath));
+
+            File.WriteAllLines(_enabledCheatsPath, enabledCheats);
+
+            Dispose();
+        }
+
+        private void CancelButton_Clicked(object sender, EventArgs args)
+        {
+            Dispose();
+        }
+    }
+}

src/Ryujinx/Ui/Windows/CheatWindow.glade

@@ -0,0 +1,135 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Generated with glade 3.21.0 -->
+<interface>
+  <requires lib="gtk+" version="3.20"/>
+  <object class="GtkWindow" id="_cheatWindow">
+    <property name="can_focus">False</property>
+    <property name="title" translatable="yes">Ryujinx - Cheat Manager</property>
+    <property name="default_width">440</property>
+    <property name="default_height">550</property>
+    <child>
+      <object class="GtkBox" id="MainBox">
+        <property name="visible">True</property>
+        <property name="can_focus">False</property>
+        <property name="orientation">vertical</property>
+        <child>
+          <object class="GtkBox" id="CheatBox">
+            <property name="visible">True</property>
+            <property name="can_focus">False</property>
+            <property name="orientation">vertical</property>
+            <child>
+              <object class="GtkLabel" id="_baseTitleInfoLabel">
+                <property name="visible">True</property>
+                <property name="can_focus">False</property>
+                <property name="margin_top">10</property>
+                <property name="margin_bottom">10</property>
+                <property name="label" translatable="yes">Available Cheats</property>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">True</property>
+                <property name="position">0</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkScrolledWindow">
+                <property name="visible">True</property>
+                <property name="can_focus">True</property>
+                <property name="margin_left">10</property>
+                <property name="margin_right">10</property>
+                <property name="shadow_type">in</property>
+                <child>
+                  <object class="GtkViewport">
+                    <property name="visible">True</property>
+                    <property name="can_focus">False</property>
+                    <child>
+                      <object class="GtkTreeView" id="_cheatTreeView">
+                        <property name="visible">True</property>
+                        <property name="can_focus">True</property>
+                        <child internal-child="selection">
+                          <object class="GtkTreeSelection"/>
+                        </child>
+                      </object>
+                    </child>
+                  </object>
+                </child>
+              </object>
+              <packing>
+                <property name="expand">True</property>
+                <property name="fill">True</property>
+                <property name="position">1</property>
+              </packing>
+            </child>
+          </object>
+          <packing>
+            <property name="expand">True</property>
+            <property name="fill">True</property>
+            <property name="position">0</property>
+          </packing>
+        </child>
+        <child>
+          <object class="GtkBox">
+            <property name="visible">True</property>
+            <property name="can_focus">False</property>
+            <child>
+              <object class="GtkButtonBox">
+                <property name="visible">True</property>
+                <property name="can_focus">False</property>
+                <property name="margin_top">10</property>
+                <property name="margin_bottom">10</property>
+                <property name="layout_style">end</property>
+                <child>
+                  <object class="GtkButton" id="_saveButton">
+                    <property name="label" translatable="yes">Save</property>
+                    <property name="visible">True</property>
+                    <property name="can_focus">True</property>
+                    <property name="receives_default">True</property>
+                    <property name="margin_right">10</property>
+                    <property name="margin_top">2</property>
+                    <property name="margin_bottom">2</property>
+                    <signal name="clicked" handler="SaveButton_Clicked" swapped="no"/>
+                  </object>
+                  <packing>
+                    <property name="expand">True</property>
+                    <property name="fill">True</property>
+                    <property name="position">0</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkButton" id="_cancelButton">
+                    <property name="label" translatable="yes">Cancel</property>
+                    <property name="visible">True</property>
+                    <property name="can_focus">True</property>
+                    <property name="receives_default">True</property>
+                    <property name="margin_right">10</property>
+                    <property name="margin_top">2</property>
+                    <property name="margin_bottom">2</property>
+                    <signal name="clicked" handler="CancelButton_Clicked" swapped="no"/>
+                  </object>
+                  <packing>
+                    <property name="expand">True</property>
+                    <property name="fill">True</property>
+                    <property name="position">1</property>
+                  </packing>
+                </child>
+              </object>
+              <packing>
+                <property name="expand">True</property>
+                <property name="fill">True</property>
+                <property name="position">1</property>
+              </packing>
+            </child>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="fill">True</property>
+            <property name="position">1</property>
+          </packing>
+        </child>
+      </object>
+    </child>
+    <child type="titlebar">
+      <placeholder/>
+    </child>
+  </object>
+</interface>

src/Ryujinx/Ui/Windows/DlcWindow.cs

@@ -0,0 +1,273 @@
+using Gtk;
+using LibHac.Common;
+using LibHac.Fs;
+using LibHac.Fs.Fsa;
+using LibHac.FsSystem;
+using LibHac.Tools.Fs;
+using LibHac.Tools.FsSystem;
+using LibHac.Tools.FsSystem.NcaUtils;
+using Ryujinx.Common.Configuration;
+using Ryujinx.Common.Utilities;
+using Ryujinx.HLE.FileSystem;
+using Ryujinx.Ui.Widgets;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using GUI = Gtk.Builder.ObjectAttribute;
+
+namespace Ryujinx.Ui.Windows
+{
+    public class DlcWindow : Window
+    {
+        private readonly VirtualFileSystem                  _virtualFileSystem;
+        private readonly string                             _titleId;
+        private readonly string                             _dlcJsonPath;
+        private readonly List<DownloadableContentContainer> _dlcContainerList;
+
+        private static readonly DownloadableContentJsonSerializerContext SerializerContext = new(JsonHelper.GetDefaultSerializerOptions());
+
+#pragma warning disable CS0649, IDE0044
+        [GUI] Label         _baseTitleInfoLabel;
+        [GUI] TreeView      _dlcTreeView;
+        [GUI] TreeSelection _dlcTreeSelection;
+#pragma warning restore CS0649, IDE0044
+
+        public DlcWindow(VirtualFileSystem virtualFileSystem, string titleId, string titleName) : this(new Builder("Ryujinx.Ui.Windows.DlcWindow.glade"), virtualFileSystem, titleId, titleName) { }
+
+        private DlcWindow(Builder builder, VirtualFileSystem virtualFileSystem, string titleId, string titleName) : base(builder.GetRawOwnedObject("_dlcWindow"))
+        {
+            builder.Autoconnect(this);
+
+            _titleId                 = titleId;
+            _virtualFileSystem       = virtualFileSystem;
+            _dlcJsonPath             = System.IO.Path.Combine(AppDataManager.GamesDirPath, _titleId, "dlc.json");
+            _baseTitleInfoLabel.Text = $"DLC Available for {titleName} [{titleId.ToUpper()}]";
+
+            try
+            {
+                _dlcContainerList = JsonHelper.DeserializeFromFile(_dlcJsonPath, SerializerContext.ListDownloadableContentContainer);
+            }
+            catch
+            {
+                _dlcContainerList = new List<DownloadableContentContainer>();
+            }
+            
+            _dlcTreeView.Model = new TreeStore(typeof(bool), typeof(string), typeof(string));
+
+            CellRendererToggle enableToggle = new CellRendererToggle();
+            enableToggle.Toggled += (sender, args) =>
+            {
+                _dlcTreeView.Model.GetIter(out TreeIter treeIter, new TreePath(args.Path));
+                bool newValue = !(bool)_dlcTreeView.Model.GetValue(treeIter, 0);
+                _dlcTreeView.Model.SetValue(treeIter, 0, newValue);
+
+                if (_dlcTreeView.Model.IterChildren(out TreeIter childIter, treeIter))
+                {
+                    do
+                    {
+                        _dlcTreeView.Model.SetValue(childIter, 0, newValue);
+                    }
+                    while (_dlcTreeView.Model.IterNext(ref childIter));
+                }
+            };
+
+            _dlcTreeView.AppendColumn("Enabled", enableToggle,           "active", 0);
+            _dlcTreeView.AppendColumn("TitleId", new CellRendererText(), "text",   1);
+            _dlcTreeView.AppendColumn("Path",    new CellRendererText(), "text",   2);
+
+            foreach (DownloadableContentContainer dlcContainer in _dlcContainerList)
+            {
+                if (File.Exists(dlcContainer.ContainerPath))
+                {
+                    // The parent tree item has its own "enabled" check box, but it's the actual
+                    // nca entries that store the enabled / disabled state. A bit of a UI inconsistency.
+                    // Maybe a tri-state check box would be better, but for now we check the parent
+                    // "enabled" box if all child NCAs are enabled. Usually fine since each nsp has only one nca.
+                    bool areAllContentPacksEnabled = dlcContainer.DownloadableContentNcaList.TrueForAll((nca) => nca.Enabled);
+                    TreeIter parentIter = ((TreeStore)_dlcTreeView.Model).AppendValues(areAllContentPacksEnabled, "", dlcContainer.ContainerPath);
+                    using FileStream containerFile = File.OpenRead(dlcContainer.ContainerPath);
+                    PartitionFileSystem pfs = new PartitionFileSystem(containerFile.AsStorage());
+                    _virtualFileSystem.ImportTickets(pfs);
+
+                    foreach (DownloadableContentNca dlcNca in dlcContainer.DownloadableContentNcaList)
+                    {
+                        using var ncaFile = new UniqueRef<IFile>();
+
+                        pfs.OpenFile(ref ncaFile.Ref, dlcNca.FullPath.ToU8Span(), OpenMode.Read).ThrowIfFailure();
+                        Nca nca = TryCreateNca(ncaFile.Get.AsStorage(), dlcContainer.ContainerPath);
+
+                        if (nca != null)
+                        {
+                            ((TreeStore)_dlcTreeView.Model).AppendValues(parentIter, dlcNca.Enabled, nca.Header.TitleId.ToString("X16"), dlcNca.FullPath);
+                        }
+                    }
+                }
+                else
+                {
+                    // DLC file moved or renamed. Allow the user to remove it without crashing the whole dialog.
+                    TreeIter parentIter = ((TreeStore)_dlcTreeView.Model).AppendValues(false, "", $"(MISSING) {dlcContainer.ContainerPath}");
+                }
+            }
+        }
+
+        private Nca TryCreateNca(IStorage ncaStorage, string containerPath)
+        {
+            try
+            {
+                return new Nca(_virtualFileSystem.KeySet, ncaStorage);
+            }
+            catch (Exception exception)
+            {
+                GtkDialog.CreateErrorDialog($"{exception.Message}. Errored File: {containerPath}");
+            }
+
+            return null;
+        }
+
+        private void AddButton_Clicked(object sender, EventArgs args)
+        {
+            FileChooserNative fileChooser = new FileChooserNative("Select DLC files", this, FileChooserAction.Open, "Add", "Cancel")
+            {
+                SelectMultiple = true
+            };
+
+            FileFilter filter = new FileFilter()
+            {
+                Name = "Switch Game DLCs"
+            };
+            filter.AddPattern("*.nsp");
+
+            fileChooser.AddFilter(filter);
+
+            if (fileChooser.Run() == (int)ResponseType.Accept)
+            {
+                foreach (string containerPath in fileChooser.Filenames)
+                {
+                    if (!File.Exists(containerPath))
+                    {
+                        return;
+                    }
+
+                    using (FileStream containerFile = File.OpenRead(containerPath))
+                    {
+                        PartitionFileSystem pfs = new PartitionFileSystem(containerFile.AsStorage());
+                        bool containsDlc = false;
+
+                        _virtualFileSystem.ImportTickets(pfs);
+
+                        TreeIter? parentIter = null;
+
+                        foreach (DirectoryEntryEx fileEntry in pfs.EnumerateEntries("/", "*.nca"))
+                        {
+                            using var ncaFile = new UniqueRef<IFile>();
+
+                            pfs.OpenFile(ref ncaFile.Ref, fileEntry.FullPath.ToU8Span(), OpenMode.Read).ThrowIfFailure();
+
+                            Nca nca = TryCreateNca(ncaFile.Get.AsStorage(), containerPath);
+
+                            if (nca == null) continue;
+
+                            if (nca.Header.ContentType == NcaContentType.PublicData)
+                            {
+                                if ((nca.Header.TitleId & 0xFFFFFFFFFFFFE000).ToString("x16") != _titleId)
+                                {
+                                    break;
+                                }
+
+                                parentIter ??= ((TreeStore)_dlcTreeView.Model).AppendValues(true, "", containerPath);
+
+                                ((TreeStore)_dlcTreeView.Model).AppendValues(parentIter.Value, true, nca.Header.TitleId.ToString("X16"), fileEntry.FullPath);
+                                containsDlc = true;
+                            }
+                        }
+
+                        if (!containsDlc)
+                        {
+                            GtkDialog.CreateErrorDialog("The specified file does not contain DLC for the selected title!");
+                        }
+                    }
+                }
+            }
+
+            fileChooser.Dispose();
+        }
+
+        private void RemoveButton_Clicked(object sender, EventArgs args)
+        {
+            if (_dlcTreeSelection.GetSelected(out ITreeModel treeModel, out TreeIter treeIter))
+            {
+                if (_dlcTreeView.Model.IterParent(out TreeIter parentIter, treeIter) && _dlcTreeView.Model.IterNChildren(parentIter) <= 1)
+                {
+                    ((TreeStore)treeModel).Remove(ref parentIter);
+                }
+                else
+                {
+                    ((TreeStore)treeModel).Remove(ref treeIter);
+                }
+            }
+        }
+        
+        private void RemoveAllButton_Clicked(object sender, EventArgs args)
+        {
+            List<TreeIter> toRemove = new List<TreeIter>();
+
+            if (_dlcTreeView.Model.GetIterFirst(out TreeIter iter))
+            {
+                do
+                {
+                    toRemove.Add(iter);
+                } 
+                while (_dlcTreeView.Model.IterNext(ref iter));
+            }
+
+            foreach (TreeIter i in toRemove)
+            {
+                TreeIter j = i;
+                ((TreeStore)_dlcTreeView.Model).Remove(ref j);
+            }
+        }
+
+        private void SaveButton_Clicked(object sender, EventArgs args)
+        {
+            _dlcContainerList.Clear();
+
+            if (_dlcTreeView.Model.GetIterFirst(out TreeIter parentIter))
+            {
+                do
+                {
+                    if (_dlcTreeView.Model.IterChildren(out TreeIter childIter, parentIter))
+                    {
+                        DownloadableContentContainer dlcContainer = new DownloadableContentContainer
+                        {
+                            ContainerPath              = (string)_dlcTreeView.Model.GetValue(parentIter, 2),
+                            DownloadableContentNcaList = new List<DownloadableContentNca>()
+                        };
+
+                        do
+                        {
+                            dlcContainer.DownloadableContentNcaList.Add(new DownloadableContentNca
+                            {
+                                Enabled  = (bool)_dlcTreeView.Model.GetValue(childIter, 0),
+                                TitleId  = Convert.ToUInt64(_dlcTreeView.Model.GetValue(childIter, 1).ToString(), 16),
+                                FullPath = (string)_dlcTreeView.Model.GetValue(childIter, 2)
+                            });
+                        }
+                        while (_dlcTreeView.Model.IterNext(ref childIter));
+
+                        _dlcContainerList.Add(dlcContainer);
+                    }
+                }
+                while (_dlcTreeView.Model.IterNext(ref parentIter));
+            }
+
+            JsonHelper.SerializeToFile(_dlcJsonPath, _dlcContainerList, SerializerContext.ListDownloadableContentContainer);
+
+            Dispose();
+        }
+
+        private void CancelButton_Clicked(object sender, EventArgs args)
+        {
+            Dispose();
+        }
+    }
+}

src/Ryujinx/Ui/Windows/DlcWindow.glade

@@ -0,0 +1,202 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Generated with glade 3.36.0 -->
+<interface>
+  <requires lib="gtk+" version="3.20"/>
+  <object class="GtkWindow" id="_dlcWindow">
+    <property name="can_focus">False</property>
+    <property name="title" translatable="yes">Ryujinx - DLC Manager</property>
+    <property name="modal">True</property>
+    <property name="window_position">center</property>
+    <property name="default_width">550</property>
+    <property name="default_height">350</property>
+    <child>
+      <object class="GtkBox" id="MainBox">
+        <property name="visible">True</property>
+        <property name="can_focus">False</property>
+        <property name="orientation">vertical</property>
+        <child>
+          <object class="GtkBox" id="DlcBox">
+            <property name="visible">True</property>
+            <property name="can_focus">False</property>
+            <property name="orientation">vertical</property>
+            <child>
+              <object class="GtkLabel" id="_baseTitleInfoLabel">
+                <property name="visible">True</property>
+                <property name="can_focus">False</property>
+                <property name="margin_left">10</property>
+                <property name="margin_right">10</property>
+                <property name="margin_top">10</property>
+                <property name="margin_bottom">10</property>
+                <property name="label" translatable="yes">Available DLC</property>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">True</property>
+                <property name="position">0</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkScrolledWindow">
+                <property name="visible">True</property>
+                <property name="can_focus">True</property>
+                <property name="margin_left">10</property>
+                <property name="margin_right">10</property>
+                <property name="shadow_type">in</property>
+                <child>
+                  <object class="GtkViewport">
+                    <property name="visible">True</property>
+                    <property name="can_focus">False</property>
+                    <child>
+                      <object class="GtkTreeView" id="_dlcTreeView">
+                        <property name="visible">True</property>
+                        <property name="can_focus">True</property>
+                        <property name="headers_clickable">False</property>
+                        <child internal-child="selection">
+                          <object class="GtkTreeSelection" id="_dlcTreeSelection"/>
+                        </child>
+                      </object>
+                    </child>
+                  </object>
+                </child>
+              </object>
+              <packing>
+                <property name="expand">True</property>
+                <property name="fill">True</property>
+                <property name="position">1</property>
+              </packing>
+            </child>
+          </object>
+          <packing>
+            <property name="expand">True</property>
+            <property name="fill">True</property>
+            <property name="position">0</property>
+          </packing>
+        </child>
+        <child>
+          <object class="GtkBox">
+            <property name="visible">True</property>
+            <property name="can_focus">False</property>
+            <child>
+              <object class="GtkButtonBox">
+                <property name="visible">True</property>
+                <property name="can_focus">False</property>
+                <property name="margin_top">10</property>
+                <property name="margin_bottom">10</property>
+                <property name="layout_style">start</property>
+                <child>
+                  <object class="GtkButton" id="_addUpdate">
+                    <property name="label" translatable="yes">Add</property>
+                    <property name="visible">True</property>
+                    <property name="can_focus">True</property>
+                    <property name="receives_default">True</property>
+                    <property name="tooltip_text" translatable="yes">Adds an update to this list</property>
+                    <property name="margin_left">10</property>
+                    <signal name="clicked" handler="AddButton_Clicked" swapped="no"/>
+                  </object>
+                  <packing>
+                    <property name="expand">True</property>
+                    <property name="fill">True</property>
+                    <property name="position">0</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkButton" id="_removeUpdate">
+                    <property name="label" translatable="yes">Remove</property>
+                    <property name="visible">True</property>
+                    <property name="can_focus">True</property>
+                    <property name="receives_default">True</property>
+                    <property name="tooltip_text" translatable="yes">Removes the selected update</property>
+                    <property name="margin_left">10</property>
+                    <signal name="clicked" handler="RemoveButton_Clicked" swapped="no"/>
+                  </object>
+                  <packing>
+                    <property name="expand">True</property>
+                    <property name="fill">True</property>
+                    <property name="position">1</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkButton" id="_removeAllButton">
+                    <property name="label" translatable="yes">Remove All</property>
+                    <property name="visible">True</property>
+                    <property name="can_focus">True</property>
+                    <property name="receives_default">True</property>
+                    <property name="tooltip_text" translatable="yes">Removes the selected update</property>
+                    <property name="margin_left">10</property>
+                    <signal name="clicked" handler="RemoveAllButton_Clicked" swapped="no"/>
+                  </object>
+                  <packing>
+                    <property name="expand">True</property>
+                    <property name="fill">True</property>
+                    <property name="position">2</property>
+                  </packing>
+                </child>
+              </object>
+              <packing>
+                <property name="expand">True</property>
+                <property name="fill">True</property>
+                <property name="position">0</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkButtonBox">
+                <property name="visible">True</property>
+                <property name="can_focus">False</property>
+                <property name="margin_top">10</property>
+                <property name="margin_bottom">10</property>
+                <property name="layout_style">end</property>
+                <child>
+                  <object class="GtkButton" id="_saveButton">
+                    <property name="label" translatable="yes">Save</property>
+                    <property name="visible">True</property>
+                    <property name="can_focus">True</property>
+                    <property name="receives_default">True</property>
+                    <property name="margin_right">10</property>
+                    <property name="margin_top">2</property>
+                    <property name="margin_bottom">2</property>
+                    <signal name="clicked" handler="SaveButton_Clicked" swapped="no"/>
+                  </object>
+                  <packing>
+                    <property name="expand">True</property>
+                    <property name="fill">True</property>
+                    <property name="position">0</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkButton" id="_cancelButton">
+                    <property name="label" translatable="yes">Cancel</property>
+                    <property name="visible">True</property>
+                    <property name="can_focus">True</property>
+                    <property name="receives_default">True</property>
+                    <property name="margin_right">10</property>
+                    <property name="margin_top">2</property>
+                    <property name="margin_bottom">2</property>
+                    <signal name="clicked" handler="CancelButton_Clicked" swapped="no"/>
+                  </object>
+                  <packing>
+                    <property name="expand">True</property>
+                    <property name="fill">True</property>
+                    <property name="position">1</property>
+                  </packing>
+                </child>
+              </object>
+              <packing>
+                <property name="expand">True</property>
+                <property name="fill">True</property>
+                <property name="position">1</property>
+              </packing>
+            </child>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="fill">True</property>
+            <property name="position">1</property>
+          </packing>
+        </child>
+      </object>
+    </child>
+    <child type="titlebar">
+      <placeholder/>
+    </child>
+  </object>
+</interface>

src/Ryujinx/Ui/Windows/SettingsWindow.cs

@@ -0,0 +1,816 @@
+using Gtk;
+using LibHac.Tools.FsSystem;
+using Ryujinx.Audio.Backends.OpenAL;
+using Ryujinx.Audio.Backends.SDL2;
+using Ryujinx.Audio.Backends.SoundIo;
+using Ryujinx.Common.Configuration;
+using Ryujinx.Common.Configuration.Hid;
+using Ryujinx.Common.GraphicsDriver;
+using Ryujinx.Graphics.Vulkan;
+using Ryujinx.HLE.FileSystem;
+using Ryujinx.HLE.HOS.Services.Time.TimeZone;
+using Ryujinx.Ui.Common.Configuration;
+using Ryujinx.Ui.Common.Configuration.System;
+using Ryujinx.Ui.Helper;
+using Ryujinx.Ui.Widgets;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Net.NetworkInformation;
+using System.Reflection;
+using System.Threading.Tasks;
+using GUI = Gtk.Builder.ObjectAttribute;
+
+namespace Ryujinx.Ui.Windows
+{
+    public class SettingsWindow : Window
+    {
+        private readonly MainWindow             _parent;
+        private readonly ListStore              _gameDirsBoxStore;
+        private readonly ListStore              _audioBackendStore;
+        private readonly TimeZoneContentManager _timeZoneContentManager;
+        private readonly HashSet<string>        _validTzRegions;
+
+        private long  _systemTimeOffset;
+        private float _previousVolumeLevel;
+        private bool _directoryChanged = false;
+
+#pragma warning disable CS0649, IDE0044
+        [GUI] CheckButton     _traceLogToggle;
+        [GUI] CheckButton     _errorLogToggle;
+        [GUI] CheckButton     _warningLogToggle;
+        [GUI] CheckButton     _infoLogToggle;
+        [GUI] CheckButton     _stubLogToggle;
+        [GUI] CheckButton     _debugLogToggle;
+        [GUI] CheckButton     _fileLogToggle;
+        [GUI] CheckButton     _guestLogToggle;
+        [GUI] CheckButton     _fsAccessLogToggle;
+        [GUI] Adjustment      _fsLogSpinAdjustment;
+        [GUI] ComboBoxText    _graphicsDebugLevel;
+        [GUI] CheckButton     _dockedModeToggle;
+        [GUI] CheckButton     _discordToggle;
+        [GUI] CheckButton     _checkUpdatesToggle;
+        [GUI] CheckButton     _showConfirmExitToggle;
+        [GUI] CheckButton     _hideCursorOnIdleToggle;
+        [GUI] CheckButton     _vSyncToggle;
+        [GUI] CheckButton     _shaderCacheToggle;
+        [GUI] CheckButton     _textureRecompressionToggle;
+        [GUI] CheckButton     _macroHLEToggle;
+        [GUI] CheckButton     _ptcToggle;
+        [GUI] CheckButton     _internetToggle;
+        [GUI] CheckButton     _fsicToggle;
+        [GUI] RadioButton     _mmSoftware;
+        [GUI] RadioButton     _mmHost;
+        [GUI] RadioButton     _mmHostUnsafe;
+        [GUI] CheckButton     _expandRamToggle;
+        [GUI] CheckButton     _ignoreToggle;
+        [GUI] CheckButton     _directKeyboardAccess;
+        [GUI] CheckButton     _directMouseAccess;
+        [GUI] ComboBoxText    _systemLanguageSelect;
+        [GUI] ComboBoxText    _systemRegionSelect;
+        [GUI] Entry           _systemTimeZoneEntry;
+        [GUI] EntryCompletion _systemTimeZoneCompletion;
+        [GUI] Box             _audioBackendBox;
+        [GUI] ComboBox        _audioBackendSelect;
+        [GUI] Label           _audioVolumeLabel;
+        [GUI] Scale           _audioVolumeSlider;
+        [GUI] SpinButton      _systemTimeYearSpin;
+        [GUI] SpinButton      _systemTimeMonthSpin;
+        [GUI] SpinButton      _systemTimeDaySpin;
+        [GUI] SpinButton      _systemTimeHourSpin;
+        [GUI] SpinButton      _systemTimeMinuteSpin;
+        [GUI] Adjustment      _systemTimeYearSpinAdjustment;
+        [GUI] Adjustment      _systemTimeMonthSpinAdjustment;
+        [GUI] Adjustment      _systemTimeDaySpinAdjustment;
+        [GUI] Adjustment      _systemTimeHourSpinAdjustment;
+        [GUI] Adjustment      _systemTimeMinuteSpinAdjustment;
+        [GUI] ComboBoxText    _multiLanSelect;
+        [GUI] CheckButton     _custThemeToggle;
+        [GUI] Entry           _custThemePath;
+        [GUI] ToggleButton    _browseThemePath;
+        [GUI] Label           _custThemePathLabel;
+        [GUI] TreeView        _gameDirsBox;
+        [GUI] Entry           _addGameDirBox;
+        [GUI] ComboBoxText    _galThreading;
+        [GUI] Entry           _graphicsShadersDumpPath;
+        [GUI] ComboBoxText    _anisotropy;
+        [GUI] ComboBoxText    _aspectRatio;
+        [GUI] ComboBoxText    _antiAliasing;
+        [GUI] ComboBoxText    _scalingFilter;
+        [GUI] ComboBoxText    _graphicsBackend;
+        [GUI] ComboBoxText    _preferredGpu;
+        [GUI] ComboBoxText    _resScaleCombo;
+        [GUI] Entry           _resScaleText;
+        [GUI] Adjustment      _scalingFilterLevel;
+        [GUI] Scale           _scalingFilterSlider;
+        [GUI] ToggleButton    _configureController1;
+        [GUI] ToggleButton    _configureController2;
+        [GUI] ToggleButton    _configureController3;
+        [GUI] ToggleButton    _configureController4;
+        [GUI] ToggleButton    _configureController5;
+        [GUI] ToggleButton    _configureController6;
+        [GUI] ToggleButton    _configureController7;
+        [GUI] ToggleButton    _configureController8;
+        [GUI] ToggleButton    _configureControllerH;
+
+#pragma warning restore CS0649, IDE0044
+
+        public SettingsWindow(MainWindow parent, VirtualFileSystem virtualFileSystem, ContentManager contentManager) : this(parent, new Builder("Ryujinx.Ui.Windows.SettingsWindow.glade"), virtualFileSystem, contentManager) { }
+
+        private SettingsWindow(MainWindow parent, Builder builder, VirtualFileSystem virtualFileSystem, ContentManager contentManager) : base(builder.GetRawOwnedObject("_settingsWin"))
+        {
+            Icon = new Gdk.Pixbuf(Assembly.GetAssembly(typeof(ConfigurationState)), "Ryujinx.Ui.Common.Resources.Logo_Ryujinx.png");
+
+            _parent = parent;
+
+            builder.Autoconnect(this);
+
+            _timeZoneContentManager = new TimeZoneContentManager();
+            _timeZoneContentManager.InitializeInstance(virtualFileSystem, contentManager, IntegrityCheckLevel.None);
+
+            _validTzRegions = new HashSet<string>(_timeZoneContentManager.LocationNameCache.Length, StringComparer.Ordinal); // Zone regions are identifiers. Must match exactly.
+
+            // Bind Events.
+            _configureController1.Pressed += (sender, args) => ConfigureController_Pressed(sender, PlayerIndex.Player1);
+            _configureController2.Pressed += (sender, args) => ConfigureController_Pressed(sender, PlayerIndex.Player2);
+            _configureController3.Pressed += (sender, args) => ConfigureController_Pressed(sender, PlayerIndex.Player3);
+            _configureController4.Pressed += (sender, args) => ConfigureController_Pressed(sender, PlayerIndex.Player4);
+            _configureController5.Pressed += (sender, args) => ConfigureController_Pressed(sender, PlayerIndex.Player5);
+            _configureController6.Pressed += (sender, args) => ConfigureController_Pressed(sender, PlayerIndex.Player6);
+            _configureController7.Pressed += (sender, args) => ConfigureController_Pressed(sender, PlayerIndex.Player7);
+            _configureController8.Pressed += (sender, args) => ConfigureController_Pressed(sender, PlayerIndex.Player8);
+            _configureControllerH.Pressed += (sender, args) => ConfigureController_Pressed(sender, PlayerIndex.Handheld);
+            _systemTimeZoneEntry.FocusOutEvent += TimeZoneEntry_FocusOut;
+
+            _resScaleCombo.Changed += (sender, args) => _resScaleText.Visible = _resScaleCombo.ActiveId == "-1";
+            _scalingFilter.Changed += (sender, args) => _scalingFilterSlider.Visible = _scalingFilter.ActiveId == "2";
+            _galThreading.Changed += (sender, args) =>
+            {
+                if (_galThreading.ActiveId != ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString())
+                {
+                    GtkDialog.CreateInfoDialog("Warning - Backend Threading", "Ryujinx must be restarted after changing this option for it to apply fully. Depending on your platform, you may need to manually disable your driver's own multithreading when using Ryujinx's.");
+                }
+            };
+
+            // Setup Currents.
+            if (ConfigurationState.Instance.Logger.EnableTrace)
+            {
+                _traceLogToggle.Click();
+            }
+
+            if (ConfigurationState.Instance.Logger.EnableFileLog)
+            {
+                _fileLogToggle.Click();
+            }
+
+            if (ConfigurationState.Instance.Logger.EnableError)
+            {
+                _errorLogToggle.Click();
+            }
+
+            if (ConfigurationState.Instance.Logger.EnableWarn)
+            {
+                _warningLogToggle.Click();
+            }
+
+            if (ConfigurationState.Instance.Logger.EnableInfo)
+            {
+                _infoLogToggle.Click();
+            }
+
+            if (ConfigurationState.Instance.Logger.EnableStub)
+            {
+                _stubLogToggle.Click();
+            }
+
+            if (ConfigurationState.Instance.Logger.EnableDebug)
+            {
+                _debugLogToggle.Click();
+            }
+
+            if (ConfigurationState.Instance.Logger.EnableGuest)
+            {
+                _guestLogToggle.Click();
+            }
+
+            if (ConfigurationState.Instance.Logger.EnableFsAccessLog)
+            {
+                _fsAccessLogToggle.Click();
+            }
+
+            foreach (GraphicsDebugLevel level in Enum.GetValues<GraphicsDebugLevel>())
+            {
+                _graphicsDebugLevel.Append(level.ToString(), level.ToString());
+            }
+
+            _graphicsDebugLevel.SetActiveId(ConfigurationState.Instance.Logger.GraphicsDebugLevel.Value.ToString());
+
+            if (ConfigurationState.Instance.System.EnableDockedMode)
+            {
+                _dockedModeToggle.Click();
+            }
+
+            if (ConfigurationState.Instance.EnableDiscordIntegration)
+            {
+                _discordToggle.Click();
+            }
+
+            if (ConfigurationState.Instance.CheckUpdatesOnStart)
+            {
+                _checkUpdatesToggle.Click();
+            }
+
+            if (ConfigurationState.Instance.ShowConfirmExit)
+            {
+                _showConfirmExitToggle.Click();
+            }
+
+            if (ConfigurationState.Instance.HideCursorOnIdle)
+            {
+                _hideCursorOnIdleToggle.Click();
+            }
+
+            if (ConfigurationState.Instance.Graphics.EnableVsync)
+            {
+                _vSyncToggle.Click();
+            }
+
+            if (ConfigurationState.Instance.Graphics.EnableShaderCache)
+            {
+                _shaderCacheToggle.Click();
+            }
+
+            if (ConfigurationState.Instance.Graphics.EnableTextureRecompression)
+            {
+                _textureRecompressionToggle.Click();
+            }
+
+            if (ConfigurationState.Instance.Graphics.EnableMacroHLE)
+            {
+                _macroHLEToggle.Click();
+            }
+
+            if (ConfigurationState.Instance.System.EnablePtc)
+            {
+                _ptcToggle.Click();
+            }
+
+            if (ConfigurationState.Instance.System.EnableInternetAccess)
+            {
+                _internetToggle.Click();
+            }
+
+            if (ConfigurationState.Instance.System.EnableFsIntegrityChecks)
+            {
+                _fsicToggle.Click();
+            }
+
+            switch (ConfigurationState.Instance.System.MemoryManagerMode.Value)
+            {
+                case MemoryManagerMode.SoftwarePageTable:
+                    _mmSoftware.Click();
+                    break;
+                case MemoryManagerMode.HostMapped:
+                    _mmHost.Click();
+                    break;
+                case MemoryManagerMode.HostMappedUnsafe:
+                    _mmHostUnsafe.Click();
+                    break;
+            }
+
+            if (ConfigurationState.Instance.System.ExpandRam)
+            {
+                _expandRamToggle.Click();
+            }
+
+            if (ConfigurationState.Instance.System.IgnoreMissingServices)
+            {
+                _ignoreToggle.Click();
+            }
+
+            if (ConfigurationState.Instance.Hid.EnableKeyboard)
+            {
+                _directKeyboardAccess.Click();
+            }
+
+            if (ConfigurationState.Instance.Hid.EnableMouse)
+            {
+                _directMouseAccess.Click();
+            }
+
+            if (ConfigurationState.Instance.Ui.EnableCustomTheme)
+            {
+                _custThemeToggle.Click();
+            }
+
+            // Custom EntryCompletion Columns. If added to glade, need to override more signals
+            ListStore tzList = new ListStore(typeof(string), typeof(string), typeof(string));
+            _systemTimeZoneCompletion.Model = tzList;
+
+            CellRendererText offsetCol = new CellRendererText();
+            CellRendererText abbrevCol = new CellRendererText();
+
+            _systemTimeZoneCompletion.PackStart(offsetCol, false);
+            _systemTimeZoneCompletion.AddAttribute(offsetCol, "text", 0);
+            _systemTimeZoneCompletion.TextColumn = 1; // Regions Column
+            _systemTimeZoneCompletion.PackStart(abbrevCol, false);
+            _systemTimeZoneCompletion.AddAttribute(abbrevCol, "text", 2);
+
+            int maxLocationLength = 0;
+
+            foreach (var (offset, location, abbr) in _timeZoneContentManager.ParseTzOffsets())
+            {
+                var hours = Math.DivRem(offset, 3600, out int seconds);
+                var minutes = Math.Abs(seconds) / 60;
+
+                var abbr2 = (abbr.StartsWith('+') || abbr.StartsWith('-')) ? string.Empty : abbr;
+
+                tzList.AppendValues($"UTC{hours:+0#;-0#;+00}:{minutes:D2} ", location, abbr2);
+                _validTzRegions.Add(location);
+
+                maxLocationLength = Math.Max(maxLocationLength, location.Length);
+            }
+
+            _systemTimeZoneEntry.WidthChars = Math.Max(20, maxLocationLength + 1); // Ensure minimum Entry width
+            _systemTimeZoneEntry.Text = _timeZoneContentManager.SanityCheckDeviceLocationName(ConfigurationState.Instance.System.TimeZone);
+
+            _systemTimeZoneCompletion.MatchFunc = TimeZoneMatchFunc;
+
+            _systemLanguageSelect.SetActiveId(ConfigurationState.Instance.System.Language.Value.ToString());
+            _systemRegionSelect.SetActiveId(ConfigurationState.Instance.System.Region.Value.ToString());
+            _galThreading.SetActiveId(ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString());
+            _resScaleCombo.SetActiveId(ConfigurationState.Instance.Graphics.ResScale.Value.ToString());
+            _anisotropy.SetActiveId(ConfigurationState.Instance.Graphics.MaxAnisotropy.Value.ToString());
+            _aspectRatio.SetActiveId(((int)ConfigurationState.Instance.Graphics.AspectRatio.Value).ToString());
+            _graphicsBackend.SetActiveId(((int)ConfigurationState.Instance.Graphics.GraphicsBackend.Value).ToString());
+            _antiAliasing.SetActiveId(((int)ConfigurationState.Instance.Graphics.AntiAliasing.Value).ToString());
+            _scalingFilter.SetActiveId(((int)ConfigurationState.Instance.Graphics.ScalingFilter.Value).ToString());
+
+            UpdatePreferredGpuComboBox();
+
+            _graphicsBackend.Changed += (sender, e) => UpdatePreferredGpuComboBox();
+            PopulateNetworkInterfaces();
+            _multiLanSelect.SetActiveId(ConfigurationState.Instance.Multiplayer.LanInterfaceId.Value);
+
+            _custThemePath.Buffer.Text           = ConfigurationState.Instance.Ui.CustomThemePath;
+            _resScaleText.Buffer.Text            = ConfigurationState.Instance.Graphics.ResScaleCustom.Value.ToString();
+            _scalingFilterLevel.Value            = ConfigurationState.Instance.Graphics.ScalingFilterLevel.Value;
+            _resScaleText.Visible                = _resScaleCombo.ActiveId == "-1";
+            _scalingFilterSlider.Visible         = _scalingFilter.ActiveId == "2";
+            _graphicsShadersDumpPath.Buffer.Text = ConfigurationState.Instance.Graphics.ShadersDumpPath;
+            _fsLogSpinAdjustment.Value           = ConfigurationState.Instance.System.FsGlobalAccessLogMode;
+            _systemTimeOffset                    = ConfigurationState.Instance.System.SystemTimeOffset;
+
+            _gameDirsBox.AppendColumn("", new CellRendererText(), "text", 0);
+            _gameDirsBoxStore  = new ListStore(typeof(string));
+            _gameDirsBox.Model = _gameDirsBoxStore;
+
+            foreach (string gameDir in ConfigurationState.Instance.Ui.GameDirs.Value)
+            {
+                _gameDirsBoxStore.AppendValues(gameDir);
+            }
+
+            if (_custThemeToggle.Active == false)
+            {
+                _custThemePath.Sensitive      = false;
+                _custThemePathLabel.Sensitive = false;
+                _browseThemePath.Sensitive    = false;
+            }
+
+            // Setup system time spinners
+            UpdateSystemTimeSpinners();
+
+            _audioBackendStore = new ListStore(typeof(string), typeof(AudioBackend));
+
+            TreeIter openAlIter  = _audioBackendStore.AppendValues("OpenAL", AudioBackend.OpenAl);
+            TreeIter soundIoIter = _audioBackendStore.AppendValues("SoundIO", AudioBackend.SoundIo);
+            TreeIter sdl2Iter    = _audioBackendStore.AppendValues("SDL2", AudioBackend.SDL2);
+            TreeIter dummyIter   = _audioBackendStore.AppendValues("Dummy", AudioBackend.Dummy);
+
+            _audioBackendSelect = ComboBox.NewWithModelAndEntry(_audioBackendStore);
+            _audioBackendSelect.EntryTextColumn = 0;
+            _audioBackendSelect.Entry.IsEditable = false;
+
+            switch (ConfigurationState.Instance.System.AudioBackend.Value)
+            {
+                case AudioBackend.OpenAl:
+                    _audioBackendSelect.SetActiveIter(openAlIter);
+                    break;
+                case AudioBackend.SoundIo:
+                    _audioBackendSelect.SetActiveIter(soundIoIter);
+                    break;
+                case AudioBackend.SDL2:
+                    _audioBackendSelect.SetActiveIter(sdl2Iter);
+                    break;
+                case AudioBackend.Dummy:
+                    _audioBackendSelect.SetActiveIter(dummyIter);
+                    break;
+                default:
+                    throw new ArgumentOutOfRangeException();
+            }
+
+            _audioBackendBox.Add(_audioBackendSelect);
+            _audioBackendSelect.Show();
+
+            _previousVolumeLevel            = ConfigurationState.Instance.System.AudioVolume;
+            _audioVolumeLabel               = new Label("Volume: ");
+            _audioVolumeSlider              = new Scale(Orientation.Horizontal, 0, 100, 1);
+            _audioVolumeLabel.MarginStart   = 10;
+            _audioVolumeSlider.ValuePos     = PositionType.Right;
+            _audioVolumeSlider.WidthRequest = 200;
+
+            _audioVolumeSlider.Value        =  _previousVolumeLevel * 100;
+            _audioVolumeSlider.ValueChanged += VolumeSlider_OnChange;
+            _audioBackendBox.Add(_audioVolumeLabel);
+            _audioBackendBox.Add(_audioVolumeSlider);
+            _audioVolumeLabel.Show();
+            _audioVolumeSlider.Show();
+
+            bool openAlIsSupported  = false;
+            bool soundIoIsSupported = false;
+            bool sdl2IsSupported    = false;
+
+            Task.Run(() =>
+            {
+                openAlIsSupported  = OpenALHardwareDeviceDriver.IsSupported;
+                soundIoIsSupported = !OperatingSystem.IsMacOS() && SoundIoHardwareDeviceDriver.IsSupported;
+                sdl2IsSupported    = SDL2HardwareDeviceDriver.IsSupported;
+            });
+
+            // This function runs whenever the dropdown is opened
+            _audioBackendSelect.SetCellDataFunc(_audioBackendSelect.Cells[0], (layout, cell, model, iter) =>
+            {
+                cell.Sensitive = ((AudioBackend)_audioBackendStore.GetValue(iter, 1)) switch
+                {
+                    AudioBackend.OpenAl  => openAlIsSupported,
+                    AudioBackend.SoundIo => soundIoIsSupported,
+                    AudioBackend.SDL2    => sdl2IsSupported,
+                    AudioBackend.Dummy   => true,
+                    _ => throw new ArgumentOutOfRangeException()
+                };
+            });
+
+            if (OperatingSystem.IsMacOS())
+            {
+                var store = (_graphicsBackend.Model as ListStore);
+                store.GetIter(out TreeIter openglIter, new TreePath(new int[] {1}));
+                store.Remove(ref openglIter);
+
+                _graphicsBackend.Model = store;
+            }
+        }
+
+        private void UpdatePreferredGpuComboBox()
+        {
+            _preferredGpu.RemoveAll();
+
+            if (Enum.Parse<GraphicsBackend>(_graphicsBackend.ActiveId) == GraphicsBackend.Vulkan)
+            {
+                var devices = VulkanRenderer.GetPhysicalDevices();
+                string preferredGpuIdFromConfig = ConfigurationState.Instance.Graphics.PreferredGpu.Value;
+                string preferredGpuId = preferredGpuIdFromConfig;
+                bool noGpuId = string.IsNullOrEmpty(preferredGpuIdFromConfig);
+
+                foreach (var device in devices)
+                {
+                    string dGPU = device.IsDiscrete ? " (dGPU)" : "";
+                    _preferredGpu.Append(device.Id, $"{device.Name}{dGPU}");
+
+                    // If there's no GPU selected yet, we just pick the first GPU.
+                    // If there's a discrete GPU available, we always prefer that over the previous selection,
+                    // as it is likely to have better performance and more features.
+                    // If the configuration file already has a GPU selection, we always prefer that instead.
+                    if (noGpuId && (string.IsNullOrEmpty(preferredGpuId) || device.IsDiscrete))
+                    {
+                        preferredGpuId = device.Id;
+                    }
+                }
+
+                if (!string.IsNullOrEmpty(preferredGpuId))
+                {
+                    _preferredGpu.SetActiveId(preferredGpuId);
+                }
+            }
+        }
+
+        private void PopulateNetworkInterfaces()
+        {
+            NetworkInterface[] interfaces = NetworkInterface.GetAllNetworkInterfaces();
+
+            foreach (NetworkInterface nif in interfaces)
+            {
+                string guid = nif.Id;
+                string name = nif.Name;
+
+                _multiLanSelect.Append(guid, name);
+            }
+        }
+
+        private void UpdateSystemTimeSpinners()
+        {
+            //Bind system time events
+            _systemTimeYearSpin.ValueChanged   -= SystemTimeSpin_ValueChanged;
+            _systemTimeMonthSpin.ValueChanged  -= SystemTimeSpin_ValueChanged;
+            _systemTimeDaySpin.ValueChanged    -= SystemTimeSpin_ValueChanged;
+            _systemTimeHourSpin.ValueChanged   -= SystemTimeSpin_ValueChanged;
+            _systemTimeMinuteSpin.ValueChanged -= SystemTimeSpin_ValueChanged;
+
+            //Apply actual system time + SystemTimeOffset to system time spin buttons
+            DateTime systemTime = DateTime.Now.AddSeconds(_systemTimeOffset);
+
+            _systemTimeYearSpinAdjustment.Value   = systemTime.Year;
+            _systemTimeMonthSpinAdjustment.Value  = systemTime.Month;
+            _systemTimeDaySpinAdjustment.Value    = systemTime.Day;
+            _systemTimeHourSpinAdjustment.Value   = systemTime.Hour;
+            _systemTimeMinuteSpinAdjustment.Value = systemTime.Minute;
+
+            //Format spin buttons text to include leading zeros
+            _systemTimeYearSpin.Text   = systemTime.Year.ToString("0000");
+            _systemTimeMonthSpin.Text  = systemTime.Month.ToString("00");
+            _systemTimeDaySpin.Text    = systemTime.Day.ToString("00");
+            _systemTimeHourSpin.Text   = systemTime.Hour.ToString("00");
+            _systemTimeMinuteSpin.Text = systemTime.Minute.ToString("00");
+
+            //Bind system time events
+            _systemTimeYearSpin.ValueChanged   += SystemTimeSpin_ValueChanged;
+            _systemTimeMonthSpin.ValueChanged  += SystemTimeSpin_ValueChanged;
+            _systemTimeDaySpin.ValueChanged    += SystemTimeSpin_ValueChanged;
+            _systemTimeHourSpin.ValueChanged   += SystemTimeSpin_ValueChanged;
+            _systemTimeMinuteSpin.ValueChanged += SystemTimeSpin_ValueChanged;
+        }
+
+        private void SaveSettings()
+        {
+            if (_directoryChanged)
+            {
+                List<string> gameDirs = new List<string>();
+
+                _gameDirsBoxStore.GetIterFirst(out TreeIter treeIter);
+
+                for (int i = 0; i < _gameDirsBoxStore.IterNChildren(); i++)
+                {
+                    gameDirs.Add((string)_gameDirsBoxStore.GetValue(treeIter, 0));
+
+                    _gameDirsBoxStore.IterNext(ref treeIter);
+                }
+
+                ConfigurationState.Instance.Ui.GameDirs.Value = gameDirs;
+
+                _directoryChanged = false;
+            }
+
+            if (!float.TryParse(_resScaleText.Buffer.Text, out float resScaleCustom) || resScaleCustom <= 0.0f)
+            {
+                resScaleCustom = 1.0f;
+            }
+
+            if (_validTzRegions.Contains(_systemTimeZoneEntry.Text))
+            {
+                ConfigurationState.Instance.System.TimeZone.Value = _systemTimeZoneEntry.Text;
+            }
+
+            MemoryManagerMode memoryMode = MemoryManagerMode.SoftwarePageTable;
+
+            if (_mmHost.Active)
+            {
+                memoryMode = MemoryManagerMode.HostMapped;
+            }
+
+            if (_mmHostUnsafe.Active)
+            {
+                memoryMode = MemoryManagerMode.HostMappedUnsafe;
+            }
+
+            BackendThreading backendThreading = Enum.Parse<BackendThreading>(_galThreading.ActiveId);
+            if (ConfigurationState.Instance.Graphics.BackendThreading != backendThreading)
+            {
+                DriverUtilities.ToggleOGLThreading(backendThreading == BackendThreading.Off);
+            }
+
+            ConfigurationState.Instance.Logger.EnableError.Value                  = _errorLogToggle.Active;
+            ConfigurationState.Instance.Logger.EnableTrace.Value                  = _traceLogToggle.Active;
+            ConfigurationState.Instance.Logger.EnableWarn.Value                   = _warningLogToggle.Active;
+            ConfigurationState.Instance.Logger.EnableInfo.Value                   = _infoLogToggle.Active;
+            ConfigurationState.Instance.Logger.EnableStub.Value                   = _stubLogToggle.Active;
+            ConfigurationState.Instance.Logger.EnableDebug.Value                  = _debugLogToggle.Active;
+            ConfigurationState.Instance.Logger.EnableGuest.Value                  = _guestLogToggle.Active;
+            ConfigurationState.Instance.Logger.EnableFsAccessLog.Value            = _fsAccessLogToggle.Active;
+            ConfigurationState.Instance.Logger.EnableFileLog.Value                = _fileLogToggle.Active;
+            ConfigurationState.Instance.Logger.GraphicsDebugLevel.Value           = Enum.Parse<GraphicsDebugLevel>(_graphicsDebugLevel.ActiveId);
+            ConfigurationState.Instance.System.EnableDockedMode.Value             = _dockedModeToggle.Active;
+            ConfigurationState.Instance.EnableDiscordIntegration.Value            = _discordToggle.Active;
+            ConfigurationState.Instance.CheckUpdatesOnStart.Value                 = _checkUpdatesToggle.Active;
+            ConfigurationState.Instance.ShowConfirmExit.Value                     = _showConfirmExitToggle.Active;
+            ConfigurationState.Instance.HideCursorOnIdle.Value                    = _hideCursorOnIdleToggle.Active;
+            ConfigurationState.Instance.Graphics.EnableVsync.Value                = _vSyncToggle.Active;
+            ConfigurationState.Instance.Graphics.EnableShaderCache.Value          = _shaderCacheToggle.Active;
+            ConfigurationState.Instance.Graphics.EnableTextureRecompression.Value = _textureRecompressionToggle.Active;
+            ConfigurationState.Instance.Graphics.EnableMacroHLE.Value             = _macroHLEToggle.Active;
+            ConfigurationState.Instance.System.EnablePtc.Value                    = _ptcToggle.Active;
+            ConfigurationState.Instance.System.EnableInternetAccess.Value         = _internetToggle.Active;
+            ConfigurationState.Instance.System.EnableFsIntegrityChecks.Value      = _fsicToggle.Active;
+            ConfigurationState.Instance.System.MemoryManagerMode.Value            = memoryMode;
+            ConfigurationState.Instance.System.ExpandRam.Value                    = _expandRamToggle.Active;
+            ConfigurationState.Instance.System.IgnoreMissingServices.Value        = _ignoreToggle.Active;
+            ConfigurationState.Instance.Hid.EnableKeyboard.Value                  = _directKeyboardAccess.Active;
+            ConfigurationState.Instance.Hid.EnableMouse.Value                     = _directMouseAccess.Active;
+            ConfigurationState.Instance.Ui.EnableCustomTheme.Value                = _custThemeToggle.Active;
+            ConfigurationState.Instance.System.Language.Value                     = Enum.Parse<Language>(_systemLanguageSelect.ActiveId);
+            ConfigurationState.Instance.System.Region.Value                       = Enum.Parse<Common.Configuration.System.Region>(_systemRegionSelect.ActiveId);
+            ConfigurationState.Instance.System.SystemTimeOffset.Value             = _systemTimeOffset;
+            ConfigurationState.Instance.Ui.CustomThemePath.Value                  = _custThemePath.Buffer.Text;
+            ConfigurationState.Instance.Graphics.ShadersDumpPath.Value            = _graphicsShadersDumpPath.Buffer.Text;
+            ConfigurationState.Instance.System.FsGlobalAccessLogMode.Value        = (int)_fsLogSpinAdjustment.Value;
+            ConfigurationState.Instance.Graphics.MaxAnisotropy.Value              = float.Parse(_anisotropy.ActiveId, CultureInfo.InvariantCulture);
+            ConfigurationState.Instance.Graphics.AspectRatio.Value                = Enum.Parse<AspectRatio>(_aspectRatio.ActiveId);
+            ConfigurationState.Instance.Graphics.BackendThreading.Value           = backendThreading;
+            ConfigurationState.Instance.Graphics.GraphicsBackend.Value            = Enum.Parse<GraphicsBackend>(_graphicsBackend.ActiveId);
+            ConfigurationState.Instance.Graphics.PreferredGpu.Value               = _preferredGpu.ActiveId;
+            ConfigurationState.Instance.Graphics.ResScale.Value                   = int.Parse(_resScaleCombo.ActiveId);
+            ConfigurationState.Instance.Graphics.ResScaleCustom.Value             = resScaleCustom;
+            ConfigurationState.Instance.System.AudioVolume.Value                  = (float)_audioVolumeSlider.Value / 100.0f;
+            ConfigurationState.Instance.Graphics.AntiAliasing.Value               = Enum.Parse<AntiAliasing>(_antiAliasing.ActiveId);
+            ConfigurationState.Instance.Graphics.ScalingFilter.Value              = Enum.Parse<ScalingFilter>(_scalingFilter.ActiveId);
+            ConfigurationState.Instance.Graphics.ScalingFilterLevel.Value         = (int)_scalingFilterLevel.Value;
+            ConfigurationState.Instance.Multiplayer.LanInterfaceId.Value          = _multiLanSelect.ActiveId;
+
+            _previousVolumeLevel = ConfigurationState.Instance.System.AudioVolume.Value;
+
+            if (_audioBackendSelect.GetActiveIter(out TreeIter activeIter))
+            {
+                ConfigurationState.Instance.System.AudioBackend.Value = (AudioBackend)_audioBackendStore.GetValue(activeIter, 1);
+            }
+
+            ConfigurationState.Instance.ToFileFormat().SaveConfig(Program.ConfigurationPath);
+            _parent.UpdateGraphicsConfig();
+            ThemeHelper.ApplyTheme();
+        }
+
+        //
+        // Events
+        //
+        private void TimeZoneEntry_FocusOut(object sender, FocusOutEventArgs e)
+        {
+            if (!_validTzRegions.Contains(_systemTimeZoneEntry.Text))
+            {
+                _systemTimeZoneEntry.Text = _timeZoneContentManager.SanityCheckDeviceLocationName(ConfigurationState.Instance.System.TimeZone);
+            }
+        }
+
+        private bool TimeZoneMatchFunc(EntryCompletion compl, string key, TreeIter iter)
+        {
+            key = key.Trim().Replace(' ', '_');
+
+            return ((string)compl.Model.GetValue(iter, 1)).Contains(key, StringComparison.OrdinalIgnoreCase) || // region
+                   ((string)compl.Model.GetValue(iter, 2)).StartsWith(key, StringComparison.OrdinalIgnoreCase) || // abbr
+                   ((string)compl.Model.GetValue(iter, 0))[3..].StartsWith(key); // offset
+        }
+
+        private void SystemTimeSpin_ValueChanged(object sender, EventArgs e)
+        {
+            int year   = _systemTimeYearSpin.ValueAsInt;
+            int month  = _systemTimeMonthSpin.ValueAsInt;
+            int day    = _systemTimeDaySpin.ValueAsInt;
+            int hour   = _systemTimeHourSpin.ValueAsInt;
+            int minute = _systemTimeMinuteSpin.ValueAsInt;
+
+            if (!DateTime.TryParse(year + "-" + month + "-" + day + " " + hour + ":" + minute, out DateTime newTime))
+            {
+                UpdateSystemTimeSpinners();
+
+                return;
+            }
+
+            newTime = newTime.AddSeconds(DateTime.Now.Second).AddMilliseconds(DateTime.Now.Millisecond);
+
+            long systemTimeOffset = (long)Math.Ceiling((newTime - DateTime.Now).TotalMinutes) * 60L;
+
+            if (_systemTimeOffset != systemTimeOffset)
+            {
+                _systemTimeOffset = systemTimeOffset;
+                UpdateSystemTimeSpinners();
+            }
+        }
+
+        private void AddDir_Pressed(object sender, EventArgs args)
+        {
+            if (Directory.Exists(_addGameDirBox.Buffer.Text))
+            {
+                _gameDirsBoxStore.AppendValues(_addGameDirBox.Buffer.Text);
+            }
+            else
+            {
+                FileChooserNative fileChooser = new FileChooserNative("Choose the game directory to add to the list", this, FileChooserAction.SelectFolder, "Add", "Cancel")
+                {
+                    SelectMultiple = true
+                };
+
+                if (fileChooser.Run() == (int)ResponseType.Accept)
+                {
+                    _directoryChanged = false;
+                    foreach (string directory in fileChooser.Filenames)
+                    {
+                        if (_gameDirsBoxStore.GetIterFirst(out TreeIter treeIter))
+                        {
+                            do
+                            {
+                                if (directory.Equals((string)_gameDirsBoxStore.GetValue(treeIter, 0)))
+                                {
+                                    break;
+                                }
+                            } while (_gameDirsBoxStore.IterNext(ref treeIter));
+                        }
+
+                        if (!_directoryChanged)
+                        {
+                            _gameDirsBoxStore.AppendValues(directory);
+                        }
+                    }
+
+                    _directoryChanged = true;
+                }
+
+                fileChooser.Dispose();
+            }
+
+            _addGameDirBox.Buffer.Text = "";
+
+            ((ToggleButton)sender).SetStateFlags(StateFlags.Normal, true);
+        }
+
+        private void RemoveDir_Pressed(object sender, EventArgs args)
+        {
+            TreeSelection selection = _gameDirsBox.Selection;
+
+            if (selection.GetSelected(out TreeIter treeIter))
+            {
+                _gameDirsBoxStore.Remove(ref treeIter);
+
+                _directoryChanged = true;
+            }
+
+            ((ToggleButton)sender).SetStateFlags(StateFlags.Normal, true);
+        }
+
+        private void CustThemeToggle_Activated(object sender, EventArgs args)
+        {
+            _custThemePath.Sensitive      = _custThemeToggle.Active;
+            _custThemePathLabel.Sensitive = _custThemeToggle.Active;
+            _browseThemePath.Sensitive    = _custThemeToggle.Active;
+        }
+
+        private void BrowseThemeDir_Pressed(object sender, EventArgs args)
+        {
+            using (FileChooserNative fileChooser = new FileChooserNative("Choose the theme to load", this, FileChooserAction.Open, "Select", "Cancel"))
+            {
+                FileFilter filter = new FileFilter()
+                {
+                    Name = "Theme Files"
+                };
+                filter.AddPattern("*.css");
+
+                fileChooser.AddFilter(filter);
+
+                if (fileChooser.Run() == (int)ResponseType.Accept)
+                {
+                    _custThemePath.Buffer.Text = fileChooser.Filename;
+                }
+            }
+
+            _browseThemePath.SetStateFlags(StateFlags.Normal, true);
+        }
+
+        private void ConfigureController_Pressed(object sender, PlayerIndex playerIndex)
+        {
+            ((ToggleButton)sender).SetStateFlags(StateFlags.Normal, true);
+
+            ControllerWindow controllerWindow = new ControllerWindow(_parent, playerIndex);
+
+            controllerWindow.SetSizeRequest((int)(controllerWindow.DefaultWidth * Program.WindowScaleFactor), (int)(controllerWindow.DefaultHeight * Program.WindowScaleFactor));
+            controllerWindow.Show();
+        }
+
+        private void VolumeSlider_OnChange(object sender, EventArgs args)
+        {
+            ConfigurationState.Instance.System.AudioVolume.Value = (float)(_audioVolumeSlider.Value / 100);
+        }
+
+        private void SaveToggle_Activated(object sender, EventArgs args)
+        {
+            SaveSettings();
+            Dispose();
+        }
+
+        private void ApplyToggle_Activated(object sender, EventArgs args)
+        {
+            SaveSettings();
+        }
+
+        private void CloseToggle_Activated(object sender, EventArgs args)
+        {
+            ConfigurationState.Instance.System.AudioVolume.Value = _previousVolumeLevel;
+            Dispose();
+        }
+    }
+}

src/Ryujinx/Ui/Windows/TitleUpdateWindow.cs

@@ -0,0 +1,208 @@
+using Gtk;
+using LibHac.Common;
+using LibHac.Fs;
+using LibHac.Fs.Fsa;
+using LibHac.FsSystem;
+using LibHac.Ns;
+using LibHac.Tools.FsSystem;
+using LibHac.Tools.FsSystem.NcaUtils;
+using Ryujinx.Common.Configuration;
+using Ryujinx.Common.Utilities;
+using Ryujinx.HLE.FileSystem;
+using Ryujinx.HLE.HOS;
+using Ryujinx.Ui.App.Common;
+using Ryujinx.Ui.Widgets;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using GUI         = Gtk.Builder.ObjectAttribute;
+using SpanHelpers = LibHac.Common.SpanHelpers;
+
+namespace Ryujinx.Ui.Windows
+{
+    public class TitleUpdateWindow : Window
+    {
+        private readonly MainWindow        _parent;
+        private readonly VirtualFileSystem _virtualFileSystem;
+        private readonly string            _titleId;
+        private readonly string            _updateJsonPath;
+
+        private TitleUpdateMetadata _titleUpdateWindowData;
+
+        private readonly Dictionary<RadioButton, string> _radioButtonToPathDictionary;
+        private static readonly TitleUpdateMetadataJsonSerializerContext SerializerContext = new(JsonHelper.GetDefaultSerializerOptions());
+
+#pragma warning disable CS0649, IDE0044
+        [GUI] Label       _baseTitleInfoLabel;
+        [GUI] Box         _availableUpdatesBox;
+        [GUI] RadioButton _noUpdateRadioButton;
+#pragma warning restore CS0649, IDE0044
+
+        public TitleUpdateWindow(MainWindow parent, VirtualFileSystem virtualFileSystem, string titleId, string titleName) : this(new Builder("Ryujinx.Ui.Windows.TitleUpdateWindow.glade"), parent, virtualFileSystem, titleId, titleName) { }
+
+        private TitleUpdateWindow(Builder builder, MainWindow parent, VirtualFileSystem virtualFileSystem, string titleId, string titleName) : base(builder.GetRawOwnedObject("_titleUpdateWindow"))
+        {
+            _parent = parent;
+
+            builder.Autoconnect(this);
+
+            _titleId                     = titleId;
+            _virtualFileSystem           = virtualFileSystem;
+            _updateJsonPath              = System.IO.Path.Combine(AppDataManager.GamesDirPath, _titleId, "updates.json");
+            _radioButtonToPathDictionary = new Dictionary<RadioButton, string>();
+
+            try
+            {
+                _titleUpdateWindowData = JsonHelper.DeserializeFromFile(_updateJsonPath, SerializerContext.TitleUpdateMetadata);
+            }
+            catch
+            {
+                _titleUpdateWindowData = new TitleUpdateMetadata
+                {
+                    Selected = "",
+                    Paths    = new List<string>()
+                };
+            }
+
+            _baseTitleInfoLabel.Text = $"Updates Available for {titleName} [{titleId.ToUpper()}]";
+            
+            foreach (string path in _titleUpdateWindowData.Paths)
+            {
+                AddUpdate(path);
+            }
+
+            if (_titleUpdateWindowData.Selected == "")
+            {
+                _noUpdateRadioButton.Active = true;
+            }
+            else
+            {
+                foreach ((RadioButton update, var _) in _radioButtonToPathDictionary.Where(keyValuePair => keyValuePair.Value == _titleUpdateWindowData.Selected))
+                {
+                    update.Active = true;
+                }
+            }
+        }
+
+        private void AddUpdate(string path)
+        {
+            if (File.Exists(path))
+            {
+                using (FileStream file = new FileStream(path, FileMode.Open, FileAccess.Read))
+                {
+                    PartitionFileSystem nsp = new PartitionFileSystem(file.AsStorage());
+
+                    try
+                    {
+                        (Nca patchNca, Nca controlNca) = ApplicationLibrary.GetGameUpdateDataFromPartition(_virtualFileSystem, nsp, _titleId, 0);
+
+                        if (controlNca != null && patchNca != null)
+                        {
+                            ApplicationControlProperty controlData = new ApplicationControlProperty();
+
+                            using var nacpFile = new UniqueRef<IFile>();
+
+                            controlNca.OpenFileSystem(NcaSectionType.Data, IntegrityCheckLevel.None).OpenFile(ref nacpFile.Ref, "/control.nacp".ToU8Span(), OpenMode.Read).ThrowIfFailure();
+                            nacpFile.Get.Read(out _, 0, SpanHelpers.AsByteSpan(ref controlData), ReadOption.None).ThrowIfFailure();
+
+                            RadioButton radioButton = new RadioButton($"Version {controlData.DisplayVersionString.ToString()} - {path}");
+                            radioButton.JoinGroup(_noUpdateRadioButton);
+
+                            _availableUpdatesBox.Add(radioButton);
+                            _radioButtonToPathDictionary.Add(radioButton, path);
+
+                            radioButton.Show();
+                            radioButton.Active = true;
+                        }
+                        else
+                        {
+                            GtkDialog.CreateErrorDialog("The specified file does not contain an update for the selected title!");
+                        }
+                    }
+                    catch (Exception exception)
+                    {
+                        GtkDialog.CreateErrorDialog($"{exception.Message}. Errored File: {path}");
+                    }
+                }
+            }
+        }
+
+        private void RemoveUpdates(bool removeSelectedOnly = false)
+        {
+            foreach (RadioButton radioButton in _noUpdateRadioButton.Group)
+            {
+                if (radioButton.Label != "No Update" && (!removeSelectedOnly || radioButton.Active))
+                {
+                    _availableUpdatesBox.Remove(radioButton);
+                    _radioButtonToPathDictionary.Remove(radioButton);
+                    radioButton.Dispose();
+                }
+            }
+        }
+
+        private void AddButton_Clicked(object sender, EventArgs args)
+        {
+            using (FileChooserNative fileChooser = new FileChooserNative("Select update files", this, FileChooserAction.Open, "Add", "Cancel"))
+            {
+                fileChooser.SelectMultiple = true;
+
+                FileFilter filter = new FileFilter()
+                {
+                    Name = "Switch Game Updates"
+                };
+                filter.AddPattern("*.nsp");
+
+                fileChooser.AddFilter(filter);
+
+                if (fileChooser.Run() == (int)ResponseType.Accept)
+                {
+                    foreach (string path in fileChooser.Filenames)
+                    {
+                        AddUpdate(path);
+                    }
+                }
+            }
+        }
+
+        private void RemoveButton_Clicked(object sender, EventArgs args)
+        {
+            RemoveUpdates(true);
+        }
+
+        private void RemoveAllButton_Clicked(object sender, EventArgs args)
+        {
+            RemoveUpdates();
+        }
+
+        private void SaveButton_Clicked(object sender, EventArgs args)
+        {
+            _titleUpdateWindowData.Paths.Clear();
+            _titleUpdateWindowData.Selected = "";
+
+            foreach (string paths in _radioButtonToPathDictionary.Values)
+            {
+                _titleUpdateWindowData.Paths.Add(paths);
+            }
+
+            foreach (RadioButton radioButton in _noUpdateRadioButton.Group)
+            {
+                if (radioButton.Active)
+                {
+                    _titleUpdateWindowData.Selected = _radioButtonToPathDictionary.TryGetValue(radioButton, out string updatePath) ? updatePath : "";
+                }
+            }
+
+            JsonHelper.SerializeToFile(_updateJsonPath, _titleUpdateWindowData, SerializerContext.TitleUpdateMetadata);
+
+            _parent.UpdateGameTable();
+
+            Dispose();
+        }
+
+        private void CancelButton_Clicked(object sender, EventArgs args)
+        {
+            Dispose();
+        }
+    }
+}

src/Ryujinx/Ui/Windows/TitleUpdateWindow.glade

@@ -0,0 +1,214 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Generated with glade 3.36.0 -->
+<interface>
+  <requires lib="gtk+" version="3.20"/>
+  <object class="GtkWindow" id="_titleUpdateWindow">
+    <property name="can_focus">False</property>
+    <property name="title" translatable="yes">Ryujinx - Title Update Manager</property>
+    <property name="modal">True</property>
+    <property name="window_position">center</property>
+    <property name="default_width">550</property>
+    <property name="default_height">250</property>
+    <child>
+      <object class="GtkBox" id="MainBox">
+        <property name="visible">True</property>
+        <property name="can_focus">False</property>
+        <property name="orientation">vertical</property>
+        <child>
+          <object class="GtkBox" id="UpdatesBox">
+            <property name="visible">True</property>
+            <property name="can_focus">False</property>
+            <property name="orientation">vertical</property>
+            <child>
+              <object class="GtkLabel" id="_baseTitleInfoLabel">
+                <property name="visible">True</property>
+                <property name="can_focus">False</property>
+                <property name="margin_left">10</property>
+                <property name="margin_right">10</property>
+                <property name="margin_top">10</property>
+                <property name="margin_bottom">10</property>
+                <property name="label" translatable="yes">Available Updates</property>
+              </object>
+              <packing>
+                <property name="expand">False</property>
+                <property name="fill">True</property>
+                <property name="position">0</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkScrolledWindow">
+                <property name="visible">True</property>
+                <property name="can_focus">True</property>
+                <property name="margin_left">10</property>
+                <property name="margin_right">10</property>
+                <property name="shadow_type">in</property>
+                <child>
+                  <object class="GtkViewport">
+                    <property name="visible">True</property>
+                    <property name="can_focus">False</property>
+                    <child>
+                      <object class="GtkBox" id="_availableUpdatesBox">
+                        <property name="visible">True</property>
+                        <property name="can_focus">False</property>
+                        <property name="orientation">vertical</property>
+                        <child>
+                          <object class="GtkRadioButton" id="_noUpdateRadioButton">
+                            <property name="label" translatable="yes">No Update</property>
+                            <property name="visible">True</property>
+                            <property name="can_focus">True</property>
+                            <property name="receives_default">False</property>
+                            <property name="active">True</property>
+                            <property name="draw_indicator">True</property>
+                          </object>
+                          <packing>
+                            <property name="expand">False</property>
+                            <property name="fill">True</property>
+                            <property name="position">0</property>
+                          </packing>
+                        </child>
+                      </object>
+                    </child>
+                  </object>
+                </child>
+              </object>
+              <packing>
+                <property name="expand">True</property>
+                <property name="fill">True</property>
+                <property name="position">1</property>
+              </packing>
+            </child>
+          </object>
+          <packing>
+            <property name="expand">True</property>
+            <property name="fill">True</property>
+            <property name="position">0</property>
+          </packing>
+        </child>
+        <child>
+          <object class="GtkBox">
+            <property name="visible">True</property>
+            <property name="can_focus">False</property>
+            <child>
+              <object class="GtkButtonBox">
+                <property name="visible">True</property>
+                <property name="can_focus">False</property>
+                <property name="margin_top">10</property>
+                <property name="margin_bottom">10</property>
+                <property name="layout_style">start</property>
+                <child>
+                  <object class="GtkButton" id="_addUpdate">
+                    <property name="label" translatable="yes">Add</property>
+                    <property name="visible">True</property>
+                    <property name="can_focus">True</property>
+                    <property name="receives_default">True</property>
+                    <property name="tooltip_text" translatable="yes">Adds an update to this list</property>
+                    <property name="margin_left">10</property>
+                    <signal name="clicked" handler="AddButton_Clicked" swapped="no"/>
+                  </object>
+                  <packing>
+                    <property name="expand">True</property>
+                    <property name="fill">True</property>
+                    <property name="position">0</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkButton" id="_removeUpdate">
+                    <property name="label" translatable="yes">Remove</property>
+                    <property name="visible">True</property>
+                    <property name="can_focus">True</property>
+                    <property name="receives_default">True</property>
+                    <property name="tooltip_text" translatable="yes">Removes the selected update</property>
+                    <property name="margin_left">10</property>
+                    <signal name="clicked" handler="RemoveButton_Clicked" swapped="no"/>
+                  </object>
+                  <packing>
+                    <property name="expand">True</property>
+                    <property name="fill">True</property>
+                    <property name="position">1</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkButton" id="_removeAllButton">
+                    <property name="label" translatable="yes">Remove All</property>
+                    <property name="visible">True</property>
+                    <property name="can_focus">True</property>
+                    <property name="receives_default">True</property>
+                    <property name="tooltip_text" translatable="yes">Removes the selected update</property>
+                    <property name="margin_left">10</property>
+                    <signal name="clicked" handler="RemoveAllButton_Clicked" swapped="no"/>
+                  </object>
+                  <packing>
+                    <property name="expand">True</property>
+                    <property name="fill">True</property>
+                    <property name="position">2</property>
+                  </packing>
+                </child>
+              </object>
+              <packing>
+                <property name="expand">True</property>
+                <property name="fill">True</property>
+                <property name="position">0</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkButtonBox">
+                <property name="visible">True</property>
+                <property name="can_focus">False</property>
+                <property name="margin_top">10</property>
+                <property name="margin_bottom">10</property>
+                <property name="layout_style">end</property>
+                <child>
+                  <object class="GtkButton" id="_saveButton">
+                    <property name="label" translatable="yes">Save</property>
+                    <property name="visible">True</property>
+                    <property name="can_focus">True</property>
+                    <property name="receives_default">True</property>
+                    <property name="margin_right">10</property>
+                    <property name="margin_top">2</property>
+                    <property name="margin_bottom">2</property>
+                    <signal name="clicked" handler="SaveButton_Clicked" swapped="no"/>
+                  </object>
+                  <packing>
+                    <property name="expand">True</property>
+                    <property name="fill">True</property>
+                    <property name="position">0</property>
+                  </packing>
+                </child>
+                <child>
+                  <object class="GtkButton" id="_cancelButton">
+                    <property name="label" translatable="yes">Cancel</property>
+                    <property name="visible">True</property>
+                    <property name="can_focus">True</property>
+                    <property name="receives_default">True</property>
+                    <property name="margin_right">10</property>
+                    <property name="margin_top">2</property>
+                    <property name="margin_bottom">2</property>
+                    <signal name="clicked" handler="CancelButton_Clicked" swapped="no"/>
+                  </object>
+                  <packing>
+                    <property name="expand">True</property>
+                    <property name="fill">True</property>
+                    <property name="position">1</property>
+                  </packing>
+                </child>
+              </object>
+              <packing>
+                <property name="expand">True</property>
+                <property name="fill">True</property>
+                <property name="position">1</property>
+              </packing>
+            </child>
+          </object>
+          <packing>
+            <property name="expand">False</property>
+            <property name="fill">True</property>
+            <property name="position">1</property>
+          </packing>
+        </child>
+      </object>
+    </child>
+    <child type="titlebar">
+      <placeholder/>
+    </child>
+  </object>
+</interface>

src/Ryujinx/Ui/Windows/UserProfilesManagerWindow.Designer.cs

@@ -0,0 +1,256 @@
+using Gtk;
+using Pango;
+
+namespace Ryujinx.Ui.Windows
+{
+    public partial class UserProfilesManagerWindow : Window
+    {
+        private Box            _mainBox;
+        private Label          _selectedLabel;
+        private Box            _selectedUserBox;
+        private Image          _selectedUserImage;
+        private VBox           _selectedUserInfoBox;
+        private Entry          _selectedUserNameEntry;
+        private Label          _selectedUserIdLabel;
+        private VBox           _selectedUserButtonsBox;
+        private Button         _saveProfileNameButton;
+        private Button         _changeProfileImageButton;
+        private Box            _usersTreeViewBox;
+        private Label          _availableUsersLabel;
+        private ScrolledWindow _usersTreeViewWindow;
+        private ListStore      _tableStore;
+        private TreeView       _usersTreeView;
+        private Box            _bottomBox;
+        private Button         _addButton;
+        private Button         _deleteButton;
+        private Button         _closeButton;
+
+        private void InitializeComponent()
+        {
+
+#pragma warning disable CS0612
+
+            //
+            // UserProfilesManagerWindow
+            //
+            CanFocus       = false;
+            Resizable      = false;
+            Modal          = true;
+            WindowPosition = WindowPosition.Center;
+            DefaultWidth   = 620;
+            DefaultHeight  = 548;
+            TypeHint       = Gdk.WindowTypeHint.Dialog;
+
+            //
+            // _mainBox
+            //
+            _mainBox = new Box(Orientation.Vertical, 0);
+
+            //
+            // _selectedLabel
+            //
+            _selectedLabel = new Label("Selected User Profile:")
+            {
+                Margin     = 15,
+                Attributes = new AttrList(),
+                Halign     = Align.Start
+            };
+            _selectedLabel.Attributes.Insert(new Pango.AttrWeight(Weight.Bold));
+
+            //
+            // _viewBox
+            //
+            _usersTreeViewBox = new Box(Orientation.Vertical, 0);
+
+            //
+            // _SelectedUserBox
+            //
+            _selectedUserBox = new Box(Orientation.Horizontal, 0)
+            {
+                MarginLeft = 30
+            };
+
+            //
+            // _selectedUserImage
+            //
+            _selectedUserImage = new Image();
+
+            //
+            // _selectedUserInfoBox
+            //
+            _selectedUserInfoBox = new VBox(true, 0);
+
+            //
+            // _selectedUserNameEntry
+            //
+            _selectedUserNameEntry = new Entry("")
+            {
+                MarginLeft = 15,
+                MaxLength  = (int)MaxProfileNameLength
+            };
+            _selectedUserNameEntry.KeyReleaseEvent += SelectedUserNameEntry_KeyReleaseEvent;
+
+            //
+            // _selectedUserIdLabel
+            //
+            _selectedUserIdLabel = new Label("")
+            {
+                MarginTop  = 15,
+                MarginLeft = 15
+            };
+
+            //
+            // _selectedUserButtonsBox
+            //
+            _selectedUserButtonsBox = new VBox()
+            {
+                MarginRight = 30
+            };
+
+            //
+            // _saveProfileNameButton
+            //
+            _saveProfileNameButton = new Button()
+            {
+                Label           = "Save Profile Name",
+                CanFocus        = true,
+                ReceivesDefault = true,
+                Sensitive       = false
+            };
+            _saveProfileNameButton.Clicked += EditProfileNameButton_Pressed;
+
+            //
+            // _changeProfileImageButton
+            //
+            _changeProfileImageButton = new Button()
+            {
+                Label           = "Change Profile Image",
+                CanFocus        = true,
+                ReceivesDefault = true,
+                MarginTop       = 10
+            };
+            _changeProfileImageButton.Clicked += ChangeProfileImageButton_Pressed;
+
+            //
+            // _availableUsersLabel
+            //
+            _availableUsersLabel = new Label("Available User Profiles:")
+            {
+                Margin     = 15,
+                Attributes = new AttrList(),
+                Halign     = Align.Start
+            };
+            _availableUsersLabel.Attributes.Insert(new Pango.AttrWeight(Weight.Bold));
+
+            //
+            // _usersTreeViewWindow
+            //
+            _usersTreeViewWindow = new ScrolledWindow()
+            {
+                ShadowType   = ShadowType.In,
+                CanFocus     = true,
+                Expand       = true,
+                MarginLeft   = 30,
+                MarginRight  = 30,
+                MarginBottom = 15
+            };
+
+            //
+            // _tableStore
+            //
+            _tableStore = new ListStore(typeof(bool), typeof(Gdk.Pixbuf), typeof(string), typeof(Gdk.RGBA));
+
+            //
+            // _usersTreeView
+            //
+            _usersTreeView = new TreeView(_tableStore)
+            {
+                HoverSelection = true,
+                HeadersVisible = false,
+            };
+            _usersTreeView.RowActivated += UsersTreeView_Activated;
+
+            //
+            // _bottomBox
+            //
+            _bottomBox = new Box(Orientation.Horizontal, 0)
+            {
+                MarginLeft   = 30,
+                MarginRight  = 30,
+                MarginBottom = 15
+            };
+
+            //
+            // _addButton
+            //
+            _addButton = new Button()
+            {
+                Label           = "Add New Profile",
+                CanFocus        = true,
+                ReceivesDefault = true,
+                HeightRequest   = 35
+            };
+            _addButton.Clicked += AddButton_Pressed;
+
+            //
+            // _deleteButton
+            //
+            _deleteButton = new Button()
+            {
+                Label           = "Delete Selected Profile",
+                CanFocus        = true,
+                ReceivesDefault = true,
+                HeightRequest   = 35,
+                MarginLeft      = 10
+            };
+            _deleteButton.Clicked += DeleteButton_Pressed;
+
+            //
+            // _closeButton
+            //
+            _closeButton = new Button()
+            {
+                Label           = "Close",
+                CanFocus        = true,
+                ReceivesDefault = true,
+                HeightRequest   = 35,
+                WidthRequest    = 80
+            };
+            _closeButton.Clicked += CloseButton_Pressed;
+
+#pragma warning restore CS0612
+
+            ShowComponent();
+        }
+
+        private void ShowComponent()
+        {
+            _usersTreeViewWindow.Add(_usersTreeView);
+
+            _usersTreeViewBox.Add(_usersTreeViewWindow);
+            _bottomBox.PackStart(_addButton, false, false, 0);
+            _bottomBox.PackStart(_deleteButton, false, false, 0);
+            _bottomBox.PackEnd(_closeButton, false, false, 0);
+
+            _selectedUserInfoBox.Add(_selectedUserNameEntry);
+            _selectedUserInfoBox.Add(_selectedUserIdLabel);
+
+            _selectedUserButtonsBox.Add(_saveProfileNameButton);
+            _selectedUserButtonsBox.Add(_changeProfileImageButton);
+
+            _selectedUserBox.Add(_selectedUserImage);
+            _selectedUserBox.PackStart(_selectedUserInfoBox, false, false, 0);
+            _selectedUserBox.PackEnd(_selectedUserButtonsBox, false, false, 0);
+
+            _mainBox.PackStart(_selectedLabel, false, false, 0);
+            _mainBox.PackStart(_selectedUserBox, false, true, 0);
+            _mainBox.PackStart(_availableUsersLabel, false, false, 0);
+            _mainBox.Add(_usersTreeViewBox);
+            _mainBox.Add(_bottomBox);
+
+            Add(_mainBox);
+
+            ShowAll();
+        }
+    }
+}

src/Ryujinx/Ui/Windows/UserProfilesManagerWindow.cs

@@ -0,0 +1,331 @@
+using Gtk;
+using Ryujinx.Common.Memory;
+using Ryujinx.HLE.FileSystem;
+using Ryujinx.HLE.HOS.Services.Account.Acc;
+using Ryujinx.Ui.Common.Configuration;
+using Ryujinx.Ui.Widgets;
+using SixLabors.ImageSharp;
+using SixLabors.ImageSharp.Processing;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Reflection;
+using System.Threading;
+using System.Threading.Tasks;
+using Image = SixLabors.ImageSharp.Image;
+using UserId = Ryujinx.HLE.HOS.Services.Account.Acc.UserId;
+
+namespace Ryujinx.Ui.Windows
+{
+    public partial class UserProfilesManagerWindow : Window
+    {
+        private const uint MaxProfileNameLength = 0x20;
+
+        private readonly AccountManager _accountManager;
+        private readonly ContentManager _contentManager;
+
+        private byte[] _bufferImageProfile;
+        private string _tempNewProfileName;
+
+        private Gdk.RGBA _selectedColor;
+
+        private ManualResetEvent _avatarsPreloadingEvent = new ManualResetEvent(false);
+
+        public UserProfilesManagerWindow(AccountManager accountManager, ContentManager contentManager, VirtualFileSystem virtualFileSystem) : base($"Ryujinx {Program.Version} - Manage User Profiles")
+        {
+            Icon = new Gdk.Pixbuf(Assembly.GetAssembly(typeof(ConfigurationState)), "Ryujinx.Ui.Common.Resources.Logo_Ryujinx.png");
+
+            InitializeComponent();
+
+            _selectedColor.Red   = 0.212;
+            _selectedColor.Green = 0.843;
+            _selectedColor.Blue  = 0.718;
+            _selectedColor.Alpha = 1;
+
+            _accountManager = accountManager;
+            _contentManager = contentManager;
+
+            CellRendererToggle userSelectedToggle = new CellRendererToggle();
+            userSelectedToggle.Toggled += UserSelectedToggle_Toggled;
+
+            // NOTE: Uncomment following line when multiple selection of user profiles is supported.
+            //_usersTreeView.AppendColumn("Selected",  userSelectedToggle,       "active", 0);
+            _usersTreeView.AppendColumn("User Icon", new CellRendererPixbuf(), "pixbuf", 1);
+            _usersTreeView.AppendColumn("User Info", new CellRendererText(),   "text",   2, "background-rgba", 3);
+
+            _tableStore.SetSortColumnId(0, SortType.Descending);
+            
+            RefreshList();
+
+            if (_contentManager.GetCurrentFirmwareVersion() != null)
+            {
+                Task.Run(() =>
+                {
+                    AvatarWindow.PreloadAvatars(contentManager, virtualFileSystem);
+                    _avatarsPreloadingEvent.Set();
+                });
+            }
+        }
+
+        public void RefreshList()
+        {
+            _tableStore.Clear();
+
+            foreach (UserProfile userProfile in _accountManager.GetAllUsers())
+            {
+                _tableStore.AppendValues(userProfile.AccountState == AccountState.Open, new Gdk.Pixbuf(userProfile.Image, 96, 96), $"{userProfile.Name}\n{userProfile.UserId}", Gdk.RGBA.Zero);
+
+                if (userProfile.AccountState == AccountState.Open)
+                {
+                    _selectedUserImage.Pixbuf   = new Gdk.Pixbuf(userProfile.Image, 96, 96);
+                    _selectedUserIdLabel.Text   = userProfile.UserId.ToString();
+                    _selectedUserNameEntry.Text = userProfile.Name;
+
+                    _deleteButton.Sensitive = userProfile.UserId != AccountManager.DefaultUserId;
+
+                    _usersTreeView.Model.GetIterFirst(out TreeIter firstIter);
+                    _tableStore.SetValue(firstIter, 3, _selectedColor);
+                }
+            }
+        }
+
+        //
+        // Events
+        //
+
+        private void UsersTreeView_Activated(object o, RowActivatedArgs args)
+        {
+            SelectUserTreeView();
+        }
+
+        private void UserSelectedToggle_Toggled(object o, ToggledArgs args)
+        {
+            SelectUserTreeView();
+        }
+
+        private void SelectUserTreeView()
+        {
+            // Get selected item informations.
+            _usersTreeView.Selection.GetSelected(out TreeIter selectedIter);
+
+            Gdk.Pixbuf userPicture = (Gdk.Pixbuf)_tableStore.GetValue(selectedIter, 1);
+
+            string userName = _tableStore.GetValue(selectedIter, 2).ToString().Split("\n")[0];
+            string userId   = _tableStore.GetValue(selectedIter, 2).ToString().Split("\n")[1];
+
+            // Unselect the first user.
+            _usersTreeView.Model.GetIterFirst(out TreeIter firstIter);
+            _tableStore.SetValue(firstIter, 0, false);
+            _tableStore.SetValue(firstIter, 3, Gdk.RGBA.Zero);
+
+            // Set new informations.
+            _tableStore.SetValue(selectedIter, 0, true);
+
+            _selectedUserImage.Pixbuf        = userPicture;
+            _selectedUserNameEntry.Text      = userName;
+            _selectedUserIdLabel.Text        = userId;
+            _saveProfileNameButton.Sensitive = false;
+
+            // Open the selected one.
+            _accountManager.OpenUser(new UserId(userId));
+
+            _deleteButton.Sensitive = userId != AccountManager.DefaultUserId.ToString();
+
+            _tableStore.SetValue(selectedIter, 3, _selectedColor);
+        }
+
+        private void SelectedUserNameEntry_KeyReleaseEvent(object o, KeyReleaseEventArgs args)
+        {
+            if (_saveProfileNameButton.Sensitive == false)
+            {
+                _saveProfileNameButton.Sensitive = true;
+            }
+        }
+
+        private void AddButton_Pressed(object sender, EventArgs e)
+        {
+            _tempNewProfileName = GtkDialog.CreateInputDialog(this, "Choose the Profile Name", "Please Enter a Profile Name", MaxProfileNameLength);
+
+            if (_tempNewProfileName != "")
+            {
+                SelectProfileImage(true);
+
+                if (_bufferImageProfile != null)
+                {
+                    AddUser();
+                }
+            }
+        }
+
+        private void DeleteButton_Pressed(object sender, EventArgs e)
+        {
+            if (GtkDialog.CreateChoiceDialog("Delete User Profile", "Are you sure you want to delete the profile ?", "Deleting this profile will also delete all associated save data."))
+            {
+                _accountManager.DeleteUser(GetSelectedUserId());
+
+                RefreshList();
+            }
+        }
+
+        private void EditProfileNameButton_Pressed(object sender, EventArgs e)
+        {
+            _saveProfileNameButton.Sensitive = false;
+
+            _accountManager.SetUserName(GetSelectedUserId(), _selectedUserNameEntry.Text);
+
+            RefreshList();
+        }
+
+        private void ProcessProfileImage(byte[] buffer)
+        {
+            using (Image image = Image.Load(buffer))
+            {
+                image.Mutate(x => x.Resize(256, 256));
+
+                using (MemoryStream streamJpg = MemoryStreamManager.Shared.GetStream())
+                {
+                    image.SaveAsJpeg(streamJpg);
+
+                    _bufferImageProfile = streamJpg.ToArray();
+                }
+            }
+        }
+
+        private void ProfileImageFileChooser()
+        {
+            FileChooserNative fileChooser = new FileChooserNative("Import Custom Profile Image", this, FileChooserAction.Open, "Import", "Cancel")
+            {
+                SelectMultiple = false
+            };
+
+            FileFilter filter = new FileFilter()
+            {
+                Name = "Custom Profile Images"
+            };
+            filter.AddPattern("*.jpg");
+            filter.AddPattern("*.jpeg");
+            filter.AddPattern("*.png");
+            filter.AddPattern("*.bmp");
+
+            fileChooser.AddFilter(filter);
+
+            if (fileChooser.Run() == (int)ResponseType.Accept)
+            {
+                ProcessProfileImage(File.ReadAllBytes(fileChooser.Filename));
+            }
+
+            fileChooser.Dispose();
+        }
+
+        private void SelectProfileImage(bool newUser = false)
+        {
+            if (_contentManager.GetCurrentFirmwareVersion() == null)
+            {
+                ProfileImageFileChooser();
+            }
+            else
+            {
+                Dictionary<int, string> buttons = new Dictionary<int, string>()
+                {
+                    { 0, "Import Image File"      },
+                    { 1, "Select Firmware Avatar" }
+                };
+
+                ResponseType responseDialog = GtkDialog.CreateCustomDialog("Profile Image Selection",
+                                                                           "Choose a Profile Image",
+                                                                           "You may import a custom profile image, or select an avatar from the system firmware.", 
+                                                                           buttons, MessageType.Question);
+
+                if (responseDialog == 0)
+                {
+                    ProfileImageFileChooser();
+                }
+                else if (responseDialog == (ResponseType)1)
+                {
+                    AvatarWindow avatarWindow = new AvatarWindow()
+                    {
+                        NewUser = newUser
+                    };
+
+                    avatarWindow.DeleteEvent += AvatarWindow_DeleteEvent;
+
+                    avatarWindow.SetSizeRequest((int)(avatarWindow.DefaultWidth * Program.WindowScaleFactor), (int)(avatarWindow.DefaultHeight * Program.WindowScaleFactor));
+                    avatarWindow.Show();
+                }
+            }
+        }
+
+        private void ChangeProfileImageButton_Pressed(object sender, EventArgs e)
+        {
+            if (_contentManager.GetCurrentFirmwareVersion() != null)
+            {
+                _avatarsPreloadingEvent.WaitOne();
+            }
+
+            SelectProfileImage();
+
+            if (_bufferImageProfile != null)
+            {
+                SetUserImage();
+            }
+        }
+
+        private void AvatarWindow_DeleteEvent(object sender, DeleteEventArgs args)
+        {
+            _bufferImageProfile = ((AvatarWindow)sender).SelectedProfileImage;
+
+            if (_bufferImageProfile != null)
+            {
+                if (((AvatarWindow)sender).NewUser)
+                {
+                    AddUser();
+                }
+                else
+                {
+                    SetUserImage();
+                }
+            }
+        }
+
+        private void AddUser()
+        {
+            _accountManager.AddUser(_tempNewProfileName, _bufferImageProfile);
+
+            _bufferImageProfile = null;
+            _tempNewProfileName = "";
+
+            RefreshList();
+        }
+
+        private void SetUserImage()
+        {
+            _accountManager.SetUserImage(GetSelectedUserId(), _bufferImageProfile);
+
+            _bufferImageProfile = null;
+
+            RefreshList();
+        }
+
+        private UserId GetSelectedUserId()
+        {
+            if (_usersTreeView.Model.GetIterFirst(out TreeIter iter))
+            {
+                do
+                {
+                    if ((bool)_tableStore.GetValue(iter, 0))
+                    {
+                        break;
+                    }
+                }
+                while (_usersTreeView.Model.IterNext(ref iter));
+            }
+
+            return new UserId(_tableStore.GetValue(iter, 2).ToString().Split("\n")[1]);
+        }
+
+        private void CloseButton_Pressed(object sender, EventArgs e)
+        {
+            Close();
+        }
+    }
+}