fix freeze if the usb menu is closed whilst a usb cable is not connected, 0.9.0 -> 0.9.1

bump version for new release 0.8.2 -> 0.9.0
reduce usb install exit latency by waiting on a cancel uevent, rather than relying on a timeout.
2025-05-03 21:15:21 +01:00 · 2025-05-03 18:01:49 +01:00 · 2025-05-03 17:17:53 +01:00 · 2025-05-03 15:30:40 +01:00 · 2025-05-03 15:08:25 +01:00 · 2025-05-03 14:39:20 +01:00
58 changed files with 2461 additions and 2075 deletions
--- a/README.md
+++ b/README.md
@@ -49,6 +49,40 @@ The `path` field is optional. If left out, it will use the name of the ini to fi

 See `assets/romfs/assoc/` for more examples of file assoc entries.

+## Installing (applications)
+
+Sphaira can install applications (nsp, xci, nsz, xcz) from various sources (sd card, gamecard, ftp, usb).
+
+For informantion about the install options, [see the wiki](https://github.com/ITotalJustice/sphaira/wiki/Install).
+
+### Usb (install)
+
+The USB protocol is the same as tinfoil, so tools such as [ns-usbloader](https://github.com/developersu/ns-usbloader) and [fluffy](https://github.com/fourminute/Fluffy) should work with sphaira. You may also use the provided python script found [here](tools/usb_install_pc.py).
+
+### Ftp (install)
+
+Once you have connected your ftp client to your switch, you can upload files to install into the `install` folder.
+
+## Building from source
+
+You will first need to install [devkitPro](https://devkitpro.org/wiki/Getting_Started).
+
+Next you will need to install the dependencies:
+```sh
+sudo pacman -S switch-dev deko3d switch-cmake switch-curl switch-glm switch-zlib
+```
+
+Once devkitPro and all dependencies are installed, you can now build sphaira.
+
+```sh
+git clone https://github.com/ITotalJustice/sphaira.git
+cd sphaira
+cmake --preset MinSizeRel
+cmake --build --preset MinSizeRel
+```
+
+The output will be found in `build/MinSizeRel/sphaira.nro`
+
 ## Credits

 - borealis
--- a/assets/romfs/i18n/de.json
+++ b/assets/romfs/i18n/de.json
@@ -1,21 +1,21 @@
 {
-  "[Applet Mode]": "[Applet-Modus]",
-  "No Internet": "Keine Internetverbindung",
+  "[Applet Mode]": "   | Applet Modus |",
+  "No Internet": "Kein Internet",
  "Files": "Dateien",
-  "Apps": "Apps",
-  "Store": "Store",
+  "Apps": "hb-Apps",
+  "Store": "hb-Store",
  "Menu": "Menü",
  "Options": "Optionen",
  "OK": "OK",
  "Back": "Zurück",
  "Select": "Auswählen",
-  "Open": "Öffnen",
-  "Launch": "Starten",
+  "Open": "Öffne",
+  "Launch": "Starte",
  "Info": "Info",
  "Install": "Installieren",
  "Delete": "Löschen",
  "Restart": "Neustart",
-  "Changelog": "Changelog",
+  "Changelog": "Neuerungen",
  "Details": "Details",
  "Update": "Update",
  "Remove": "Entfernen",
@@ -23,62 +23,62 @@
  "Download": "Download",
  "Next Page": "Nächste Seite",
  "Prev Page": "Vorherige Seite",
-  "Unstar": "Favorit entfernen",
+  "Unstar": "Kein Favorit",
  "Star": "Favorit",
-  "System memory": "System-Speicher",
-  "microSD card": "microSD-Karte",
-  "Sd": "SD",
-  "Image System memory": "System-Speicher Bild",
-  "Image microSD card": "microSD-Karten Bild",
-  "Slow": "Langsam",
-  "Normal": "Normal",
-  "Fast": "Schnell",
+  "System memory": "NAND Systemspeicher",
+  "microSD card": "SD-Karte",
+  "Sd": "SD-Karte | Root-Verzeichnis",
+  "Image System memory": "Album | NAND Systemspeicher",
+  "Image microSD card": "Album | SD-Karte",
+  "Slow": "Niedrig",
+  "Normal": "Mittel",
+  "Fast": "Hoch",
  "Yes": "Ja",
  "No": "Nein",
-  "Enabled": "Aktiviert",
-  "Disabled": "Deaktiviert",
+  "Enabled": "An",
+  "Disabled": "Aus",

-  "Sort By": "Sortieren nach",
-  "Sort Options": "Sortieroptionen",
-  "Filter": "Filter",
-  "Sort": "Sortieren",
-  "Order": "Reihenfolge",
+  "Sort By": "Sortierung",
+  "Sort Options": " Sortierung | Optionen",
+  "Filter": "Rubrik",
+  "Sort": "Sortiert nach",
+  "Order": "Anordnung",
  "Search": "Suchen",
-  "Updated": "Aktualisiert",
-  "Updated (Star)": "Aktualisiert (Favoriten)",
+  "Updated": "zuletzt aktualisiert",
+  "Updated (Star)": "Favorit | zuletzt aktualisiert",
  "Downloads": "Downloads",
  "Size": "Größe",
-  "Size (Star)": "Größe (Favoriten)",
-  "Alphabetical": "Alphabetisch",
-  "Alphabetical (Star)": "Alphabetisch (Favoriten)",
-  "Likes": "Likes",
-  "ID": "ID",
-  "Descending": "Absteigend",
-  "Descending (down)": "Absteigend",
-  "Desc": "Abst.",
-  "Ascending": "Aufsteigend",
-  "Ascending (Up)": "Aufsteigend",
-  "Asc": "Aufst.",
+  "Size (Star)": "Favorit | Größe",
+  "Alphabetical": "Name",
+  "Alphabetical (Star)": "Favorit | Name",
+  "Likes": "Beliebtheit",
+  "ID": "Theme | Paket ID",
+  "Descending": "Absteigend ↓",
+  "Descending (down)": "Absteigend ↓",
+  "Desc": " ↓",
+  "Ascending": "Aufsteigend ↑",
+  "Ascending (Up)": "Aufsteigend ↑",
+  "Asc": " ↑",

-  "Menu Options": "Menü-Optionen",
-  "Theme": "Theme",
-  "Theme Options": "Theme-Optionen",
-  "Select Theme": "Theme auswählen",
+  "Menu Options": " Menü | Optionen",
+  "Theme": "Themes",
+  "Theme Options": " Themes | Optionen",
+  "Select Theme": "Theme wählen",
  "Shuffle": "Zufällig",
  "Music": "Musik",
-  "12 Hour Time": "",
-  "Network": "Netzwerk",
-  "Network Options": "Netzwerk-Optionen",
+  "12 Hour Time": "12-Std Zeitformat",
+  "Network": "Konnektivität",
+  "Network Options": "Konnektivität | Optionen",
  "Ftp": "FTP",
  "Mtp": "MTP",
-  "Nxlink": "Nxlink",
-  "Nxlink Connected": "Nxlink verbunden",
-  "Nxlink Upload": "Nxlink Upload",
-  "Nxlink Finished": "Nxlink abgeschlossen",
-  "Switch-Handheld!": "Switch-Handheld!",
-  "Switch-Docked!": "Switch-Dock-Modus!",
+  "Nxlink": "NXLink",
+  "Nxlink Connected": "NXLink | Verbunden",
+  "Nxlink Upload": "NXLink | wird hochgeladen...",
+  "Nxlink Finished": "NXLink | Hochladen beendet",
+  "Switch-Handheld!": "Handheld!",
+  "Switch-Docked!": "Angedockt!",
  "Language": "Sprache",
-  "Auto": "Auto",
+  "Auto": "Systemsprache",
  "English": "English",
  "Japanese": "日本語",
  "French": "Français",
@@ -87,55 +87,55 @@
  "Spanish": "Español",
  "Chinese": "中文",
  "Korean": "한국어",
-  "Dutch": "Dutch",
+  "Dutch": "Nederlands",
  "Portuguese": "Português",
  "Russian": "Русский",
  "Swedish": "Svenska",
-  "Vietnamese": "Vietnamese",
-  "Logging": "Logging",
-  "Replace hbmenu on exit": "hbmenu beim Beenden ersetzen",
-  "Misc": "Sonstiges",
-  "Misc Options": "Weitere Optionen",
-  "Web": "Web",
+  "Vietnamese": "tiếng Việt",
+  "Logging": "Protokollieren",
+  "Replace hbmenu on exit": "hbmenu durch sphaira ersetzen",
+  "Misc": "Extras",
+  "Misc Options": " Extras | Optionen",
+  "Web": "WEB Browser",
  "Install forwarders": "Forwarder installieren",
-  "Install location": "Installationsort",
-  "Show install warning": "Installationswarnung anzeigen",
-  "Text scroll speed": "Textlaufgeschwindigkeit",
+  "Install location": "Einhängepunkt",
+  "Show install warning": "Warnungen anzeigen",
+  "Text scroll speed": "Laufschrift Tempo",

-  "FileBrowser": "Datei-Browser",
+  "FileBrowser": "Datei-Manager",
  "%zd files": "%zd Dateien",
  "%zd dirs": "%zd Ordner",
-  "File Options": "Datei-Optionen",
-  "Show Hidden": "Versteckte anzeigen",
+  "File Options": "Datei - Ordner | Optionen",
+  "Show Hidden": "Versteckte zeigen",
  "Folders First": "Ordner zuerst",
  "Hidden Last": "Versteckte zuletzt",
  "Cut": "Ausschneiden",
  "Copy": "Kopieren",
  "Paste": "Einfügen",
-  "Paste ": "Einfügen ",
-  " file(s)?": " Datei(en)?",
+  "Paste ": "Einfügen von: ",
+  " file(s)?": " Datei/en?",
  "Rename": "Umbenennen",
-  "Set New File Name": "Neuen Dateinamen eingeben",
-  "Advanced": "Erweitert",
-  "Advanced Options": "Erweiterte Optionen",
-  "Create File": "Datei erstellen",
-  "Set File Name": "Dateinamen eingeben",
-  "Create Folder": "Ordner erstellen",
-  "Set Folder Name": "Ordnernamen eingeben",
-  "View as text (unfinished)": "Als Text anzeigen (Beta)",
-  "Ignore read only": "Schreibschutz ignorieren",
-  "Mount": "Einbinden",
-  "Empty...": "Leer...",
-  "Open with DayBreak?": "Mit DayBreak öffnen?",
-  "Launch ": "Starten ",
-  "Launch option for: ": "Startoption für: ",
-  "Select launcher for: ": "Launcher auswählen für: ",
+  "Set New File Name": "Neuen Dateinamen festlegen",
+  "Advanced": "Erweitert...",
+  "Advanced Options": " Erweitert | Optionen",
+  "Create File": "Neue Datei",
+  "Set File Name": "Dateiname festlegen",
+  "Create Folder": "Neuer Ordner",
+  "Set Folder Name": "Ordner umbenennen",
+  "View as text (unfinished)": "Als Text anzeigen",
+  "Ignore read only": "Schreibschutz umgehen?",
+  "Mount": "Einhängen",
+  "Empty...": "Keine Daten...",
+  "Open with DayBreak?": "Mit Daybreak öffnen?",
+  "Launch ": "Starte ",
+  "Launch option for: ": "Start Option für: ",
+  "Select launcher for: ": "Wähle Launcher für: ",

-  "Homebrew": "Homebrew",
-  "Homebrew Options": "Homebrew-Optionen",
-  "Hide Sphaira": "Sphaira ausblenden",
+  "Homebrew": "hbmenu",
+  "Homebrew Options": " hbmenu | Optionen",
+  "Hide Sphaira": "Verstecke sphaira",
  "Install Forwarder": "Forwarder installieren",
-  "WARNING: Installing forwarders will lead to a ban!": "WARNUNG: Installation von Forwardern führt zum Ban!",
+  "WARNING: Installing forwarders will lead to a ban!": "Installiere Forwarder-NSP´s mit VORSICHT.\nEs erhöht das Risiko eines Konsolen-Banns!",
  "Installing Forwarder": "Installiere Forwarder",
  "Creating Program": "Erstelle Programm",
  "Creating Control": "Erstelle Control",
@@ -144,26 +144,26 @@
  "Updating ncm databse": "Aktualisiere NCM-Datenbank",
  "Pushing application record": "Übertrage Anwendungsdaten",
  "Installed!": "Installiert!",
-  "Failed to install forwarder": "Forwarder-Installation fehlgeschlagen",
+  "Failed to install forwarder": "Fehler beim installieren des Forwarders",
  "Unstarred ": "Favorit entfernt ",
-  "Starred ": "Favorit hinzugefügt ",
+  "Starred ": "Favorit ",

-  "AppStore": "AppStore",
-  "Filter: %s | Sort: %s | Order: %s": "Filter: %s | Sortierung: %s | Reihenfolge: %s",
-  "AppStore Options": "AppStore-Optionen",
-  "All": "Alle",
+  "AppStore": "hb-AppStore",
+  "Filter: %s | Sort: %s | Order: %s": "Rubrik: %s | Sort.nach.: %s | Ordnung: %s",
+  "AppStore Options": " hb-AppStore | Optionen",
+  "All": "Alles anzeigen",
  "Games": "Spiele",
  "Emulators": "Emulatoren",
  "Tools": "Tools",
  "Themes": "Themes",
-  "Legacy": "Legacy",
+  "Legacy": "Älteres",
  "version: %s": "Version: %s",
-  "updated: %s": "Aktualisiert: %s",
-  "category: %s": "Kategorie: %s",
-  "extracted: %.2f MiB": "Entpackt: %.2f MiB",
-  "app_dls: %s": "Downloads: %s",
-  "More by Author": "Mehr vom Entwickler",
-  "Leave Feedback": "Feedback geben",
+  "updated: %s": "Letztes Update am: %s",
+  "category: %s": "Rubrik: %s",
+  "extracted: %.2f MiB": "Größe: %.2f MiB",
+  "app_dls: %s": "Anzahl Downloads: %s",
+  "More by Author": "Weitere Apps des Entwicklers",
+  "Leave Feedback": "Feedback hinterlassen",

  "Irs": "IR-Sensor",
  "Ambient Noise Level: ": "Umgebungsrauschen: ",
@@ -203,55 +203,55 @@
  "External Light Filter": "Externes Lichtfilter",
  "Load Default": "Standard laden",

-  "Themezer": "Themezer",
-  "Themezer Options": "Themezer-Optionen",
+  "Themezer": "Themezer | NX Themes",
+  "Themezer Options": " Themezer | Optionen",
  "Nsfw": "NSFW",
-  "Page": "Seite",
-  "Page %zu / %zu": "Seite %zu / %zu",
-  "Enter Page Number": "Seitenzahl eingeben",
-  "Bad Page": "Ungültige Seite",
+  "Page": "Seiten Nr. wählen ",
+  "Page %zu / %zu": " %zu / %zu",
+  "Enter Page Number": "Zu Seite Nr.: ___",
+  "Bad Page": "Seite nicht gefunden",
  "Download theme?": "Theme herunterladen?",

  "GitHub": "GitHub",
-  "Downloading json": "Lade JSON herunter",
-  "Select asset to download for ": "Wähle Asset zum Download für ",
+  "Downloading json": "Lade JSON-File",
+  "Select asset to download for ": "Wähle Asset für den Download von ",

-  "Installing ": "Installiere ",
-  "Uninstalling ": "Deinstalliere ",
-  "Deleting ": "Lösche ",
-  "Deleting": "Lösche",
-  "Pasting ": "Füge ein ",
-  "Pasting": "Füge ein",
-  "Removing ": "Entferne ",
-  "Scanning ": "Scanne ",
-  "Creating ": "Erstelle ",
-  "Copying ": "Kopiere ",
-  "Trying to load ": "Lade ",
-  "Downloading ": "Lade herunter ",
-  "Downloaded ": "Heruntergeladen ",
-  "Removed ": "Entfernt ",
-  "Checking MD5": "Prüfe MD5",
-  "Loading...": "Lade...",
-  "Loading": "Lade",
-  "Empty!": "Leer!",
+  "Installing ": "Installiert wird: ",
+  "Uninstalling ": "Deinstalliert wird: ",
+  "Deleting ": "Gelöscht wird: ",
+  "Deleting": "Gelöscht wurde:",
+  "Pasting ": "Eingefügt wird: ",
+  "Pasting": "Eingefügt wurde:",
+  "Removing ": "Entfernt wird: ",
+  "Scanning ": "Gescannt wird: ",
+  "Creating ": "Erstellt wird: ",
+  "Copying ": "Kopiert wird: ",
+  "Trying to load ": "Versucht zu laden wird: ",
+  "Downloading ": "Heruntergeladen wird: ",
+  "Downloaded ": "Heruntergeladen wurde: ",
+  "Removed ": "Entfernt wurde: ",
+  "Checking MD5": "Checke MD5 Prüfsumme",
+  "Loading...": "Wird geladen...",
+  "Loading": "Wird geladen",
+  "Empty!": "Keine Daten!",
  "Not Ready...": "Nicht bereit...",
-  "Error loading page!": "Fehler beim Laden!",
+  "Error loading page!": "Ladefehler!",
  "Update avaliable: ": "Update verfügbar: ",
-  "Download update: ": "Update herunterladen: ",
-  "Updated to ": "Aktualisiert auf ",
-  "Press OK to restart Sphaira": "OK drücken um Sphaira neuzustarten",
-  "Restart Sphaira?": "Sphaira neustarten?",
-  "Failed to download update": "Update-Download fehlgeschlagen",
+  "Download update: ": " Herunterladen des Updates: ",
+  "Updated to ": "Aktualisiert auf: ",
+  "Press OK to restart Sphaira": "Drücke OK um sphaira erneut zustarten",
+  "Restart Sphaira?": "sphaira erneut starten?",
+  "Failed to download update": "Herunterladen des Updates fehlgeschlagen!",
  "Restore hbmenu?": "hbmenu wiederherstellen?",
-  "Failed to find /switch/hbmenu.nro\nUse the Appstore to re-install hbmenu": "Konnte /switch/hbmenu.nro nicht finden\nBitte hbmenu über den AppStore neu installieren",
-  "Failed to restore hbmenu, please re-download hbmenu": "Wiederherstellung fehlgeschlagen, bitte hbmenu neu herunterladen",
-  "Failed to restore hbmenu, using sphaira instead": "Wiederherstellung fehlgeschlagen, verwende stattdessen Sphaira",
-  "Restored hbmenu, closing sphaira": "hbmenu wiederhergestellt, Sphaira wird beendet",
-  "Restored hbmenu": "hbmenu wiederhergestellt",
-  "Delete Selected files?": "Ausgewählte Dateien löschen?",
-  "Completely remove ": "Vollständig entfernen ",
-  "Are you sure you want to delete ": "Wirklich löschen ",
-  "Are you sure you wish to cancel?": "Wirklich abbrechen?",
-  "Audio disabled due to suspended game": "",
+  "Failed to find /switch/hbmenu.nro\nUse the Appstore to re-install hbmenu": "Die Datei /switch/hbmenu.nro fehlt.\nInstalliere hbmenu über den hb-AppStore.",
+  "Failed to restore hbmenu, please re-download hbmenu": "Fehler, hbmenu nicht wiederhergrstellt!\nInstalliere hbmenu über den hb-AppStore.",
+  "Failed to restore hbmenu, using sphaira instead": "Fehler, hbmenu nicht wiederhergrstellt!\nVerwende weiter sphaira",
+  "Restored hbmenu, closing sphaira": "hbmenu wurde wiederhergestellt, schließe sphaira",
+  "Restored hbmenu": "hbmenu wurde wiederhergestellt",
+  "Delete Selected files?": "Ausgewähle Dateien löschen?",
+  "Completely remove ": "Komplett gelöscht wird: ",
+  "Are you sure you want to delete ": "Bist du sicher zu löschen? Bestätige Löschung von: ",
+  "Are you sure you wish to cancel?": "Bist du sicher dass du abbrechen willst?",
+  "Audio disabled due to suspended game": "Audio deaktivert wegen Spielabbruch",
  "If this message appears repeatedly, please open an issue.": "Bei wiederholtem Auftreten bitte Issue erstellen."
 }
--- a/assets/romfs/i18n/zh.json
+++ b/assets/romfs/i18n/zh.json
@@ -66,7 +66,7 @@
  "Select Theme": "选择主题",
  "Shuffle": "随机播放",
  "Music": "音乐",
-  "12 Hour Time": "",
+  "12 Hour Time": "12小时制时间",
  "Network": "网络",
  "Network Options": "网络选项",
  "Ftp": "FTP",
@@ -170,7 +170,7 @@
  "Controller": "控制器",
  "Pad ": "手柄 ",
  " (Available)": " （可用的）",
-  " (Unsupported)": "",
+  " (Unsupported)": " (不支持的）",
  " (Unconnected)": " （未连接）",
  "HandHeld": "掌机模式",
  "Rotation": "旋转",
@@ -239,7 +239,7 @@
  "Update avaliable: ": "有可用更新！",
  "Download update: ": "下载更新：",
  "Updated to ": "更新至 ",
-  "Press OK to restart Sphaira": "",
+  "Press OK to restart Sphaira": "按OK键以重启shphaira菜单",
  "Restart Sphaira?": "重启 Sphaira？",
  "Failed to download update": "更新下载失败",
  "Restore hbmenu?": "恢复 hbmenu？",
--- a/sphaira/CMakeLists.txt
+++ b/sphaira/CMakeLists.txt
@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.13)

-set(sphaira_VERSION 0.8.0)
+set(sphaira_VERSION 0.9.1)

 project(sphaira
    VERSION ${sphaira_VERSION}
@@ -49,6 +49,7 @@ add_executable(sphaira
    source/ui/menus/usb_menu.cpp
    source/ui/menus/ftp_menu.cpp
    source/ui/menus/gc_menu.cpp
+    source/ui/menus/game_menu.cpp

    source/ui/error_box.cpp
    source/ui/notification.cpp
@@ -61,6 +62,7 @@ add_executable(sphaira
    source/ui/widget.cpp
    source/ui/list.cpp
    source/ui/bubbles.cpp
+    source/ui/scrolling_text.cpp

    source/app.cpp
    source/download.cpp
@@ -74,7 +76,6 @@ add_executable(sphaira
    source/nxlink.cpp
    source/owo.cpp
    source/swkbd.cpp
-    source/web.cpp
    source/i18n.cpp
    source/ftpsrv_helper.cpp

--- a/sphaira/include/app.hpp
+++ b/sphaira/include/app.hpp
@@ -184,11 +184,13 @@ public:
    option::OptionBool m_theme_music{INI_SECTION, "theme_music", true};
    option::OptionBool m_12hour_time{INI_SECTION, "12hour_time", false};
    option::OptionLong m_language{INI_SECTION, "language", 0}; // auto
+    option::OptionString m_right_side_menu{INI_SECTION, "right_side_menu", "Appstore"};

    // install options
    option::OptionBool m_install{INI_SECTION, "install", false};
    option::OptionBool m_install_sd{INI_SECTION, "install_sd", true};
    option::OptionLong m_install_prompt{INI_SECTION, "install_prompt", true};
+    option::OptionLong m_boost_mode{INI_SECTION, "boost_mode", false};
    option::OptionBool m_allow_downgrade{INI_SECTION, "allow_downgrade", false};
    option::OptionBool m_skip_if_already_installed{INI_SECTION, "skip_if_already_installed", true};
    option::OptionBool m_ticket_only{INI_SECTION, "ticket_only", false};
--- a/sphaira/include/i18n.hpp
+++ b/sphaira/include/i18n.hpp
@@ -1,13 +1,14 @@
 #pragma once

 #include <string>
+#include <string_view>

 namespace sphaira::i18n {

 bool init(long index);
 void exit();

-std::string get(const char* str);
+std::string get(std::string_view str);

 } // namespace sphaira::i18n

--- a/sphaira/include/ui/error_box.hpp
+++ b/sphaira/include/ui/error_box.hpp
@@ -8,15 +8,14 @@ namespace sphaira::ui {
 class ErrorBox final : public Widget {
 public:
    ErrorBox(Result code, const std::string& message);
+    ErrorBox(const std::string& message);

    auto Update(Controller* controller, TouchInfo* touch) -> void override;
    auto Draw(NVGcontext* vg, Theme* theme) -> void override;

 private:
-    Result m_code{};
+    std::optional<Result> m_code{};
    std::string m_message{};
-    std::string m_module_str{};
-    std::string m_description_str{};
 };

 } // namespace sphaira::ui
--- a/sphaira/include/ui/menus/appstore.hpp
+++ b/sphaira/include/ui/menus/appstore.hpp
@@ -2,8 +2,8 @@

 #include "ui/menus/menu_base.hpp"
 #include "ui/scrollable_text.hpp"
+#include "ui/scrolling_text.hpp"
 #include "ui/list.hpp"
-#include "nro.hpp"
 #include "fs.hpp"
 #include <span>

@@ -73,6 +73,7 @@ struct EntryMenu final : MenuBase {
    EntryMenu(Entry& entry, const LazyImage& default_icon, Menu& menu);
    ~EntryMenu();

+    auto GetShortTitle() const -> const char* override { return "Entry"; };
    void Update(Controller* controller, TouchInfo* touch) override;
    void Draw(NVGcontext* vg, Theme* theme) override;
    // void OnFocusGained() override;
@@ -135,9 +136,10 @@ enum OrderType {
 };

 struct Menu final : MenuBase {
-    Menu(const std::vector<NroEntry>& nro_entries);
+    Menu();
    ~Menu();

+    auto GetShortTitle() const -> const char* override { return "Store"; };
    void Update(Controller* controller, TouchInfo* touch) override;
    void Draw(NVGcontext* vg, Theme* theme) override;
    void OnFocusGained() override;
@@ -162,13 +164,16 @@ struct Menu final : MenuBase {
    }

 private:
-    const std::vector<NroEntry>& m_nro_entries;
    std::vector<Entry> m_entries{};
    std::vector<EntryMini> m_entries_index[Filter_MAX]{};
    std::vector<EntryMini> m_entries_index_author{};
    std::vector<EntryMini> m_entries_index_search{};
    std::span<EntryMini> m_entries_current{};

+    ScrollingText m_scroll_name{};
+    ScrollingText m_scroll_author{};
+    ScrollingText m_scroll_version{};
+
    Filter m_filter{Filter::Filter_All};
    SortType m_sort{SortType::SortType_Updated};
    OrderType m_order{OrderType::OrderType_Descending};
--- a/sphaira/include/ui/menus/file_viewer.hpp
+++ b/sphaira/include/ui/menus/file_viewer.hpp
@@ -10,6 +10,7 @@ struct Menu final : MenuBase {
    Menu(const fs::FsPath& path);
    ~Menu();

+    auto GetShortTitle() const -> const char* override { return "File"; };
    void Update(Controller* controller, TouchInfo* touch) override;
    void Draw(NVGcontext* vg, Theme* theme) override;
    void OnFocusGained() override;
--- a/sphaira/include/ui/menus/filebrowser.hpp
+++ b/sphaira/include/ui/menus/filebrowser.hpp
@@ -124,6 +124,7 @@ struct Menu final : MenuBase {
    Menu(const std::vector<NroEntry>& nro_entries);
    ~Menu();

+    auto GetShortTitle() const -> const char* override { return "Files"; };
    void Update(Controller* controller, TouchInfo* touch) override;
    void Draw(NVGcontext* vg, Theme* theme) override;
    void OnFocusGained() override;
@@ -137,6 +138,13 @@ private:
    void InstallForwarder();
    void InstallFile(const FileEntry& target);
    void InstallFiles(const std::vector<FileEntry>& targets);
+
+    void UnzipFile(const fs::FsPath& folder, const FileEntry& target);
+    void UnzipFiles(fs::FsPath folder, const std::vector<FileEntry>& targets);
+
+    void ZipFile(const fs::FsPath& zip_path, const FileEntry& target);
+    void ZipFiles(fs::FsPath zip_path, const std::vector<FileEntry>& targets);
+
    auto Scan(const fs::FsPath& new_path, bool is_walk_up = false) -> Result;

    void LoadAssocEntriesPath(const fs::FsPath& path);
--- a/sphaira/include/ui/menus/ftp_menu.hpp
+++ b/sphaira/include/ui/menus/ftp_menu.hpp
@@ -38,6 +38,7 @@ struct Menu final : MenuBase {
    Menu();
    ~Menu();

+    auto GetShortTitle() const -> const char* override { return "FTP"; };
    void Update(Controller* controller, TouchInfo* touch) override;
    void Draw(NVGcontext* vg, Theme* theme) override;
    void OnFocusGained() override;
--- a/sphaira/include/ui/menus/game_menu.hpp
+++ b/sphaira/include/ui/menus/game_menu.hpp
@@ -0,0 +1,88 @@
+#pragma once
+
+#include "ui/menus/menu_base.hpp"
+#include "ui/scrolling_text.hpp"
+#include "ui/list.hpp"
+#include "fs.hpp"
+#include "option.hpp"
+#include <memory>
+
+namespace sphaira::ui::menu::game {
+
+enum class NacpLoadStatus {
+    // not yet attempted to be loaded.
+    None,
+    // loaded, ready to parse.
+    Loaded,
+    // failed to load, do not attempt to load again!
+    Error,
+};
+
+struct Entry {
+    u64 app_id{};
+    s64 size{};
+    char display_version[0x10]{};
+    NacpLanguageEntry lang{};
+    int image{};
+
+    std::unique_ptr<NsApplicationControlData> control{};
+    u64 control_size{};
+    NacpLoadStatus status{NacpLoadStatus::None};
+
+    auto GetName() const -> const char* {
+        return lang.name;
+    }
+
+    auto GetAuthor() const -> const char* {
+        return lang.author;
+    }
+
+    auto GetDisplayVersion() const -> const char* {
+        return display_version;
+    }
+};
+
+enum SortType {
+    SortType_Updated,
+};
+
+enum OrderType {
+    OrderType_Descending,
+    OrderType_Ascending,
+};
+
+struct Menu final : MenuBase {
+    Menu();
+    ~Menu();
+
+    auto GetShortTitle() const -> const char* override { return "Games"; };
+    void Update(Controller* controller, TouchInfo* touch) override;
+    void Draw(NVGcontext* vg, Theme* theme) override;
+    void OnFocusGained() override;
+
+private:
+    void SetIndex(s64 index);
+    void ScanHomebrew();
+    void Sort();
+    void SortAndFindLastFile();
+    void FreeEntries();
+
+private:
+    static constexpr inline const char* INI_SECTION = "games";
+
+    std::vector<Entry> m_entries{};
+    s64 m_index{}; // where i am in the array
+    std::unique_ptr<List> m_list{};
+    bool m_is_reversed{};
+    bool m_dirty{};
+
+    ScrollingText m_scroll_name{};
+    ScrollingText m_scroll_author{};
+    ScrollingText m_scroll_version{};
+
+    option::OptionLong m_sort{INI_SECTION, "sort", SortType::SortType_Updated};
+    option::OptionLong m_order{INI_SECTION, "order", OrderType::OrderType_Descending};
+    option::OptionBool m_hide_forwarders{INI_SECTION, "hide_forwarders", false};
+};
+
+} // namespace sphaira::ui::menu::game
--- a/sphaira/include/ui/menus/gc_menu.hpp
+++ b/sphaira/include/ui/menus/gc_menu.hpp
@@ -10,14 +10,16 @@
 namespace sphaira::ui::menu::gc {

 struct GcCollection : yati::container::CollectionEntry {
-    GcCollection(const char* _name, s64 _size, u8 _type) {
+    GcCollection(const char* _name, s64 _size, u8 _type, u8 _id_offset) {
        name = _name;
        size = _size;
        type = _type;
+        id_offset = _id_offset;
    }

    // NcmContentType
    u8 type{};
+    u8 id_offset{};
 };

 using GcCollections = std::vector<GcCollection>;
@@ -41,13 +43,16 @@ struct Menu final : MenuBase {
    Menu();
    ~Menu();

+    auto GetShortTitle() const -> const char* override { return "GC"; };
    void Update(Controller* controller, TouchInfo* touch) override;
    void Draw(NVGcontext* vg, Theme* theme) override;
+    void OnFocusGained() override;

 private:
    Result GcMount();
    void GcUnmount();
    Result GcPoll(bool* inserted);
+    Result GcOnEvent();
    Result UpdateStorageSize();

    void FreeImage();
@@ -57,6 +62,8 @@ private:
    FsDeviceOperator m_dev_op{};
    FsGameCardHandle m_handle{};
    std::unique_ptr<fs::FsNativeGameCard> m_fs{};
+    FsEventNotifier m_event_notifier{};
+    Event m_event{};

    std::vector<ApplicationEntry> m_entries{};
    std::unique_ptr<List> m_list{};
--- a/sphaira/include/ui/menus/ghdl.hpp
+++ b/sphaira/include/ui/menus/ghdl.hpp
@@ -45,6 +45,7 @@ struct Menu final : MenuBase {
    Menu();
    ~Menu();

+    auto GetShortTitle() const -> const char* override { return "GitHub"; };
    void Update(Controller* controller, TouchInfo* touch) override;
    void Draw(NVGcontext* vg, Theme* theme) override;
    void OnFocusGained() override;
--- a/sphaira/include/ui/menus/homebrew.hpp
+++ b/sphaira/include/ui/menus/homebrew.hpp
@@ -1,6 +1,7 @@
 #pragma once

 #include "ui/menus/menu_base.hpp"
+#include "ui/scrolling_text.hpp"
 #include "ui/list.hpp"
 #include "nro.hpp"
 #include "fs.hpp"
@@ -26,27 +27,30 @@ struct Menu final : MenuBase {
    Menu();
    ~Menu();

+    auto GetShortTitle() const -> const char* override { return "Apps"; };
    void Update(Controller* controller, TouchInfo* touch) override;
    void Draw(NVGcontext* vg, Theme* theme) override;
    void OnFocusGained() override;

-    void SetIndex(s64 index);
-    void InstallHomebrew();
-    void ScanHomebrew();
-    void Sort();
-    void SortAndFindLastFile();
-
    auto GetHomebrewList() const -> const std::vector<NroEntry>& {
        return m_entries;
    }

+    static Result InstallHomebrew(const fs::FsPath& path, const NacpStruct& nacp, const std::vector<u8>& icon);
+    static Result InstallHomebrewFromPath(const fs::FsPath& path);
+
+private:
+    void SetIndex(s64 index);
+    void InstallHomebrew();
+    void ScanHomebrew();
+    void Sort();
+    void SortAndFindLastFile();
+    void FreeEntries();
+
    auto IsStarEnabled() -> bool {
        return m_sort.Get() >= SortType_UpdatedStar;
    }

-    static Result InstallHomebrew(const fs::FsPath& path, const NacpStruct& nacp, const std::vector<u8>& icon);
-    static Result InstallHomebrewFromPath(const fs::FsPath& path);
-
 private:
    static constexpr inline const char* INI_SECTION = "homebrew";

@@ -54,6 +58,10 @@ private:
    s64 m_index{}; // where i am in the array
    std::unique_ptr<List> m_list{};

+    ScrollingText m_scroll_name{};
+    ScrollingText m_scroll_author{};
+    ScrollingText m_scroll_version{};
+
    option::OptionLong m_sort{INI_SECTION, "sort", SortType::SortType_AlphabeticalStar};
    option::OptionLong m_order{INI_SECTION, "order", OrderType::OrderType_Descending};
    option::OptionBool m_hide_sphaira{INI_SECTION, "hide_sphaira", false};
--- a/sphaira/include/ui/menus/irs_menu.hpp
+++ b/sphaira/include/ui/menus/irs_menu.hpp
@@ -30,16 +30,19 @@ struct Menu final : MenuBase {
    Menu();
    ~Menu();

+    auto GetShortTitle() const -> const char* override { return "IRS"; };
    void Update(Controller* controller, TouchInfo* touch) override;
    void Draw(NVGcontext* vg, Theme* theme) override;
    void OnFocusGained() override;

+private:
    void PollCameraStatus(bool statup = false);
    void LoadDefaultConfig();
    void UpdateConfig(const IrsImageTransferProcessorExConfig* config);
    void ResetImage();
    void UpdateImage();
    void updateColourArray();
+    auto GetEntryName(s64 i) -> std::string;

 private:
    Result m_init_rc{};
--- a/sphaira/include/ui/menus/main_menu.hpp
+++ b/sphaira/include/ui/menus/main_menu.hpp
@@ -3,7 +3,6 @@
 #include "ui/widget.hpp"
 #include "ui/menus/homebrew.hpp"
 #include "ui/menus/filebrowser.hpp"
-#include "ui/menus/appstore.hpp"

 namespace sphaira::ui::menu::main {

@@ -18,6 +17,32 @@ enum class UpdateState {
    Error,
 };

+using MiscMenuFunction = std::function<std::shared_ptr<ui::menu::MenuBase>(void)>;
+
+enum MiscMenuFlag : u8 {
+    // can be set as the rightside menu.
+    MiscMenuFlag_Shortcut = 1 << 0,
+    // needs install option to be enabled.
+    MiscMenuFlag_Install = 1 << 1,
+};
+
+struct MiscMenuEntry {
+    const char* name;
+    const char* title;
+    MiscMenuFunction func;
+    u8 flag;
+
+    auto IsShortcut() const -> bool {
+        return flag & MiscMenuFlag_Shortcut;
+    }
+
+    auto IsInstall() const -> bool {
+        return flag & MiscMenuFlag_Install;
+    }
+};
+
+auto GetMiscMenuEntries() -> std::span<const MiscMenuEntry>;
+
 // this holds 2 menus and allows for switching between them
 struct MainMenu final : Widget {
    MainMenu();
@@ -39,7 +64,7 @@ private:
 private:
    std::shared_ptr<homebrew::Menu> m_homebrew_menu{};
    std::shared_ptr<filebrowser::Menu> m_filebrowser_menu{};
-    std::shared_ptr<appstore::Menu> m_app_store_menu{};
+    std::shared_ptr<MenuBase> m_right_side_menu{};
    std::shared_ptr<MenuBase> m_current_menu{};

    std::string m_update_url{};
--- a/sphaira/include/ui/menus/menu_base.hpp
+++ b/sphaira/include/ui/menus/menu_base.hpp
@@ -10,6 +10,7 @@ struct MenuBase : Widget {
    MenuBase(std::string title);
    virtual ~MenuBase();

+    virtual auto GetShortTitle() const -> const char* = 0;
    virtual void Update(Controller* controller, TouchInfo* touch);
    virtual void Draw(NVGcontext* vg, Theme* theme);

@@ -21,6 +22,10 @@ struct MenuBase : Widget {
    void SetTitleSubHeading(std::string sub_heading);
    void SetSubHeading(std::string sub_heading);

+    auto GetTitle() const {
+        return m_title;
+    }
+
 private:
    void UpdateVars();

--- a/sphaira/include/ui/menus/themezer.hpp
+++ b/sphaira/include/ui/menus/themezer.hpp
@@ -2,6 +2,7 @@

 #include "ui/menus/menu_base.hpp"
 #include "ui/scrollable_text.hpp"
+#include "ui/scrolling_text.hpp"
 #include "ui/list.hpp"
 #include "option.hpp"
 #include <span>
@@ -132,6 +133,7 @@ struct Menu final : MenuBase {
    Menu();
    ~Menu();

+    auto GetShortTitle() const -> const char* override { return "Themezer"; };
    void Update(Controller* controller, TouchInfo* touch) override;
    void Draw(NVGcontext* vg, Theme* theme) override;
    void OnFocusGained() override;
@@ -160,6 +162,9 @@ private:
    s64 m_index{}; // where i am in the array
    std::unique_ptr<List> m_list{};

+    ScrollingText m_scroll_name{};
+    ScrollingText m_scroll_author{};
+
    // options
    option::OptionLong m_sort{INI_SECTION, "sort", 0};
    option::OptionLong m_order{INI_SECTION, "order", 0};
--- a/sphaira/include/ui/menus/usb_menu.hpp
+++ b/sphaira/include/ui/menus/usb_menu.hpp
@@ -8,8 +8,10 @@ namespace sphaira::ui::menu::usb {
 enum class State {
    // not connected.
    None,
+    // just connected, waiting for file list.
+    Connected_WaitForFileList,
    // just connected, starts the transfer.
-    Connected,
+    Connected_StartingTransfer,
    // set whilst transfer is in progress.
    Progress,
    // set when the transfer is finished.
@@ -22,6 +24,7 @@ struct Menu final : MenuBase {
    Menu();
    ~Menu();

+    auto GetShortTitle() const -> const char* override { return "USB"; };
    void Update(Controller* controller, TouchInfo* touch) override;
    void Draw(NVGcontext* vg, Theme* theme) override;
    void OnFocusGained() override;
@@ -35,9 +38,8 @@ struct Menu final : MenuBase {
    Mutex m_mutex{};
    // the below are shared across threads, lock with the above mutex!
    State m_state{State::None};
+    std::vector<std::string> m_names{};
    bool m_usb_has_connection{};
-    u32 m_usb_speed{};
-    u32 m_usb_count{};
 };

 } // namespace sphaira::ui::menu::usb
--- a/sphaira/include/ui/option_box.hpp
+++ b/sphaira/include/ui/option_box.hpp
@@ -32,11 +32,9 @@ public:
    using Options = std::vector<Option>;

 public:
-    OptionBox(const std::string& message, const Option& a, Callback cb = [](auto){}); // confirm
-    OptionBox(const std::string& message, const Option& a, const Option& b, Callback cb); // yesno
-    OptionBox(const std::string& message, const Option& a, const Option& b, s64 index, Callback cb); // yesno
-    OptionBox(const std::string& message, const Option& a, const Option& b, const Option& c, Callback cb); // tri
-    OptionBox(const std::string& message, const Option& a, const Option& b, const Option& c, s64 index, Callback cb); // tri
+    OptionBox(const std::string& message, const Option& a, Callback cb = [](auto){}, int image = 0); // confirm
+    OptionBox(const std::string& message, const Option& a, const Option& b, Callback cb, int image = 0); // yesno
+    OptionBox(const std::string& message, const Option& a, const Option& b, s64 index, Callback cb, int image = 0); // yesno

    auto Update(Controller* controller, TouchInfo* touch) -> void override;
    auto Draw(NVGcontext* vg, Theme* theme) -> void override;
@@ -50,6 +48,7 @@ private:
 private:
    std::string m_message{};
    Callback m_callback{};
+    int m_image{};

    Vec4 m_spacer_line{};

--- a/sphaira/include/ui/popup_list.hpp
+++ b/sphaira/include/ui/popup_list.hpp
@@ -1,6 +1,7 @@
 #pragma once

 #include "ui/widget.hpp"
+#include "ui/scrolling_text.hpp"
 #include "ui/list.hpp"
 #include <optional>

@@ -36,8 +37,10 @@ private:
    Items m_items{};
    Callback m_callback{};
    s64 m_index{}; // index in list array
+    s64 m_starting_index{};

    std::unique_ptr<List> m_list{};
+    ScrollingText m_scroll_text{};

    float m_yoff{};
    float m_line_top{};
--- a/sphaira/include/ui/scrolling_text.hpp
+++ b/sphaira/include/ui/scrolling_text.hpp
@@ -0,0 +1,19 @@
+#pragma once
+
+#include "ui/widget.hpp"
+#include <string>
+
+namespace sphaira::ui {
+
+struct ScrollingText final {
+public:
+    void Draw(NVGcontext*, bool focus, float x, float y, float w, float size, int align, const NVGcolor& colour, const std::string& text_entry);
+    void DrawArgs(NVGcontext*, bool focus, float x, float y, float w, float size, int align, const NVGcolor& colour, const char* s, ...) __attribute__ ((format (printf, 10, 11)));
+
+private:
+    std::string m_str;
+    s64 m_tick;
+    float m_text_xoff;
+};
+
+} // namespace sphaira::ui
--- a/sphaira/include/ui/types.hpp
+++ b/sphaira/include/ui/types.hpp
@@ -226,7 +226,6 @@ struct ThemeMeta {

 struct Theme {
    ThemeMeta meta;
-    PLSR_BFSTM music;
    ElementEntry elements[ThemeEntryID_MAX];

    auto GetColour(ThemeEntryID id) const {
--- a/sphaira/include/web.hpp
+++ b/sphaira/include/web.hpp
@@ -1,13 +0,0 @@
-#pragma once
-
-#include <switch.h>
-#include <string>
-
-namespace sphaira {
-
-// if show_error = true, it will display popup error box on
-// faliure. set this to false if you want to handle errors
-// from the caller.
-auto WebShow(const std::string& url, bool show_error = true) -> Result;
-
-} // namespace sphaira
--- a/sphaira/include/yati/nx/nca.hpp
+++ b/sphaira/include/yati/nx/nca.hpp
@@ -41,6 +41,7 @@ enum KeyGeneration {
    KeyGeneration_1700    = 0x11,
    KeyGeneration_1800    = 0x12,
    KeyGeneration_1900    = 0x13,
+    KeyGeneration_2000    = 0x14,
    KeyGeneration_Invalid = 0xFF,
 };

@@ -175,7 +176,7 @@ struct Header {
    u8 old_key_gen;            // see KeyGenerationOld.
    u8 kaek_index;             // see KeyAreaEncryptionKeyIndex.
    u64 size;
-    u64 title_id;
+    u64 program_id;
    u32 context_id;
    u32 sdk_version;
    u8 key_gen;                // see KeyGeneration.
--- a/sphaira/include/yati/nx/ncm.hpp
+++ b/sphaira/include/yati/nx/ncm.hpp
@@ -31,6 +31,9 @@ union ExtendedHeader {
    NcmDataPatchMetaExtendedHeader data_patch;
 };

+auto GetMetaTypeStr(u8 meta_type) -> const char*;
+auto GetStorageIdStr(u8 storage_id) -> const char*;
+
 auto GetAppId(u8 meta_type, u64 id) -> u64;
 auto GetAppId(const NcmContentMetaKey& key) -> u64;
 auto GetAppId(const PackagedContentMeta& meta) -> u64;
--- a/sphaira/include/yati/source/base.hpp
+++ b/sphaira/include/yati/source/base.hpp
@@ -14,6 +14,10 @@ struct Base {
        return false;
    }

+    virtual void SignalCancel() {
+
+    }
+
    Result GetOpenResult() const {
        return m_open_result;
    }
--- a/sphaira/include/yati/source/usb.hpp
+++ b/sphaira/include/yati/source/usb.hpp
@@ -2,6 +2,10 @@

 #include "base.hpp"
 #include "fs.hpp"
+
+#include <vector>
+#include <string>
+#include <new>
 #include <switch.h>

 namespace sphaira::yati::source {
@@ -15,17 +19,54 @@ struct Usb final : Base {
        Result_BadCount = MAKERESULT(USBModule, 2),
        Result_BadTransferSize = MAKERESULT(USBModule, 3),
        Result_BadTotalSize = MAKERESULT(USBModule, 4),
+        Result_Cancelled = MAKERESULT(USBModule, 11),
    };

    Usb(u64 transfer_timeout);
    ~Usb();

    Result Read(void* buf, s64 off, s64 size, u64* bytes_read) override;
-    Result Finished() const;
+    Result Finished();

    Result Init();
-    Result WaitForConnection(u64 timeout, u32& speed, u32& count);
-    Result GetFileInfo(std::string& name_out, u64& size_out);
+    Result IsUsbConnected(u64 timeout);
+    Result WaitForConnection(u64 timeout, std::vector<std::string>& out_names);
+    void SetFileNameForTranfser(const std::string& name);
+
+    auto GetCancelEvent() {
+        return &m_uevent;
+    }
+
+    void SignalCancel() override {
+        ueventSignal(GetCancelEvent());
+    }
+
+public:
+    // custom allocator for std::vector that respects alignment.
+    // https://en.cppreference.com/w/cpp/named_req/Allocator
+    template <typename T, std::size_t Align>
+    struct CustomVectorAllocator {
+    public:
+        // https://en.cppreference.com/w/cpp/memory/new/operator_new
+        auto allocate(std::size_t n) -> T* {
+            return new(align) T[n];
+        }
+
+        // https://en.cppreference.com/w/cpp/memory/new/operator_delete
+        auto deallocate(T* p, std::size_t n) noexcept -> void {
+            ::operator delete[] (p, n, align);
+        }
+
+    private:
+        static constexpr inline std::align_val_t align{Align};
+    };
+
+    template <typename T>
+    struct PageAllocator : CustomVectorAllocator<T, 0x1000> {
+        using value_type = T; // used by std::vector
+    };
+
+    using PageAlignedVector = std::vector<u8, PageAllocator<u8>>;

 private:
    enum UsbSessionEndpoint {
@@ -33,20 +74,26 @@ private:
        UsbSessionEndpoint_Out = 1,
    };

-    Result SendCommand(s64 off, s64 size) const;
-    Result InternalRead(void* buf, s64 off, s64 size) const;
+    Result SendCmdHeader(u32 cmdId, size_t dataSize);
+    Result SendFileRangeCmd(u64 offset, u64 size);

-    bool GetConfigured() const;
    Event *GetCompletionEvent(UsbSessionEndpoint ep) const;
-    Result WaitTransferCompletion(UsbSessionEndpoint ep, u64 timeout) const;
+    Result WaitTransferCompletion(UsbSessionEndpoint ep, u64 timeout);
    Result TransferAsync(UsbSessionEndpoint ep, void *buffer, u32 size, u32 *out_urb_id) const;
    Result GetTransferResult(UsbSessionEndpoint ep, u32 urb_id, u32 *out_requested_size, u32 *out_transferred_size) const;
-    Result TransferPacketImpl(bool read, void *page, u32 size, u32 *out_size_transferred, u64 timeout) const;
+    Result TransferPacketImpl(bool read, void *page, u32 size, u32 *out_size_transferred, u64 timeout);
+    Result TransferAll(bool read, void *data, u32 size, u64 timeout);

 private:
    UsbDsInterface* m_interface{};
    UsbDsEndpoint* m_endpoints[2]{};
    u64 m_transfer_timeout{};
+    UEvent m_uevent{};
+    // std::vector<UEvent*> m_cancel_events{};
+    // aligned buffer that transfer data is copied to and from.
+    // a vector is used to avoid multiple alloc within the transfer loop.
+    PageAlignedVector m_aligned{};
+    std::string m_transfer_file_name{};
 };

 } // namespace sphaira::yati::source
--- a/sphaira/include/yati/yati.hpp
+++ b/sphaira/include/yati/yati.hpp
@@ -71,6 +71,10 @@ enum : Result {
 struct Config {
    bool sd_card_install{};

+    // sets the performance mode to FastLoad which boosts the CPU clock
+    // and lowers the GPU clock.
+    bool boost_mode{};
+
    // enables downgrading patch / data patch (dlc) version.
    bool allow_downgrade{};

@@ -132,7 +136,7 @@ Result InstallFromSource(ui::ProgressBox* pbox, std::shared_ptr<source::Base> so
 Result InstallFromContainer(ui::ProgressBox* pbox, std::shared_ptr<container::Base> container, const ConfigOverride& override = {});
 Result InstallFromCollections(ui::ProgressBox* pbox, std::shared_ptr<source::Base> source, const container::Collections& collections, const ConfigOverride& override = {});

-Result ParseCnmtNca(const fs::FsPath& path,  ncm::PackagedContentMeta& header, std::vector<u8>& extended_header, std::vector<NcmPackagedContentInfo>& infos);
-Result ParseControlNca(const fs::FsPath& path, u64 id, void* nacp_out = nullptr, s64 nacp_size = 0, std::vector<u8>* icon_out = nullptr);
+Result ParseCnmtNca(const fs::FsPath& path, u64 program_id, ncm::PackagedContentMeta& header, std::vector<u8>& extended_header, std::vector<NcmPackagedContentInfo>& infos);
+Result ParseControlNca(const fs::FsPath& path, u64 program_id, void* nacp_out = nullptr, s64 nacp_size = 0, std::vector<u8>* icon_out = nullptr);

 } // namespace sphaira::yati
--- a/sphaira/source/app.cpp
+++ b/sphaira/source/app.cpp
@@ -7,12 +7,6 @@
 #include "ui/error_box.hpp"

 #include "ui/menus/main_menu.hpp"
-#include "ui/menus/irs_menu.hpp"
-#include "ui/menus/themezer.hpp"
-#include "ui/menus/ghdl.hpp"
-#include "ui/menus/usb_menu.hpp"
-#include "ui/menus/ftp_menu.hpp"
-#include "ui/menus/gc_menu.hpp"

 #include "app.hpp"
 #include "log.hpp"
@@ -26,7 +20,6 @@
 #include "defines.hpp"
 #include "i18n.hpp"
 #include "ftpsrv_helper.hpp"
-#include "web.hpp"

 #include <nanovg_dk.h>
 #include <minIni.h>
@@ -46,8 +39,33 @@ extern "C" {
 namespace sphaira {
 namespace {

+constexpr fs::FsPath DEFAULT_MUSIC_PATH = "/config/sphaira/themes/default_music.bfstm";
+constexpr const char* DEFAULT_MUSIC_URL = "https://files.catbox.moe/1ovji1.bfstm";
+// constexpr const char* DEFAULT_MUSIC_URL = "https://raw.githubusercontent.com/ITotalJustice/sphaira/refs/heads/master/assets/default_music.bfstm";
+
+void download_default_music() {
+    App::Push(std::make_shared<ui::ProgressBox>(0, "Downloading "_i18n, "default_music.bfstm", [](auto pbox){
+        const auto result = curl::Api().ToFile(
+            curl::Url{DEFAULT_MUSIC_URL},
+            curl::Path{DEFAULT_MUSIC_PATH},
+            curl::OnProgress{pbox->OnDownloadProgressCallback()}
+        );
+
+        return result.success;
+    }, [](bool success){
+        if (success) {
+            App::Notify("Downloaded "_i18n + "default_music.bfstm");
+            App::SetTheme(App::GetThemeIndex());
+        } else {
+            App::Push(std::make_shared<ui::ErrorBox>(
+                "Failed to download default_music.bfstm, please try again"_i18n
+            ));
+        }
+    }));
+}
+
 struct ThemeData {
-    fs::FsPath music_path{"/config/sphaira/themes/default_music.bfstm"};
+    fs::FsPath music_path{DEFAULT_MUSIC_PATH};
    std::string elements[ThemeEntryID_MAX]{};
 };

@@ -1116,7 +1134,6 @@ void App::CloseTheme() {
    if (m_sound_ids[SoundEffect_Music]) {
        plsrPlayerFree(m_sound_ids[SoundEffect_Music]);
        m_sound_ids[SoundEffect_Music] = nullptr;
-        plsrBFSTMClose(&m_theme.music);
    }

    for (auto& e : m_theme.elements) {
@@ -1146,10 +1163,12 @@ void App::LoadTheme(const ThemeMeta& meta) {

        // load music
        if (!theme_data.music_path.empty()) {
-            if (R_SUCCEEDED(plsrBFSTMOpen(theme_data.music_path, &m_theme.music))) {
-                if (R_SUCCEEDED(plsrPlayerLoadStream(&m_theme.music, &m_sound_ids[SoundEffect_Music]))) {
+            PLSR_BFSTM music_stream;
+            if (R_SUCCEEDED(plsrBFSTMOpen(theme_data.music_path, &music_stream))) {
+                if (R_SUCCEEDED(plsrPlayerLoadStream(&music_stream, &m_sound_ids[SoundEffect_Music]))) {
                    PlaySoundEffect(SoundEffect_Music);
                }
+                plsrBFSTMClose(&music_stream);
            }
        }
    }
@@ -1312,16 +1331,21 @@ App::App(const char* argv0) {
        if (R_SUCCEEDED(plsrBFSAROpen("qlaunch:/sound/qlaunch.bfsar", &qlaunch_bfsar))) {
            ON_SCOPE_EXIT(plsrBFSARClose(&qlaunch_bfsar));

-            plsrPlayerLoadSoundByName(&qlaunch_bfsar, "SeGameIconFocus", &m_sound_ids[SoundEffect_Focus]);
-            plsrPlayerLoadSoundByName(&qlaunch_bfsar, "SeGameIconScroll", &m_sound_ids[SoundEffect_Scroll]);
-            plsrPlayerLoadSoundByName(&qlaunch_bfsar, "SeGameIconLimit", &m_sound_ids[SoundEffect_Limit]);
-            plsrPlayerLoadSoundByName(&qlaunch_bfsar, "SeStartupMenu_game", &m_sound_ids[SoundEffect_Startup]);
-            plsrPlayerLoadSoundByName(&qlaunch_bfsar, "SeGameIconAdd", &m_sound_ids[SoundEffect_Install]);
-            plsrPlayerLoadSoundByName(&qlaunch_bfsar, "SeInsertError", &m_sound_ids[SoundEffect_Error]);
+            const auto load_sound = [&](const char* name, u32 id) {
+                if (R_FAILED(plsrPlayerLoadSoundByName(&qlaunch_bfsar, name, &m_sound_ids[id]))) {
+                    log_write("[PLSR] failed to load sound effect: %s\n", name);
+                }
+            };
+
+            load_sound("SeGameIconFocus", SoundEffect_Focus);
+            load_sound("SeGameIconScroll", SoundEffect_Scroll);
+            load_sound("SeGameIconLimit", SoundEffect_Limit);
+            load_sound("StartupMenu_Game", SoundEffect_Startup);
+            load_sound("SeGameIconAdd", SoundEffect_Install);
+            load_sound("SeInsertError", SoundEffect_Error);

            plsrPlayerSetVolume(m_sound_ids[SoundEffect_Limit], 2.0f);
            plsrPlayerSetVolume(m_sound_ids[SoundEffect_Focus], 0.5f);
-            PlaySoundEffect(SoundEffect_Startup);
        }
    } else {
        log_write("failed to mount romfs 0x0100000000001000\n");
@@ -1450,17 +1474,34 @@ void App::DisplayThemeOptions(bool left_side) {
    auto options = std::make_shared<ui::Sidebar>("Theme Options"_i18n, left_side ? ui::Sidebar::Side::LEFT : ui::Sidebar::Side::RIGHT);
    ON_SCOPE_EXIT(App::Push(options));

-    options->Add(std::make_shared<ui::SidebarEntryArray>("Select Theme"_i18n, theme_items, [theme_items](s64& index_out){
+    options->Add(std::make_shared<ui::SidebarEntryArray>("Select Theme"_i18n, theme_items, [](s64& index_out){
        App::SetTheme(index_out);
    }, App::GetThemeIndex()));

    options->Add(std::make_shared<ui::SidebarEntryBool>("Music"_i18n, App::GetThemeMusicEnable(), [](bool& enable){
        App::SetThemeMusicEnable(enable);
-    }, "Enabled"_i18n, "Disabled"_i18n));
+    }));

    options->Add(std::make_shared<ui::SidebarEntryBool>("12 Hour Time"_i18n, App::Get12HourTimeEnable(), [](bool& enable){
        App::Set12HourTimeEnable(enable);
-    }, "Enabled"_i18n, "Disabled"_i18n));
+    }));
+
+    options->Add(std::make_shared<ui::SidebarEntryCallback>("Download Default Music"_i18n, [](){
+        // check if we already have music
+        if (fs::FileExists(DEFAULT_MUSIC_PATH)) {
+            App::Push(std::make_shared<ui::OptionBox>(
+                "Overwrite current default music?"_i18n,
+                "No"_i18n, "Yes"_i18n, 0, [](auto op_index){
+                    if (op_index && *op_index) {
+                        download_default_music();
+                    }
+                }
+            ));
+
+        } else {
+            download_default_music();
+        }
+    }));
 }

 void App::DisplayNetworkOptions(bool left_side) {
@@ -1471,37 +1512,17 @@ void App::DisplayMiscOptions(bool left_side) {
    auto options = std::make_shared<ui::Sidebar>("Misc Options"_i18n, left_side ? ui::Sidebar::Side::LEFT : ui::Sidebar::Side::RIGHT);
    ON_SCOPE_EXIT(App::Push(options));

-    options->Add(std::make_shared<ui::SidebarEntryCallback>("Themezer"_i18n, [](){
-        App::Push(std::make_shared<ui::menu::themezer::Menu>());
-    }));
-
-    options->Add(std::make_shared<ui::SidebarEntryCallback>("GitHub"_i18n, [](){
-        App::Push(std::make_shared<ui::menu::gh::Menu>());
-    }));
-
-    options->Add(std::make_shared<ui::SidebarEntryCallback>("Irs"_i18n, [](){
-        App::Push(std::make_shared<ui::menu::irs::Menu>());
-    }));
-
-    if (App::IsApplication()) {
-        options->Add(std::make_shared<ui::SidebarEntryCallback>("Web"_i18n, [](){
-            WebShow("https://lite.duckduckgo.com/lite");
-        }));
-    }
-
-    if (App::GetApp()->m_install.Get()) {
-        if (App::GetFtpEnable()) {
-            options->Add(std::make_shared<ui::SidebarEntryCallback>("Ftp Install"_i18n, [](){
-                App::Push(std::make_shared<ui::menu::ftp::Menu>());
-            }));
+    for (auto& e : ui::menu::main::GetMiscMenuEntries()) {
+        if (e.name == g_app->m_right_side_menu.Get()) {
+            continue;
        }

-        options->Add(std::make_shared<ui::SidebarEntryCallback>("Usb Install"_i18n, [](){
-            App::Push(std::make_shared<ui::menu::usb::Menu>());
-        }));
+        if (e.IsInstall() && !App::GetInstallEnable()) {
+            continue;
+        }

-        options->Add(std::make_shared<ui::SidebarEntryCallback>("GameCard Install"_i18n, [](){
-            App::Push(std::make_shared<ui::menu::gc::Menu>());
+        options->Add(std::make_shared<ui::SidebarEntryCallback>(i18n::get(e.title), [e](){
+            App::Push(e.func());
        }));
    }
 }
@@ -1515,17 +1536,52 @@ void App::DisplayAdvancedOptions(bool left_side) {
    text_scroll_speed_items.push_back("Normal"_i18n);
    text_scroll_speed_items.push_back("Fast"_i18n);

+    std::vector<const char*> menu_names;
+    for (auto& e : ui::menu::main::GetMiscMenuEntries()) {
+        if (!e.IsShortcut()) {
+            continue;
+        }
+
+        if (e.IsInstall() && !App::GetInstallEnable()) {
+            continue;
+        }
+
+        menu_names.emplace_back(e.name);
+    }
+
+    ui::SidebarEntryArray::Items right_side_menu_items;
+    for (auto& str : menu_names) {
+        right_side_menu_items.push_back(i18n::get(str));
+    }
+
+    const auto it = std::find(menu_names.cbegin(), menu_names.cend(), g_app->m_right_side_menu.Get());
+    if (it == menu_names.cend()) {
+        g_app->m_right_side_menu.Set(menu_names[0]);
+    }
+
    options->Add(std::make_shared<ui::SidebarEntryBool>("Logging"_i18n, App::GetLogEnable(), [](bool& enable){
        App::SetLogEnable(enable);
-    }, "Enabled"_i18n, "Disabled"_i18n));
+    }));

    options->Add(std::make_shared<ui::SidebarEntryBool>("Replace hbmenu on exit"_i18n, App::GetReplaceHbmenuEnable(), [](bool& enable){
        App::SetReplaceHbmenuEnable(enable);
-    }, "Enabled"_i18n, "Disabled"_i18n));
+    }));

    options->Add(std::make_shared<ui::SidebarEntryArray>("Text scroll speed"_i18n, text_scroll_speed_items, [](s64& index_out){
        App::SetTextScrollSpeed(index_out);
-    }, (s64)App::GetTextScrollSpeed()));
+    }, App::GetTextScrollSpeed()));
+
+    options->Add(std::make_shared<ui::SidebarEntryArray>("Set right-side menu"_i18n, right_side_menu_items, [menu_names](s64& index_out){
+        const auto e = menu_names[index_out];
+        if (g_app->m_right_side_menu.Get() != e) {
+            g_app->m_right_side_menu.Set(e);
+            App::Push(std::make_shared<ui::OptionBox>(
+                "Press OK to restart Sphaira"_i18n, "OK"_i18n, [](auto){
+                    App::ExitRestart();
+                }
+            ));
+        }
+    }, i18n::get(g_app->m_right_side_menu.Get())));

    options->Add(std::make_shared<ui::SidebarEntryCallback>("Install options"_i18n, [left_side](){
        App::DisplayInstallOptions(left_side);
@@ -1540,77 +1596,81 @@ void App::DisplayInstallOptions(bool left_side) {
    install_items.push_back("System memory"_i18n);
    install_items.push_back("microSD card"_i18n);

-    options->Add(std::make_shared<ui::SidebarEntryBool>("Enable"_i18n, App::GetInstallEnable(), [](bool& enable){
-        App::SetInstallEnable(enable);
-    }, "Enabled"_i18n, "Disabled"_i18n));
+    options->Add(std::make_shared<ui::SidebarEntryBool>("Enable"_i18n, App::GetApp()->m_install.Get(), [](bool& enable){
+        App::GetApp()->m_install.Set(enable);
+    }));

-    options->Add(std::make_shared<ui::SidebarEntryBool>("Show install warning"_i18n, App::GetInstallPrompt(), [](bool& enable){
-        App::SetInstallPrompt(enable);
-    }, "Enabled"_i18n, "Disabled"_i18n));
+    options->Add(std::make_shared<ui::SidebarEntryBool>("Show install warning"_i18n, App::GetApp()->m_install_prompt.Get(), [](bool& enable){
+        App::GetApp()->m_install_prompt.Set(enable);
+    }));

    options->Add(std::make_shared<ui::SidebarEntryArray>("Install location"_i18n, install_items, [](s64& index_out){
        App::SetInstallSdEnable(index_out);
    }, (s64)App::GetInstallSdEnable()));

+    options->Add(std::make_shared<ui::SidebarEntryBool>("Boost CPU clock"_i18n, App::GetApp()->m_boost_mode.Get(), [](bool& enable){
+        App::GetApp()->m_boost_mode.Set(enable);
+    }));
+
    options->Add(std::make_shared<ui::SidebarEntryBool>("Allow downgrade"_i18n, App::GetApp()->m_allow_downgrade.Get(), [](bool& enable){
        App::GetApp()->m_allow_downgrade.Set(enable);
-    }, "Enabled"_i18n, "Disabled"_i18n));
+    }));

    options->Add(std::make_shared<ui::SidebarEntryBool>("Skip if already installed"_i18n, App::GetApp()->m_skip_if_already_installed.Get(), [](bool& enable){
        App::GetApp()->m_skip_if_already_installed.Set(enable);
-    }, "Enabled"_i18n, "Disabled"_i18n));
+    }));

    options->Add(std::make_shared<ui::SidebarEntryBool>("Ticket only"_i18n, App::GetApp()->m_ticket_only.Get(), [](bool& enable){
        App::GetApp()->m_ticket_only.Set(enable);
-    }, "Enabled"_i18n, "Disabled"_i18n));
+    }));

    options->Add(std::make_shared<ui::SidebarEntryBool>("Skip base"_i18n, App::GetApp()->m_skip_base.Get(), [](bool& enable){
        App::GetApp()->m_skip_base.Set(enable);
-    }, "Enabled"_i18n, "Disabled"_i18n));
+    }));

-    options->Add(std::make_shared<ui::SidebarEntryBool>("Skip Patch"_i18n, App::GetApp()->m_skip_patch.Get(), [](bool& enable){
+    options->Add(std::make_shared<ui::SidebarEntryBool>("Skip patch"_i18n, App::GetApp()->m_skip_patch.Get(), [](bool& enable){
        App::GetApp()->m_skip_patch.Set(enable);
-    }, "Enabled"_i18n, "Disabled"_i18n));
+    }));

-    options->Add(std::make_shared<ui::SidebarEntryBool>("Skip addon"_i18n, App::GetApp()->m_skip_addon.Get(), [](bool& enable){
+    options->Add(std::make_shared<ui::SidebarEntryBool>("Skip dlc"_i18n, App::GetApp()->m_skip_addon.Get(), [](bool& enable){
        App::GetApp()->m_skip_addon.Set(enable);
-    }, "Enabled"_i18n, "Disabled"_i18n));
+    }));

    options->Add(std::make_shared<ui::SidebarEntryBool>("Skip data patch"_i18n, App::GetApp()->m_skip_data_patch.Get(), [](bool& enable){
        App::GetApp()->m_skip_data_patch.Set(enable);
-    }, "Enabled"_i18n, "Disabled"_i18n));
+    }));

    options->Add(std::make_shared<ui::SidebarEntryBool>("Skip ticket"_i18n, App::GetApp()->m_skip_ticket.Get(), [](bool& enable){
        App::GetApp()->m_skip_ticket.Set(enable);
-    }, "Enabled"_i18n, "Disabled"_i18n));
+    }));

    options->Add(std::make_shared<ui::SidebarEntryBool>("skip NCA hash verify"_i18n, App::GetApp()->m_skip_nca_hash_verify.Get(), [](bool& enable){
        App::GetApp()->m_skip_nca_hash_verify.Set(enable);
-    }, "Enabled"_i18n, "Disabled"_i18n));
+    }));

    options->Add(std::make_shared<ui::SidebarEntryBool>("Skip RSA header verify"_i18n, App::GetApp()->m_skip_rsa_header_fixed_key_verify.Get(), [](bool& enable){
        App::GetApp()->m_skip_rsa_header_fixed_key_verify.Set(enable);
-    }, "Enabled"_i18n, "Disabled"_i18n));
+    }));

    options->Add(std::make_shared<ui::SidebarEntryBool>("Skip RSA NPDM verify"_i18n, App::GetApp()->m_skip_rsa_npdm_fixed_key_verify.Get(), [](bool& enable){
        App::GetApp()->m_skip_rsa_npdm_fixed_key_verify.Set(enable);
-    }, "Enabled"_i18n, "Disabled"_i18n));
+    }));

    options->Add(std::make_shared<ui::SidebarEntryBool>("Ignore distribution bit"_i18n, App::GetApp()->m_ignore_distribution_bit.Get(), [](bool& enable){
        App::GetApp()->m_ignore_distribution_bit.Set(enable);
-    }, "Enabled"_i18n, "Disabled"_i18n));
+    }));

    options->Add(std::make_shared<ui::SidebarEntryBool>("Convert to standard crypto"_i18n, App::GetApp()->m_convert_to_standard_crypto.Get(), [](bool& enable){
        App::GetApp()->m_convert_to_standard_crypto.Set(enable);
-    }, "Enabled"_i18n, "Disabled"_i18n));
+    }));

    options->Add(std::make_shared<ui::SidebarEntryBool>("Lower master key"_i18n, App::GetApp()->m_lower_master_key.Get(), [](bool& enable){
        App::GetApp()->m_lower_master_key.Set(enable);
-    }, "Enabled"_i18n, "Disabled"_i18n));
+    }));

    options->Add(std::make_shared<ui::SidebarEntryBool>("Lower system version"_i18n, App::GetApp()->m_lower_system_version.Get(), [](bool& enable){
        App::GetApp()->m_lower_system_version.Set(enable);
-    }, "Enabled"_i18n, "Disabled"_i18n));
+    }));
 }

 App::~App() {
--- a/sphaira/source/download.cpp
+++ b/sphaira/source/download.cpp
@@ -195,6 +195,8 @@ private:
        } else {
            const auto update_entry = [this, &hash_key](const char* tag, const std::string& value) {
                if (value.empty()) {
+                    // workaround for appstore accepting etags but not returning them.
+                    yyjson_mut_obj_remove_str(hash_key, tag);
                    return true;
                } else {
                    auto key = yyjson_mut_obj_get(hash_key, tag);
@@ -471,7 +473,8 @@ auto DownloadInternal(CURL* curl, const Api& e) -> ApiResult {
            return {};
        }

-        if (e.GetFlags() & Flag_Cache) {
+        // only add etag if the dst file still exists.
+        if ((e.GetFlags() & Flag_Cache) && fs::FileExists(&fs.m_fs, e.GetPath())) {
            g_cache.get(e.GetPath(), header_in);
        }
    }
@@ -490,6 +493,8 @@ auto DownloadInternal(CURL* curl, const Api& e) -> ApiResult {
    CURL_EASY_SETOPT_LOG(curl, CURLOPT_BUFFERSIZE, 1024*512);
    CURL_EASY_SETOPT_LOG(curl, CURLOPT_HEADERFUNCTION, header_callback);
    CURL_EASY_SETOPT_LOG(curl, CURLOPT_HEADERDATA, &header_out);
+    // enable all forms of compression supported by libcurl.
+    CURL_EASY_SETOPT_LOG(curl, CURLOPT_ACCEPT_ENCODING, "");

    if (has_post) {
        CURL_EASY_SETOPT_LOG(curl, CURLOPT_POSTFIELDS, e.GetFields().c_str());
@@ -558,6 +563,15 @@ auto DownloadInternal(CURL* curl, const Api& e) -> ApiResult {
                    g_cache.set(e.GetPath(), header_out);
                }

+                // enable to log received headers.
+                #if 0
+                log_write("\n\nLOGGING HEADER\n");
+                    for (auto [a, b] : header_out.m_map) {
+                        log_write("\t%s: %s\n", a.c_str(), b.c_str());
+                    }
+                log_write("\n\n");
+                #endif
+
                fs.DeleteFile(e.GetPath());
                fs.CreateDirectoryRecursivelyWithPath(e.GetPath());
                if (R_FAILED(fs.RenameFile(tmp_buf, e.GetPath()))) {
--- a/sphaira/source/i18n.cpp
+++ b/sphaira/source/i18n.cpp
@@ -13,8 +13,8 @@ yyjson_doc* json;
 yyjson_val* root;
 std::unordered_map<std::string, std::string> g_tr_cache;

-std::string get_internal(const char* str, size_t len) {
-    const std::string kkey = {str, len};
+std::string get_internal(std::string_view str) {
+    const std::string kkey = {str.data(), str.length()};

    if (auto it = g_tr_cache.find(kkey); it != g_tr_cache.end()) {
        return it->second;
@@ -28,7 +28,7 @@ std::string get_internal(const char* str, size_t len) {
        return kkey;
    }

-    auto key = yyjson_obj_getn(root, str, len);
+    auto key = yyjson_obj_getn(root, str.data(), str.length());
    if (!key) {
        log_write("\tfailed to find key: [%s]\n", kkey.c_str());
        return kkey;
@@ -134,8 +134,8 @@ void exit() {
    g_i18n_data.clear();
 }

-std::string get(const char* str) {
-    return get_internal(str, std::strlen(str));
+std::string get(std::string_view str) {
+    return get_internal(str);
 }

 } // namespace sphaira::i18n
@@ -143,7 +143,7 @@ std::string get(const char* str) {
 namespace literals {

 std::string operator"" _i18n(const char* str, size_t len) {
-    return sphaira::i18n::get_internal(str, len);
+    return sphaira::i18n::get_internal({str, len});
 }

 } // namespace literals
--- a/sphaira/source/owo.cpp
+++ b/sphaira/source/owo.cpp
@@ -715,7 +715,7 @@ void write_nca_header_encypted(nca::Header& nca_header, u64 tid, const keys::Key
    nca_header.magic = NCA3_MAGIC;
    nca_header.distribution_type = nca::DistributionType_System;
    nca_header.content_type = type;
-    nca_header.title_id = tid;
+    nca_header.program_id = tid;
    nca_header.sdk_version = 0x000C1100;
    nca_header.size = buf.tell();

@@ -857,7 +857,8 @@ auto install_forwader_internal(ui::ProgressBox* pbox, OwoConfig& config, NcmStor
    u64 hash_data[SHA256_HASH_SIZE / sizeof(u64)];
    const auto hash_path = config.nro_path + config.args;
    sha256CalculateHash(hash_data, hash_path.data(), hash_path.length());
-    const u64 tid = 0x0100000000000000 | (hash_data[0] & 0x00FFFFFFFFFFF000);
+    const u64 old_tid = 0x0100000000000000 | (hash_data[0] & 0x00FFFFFFFFFFF000);
+    const u64 tid = 0x0500000000000000 | (hash_data[0] & 0x00FFFFFFFFFFF000);

    std::vector<NcaEntry> nca_entries;

@@ -980,6 +981,12 @@ auto install_forwader_internal(ui::ProgressBox* pbox, OwoConfig& config, NcmStor
            R_TRY(nsIsAnyApplicationEntityInstalled(tid, &already_installed));
        }

+        // remove old id for forwarders.
+        const auto rc = nsDeleteApplicationCompletely(old_tid);
+        if (R_FAILED(rc) && rc != 0x410) { // not found
+            App::Notify("Failed to remove old forwarder, please manually remove it!");
+        }
+
        // remove previous application record
        if (already_installed || hosversionBefore(2,0,0)) {
            const auto rc = ns::DeleteApplicationRecord(srv_ptr, tid);
--- a/sphaira/source/ui/error_box.cpp
+++ b/sphaira/source/ui/error_box.cpp
--- a/sphaira/source/ui/menus/appstore.cpp
+++ b/sphaira/source/ui/menus/appstore.cpp
@@ -236,7 +236,7 @@ void DrawIcon(NVGcontext* vg, const LazyImage& l, const LazyImage& d, float x, f
    bool crop = false;
    if (iw < w || ih < h) {
        rounded_image = false;
-        gfx::drawRect(vg, x, y, w, h, nvgRGB(i.first_pixel[0], i.first_pixel[1], i.first_pixel[2]), rounded ? 15 : 0);
+        gfx::drawRect(vg, x, y, w, h, nvgRGB(i.first_pixel[0], i.first_pixel[1], i.first_pixel[2]), rounded ? 5 : 0);
    }
    if (iw > w || ih > h) {
        crop = true;
@@ -244,7 +244,7 @@ void DrawIcon(NVGcontext* vg, const LazyImage& l, const LazyImage& d, float x, f
        nvgIntersectScissor(vg, x, y, w, h);
    }

-    gfx::drawImage(vg, ix, iy, iw, ih, i.image, rounded_image ? 15 : 0);
+    gfx::drawImage(vg, ix, iy, iw, ih, i.image, rounded_image ? 5 : 0);
    if (crop) {
        nvgRestore(vg);
    }
@@ -590,6 +590,14 @@ auto InstallApp(ProgressBox* pbox, const Entry& entry) -> bool {
    return true;
 }

+// case-insensitive version of str.find()
+auto FindCaseInsensitive(std::string_view base, std::string_view term) -> bool {
+    const auto it = std::search(base.cbegin(), base.cend(), term.cbegin(), term.cend(), [](char a, char b){
+        return std::toupper(a) == std::toupper(b);
+    });
+    return it != base.cend();
+}
+
 } // namespace

 EntryMenu::EntryMenu(Entry& entry, const LazyImage& default_icon, Menu& menu)
@@ -838,19 +846,42 @@ void EntryMenu::SetIndex(s64 index) {
    }
 }

-auto toLower(const std::string& str) -> std::string {
-	std::string lower;
-	std::transform(str.cbegin(), str.cend(), std::back_inserter(lower), tolower);
-	return lower;
-}
-
-Menu::Menu(const std::vector<NroEntry>& nro_entries) : MenuBase{"AppStore"_i18n}, m_nro_entries{nro_entries} {
+Menu::Menu() : MenuBase{"AppStore"_i18n} {
    fs::FsNativeSd fs;
    fs.CreateDirectoryRecursively("/switch/sphaira/cache/appstore/icons");
    fs.CreateDirectoryRecursively("/switch/sphaira/cache/appstore/banners");
    fs.CreateDirectoryRecursively("/switch/sphaira/cache/appstore/screens");

    this->SetActions(
+        std::make_pair(Button::B, Action{"Back"_i18n, [this](){
+            if (m_is_author) {
+                m_is_author = false;
+                if (m_is_search) {
+                    SetSearch(m_search_term);
+                } else {
+                    SetFilter(m_filter);
+                }
+
+                SetIndex(m_entry_author_jump_back);
+                if (m_entry_author_jump_back >= 9) {
+                    m_list->SetYoff((((m_entry_author_jump_back - 9) + 3) / 3) * m_list->GetMaxY());
+                } else {
+                    m_list->SetYoff(0);
+                }
+            } else if (m_is_search) {
+                m_is_search = false;
+                SetFilter(m_filter);
+                SetIndex(m_entry_search_jump_back);
+                if (m_entry_search_jump_back >= 9) {
+                    m_list->SetYoff(0);
+                    m_list->SetYoff((((m_entry_search_jump_back - 9) + 3) / 3) * m_list->GetMaxY());
+                } else {
+                    m_list->SetYoff(0);
+                }
+            } else {
+                SetPop();
+            }
+        }}),
        std::make_pair(Button::A, Action{"Info"_i18n, [this](){
            if (m_entries_current.empty()) {
                // log_write("pushing A when empty: size: %zu count: %zu\n", repo_json.size(), m_entries_current.size());
@@ -1025,7 +1056,8 @@ void Menu::Draw(NVGcontext* vg, Theme* theme) {
        }

        auto text_id = ThemeEntryID_TEXT;
-        if (pos == m_index) {
+        const auto selected = pos == m_index;
+        if (selected) {
            text_id = ThemeEntryID_TEXT_SELECTED;
            gfx::drawRectOutline(vg, theme, 4.f, v);
        } else {
@@ -1038,15 +1070,13 @@ void Menu::Draw(NVGcontext* vg, Theme* theme) {
        DrawIcon(vg, e.image, m_default_image, x + 20, y + 20, 115, 115, true, image_scale);
        // gfx::drawImage(vg, x + 20, y + 20, image_size, image_size_h, image.image ? image.image : m_default_image);

-        nvgSave(vg);
-        nvgIntersectScissor(vg, v.x, v.y, w - 30.f, h); // clip
-        {
-            const float font_size = 18;
-            gfx::drawTextArgs(vg, x + 148, y + 45, font_size, NVG_ALIGN_LEFT, theme->GetColour(text_id), e.title.c_str());
-            gfx::drawTextArgs(vg, x + 148, y + 80, font_size, NVG_ALIGN_LEFT, theme->GetColour(text_id), e.author.c_str());
-            gfx::drawTextArgs(vg, x + 148, y + 115, font_size, NVG_ALIGN_LEFT, theme->GetColour(text_id), e.version.c_str());
-        }
-        nvgRestore(vg);
+        const auto text_off = 148;
+        const auto text_x = x + text_off;
+        const auto text_clip_w = w - 30.f - text_off;
+        const float font_size = 18;
+        m_scroll_name.Draw(vg, selected, text_x, y + 45, text_clip_w, font_size, NVG_ALIGN_LEFT, theme->GetColour(text_id), e.title.c_str());
+        m_scroll_author.Draw(vg, selected, text_x, y + 80, text_clip_w, font_size, NVG_ALIGN_LEFT, theme->GetColour(text_id), e.author.c_str());
+        m_scroll_version.Draw(vg, selected, text_x, y + 115, text_clip_w, font_size, NVG_ALIGN_LEFT, theme->GetColour(text_id), e.version.c_str());

        float i_size = 22;
        switch (e.status) {
@@ -1263,7 +1293,6 @@ void Menu::Sort() {
 void Menu::SetFilter(Filter filter) {
    m_is_search = false;
    m_is_author = false;
-    RemoveAction(Button::B);

    m_filter = filter;
    m_entries_current = m_entries_index[m_filter];
@@ -1293,27 +1322,15 @@ void Menu::SetSearch(const std::string& term) {

    m_search_term = term;
    m_entries_index_search.clear();
-    const auto query = toLower(m_search_term);
-    const auto npos = std::string::npos;
+    const auto query = m_search_term;

    for (u64 i = 0; i < m_entries.size(); i++) {
        const auto& e = m_entries[i];
-        if (toLower(e.title).find(query) != npos || toLower(e.author).find(query) != npos || toLower(e.details).find(query) != npos || toLower(e.description).find(query) != npos) {
+        if (FindCaseInsensitive(e.title, query) || FindCaseInsensitive(e.author, query) || FindCaseInsensitive(e.description, query)) {
            m_entries_index_search.emplace_back(i);
        }
    }

-    SetAction(Button::B, Action{"Back"_i18n, [this](){
-        SetFilter(m_filter);
-        SetIndex(m_entry_search_jump_back);
-        if (m_entry_search_jump_back >= 9) {
-            m_list->SetYoff(0);
-            m_list->SetYoff((((m_entry_search_jump_back - 9) + 3) / 3) * m_list->GetMaxY());
-        } else {
-            m_list->SetYoff(0);
-        }
-    }});
-
    m_is_search = true;
    m_entries_current = m_entries_index_search;
    SetIndex(0);
@@ -1327,29 +1344,15 @@ void Menu::SetAuthor() {

    m_author_term = m_entries[m_entries_current[m_index]].author;
    m_entries_index_author.clear();
+    const auto query = m_author_term;

    for (u64 i = 0; i < m_entries.size(); i++) {
        const auto& e = m_entries[i];
-        if (e.author.find(m_author_term) != std::string::npos) {
+        if (FindCaseInsensitive(e.author, query)) {
            m_entries_index_author.emplace_back(i);
        }
    }

-    SetAction(Button::B, Action{"Back"_i18n, [this](){
-        if (m_is_search) {
-            SetSearch(m_search_term);
-        } else {
-            SetFilter(m_filter);
-        }
-
-        SetIndex(m_entry_author_jump_back);
-        if (m_entry_author_jump_back >= 9) {
-            m_list->SetYoff((((m_entry_author_jump_back - 9) + 3) / 3) * m_list->GetMaxY());
-        } else {
-            m_list->SetYoff(0);
-        }
-    }});
-
    m_is_author = true;
    m_entries_current = m_entries_index_author;
    SetIndex(0);
--- a/sphaira/source/ui/menus/filebrowser.cpp
+++ b/sphaira/source/ui/menus/filebrowser.cpp
@@ -22,6 +22,7 @@
 #include "yati/source/file.hpp"

 #include <minIni.h>
+#include <minizip/zip.h>
 #include <minizip/unzip.h>
 #include <dirent.h>
 #include <cstring>
@@ -57,6 +58,14 @@ constexpr std::string_view IMAGE_EXTENSIONS[] = {
 constexpr std::string_view INSTALL_EXTENSIONS[] = {
    "nsp", "xci", "nsz", "xcz",
 };
+// these are files that are already compressed or encrypted and should
+// be stored raw in a zip file.
+constexpr std::string_view COMPRESSED_EXTENSIONS[] = {
+    "zip", "xz", "7z", "rar", "tar", "nca", "nsp", "xci", "nsz", "xcz"
+};
+constexpr std::string_view ZIP_EXTENSIONS[] = {
+    "zip",
+};


 struct RomDatabaseEntry {
@@ -267,6 +276,25 @@ auto GetRomIcon(fs::FsNative* fs, ProgressBox* pbox, std::string filename, const

 Menu::Menu(const std::vector<NroEntry>& nro_entries) : MenuBase{"FileBrowser"_i18n}, m_nro_entries{nro_entries} {
    this->SetActions(
+        std::make_pair(Button::L2, Action{[this](){
+            if (!m_selected_files.empty()) {
+                ResetSelection();
+            }
+
+            const auto set = m_selected_count != m_entries_current.size();
+
+            for (u32 i = 0; i < m_entries_current.size(); i++) {
+                auto& e = GetEntry(i);
+                if (e.selected != set) {
+                    e.selected = set;
+                    if (set) {
+                        m_selected_count++;
+                    } else {
+                        m_selected_count--;
+                    }
+                }
+            }
+        }}),
        std::make_pair(Button::R2, Action{[this](){
            if (!m_selected_files.empty()) {
                ResetSelection();
@@ -384,17 +412,17 @@ Menu::Menu(const std::vector<NroEntry>& nro_entries) : MenuBase{"FileBrowser"_i1
                options->Add(std::make_shared<SidebarEntryBool>("Show Hidden"_i18n, m_show_hidden.Get(), [this](bool& v_out){
                    m_show_hidden.Set(v_out);
                    SortAndFindLastFile();
-                }, "Yes"_i18n, "No"_i18n));
+                }));

                options->Add(std::make_shared<SidebarEntryBool>("Folders First"_i18n, m_folders_first.Get(), [this](bool& v_out){
                    m_folders_first.Set(v_out);
                    SortAndFindLastFile();
-                }, "Yes"_i18n, "No"_i18n));
+                }));

                options->Add(std::make_shared<SidebarEntryBool>("Hidden Last"_i18n, m_hidden_last.Get(), [this](bool& v_out){
                    m_hidden_last.Set(v_out);
                    SortAndFindLastFile();
-                }, "Yes"_i18n, "No"_i18n));
+                }));
            }));

            if (m_entries_current.size()) {
@@ -475,22 +503,24 @@ Menu::Menu(const std::vector<NroEntry>& nro_entries) : MenuBase{"FileBrowser"_i1
                }));
            }

-            // if install is enabled, check if all currently selected files are installable.
-            if (m_entries_current.size() && App::GetInstallEnable()) {
-                bool should_install = true;
+            // returns true if all entries match the ext array.
+            const auto check_all_ext = [this](auto& exts){
                if (!m_selected_count) {
-                    should_install = IsExtension(GetEntry().GetExtension(), INSTALL_EXTENSIONS);
+                    return IsExtension(GetEntry().GetExtension(), exts);
                } else {
                    const auto entries = GetSelectedEntries();
                    for (auto&e : entries) {
-                        if (!IsExtension(e.GetExtension(), INSTALL_EXTENSIONS)) {
-                            should_install = false;
-                            break;
+                        if (!IsExtension(e.GetExtension(), exts)) {
+                            return false;
                        }
                    }
                }
+                return true;
+            };

-                if (should_install) {
+            // if install is enabled, check if all currently selected files are installable.
+            if (m_entries_current.size() && App::GetInstallEnable()) {
+                if (check_all_ext(INSTALL_EXTENSIONS)) {
                    options->Add(std::make_shared<SidebarEntryCallback>("Install"_i18n, [this](){
                        if (!m_selected_count) {
                            InstallFile(GetEntry());
@@ -501,6 +531,92 @@ Menu::Menu(const std::vector<NroEntry>& nro_entries) : MenuBase{"FileBrowser"_i1
                }
            }

+            if (m_fs_type == FsType::Sd && m_entries_current.size()) {
+                if (App::GetInstallEnable() && HasTypeInSelectedEntries(FsDirEntryType_File) && !m_selected_count && (GetEntry().GetExtension() == "nro" || !FindFileAssocFor().empty())) {
+                    options->Add(std::make_shared<SidebarEntryCallback>("Install Forwarder"_i18n, [this](){;
+                        if (App::GetInstallPrompt()) {
+                            App::Push(std::make_shared<OptionBox>(
+                                "WARNING: Installing forwarders will lead to a ban!"_i18n,
+                                "Back"_i18n, "Install"_i18n, 0, [this](auto op_index){
+                                    if (op_index && *op_index) {
+                                        InstallForwarder();
+                                    }
+                                }
+                            ));
+                        } else {
+                            InstallForwarder();
+                        }
+                    }));
+                }
+            }
+
+            if (m_entries_current.size()) {
+                if (check_all_ext(ZIP_EXTENSIONS)) {
+                    options->Add(std::make_shared<SidebarEntryCallback>("Extract zip"_i18n, [this](){
+                        auto options = std::make_shared<Sidebar>("Extract Options"_i18n, Sidebar::Side::RIGHT);
+                        ON_SCOPE_EXIT(App::Push(options));
+
+                        options->Add(std::make_shared<SidebarEntryCallback>("Extract here"_i18n, [this](){
+                            if (!m_selected_count) {
+                                UnzipFile("", GetEntry());
+                            } else {
+                                UnzipFiles("", GetSelectedEntries());
+                            }
+                        }));
+
+                        options->Add(std::make_shared<SidebarEntryCallback>("Extract to root"_i18n, [this](){
+                            App::Push(std::make_shared<OptionBox>("Are you sure you want to extract to root?"_i18n,
+                                "No"_i18n, "Yes"_i18n, 0, [this](auto op_index){
+                                if (op_index && *op_index) {
+                                    if (!m_selected_count) {
+                                        UnzipFile("/", GetEntry());
+                                    } else {
+                                        UnzipFiles("/", GetSelectedEntries());
+                                    }
+                                }
+                            }));
+                        }));
+
+                        options->Add(std::make_shared<SidebarEntryCallback>("Extract to..."_i18n, [this](){
+                            std::string out;
+                            if (R_SUCCEEDED(swkbd::ShowText(out, "Enter the path to the folder to extract into", fs::AppendPath(m_path, ""))) && !out.empty()) {
+                                if (!m_selected_count) {
+                                    UnzipFile(out, GetEntry());
+                                } else {
+                                    UnzipFiles(out, GetSelectedEntries());
+                                }
+                            }
+                        }));
+                    }));
+                }
+
+                if (!check_all_ext(ZIP_EXTENSIONS) || m_selected_count) {
+                    options->Add(std::make_shared<SidebarEntryCallback>("Compress to zip"_i18n, [this](){
+                        auto options = std::make_shared<Sidebar>("Compress Options"_i18n, Sidebar::Side::RIGHT);
+                        ON_SCOPE_EXIT(App::Push(options));
+
+                        options->Add(std::make_shared<SidebarEntryCallback>("Compress"_i18n, [this](){
+                            if (!m_selected_count) {
+                                ZipFile("", GetEntry());
+                            } else {
+                                ZipFiles("", GetSelectedEntries());
+                            }
+                        }));
+
+                        options->Add(std::make_shared<SidebarEntryCallback>("Compress to..."_i18n, [this](){
+                            std::string out;
+                            if (R_SUCCEEDED(swkbd::ShowText(out, "Enter the path to the folder to extract into", m_path)) && !out.empty()) {
+                                if (!m_selected_count) {
+                                    ZipFile(out, GetEntry());
+                                } else {
+                                    ZipFiles(out, GetSelectedEntries());
+                                }
+                            }
+                        }));
+                    }));
+                }
+            }
+
            options->Add(std::make_shared<SidebarEntryCallback>("Advanced"_i18n, [this](){
                auto options = std::make_shared<Sidebar>("Advanced Options"_i18n, Sidebar::Side::RIGHT);
                ON_SCOPE_EXIT(App::Push(options));
@@ -529,7 +645,7 @@ Menu::Menu(const std::vector<NroEntry>& nro_entries) : MenuBase{"FileBrowser"_i1

                options->Add(std::make_shared<SidebarEntryCallback>("Create Folder"_i18n, [this](){
                    std::string out;
-                    if (R_SUCCEEDED(swkbd::ShowText(out, "Set Folder Name"_i18n.c_str())) && !out.empty()) {
+                    if (R_SUCCEEDED(swkbd::ShowText(out, "Set Folder Name"_i18n.c_str(), fs::AppendPath(m_path, ""))) && !out.empty()) {
                        App::PopToMenu();

                        fs::FsPath full_path;
@@ -554,29 +670,10 @@ Menu::Menu(const std::vector<NroEntry>& nro_entries) : MenuBase{"FileBrowser"_i1
                    }));
                }

-                if (m_fs_type == FsType::Sd && m_entries_current.size()) {
-                    if (App::GetInstallEnable() && HasTypeInSelectedEntries(FsDirEntryType_File) && !m_selected_count && (GetEntry().GetExtension() == "nro" || !FindFileAssocFor().empty())) {
-                        options->Add(std::make_shared<SidebarEntryCallback>("Install Forwarder"_i18n, [this](){;
-                            if (App::GetInstallPrompt()) {
-                                App::Push(std::make_shared<OptionBox>(
-                                    "WARNING: Installing forwarders will lead to a ban!"_i18n,
-                                    "Back"_i18n, "Install"_i18n, 0, [this](auto op_index){
-                                        if (op_index && *op_index) {
-                                            InstallForwarder();
-                                        }
-                                    }
-                                ));
-                            } else {
-                                InstallForwarder();
-                            }
-                        }));
-                    }
-                }
-
                options->Add(std::make_shared<SidebarEntryBool>("Ignore read only"_i18n, m_ignore_read_only.Get(), [this](bool& v_out){
                    m_ignore_read_only.Set(v_out);
                    m_fs->SetIgnoreReadOnly(v_out);
-                }, "Yes"_i18n, "No"_i18n));
+                }));

                SidebarEntryArray::Items mount_items;
                mount_items.push_back("Sd"_i18n);
@@ -650,7 +747,8 @@ void Menu::Draw(NVGcontext* vg, Theme* theme) {
        }

        auto text_id = ThemeEntryID_TEXT;
-        if (m_index == i) {
+        const auto selected = m_index == i;
+        if (selected) {
            text_id = ThemeEntryID_TEXT_SELECTED;
            gfx::drawRectOutline(vg, theme, 4.f, v);
        } else {
@@ -673,7 +771,7 @@ void Menu::Draw(NVGcontext* vg, Theme* theme) {
            } else if (IsExtension(ext, INSTALL_EXTENSIONS)) {
                // todo: maybe replace this icon with something else?
                icon = ThemeEntryID_ICON_NRO;
-            } else if (IsExtension(ext, "zip")) {
+            } else if (IsExtension(ext, ZIP_EXTENSIONS)) {
                icon = ThemeEntryID_ICON_ZIP;
            } else if (IsExtension(ext, "nro")) {
                icon = ThemeEntryID_ICON_NRO;
@@ -848,6 +946,272 @@ void Menu::InstallFiles(const std::vector<FileEntry>& targets) {
    }));
 }

+void Menu::UnzipFile(const fs::FsPath& dir_path, const FileEntry& target) {
+    std::vector<FileEntry> targets{target};
+    UnzipFiles(dir_path, targets);
+}
+
+void Menu::UnzipFiles(fs::FsPath dir_path, const std::vector<FileEntry>& targets) {
+    // set to current path.
+    if (dir_path.empty()) {
+        dir_path = m_path;
+    }
+
+    App::Push(std::make_shared<ui::ProgressBox>(0, "Extracting "_i18n, "", [this, dir_path, targets](auto pbox) mutable -> bool {
+        constexpr auto chunk_size = 1024 * 512; // 512KiB
+        auto& fs = *m_fs.get();
+
+        for (auto& e : targets) {
+            pbox->SetTitle(e.GetName());
+
+            const auto zip_out = GetNewPath(e);
+            auto zfile = unzOpen64(zip_out);
+            if (!zfile) {
+                log_write("failed to open zip: %s\n", zip_out.s);
+                return false;
+            }
+            ON_SCOPE_EXIT(unzClose(zfile));
+
+            unz_global_info64 pglobal_info;
+            if (UNZ_OK != unzGetGlobalInfo64(zfile, &pglobal_info)) {
+                return false;
+            }
+
+            for (int i = 0; i < pglobal_info.number_entry; i++) {
+                if (i > 0) {
+                    if (UNZ_OK != unzGoToNextFile(zfile)) {
+                        log_write("failed to unzGoToNextFile\n");
+                        return false;
+                    }
+                }
+
+                if (UNZ_OK != unzOpenCurrentFile(zfile)) {
+                    log_write("failed to open current file\n");
+                    return false;
+                }
+                ON_SCOPE_EXIT(unzCloseCurrentFile(zfile));
+
+                unz_file_info64 info;
+                char name[512];
+                if (UNZ_OK != unzGetCurrentFileInfo64(zfile, &info, name, sizeof(name), 0, 0, 0, 0)) {
+                    log_write("failed to get current info\n");
+                    return false;
+                }
+
+                const auto file_path = fs::AppendPath(dir_path, name);
+                pbox->NewTransfer(name);
+
+                // create directories
+                fs.CreateDirectoryRecursivelyWithPath(file_path);
+
+                Result rc;
+                if (R_FAILED(rc = fs.CreateFile(file_path, info.uncompressed_size, 0)) && rc != FsError_PathAlreadyExists) {
+                    log_write("failed to create file: %s 0x%04X\n", file_path.s, rc);
+                    return false;
+                }
+
+                FsFile f;
+                if (R_FAILED(rc = fs.OpenFile(file_path, FsOpenMode_Write, &f))) {
+                    log_write("failed to open file: %s 0x%04X\n", file_path.s, rc);
+                    return false;
+                }
+                ON_SCOPE_EXIT(fsFileClose(&f));
+
+                if (R_FAILED(rc = fsFileSetSize(&f, info.uncompressed_size))) {
+                    log_write("failed to set file size: %s 0x%04X\n", file_path.s, rc);
+                    return false;
+                }
+
+                std::vector<char> buf(chunk_size);
+                s64 offset{};
+                while (offset < info.uncompressed_size) {
+                    if (pbox->ShouldExit()) {
+                        return false;
+                    }
+
+                    const auto bytes_read = unzReadCurrentFile(zfile, buf.data(), buf.size());
+                    if (bytes_read <= 0) {
+                        log_write("failed to read zip file: %s\n", name);
+                        return false;
+                    }
+
+                    if (R_FAILED(rc = fsFileWrite(&f, offset, buf.data(), bytes_read, FsWriteOption_None))) {
+                        log_write("failed to write file: %s 0x%04X\n", file_path.s, rc);
+                        return false;
+                    }
+
+                    pbox->UpdateTransfer(offset, info.uncompressed_size);
+                    offset += bytes_read;
+                }
+            }
+        }
+
+        return true;
+    }, [this](bool success){
+        if (success) {
+            App::Notify("Extract success!");
+        } else {
+            App::Notify("Extract failed!");
+        }
+        Scan(m_path);
+        log_write("did extract\n");
+    }));
+}
+
+void Menu::ZipFile(const fs::FsPath& zip_path, const FileEntry& target) {
+    std::vector<FileEntry> targets{target};
+    ZipFiles(zip_path, targets);
+}
+
+void Menu::ZipFiles(fs::FsPath zip_out, const std::vector<FileEntry>& targets) {
+    // set to current path.
+    if (zip_out.empty()) {
+        if (std::size(targets) == 1) {
+            const auto name = targets[0].name;
+            const auto ext = std::strrchr(targets[0].name, '.');
+            fs::FsPath file_path;
+            if (!ext) {
+                std::snprintf(file_path, sizeof(file_path), "%s.zip", name);
+            } else {
+                std::snprintf(file_path, sizeof(file_path), "%.*s.zip", (int)(ext - name), name);
+            }
+            zip_out = fs::AppendPath(m_path, file_path);
+            log_write("zip out: %s name: %s file_path: %s\n", zip_out.s, name, file_path.s);
+        } else {
+            // loop until we find an unused file name.
+            for (u64 i = 0; ; i++) {
+                fs::FsPath file_path = "Archive.zip";
+                if (i) {
+                    std::snprintf(file_path, sizeof(file_path), "Archive (%zu).zip", i);
+                }
+
+                zip_out = fs::AppendPath(m_path, file_path);
+                if (!fs::FileExists(&m_fs->m_fs, zip_out)) {
+                    break;
+                }
+            }
+        }
+    } else {
+        if (!std::string_view(zip_out).ends_with(".zip")) {
+            zip_out += ".zip";
+        }
+    }
+
+    App::Push(std::make_shared<ui::ProgressBox>(0, "Compressing "_i18n, "", [this, zip_out, targets](auto pbox) mutable -> bool {
+        constexpr auto chunk_size = 1024 * 512; // 512KiB
+        auto& fs = *m_fs.get();
+
+        const auto t = std::time(NULL);
+        const auto tm = std::localtime(&t);
+
+        // pre-calculate the time rather than calculate it in the loop.
+        zip_fileinfo zip_info{};
+        zip_info.tmz_date.tm_sec = tm->tm_sec;
+        zip_info.tmz_date.tm_min = tm->tm_min;
+        zip_info.tmz_date.tm_hour = tm->tm_hour;
+        zip_info.tmz_date.tm_mday = tm->tm_mday;
+        zip_info.tmz_date.tm_mon = tm->tm_mon;
+        zip_info.tmz_date.tm_year = tm->tm_year;
+
+        auto zfile = zipOpen(zip_out, APPEND_STATUS_CREATE);
+        if (!zfile) {
+            log_write("failed to open zip: %s\n", zip_out.s);
+            return false;
+        }
+        ON_SCOPE_EXIT(zipClose(zfile, "sphaira v" APP_VERSION_HASH));
+
+        const auto zip_add = [&](const fs::FsPath& file_path){
+            // the file name needs to be relative to the current directory.
+            const char* file_name_in_zip = file_path.s + std::strlen(m_path);
+
+            // root paths are banned in zips, they will warn when extracting otherwise.
+            if (file_name_in_zip[0] == '/') {
+                file_name_in_zip++;
+            }
+
+            pbox->NewTransfer(file_name_in_zip);
+
+            const auto ext = std::strrchr(file_name_in_zip, '.');
+            const auto raw = ext && IsExtension(ext + 1, COMPRESSED_EXTENSIONS);
+
+            if (ZIP_OK != zipOpenNewFileInZip2(zfile, file_name_in_zip, &zip_info, NULL, 0, NULL, 0, NULL, Z_DEFLATED, Z_DEFAULT_COMPRESSION, raw)) {
+                return false;
+            }
+            ON_SCOPE_EXIT(zipCloseFileInZip(zfile));
+
+            FsFile f;
+            Result rc;
+            if (R_FAILED(rc = fs.OpenFile(file_path, FsOpenMode_Read, &f))) {
+                log_write("failed to open file: %s 0x%04X\n", file_path.s, rc);
+                return false;
+            }
+            ON_SCOPE_EXIT(fsFileClose(&f));
+
+            s64 file_size;
+            if (R_FAILED(rc = fsFileGetSize(&f, &file_size))) {
+                log_write("failed to get file size: %s 0x%04X\n", file_path.s, rc);
+                return false;
+            }
+
+            std::vector<char> buf(chunk_size);
+            s64 offset{};
+            while (offset < file_size) {
+                if (pbox->ShouldExit()) {
+                    return false;
+                }
+
+                u64 bytes_read;
+                if (R_FAILED(rc = fsFileRead(&f, offset, buf.data(), buf.size(), FsReadOption_None, &bytes_read))) {
+                    log_write("failed to write file: %s 0x%04X\n", file_path.s, rc);
+                    return false;
+                }
+
+                if (ZIP_OK != zipWriteInFileInZip(zfile, buf.data(), bytes_read)) {
+                    log_write("failed to write zip file: %s\n", file_path.s);
+                    return false;
+                }
+
+                pbox->UpdateTransfer(offset, file_size);
+                offset += bytes_read;
+            }
+
+            return true;
+        };
+
+        for (auto& e : targets) {
+            pbox->SetTitle(e.GetName());
+            if (e.IsFile()) {
+                const auto file_path = GetNewPath(e);
+                if (!zip_add(file_path)) {
+                    return false;
+                }
+            } else {
+                FsDirCollections collections;
+                get_collections(GetNewPath(e), e.name, collections);
+
+                for (const auto& collection : collections) {
+                    for (const auto& file : collection.files) {
+                        const auto file_path = fs::AppendPath(collection.path, file.name);
+                        if (!zip_add(file_path)) {
+                            return false;
+                        }
+                    }
+                }
+            }
+        }
+
+        return true;
+    }, [this](bool success){
+        if (success) {
+            App::Notify("Compress success!");
+        } else {
+            App::Notify("Compress failed!");
+        }
+        Scan(m_path);
+        log_write("did compress\n");
+    }));
+}
+
 auto Menu::Scan(const fs::FsPath& new_path, bool is_walk_up) -> Result {
    log_write("new scan path: %s\n", new_path.s);
    if (!is_walk_up && !m_path.empty() && !m_entries_current.empty()) {
--- a/sphaira/source/ui/menus/game_menu.cpp
+++ b/sphaira/source/ui/menus/game_menu.cpp
@@ -0,0 +1,452 @@
+#include "app.hpp"
+#include "log.hpp"
+#include "fs.hpp"
+#include "ui/menus/game_menu.hpp"
+#include "ui/sidebar.hpp"
+#include "ui/error_box.hpp"
+#include "ui/option_box.hpp"
+#include "ui/progress_box.hpp"
+#include "ui/popup_list.hpp"
+#include "ui/nvg_util.hpp"
+#include "defines.hpp"
+#include "i18n.hpp"
+#include "yati/nx/ncm.hpp"
+
+#include <utility>
+#include <cstring>
+
+namespace sphaira::ui::menu::game {
+namespace {
+
+// thank you Shchmue ^^
+struct ApplicationOccupiedSizeEntry {
+    u8 storageId;
+    u8 padding[0x7];
+    u64 sizeApplication;
+    u64 sizePatch;
+    u64 sizeAddOnContent;
+};
+
+struct ApplicationOccupiedSize {
+    ApplicationOccupiedSizeEntry entry[4];
+};
+
+static_assert(sizeof(ApplicationOccupiedSize) == sizeof(NsApplicationOccupiedSize));
+
+using MetaEntries = std::vector<NsApplicationContentMetaStatus>;
+
+Result Notify(Result rc, const std::string& error_message) {
+    if (R_FAILED(rc)) {
+        App::Push(std::make_shared<ui::ErrorBox>(rc,
+            i18n::get(error_message)
+        ));
+    } else {
+        App::Notify("Success");
+    }
+
+    return rc;
+}
+
+Result GetMetaEntries(const Entry& e, MetaEntries& out) {
+    s32 count;
+    R_TRY(nsCountApplicationContentMeta(e.app_id, &count));
+
+    out.resize(count);
+    R_TRY(nsListApplicationContentMetaStatus(e.app_id, 0, out.data(), out.size(), &count));
+
+    out.resize(count);
+    R_SUCCEED();
+}
+
+// also sets the status to error.
+void FakeNacpEntry(Entry& e) {
+    e.status = NacpLoadStatus::Error;
+    // fake the nacp entry
+    std::strcpy(e.lang.name, "Corrupted");
+    std::strcpy(e.lang.author, "Corrupted");
+    std::strcpy(e.display_version, "0.0.0");
+    e.control.reset();
+}
+
+bool LoadControlImage(Entry& e) {
+    if (!e.image && e.control) {
+        const auto jpeg_size = e.control_size - sizeof(NacpStruct);
+        e.image = nvgCreateImageMem(App::GetVg(), 0, e.control->icon, jpeg_size);
+        e.control.reset();
+        return true;
+    }
+
+    return false;
+}
+
+void LoadControlEntry(Entry& e, bool force_image_load = false) {
+    if (e.status == NacpLoadStatus::None) {
+        e.control = std::make_unique<NsApplicationControlData>();
+        if (R_FAILED(nsGetApplicationControlData(NsApplicationControlSource_Storage, e.app_id, e.control.get(), sizeof(NsApplicationControlData), &e.control_size))) {
+            FakeNacpEntry(e);
+        } else {
+            NacpLanguageEntry* lang{};
+            if (R_FAILED(nsGetApplicationDesiredLanguage(&e.control->nacp, &lang)) || !lang) {
+                FakeNacpEntry(e);
+            } else {
+                e.lang = *lang;
+                std::memcpy(e.display_version, e.control->nacp.display_version, sizeof(e.display_version));
+                e.status = NacpLoadStatus::Loaded;
+
+                if (force_image_load) {
+                    LoadControlImage(e);
+                }
+            }
+        }
+    }
+}
+
+void FreeEntry(NVGcontext* vg, Entry& e) {
+    nvgDeleteImage(vg, e.image);
+    e.image = 0;
+}
+
+void LaunchEntry(const Entry& e) {
+    const auto rc = appletRequestLaunchApplication(e.app_id, nullptr);
+    Notify(rc, "Failed to launch application");
+}
+
+} // namespace
+
+Menu::Menu() : MenuBase{"Games"_i18n} {
+    this->SetActions(
+        std::make_pair(Button::B, Action{"Back"_i18n, [this](){
+            SetPop();
+        }}),
+        std::make_pair(Button::A, Action{"Launch"_i18n, [this](){
+            if (m_entries.empty()) {
+                return;
+            }
+            LaunchEntry(m_entries[m_index]);
+        }}),
+        std::make_pair(Button::X, Action{"Options"_i18n, [this](){
+            auto options = std::make_shared<Sidebar>("Game Options"_i18n, Sidebar::Side::RIGHT);
+            ON_SCOPE_EXIT(App::Push(options));
+
+            if (m_entries.size()) {
+                options->Add(std::make_shared<SidebarEntryCallback>("Sort By"_i18n, [this](){
+                    auto options = std::make_shared<Sidebar>("Sort Options"_i18n, Sidebar::Side::RIGHT);
+                    ON_SCOPE_EXIT(App::Push(options));
+
+                    SidebarEntryArray::Items sort_items;
+                    sort_items.push_back("Updated"_i18n);
+
+                    SidebarEntryArray::Items order_items;
+                    order_items.push_back("Descending"_i18n);
+                    order_items.push_back("Ascending"_i18n);
+
+                    options->Add(std::make_shared<SidebarEntryArray>("Sort"_i18n, sort_items, [this, sort_items](s64& index_out){
+                        m_sort.Set(index_out);
+                        SortAndFindLastFile();
+                    }, m_sort.Get()));
+
+                    options->Add(std::make_shared<SidebarEntryArray>("Order"_i18n, order_items, [this, order_items](s64& index_out){
+                        m_order.Set(index_out);
+                        SortAndFindLastFile();
+                    }, m_order.Get()));
+
+                    options->Add(std::make_shared<SidebarEntryBool>("Hide forwarders"_i18n, m_hide_forwarders.Get(), [this](bool& v_out){
+                        m_hide_forwarders.Set(v_out);
+                        m_dirty = true;
+                    }));
+                }));
+
+                #if 0
+                options->Add(std::make_shared<SidebarEntryCallback>("Info"_i18n, [this](){
+
+                }));
+                #endif
+
+                options->Add(std::make_shared<SidebarEntryCallback>("Launch random game"_i18n, [this](){
+                    const auto random_index = randomGet64() % std::size(m_entries);
+                    auto& e = m_entries[random_index];
+                    LoadControlEntry(e, true);
+
+                    App::Push(std::make_shared<OptionBox>(
+                        "Launch "_i18n + e.GetName(),
+                        "Back"_i18n, "Launch"_i18n, 1, [this, &e](auto op_index){
+                            if (op_index && *op_index) {
+                                LaunchEntry(e);
+                            }
+                        }, e.image
+                    ));
+                }));
+
+                options->Add(std::make_shared<SidebarEntryCallback>("List meta records"_i18n, [this](){
+                    MetaEntries meta_entries;
+                    const auto rc = GetMetaEntries(m_entries[m_index], meta_entries);
+                    if (R_FAILED(rc)) {
+                        App::Push(std::make_shared<ui::ErrorBox>(rc,
+                            i18n::get("Failed to list application meta entries")
+                        ));
+                        return;
+                    }
+
+                    if (meta_entries.empty()) {
+                        App::Notify("No meta entries found...\n");
+                        return;
+                    }
+
+                    PopupList::Items items;
+                    for (auto& e : meta_entries) {
+                        char buf[256];
+                        std::snprintf(buf, sizeof(buf), "Type: %s Storage: %s [%016lX][v%u]", ncm::GetMetaTypeStr(e.meta_type), ncm::GetStorageIdStr(e.storageID), e.application_id, e.version);
+                        items.emplace_back(buf);
+                    }
+
+                    App::Push(std::make_shared<PopupList>(
+                        "Entries", items, [this, meta_entries](auto op_index){
+                            #if 0
+                            if (op_index) {
+                                const auto& e = meta_entries[*op_index];
+                            }
+                            #endif
+                        }
+                    ));
+                }));
+
+                // completely deletes the application record and all data.
+                options->Add(std::make_shared<SidebarEntryCallback>("Delete"_i18n, [this](){
+                    const auto buf = "Are you sure you want to delete "_i18n + m_entries[m_index].GetName() + "?";
+                    App::Push(std::make_shared<OptionBox>(
+                        buf,
+                        "Back"_i18n, "Delete"_i18n, 0, [this](auto op_index){
+                            if (op_index && *op_index) {
+                                const auto rc = nsDeleteApplicationCompletely(m_entries[m_index].app_id);
+                                if (R_SUCCEEDED(Notify(rc, "Failed to delete application"))) {
+                                    FreeEntry(App::GetVg(), m_entries[m_index]);
+                                    m_entries.erase(m_entries.begin() + m_index);
+                                    SetIndex(m_index ? m_index - 1 : 0);
+                                }
+                            }
+                        }, m_entries[m_index].image
+                    ));
+                }, true));
+
+                // removes installed data but keeps the record, basically archiving.
+                options->Add(std::make_shared<SidebarEntryCallback>("Delete entity"_i18n, [this](){
+                    const auto buf = "Are you sure you want to delete "_i18n + m_entries[m_index].GetName() + "?";
+                    App::Push(std::make_shared<OptionBox>(
+                        buf,
+                        "Back"_i18n, "Delete"_i18n, 0, [this](auto op_index){
+                            if (op_index && *op_index) {
+                                const auto rc = nsDeleteApplicationEntity(m_entries[m_index].app_id);
+                                Notify(rc, "Failed to delete application");
+                            }
+                        }, m_entries[m_index].image
+                    ));
+                }, true));
+            }
+        }})
+    );
+
+    const Vec4 v{75, 110, 370, 155};
+    const Vec2 pad{10, 10};
+    m_list = std::make_unique<List>(3, 9, m_pos, v, pad);
+    nsInitialize();
+}
+
+Menu::~Menu() {
+    FreeEntries();
+    nsExit();
+}
+
+void Menu::Update(Controller* controller, TouchInfo* touch) {
+    MenuBase::Update(controller, touch);
+    m_list->OnUpdate(controller, touch, m_index, m_entries.size(), [this](bool touch, auto i) {
+        if (touch && m_index == i) {
+            FireAction(Button::A);
+        } else {
+            App::PlaySoundEffect(SoundEffect_Focus);
+            SetIndex(i);
+        }
+    });
+}
+
+void Menu::Draw(NVGcontext* vg, Theme* theme) {
+    MenuBase::Draw(vg, theme);
+
+    // max images per frame, in order to not hit io / gpu too hard.
+    const int image_load_max = 2;
+    int image_load_count = 0;
+
+    m_list->Draw(vg, theme, m_entries.size(), [this, &image_load_count](auto* vg, auto* theme, auto v, auto pos) {
+        const auto& [x, y, w, h] = v;
+        auto& e = m_entries[pos];
+
+        if (e.status == NacpLoadStatus::None) {
+            LoadControlEntry(e);
+        }
+
+        // lazy load image
+        if (image_load_count < image_load_max) {
+            if (LoadControlImage(e)) {
+                image_load_count++;
+            }
+        }
+
+        auto text_id = ThemeEntryID_TEXT;
+        const auto selected = pos == m_index;
+        if (selected) {
+            text_id = ThemeEntryID_TEXT_SELECTED;
+            gfx::drawRectOutline(vg, theme, 4.f, v);
+        } else {
+            DrawElement(v, ThemeEntryID_GRID);
+        }
+
+        const float image_size = 115;
+        gfx::drawImage(vg, x + 20, y + 20, image_size, image_size, e.image ? e.image : App::GetDefaultImage(), 5);
+
+        const auto text_off = 148;
+        const auto text_x = x + text_off;
+        const auto text_clip_w = w - 30.f - text_off;
+        const float font_size = 18;
+        m_scroll_name.Draw(vg, selected, text_x, y + 45, text_clip_w, font_size, NVG_ALIGN_LEFT, theme->GetColour(text_id), e.GetName());
+        m_scroll_author.Draw(vg, selected, text_x, y + 80, text_clip_w, font_size, NVG_ALIGN_LEFT, theme->GetColour(text_id), e.GetAuthor());
+        m_scroll_version.Draw(vg, selected, text_x, y + 115, text_clip_w, font_size, NVG_ALIGN_LEFT, theme->GetColour(text_id), e.GetDisplayVersion());
+    });
+}
+
+void Menu::OnFocusGained() {
+    MenuBase::OnFocusGained();
+    if (m_dirty || m_entries.empty()) {
+        ScanHomebrew();
+    }
+}
+
+void Menu::SetIndex(s64 index) {
+    m_index = index;
+    if (!m_index) {
+        m_list->SetYoff(0);
+    }
+
+    char title_id[33];
+    std::snprintf(title_id, sizeof(title_id), "%016lX", m_entries[m_index].app_id);
+    SetTitleSubHeading(title_id);
+    this->SetSubHeading(std::to_string(m_index + 1) + " / " + std::to_string(m_entries.size()));
+}
+
+void Menu::ScanHomebrew() {
+    constexpr auto ENTRY_CHUNK_COUNT = 1000;
+    const auto hide_forwarders = m_hide_forwarders.Get();
+    TimeStamp ts;
+
+    FreeEntries();
+    m_entries.reserve(ENTRY_CHUNK_COUNT);
+
+    std::vector<NsApplicationRecord> record_list(ENTRY_CHUNK_COUNT);
+    s32 offset{};
+    while (true) {
+        s32 record_count{};
+        if (R_FAILED(nsListApplicationRecord(record_list.data(), record_list.size(), offset, &record_count))) {
+            log_write("failed to list application records at offset: %d\n", offset);
+        }
+
+        // finished parsing all entries.
+        if (!record_count) {
+            break;
+        }
+
+        for (s32 i = 0; i < record_count; i++) {
+            const auto& e = record_list[i];
+            #if 0
+            u8 unk_x09 = e.unk_x09;
+            u64 unk_x0a;// = e.unk_x0a;
+            u8 unk_x10 = e.unk_x10;
+            u64 unk_x11;// = e.unk_x11;
+            memcpy(&unk_x0a, e.unk_x0a, sizeof(e.unk_x0a));
+            memcpy(&unk_x11, e.unk_x11, sizeof(e.unk_x11));
+            log_write("ID: %016lx got type: %u unk_x09: %u unk_x0a: %zu unk_x10: %u unk_x11: %zu\n", e.application_id, e.type,
+                unk_x09,
+                unk_x0a,
+                unk_x10,
+                unk_x11
+            );
+            #endif
+            if (hide_forwarders && (e.application_id & 0x0500000000000000) == 0x0500000000000000) {
+                continue;
+            }
+
+            s64 size{};
+            // code for sorting by size, it's too slow however...
+            #if 0
+            ApplicationOccupiedSize occupied_size;
+            if (R_SUCCEEDED(nsCalculateApplicationOccupiedSize(e.application_id, (NsApplicationOccupiedSize*)&occupied_size))) {
+                for (auto& s : occupied_size.entry) {
+                    size += s.sizeApplication;
+                    size += s.sizePatch;
+                    size += s.sizeAddOnContent;
+                }
+            }
+            #endif
+
+            m_entries.emplace_back(e.application_id, size);
+        }
+
+        offset += record_count;
+    }
+
+    m_is_reversed = false;
+    m_dirty = false;
+    log_write("games found: %zu time_taken: %.2f seconds %zu ms %zu ns\n", m_entries.size(), ts.GetSecondsD(), ts.GetMs(), ts.GetNs());
+    this->Sort();
+    SetIndex(0);
+}
+
+void Menu::Sort() {
+    // const auto sort = m_sort.Get();
+    const auto order = m_order.Get();
+
+    if (order == OrderType_Ascending) {
+        if (!m_is_reversed) {
+            std::reverse(m_entries.begin(), m_entries.end());
+            m_is_reversed = true;
+        }
+    } else {
+        if (m_is_reversed) {
+            std::reverse(m_entries.begin(), m_entries.end());
+            m_is_reversed = false;
+        }
+    }
+}
+
+void Menu::SortAndFindLastFile() {
+    const auto app_id = m_entries[m_index].app_id;
+    Sort();
+    SetIndex(0);
+
+    s64 index = -1;
+    for (u64 i = 0; i < m_entries.size(); i++) {
+        if (app_id == m_entries[i].app_id) {
+            index = i;
+            break;
+        }
+    }
+
+    if (index >= 0) {
+        // guesstimate where the position is
+        if (index >= 9) {
+            m_list->SetYoff((((index - 9) + 3) / 3) * m_list->GetMaxY());
+        } else {
+            m_list->SetYoff(0);
+        }
+        SetIndex(index);
+    }
+}
+
+void Menu::FreeEntries() {
+    auto vg = App::GetVg();
+
+    for (auto&p : m_entries) {
+        FreeEntry(vg, p);
+    }
+
+    m_entries.clear();
+}
+
+} // namespace sphaira::ui::menu::game
--- a/sphaira/source/ui/menus/gc_menu.cpp
+++ b/sphaira/source/ui/menus/gc_menu.cpp
@@ -44,6 +44,13 @@ auto BuildGcPath(const char* name, const FsGameCardHandle* handle, FsGameCardPar
    return path;
 }

+Result fsOpenGameCardDetectionEventNotifier(FsEventNotifier* out) {
+    return serviceDispatch(fsGetServiceSession(), 501,
+        .out_num_objects = 1,
+        .out_objects = &out->s
+    );
+}
+
 auto InRange(u64 off, u64 offset, u64 size) -> bool {
    return off < offset + size && off >= offset;
 }
@@ -175,29 +182,22 @@ Menu::Menu() : MenuBase{"GameCard"_i18n} {
    m_list = std::make_unique<List>(1, 3, m_pos, v, pad);

    fsOpenDeviceOperator(std::addressof(m_dev_op));
-    UpdateStorageSize();
+    fsOpenGameCardDetectionEventNotifier(std::addressof(m_event_notifier));
+    fsEventNotifierGetEventHandle(std::addressof(m_event_notifier), std::addressof(m_event), true);
 }

 Menu::~Menu() {
    GcUnmount();
+    eventClose(std::addressof(m_event));
+    fsEventNotifierClose(std::addressof(m_event_notifier));
    fsDeviceOperatorClose(std::addressof(m_dev_op));
 }

 void Menu::Update(Controller* controller, TouchInfo* touch) {
    // poll for the gamecard first before handling inputs as the gamecard
    // may have been removed, thus pressing A would fail.
-    bool inserted{};
-    GcPoll(&inserted);
-    if (m_mounted != inserted) {
-        log_write("gc state changed\n");
-        m_mounted = inserted;
-        if (m_mounted) {
-            log_write("trying to mount\n");
-            m_mounted = R_SUCCEEDED(GcMount());
-        } else {
-            log_write("trying to unmount\n");
-            GcUnmount();
-        }
+    if (R_SUCCEEDED(eventWait(std::addressof(m_event), 0))) {
+        GcOnEvent();
    }

    MenuBase::Update(controller, touch);
@@ -267,6 +267,13 @@ void Menu::Draw(NVGcontext* vg, Theme* theme) {
    });
 }

+void Menu::OnFocusGained() {
+    MenuBase::OnFocusGained();
+
+    GcOnEvent();
+    UpdateStorageSize();
+}
+
 Result Menu::GcMount() {
    GcUnmount();

@@ -312,7 +319,7 @@ Result Menu::GcMount() {
        std::vector<u8> extended_header;
        std::vector<NcmPackagedContentInfo> infos;
        const auto path = BuildGcPath(e.name, &m_handle);
-        R_TRY(yati::ParseCnmtNca(path, header, extended_header, infos));
+        R_TRY(yati::ParseCnmtNca(path, 0, header, extended_header, infos));

        u8 key_gen;
        FsRightsId rights_id;
@@ -321,23 +328,24 @@ Result Menu::GcMount() {
        // always add tickets, yati will ignore them if not needed.
        GcCollections collections;
        // add cnmt file.
-        collections.emplace_back(e.name, e.file_size, NcmContentType_Meta);
+        collections.emplace_back(e.name, e.file_size, NcmContentType_Meta, 0);

-        for (const auto& info : infos) {
+        for (const auto& packed_info : infos) {
+            const auto& info = packed_info.info;
            // these don't exist for gamecards, however i may copy/paste this code
            // somewhere so i'm future proofing against myself.
-            if (info.info.content_type == NcmContentType_DeltaFragment) {
+            if (info.content_type == NcmContentType_DeltaFragment) {
                continue;
            }

            // find the nca file, this will never fail for gamecards, see above comment.
-            const auto str = hexIdToStr(info.info.content_id);
+            const auto str = hexIdToStr(info.content_id);
            const auto it = std::find_if(buf.cbegin(), buf.cend(), [str](auto& e){
                return !std::strncmp(str.str, e.name, std::strlen(str.str));
            });

            R_UNLESS(it != buf.cend(), yati::Result_NcaNotFound);
-            collections.emplace_back(it->name, it->file_size, info.info.content_type);
+            collections.emplace_back(it->name, it->file_size, info.content_type, info.id_offset);
        }

        const auto app_id = ncm::GetAppId(header);
@@ -388,20 +396,18 @@ Result Menu::GcMount() {
                    } else {
                        App::Notify("Gc install failed!"_i18n);
                    }
-
-                    UpdateStorageSize();
                }));
            }
        }
    }});

    if (m_entries.size() > 1) {
-        SetAction(Button::L, Action{"Prev"_i18n, [this](){
+        SetAction(Button::L2, Action{"Prev"_i18n, [this](){
            if (m_entry_index != 0) {
                OnChangeIndex(m_entry_index - 1);
            }
        }});
-        SetAction(Button::R, Action{"Next"_i18n, [this](){
+        SetAction(Button::R2, Action{"Next"_i18n, [this](){
            if (m_entry_index < m_entries.size()) {
                OnChangeIndex(m_entry_index + 1);
            }
@@ -409,6 +415,7 @@ Result Menu::GcMount() {
    }

    OnChangeIndex(0);
+    m_mounted = true;
    R_SUCCEED();
 }

@@ -420,8 +427,8 @@ void Menu::GcUnmount() {
    m_lang_entry = {};
    FreeImage();

-    RemoveAction(Button::L);
-    RemoveAction(Button::R);
+    RemoveAction(Button::L2);
+    RemoveAction(Button::R2);
 }

 Result Menu::GcPoll(bool* inserted) {
@@ -439,6 +446,28 @@ Result Menu::GcPoll(bool* inserted) {
    R_SUCCEED();
 }

+Result Menu::GcOnEvent() {
+    bool inserted{};
+    R_TRY(GcPoll(&inserted));
+
+    if (m_mounted != inserted) {
+        log_write("gc state changed\n");
+        m_mounted = inserted;
+        if (m_mounted) {
+            log_write("trying to mount\n");
+            m_mounted = R_SUCCEEDED(GcMount());
+            if (m_mounted) {
+                App::PlaySoundEffect(SoundEffect::SoundEffect_Startup);
+            }
+        } else {
+            log_write("trying to unmount\n");
+            GcUnmount();
+        }
+    }
+
+    R_SUCCEED();
+}
+
 Result Menu::UpdateStorageSize() {
    fs::FsNativeContentStorage fs_nand{FsContentStorageId_User};
    fs::FsNativeContentStorage fs_sd{FsContentStorageId_SdCard};
@@ -475,7 +504,13 @@ void Menu::OnChangeIndex(s64 new_index) {
                NacpStruct nacp;
                std::vector<u8> icon;
                const auto path = BuildGcPath(collection.name.c_str(), &m_handle);
-                if (R_SUCCEEDED(yati::ParseControlNca(path, m_entries[m_entry_index].app_id, &nacp, sizeof(nacp), &icon))) {
+
+                u64 program_id = m_entries[m_entry_index].app_id | collection.id_offset;
+                if (hosversionAtLeast(17, 0, 0)) {
+                    fsGetProgramId(&program_id, path, FsContentAttributes_All);
+                }
+
+                if (R_SUCCEEDED(yati::ParseControlNca(path, program_id, &nacp, sizeof(nacp), &icon))) {
                    log_write("managed to parse control nca %s\n", path.s);
                    NacpLanguageEntry* lang_entry{};
                    nacpGetLanguageEntry(&nacp, &lang_entry);
--- a/sphaira/source/ui/menus/homebrew.cpp
+++ b/sphaira/source/ui/menus/homebrew.cpp
@@ -24,6 +24,11 @@ auto GenerateStarPath(const fs::FsPath& nro_path) -> fs::FsPath {
    return out;
 }

+void FreeEntry(NVGcontext* vg, NroEntry& e) {
+    nvgDeleteImage(vg, e.image);
+    e.image = 0;
+}
+
 } // namespace

 Menu::Menu() : MenuBase{"Homebrew"_i18n} {
@@ -64,7 +69,7 @@ Menu::Menu() : MenuBase{"Homebrew"_i18n} {

                    options->Add(std::make_shared<SidebarEntryBool>("Hide Sphaira"_i18n, m_hide_sphaira.Get(), [this](bool& enable){
                        m_hide_sphaira.Set(enable);
-                    }, "Enabled"_i18n, "Disabled"_i18n));
+                    }));
                }));

                #if 0
@@ -80,11 +85,12 @@ Menu::Menu() : MenuBase{"Homebrew"_i18n} {
                        "Back"_i18n, "Delete"_i18n, 1, [this](auto op_index){
                            if (op_index && *op_index) {
                                if (R_SUCCEEDED(fs::FsNativeSd().DeleteFile(m_entries[m_index].path))) {
+                                    FreeEntry(App::GetVg(), m_entries[m_index]);
                                    m_entries.erase(m_entries.begin() + m_index);
                                    SetIndex(m_index ? m_index - 1 : 0);
                                }
                            }
-                        }
+                        }, m_entries[m_index].image
                    ));
                }, true));

@@ -97,7 +103,7 @@ Menu::Menu() : MenuBase{"Homebrew"_i18n} {
                                    if (op_index && *op_index) {
                                        InstallHomebrew();
                                    }
-                                }
+                                }, m_entries[m_index].image
                            ));
                        } else {
                            InstallHomebrew();
@@ -114,11 +120,7 @@ Menu::Menu() : MenuBase{"Homebrew"_i18n} {
 }

 Menu::~Menu() {
-    auto vg = App::GetVg();
-
-    for (auto&p : m_entries) {
-        nvgDeleteImage(vg, p.image);
-    }
+    FreeEntries();
 }

 void Menu::Update(Controller* controller, TouchInfo* touch) {
@@ -160,7 +162,8 @@ void Menu::Draw(NVGcontext* vg, Theme* theme) {
        }

        auto text_id = ThemeEntryID_TEXT;
-        if (pos == m_index) {
+        const auto selected = pos == m_index;
+        if (selected) {
            text_id = ThemeEntryID_TEXT_SELECTED;
            gfx::drawRectOutline(vg, theme, 4.f, v);
        } else {
@@ -168,25 +171,23 @@ void Menu::Draw(NVGcontext* vg, Theme* theme) {
        }

        const float image_size = 115;
-        gfx::drawImage(vg, x + 20, y + 20, image_size, image_size, e.image ? e.image : App::GetDefaultImage(), 15);
+        gfx::drawImage(vg, x + 20, y + 20, image_size, image_size, e.image ? e.image : App::GetDefaultImage(), 5);

-        nvgSave(vg);
-        nvgIntersectScissor(vg, x, y, w - 30.f, h); // clip
-        {
-            bool has_star = false;
-            if (IsStarEnabled()) {
-                if (!e.has_star.has_value()) {
-                    e.has_star = fs::FsNativeSd().FileExists(GenerateStarPath(e.path));
-                }
-                has_star = e.has_star.value();
+        const auto text_off = 148;
+        const auto text_x = x + text_off;
+        const auto text_clip_w = w - 30.f - text_off;
+        bool has_star = false;
+        if (IsStarEnabled()) {
+            if (!e.has_star.has_value()) {
+                e.has_star = fs::FsNativeSd().FileExists(GenerateStarPath(e.path));
            }
-
-            const float font_size = 18;
-            gfx::drawTextArgs(vg, x + 148, y + 45, font_size, NVG_ALIGN_LEFT, theme->GetColour(text_id), "%s%s", has_star ? "\u2605 " : "", e.GetName());
-            gfx::drawTextArgs(vg, x + 148, y + 80, font_size, NVG_ALIGN_LEFT, theme->GetColour(text_id), e.GetAuthor());
-            gfx::drawTextArgs(vg, x + 148, y + 115, font_size, NVG_ALIGN_LEFT, theme->GetColour(text_id), e.GetDisplayVersion());
+            has_star = e.has_star.value();
        }
-        nvgRestore(vg);
+
+        const float font_size = 18;
+        m_scroll_name.DrawArgs(vg, selected, text_x, y + 45, text_clip_w, font_size, NVG_ALIGN_LEFT, theme->GetColour(text_id), "%s%s", has_star ? "\u2605 " : "", e.GetName());
+        m_scroll_author.Draw(vg, selected, text_x, y + 80, text_clip_w, font_size, NVG_ALIGN_LEFT, theme->GetColour(text_id), e.GetAuthor());
+        m_scroll_version.Draw(vg, selected, text_x, y + 115, text_clip_w, font_size, NVG_ALIGN_LEFT, theme->GetColour(text_id), e.GetDisplayVersion());
    });
 }

@@ -238,6 +239,7 @@ void Menu::InstallHomebrew() {

 void Menu::ScanHomebrew() {
    TimeStamp ts;
+    FreeEntries();
    nro_scan("/switch", m_entries, m_hide_sphaira.Get());
    log_write("nros found: %zu time_taken: %.2f\n", m_entries.size(), ts.GetSecondsD());

@@ -394,6 +396,16 @@ void Menu::SortAndFindLastFile() {
    }
 }

+void Menu::FreeEntries() {
+    auto vg = App::GetVg();
+
+    for (auto&p : m_entries) {
+        FreeEntry(vg, p);
+    }
+
+    m_entries.clear();
+}
+
 Result Menu::InstallHomebrew(const fs::FsPath& path, const NacpStruct& nacp, const std::vector<u8>& icon) {
    OwoConfig config{};
    config.nro_path = path.toString();
--- a/sphaira/source/ui/menus/irs_menu.cpp
+++ b/sphaira/source/ui/menus/irs_menu.cpp
@@ -86,20 +86,7 @@ Menu::Menu() : MenuBase{"Irs"_i18n} {

        SidebarEntryArray::Items controller_str;
        for (u32 i = 0; i < IRS_MAX_CAMERAS; i++) {
-            const auto& e = m_entries[i];
-            std::string text = "Pad "_i18n + (i == 8 ? "HandHeld"_i18n : std::to_string(i));
-            switch (e.status) {
-                case IrsIrCameraStatus_Available:
-                    text += " (Available)"_i18n;
-                    break;
-                case IrsIrCameraStatus_Unsupported:
-                    text += " (Unsupported)"_i18n;
-                    break;
-                case IrsIrCameraStatus_Unconnected:
-                    text += " (Unconnected)"_i18n;
-                    break;
-            }
-            controller_str.emplace_back(text);
+            controller_str.emplace_back(GetEntryName(i));
        }

        SidebarEntryArray::Items rotation_str;
@@ -189,7 +176,7 @@ Menu::Menu() : MenuBase{"Irs"_i18n} {
            options->Add(std::make_shared<SidebarEntryBool>("External Light Filter"_i18n, m_config.is_external_light_filter_enabled, [this](bool& enable){
                m_config.is_external_light_filter_enabled = enable;
                UpdateConfig(&m_config);
-            }, "Enabled"_i18n, "Disabled"_i18n));
+            }));
        }

        options->Add(std::make_shared<SidebarEntryCallback>("Load Default"_i18n, [this](){
@@ -233,6 +220,7 @@ Menu::~Menu() {
 void Menu::Update(Controller* controller, TouchInfo* touch) {
    MenuBase::Update(controller, touch);
    PollCameraStatus();
+    SetTitleSubHeading(GetEntryName(m_index));
 }

 void Menu::Draw(NVGcontext* vg, Theme* theme) {
@@ -308,6 +296,20 @@ void Menu::Draw(NVGcontext* vg, Theme* theme) {

 void Menu::OnFocusGained() {
    MenuBase::OnFocusGained();
+
+    if (m_entries[m_index].status != IrsIrCameraStatus_Available) {
+        // poll to get first available handle.
+        PollCameraStatus(false);
+
+        // find the first available entry and connect to that.
+        for (s64 i = 0; i < std::size(m_entries); i++) {
+            if (m_entries[i].status == IrsIrCameraStatus_Available) {
+                m_index = i;
+                UpdateConfig(&m_config);
+                break;
+            }
+        }
+    }
 }

 void Menu::PollCameraStatus(bool statup) {
@@ -530,4 +532,21 @@ void Menu::updateColourArray() {
    UpdateImage();
 }

+auto Menu::GetEntryName(s64 i) -> std::string {
+    const auto& e = m_entries[i];
+    std::string text = "Pad "_i18n + (i == 8 ? "HandHeld"_i18n : std::to_string(i));
+    switch (e.status) {
+        case IrsIrCameraStatus_Available:
+            text += " (Available)"_i18n;
+            break;
+        case IrsIrCameraStatus_Unsupported:
+            text += " (Unsupported)"_i18n;
+            break;
+        case IrsIrCameraStatus_Unconnected:
+            text += " (Unconnected)"_i18n;
+            break;
+    }
+    return text;
+}
+
 } // namespace sphaira::ui::menu::irs
--- a/sphaira/source/ui/menus/main_menu.cpp
+++ b/sphaira/source/ui/menus/main_menu.cpp
@@ -6,6 +6,15 @@
 #include "ui/progress_box.hpp"
 #include "ui/error_box.hpp"

+#include "ui/menus/irs_menu.hpp"
+#include "ui/menus/themezer.hpp"
+#include "ui/menus/ghdl.hpp"
+#include "ui/menus/usb_menu.hpp"
+#include "ui/menus/ftp_menu.hpp"
+#include "ui/menus/gc_menu.hpp"
+#include "ui/menus/game_menu.hpp"
+#include "ui/menus/appstore.hpp"
+
 #include "app.hpp"
 #include "log.hpp"
 #include "download.hpp"
@@ -22,6 +31,22 @@ namespace {
 constexpr const char* GITHUB_URL{"https://api.github.com/repos/ITotalJustice/sphaira/releases/latest"};
 constexpr fs::FsPath CACHE_PATH{"/switch/sphaira/cache/sphaira_latest.json"};

+template<typename T>
+auto MiscMenuFuncGenerator() {
+    return std::make_shared<T>();
+}
+
+const MiscMenuEntry MISC_MENU_ENTRIES[] = {
+    { .name = "Appstore", .title = "Appstore", .func = MiscMenuFuncGenerator<ui::menu::appstore::Menu>, .flag = MiscMenuFlag_Shortcut },
+    { .name = "Games", .title = "Games", .func = MiscMenuFuncGenerator<ui::menu::game::Menu>, .flag = MiscMenuFlag_Shortcut },
+    { .name = "Themezer", .title = "Themezer", .func = MiscMenuFuncGenerator<ui::menu::themezer::Menu>, .flag = MiscMenuFlag_Shortcut },
+    { .name = "GitHub", .title = "GitHub", .func = MiscMenuFuncGenerator<ui::menu::gh::Menu>, .flag = MiscMenuFlag_Shortcut },
+    { .name = "FTP", .title = "FTP Install", .func = MiscMenuFuncGenerator<ui::menu::ftp::Menu>, .flag = MiscMenuFlag_Install },
+    { .name = "USB", .title = "USB Install", .func = MiscMenuFuncGenerator<ui::menu::usb::Menu>, .flag = MiscMenuFlag_Install },
+    { .name = "GameCard", .title = "GameCard Install", .func = MiscMenuFuncGenerator<ui::menu::gc::Menu>, .flag = MiscMenuFlag_Shortcut|MiscMenuFlag_Install },
+    { .name = "IRS", .title = "IRS (Infrared Joycon Camera)", .func = MiscMenuFuncGenerator<ui::menu::irs::Menu>, .flag = MiscMenuFlag_Shortcut },
+};
+
 auto InstallUpdate(ProgressBox* pbox, const std::string url, const std::string version) -> bool {
    static fs::FsPath zip_out{"/switch/sphaira/cache/update.zip"};
    constexpr auto chunk_size = 1024 * 512; // 512KiB
@@ -139,8 +164,24 @@ auto InstallUpdate(ProgressBox* pbox, const std::string url, const std::string v
    return true;
 }

+auto CreateRightSideMenu() -> std::shared_ptr<MenuBase> {
+    const auto name = App::GetApp()->m_right_side_menu.Get();
+
+    for (auto& e : GetMiscMenuEntries()) {
+        if (e.name == name) {
+            return e.func();
+        }
+    }
+
+    return std::make_shared<ui::menu::appstore::Menu>();
+}
+
 } // namespace

+auto GetMiscMenuEntries() -> std::span<const MiscMenuEntry> {
+    return MISC_MENU_ENTRIES;
+}
+
 MainMenu::MainMenu() {
    curl::Api().ToFileAsync(
        curl::Url{GITHUB_URL},
@@ -208,6 +249,7 @@ MainMenu::MainMenu() {

    this->SetActions(
        std::make_pair(Button::START, Action{App::Exit}),
+        std::make_pair(Button::SELECT, Action{App::DisplayMiscOptions}),
        std::make_pair(Button::Y, Action{"Menu"_i18n, [this](){
            auto options = std::make_shared<Sidebar>("Menu Options"_i18n, "v" APP_VERSION_HASH, Sidebar::Side::LEFT);
            ON_SCOPE_EXIT(App::Push(options));
@@ -238,15 +280,15 @@ MainMenu::MainMenu() {

                options->Add(std::make_shared<SidebarEntryBool>("Ftp"_i18n, App::GetFtpEnable(), [](bool& enable){
                    App::SetFtpEnable(enable);
-                }, "Enabled"_i18n, "Disabled"_i18n));
+                }));

                options->Add(std::make_shared<SidebarEntryBool>("Mtp"_i18n, App::GetMtpEnable(), [](bool& enable){
                    App::SetMtpEnable(enable);
-                }, "Enabled"_i18n, "Disabled"_i18n));
+                }));

                options->Add(std::make_shared<SidebarEntryBool>("Nxlink"_i18n, App::GetNxlinkEnable(), [](bool& enable){
                    App::SetNxlinkEnable(enable);
-                }, "Enabled"_i18n, "Disabled"_i18n));
+                }));

                if (m_update_state == UpdateState::Update) {
                    options->Add(std::make_shared<SidebarEntryCallback>("Download update: "_i18n + m_update_version, [this](){
@@ -285,7 +327,7 @@ MainMenu::MainMenu() {

    m_homebrew_menu = std::make_shared<homebrew::Menu>();
    m_filebrowser_menu = std::make_shared<filebrowser::Menu>(m_homebrew_menu->GetHomebrewList());
-    m_app_store_menu = std::make_shared<appstore::Menu>(m_homebrew_menu->GetHomebrewList());
+    m_right_side_menu = CreateRightSideMenu();
    m_current_menu = m_homebrew_menu;

    AddOnLRPress();
@@ -336,16 +378,16 @@ void MainMenu::OnLRPress(std::shared_ptr<MenuBase> menu, Button b) {

 void MainMenu::AddOnLRPress() {
    if (m_current_menu != m_filebrowser_menu) {
-        const auto label = m_current_menu == m_homebrew_menu ? "Files" : "Apps";
+        const auto label = m_current_menu == m_homebrew_menu ? m_filebrowser_menu->GetShortTitle() : m_homebrew_menu->GetShortTitle();
        SetAction(Button::L, Action{i18n::get(label), [this]{
            OnLRPress(m_filebrowser_menu, Button::L);
        }});
    }

-    if (m_current_menu != m_app_store_menu) {
-        const auto label = m_current_menu == m_homebrew_menu ? "Store" : "Apps";
+    if (m_current_menu != m_right_side_menu) {
+        const auto label = m_current_menu == m_homebrew_menu ? m_right_side_menu->GetShortTitle() : m_homebrew_menu->GetShortTitle();
        SetAction(Button::R, Action{i18n::get(label), [this]{
-            OnLRPress(m_app_store_menu, Button::R);
+            OnLRPress(m_right_side_menu, Button::R);
        }});
    }
 }
--- a/sphaira/source/ui/menus/themezer.cpp
+++ b/sphaira/source/ui/menus/themezer.cpp
@@ -306,6 +306,7 @@ auto InstallTheme(ProgressBox* pbox, const PackListEntry& entry) -> bool {
            }

            const auto file_path = fs::AppendPath(dir_path, name);
+            pbox->NewTransfer(name);

            Result rc;
            if (R_FAILED(rc = fs.CreateFile(file_path, info.uncompressed_size, 0)) && rc != FsError_PathAlreadyExists) {
@@ -414,7 +415,7 @@ Menu::Menu() : MenuBase{"Themezer"_i18n} {
            options->Add(std::make_shared<SidebarEntryBool>("Nsfw"_i18n, m_nsfw.Get(), [this](bool& v_out){
                m_nsfw.Set(v_out);
                InvalidateAllPages();
-            }, "Enabled"_i18n, "Disabled"_i18n));
+            }));

            options->Add(std::make_shared<SidebarEntryArray>("Sort"_i18n, sort_items, [this, sort_items](s64& index_out){
                if (m_sort.Get() != index_out) {
@@ -452,7 +453,7 @@ Menu::Menu() : MenuBase{"Themezer"_i18n} {
                }
            }));
        }}),
-        std::make_pair(Button::R, Action{"Next Page"_i18n, [this](){
+        std::make_pair(Button::R2, Action{"Next"_i18n, [this](){
            m_page_index++;
            if (m_page_index >= m_page_index_max) {
                m_page_index = m_page_index_max - 1;
@@ -460,7 +461,7 @@ Menu::Menu() : MenuBase{"Themezer"_i18n} {
                PackListDownload();
            }
        }}),
-        std::make_pair(Button::L, Action{"Prev Page"_i18n, [this](){
+        std::make_pair(Button::L2, Action{"Prev"_i18n, [this](){
            if (m_page_index) {
                m_page_index--;
                PackListDownload();
@@ -536,7 +537,8 @@ void Menu::Draw(NVGcontext* vg, Theme* theme) {
        auto& e = page.m_packList[pos];

        auto text_id = ThemeEntryID_TEXT;
-        if (pos == m_index) {
+        const auto selected = pos == m_index;
+        if (selected) {
            text_id = ThemeEntryID_TEXT_SELECTED;
            gfx::drawRectOutline(vg, theme, 4.f, v);
        } else {
@@ -603,16 +605,14 @@ void Menu::Draw(NVGcontext* vg, Theme* theme) {
                }
            }

-            gfx::drawImage(vg, x + xoff, y, 320, 180, image.image ? image.image : App::GetDefaultImage(), 15);
+            gfx::drawImage(vg, x + xoff, y, 320, 180, image.image ? image.image : App::GetDefaultImage(), 5);
        }

-        nvgSave(vg);
-        nvgIntersectScissor(vg, x, y, w - 30.f, h); // clip
-        {
-            gfx::drawTextArgs(vg, x + xoff, y + 180 + 20, 18, NVG_ALIGN_LEFT, theme->GetColour(text_id), "%s", e.details.name.c_str());
-            gfx::drawTextArgs(vg, x + xoff, y + 180 + 55, 18, NVG_ALIGN_LEFT, theme->GetColour(text_id), "%s", e.creator.display_name.c_str());
-        }
-        nvgRestore(vg);
+        const auto text_x = x + xoff;
+        const auto text_clip_w = w - 30.f - xoff;
+        const float font_size = 18;
+        m_scroll_name.Draw(vg, selected, text_x, y + 180 + 20, text_clip_w, font_size, NVG_ALIGN_LEFT, theme->GetColour(text_id), e.details.name.c_str());
+        m_scroll_author.Draw(vg, selected, text_x, y + 180 + 55, text_clip_w, font_size, NVG_ALIGN_LEFT, theme->GetColour(text_id), e.creator.display_name.c_str());
    });
 }

--- a/sphaira/source/ui/menus/usb_menu.cpp
+++ b/sphaira/source/ui/menus/usb_menu.cpp
@@ -10,8 +10,8 @@
 namespace sphaira::ui::menu::usb {
 namespace {

-constexpr u64 CONNECTION_TIMEOUT = 1e+9 * 3;
-constexpr u64 TRANSFER_TIMEOUT = 1e+9 * 5;
+constexpr u64 CONNECTION_TIMEOUT = UINT64_MAX;
+constexpr u64 TRANSFER_TIMEOUT = UINT64_MAX;

 void thread_func(void* user) {
    auto app = static_cast<Menu*>(user);
@@ -21,17 +21,29 @@ void thread_func(void* user) {
            break;
        }

-        const auto rc = app->m_usb_source->WaitForConnection(CONNECTION_TIMEOUT, app->m_usb_speed, app->m_usb_count);
+        const auto rc = app->m_usb_source->IsUsbConnected(CONNECTION_TIMEOUT);
+        if (rc == app->m_usb_source->Result_Cancelled) {
+            break;
+        }
+
+        // set connected status
        mutexLock(&app->m_mutex);
-        ON_SCOPE_EXIT(mutexUnlock(&app->m_mutex));
+            if (R_SUCCEEDED(rc)) {
+                app->m_state = State::Connected_WaitForFileList;
+            } else {
+                app->m_state = State::None;
+            }
+        mutexUnlock(&app->m_mutex);

        if (R_SUCCEEDED(rc)) {
-            app->m_state = State::Connected;
-            break;
-        } else if (R_FAILED(rc) && R_VALUE(rc) != 0xEA01) {
-            log_write("got: 0x%X value: 0x%X\n", rc, R_VALUE(rc));
-            app->m_state = State::Failed;
-            break;
+            std::vector<std::string> names;
+            if (R_SUCCEEDED(app->m_usb_source->WaitForConnection(CONNECTION_TIMEOUT, names))) {
+                mutexLock(&app->m_mutex);
+                ON_SCOPE_EXIT(mutexUnlock(&app->m_mutex));
+                app->m_state = State::Connected_StartingTransfer;
+                app->m_names = names;
+                break;
+            }
        }
    }
 }
@@ -67,6 +79,7 @@ Menu::Menu() : MenuBase{"USB"_i18n} {
    }

    mutexInit(&m_mutex);
+
    if (m_state != State::Failed) {
        threadCreate(&m_thread, thread_func, this, nullptr, 1024*32, 0x2C, 1);
        threadStart(&m_thread);
@@ -76,6 +89,7 @@ Menu::Menu() : MenuBase{"USB"_i18n} {
 Menu::~Menu() {
    // signal for thread to exit and wait.
    m_stop_source.request_stop();
+    m_usb_source->SignalCancel();
    threadWaitForExit(&m_thread);
    threadClose(&m_thread);

@@ -95,54 +109,38 @@ void Menu::Update(Controller* controller, TouchInfo* touch) {
    mutexLock(&m_mutex);
    ON_SCOPE_EXIT(mutexUnlock(&m_mutex));

-    switch (m_state) {
-        case State::None:
-            break;
+    if (m_state == State::Connected_StartingTransfer) {
+        log_write("set to progress\n");
+        m_state = State::Progress;
+        log_write("got connection\n");
+        App::Push(std::make_shared<ui::ProgressBox>(0, "Installing "_i18n, "", [this](auto pbox) mutable -> bool {
+            ON_SCOPE_EXIT(m_usb_source->Finished());

-        case State::Connected:
-            log_write("set to progress\n");
-            m_state = State::Progress;
-            log_write("got connection\n");
-            App::Push(std::make_shared<ui::ProgressBox>(0, "Installing "_i18n, "", [this](auto pbox) mutable -> bool {
-                log_write("inside progress box\n");
-                for (u32 i = 0; i < m_usb_count; i++) {
-                    std::string file_name;
-                    u64 file_size;
-                    if (R_FAILED(m_usb_source->GetFileInfo(file_name, file_size))) {
-                        return false;
-                    }
+            log_write("inside progress box\n");
+            for (const auto& file_name : m_names) {
+                m_usb_source->SetFileNameForTranfser(file_name);

-                    log_write("got file name: %s size: %lX\n", file_name.c_str(), file_size);
-
-                    const auto rc = yati::InstallFromSource(pbox, m_usb_source, file_name);
-                    if (R_FAILED(rc)) {
-                        return false;
-                    }
-
-                    App::Notify("Installed via usb"_i18n);
-                    m_usb_source->Finished();
+                const auto rc = yati::InstallFromSource(pbox, m_usb_source, file_name);
+                if (R_FAILED(rc)) {
+                    m_usb_source->SignalCancel();
+                    log_write("exiting usb install\n");
+                    return false;
                }

-                return true;
-            }, [this](bool result){
-                if (result) {
-                    App::Notify("Usb install success!"_i18n);
-                    m_state = State::Done;
-                } else {
-                    App::Notify("Usb install failed!"_i18n);
-                    m_state = State::Failed;
-                }
-            }));
-            break;
+                App::Notify("Installed via usb"_i18n);
+            }

-        case State::Progress:
-            break;
-
-        case State::Done:
-            break;
-
-        case State::Failed:
-            break;
+            return true;
+        }, [this](bool result){
+            if (result) {
+                App::Notify("Usb install success!"_i18n);
+                m_state = State::Done;
+                SetPop();
+            } else {
+                App::Notify("Usb install failed!"_i18n);
+                m_state = State::Failed;
+            }
+        }));
    }
 }

@@ -157,7 +155,12 @@ void Menu::Draw(NVGcontext* vg, Theme* theme) {
            gfx::drawTextArgs(vg, SCREEN_WIDTH / 2.f, SCREEN_HEIGHT / 2.f, 36.f, NVG_ALIGN_CENTER | NVG_ALIGN_MIDDLE, theme->GetColour(ThemeEntryID_TEXT_INFO), "Waiting for connection..."_i18n.c_str());
            break;

-        case State::Connected:
+        case State::Connected_WaitForFileList:
+            gfx::drawTextArgs(vg, SCREEN_WIDTH / 2.f, SCREEN_HEIGHT / 2.f, 36.f, NVG_ALIGN_CENTER | NVG_ALIGN_MIDDLE, theme->GetColour(ThemeEntryID_TEXT_INFO), "Connected, waiting for file list..."_i18n.c_str());
+            break;
+
+        case State::Connected_StartingTransfer:
+            gfx::drawTextArgs(vg, SCREEN_WIDTH / 2.f, SCREEN_HEIGHT / 2.f, 36.f, NVG_ALIGN_CENTER | NVG_ALIGN_MIDDLE, theme->GetColour(ThemeEntryID_TEXT_INFO), "Connected, starting transfer..."_i18n.c_str());
            break;

        case State::Progress:
--- a/sphaira/source/ui/nvg_util.cpp
+++ b/sphaira/source/ui/nvg_util.cpp
@@ -1,4 +1,5 @@
 #include "ui/nvg_util.hpp"
+#include "log.hpp"
 #include <cstddef>
 #include <cstdio>
 #include <cstdarg>
@@ -10,6 +11,9 @@
 namespace sphaira::ui::gfx {
 namespace {

+constexpr auto ALIGN_HOR = NVG_ALIGN_LEFT|NVG_ALIGN_CENTER|NVG_ALIGN_RIGHT;
+constexpr auto ALIGN_VER = NVG_ALIGN_TOP|NVG_ALIGN_MIDDLE|NVG_ALIGN_BOTTOM|NVG_ALIGN_BASELINE;
+
 constexpr std::array buttons = {
    std::pair{Button::A, "\uE0E0"},
    std::pair{Button::B, "\uE0E1"},
@@ -17,10 +21,8 @@ constexpr std::array buttons = {
    std::pair{Button::Y, "\uE0E3"},
    std::pair{Button::L, "\uE0E4"},
    std::pair{Button::R, "\uE0E5"},
-    std::pair{Button::L, "\uE0E6"},
-    std::pair{Button::R, "\uE0E7"},
-    std::pair{Button::L2, "\uE0E8"},
-    std::pair{Button::R2, "\uE0E9"},
+    std::pair{Button::L2, "\uE0E6"},
+    std::pair{Button::R2, "\uE0E7"},
    std::pair{Button::UP, "\uE0EB"},
    std::pair{Button::DOWN, "\uE0EC"},
    std::pair{Button::LEFT, "\uE0ED"},
@@ -33,8 +35,29 @@ constexpr std::array buttons = {
    std::pair{Button::R3, "\uE105"},
 };

+// software based clipping, saves a few cpu cycles.
+bool ClipRect(float x, float y) {
+    return x >= SCREEN_WIDTH || y >= SCREEN_HEIGHT;
+}
+
+bool ClipText(float x, float y, int align) {
+    if ((!(align & ALIGN_HOR) || (align & NVG_ALIGN_LEFT)) && x >= SCREEN_WIDTH) {
+        return true;
+    }
+
+    if ((!(align & ALIGN_VER) || (align & NVG_ALIGN_TOP)) && y >= SCREEN_HEIGHT) {
+        return true;
+    }
+
+    return false;
+}
+
 // NEW ---------------------
 void drawRectIntenal(NVGcontext* vg, const Vec4& v, const NVGcolor& c, float rounded) {
+    if (ClipRect(v.x, v.y)) {
+        return;
+    }
+
    nvgBeginPath(vg);
    nvgRoundedRect(vg, v.x, v.y, v.w, v.h, rounded);
    nvgFillColor(vg, c);
@@ -42,6 +65,10 @@ void drawRectIntenal(NVGcontext* vg, const Vec4& v, const NVGcolor& c, float rou
 }

 void drawRectIntenal(NVGcontext* vg, const Vec4& v, const NVGpaint& p, float rounded) {
+    if (ClipRect(v.x, v.y)) {
+        return;
+    }
+
    nvgBeginPath(vg);
    nvgRoundedRect(vg, v.x, v.y, v.w, v.h, rounded);
    nvgFillPaint(vg, p);
@@ -120,6 +147,10 @@ void drawRectOutlineInternal(NVGcontext* vg, const Theme* theme, float size, con
 }

 void drawRectOutlineInternal(NVGcontext* vg, const Theme* theme, float size, const Vec4& v, const NVGcolor& c) {
+    if (ClipRect(v.x, v.y)) {
+        return;
+    }
+
    const auto corner_radius = 0.5;
    drawRectOutlineInternal(vg, theme, size, v);
    nvgBeginPath(vg);
@@ -129,6 +160,10 @@ void drawRectOutlineInternal(NVGcontext* vg, const Theme* theme, float size, con
 }

 void drawTextIntenal(NVGcontext* vg, const Vec2& v, float size, const char* str, const char* end, int align, const NVGcolor& c) {
+    if (ClipText(v.x, v.y, align)) {
+        return;
+    }
+
    nvgBeginPath(vg);
    nvgFontSize(vg, size);
    nvgTextAlign(vg, align);
@@ -166,6 +201,10 @@ void drawImage(NVGcontext* vg, float x, float y, float w, float h, int texture,
 }

 void drawTextBox(NVGcontext* vg, float x, float y, float size, float bound, const NVGcolor& c, const char* str, int align, const char* end) {
+    if (ClipText(x, y, align)) {
+        return;
+    }
+
    nvgBeginPath(vg);
    nvgFontSize(vg, size);
    nvgTextAlign(vg, align);
--- a/sphaira/source/ui/option_box.cpp
+++ b/sphaira/source/ui/option_box.cpp
@@ -23,7 +23,7 @@ auto OptionBoxEntry::Selected(bool enable) -> void {
    m_selected = enable;
 }

-OptionBox::OptionBox(const std::string& message, const Option& a, Callback cb)
+OptionBox::OptionBox(const std::string& message, const Option& a, Callback cb, int image)
 : m_message{message}
 , m_callback{cb} {

@@ -40,14 +40,15 @@ OptionBox::OptionBox(const std::string& message, const Option& a, Callback cb)
    Setup(0);
 }

-OptionBox::OptionBox(const std::string& message, const Option& a, const Option& b, Callback cb)
-: OptionBox{message, a, b, 0, cb} {
+OptionBox::OptionBox(const std::string& message, const Option& a, const Option& b, Callback cb, int image)
+: OptionBox{message, a, b, 0, cb, image} {

 }

-OptionBox::OptionBox(const std::string& message, const Option& a, const Option& b, s64 index, Callback cb)
+OptionBox::OptionBox(const std::string& message, const Option& a, const Option& b, s64 index, Callback cb, int image)
 : m_message{message}
-, m_callback{cb} {
+, m_callback{cb}
+, m_image{image} {

    m_pos.w = 770.f;
    m_pos.h = 295.f;
@@ -65,17 +66,6 @@ OptionBox::OptionBox(const std::string& message, const Option& a, const Option&
    Setup(index);
 }

-OptionBox::OptionBox(const std::string& message, const Option& a, const Option& b, const Option& c, Callback cb)
-: OptionBox{message, a, b, c, 0, cb} {
-
-}
-
-OptionBox::OptionBox(const std::string& message, const Option& a, const Option& b, const Option& c, s64 index, Callback cb)
-: m_message{message}
-, m_callback{cb} {
-
-}
-
 auto OptionBox::Update(Controller* controller, TouchInfo* touch) -> void {
    Widget::Update(controller, touch);

@@ -92,13 +82,25 @@ auto OptionBox::Update(Controller* controller, TouchInfo* touch) -> void {
 }

 auto OptionBox::Draw(NVGcontext* vg, Theme* theme) -> void {
-    const float padding = 15;
    gfx::dimBackground(vg);
-    gfx::drawRect(vg, m_pos, theme->GetColour(ThemeEntryID_POPUP));
+    gfx::drawRect(vg, m_pos, theme->GetColour(ThemeEntryID_POPUP), 5);

    nvgSave(vg);
    nvgTextLineHeight(vg, 1.5);
-    gfx::drawTextBox(vg, m_pos.x + padding, m_pos.y + 110.f, 26.f, m_pos.w - padding*2, theme->GetColour(ThemeEntryID_TEXT), m_message.c_str(), NVG_ALIGN_CENTER | NVG_ALIGN_MIDDLE);
+    if (m_image) {
+        Vec4 image{m_pos};
+        image.x += 40;
+        image.y += 40;
+        image.w = 150;
+        image.h = 150;
+
+        const float padding = 40;
+        gfx::drawImage(vg, image, m_image, 5);
+        gfx::drawTextBox(vg, image.x + image.w + padding, m_pos.y + 110.f, 22.f, m_pos.w - (image.x - m_pos.x) - image.w - padding*2, theme->GetColour(ThemeEntryID_TEXT), m_message.c_str(), NVG_ALIGN_LEFT | NVG_ALIGN_BASELINE);
+    } else {
+        const float padding = 30;
+        gfx::drawTextBox(vg, m_pos.x + padding, m_pos.y + 110.f, 24.f, m_pos.w - padding*2, theme->GetColour(ThemeEntryID_TEXT), m_message.c_str(), NVG_ALIGN_CENTER | NVG_ALIGN_MIDDLE);
+    }
    nvgRestore(vg);

    gfx::drawRect(vg, m_spacer_line, theme->GetColour(ThemeEntryID_LINE_SEPARATOR));
--- a/sphaira/source/ui/popup_list.cpp
+++ b/sphaira/source/ui/popup_list.cpp
@@ -73,6 +73,8 @@ PopupList::PopupList(std::string title, Items items, Callback cb, s64 index)
        }})
    );

+    m_starting_index = m_index;
+
    m_pos.w = 1280.f;
    const float a = std::min(370.f, (60.f * static_cast<float>(m_items.size())));
    m_pos.h = 80.f + 140.f + a;
@@ -110,15 +112,24 @@ auto PopupList::Draw(NVGcontext* vg, Theme* theme) -> void {

    m_list->Draw(vg, theme, m_items.size(), [this](auto* vg, auto* theme, auto v, auto i) {
        const auto& [x, y, w, h] = v;
-        if (m_index == i) {
+        auto colour = ThemeEntryID_TEXT;
+        const auto selected = m_index == i;
+        if (selected) {
            gfx::drawRectOutline(vg, theme, 4.f, v);
-            gfx::drawText(vg, x + m_text_xoffset, y + (h / 2.f), 20.f, m_items[i].c_str(), NULL, NVG_ALIGN_LEFT | NVG_ALIGN_MIDDLE, theme->GetColour(ThemeEntryID_TEXT_SELECTED));
        } else {
            if (i != m_items.size() - 1) {
                gfx::drawRect(vg, x, y + h, w, 1.f, theme->GetColour(ThemeEntryID_LINE_SEPARATOR));
            }
-            gfx::drawText(vg, x + m_text_xoffset, y + (h / 2.f), 20.f, m_items[i].c_str(), NULL, NVG_ALIGN_LEFT | NVG_ALIGN_MIDDLE, theme->GetColour(ThemeEntryID_TEXT));
        }
+
+        if (m_starting_index == i) {
+            colour = ThemeEntryID_TEXT_SELECTED;
+            gfx::drawText(vg, x + w - m_text_xoffset, y + (h / 2.f), 20.f, "\uE14B", NULL, NVG_ALIGN_RIGHT | NVG_ALIGN_MIDDLE, theme->GetColour(colour));
+        }
+
+        const auto text_x = x + m_text_xoffset;
+        const auto text_clip_w = w - 60.f - m_text_xoffset;
+        m_scroll_text.Draw(vg, selected, text_x, y + (h / 2.f), text_clip_w, 20.f, NVG_ALIGN_LEFT | NVG_ALIGN_MIDDLE, theme->GetColour(colour), m_items[i]);
    });

    Widget::Draw(vg, theme);
--- a/sphaira/source/ui/progress_box.cpp
+++ b/sphaira/source/ui/progress_box.cpp
@@ -95,7 +95,7 @@ auto ProgressBox::Draw(NVGcontext* vg, Theme* theme) -> void {
    }

    gfx::dimBackground(vg);
-    gfx::drawRect(vg, m_pos, theme->GetColour(ThemeEntryID_POPUP));
+    gfx::drawRect(vg, m_pos, theme->GetColour(ThemeEntryID_POPUP), 5);

    // The pop up shape.
    // const Vec4 box = { 255, 145, 770, 430 };
--- a/sphaira/source/ui/scrolling_text.cpp
+++ b/sphaira/source/ui/scrolling_text.cpp
@@ -0,0 +1,81 @@
+#include "ui/scrolling_text.hpp"
+#include "ui/nvg_util.hpp"
+#include "app.hpp"
+#include <cstdarg>
+
+namespace sphaira::ui {
+namespace {
+
+auto GetTextScrollSpeed() -> float {
+    switch (App::GetTextScrollSpeed()) {
+        case 0: return 0.5;
+        default: case 1: return 1.0;
+        case 2: return 1.5;
+    }
+}
+
+void DrawClipped(NVGcontext* vg, const Vec4& clip, float x, float y, float size, int align, const NVGcolor& colour, const std::string& str) {
+        nvgSave(vg);
+    nvgIntersectScissor(vg, clip.x, clip.y, clip.w, clip.h); // clip
+        gfx::drawText(vg, x, y, size, colour, str.c_str(), align);
+    nvgRestore(vg);
+}
+
+} // namespace
+
+void ScrollingText::Draw(NVGcontext* vg, bool focus, float x, float y, float w, float size, int align, const NVGcolor& colour, const std::string& text_entry) {
+    const Vec4 clip{x, 0, w, 720};
+
+    if (!focus) {
+        DrawClipped(vg, clip, x, y, size, align, colour, text_entry);
+        return;
+    }
+
+    if (m_str != text_entry) {
+        m_str = text_entry;
+        m_tick = 0;
+        m_text_xoff = 0;
+    }
+
+    float bounds[4];
+    auto value_str = text_entry;
+    nvgFontSize(vg, size);
+    nvgTextAlign(vg, align);
+    nvgTextBounds(vg, 0, 0, value_str.c_str(), nullptr, bounds);
+
+    if (focus) {
+        const auto scroll_amount = GetTextScrollSpeed();
+        if (bounds[2] > w) {
+            value_str += "        ";
+            nvgTextBounds(vg, 0, 0, value_str.c_str(), nullptr, bounds);
+
+            if (!m_text_xoff) {
+                m_tick++;
+                if (m_tick >= 60) {
+                    m_tick = 0;
+                    m_text_xoff += scroll_amount;
+                }
+            } else if (bounds[2] > m_text_xoff) {
+                m_text_xoff += std::min(scroll_amount, bounds[2] - m_text_xoff);
+            } else {
+                m_text_xoff = 0;
+            }
+
+            value_str += text_entry;
+        }
+    }
+
+    x -= m_text_xoff;
+    DrawClipped(vg, clip, x, y, size, align, colour, value_str);
+}
+
+void ScrollingText::DrawArgs(NVGcontext* vg, bool focus, float x, float y, float w, float size, int align, const NVGcolor& colour, const char* s, ...) {
+    std::va_list v{};
+    va_start(v, s);
+    char buffer[0x100];
+    std::vsnprintf(buffer, sizeof(buffer), s, v);
+    va_end(v);
+    Draw(vg, focus, x, y, w, size, align, colour, buffer);
+}
+
+} // namespace sphaira::ui
--- a/sphaira/source/ui/sidebar.cpp
+++ b/sphaira/source/ui/sidebar.cpp
@@ -43,6 +43,13 @@ SidebarEntryBool::SidebarEntryBool(std::string title, bool option, Callback cb,
 , m_true_str{std::move(true_str)}
 , m_false_str{std::move(false_str)} {

+    if (m_true_str == "On") {
+        m_true_str = i18n::get(m_true_str);
+    }
+    if (m_false_str == "Off") {
+        m_false_str = i18n::get(m_false_str);
+    }
+
    SetAction(Button::A, Action{"OK"_i18n, [this](){
            m_option ^= 1;
            m_callback(m_option);
--- a/sphaira/source/ui/widget.cpp
+++ b/sphaira/source/ui/widget.cpp
@@ -86,6 +86,11 @@ auto Widget::GetUiButtons() const -> uiButtons {
    uiButtons draw_actions;
    draw_actions.reserve(m_actions.size());

+    const std::pair<Button, Button> swap_buttons[] = {
+        {Button::L, Button::R},
+        {Button::L2, Button::R2},
+    };
+
    // build array
    for (const auto& [button, action] : m_actions) {
        if (action.IsHidden() || action.m_hint.empty()) {
@@ -94,13 +99,19 @@ auto Widget::GetUiButtons() const -> uiButtons {

        uiButton ui_button{button, action};

-        // swap
-        if (button == Button::R && draw_actions.size() && draw_actions.back().m_button == Button::L) {
-            const auto s = draw_actions.back();
-            draw_actions.back().m_button = button;
-            draw_actions.back().m_action = action;
-            draw_actions.emplace_back(s);
-        } else {
+        bool should_swap = false;
+        for (auto [left, right] : swap_buttons) {
+            if (button == right && draw_actions.size() && draw_actions.back().m_button == left) {
+                const auto s = draw_actions.back();
+                draw_actions.back().m_button = button;
+                draw_actions.back().m_action = action;
+                draw_actions.emplace_back(s);
+                should_swap = true;
+                break;
+            }
+        }
+
+        if (!should_swap) {
            draw_actions.emplace_back(ui_button);
        }
    }
--- a/sphaira/source/web.cpp
+++ b/sphaira/source/web.cpp
@@ -1,54 +0,0 @@
-#include "web.hpp"
-#include "log.hpp"
-#include "defines.hpp"
-#include <cstring>
-
-namespace sphaira {
-
-auto WebShow(const std::string& url, bool show_error) -> Result {
-    // showError("Running in applet mode\nPlease launch hbmenu by holding R on an APP (e.g. a game) NOT an applet (e.g. Gallery)", "", 0);
-    // showError("Error: Nag active, check more details", "Browser won't launch if supernag is active\n\nUse gagorder or switch-sys-tweak (the latter is bundled with BrowseNX) to disable supernag.", 0);
-    // log_write("web show with url: %s\n", url.c_str());
-    // return 0;
-    WebCommonConfig config{};
-    WebCommonReply reply{};
-    WebExitReason reason{};
-    AccountUid account_uid{};
-    char last_url[FS_MAX_PATH]{};
-    size_t last_url_len{};
-
-    // WebBackgroundKind_Unknown1 = shows background
-    // WebBackgroundKind_Unknown2 = shows background faded
-    if (R_FAILED(accountTrySelectUserWithoutInteraction(&account_uid, false))) { log_write("failed: accountTrySelectUserWithoutInteraction\n"); }
-    if (R_FAILED(webPageCreate(&config, url.c_str()))) { log_write("failed: webPageCreate\n"); }
-    if (R_FAILED(webConfigSetWhitelist(&config, "^http"))) { log_write("failed: webConfigSetWhitelist\n"); }
-    if (R_FAILED(webConfigSetEcClientCert(&config, true))) { log_write("failed: webConfigSetEcClientCert\n"); }
-    if (R_FAILED(webConfigSetScreenShot(&config, true))) { log_write("failed: webConfigSetScreenShot\n"); }
-    if (R_FAILED(webConfigSetBootDisplayKind(&config, WebBootDisplayKind_Black))) { log_write("failed: webConfigSetBootDisplayKind\n"); }
-    if (R_FAILED(webConfigSetBackgroundKind(&config, WebBackgroundKind_Default))) { log_write("failed: webConfigSetBackgroundKind\n"); }
-    if (R_FAILED(webConfigSetPointer(&config, true))) { log_write("failed: webConfigSetPointer\n"); }
-    if (R_FAILED(webConfigSetLeftStickMode(&config, WebLeftStickMode_Pointer))) { log_write("failed: webConfigSetLeftStickMode\n"); }
-    // if (R_FAILED(webConfigSetBootAsMediaPlayer(&config, true))) { log_write("failed: webConfigSetBootAsMediaPlayer\n"); }
-    if (R_FAILED(webConfigSetJsExtension(&config, true))) { log_write("failed: webConfigSetJsExtension\n"); }
-    if (R_FAILED(webConfigSetMediaPlayerAutoClose(&config, true))) { log_write("failed: webConfigSetMediaPlayerAutoClose\n"); }
-    if (R_FAILED(webConfigSetPageCache(&config, true))) { log_write("failed: webConfigSetPageCache\n"); }
-    if (R_FAILED(webConfigSetFooterFixedKind(&config, WebFooterFixedKind_Hidden))) { log_write("failed: webConfigSetFooterFixedKind\n"); }
-    if (R_FAILED(webConfigSetPageFade(&config, true))) { log_write("failed: webConfigSetPageFade\n"); }
-    if (R_FAILED(webConfigSetPageScrollIndicator(&config, true))) { log_write("failed: webConfigSetPageScrollIndicator\n"); }
-    // if (R_FAILED(webConfigSetMediaPlayerSpeedControl(&config, true))) { log_write("failed: webConfigSetMediaPlayerSpeedControl\n"); }
-    if (R_FAILED(webConfigSetBootMode(&config, WebSessionBootMode_AllForeground))) { log_write("failed: webConfigSetBootMode\n"); }
-    if (R_FAILED(webConfigSetTransferMemory(&config, true))) { log_write("failed: webConfigSetTransferMemory\n"); }
-    if (R_FAILED(webConfigSetTouchEnabledOnContents(&config, true))) { log_write("failed: webConfigSetTouchEnabledOnContents\n"); }
-    // if (R_FAILED(webConfigSetMediaPlayerUi(&config, true))) { log_write("failed: webConfigSetMediaPlayerUi\n"); }
-    // if (R_FAILED(webConfigSetWebAudio(&config, true))) { log_write("failed: webConfigSetWebAudio\n"); }
-    if (R_FAILED(webConfigSetPageCache(&config, true))) { log_write("failed: webConfigSetPageCache\n"); }
-    if (R_FAILED(webConfigSetBootLoadingIcon(&config, true))) { log_write("failed: webConfigSetBootLoadingIcon\n"); }
-    if (R_FAILED(webConfigSetUid(&config, account_uid))) { log_write("failed: webConfigSetUid\n"); }
-    if (R_FAILED(webConfigShow(&config, &reply))) { log_write("failed: webConfigShow\n"); }
-    if (R_FAILED(webReplyGetExitReason(&reply, &reason))) { log_write("failed: webReplyGetExitReason\n"); }
-    if (R_FAILED(webReplyGetLastUrl(&reply, last_url, sizeof(last_url), &last_url_len))) { log_write("failed: webReplyGetLastUrl\n"); }
-    log_write("last url: %s\n", last_url);
-    R_SUCCEED();
-}
-
-} // namespace sphaira
--- a/sphaira/source/yati/nx/nca.cpp
+++ b/sphaira/source/yati/nx/nca.cpp
@@ -172,6 +172,7 @@ auto GetKeyGenStr(u8 key_gen) -> const char* {
        case KeyGeneration_1700: return "17.0.0";
        case KeyGeneration_1800: return "18.0.0";
        case KeyGeneration_1900: return "19.0.0";
+        case KeyGeneration_2000: return "20.0.0";
    }

    return "Unknown";
--- a/sphaira/source/yati/nx/ncm.cpp
+++ b/sphaira/source/yati/nx/ncm.cpp
@@ -7,6 +7,38 @@ namespace {

 } // namespace

+auto GetMetaTypeStr(u8 meta_type) -> const char* {
+    switch (meta_type) {
+        case NcmContentMetaType_Unknown: return "Unknown";
+        case NcmContentMetaType_SystemProgram: return "SystemProgram";
+        case NcmContentMetaType_SystemData: return "SystemData";
+        case NcmContentMetaType_SystemUpdate: return "SystemUpdate";
+        case NcmContentMetaType_BootImagePackage: return "BootImagePackage";
+        case NcmContentMetaType_BootImagePackageSafe: return "BootImagePackageSafe";
+        case NcmContentMetaType_Application: return "Application";
+        case NcmContentMetaType_Patch: return "Patch";
+        case NcmContentMetaType_AddOnContent: return "AddOnContent";
+        case NcmContentMetaType_Delta: return "Delta";
+        case NcmContentMetaType_DataPatch: return "DataPatch";
+    }
+
+    return "Unknown";
+}
+
+auto GetStorageIdStr(u8 storage_id) -> const char* {
+    switch (storage_id) {
+        case NcmStorageId_None: return "None";
+        case NcmStorageId_Host: return "Host";
+        case NcmStorageId_GameCard: return "GameCard";
+        case NcmStorageId_BuiltInSystem: return "BuiltInSystem";
+        case NcmStorageId_BuiltInUser: return "BuiltInUser";
+        case NcmStorageId_SdCard: return "SdCard";
+        case NcmStorageId_Any: return "Any";
+    }
+
+    return "Unknown";
+}
+
 auto GetAppId(u8 meta_type, u64 id) -> u64 {
    if (meta_type == NcmContentMetaType_Patch) {
        return id ^ 0x800;
--- a/sphaira/source/yati/source/usb.cpp
+++ b/sphaira/source/yati/source/usb.cpp
@@ -14,33 +14,59 @@
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

-// Most of the usb transfer code was taken from Haze.
+// The USB transfer code was taken from Haze (part of Atmosphere).
+// The USB protocol was taken from Tinfoil, by Adubbz.
+
 #include "yati/source/usb.hpp"
 #include "log.hpp"
+#include <ranges>

 namespace sphaira::yati::source {
 namespace {

-constexpr u32 MAGIC = 0x53504841;
-constexpr u32 VERSION = 2;
-
-struct SendHeader {
-    u32 magic;
-    u32 version;
+enum USBCmdType : u8 {
+    REQUEST = 0,
+    RESPONSE = 1
 };

-struct RecvHeader {
-    u32 magic;
-    u32 version;
-    u32 bcdUSB;
-    u32 count;
+enum USBCmdId : u32 {
+    EXIT = 0,
+    FILE_RANGE = 1
 };

+struct NX_PACKED USBCmdHeader {
+    u32 magic;
+    USBCmdType type;
+    u8 padding[0x3] = {0};
+    u32 cmdId;
+    u64 dataSize;
+    u8 reserved[0xC] = {0};
+};
+
+struct FileRangeCmdHeader {
+    u64 size;
+    u64 offset;
+    u64 nspNameLen;
+    u64 padding;
+};
+
+struct TUSHeader {
+    u32 magic; // TUL0 (Tinfoil Usb List 0)
+    u32 nspListSize;
+    u64 padding;
+};
+
+static_assert(sizeof(TUSHeader) == 0x10, "TUSHeader must be 0x10!");
+static_assert(sizeof(USBCmdHeader) == 0x20, "USBCmdHeader must be 0x20!");
+
 } // namespace

 Usb::Usb(u64 transfer_timeout) {
    m_open_result = usbDsInitialize();
    m_transfer_timeout = transfer_timeout;
+    ueventCreate(GetCancelEvent(), true);
+    // this avoids allocations during transfers.
+    m_aligned.reserve(1024 * 1024 * 16);
 }

 Usb::~Usb() {
@@ -53,6 +79,11 @@ Result Usb::Init() {
    log_write("doing USB init\n");
    R_TRY(m_open_result);

+    SetSysSerialNumber serial_number;
+    R_TRY(setsysInitialize());
+    ON_SCOPE_EXIT(setsysExit());
+    R_TRY(setsysGetSerialNumber(&serial_number));
+
    u8 iManufacturer, iProduct, iSerialNumber;
    static const u16 supported_langs[1] = {0x0409};
    // Send language descriptor
@@ -62,7 +93,7 @@ Result Usb::Init() {
    // Send product
    R_TRY(usbDsAddUsbStringDescriptor(&iProduct, "Nintendo Switch"));
    // Send serial number
-    R_TRY(usbDsAddUsbStringDescriptor(&iSerialNumber, "SerialNumber"));
+    R_TRY(usbDsAddUsbStringDescriptor(&iSerialNumber, serial_number.number));

    // Send device descriptors
    struct usb_device_descriptor device_descriptor = {
@@ -131,13 +162,11 @@ Result Usb::Init() {
        .bInterfaceProtocol = USB_CLASS_VENDOR_SPEC,
    };

-
    struct usb_endpoint_descriptor endpoint_descriptor_in = {
        .bLength = USB_DT_ENDPOINT_SIZE,
        .bDescriptorType = USB_DT_ENDPOINT,
        .bEndpointAddress = USB_ENDPOINT_IN,
        .bmAttributes = USB_TRANSFER_TYPE_BULK,
-        .wMaxPacketSize = 0x40,
    };

    struct usb_endpoint_descriptor endpoint_descriptor_out = {
@@ -145,7 +174,6 @@ Result Usb::Init() {
        .bDescriptorType = USB_DT_ENDPOINT,
        .bEndpointAddress = USB_ENDPOINT_OUT,
        .bmAttributes = USB_TRANSFER_TYPE_BULK,
-        .wMaxPacketSize = 0x40,
    };

    const struct usb_ss_endpoint_companion_descriptor endpoint_companion = {
@@ -163,6 +191,8 @@ Result Usb::Init() {
    endpoint_descriptor_out.bEndpointAddress += interface_descriptor.bInterfaceNumber + 1;

    // Full Speed Config
+    endpoint_descriptor_in.wMaxPacketSize = 0x40;
+    endpoint_descriptor_out.wMaxPacketSize = 0x40;
    R_TRY(usbDsInterface_AppendConfigurationData(m_interface, UsbDeviceSpeed_Full, &interface_descriptor, USB_DT_INTERFACE_SIZE));
    R_TRY(usbDsInterface_AppendConfigurationData(m_interface, UsbDeviceSpeed_Full, &endpoint_descriptor_in, USB_DT_ENDPOINT_SIZE));
    R_TRY(usbDsInterface_AppendConfigurationData(m_interface, UsbDeviceSpeed_Full, &endpoint_descriptor_out, USB_DT_ENDPOINT_SIZE));
@@ -194,71 +224,101 @@ Result Usb::Init() {
    R_SUCCEED();
 }

-Result Usb::WaitForConnection(u64 timeout, u32& speed, u32& count) {
-    const SendHeader send_header{
-        .magic = MAGIC,
-        .version = VERSION,
+// the blow code is taken from libnx, with the addition of a uevent to cancel.
+Result Usb::IsUsbConnected(u64 timeout) {
+    Result rc;
+    UsbState state = UsbState_Detached;
+
+    rc = usbDsGetState(&state);
+    if (R_FAILED(rc)) return rc;
+    if (state == UsbState_Configured) return 0;
+
+    bool has_timeout = timeout != UINT64_MAX;
+    u64 deadline = 0;
+
+    const std::array waiters{
+        waiterForEvent(usbDsGetStateChangeEvent()),
+        waiterForUEvent(GetCancelEvent()),
    };

-    alignas(0x1000) u8 aligned[0x1000]{};
-    std::memcpy(aligned, std::addressof(send_header), sizeof(send_header));
+    if (has_timeout)
+        deadline = armGetSystemTick() + armNsToTicks(timeout);

-    // send header.
-    u32 transferredSize;
-    R_TRY(TransferPacketImpl(false, aligned, sizeof(send_header), &transferredSize, timeout));
+    do {
+        if (has_timeout) {
+            s64 remaining = deadline - armGetSystemTick();
+            timeout = remaining > 0 ? armTicksToNs(remaining) : 0;
+        }

-    // receive header.
-    struct RecvHeader recv_header{};
-    R_TRY(TransferPacketImpl(true, aligned, sizeof(recv_header), &transferredSize, timeout));
+        s32 idx;
+        rc = waitObjects(&idx, waiters.data(), waiters.size(), timeout);
+        eventClear(usbDsGetStateChangeEvent());

-    // copy data into header struct.
-    std::memcpy(&recv_header, aligned, sizeof(recv_header));
+        // check if we got one of the cancel events.
+        if (R_SUCCEEDED(rc) && idx != 0) {
+            rc = Result_Cancelled; // cancelled.
+            break;
+        }

-    // validate received header.
-    R_UNLESS(recv_header.magic == MAGIC, Result_BadMagic);
-    R_UNLESS(recv_header.version == VERSION, Result_BadVersion);
-    R_UNLESS(recv_header.count > 0, Result_BadCount);
+        rc = usbDsGetState(&state);
+    } while (R_SUCCEEDED(rc) && state != UsbState_Configured && timeout > 0);

-    count = recv_header.count;
-    speed = recv_header.bcdUSB;
+    if (R_SUCCEEDED(rc) && state != UsbState_Configured && timeout == 0)
+        return KERNELRESULT(TimedOut);
+
+    return rc;
+}
+
+Result Usb::WaitForConnection(u64 timeout, std::vector<std::string>& out_names) {
+    TUSHeader header;
+    R_TRY(TransferAll(true, &header, sizeof(header), timeout));
+    R_UNLESS(header.magic == 0x304C5554, Result_BadMagic);
+    R_UNLESS(header.nspListSize > 0, Result_BadCount);
+    log_write("USB got header\n");
+
+    std::vector<char> names(header.nspListSize);
+    R_TRY(TransferAll(true, names.data(), names.size(), timeout));
+
+    out_names.clear();
+    for (const auto& name : std::views::split(names, '\n')) {
+        if (!name.empty()) {
+            out_names.emplace_back(name.data(), name.size());
+        }
+    }
+
+    for (auto& name : out_names) {
+        log_write("got name: %s\n", name.c_str());
+    }
+
+    R_UNLESS(!out_names.empty(), Result_BadCount);
+    log_write("USB SUCCESS\n");
    R_SUCCEED();
 }

-Result Usb::GetFileInfo(std::string& name_out, u64& size_out) {
-    struct {
-        u64 size;
-        u64 name_length;
-    } file_info_meta;
-
-    alignas(0x1000) u8 aligned[0x1000]{};
-
-    // receive meta.
-    u32 transferredSize;
-    R_TRY(TransferPacketImpl(true, aligned, sizeof(file_info_meta), &transferredSize, m_transfer_timeout));
-    std::memcpy(&file_info_meta, aligned, sizeof(file_info_meta));
-    R_UNLESS(file_info_meta.name_length < sizeof(aligned), 0x1);
-
-    R_TRY(TransferPacketImpl(true, aligned, file_info_meta.name_length, &transferredSize, m_transfer_timeout));
-    name_out.resize(file_info_meta.name_length);
-    std::memcpy(name_out.data(), aligned, name_out.size());
-
-    size_out = file_info_meta.size;
-    R_SUCCEED();
-}
-
-bool Usb::GetConfigured() const {
-    UsbState usb_state;
-    usbDsGetState(std::addressof(usb_state));
-    return usb_state == UsbState_Configured;
+void Usb::SetFileNameForTranfser(const std::string& name) {
+    m_transfer_file_name = name;
 }

 Event *Usb::GetCompletionEvent(UsbSessionEndpoint ep) const {
    return std::addressof(m_endpoints[ep]->CompletionEvent);
 }

-Result Usb::WaitTransferCompletion(UsbSessionEndpoint ep, u64 timeout) const {
+Result Usb::WaitTransferCompletion(UsbSessionEndpoint ep, u64 timeout) {
    auto event = GetCompletionEvent(ep);
-    const auto rc = eventWait(event, timeout);
+
+    const std::array waiters{
+        waiterForEvent(event),
+        waiterForUEvent(GetCancelEvent()),
+    };
+
+    s32 idx;
+    auto rc = waitObjects(&idx, waiters.data(), waiters.size(), timeout);
+
+    // check if we got one of the cancel events.
+    if (R_SUCCEEDED(rc) && idx != 0) {
+        log_write("got usb cancel event\n");
+        rc = Result_Cancelled; // cancelled.
+    }

    if (R_FAILED(rc)) {
        R_TRY(usbDsEndpoint_Cancel(m_endpoints[ep]));
@@ -282,16 +342,11 @@ Result Usb::GetTransferResult(UsbSessionEndpoint ep, u32 urb_id, u32 *out_reques
    R_SUCCEED();
 }

-Result Usb::TransferPacketImpl(bool read, void *page, u32 size, u32 *out_size_transferred, u64 timeout) const {
+Result Usb::TransferPacketImpl(bool read, void *page, u32 size, u32 *out_size_transferred, u64 timeout) {
    u32 urb_id;

    /* If we're not configured yet, wait to become configured first. */
-    // R_TRY(usbDsWaitReady(timeout));
-    if (!GetConfigured()) {
-        R_TRY(eventWait(usbDsGetStateChangeEvent(), timeout));
-        R_TRY(eventClear(usbDsGetStateChangeEvent()));
-        R_THROW(0xEA01);
-    }
+    R_TRY(IsUsbConnected(timeout));

    /* Select the appropriate endpoint and begin a transfer. */
    const auto ep = read ? UsbSessionEndpoint_Out : UsbSessionEndpoint_In;
@@ -304,78 +359,73 @@ Result Usb::TransferPacketImpl(bool read, void *page, u32 size, u32 *out_size_tr
    return GetTransferResult(ep, urb_id, nullptr, out_size_transferred);
 }

-Result Usb::SendCommand(s64 off, s64 size) const {
-    struct {
-        u32 hash;
-        u32 magic;
-        s64 off;
-        s64 size;
-    } meta{0, 0, off, size};
-
-    alignas(0x1000) static u8 aligned[0x1000]{};
-    std::memcpy(aligned, std::addressof(meta), sizeof(meta));
-
-    u32 transferredSize;
-    return TransferPacketImpl(false, aligned, sizeof(meta), &transferredSize, m_transfer_timeout);
-}
-
-Result Usb::Finished() const {
-    return SendCommand(0, 0);
-}
-
-Result Usb::InternalRead(void* _buf, s64 off, s64 size) const {
-    u8* buf = (u8*)_buf;
-    alignas(0x1000) u8 aligned[0x1000]{};
-    const auto stored_size = size;
-    s64 total = 0;
+// while it may seem like a bad idea to transfer data to a buffer and copy it
+// in practice, this has no impact on performance.
+// the switch is *massively* bottlenecked by slow io (nand and sd).
+// so making usb transfers zero-copy provides no benefit other than increased
+// code complexity and the increase of future bugs if/when sphaira is forked
+// an changes are made.
+// yati already goes to great lengths to be zero-copy during installing
+// by swapping buffers and inflating in-place.
+Result Usb::TransferAll(bool read, void *data, u32 size, u64 timeout) {
+    auto buf = static_cast<u8*>(data);
+    m_aligned.resize((size + 0xFFF) & ~0xFFF);

    while (size) {
-        auto read_size = size;
-        auto read_buf = buf;
-
-        if (u64(buf) & 0xFFF) {
-            read_size = std::min<u64>(size, sizeof(aligned) - (u64(buf) & 0xFFF));
-            read_buf = aligned;
-            log_write("unaligned read %zd %zd read_size: %zd align: %zd\n", off, size, read_size, u64(buf) & 0xFFF);
-        } else if (read_size & 0xFFF) {
-            if (read_size <= 0xFFF) {
-                log_write("unaligned small read %zd %zd read_size: %zd align: %zd\n", off, size, read_size, u64(buf) & 0xFFF);
-                read_buf = aligned;
-            } else {
-                log_write("unaligned big read %zd %zd read_size: %zd align: %zd\n", off, size, read_size, u64(buf) & 0xFFF);
-                // read as much as possible into buffer, the rest will
-                // be handled in a second read which will be aligned size aligned.
-                read_size = read_size & ~0xFFF;
-            }
+        if (!read) {
+            std::memcpy(m_aligned.data(), buf, size);
        }

-        R_TRY(SendCommand(off, read_size));
+        u32 out_size_transferred;
+        R_TRY(TransferPacketImpl(read, m_aligned.data(), size, &out_size_transferred, timeout));

-        u32 transferredSize{};
-        R_TRY(TransferPacketImpl(true, read_buf, read_size, &transferredSize, m_transfer_timeout));
-        R_UNLESS(transferredSize <= read_size, Result_BadTransferSize);
-
-        if (read_buf == aligned) {
-            std::memcpy(buf, aligned, transferredSize);
+        if (read) {
+            std::memcpy(buf, m_aligned.data(), out_size_transferred);
        }

-        if (transferredSize < read_size) {
-            log_write("reading less than expected! %u vs %zd stored: %zd\n", transferredSize, read_size, stored_size);
-        }
-
-        off += transferredSize;
-        buf += transferredSize;
-        size -= transferredSize;
-        total += transferredSize;
+        buf += out_size_transferred;
+        size -= out_size_transferred;
    }

-    R_UNLESS(total == stored_size, Result_BadTotalSize);
    R_SUCCEED();
 }

+Result Usb::SendCmdHeader(u32 cmdId, size_t dataSize) {
+    USBCmdHeader header{
+        .magic = 0x30435554, // TUC0 (Tinfoil USB Command 0)
+        .type = USBCmdType::REQUEST,
+        .cmdId = cmdId,
+        .dataSize = dataSize,
+    };
+
+    return TransferAll(false, &header, sizeof(header), m_transfer_timeout);
+}
+
+Result Usb::SendFileRangeCmd(u64 off, u64 size) {
+    FileRangeCmdHeader fRangeHeader;
+    fRangeHeader.size = size;
+    fRangeHeader.offset = off;
+    fRangeHeader.nspNameLen = m_transfer_file_name.size();
+    fRangeHeader.padding = 0;
+
+    R_TRY(SendCmdHeader(USBCmdId::FILE_RANGE, sizeof(fRangeHeader) + fRangeHeader.nspNameLen));
+    R_TRY(TransferAll(false, &fRangeHeader, sizeof(fRangeHeader), m_transfer_timeout));
+    R_TRY(TransferAll(false, m_transfer_file_name.data(), m_transfer_file_name.size(), m_transfer_timeout));
+
+    USBCmdHeader responseHeader;
+    R_TRY(TransferAll(true, &responseHeader, sizeof(responseHeader), m_transfer_timeout));
+
+    R_SUCCEED();
+}
+
+Result Usb::Finished() {
+    return SendCmdHeader(USBCmdId::EXIT, 0);
+}
+
 Result Usb::Read(void* buf, s64 off, s64 size, u64* bytes_read) {
    R_TRY(GetOpenResult());
-    R_TRY(InternalRead(buf, off, size));
+    R_TRY(SendFileRangeCmd(off, size));
+    R_TRY(TransferAll(true, buf, size, m_transfer_timeout));
    *bytes_read = size;
    R_SUCCEED();
 }
--- a/sphaira/source/yati/yati.cpp
+++ b/sphaira/source/yati/yati.cpp
@@ -18,7 +18,6 @@
 #include "i18n.hpp"
 #include "log.hpp"

-#include <new>
 #include <zstd.h>
 #include <minIni.h>

@@ -30,40 +29,10 @@ constexpr NcmStorageId NCM_STORAGE_IDS[]{
    NcmStorageId_SdCard,
 };

-// custom allocator for std::vector that respects alignment.
-// https://en.cppreference.com/w/cpp/named_req/Allocator
-template <typename T, std::size_t Align>
-struct CustomVectorAllocator {
-public:
-    // https://en.cppreference.com/w/cpp/memory/new/operator_new
-    auto allocate(std::size_t n) -> T* {
-        // log_write("allocating ptr size: %zu\n", n);
-        return new(align) T[n];
-    }
-
-    // https://en.cppreference.com/w/cpp/memory/new/operator_delete
-    auto deallocate(T* p, std::size_t n) noexcept -> void {
-        // log_write("deleting ptr size: %zu\n", n);
-        ::operator delete[] (p, n, align);
-    }
-
-private:
-    static constexpr inline std::align_val_t align{Align};
-};
-
-template <typename T>
-struct PageAllocator : CustomVectorAllocator<T, 0x1000> {
-    using value_type = T; // used by std::vector
-};
-
-template<class T, class U>
-bool operator==(const PageAllocator <T>&, const PageAllocator <U>&) { return true; }
-
-using PageAlignedVector = std::vector<u8, PageAllocator<u8>>;
-
 constexpr u32 KEYGEN_LIMIT = 0x20;

 struct NcaCollection : container::CollectionEntry {
+    nca::Header header{};
    // NcmContentType
    u8 type{};
    NcmContentId content_id{};
@@ -72,6 +41,8 @@ struct NcaCollection : container::CollectionEntry {
    u8 hash[SHA256_HASH_SIZE]{};
    // set true if nca has been modified.
    bool modified{};
+    // set if the nca was not installed.
+    bool skipped{};
 };

 struct CnmtCollection : NcaCollection {
@@ -81,7 +52,7 @@ struct CnmtCollection : NcaCollection {
    // if set, the ticket / cert will be installed once all nca's have installed.
    std::vector<FsRightsId> rights_id{};

-    NcmContentMetaHeader header{};
+    NcmContentMetaHeader meta_header{};
    NcmContentMetaKey key{};
    NcmContentInfo content_info{};
    std::vector<u8> extended_header{};
@@ -107,7 +78,7 @@ struct ThreadBuffer {
        buf.reserve(INFLATE_BUFFER_MAX);
    }

-    PageAlignedVector buf;
+    std::vector<u8> buf;
    s64 off;
 };

@@ -137,7 +108,7 @@ public:
        return ringbuf_capacity() - ringbuf_size();
    }

-    void ringbuf_push(PageAlignedVector& buf_in, s64 off_in) {
+    void ringbuf_push(std::vector<u8>& buf_in, s64 off_in) {
        auto& value = this->buf[this->w_index % ringbuf_capacity()];
        value.off = off_in;
        std::swap(value.buf, buf_in);
@@ -145,7 +116,7 @@ public:
        this->w_index = (this->w_index + 1U) % (ringbuf_capacity() * 2U);
    }

-    void ringbuf_pop(PageAlignedVector& buf_out, s64& off_out) {
+    void ringbuf_pop(std::vector<u8>& buf_out, s64& off_out) {
        auto& value = this->buf[this->r_index % ringbuf_capacity()];
        off_out = value.off;
        std::swap(value.buf, buf_out);
@@ -178,7 +149,7 @@ struct ThreadData {

    Result Read(void* buf, s64 size, u64* bytes_read);

-    Result SetDecompressBuf(PageAlignedVector& buf, s64 off, s64 size) {
+    Result SetDecompressBuf(std::vector<u8>& buf, s64 off, s64 size) {
        buf.resize(size);

        mutexLock(std::addressof(read_mutex));
@@ -192,7 +163,7 @@ struct ThreadData {
        return condvarWakeOne(std::addressof(can_decompress));
    }

-    Result GetDecompressBuf(PageAlignedVector& buf_out, s64& off_out) {
+    Result GetDecompressBuf(std::vector<u8>& buf_out, s64& off_out) {
        mutexLock(std::addressof(read_mutex));
        if (!read_buffers.ringbuf_size()) {
            R_TRY(condvarWait(std::addressof(can_decompress), std::addressof(read_mutex)));
@@ -204,7 +175,7 @@ struct ThreadData {
        return condvarWakeOne(std::addressof(can_read));
    }

-    Result SetWriteBuf(PageAlignedVector& buf, s64 size, bool skip_verify) {
+    Result SetWriteBuf(std::vector<u8>& buf, s64 size, bool skip_verify) {
        buf.resize(size);
        if (!skip_verify) {
            sha256ContextUpdate(std::addressof(sha256), buf.data(), buf.size());
@@ -221,7 +192,7 @@ struct ThreadData {
        return condvarWakeOne(std::addressof(can_write));
    }

-    Result GetWriteBuf(PageAlignedVector& buf_out, s64& off_out) {
+    Result GetWriteBuf(std::vector<u8>& buf_out, s64& off_out) {
        mutexLock(std::addressof(write_mutex));
        if (!write_buffers.ringbuf_size()) {
            R_TRY(condvarWait(std::addressof(can_write), std::addressof(write_mutex)));
@@ -276,8 +247,8 @@ struct Yati {

    Result Setup(const ConfigOverride& override);
    Result InstallNca(std::span<TikCollection> tickets, NcaCollection& nca);
+    Result InstallNcaInternal(std::span<TikCollection> tickets, NcaCollection& nca);
    Result InstallCnmtNca(std::span<TikCollection> tickets, CnmtCollection& cnmt, const container::Collections& collections);
-    Result InstallControlNca(std::span<TikCollection> tickets, const CnmtCollection& cnmt, NcaCollection& nca);

    Result readFuncInternal(ThreadData* t);
    Result decompressFuncInternal(ThreadData* t);
@@ -361,11 +332,11 @@ HashStr hexIdToStr(auto id) {
 // parsing ncz headers, sections and reading ncz blocks
 Result Yati::readFuncInternal(ThreadData* t) {
    // the main buffer which data is read into.
-    PageAlignedVector buf;
+    std::vector<u8> buf;
    // workaround ncz block reading ahead. if block isn't found, we usually
    // would seek back to the offset, however this is not possible in stream
    // mode, so we instead store the data to the temp buffer and pre-pend it.
-    PageAlignedVector temp_buf;
+    std::vector<u8> temp_buf;
    buf.reserve(t->max_buffer_size);
    temp_buf.reserve(t->max_buffer_size);

@@ -453,12 +424,12 @@ Result Yati::decompressFuncInternal(ThreadData* t) {

    s64 inflate_offset{};
    Aes128CtrContext ctx{};
-    PageAlignedVector inflate_buf{};
+    std::vector<u8> inflate_buf{};
    inflate_buf.reserve(t->max_buffer_size);

    s64 written{};
    s64 decompress_buf_off{};
-    PageAlignedVector buf{};
+    std::vector<u8> buf{};
    buf.reserve(t->max_buffer_size);

    // encrypts the nca and passes the buffer to the write thread.
@@ -471,7 +442,7 @@ Result Yati::decompressFuncInternal(ThreadData* t) {
        // the remaining data.
        // rather that copying the entire vector to the write thread,
        // only copy (store) the remaining amount.
-        PageAlignedVector temp_vector{};
+        std::vector<u8> temp_vector{};
        if (size < inflate_offset) {
            temp_vector.resize(inflate_offset - size);
            std::memcpy(temp_vector.data(), inflate_buf.data() + size, temp_vector.size());
@@ -538,6 +509,9 @@ Result Yati::decompressFuncInternal(ThreadData* t) {
                R_UNLESS(header.magic == 0x3341434E, Result_InvalidNcaMagic);
                log_write("nca magic is ok! type: %u\n", header.content_type);

+                // store the unmodified header.
+                t->nca->header = header;
+
                if (!config.skip_rsa_header_fixed_key_verify) {
                    log_write("verifying nca fixed key\n");
                    R_TRY(nca::VerifyFixedKey(header));
@@ -556,7 +530,7 @@ Result Yati::decompressFuncInternal(ThreadData* t) {

                TikCollection* ticket = nullptr;
                if (isRightsIdValid(header.rights_id)) {
-                    auto it = std::find_if(t->tik.begin(), t->tik.end(), [header](auto& e){
+                    auto it = std::find_if(t->tik.begin(), t->tik.end(), [&header](auto& e){
                        return !std::memcmp(&header.rights_id, &e.rights_id, sizeof(e.rights_id));
                    });

@@ -709,7 +683,7 @@ Result Yati::decompressFuncInternal(ThreadData* t) {

 // write thread writes data to the nca placeholder.
 Result Yati::writeFuncInternal(ThreadData* t) {
-    PageAlignedVector buf;
+    std::vector<u8> buf;
    buf.reserve(t->max_buffer_size);

    while (t->write_offset < t->write_size && R_SUCCEEDED(t->GetResults())) {
@@ -790,10 +764,15 @@ Yati::~Yati() {

    serviceClose(std::addressof(es));
    appletSetMediaPlaybackState(false);
+
+    if (config.boost_mode) {
+        appletSetCpuBoostMode(ApmCpuBoostMode_Normal);
+    }
 }

 Result Yati::Setup(const ConfigOverride& override) {
    config.sd_card_install = override.sd_card_install.value_or(App::GetApp()->m_install_sd.Get());
+    config.boost_mode = App::GetApp()->m_boost_mode.Get();
    config.allow_downgrade = App::GetApp()->m_allow_downgrade.Get();
    config.skip_if_already_installed = App::GetApp()->m_skip_if_already_installed.Get();
    config.ticket_only = App::GetApp()->m_ticket_only.Get();
@@ -811,6 +790,10 @@ Result Yati::Setup(const ConfigOverride& override) {
    config.lower_system_version = override.lower_system_version.value_or(App::GetApp()->m_lower_system_version.Get());
    storage_id = config.sd_card_install ? NcmStorageId_SdCard : NcmStorageId_BuiltInUser;

+    if (config.boost_mode) {
+        appletSetCpuBoostMode(ApmCpuBoostMode_FastLoad);
+    }
+
    R_TRY(source->GetOpenResult());
    R_TRY(splCryptoInitialize());
    R_TRY(nsInitialize());
@@ -829,10 +812,17 @@ Result Yati::Setup(const ConfigOverride& override) {
    R_SUCCEED();
 }

-Result Yati::InstallNca(std::span<TikCollection> tickets, NcaCollection& nca) {
-    log_write("in install nca\n");
-    pbox->NewTransfer(nca.name);
-    keys::parse_hex_key(std::addressof(nca.content_id), nca.name.c_str());
+Result Yati::InstallNcaInternal(std::span<TikCollection> tickets, NcaCollection& nca) {
+    if (config.skip_if_already_installed) {
+        R_TRY(ncmContentStorageHas(std::addressof(cs), std::addressof(nca.skipped), std::addressof(nca.content_id)));
+        if (nca.skipped) {
+            log_write("\tskipped nca as it's already installed ncmContentStorageHas()\n");
+            R_TRY(ncmContentStorageReadContentIdFile(std::addressof(cs), std::addressof(nca.header), sizeof(nca.header), std::addressof(nca.content_id), 0));
+            crypto::cryptoAes128Xts(std::addressof(nca.header), std::addressof(nca.header), keys.header_key, 0, 0x200, sizeof(nca.header), false);
+            R_SUCCEED();
+        }
+    }
+
    log_write("generateing placeholder\n");
    R_TRY(ncmContentStorageGeneratePlaceHolderId(std::addressof(cs), std::addressof(nca.placeholder_id)));
    log_write("creating placeholder\n");
@@ -918,39 +908,71 @@ Result Yati::InstallNca(std::span<TikCollection> tickets, NcaCollection& nca) {
    R_SUCCEED();
 }

+Result Yati::InstallNca(std::span<TikCollection> tickets, NcaCollection& nca) {
+    log_write("in install nca\n");
+    pbox->NewTransfer(nca.name);
+    keys::parse_hex_key(std::addressof(nca.content_id), nca.name.c_str());
+
+    R_TRY(InstallNcaInternal(tickets, nca));
+
+    fs::FsPath path;
+    if (nca.skipped) {
+        R_TRY(ncmContentStorageGetPath(std::addressof(cs), path, sizeof(path), std::addressof(nca.content_id)));
+    } else {
+        R_TRY(ncmContentStorageFlushPlaceHolder(std::addressof(cs)));
+        R_TRY(ncmContentStorageGetPlaceHolderPath(std::addressof(cs), path, sizeof(path), std::addressof(nca.placeholder_id)));
+    }
+
+    if (nca.header.content_type == nca::ContentType_Program) {
+        // todo: verify npdm key.
+    } else if (nca.header.content_type == nca::ContentType_Control) {
+        NacpLanguageEntry entry;
+        std::vector<u8> icon;
+        R_TRY(yati::ParseControlNca(path, nca.header.program_id, &entry, sizeof(entry), &icon));
+        pbox->SetTitle(entry.name).SetImageData(icon);
+    }
+
+    R_SUCCEED();
+}
+
 Result Yati::InstallCnmtNca(std::span<TikCollection> tickets, CnmtCollection& cnmt, const container::Collections& collections) {
    R_TRY(InstallNca(tickets, cnmt));

    fs::FsPath path;
-    R_TRY(ncmContentStorageFlushPlaceHolder(std::addressof(cs)));
-    R_TRY(ncmContentStorageGetPlaceHolderPath(std::addressof(cs), path, sizeof(path), std::addressof(cnmt.placeholder_id)));
+    if (cnmt.skipped) {
+        R_TRY(ncmContentStorageGetPath(std::addressof(cs), path, sizeof(path), std::addressof(cnmt.content_id)));
+    } else {
+        R_TRY(ncmContentStorageFlushPlaceHolder(std::addressof(cs)));
+        R_TRY(ncmContentStorageGetPlaceHolderPath(std::addressof(cs), path, sizeof(path), std::addressof(cnmt.placeholder_id)));
+    }

    ncm::PackagedContentMeta header;
    std::vector<NcmPackagedContentInfo> infos;
-    R_TRY(ParseCnmtNca(path, header, cnmt.extended_header, infos));
+    R_TRY(ParseCnmtNca(path, cnmt.header.program_id, header, cnmt.extended_header, infos));

-    for (const auto& info : infos) {
-        if (info.info.content_type == NcmContentType_DeltaFragment) {
+    for (const auto& packed_info : infos) {
+        const auto& info = packed_info.info;
+        if (info.content_type == NcmContentType_DeltaFragment) {
            continue;
        }

-        const auto str = hexIdToStr(info.info.content_id);
-        const auto it = std::find_if(collections.cbegin(), collections.cend(), [str](auto& e){
+        const auto str = hexIdToStr(info.content_id);
+        const auto it = std::find_if(collections.cbegin(), collections.cend(), [&str](auto& e){
            return e.name.find(str.str) != e.name.npos;
        });

        R_UNLESS(it != collections.cend(), Result_NcaNotFound);

        log_write("found: %s\n", str.str);
-        cnmt.infos.emplace_back(info);
+        cnmt.infos.emplace_back(packed_info);
        auto& nca = cnmt.ncas.emplace_back(*it);
-        nca.type = info.info.content_type;
+        nca.type = info.content_type;
    }

    // update header
-    cnmt.header = header.meta_header;
-    cnmt.header.content_count = cnmt.infos.size() + 1;
-    cnmt.header.storage_id = 0;
+    cnmt.meta_header = header.meta_header;
+    cnmt.meta_header.content_count = cnmt.infos.size() + 1;
+    cnmt.meta_header.storage_id = 0;

    cnmt.key.id = header.title_id;
    cnmt.key.version = header.title_version;
@@ -985,26 +1007,6 @@ Result Yati::InstallCnmtNca(std::span<TikCollection> tickets, CnmtCollection& cn
    R_SUCCEED();
 }

-Result Yati::InstallControlNca(std::span<TikCollection> tickets, const CnmtCollection& cnmt, NcaCollection& nca) {
-    R_TRY(InstallNca(tickets, nca));
-
-    fs::FsPath path;
-    R_TRY(ncmContentStorageFlushPlaceHolder(std::addressof(cs)));
-    R_TRY(ncmContentStorageGetPlaceHolderPath(std::addressof(cs), path, sizeof(path), std::addressof(nca.placeholder_id)));
-
-    // this can fail if it's not a valid control nca, examples are mario 3d all stars.
-    // there are 4 control ncas, only 1 is valid (InvalidNcaId 0x235E02).
-    NacpLanguageEntry entry;
-    std::vector<u8> icon;
-    if (R_SUCCEEDED(yati::ParseControlNca(path, ncm::GetAppId(cnmt.key), &entry, sizeof(entry), &icon))) {
-        pbox->SetTitle(entry.name).SetImageData(icon);
-    } else {
-        log_write("\tWARNING: failed to parse control nca!\n");
-    }
-
-    R_SUCCEED();
-}
-
 Result Yati::ParseTicketsIntoCollection(std::vector<TikCollection>& tickets, const container::Collections& collections, bool read_data) {
    for (const auto& collection : collections) {
        if (collection.name.ends_with(".tik")) {
@@ -1012,7 +1014,7 @@ Result Yati::ParseTicketsIntoCollection(std::vector<TikCollection>& tickets, con
            keys::parse_hex_key(entry.rights_id.c, collection.name.c_str());
            const auto str = collection.name.substr(0, collection.name.length() - 4) + ".cert";

-            const auto cert = std::find_if(collections.cbegin(), collections.cend(), [str](auto& e){
+            const auto cert = std::find_if(collections.cbegin(), collections.cend(), [&str](auto& e){
                return e.name.find(str) != e.name.npos;
            });

@@ -1091,6 +1093,13 @@ Result Yati::ShouldSkip(const CnmtCollection& cnmt, bool& skip) {
    } else if (config.skip_data_patch && cnmt.key.type == NcmContentMetaType_DataPatch) {
        log_write("\tskipping: [NcmContentMetaType_DataPatch]\n");
        skip = true;
+    } else if (config.skip_if_already_installed) {
+        bool has;
+        R_TRY(ncmContentMetaDatabaseHas(std::addressof(db), std::addressof(has), std::addressof(cnmt.key)));
+        if (has) {
+            log_write("\tskipping: [ncmContentMetaDatabaseHas()]\n");
+            skip = true;
+        }
    }

    R_SUCCEED();
@@ -1183,7 +1192,7 @@ Result Yati::RegisterNcasAndPushRecord(const CnmtCollection& cnmt, u32 latest_ve
    log_write("registered cnmt nca\n");

    for (auto& nca : cnmt.ncas) {
-        if (nca.type != NcmContentType_DeltaFragment) {
+        if (!nca.skipped && nca.type != NcmContentType_DeltaFragment) {
            log_write("registering nca: %s\n", nca.name.c_str());
            R_TRY(ncm::Register(std::addressof(cs), std::addressof(nca.content_id), std::addressof(nca.placeholder_id)));
            log_write("registered nca: %s\n", nca.name.c_str());
@@ -1194,7 +1203,7 @@ Result Yati::RegisterNcasAndPushRecord(const CnmtCollection& cnmt, u32 latest_ve

    // build ncm meta and push to the database.
    BufHelper buf{};
-    buf.write(std::addressof(cnmt.header), sizeof(cnmt.header));
+    buf.write(std::addressof(cnmt.meta_header), sizeof(cnmt.meta_header));
    buf.write(cnmt.extended_header.data(), cnmt.extended_header.size());
    buf.write(std::addressof(cnmt.content_info), sizeof(cnmt.content_info));

@@ -1262,12 +1271,7 @@ Result InstallInternal(ui::ProgressBox* pbox, std::shared_ptr<source::Base> sour

        log_write("installing nca's\n");
        for (auto& nca : cnmt.ncas) {
-            if (nca.type == NcmContentType_Control) {
-                log_write("installing control nca\n");
-                R_TRY(yati->InstallControlNca(tickets, cnmt, nca));
-            } else {
-                R_TRY(yati->InstallNca(tickets, nca));
-            }
+            R_TRY(yati->InstallNca(tickets, nca));
        }

        R_TRY(yati->ImportTickets(tickets));
@@ -1284,6 +1288,7 @@ Result InstallInternalStream(ui::ProgressBox* pbox, std::shared_ptr<source::Base
    R_TRY(yati->Setup(override));

    // not supported with stream installs (yet).
+    yati->config.skip_if_already_installed = false;
    yati->config.convert_to_standard_crypto = false;
    yati->config.lower_master_key = false;

@@ -1326,7 +1331,7 @@ Result InstallInternalStream(ui::ProgressBox* pbox, std::shared_ptr<source::Base
            keys::parse_hex_key(rights_id.c, collection.name.c_str());
            const auto str = collection.name.substr(0, collection.name.length() - 4) + ".cert";

-            auto entry = std::find_if(tickets.begin(), tickets.end(), [rights_id](auto& e){
+            auto entry = std::find_if(tickets.begin(), tickets.end(), [&rights_id](auto& e){
                return !std::memcmp(&rights_id, &e.rights_id, sizeof(rights_id));
            });

@@ -1345,7 +1350,7 @@ Result InstallInternalStream(ui::ProgressBox* pbox, std::shared_ptr<source::Base
    for (auto& cnmt : cnmts) {
        // copy nca structs into cnmt.
        for (auto& cnmt_nca : cnmt.ncas) {
-            auto it = std::find_if(ncas.cbegin(), ncas.cend(), [cnmt_nca](auto& e){
+            auto it = std::find_if(ncas.cbegin(), ncas.cend(), [&cnmt_nca](auto& e){
                return e.name == cnmt_nca.name;
            });

@@ -1412,9 +1417,9 @@ Result InstallFromCollections(ui::ProgressBox* pbox, std::shared_ptr<source::Bas
    }
 }

-Result ParseCnmtNca(const fs::FsPath& path, ncm::PackagedContentMeta& header, std::vector<u8>& extended_header, std::vector<NcmPackagedContentInfo>& infos) {
+Result ParseCnmtNca(const fs::FsPath& path, u64 program_id, ncm::PackagedContentMeta& header, std::vector<u8>& extended_header, std::vector<NcmPackagedContentInfo>& infos) {
    FsFileSystem fs;
-    R_TRY(fsOpenFileSystem(std::addressof(fs), FsFileSystemType_ContentMeta, path));
+    R_TRY(fsOpenFileSystemWithId(std::addressof(fs), program_id, FsFileSystemType_ContentMeta, path, FsContentAttributes_All));
    ON_SCOPE_EXIT(fsFsClose(std::addressof(fs)));

    FsDir dir;
@@ -1447,9 +1452,9 @@ Result ParseCnmtNca(const fs::FsPath& path, ncm::PackagedContentMeta& header, st
    R_SUCCEED();
 }

-Result ParseControlNca(const fs::FsPath& path, u64 id, void* nacp_out, s64 nacp_size, std::vector<u8>* icon_out) {
+Result ParseControlNca(const fs::FsPath& path, u64 program_id, void* nacp_out, s64 nacp_size, std::vector<u8>* icon_out) {
    FsFileSystem fs;
-    R_TRY(fsOpenFileSystemWithId(std::addressof(fs), id, FsFileSystemType_ContentControl, path, FsContentAttributes_All));
+    R_TRY(fsOpenFileSystemWithId(std::addressof(fs), program_id, FsFileSystemType_ContentControl, path, FsContentAttributes_All));
    ON_SCOPE_EXIT(fsFsClose(std::addressof(fs)));

    // read nacp.
--- a/tools/usb_install_pc.py
+++ b/tools/usb_install_pc.py
@@ -0,0 +1,171 @@
+# This script depends on PyUSB. You can get it with pip install pyusb.
+# You will also need libusb installed
+
+# My sincere apologies for this process being overly complicated. Apparently Python and Windows
+# aren't very friendly :(
+# Windows Instructions:
+# 1. Download Zadig from https://zadig.akeo.ie/.
+# 2. With your switch plugged in and on the Tinfoil USB install menu,
+#    choose "List All Devices" under the options menu in Zadig, and select libnx USB comms.
+# 3. Choose libusbK from the driver list and click the "Replace Driver" button.
+# 4. Run this script
+
+# macOS Instructions:
+# 1. Install Homebrew https://brew.sh
+# 2. Install Python 3
+#      sudo mkdir /usr/local/Frameworks
+#      sudo chown $(whoami) /usr/local/Frameworks
+#      brew install python
+# 3. Install PyUSB
+#      pip3 install pyusb
+# 4. Install libusb
+#      brew install libusb
+# 5. Plug in your Switch and go to Tinfoil > Title Management > USB Install NSP
+# 6. Run this script
+#      python3 usb_install_pc.py <path/to/nsp_folder>
+
+import usb.core
+import usb.util
+import struct
+import sys
+from pathlib import Path
+import time
+
+CMD_ID_EXIT = 0
+CMD_ID_FILE_RANGE = 1
+
+CMD_TYPE_RESPONSE = 1
+
+# list of supported extensions.
+EXTS = (".nsp", ".xci", ".nsz", ".xcz")
+
+def send_response_header(out_ep, cmd_id, data_size):
+    out_ep.write(b'TUC0') # Tinfoil USB Command 0
+    out_ep.write(struct.pack('<B', CMD_TYPE_RESPONSE))
+    out_ep.write(b'\x00' * 3)
+    out_ep.write(struct.pack('<I', cmd_id))
+    out_ep.write(struct.pack('<Q', data_size))
+    out_ep.write(b'\x00' * 0xC)
+
+def file_range_cmd(nsp_dir, in_ep, out_ep, data_size):
+    file_range_header = in_ep.read(0x20)
+
+    range_size = struct.unpack('<Q', file_range_header[:8])[0]
+    range_offset = struct.unpack('<Q', file_range_header[8:16])[0]
+    nsp_name_len = struct.unpack('<Q', file_range_header[16:24])[0]
+    #in_ep.read(0x8) # Reserved
+    nsp_name = bytes(in_ep.read(nsp_name_len)).decode('utf-8')
+
+    print('Range Size: {}, Range Offset: {}, Name len: {}, Name: {}'.format(range_size, range_offset, nsp_name_len, nsp_name))
+    send_response_header(out_ep, CMD_ID_FILE_RANGE, range_size)
+
+    with open(nsp_name, 'rb') as f:
+        f.seek(range_offset)
+
+        curr_off = 0x0
+        end_off = range_size
+        read_size = 0x800000
+
+        while curr_off < end_off:
+            if curr_off + read_size >= end_off:
+                read_size = end_off - curr_off
+
+            buf = f.read(read_size)
+            out_ep.write(data=buf, timeout=0)
+            curr_off += read_size
+
+def poll_commands(nsp_dir, in_ep, out_ep):
+    while True:
+        cmd_header = bytes(in_ep.read(0x20, timeout=0))
+        magic = cmd_header[:4]
+        print('Magic: {}'.format(magic), flush=True)
+
+        if magic != b'TUC0': # Tinfoil USB Command 0
+            continue
+
+        cmd_type = struct.unpack('<B', cmd_header[4:5])[0]
+        cmd_id = struct.unpack('<I', cmd_header[8:12])[0]
+        data_size = struct.unpack('<Q', cmd_header[12:20])[0]
+
+        print('Cmd Type: {}, Command id: {}, Data size: {}'.format(cmd_type, cmd_id, data_size), flush=True)
+
+        if cmd_id == CMD_ID_EXIT:
+            print('Exiting...')
+            break
+        elif cmd_id == CMD_ID_FILE_RANGE:
+            file_range_cmd(nsp_dir, in_ep, out_ep, data_size)
+
+def send_nsp_list(nsp_dir, out_ep):
+    nsp_path_list = list()
+    nsp_path_list_len = 0
+
+    # Add all files with the extension .nsp in the provided dir
+    for nsp_path in [f for f in nsp_dir.iterdir() if f.is_file() and (f.suffix in EXTS)]:
+        nsp_path_list.append(nsp_path.__str__() + '\n')
+        nsp_path_list_len += len(nsp_path.__str__()) + 1
+
+    print('Sending header...')
+
+    out_ep.write(b'TUL0') # Tinfoil USB List 0
+    out_ep.write(struct.pack('<I', nsp_path_list_len))
+    out_ep.write(b'\x00' * 0x8) # Padding
+
+    print('Sending NSP list: {}'.format(nsp_path_list))
+
+    for nsp_path in nsp_path_list:
+        out_ep.write(nsp_path)
+
+def print_usage():
+    print("""\
+usb_install_pc.py
+
+Used for the installation of NSPs over USB.
+
+Usage: usb_install_pc.py <nsp folder>""")
+
+if __name__ == '__main__':
+    if len(sys.argv) != 2:
+        print_usage()
+        sys.exit(1)
+
+    nsp_dir = Path(sys.argv[1])
+
+    if not nsp_dir.is_dir():
+        raise ValueError('1st argument must be a directory')
+
+    print("waiting for switch...\n")
+    dev = None
+
+    while (dev is None):
+        dev = usb.core.find(idVendor=0x057E, idProduct=0x3000)
+        time.sleep(0.5)
+
+    print("found the switch!\n")
+
+    cfg = None
+
+    try:
+        cfg = dev.get_active_configuration()
+        print("found active config")
+    except usb.core.USBError:
+        print("no currently active config")
+        cfg = None
+
+    if cfg is None:
+        dev.reset()
+        dev.set_configuration()
+        cfg = dev.get_active_configuration()
+
+    is_out_ep = lambda ep: usb.util.endpoint_direction(ep.bEndpointAddress) == usb.util.ENDPOINT_OUT
+    is_in_ep = lambda ep: usb.util.endpoint_direction(ep.bEndpointAddress) == usb.util.ENDPOINT_IN
+    out_ep = usb.util.find_descriptor(cfg[(0,0)], custom_match=is_out_ep)
+    in_ep = usb.util.find_descriptor(cfg[(0,0)], custom_match=is_in_ep)
+
+    assert out_ep is not None
+    assert in_ep is not None
+
+    print("iManufacturer: {} iProduct: {} iSerialNumber: {}".format(dev.manufacturer, dev.product, dev.serial_number))
+    print("bcdUSB: {} bMaxPacketSize0: {}".format(hex(dev.bcdUSB), dev.bMaxPacketSize0))
+
+    send_nsp_list(nsp_dir, out_ep)
+    poll_commands(nsp_dir, in_ep, out_ep)
--- a/tools/usb_total.py
+++ b/tools/usb_total.py
@@ -1,141 +0,0 @@
-# based on usb.py from Tinfoil, by Adubbz.
-import struct
-import sys
-import os
-import usb.core
-import usb.util
-import time
-import glob
-from pathlib import Path
-
-# magic number (SPHA) for the script and switch.
-MAGIC = 0x53504841
-# version of the usb script.
-VERSION = 2
-# list of supported extensions.
-EXTS = (".nsp", ".xci", ".nsz", ".xcz")
-
-def verify_switch(bcdUSB, count, in_ep, out_ep):
-    header = in_ep.read(8, timeout=0)
-    switch_magic = struct.unpack('<I', header[0:4])[0]
-    switch_version = struct.unpack('<I', header[4:8])[0]
-
-    if switch_magic != MAGIC:
-        raise Exception("Unexpected magic {}".format(switch_magic))
-
-    if switch_version != VERSION:
-        raise Exception("Unexpected version {}".format(switch_version))
-
-    send_data = struct.pack('<IIII', MAGIC, VERSION, bcdUSB, count)
-    out_ep.write(data=send_data, timeout=0)
-
-def send_file_info(path, in_ep, out_ep):
-    file_name = Path(path).name
-    file_size = Path(path).stat().st_size
-    file_name_len = len(file_name)
-
-    send_data = struct.pack('<QQ', file_size, file_name_len)
-    out_ep.write(data=send_data, timeout=0)
-    out_ep.write(data=file_name, timeout=0)
-
-def wait_for_input(path, in_ep, out_ep):
-    buf = None
-    predicted_off = 0
-    print("now waiting for intput\n")
-
-    with open(path, "rb") as file:
-        while True:
-            header = in_ep.read(24, timeout=0)
-
-            range_offset = struct.unpack('<Q', header[8:16])[0]
-            range_size = struct.unpack('<Q', header[16:24])[0]
-
-            if (range_offset == 0 and range_size == 0):
-                break
-
-            if (buf != None and range_offset == predicted_off and range_size == len(buf)):
-                # print("predicted the read off {} size {}".format(predicted_off, len(buf)))
-                pass
-            else:
-                file.seek(range_offset)
-                buf = file.read(range_size)
-
-            if (len(buf) != range_size):
-                # print("off: {} size: {}".format(range_offset, range_size))
-                raise ValueError('bad buf size!!!!!')
-
-            result = out_ep.write(data=buf, timeout=0)
-            if (len(buf) != result):
-                print("off: {} size: {}".format(range_offset, range_size))
-                raise ValueError('bad result!!!!!')
-
-            predicted_off = range_offset + range_size
-            buf = file.read(range_size)
-
-if __name__ == '__main__':
-    print("hello world")
-
-    # check which mode the user has selected.
-    args = len(sys.argv)
-    if (args != 2):
-        print("either run python usb_total.py game.nsp OR drag and drop the game onto the python file (if python is in your path)")
-        sys.exit(1)
-
-    path = sys.argv[1]
-    files = []
-
-    if os.path.isfile(path) and path.endswith(EXTS):
-        files.append(path)
-    elif os.path.isdir(path):
-        for f in glob.glob(path + "/**/*.*", recursive=True):
-            if os.path.isfile(f) and f.endswith(EXTS):
-                files.append(f)
-    else:
-        raise ValueError('must be a file!')
-
-    # for file in files:
-    #     print("found file: {}".format(file))
-
-    # Find the switch
-    print("waiting for switch...\n")
-    dev = None
-
-    while (dev is None):
-        dev = usb.core.find(idVendor=0x057E, idProduct=0x3000)
-        time.sleep(0.5)
-
-    print("found the switch!\n")
-
-    cfg = None
-
-    try:
-        cfg = dev.get_active_configuration()
-        print("found active config")
-    except usb.core.USBError:
-        print("no currently active config")
-        cfg = None
-
-    if cfg is None:
-        dev.set_configuration()
-        cfg = dev.get_active_configuration()
-
-    is_out_ep = lambda ep: usb.util.endpoint_direction(ep.bEndpointAddress) == usb.util.ENDPOINT_OUT
-    is_in_ep = lambda ep: usb.util.endpoint_direction(ep.bEndpointAddress) == usb.util.ENDPOINT_IN
-    out_ep = usb.util.find_descriptor(cfg[(0,0)], custom_match=is_out_ep)
-    in_ep = usb.util.find_descriptor(cfg[(0,0)], custom_match=is_in_ep)
-    assert out_ep is not None
-    assert in_ep is not None
-
-    print("iManufacturer: {} iProduct: {} iSerialNumber: {}".format(dev.manufacturer, dev.product, dev.serial_number))
-    print("bcdUSB: {} bMaxPacketSize0: {}".format(hex(dev.bcdUSB), dev.bMaxPacketSize0))
-
-    try:
-        verify_switch(dev.bcdUSB, len(files), in_ep, out_ep)
-
-        for file in files:
-            print("installing file: {}".format(file))
-            send_file_info(file, in_ep, out_ep)
-            wait_for_input(file, in_ep, out_ep)
-        dev.reset()
-    except Exception as inst:
-        print("An exception occurred " + str(inst))
Author	SHA1	Message	Date
ITotalJustice	365ae2d0cb	fix freeze if the usb menu is closed whilst a usb cable is not connected, 0.9.0 -> 0.9.1	2025-05-03 21:15:21 +01:00
ITotalJustice	5b6e09b926	bump version for new release 0.8.2 -> 0.9.0	2025-05-03 18:01:49 +01:00
ITotalJustice	7072647611	reduce usb install exit latency by waiting on a cancel uevent, rather than relying on a timeout.	2025-05-03 17:17:53 +01:00
ITotalJustice	30cf4826f8	add code for calculating games size, stubbed for now as the ns calls are too slow to be usable.	2025-05-03 15:30:40 +01:00
ITotalJustice	ca47fc1f89	add (limited) sort options to game menu. getting the list of title_ids is very fast (less than 1ms), however parsing the control info, such as title names is very slow. depending on how many games the user has, blocking until we read all control info can take several seconds... we would only need to block if the user wants to sort by name. normally, we lazy load the control data, so we don't suffer from slow load times at all. i decided that its not worth slowing the whole system down just to give the option to sort by name.	2025-05-03 15:08:25 +01:00
ITotalJustice	16a2c84edd	simplify right-side shortcuts impl, add gamecard and themezer to shortcut list, fix l2/r2 using wrong icons, sort l2/r2 so l2 displays first. some other changes: - shorten the next page and prev page to just next/prev in themezer. - remove misc shortcut name. the function itself still exists.	2025-05-03 14:39:20 +01:00
ITotalJustice	df5e27dd06	fix filebrowser crash caused when trying to select all files (L2) whilst a hidden file/folder exists. this crash was found by @WE1ZARD. to trigger it, press L2 in the filebrowser whilst a hidden file exists and the hide hidden is enabled. the was due to GetEntry(i) internally using m_entries_current, and the select all was using the index from m_entries_current. this would result in an index that goes oob, and as its a write, it crashes.	2025-05-03 13:25:09 +01:00
ITotalJustice	d95226f8c0	i18n::get should accept a string_view rather than char*, simplifies calling.	2025-05-03 13:25:09 +01:00
ITotalJustice	164fec5b73	fix right-side shortcut not displaying the correct name (again) when using translations.	2025-05-03 13:25:09 +01:00
glitched_nx	8dad96f39f	Update de.json (#130 ) Commit changes to language file (de.json), with many improvements and corrections. The changes include: - Modification and correction of existing translations for greater clarity and accuracy. - Updated translations to match the terminology for homebrew and Nintendo Switch UI elements. - Added new 'de' translation for the “ 12h time format” setting function.	2025-05-02 22:48:48 +01:00
ITotalJustice	2244e73c53	change "yes, no" for boolean options to "on, off", to match N's sidebar.	2025-05-02 00:57:11 +01:00
ITotalJustice	456cb02d2a	[breaking change] update forwarder id generation, add "hide forwarders" to game menu.	2025-05-02 00:52:08 +01:00
ITotalJustice	f310704472	bump nca key generation values for fw 20.0.0	2025-05-02 00:02:09 +01:00
ITotalJustice	96e5a7081b	clip rect and text drawing that go offscreen. this is already handled by the gpu, but cpu side still has to do some work. this wasn't a performance issue (we only use 4%) but its a free win, so we might as well.	2025-05-01 23:49:01 +01:00
ITotalJustice	1c93e18822	replace all "enabled" and "disabled" options with the default "On" and "Off".	2025-05-01 22:10:47 +01:00
ITotalJustice	ac152454f0	fix menu shortcut setting translated names for the config.	2025-05-01 22:00:40 +01:00
ITotalJustice	7851f7f400	add option to extract zip to root, better name extract / compress options.	2025-05-01 18:28:35 +01:00
ITotalJustice	2b561dd438	add option to change the right-side menu.	2025-05-01 18:06:10 +01:00
ITotalJustice	3545f557fc	add scrolling text to popup list, handling clipping inside scrolling text, game menu changes - added delete entity in game menu - added list meta records to game menu	2025-05-01 15:14:50 +01:00
ITotalJustice	8dfb9b9ba6	reduce time for scrolling text from 1.5s to 1s.	2025-05-01 00:04:32 +01:00
ITotalJustice	7cf36cd25f	reduces rounding of icons in grid based menus (15 -> 5).	2025-04-30 23:59:05 +01:00
ITotalJustice	c53692022b	add scrolling text to all grid based menus. fixes #122	2025-04-30 23:56:40 +01:00
ITotalJustice	0f3b7da0b2	fix memleak when deleting homebrew, add game menu.	2025-04-30 22:45:52 +01:00
ITotalJustice	e22daefb08	slightly round edges for progress and option box, add image support to option boxes	2025-04-30 18:19:13 +01:00
ITotalJustice	6fb5319da3	bump version for new release 0.8.1 -> 0.8.2	2025-04-30 17:21:04 +01:00
ITotalJustice	6970fec554	irs connect to first available handle, irs display connected pad in the title.	2025-04-30 17:16:59 +01:00
ITotalJustice	36be56647f	Revert "remove IRS menu" This reverts commit `1dafa2748c`.	2025-04-30 17:05:44 +01:00
ITotalJustice	cca6326314	filebrowser add select al option by pressing L2	2025-04-30 16:55:33 +01:00
ITotalJustice	9176c6780a	filebrowser move install forwarder option out of the advanced menu.	2025-04-30 16:49:19 +01:00
ITotalJustice	b1a6b12cf3	add zip extraction, add zip creation, themezer now displays the file name its extracting.	2025-04-30 16:42:05 +01:00
ITotalJustice	c7cc11cc98	only add etag is dst file already exists, enable curl --compressed option. curl/libcurl does not send Accept-Encoding by default. many servers support sending compressed versions of files, to speed up transfers. this is ideal for the switch as its io is shit, but the cpu is mostly idle (4% cpu usage for sphaira). github and appstore support sending gzip json files, themezer doesn't seem to.	2025-04-30 00:40:04 +01:00
ITotalJustice	ec4b96b95d	remove stale etag if the server stops sending etags back workaround for appstore images which stopped sending etags back.	2025-04-29 22:41:33 +01:00
ITotalJustice	a2e343daa7	improve popup_list to highlight the currently selected item.	2025-04-29 22:40:32 +01:00
BIGBIGSUI	b811c9e3cd	Update zh.json (#129 ) A latest zh.json. Hope it will be helpful	2025-04-29 20:35:05 +01:00
ITotalJustice	8ffaa56bc3	bump version for new release 0.8.0 -> 0.8.1	2025-04-29 20:03:23 +01:00
ITotalJustice	eca3358e57	add option to download default music.	2025-04-29 20:01:51 +01:00
ITotalJustice	757e380e08	play sound effect when gamecard is inserted.	2025-04-29 19:23:37 +01:00
ITotalJustice	6c1b5de932	label the shortcut for misc	2025-04-29 19:06:33 +01:00
ITotalJustice	d79ac126f7	remove all strings and error codes in error_box.cpp, reduce binary by a further 60k.	2025-04-29 18:56:55 +01:00
ITotalJustice	2d7763444e	remove Web menu the web browser on the switch is really bad, it shouldnt be used. i am removing this menu because its another option that gets in the way of other options, and code bloat.	2025-04-29 18:42:32 +01:00
ITotalJustice	1dafa2748c	remove IRS menu i added the irs menu when i wanted to mess around with the sensor on the joycon. since then, i have used it a total of 0 times, and i don't think any users use it either.	2025-04-29 18:37:43 +01:00
ITotalJustice	9f7bf9581c	add boost mode option for installing	2025-04-29 18:33:02 +01:00
ITotalJustice	8f39acbaa2	replace usb protocol with tinfoils protocol, in order to support applications supporting said protocol. - replace the python script with the one included with tinfoil, minor changes such as changing the supported extension, removing unused imports. - tested with the included script, fluffy and ns-usbloader on linux. a user was unable to get it working on mac however... - added build instructions to the readme, i think they're correct. - added install instructions to the readme.	2025-04-29 18:11:07 +01:00
ITotalJustice	81469d0ac9	remove PageAlignedVector from yati as it's no longer needed due to previous commit. the previous commit changed usb transfers to always transfer to/from page aligned buffers. i wanted to keep the commits seperate so that its easier revert or git bisect later on, if needed.	2025-04-29 14:19:37 +01:00
ITotalJustice	1eae35f072	simplify the usb transfer process by using an aligned buffer to transfer to/from.	2025-04-29 14:17:12 +01:00
ITotalJustice	5b82e07b1c	fix building due to previous commit	2025-04-29 13:08:32 +01:00
ITotalJustice	73886c28ae	add gc event waiting, fix control nca mounting, better skip nca support. - gamecards now wait for an event to change, rather than polling each frame. this reduces cpu load on core 3 slightly (3-4% less). - my understanding of fsOpenFileSystemWithId() was wrong, i thought it used the app_id for the id param. turns out it needs the program id (found in the nca header), this is why mounting some control ncas would fail. fs (and ncm) have a call in 17+ to get the program id, it does so by parsing the nca header. in yati, we already have the header so we can avoid the call. for the gamecard menu, we don't. so we can parse the nca header, or use the id offset (which we already have) to form the program id. - std::find_if in yati now takes args by ref rather than by value, avoid quite large copies. - stream installs can now parse the control nca. - if an nca is already installed, it is now skipped. this is regardless to whether it is not in ncm db. - nca skipping is technically supported for stream installs, however it is disabled for now as there needs to be a way to allow for the stream to continue reading and discarding data until the stream has finished. currently, if a ftp (stream) install is skipped, it will close the progress box and cause spahira to hang. this is because sphaira expects the stream to only be closed upon all data being read, so there's nothing more to process. - renamed the title_id field in nca header to program_id.	2025-04-29 12:47:38 +01:00
ITotalJustice	eea09f6e57	[appstore] make author search case insensitive.	2025-04-28 22:06:44 +01:00