From 18e15e39931976f2018375e95bfa6b43557ecfb5 Mon Sep 17 00:00:00 2001
From: Tim Strulik <timstrulik@gmail.com>
Date: Mon, 9 Nov 2026 17:16:28 +0100
Subject: [PATCH 1/2] feat: launcher profiles with saves of their own, and save
 import

The launcher (Windows and Linux) gets a Profile choice above Play. Each
profile is a user of the game with its own save folder, save/<id> in the
user folder; Play starts the game with HOOKSHOT_PROFILE=<id> and the game
mounts that profile's saves (host/nn_applet.c). Without the variable the
game plays the default profile, the uid every build had, so existing saves
stay where they are and an older game simply ignores it.

Manage renames the chosen profile, imports a save into it, opens its save
folder or removes it; New profile makes one. Import takes the game's save
folder (account.sav, option.sav, slot_00 ...) or an emulator's whole save
folder, and asks which user when it holds several. Nothing is deleted:
the profile's saves before an import, and a removed profile's saves, are
moved to save-backups. The default profile is marked "(default)" and
cannot be removed.

builder/linux/profiles.py and builder/HookshotBuilder/Profiles.cs keep the
same profiles.txt. Tests: tests/test_launcher_profiles.py,
tests/test_account_profile.py (pick_user built from the source),
tests/launcher_profiles (C#, wired into source-regressions on Windows) and
tests/test_hookshot_launch.py (--play passes the chosen profile).

Assisted-by: Claude Code
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .github/workflows/source-regressions.yml      |   6 +
 builder/HookshotBuilder/App.xaml              |  31 +++
 builder/HookshotBuilder/MainWindow.xaml       |  44 +++
 builder/HookshotBuilder/MainWindow.xaml.cs    | 204 +++++++++++++-
 builder/HookshotBuilder/Profiles.cs           | 257 ++++++++++++++++++
 builder/linux/hookshot-launch                 |  26 +-
 builder/linux/hookshot_builder.py             | 168 +++++++++++-
 builder/linux/profiles.py                     | 223 +++++++++++++++
 host/nn_applet.c                              |  35 ++-
 readme.md                                     |  16 ++
 .../LauncherProfilesTests.csproj              |  12 +
 tests/launcher_profiles/NuGet.Config          |   2 +
 tests/launcher_profiles/Program.cs            | 140 ++++++++++
 tests/run_all.py                              |   2 +
 tests/test_account_profile.py                 |  75 +++++
 tests/test_hookshot_launch.py                 |  20 +-
 tests/test_launcher_profiles.py               | 122 +++++++++
 17 files changed, 1360 insertions(+), 23 deletions(-)
 create mode 100644 builder/HookshotBuilder/Profiles.cs
 create mode 100644 builder/linux/profiles.py
 create mode 100644 tests/launcher_profiles/LauncherProfilesTests.csproj
 create mode 100644 tests/launcher_profiles/NuGet.Config
 create mode 100644 tests/launcher_profiles/Program.cs
 create mode 100644 tests/test_account_profile.py
 create mode 100644 tests/test_launcher_profiles.py

diff --git a/.github/workflows/source-regressions.yml b/.github/workflows/source-regressions.yml
index 40bb187d5..d3bad4e0b 100644
--- a/.github/workflows/source-regressions.yml
+++ b/.github/workflows/source-regressions.yml
@@ -100,6 +100,12 @@ jobs:
         run: |
           dotnet restore tests/builder_workers/BuilderWorkersTests.csproj --configfile tests/builder_workers/NuGet.Config
           dotnet run --project tests/builder_workers/BuilderWorkersTests.csproj --configuration Release --no-restore -- (Get-Command python).Source
+      - name: Check the launcher's profiles
+        if: ${{ !cancelled() && runner.os == 'Windows' }}
+        shell: pwsh
+        run: |
+          dotnet restore tests/launcher_profiles/LauncherProfilesTests.csproj --configfile tests/launcher_profiles/NuGet.Config
+          dotnet run --project tests/launcher_profiles/LauncherProfilesTests.csproj --configuration Release --no-restore
       - name: Compile Windows Builder
         if: ${{ !cancelled() && runner.os == 'Windows' }}
         run: dotnet build builder/HookshotBuilder/HookshotBuilder.csproj --configuration Debug -p:NuGetAudit=false
diff --git a/builder/HookshotBuilder/App.xaml b/builder/HookshotBuilder/App.xaml
index 0c9113683..449346146 100644
--- a/builder/HookshotBuilder/App.xaml
+++ b/builder/HookshotBuilder/App.xaml
@@ -334,6 +334,37 @@
       </Setter>
     </Style>
 
+    <!-- a row of a drop-down menu (the launcher's Manage profiles), as a ChoiceItem looks -->
+    <Style x:Key="MenuRow" TargetType="Button">
+      <Setter Property="Foreground" Value="{StaticResource Ink}"/>
+      <Setter Property="FontFamily" Value="{StaticResource Ui}"/>
+      <Setter Property="FontSize" Value="13"/>
+      <Setter Property="Cursor" Value="Hand"/>
+      <Setter Property="FocusVisualStyle" Value="{x:Null}"/>
+      <Setter Property="HorizontalContentAlignment" Value="Left"/>
+      <Setter Property="Template">
+        <Setter.Value>
+          <ControlTemplate TargetType="Button">
+            <Border x:Name="Box" Background="Transparent" CornerRadius="6" Padding="10,7">
+              <ContentPresenter HorizontalAlignment="Left"/>
+            </Border>
+            <ControlTemplate.Triggers>
+              <Trigger Property="IsMouseOver" Value="True">
+                <Setter TargetName="Box" Property="Background" Value="{StaticResource RaisedHover}"/>
+              </Trigger>
+              <Trigger Property="IsKeyboardFocused" Value="True">
+                <Setter TargetName="Box" Property="Background" Value="{StaticResource RaisedHover}"/>
+              </Trigger>
+              <Trigger Property="IsEnabled" Value="False">
+                <Setter Property="Foreground" Value="{StaticResource InkFaint}"/>
+                <Setter Property="Cursor" Value="Arrow"/>
+              </Trigger>
+            </ControlTemplate.Triggers>
+          </ControlTemplate>
+        </Setter.Value>
+      </Setter>
+    </Style>
+
     <Style x:Key="Choice" TargetType="ComboBox">
       <Setter Property="Height" Value="40"/>
       <Setter Property="FontFamily" Value="{StaticResource Ui}"/>
diff --git a/builder/HookshotBuilder/MainWindow.xaml b/builder/HookshotBuilder/MainWindow.xaml
index e358b23db..4d811df63 100644
--- a/builder/HookshotBuilder/MainWindow.xaml
+++ b/builder/HookshotBuilder/MainWindow.xaml
@@ -266,7 +266,51 @@
           <TextBlock x:Name="LaunchVersion" Style="{StaticResource Sub}" HorizontalAlignment="Center" TextAlignment="Center" Margin="0,8,0,0"/>
           <TextBlock x:Name="LaunchStatus" FontSize="13" Foreground="{StaticResource InkSoft}" Text="Checking for updates…"
                      HorizontalAlignment="Center" Margin="0,16,0,0"/>
+          <!-- the profiles (Profiles.cs): the one Play starts, right above Play, with New profile after it. What changes the chosen
+               profile is wanted rarely: it is in the Manage menu, out of Play's way, with Remove last and apart -->
           <StackPanel Orientation="Horizontal" HorizontalAlignment="Center" Margin="0,28,0,0">
+            <TextBlock Style="{StaticResource Note}" Text="Profile" VerticalAlignment="Center" Margin="0,0,10,0"/>
+            <ComboBox x:Name="ProfileBox" Style="{StaticResource Choice}" Width="220" AutomationProperties.Name="Profile"
+                      SelectionChanged="ProfileChanged"/>
+            <Button x:Name="ProfileManage" Style="{StaticResource Quiet}" Margin="10,0,0,0" AutomationProperties.Name="Manage profiles"
+                    Click="ProfileManageClick">
+              <StackPanel Orientation="Horizontal">
+                <TextBlock Text="Manage" FontSize="13" FontWeight="SemiBold"/>
+                <Path Data="M0,0 L8,0 L4,5 Z" Fill="{StaticResource InkSoft}" VerticalAlignment="Center" Margin="8,1,0,0"/>
+              </StackPanel>
+            </Button>
+            <Button Style="{StaticResource Quiet}" Margin="10,0,0,0" FontSize="13" Content="New profile…" Click="ProfileNewClick"/>
+          </StackPanel>
+          <Popup x:Name="ProfileMenu" PlacementTarget="{Binding ElementName=ProfileManage}" Placement="Bottom" StaysOpen="False"
+                 AllowsTransparency="True">
+            <Border Background="{StaticResource Raised}" BorderBrush="{StaticResource LineStrong}" BorderThickness="1" CornerRadius="8"
+                    Padding="4" Margin="0,4,0,0" MinWidth="240">
+              <StackPanel>
+                <Button x:Name="MenuRename" Style="{StaticResource MenuRow}" Click="ProfileRenameClick"/>
+                <Button x:Name="MenuImport" Style="{StaticResource MenuRow}" Click="ProfileImportClick"/>
+                <Button x:Name="MenuFolder" Style="{StaticResource MenuRow}" Click="ProfileFolderClick"/>
+                <Border Height="1" Background="{StaticResource Line}" Margin="6,4"/>
+                <Button x:Name="MenuRemove" Style="{StaticResource MenuRow}" Foreground="{StaticResource Bad}" Click="ProfileRemoveClick"/>
+              </StackPanel>
+            </Border>
+          </Popup>
+          <StackPanel x:Name="ProfileNameRow" Orientation="Horizontal" HorizontalAlignment="Center" Margin="0,10,0,0" Visibility="Collapsed">
+            <TextBox x:Name="ProfileName" Style="{StaticResource Path}" Width="260" MaxLength="32" AutomationProperties.Name="Profile name"
+                     KeyDown="ProfileNameKey"/>
+            <Button x:Name="ProfileNameOk" Style="{StaticResource Quiet}" Content="Add" Margin="10,0,0,0" Click="ProfileNameOkClick"/>
+            <Button Style="{StaticResource LinkButton}" Content="Cancel" Margin="14,0,0,0" VerticalAlignment="Center" Click="ProfileRowsCancel"/>
+          </StackPanel>
+          <StackPanel x:Name="SaveChoiceRow" HorizontalAlignment="Center" Margin="0,10,0,0" Visibility="Collapsed">
+            <TextBlock x:Name="SaveChoiceText" Style="{StaticResource Note}" HorizontalAlignment="Center" Margin="0,0,0,8"/>
+            <StackPanel Orientation="Horizontal" HorizontalAlignment="Center">
+              <ComboBox x:Name="SaveChoice" Style="{StaticResource Choice}" Width="560" AutomationProperties.Name="Save to import"/>
+              <Button Style="{StaticResource Quiet}" Content="Import" Margin="10,0,0,0" Click="SaveChoiceOkClick"/>
+              <Button Style="{StaticResource LinkButton}" Content="Cancel" Margin="14,0,0,0" VerticalAlignment="Center" Click="ProfileRowsCancel"/>
+            </StackPanel>
+          </StackPanel>
+          <TextBlock x:Name="ProfileNote" Style="{StaticResource Note}" HorizontalAlignment="Center" TextAlignment="Center" MaxWidth="700"
+                     Margin="0,10,0,0"/>
+          <StackPanel Orientation="Horizontal" HorizontalAlignment="Center" Margin="0,24,0,0">
             <Button x:Name="LaunchUpdate" Style="{StaticResource Primary}" Height="50" Padding="26,0" Margin="0,0,12,0" Content="Update"
                     Visibility="Collapsed" Click="LaunchUpdateClick"/>
             <Button x:Name="LaunchPlay" Style="{StaticResource GoButton}" Click="LaunchPlayClick">
diff --git a/builder/HookshotBuilder/MainWindow.xaml.cs b/builder/HookshotBuilder/MainWindow.xaml.cs
index ad0b23c9b..61261d233 100644
--- a/builder/HookshotBuilder/MainWindow.xaml.cs
+++ b/builder/HookshotBuilder/MainWindow.xaml.cs
@@ -198,6 +198,9 @@ async void ShowLauncher(string folder)
         var game = GameVersion(folder) ?? ReadVersion(folder);
         LaunchVersion.Text = (game != null ? $"Hookshot {game}" : "Hookshot") + " · " + folder;
         LaunchPlay.IsEnabled = File.Exists(GameExe(folder));
+        profileUser = Profiles.UserDir(folder);
+        ProfileNote.Text = "";   // (what the last action did; empty until then)
+        ShowProfiles(Profiles.Chosen(folder, SavedProfile()));
         ShowPage(LaunchPage);
         latestTag = Environment.GetEnvironmentVariable("HOOKSHOT_LATEST_TAG") is { Length: > 0 } fake ? (fake == "none" ? null : fake) : await Updater.LatestTag();
         updateTarget = latestTag ?? Tools.Find()?.Version;   // (GitHub's newest, else this builder's own)
@@ -233,11 +236,12 @@ static string GameExe(string folder)
         return File.Exists(game) ? game : System.IO.Path.Combine(folder, "hookshot.exe");
     }
 
-    /// (the launcher already checked for updates: the game does not ask again)
+    /// (the launcher already checked for updates: the game does not ask again. The profile is the one chosen last: Profiles.cs)
     static void StartGame(string folder)
     {
         var si = new ProcessStartInfo(GameExe(folder)) { UseShellExecute = false, WorkingDirectory = folder };
         si.Environment["HOOKSHOT_NO_UPDATE_CHECK"] = "1";
+        si.Environment["HOOKSHOT_PROFILE"] = Profiles.Chosen(folder, SavedProfile());
         Process.Start(si);
     }
 
@@ -252,6 +256,175 @@ void LaunchPlayClick(object sender, RoutedEventArgs e)
     void LaunchFolderClick(object sender, RoutedEventArgs e) =>
         Process.Start(new ProcessStartInfo(launchFolder) { UseShellExecute = true });
 
+    // ---- the launcher's profiles (Profiles.cs): which saves Play starts the game with ----
+    string profileUser = "";
+    List<Profiles.Profile> profileList = new();
+    string? renaming;   // (the name row renames this profile; null: it adds one)
+    List<string> saveChoices = new();
+    string saveChosenFolder = "";
+    bool fillingProfiles;
+
+    void ShowProfiles(string id)
+    {
+        profileList = Profiles.Load(profileUser);
+        fillingProfiles = true;
+        ProfileBox.ItemsSource = profileList.Select(Profiles.ShownName).ToList();
+        var i = profileList.FindIndex(p => p.Id == id);
+        ProfileBox.SelectedIndex = i < 0 ? 0 : i;
+        fillingProfiles = false;
+        SaveProfile(CurrentProfile.Id);
+        FillProfileMenu();
+    }
+
+    /// The Manage menu, naming the profile its actions change
+    void FillProfileMenu()
+    {
+        var p = CurrentProfile;
+        MenuRename.Content = $"Rename {p.Name}…";
+        MenuImport.Content = $"Import a save into {p.Name}…";
+        MenuFolder.Content = $"Open {p.Name}'s save folder";
+        MenuRemove.Content = p.Id == Profiles.Default ? "The default profile cannot be removed" : $"Remove {p.Name}…";
+        MenuRemove.IsEnabled = p.Id != Profiles.Default;
+    }
+
+    // (opened, not toggled: a click on Manage while the menu is open closes it first, as any click outside does)
+    void ProfileManageClick(object sender, RoutedEventArgs e) => ProfileMenu.IsOpen = true;
+
+    Profiles.Profile CurrentProfile => profileList[Math.Clamp(ProfileBox.SelectedIndex, 0, profileList.Count - 1)];
+
+    void ProfileChanged(object sender, SelectionChangedEventArgs e)
+    {
+        if (fillingProfiles || profileList.Count == 0) return;
+        SaveProfile(CurrentProfile.Id);
+        FillProfileMenu();
+    }
+
+    void ProfileError(Exception x) => MessageBox.Show(this, x.Message, "Hookshot");
+
+    void ProfileRowsCancel(object? sender, RoutedEventArgs? e)
+    {
+        ProfileMenu.IsOpen = false;
+        ProfileNameRow.Visibility = Visibility.Collapsed;
+        SaveChoiceRow.Visibility = Visibility.Collapsed;
+    }
+
+    void ShowNameRow(string? id, string name, string button)
+    {
+        ProfileRowsCancel(null, null);
+        renaming = id;
+        ProfileName.Text = name;
+        ProfileNameOk.Content = button;
+        ProfileNameRow.Visibility = Visibility.Visible;
+        ProfileName.Focus();
+        ProfileName.SelectAll();
+    }
+
+    void ProfileNewClick(object sender, RoutedEventArgs e) => ShowNameRow(null, "", "Add");
+
+    void ProfileRenameClick(object sender, RoutedEventArgs e) => ShowNameRow(CurrentProfile.Id, CurrentProfile.Name, "Rename");
+
+    void ProfileNameKey(object sender, System.Windows.Input.KeyEventArgs e)
+    {
+        if (e.Key == System.Windows.Input.Key.Enter) ProfileNameOkClick(sender, e);
+        else if (e.Key == System.Windows.Input.Key.Escape) ProfileRowsCancel(sender, e);
+    }
+
+    void ProfileNameOkClick(object sender, RoutedEventArgs e)
+    {
+        try
+        {
+            if (renaming is { } id)
+            {
+                Profiles.Rename(profileUser, id, ProfileName.Text);
+                ShowProfiles(id);
+                ProfileNote.Text = $"Renamed to {Profiles.CleanName(ProfileName.Text)}.";
+            }
+            else
+            {
+                ShowProfiles(Profiles.Add(profileUser, ProfileName.Text));
+                ProfileNote.Text = $"{CurrentProfile.Name} has no saves yet: the game starts at an empty file select. Import save… brings one in.";
+            }
+            ProfileRowsCancel(null, null);
+        }
+        catch (Exception x) when (x is IOException or UnauthorizedAccessException or ArgumentException) { ProfileError(x); }
+    }
+
+    void ProfileRemoveClick(object sender, RoutedEventArgs e)
+    {
+        ProfileRowsCancel(null, null);
+        var p = CurrentProfile;
+        if (p.Id == Profiles.Default)
+        {
+            MessageBox.Show(this, $"{p.Name} is the default profile and cannot be removed: the game plays it when it is started without the launcher.", "Hookshot");
+            return;
+        }
+        var backups = System.IO.Path.Combine(profileUser, "save-backups");
+        if (MessageBox.Show(this, $"Remove the profile {p.Name}?\n\nIts saves are not deleted: they are moved to {backups}.", "Hookshot",
+                            MessageBoxButton.YesNo) != MessageBoxResult.Yes) return;
+        try
+        {
+            var moved = Profiles.Remove(profileUser, p.Id);
+            ShowProfiles(Profiles.Default);
+            ProfileNote.Text = $"Removed {p.Name}." + (moved != null ? $" Its saves are in {moved}" : "");
+        }
+        catch (Exception x) when (x is IOException or UnauthorizedAccessException or ArgumentException) { ProfileError(x); }
+    }
+
+    void ProfileFolderClick(object sender, RoutedEventArgs e)
+    {
+        ProfileMenu.IsOpen = false;
+        if (Profiles.FolderToShow(profileUser, CurrentProfile.Id) is { } path)
+            Process.Start(new ProcessStartInfo("explorer.exe", $"\"{path}\"") { UseShellExecute = true });
+        else MessageBox.Show(this, $"There are no saves yet: the game makes {profileUser} at its first start.", "Hookshot");
+    }
+
+    void ProfileImportClick(object sender, RoutedEventArgs e)
+    {
+        ProfileRowsCancel(null, null);
+        if (PickFolder("The save to import: its folder, or an emulator's save folder") is not { } chosen) return;
+        var found = Profiles.FindSaves(chosen);
+        if (found.Count == 0)
+        {
+            MessageBox.Show(this, $"No save of Ocarina of Time in {chosen}.\n\nChoose the folder with account.sav, option.sav and slot_00 to " +
+                                  "slot_05 in it, or an emulator's save folder.", "Hookshot");
+            return;
+        }
+        if (found.Count == 1)
+        {
+            ImportSave(found[0], chosen);
+            return;
+        }
+        // (an emulator's save folder: one save for each of its users. The row asks which)
+        saveChoices = found;
+        saveChosenFolder = chosen;
+        SaveChoiceText.Text = $"{chosen} has {found.Count} saves of the game. Which one goes into {CurrentProfile.Name}?";
+        SaveChoice.ItemsSource = found.Select(f => Profiles.Describe(f, chosen)).ToList();
+        SaveChoice.SelectedIndex = 0;
+        SaveChoiceRow.Visibility = Visibility.Visible;
+    }
+
+    void SaveChoiceOkClick(object sender, RoutedEventArgs e)
+    {
+        var i = SaveChoice.SelectedIndex;
+        ProfileRowsCancel(null, null);
+        if (i >= 0 && i < saveChoices.Count) ImportSave(saveChoices[i], saveChosenFolder);
+    }
+
+    void ImportSave(string source, string chosen)
+    {
+        var p = CurrentProfile;
+        var backups = System.IO.Path.Combine(profileUser, "save-backups");
+        if (MessageBox.Show(this, $"Import this save into the profile {p.Name}?\n\n{Profiles.Describe(source, chosen)}\n\n" +
+                                  $"The profile's saves now, if it has any, are moved to {backups} first.", "Hookshot",
+                            MessageBoxButton.YesNo) != MessageBoxResult.Yes) return;
+        try
+        {
+            var moved = Profiles.Import(source, profileUser, p.Id);
+            ProfileNote.Text = $"Imported into {p.Name}." + (moved != null ? $" Its saves before are in {moved}" : "");
+        }
+        catch (Exception x) when (x is IOException or UnauthorizedAccessException or ArgumentException) { ProfileError(x); }
+    }
+
     // ---- what the player chose last time (the install folder, the game files): builder-settings.json beside the versions ----
     sealed class BuilderSettings
     {
@@ -259,15 +432,14 @@ sealed class BuilderSettings
         public string? Nup { get; set; }
         public string? Romfs { get; set; }
         public string? Exefs { get; set; }
+        public string? Profile { get; set; }   // (the launcher's profile Play starts: Profiles.cs)
     }
     static string SettingsPath => System.IO.Path.Combine(
         Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "HookshotBuilder", "builder-settings.json");
 
     void ApplySettings()
     {
-        BuilderSettings? s = null;
-        try { s = System.Text.Json.JsonSerializer.Deserialize<BuilderSettings>(File.ReadAllText(SettingsPath)); } catch (Exception) { }
-        if (s == null) return;
+        if (ReadSettings() is not { } s) return;
         if (!string.IsNullOrEmpty(s.Out)) OutPath.Text = s.Out;
         if (s.Romfs != null && s.Exefs != null && Directory.Exists(s.Romfs) && File.Exists(System.IO.Path.Combine(s.Exefs, "main")))
         {
@@ -286,11 +458,33 @@ void ApplySettings()
         }
     }
 
+    static BuilderSettings? ReadSettings()
+    {
+        try { return System.Text.Json.JsonSerializer.Deserialize<BuilderSettings>(File.ReadAllText(SettingsPath)); }
+        catch (Exception) { return null; }
+    }
+
+    static string? SavedProfile() => ReadSettings()?.Profile;
+
+    /// (only the profile changes: the launcher has none of the build form's choices to write)
+    static void SaveProfile(string id)
+    {
+        try
+        {
+            var s = ReadSettings() ?? new BuilderSettings();
+            if (s.Profile == id) return;
+            s.Profile = id;
+            Directory.CreateDirectory(System.IO.Path.GetDirectoryName(SettingsPath)!);
+            File.WriteAllText(SettingsPath, System.Text.Json.JsonSerializer.Serialize(s));
+        }
+        catch (Exception) { }
+    }
+
     void SaveSettings()
     {
         try
         {
-            var s = new BuilderSettings { Out = OutPath.Text, Nup = romfs == null ? chosenNup : null, Romfs = romfs, Exefs = exefs };
+            var s = new BuilderSettings { Out = OutPath.Text, Nup = romfs == null ? chosenNup : null, Romfs = romfs, Exefs = exefs, Profile = SavedProfile() };
             Directory.CreateDirectory(System.IO.Path.GetDirectoryName(SettingsPath)!);
             File.WriteAllText(SettingsPath, System.Text.Json.JsonSerializer.Serialize(s));
         }
diff --git a/builder/HookshotBuilder/Profiles.cs b/builder/HookshotBuilder/Profiles.cs
new file mode 100644
index 000000000..571a11074
--- /dev/null
+++ b/builder/HookshotBuilder/Profiles.cs
@@ -0,0 +1,257 @@
+using System.IO;
+using System.Text.RegularExpressions;
+
+namespace HookshotBuilder;
+
+// The launcher's profiles, as builder/linux/profiles.py keeps them on Linux (the same profiles.txt): each one is a user of the
+// game with saves of its own, save\<id> in the game's user folder (user in the game folder on Windows: host/hos_main.c).
+//
+// The game plays the profile HOOKSHOT_PROFILE=<id> names (host/nn_applet.c); without it, the default profile, the one user
+// every build had before profiles, so its saves stay where they were. The list is profiles.txt in the user folder, one
+// "<id> <name>" a line. An id is 32 hex digits, the save folder's name (host/nn_fs.c).
+//
+// A save from a console or an emulator is imported into a profile: the folder of the game's save data (account.sav,
+// option.sav, slot_00 ... slot_05) is copied over the profile's. The profile's saves before it are kept in
+// save-backups\<id>-<time> in the user folder. Removing a profile moves its saves there too: nothing is deleted.
+public static class Profiles
+{
+    public const string Default = "5a3c9e1f0b7d24680000000000000001";   // (the uid host/nn_applet.c always had)
+    const string Prefix = "5a3c9e1f0b7d2468";
+    const string Title = "0400486024dec000";   // (the game's program id: an emulator keeps its saves in a folder of that name)
+    const string ListName = "profiles.txt";
+    public const int NameMax = 32;
+    static readonly Regex Id = new("^[0-9a-f]{32}$");
+    static readonly Regex Slot = new("^slot_[0-9]{2}$", RegexOptions.IgnoreCase);
+
+    public sealed record Profile(string Id, string Name);
+
+    /// The folder the game keeps its saves in when the launcher starts it: user in the game folder
+    public static string UserDir(string folder) => Path.Combine(folder, "user");
+
+    /// The name the profile list shows: the default profile says it is, whatever it is called, so that it is clear why it
+    /// cannot be removed
+    public static string ShownName(Profile p) => p.Id == Default ? $"{p.Name} (default)" : p.Name;
+
+    public static string CleanName(string? name)
+    {
+        var words = string.Join(" ", (name ?? "").Split((char[]?)null, StringSplitOptions.RemoveEmptyEntries));
+        return words.Length > NameMax ? words[..NameMax] : words;
+    }
+
+    /// The profiles, the default one first
+    public static List<Profile> Load(string user)
+    {
+        var list = new List<Profile>();
+        try
+        {
+            foreach (var raw in File.ReadAllLines(Path.Combine(user, ListName)))
+            {
+                var line = raw.Trim();
+                var space = line.IndexOf(' ');
+                var id = (space < 0 ? line : line[..space]).ToLowerInvariant();
+                var name = space < 0 ? "" : line[(space + 1)..];
+                if (Id.IsMatch(id) && id != new string('0', 32) && list.All(p => p.Id != id))
+                    list.Add(new Profile(id, CleanName(name) is { Length: > 0 } n ? n : id[^4..]));
+            }
+        }
+        catch (IOException) { }
+        catch (UnauthorizedAccessException) { }
+        var first = list.FindIndex(p => p.Id == Default);
+        if (first < 0) list.Insert(0, new Profile(Default, "Player"));
+        else if (first > 0)
+        {
+            var d = list[first];
+            list.RemoveAt(first);
+            list.Insert(0, d);
+        }
+        return list;
+    }
+
+    static void Store(string user, IEnumerable<Profile> profiles)
+    {
+        Directory.CreateDirectory(user);
+        var path = Path.Combine(user, ListName);
+        var lines = new List<string> { "# Hookshot's profiles: the save folder (save/<id>) and the name the launcher shows" };
+        lines.AddRange(profiles.Select(p => $"{p.Id} {p.Name}"));
+        File.WriteAllText(path + ".tmp", string.Join("\n", lines) + "\n");
+        File.Move(path + ".tmp", path, overwrite: true);
+    }
+
+    /// The profile Play starts the game with: the one chosen last, while it is still on the list
+    public static string Chosen(string folder, string? chosen) =>
+        chosen != null && Load(UserDir(folder)).Any(p => p.Id == chosen) ? chosen : Default;
+
+    /// A new profile, with no saves yet: the game starts it at an empty file select. Returns its id.
+    public static string Add(string user, string? name)
+    {
+        var clean = CleanName(name);
+        if (clean.Length == 0) throw new ArgumentException("Give the profile a name.");
+        var list = Load(user);
+        if (list.Any(p => string.Equals(p.Name, clean, StringComparison.OrdinalIgnoreCase)))
+            throw new ArgumentException($"There is a profile called \"{clean}\" already.");
+        var taken = new HashSet<string>(list.Select(p => p.Id));
+        try
+        {
+            foreach (var d in Directory.EnumerateDirectories(Path.Combine(user, "save")))   // (a removed profile's folder is not reused)
+                taken.Add(Path.GetFileName(d).ToLowerInvariant());
+        }
+        catch (IOException) { }
+        catch (UnauthorizedAccessException) { }
+        var n = 2L;
+        while (taken.Contains($"{Prefix}{n:x16}")) n++;
+        var id = $"{Prefix}{n:x16}";
+        list.Add(new Profile(id, clean));
+        Store(user, list);
+        return id;
+    }
+
+    public static void Rename(string user, string id, string? name)
+    {
+        var clean = CleanName(name);
+        if (clean.Length == 0) throw new ArgumentException("Give the profile a name.");
+        var list = Load(user);
+        if (list.Any(p => p.Id != id && string.Equals(p.Name, clean, StringComparison.OrdinalIgnoreCase)))
+            throw new ArgumentException($"There is a profile called \"{clean}\" already.");
+        Store(user, list.Select(p => p.Id == id ? p with { Name = clean } : p));
+    }
+
+    /// The folder "Open save folder" shows: the profile's saves, or the nearest folder above them that is there. None is
+    /// made: an empty save folder would read to the game as a save that exists.
+    public static string? FolderToShow(string user, string id) =>
+        new[] { Path.Combine(user, "save", id), Path.Combine(user, "save"), user }.FirstOrDefault(Directory.Exists);
+
+    /// Moves the profile's save folder to save-backups; returns where, or null when there were no saves
+    static string? Backup(string user, string id)
+    {
+        var saves = Path.Combine(user, "save", id);
+        if (!Directory.Exists(saves)) return null;
+        if (!Directory.EnumerateFileSystemEntries(saves).Any())
+        {
+            Directory.Delete(saves);
+            return null;
+        }
+        var root = Path.Combine(user, "save-backups");
+        Directory.CreateDirectory(root);
+        var stamp = DateTime.Now.ToString("yyyy-MM-dd_HH-mm-ss");
+        var dest = Path.Combine(root, $"{id}-{stamp}");
+        for (var k = 2; Directory.Exists(dest) || File.Exists(dest); k++) dest = Path.Combine(root, $"{id}-{stamp}-{k}");
+        Directory.Move(saves, dest);
+        return dest;
+    }
+
+    /// Takes the profile off the list; its saves go to save-backups. Returns where they went, or null.
+    public static string? Remove(string user, string id)
+    {
+        if (id == Default)
+            throw new ArgumentException("The default profile cannot be removed: the game plays it when it is started without the launcher.");
+        var moved = Backup(user, id);
+        Store(user, Load(user).Where(p => p.Id != id));
+        return moved;
+    }
+
+    /// A folder of the game's save data: account.sav, option.sav or slot_NN in it
+    public static bool IsSave(string path)
+    {
+        try
+        {
+            foreach (var e in Directory.EnumerateFileSystemEntries(path))
+            {
+                var name = Path.GetFileName(e);
+                if (name.Equals("account.sav", StringComparison.OrdinalIgnoreCase) || name.Equals("option.sav", StringComparison.OrdinalIgnoreCase)
+                    || (Slot.IsMatch(name) && Directory.Exists(e)))
+                    return true;
+            }
+        }
+        catch (IOException) { }
+        catch (UnauthorizedAccessException) { }
+        return false;
+    }
+
+    /// The game's save folders in what the player chose: the save folder itself, or an emulator's save folder
+    /// (save\0000000000000000\(user)\0400486024DEC000), one for each user it has. The newest first.
+    public static List<string> FindSaves(string path, int depth = 6)
+    {
+        if (IsSave(path)) return new List<string> { path };
+        var found = new List<string>();
+        void Walk(string dir, int level)
+        {
+            IEnumerable<string> subs;
+            try { subs = Directory.EnumerateDirectories(dir).ToList(); }
+            catch (IOException) { return; }
+            catch (UnauthorizedAccessException) { return; }
+            foreach (var sub in subs)
+            {
+                if (new DirectoryInfo(sub).LinkTarget != null) continue;
+                if (Path.GetFileName(sub).Equals(Title, StringComparison.OrdinalIgnoreCase) && IsSave(sub)) found.Add(sub);
+                else if (level + 1 < depth) Walk(sub, level + 1);
+            }
+        }
+        Walk(path, 0);
+        return found.OrderByDescending(LastSaved).ToList();
+    }
+
+    public static DateTime LastSaved(string path)
+    {
+        var newest = DateTime.MinValue;
+        try
+        {
+            foreach (var f in Directory.EnumerateFiles(path, "*", SearchOption.AllDirectories))
+                if (File.GetLastWriteTime(f) is var t && t > newest) newest = t;
+        }
+        catch (IOException) { }
+        catch (UnauthorizedAccessException) { }
+        return newest;
+    }
+
+    /// One line for a save folder: where it is under the folder the player chose, how many save slots, when last saved
+    public static string Describe(string path, string chosen)
+    {
+        var where = Path.GetRelativePath(chosen, path);
+        if (where == ".") where = Path.GetFileName(Path.TrimEndingDirectorySeparator(path)) is { Length: > 0 } n ? n : path;
+        var slots = 0;
+        try
+        {
+            slots = Directory.EnumerateDirectories(path).Count(d => Slot.IsMatch(Path.GetFileName(d)) && Directory.EnumerateFileSystemEntries(d).Any());
+        }
+        catch (IOException) { }
+        catch (UnauthorizedAccessException) { }
+        var saved = LastSaved(path);
+        var when = saved == DateTime.MinValue ? "never" : saved.ToString("yyyy-MM-dd HH:mm");
+        return $"{where}  ({slots} save slot{(slots == 1 ? "" : "s")}, last saved {when})";
+    }
+
+    static void CopyTree(string from, string to)
+    {
+        Directory.CreateDirectory(to);
+        foreach (var f in Directory.EnumerateFiles(from)) File.Copy(f, Path.Combine(to, Path.GetFileName(f)));
+        foreach (var d in Directory.EnumerateDirectories(from)) CopyTree(d, Path.Combine(to, Path.GetFileName(d)));
+    }
+
+    static bool Within(string path, string root) =>
+        path.Equals(root, StringComparison.OrdinalIgnoreCase) ||
+        path.StartsWith(root.TrimEnd(Path.DirectorySeparatorChar) + Path.DirectorySeparatorChar, StringComparison.OrdinalIgnoreCase);
+
+    /// Copies the save folder src over the profile's saves. The profile's saves before it go to save-backups: returns where,
+    /// or null when it had none. A failed copy leaves the profile's saves as they were.
+    public static string? Import(string src, string user, string id)
+    {
+        if (!IsSave(src))
+            throw new ArgumentException($"{src} has none of the game's save files (account.sav, option.sav, slot_00 ...).");
+        var saves = Path.Combine(user, "save", id);
+        var fullSrc = Path.GetFullPath(src);
+        var fullSaves = Path.GetFullPath(saves);
+        if (Within(fullSrc, fullSaves) || Within(fullSaves, fullSrc)) throw new ArgumentException("These are the profile's own saves.");
+        Directory.CreateDirectory(Path.GetDirectoryName(saves)!);
+        var staging = saves + ".importing";
+        if (Directory.Exists(staging)) Directory.Delete(staging, recursive: true);
+        try { CopyTree(src, staging); }
+        catch
+        {
+            try { Directory.Delete(staging, recursive: true); } catch (Exception) { }
+            throw;
+        }
+        var moved = Backup(user, id);
+        Directory.Move(staging, saves);
+        return moved;
+    }
+}
diff --git a/builder/linux/hookshot-launch b/builder/linux/hookshot-launch
index 1c6c18fe0..d60a71d9b 100755
--- a/builder/linux/hookshot-launch
+++ b/builder/linux/hookshot-launch
@@ -15,16 +15,16 @@ ini_path() {
     fi
 }
 
-# the last out= line, as the builder keeps the last value it wrote
-out_of() {
-    out=
+# the last <name>= line, as the builder keeps the last value it wrote
+value_of() {
+    value=
     while IFS= read -r line || [ -n "$line" ]; do
         case $line in
-            out=*) out=${line#out=} ;;
+            "$2"=*) value=${line#"$2"=} ;;
         esac
     done < "$1"
-    [ -n "$out" ] || return 1
-    printf '%s\n' "$out"
+    [ -n "$value" ] || return 1
+    printf '%s\n' "$value"
 }
 
 ready() {
@@ -32,11 +32,14 @@ ready() {
 }
 
 folder=${1:-}
-if [ -z "$folder" ]; then
-    ini=$(ini_path)
-    if [ -f "$ini" ]; then
-        folder=$(out_of "$ini") || folder=
+ini=$(ini_path)
+profile=
+if [ -f "$ini" ]; then
+    if [ -z "$folder" ]; then
+        folder=$(value_of "$ini" out) || folder=
     fi
+    # (the profile the launcher's Play chose last: builder/linux/profiles.py)
+    profile=$(value_of "$ini" profile) || profile=
 fi
 
 if ! ready "$folder"; then
@@ -62,6 +65,9 @@ done
 cd "$folder"
 # (--play already chose Play. The game's own update question stays for a bin/hookshot the player started themselves)
 export HOOKSHOT_NO_UPDATE_CHECK=1
+if [ -n "$profile" ]; then
+    export HOOKSHOT_PROFILE="$profile"
+fi
 if [ -x ./bin/hookshot ]; then
     exec ./bin/hookshot
 fi
diff --git a/builder/linux/hookshot_builder.py b/builder/linux/hookshot_builder.py
index 7cdb71c2a..bb28c031e 100644
--- a/builder/linux/hookshot_builder.py
+++ b/builder/linux/hookshot_builder.py
@@ -4,7 +4,8 @@
 
     hookshot_builder.py                     the window. Its button is Build, Update, Play, or Update builder
     hookshot_builder.py --play              the game built last time, if there is one (else the window)
-    hookshot_builder.py --launch <folder>   that folder's launcher: Play, and Update when a newer release is out
+    hookshot_builder.py --launch <folder>   that folder's launcher: Play with a profile (profiles.py), and Update when a newer
+                                            release is out
     hookshot_builder.py --update <folder>   download the new release (only parts that changed) and build the folder again
 """
 import os
@@ -25,6 +26,7 @@
 sys.path.insert(0, os.path.join(ROOT, "nx2"))
 sys.path.insert(0, os.path.join(ROOT, "third_party", "a64-kit", "tools"))
 import linux_update  # noqa: E402  (the release check and the part download)
+import profiles  # noqa: E402  (the launcher's profiles and save import)
 import make_game  # noqa: E402  (LANGUAGES, BUILD_ID)
 import toolchain  # noqa: E402  (default_jobs: RX_JOBS)
 
@@ -65,6 +67,12 @@ def game_ready(folder):
     return linux_update.game_exe(folder) is not None
 
 
+def chosen_profile(folder, cfg=None):
+    """the profile Play starts the game with: the one chosen last, while it is still on the list"""
+    uid = (load_config() if cfg is None else cfg).get("profile", "")
+    return uid if any(uid == p[0] for p in profiles.load(profiles.user_dir(folder))) else profiles.DEFAULT
+
+
 def play(folder):
     """the game, on its own (it outlives this window), from its folder. The launcher already asked about updates."""
     exe = linux_update.game_exe(folder)
@@ -73,6 +81,7 @@ def play(folder):
     env = {k: v for k, v in os.environ.items() if not k.startswith(("HOOKSHOT_", "PYTHON", "APPDIR", "APPIMAGE", "ARGV0", "OWD"))}
     env.pop("LD_LIBRARY_PATH", None)
     env["HOOKSHOT_NO_UPDATE_CHECK"] = "1"
+    env["HOOKSHOT_PROFILE"] = chosen_profile(folder)
     subprocess.Popen([exe], cwd=folder, env=env, start_new_session=True,
                      stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
 
@@ -363,13 +372,164 @@ def show_launch(self, folder):
         ttk.Label(f, text=folder, wraplength=self.px(560)).pack(anchor="w", **self.pad)
         self.launch_status = tk.StringVar(value="Checking for updates...")
         ttk.Label(f, textvariable=self.launch_status, wraplength=self.px(560)).pack(anchor="w", **self.pad)
+        self.show_profile_row(f, folder)
+        # (Play on the right, the default (Enter); Update joins it on its left when there is one. The game folder, rarely
+        # wanted, on the left)
         buttons = ttk.Frame(f)
-        buttons.pack(anchor="e", **self.pad)
+        buttons.pack(fill="x", **self.pad)
+        ttk.Button(buttons, text="Play", default="active", command=lambda: self.play_and_close(folder)).pack(side="right", padx=self.px(4))
         self.launch_update = ttk.Button(buttons, text="Update", command=lambda: self.begin_update(folder))
-        ttk.Button(buttons, text="Play", command=lambda: self.play_and_close(folder)).pack(side="right", padx=self.px(4))
-        ttk.Button(buttons, text="Open folder", command=lambda: subprocess.Popen(["xdg-open", folder])).pack(side="right", padx=self.px(4))
+        ttk.Button(buttons, text="Open game folder", command=lambda: subprocess.Popen(["xdg-open", folder])).pack(side="left", padx=self.px(4))
+        self.bind("<Return>", lambda event: self.play_and_close(folder))
         self.lookup_latest()
 
+    # ---- the launcher's profiles (profiles.py) ----
+    def show_profile_row(self, f, folder):
+        """the profile Play starts the game with, right above Play, with New profile after it. What changes the chosen profile
+        is wanted rarely: it is in the Manage menu, out of Play's way, with Remove last and apart"""
+        self.user = profiles.user_dir(folder)
+        row = ttk.Frame(f)
+        row.pack(fill="x", padx=self.px(12), pady=(self.px(16), self.px(4)))
+        ttk.Label(row, text="Profile").pack(side="left", padx=(self.px(4), self.px(8)))
+        self.profile_box = ttk.Combobox(row, state="readonly", width=24)
+        self.profile_box.pack(side="left")
+        self.profile_box.bind("<<ComboboxSelected>>", lambda event: self.pick_profile())
+        self.profile_menu = tk.Menu(self, tearoff=False)
+        ttk.Menubutton(row, text="Manage", menu=self.profile_menu).pack(side="left", padx=self.px(8))
+        ttk.Button(row, text="New profile...", command=self.new_profile).pack(side="left")
+        self.profile_note = tk.StringVar()   # (what the last action did; empty until then)
+        ttk.Label(f, textvariable=self.profile_note, wraplength=self.px(560)).pack(anchor="w", **self.pad)
+        self.show_profiles(chosen_profile(folder, self.cfg))
+
+    def fill_profile_menu(self):
+        """the Manage menu, naming the profile its actions change"""
+        uid, name = self.current_profile()
+        menu = self.profile_menu
+        menu.delete(0, "end")
+        menu.add_command(label="Rename %s..." % name, command=self.rename_profile)
+        menu.add_command(label="Import a save into %s..." % name, command=self.import_profile_save)
+        menu.add_command(label="Open %s's save folder" % name, command=self.open_profile_folder)
+        menu.add_separator()
+        if uid == profiles.DEFAULT:
+            menu.add_command(label="The default profile cannot be removed", state="disabled")
+        else:
+            menu.add_command(label="Remove %s..." % name, command=self.remove_profile)
+
+    def show_profiles(self, uid):
+        self.profile_list = profiles.load(self.user)
+        ids = [p[0] for p in self.profile_list]
+        self.profile_box.configure(values=[profiles.shown_name(uid, name) for uid, name in self.profile_list])
+        self.profile_box.current(ids.index(uid) if uid in ids else 0)
+        self.pick_profile()
+
+    def pick_profile(self):
+        self.cfg["profile"] = self.current_profile()[0]
+        save_config(self.cfg)
+        self.fill_profile_menu()
+
+    def current_profile(self):
+        index = self.profile_box.current()
+        return self.profile_list[index if 0 <= index < len(self.profile_list) else 0]
+
+    def profile_error(self, error):
+        messagebox.showerror("Hookshot", str(error), parent=self)
+
+    def new_profile(self):
+        from tkinter import simpledialog
+        name = simpledialog.askstring("New profile", "Name of the new profile:", parent=self)
+        if name is None:
+            return
+        try:
+            uid = profiles.add(self.user, name)
+        except (OSError, ValueError) as error:
+            return self.profile_error(error)
+        self.show_profiles(uid)
+        self.profile_note.set("%s has no saves yet: the game starts at an empty file select. Import save... brings one in."
+                              % profiles.clean_name(name))
+
+    def rename_profile(self):
+        from tkinter import simpledialog
+        uid, old = self.current_profile()
+        name = simpledialog.askstring("Rename profile", "New name for %s:" % old, initialvalue=old, parent=self)
+        if name is None:
+            return
+        try:
+            profiles.rename(self.user, uid, name)
+        except (OSError, ValueError) as error:
+            return self.profile_error(error)
+        self.show_profiles(uid)
+
+    def remove_profile(self):
+        uid, name = self.current_profile()
+        if uid == profiles.DEFAULT:
+            return self.profile_error("%s is the default profile and cannot be removed: the game plays it when it is started "
+                                      "without the launcher." % name)
+        if not messagebox.askyesno("Hookshot", "Remove the profile %s?\n\nIts saves are not deleted: they are moved to %s."
+                                   % (name, os.path.join(self.user, "save-backups")), parent=self):
+            return
+        try:
+            moved = profiles.remove(self.user, uid)
+        except (OSError, ValueError) as error:
+            return self.profile_error(error)
+        self.show_profiles(profiles.DEFAULT)
+        self.profile_note.set("Removed %s.%s" % (name, " Its saves are in %s" % moved if moved else ""))
+
+    def open_profile_folder(self):
+        path = profiles.folder_to_show(self.user, self.current_profile()[0])
+        if not path:
+            return self.profile_error("There are no saves yet: the game makes %s at its first start." % self.user)
+        subprocess.Popen(["xdg-open", path])
+
+    def import_profile_save(self):
+        chosen = filedialog.askdirectory(parent=self, initialdir=os.path.expanduser("~"),
+                                         title="The save to import: its folder, or an emulator's save folder")
+        if not chosen:
+            return
+        found = profiles.find_saves(chosen)
+        if not found:
+            return self.profile_error("No save of Ocarina of Time in %s.\n\nChoose the folder with account.sav, option.sav and "
+                                      "slot_00 to slot_05 in it, or an emulator's save folder." % chosen)
+        source = found[0] if len(found) == 1 else self.choose_save(found, chosen)
+        if not source:
+            return
+        uid, name = self.current_profile()
+        if not messagebox.askyesno("Hookshot", "Import this save into the profile %s?\n\n%s\n\nThe profile's saves now, if it "
+                                   "has any, are moved to %s first." % (name, profiles.describe(source, chosen),
+                                                                        os.path.join(self.user, "save-backups")), parent=self):
+            return
+        try:
+            moved = profiles.import_save(source, self.user, uid)
+        except (OSError, ValueError) as error:
+            return self.profile_error(error)
+        self.profile_note.set("Imported into %s.%s" % (name, " Its saves before are in %s" % moved if moved else ""))
+
+    def choose_save(self, found, chosen):
+        """the save to import when the folder has more than one (an emulator's, one for each of its users)"""
+        win = tk.Toplevel(self)
+        win.title("Choose a save")
+        win.transient(self)
+        ttk.Label(win, text="%s has %d saves of the game. Which one?" % (chosen, len(found)), wraplength=self.px(560)).pack(
+            anchor="w", **self.pad)
+        lines = tk.Listbox(win, height=min(len(found), 8), width=90, exportselection=False)
+        for path in found:
+            lines.insert("end", profiles.describe(path, chosen))
+        lines.selection_set(0)
+        lines.pack(fill="both", expand=True, **self.pad)
+        picked = []
+
+        def done(ok):
+            if ok and lines.curselection():
+                picked.append(found[lines.curselection()[0]])
+            win.destroy()
+        buttons = ttk.Frame(win)
+        buttons.pack(anchor="e", **self.pad)
+        ttk.Button(buttons, text="Import", command=lambda: done(True)).pack(side="right", padx=self.px(4))
+        ttk.Button(buttons, text="Cancel", command=lambda: done(False)).pack(side="right", padx=self.px(4))
+        lines.bind("<Double-Button-1>", lambda event: done(True))
+        win.grab_set()
+        self.wait_window(win)
+        return picked[0] if picked else None
+
     def begin_update(self, folder=None):
         if folder is not None:
             self.update_folder = folder
diff --git a/builder/linux/profiles.py b/builder/linux/profiles.py
new file mode 100644
index 000000000..039341bc9
--- /dev/null
+++ b/builder/linux/profiles.py
@@ -0,0 +1,223 @@
+"""The launcher's profiles: each one is a user of the game with saves of its own, save/<id> in the game's user folder.
+The Windows launcher keeps them the same way: builder/HookshotBuilder/Profiles.cs.
+
+The game plays the profile HOOKSHOT_PROFILE=<id> names (host/nn_applet.c); without it, the default profile, the one user
+every build had before profiles, so its saves stay where they were. The list is profiles.txt in the user folder, one
+"<id> <name>" a line. An id is 32 hex digits, the save folder's name (host/nn_fs.c).
+
+A save from a console or an emulator is imported into a profile: the folder of the game's save data (account.sav,
+option.sav, slot_00 ... slot_05) is copied over the profile's. The profile's saves before it are kept in
+save-backups/<id>-<time> in the user folder. Removing a profile moves its saves there too: nothing is deleted.
+"""
+import os
+import re
+import shutil
+import time
+
+DEFAULT = "5a3c9e1f0b7d24680000000000000001"   # (the uid host/nn_applet.c always had)
+PREFIX = DEFAULT[:16]
+TITLE = "0400486024dec000"   # (the game's program id: an emulator keeps its saves in a folder of that name)
+LIST = "profiles.txt"
+NAME_MAX = 32
+_ID = re.compile(r"[0-9a-f]{32}")
+_SLOT = re.compile(r"slot_\d\d", re.I)
+
+
+def user_dir(folder, environ=os.environ):
+    """The folder the game keeps saves in when the launcher starts it, as host/hos_main.c's saves_dir chooses it:
+    $XDG_DATA_HOME/hookshot or ~/.local/share/hookshot, unless a user folder the game could not move is still beside it."""
+    beside = os.path.join(folder, "user")
+    try:
+        if os.listdir(beside):
+            return beside
+    except OSError:
+        pass
+    xdg, home = environ.get("XDG_DATA_HOME", ""), environ.get("HOME", "")
+    if xdg.startswith("/"):
+        return os.path.join(xdg, "hookshot")
+    if home.startswith("/"):
+        return os.path.join(home, ".local", "share", "hookshot")
+    return beside
+
+
+def shown_name(uid, name):
+    """the name the profile list shows: the default profile says it is, whatever it is called, so that it is clear why it
+    cannot be removed"""
+    return "%s (default)" % name if uid == DEFAULT else name
+
+
+def clean_name(name):
+    return " ".join((name or "").split())[:NAME_MAX]
+
+
+def load(user):
+    """[(id, name)], the default profile first"""
+    profiles = []
+    try:
+        with open(os.path.join(user, LIST), encoding="utf-8") as f:
+            for line in f:
+                uid, _, name = line.strip().partition(" ")
+                uid = uid.lower()
+                if _ID.fullmatch(uid) and uid != "0" * 32 and all(uid != p[0] for p in profiles):
+                    profiles.append((uid, clean_name(name) or uid[-4:]))
+    except OSError:
+        pass
+    if all(uid != DEFAULT for uid, _ in profiles):
+        profiles.insert(0, (DEFAULT, "Player"))
+    else:
+        profiles.sort(key=lambda p: p[0] != DEFAULT)
+    return profiles
+
+
+def store(user, profiles):
+    os.makedirs(user, exist_ok=True)
+    path = os.path.join(user, LIST)
+    with open(path + ".tmp", "w", encoding="utf-8") as f:
+        f.write("# Hookshot's profiles: the save folder (save/<id>) and the name the launcher shows\n")
+        f.writelines("%s %s\n" % (uid, name) for uid, name in profiles)
+    os.replace(path + ".tmp", path)
+
+
+def add(user, name):
+    """a new profile, with no saves yet: the game starts it at an empty file select. Returns its id."""
+    name = clean_name(name)
+    if not name:
+        raise ValueError("Give the profile a name.")
+    profiles = load(user)
+    if any(n.casefold() == name.casefold() for _, n in profiles):
+        raise ValueError('There is a profile called "%s" already.' % name)
+    taken = set(p[0] for p in profiles)
+    try:
+        taken.update(n.lower() for n in os.listdir(os.path.join(user, "save")))   # (a removed profile's folder is not reused)
+    except OSError:
+        pass
+    n = 2
+    while "%s%016x" % (PREFIX, n) in taken:
+        n += 1
+    uid = "%s%016x" % (PREFIX, n)
+    store(user, profiles + [(uid, name)])
+    return uid
+
+
+def rename(user, uid, name):
+    name = clean_name(name)
+    if not name:
+        raise ValueError("Give the profile a name.")
+    profiles = load(user)
+    if any(n.casefold() == name.casefold() and u != uid for u, n in profiles):
+        raise ValueError('There is a profile called "%s" already.' % name)
+    store(user, [(u, name if u == uid else n) for u, n in profiles])
+
+
+def folder_to_show(user, uid):
+    """The folder "Open save folder" shows: the profile's saves, or the nearest folder above them that is there. None is
+    made: an empty save folder would read to the game as a save that exists."""
+    for path in (os.path.join(user, "save", uid), os.path.join(user, "save"), user):
+        if os.path.isdir(path):
+            return path
+    return None
+
+
+def _backup(user, uid):
+    """moves save/<id> to save-backups/<id>-<time>; returns where, or None when there were no saves"""
+    saves = os.path.join(user, "save", uid)
+    try:
+        if not os.listdir(saves):
+            os.rmdir(saves)
+            return None
+    except OSError:
+        return None
+    root = os.path.join(user, "save-backups")
+    os.makedirs(root, exist_ok=True)
+    stamp = time.strftime("%Y-%m-%d_%H-%M-%S")
+    dest = os.path.join(root, "%s-%s" % (uid, stamp))
+    k = 2
+    while os.path.exists(dest):
+        dest = os.path.join(root, "%s-%s-%d" % (uid, stamp, k))
+        k += 1
+    os.replace(saves, dest)
+    return dest
+
+
+def remove(user, uid):
+    """takes the profile off the list; its saves go to save-backups. Returns where they went, or None."""
+    if uid == DEFAULT:
+        raise ValueError("The default profile cannot be removed: the game plays it when it is started without the launcher.")
+    moved = _backup(user, uid)
+    store(user, [p for p in load(user) if p[0] != uid])
+    return moved
+
+
+def is_save(path):
+    """a folder of the game's save data: account.sav, option.sav or slot_NN in it"""
+    try:
+        names = os.listdir(path)
+    except OSError:
+        return False
+    return any(n.lower() in ("account.sav", "option.sav") or (_SLOT.fullmatch(n) and os.path.isdir(os.path.join(path, n)))
+               for n in names)
+
+
+def find_saves(path, depth=6):
+    """The game's save folders in what the player chose: the save folder itself, or an emulator's save folder
+    (save/0000000000000000/<user>/0400486024DEC000), one for each user it has. The newest first."""
+    if is_save(path):
+        return [path]
+    found = []
+    top = path.rstrip(os.sep).count(os.sep)
+    for here, dirs, _files in os.walk(path):
+        if here.count(os.sep) - top >= depth:
+            dirs[:] = []
+        dirs[:] = [d for d in dirs if not os.path.islink(os.path.join(here, d))]
+        for d in list(dirs):
+            if d.lower() == TITLE and is_save(os.path.join(here, d)):
+                found.append(os.path.join(here, d))
+                dirs.remove(d)
+    return sorted(found, key=lambda p: -last_saved(p))
+
+
+def last_saved(path):
+    newest = 0.0
+    for here, _dirs, files in os.walk(path):
+        for f in files:
+            try:
+                newest = max(newest, os.path.getmtime(os.path.join(here, f)))
+            except OSError:
+                pass
+    return newest
+
+
+def describe(path, chosen):
+    """one line for a save folder: where it is under the folder the player chose, how many files, when last saved"""
+    where = os.path.relpath(path, chosen)
+    if where == ".":
+        where = os.path.basename(path.rstrip(os.sep)) or path
+    try:
+        slots = sum(1 for n in os.listdir(path) if _SLOT.fullmatch(n) and os.listdir(os.path.join(path, n)))
+    except OSError:
+        slots = 0
+    saved = last_saved(path)
+    when = time.strftime("%Y-%m-%d %H:%M", time.localtime(saved)) if saved else "never"
+    return "%s  (%d save slot%s, last saved %s)" % (where, slots, "" if slots == 1 else "s", when)
+
+
+def import_save(src, user, uid):
+    """Copies the save folder src over the profile's saves. The profile's saves before it go to save-backups: returns
+    where, or None when it had none. A failed copy leaves the profile's saves as they were."""
+    if not is_save(src):
+        raise ValueError("%s has none of the game's save files (account.sav, option.sav, slot_00 ...)." % src)
+    saves = os.path.join(user, "save", uid)
+    real_src, real_saves = os.path.realpath(src), os.path.realpath(saves)
+    if real_src == real_saves or real_src.startswith(real_saves + os.sep) or real_saves.startswith(real_src + os.sep):
+        raise ValueError("These are the profile's own saves.")
+    os.makedirs(os.path.dirname(saves), exist_ok=True)
+    staging = saves + ".importing"
+    shutil.rmtree(staging, ignore_errors=True)
+    try:
+        shutil.copytree(src, staging)
+    except BaseException:
+        shutil.rmtree(staging, ignore_errors=True)
+        raise
+    moved = _backup(user, uid)
+    os.replace(staging, saves)
+    return moved
diff --git a/host/nn_applet.c b/host/nn_applet.c
index 894b54df8..1672428fa 100644
--- a/host/nn_applet.c
+++ b/host/nn_applet.c
@@ -1,6 +1,6 @@
 /* nn::oe (applet), nn::account, nn::time, nn::pl, nn::err: what a game asks the system about itself.
    The answers describe a docked console in English (HOS_LANGUAGE / language.txt: another language) with one user,
-   "Player". */
+   "Player": the launcher's profile (HOOKSHOT_PROFILE). */
 #include "hos.h"
 #include "hos_paths.h"
 #include <stdio.h>
@@ -151,10 +151,36 @@ HLE(_ZN2nn2oe25TryPopNotificationMessageEPj) { RET(0); }
 HLE(_ZN2nn2oe22PopNotificationMessageEv) { for (;;) hos_sleep_ns(1000000000LL); }
 
 /* ---- nn::account: one user ------------------------------------------------------------------------------------ */
-static const uint64_t user_uid[2] = {0x0000000000000001ULL, 0x5a3c9e1f0b7d2468ULL};
-HLE(_ZN2nn7account10InitializeEv) {}
+/* The user is the launcher's profile: HOOKSHOT_PROFILE=<32 hex digits> is its save folder's name, save/<those digits> in the
+   user folder (nn_fs.c names the folder by the uid's second word, then its first). Without it, or with anything else in it, the
+   user every build had before profiles: its saves stay where they were. The launchers keep the profile list:
+   builder/linux/profiles.py and builder/HookshotBuilder/Profiles.cs. */
+static uint64_t user_uid[2] = {0x0000000000000001ULL, 0x5a3c9e1f0b7d2468ULL};
+static void pick_user(void) {
+    static volatile LONG picked;
+    if (picked) return;
+    const char *hex = getenv("HOOKSHOT_PROFILE");
+    uint64_t w[2] = {0, 0};
+    int ok = hex && strlen(hex) == 32;
+    for (int i = 0; ok && i < 32; i++) {
+        const char ch = hex[i];
+        const int d = ch >= '0' && ch <= '9' ? ch - '0' : ch >= 'a' && ch <= 'f' ? ch - 'a' + 10 : ch >= 'A' && ch <= 'F' ? ch - 'A' + 10 : -1;
+        if (d < 0) ok = 0;
+        else w[i / 16] = w[i / 16] << 4 | (uint64_t)d;
+    }
+    if (ok && (w[0] | w[1])) {
+        user_uid[1] = w[0];
+        user_uid[0] = w[1];
+        hos_log("account: profile %016llx%016llx", (unsigned long long)user_uid[1], (unsigned long long)user_uid[0]);
+    } else if (hex && *hex) {
+        hos_log("account: HOOKSHOT_PROFILE=%s is not 32 hex digits: the default profile", hex);
+    }
+    InterlockedExchange(&picked, 1);
+}
+HLE(_ZN2nn7account10InitializeEv) { pick_user(); }
 /* TryOpenPreselectedUser(UserHandle*) -> bool. A handle is three words; ours carries the uid. */
 HLE(_ZN2nn7account22TryOpenPreselectedUserEPNS0_10UserHandleE) {
+    pick_user();
     G64(ARG(0)) = user_uid[0];
     G64(ARG(0) + 8) = user_uid[1];
     G64(ARG(0) + 16) = 1;
@@ -163,6 +189,7 @@ HLE(_ZN2nn7account22TryOpenPreselectedUserEPNS0_10UserHandleE) {
 HLE(_ZN2nn7account9CloseUserERKNS0_10UserHandleE) {}
 /* GetUserId(Uid*, UserHandle const&) -> Result */
 HLE(_ZN2nn7account9GetUserIdEPNS0_3UidERKNS0_10UserHandleE) {
+    pick_user();
     G64(ARG(0)) = user_uid[0];
     G64(ARG(0) + 8) = user_uid[1];
     RET(0);
@@ -174,6 +201,7 @@ HLE(_ZN2nn7account11GetNicknameEPNS0_8NicknameERKNS0_3UidE) {
     RET(0);
 }
 HLE(_ZN2nn7account16GetUserExistenceEPbRKNS0_3UidE) {
+    pick_user();
     *(uint8_t *)GP(ARG(0)) = G64(ARG(1)) == user_uid[0] && G64(ARG(1) + 8) == user_uid[1];
     RET(0);
 }
@@ -320,6 +348,7 @@ HLE(_ZN2nn5prepo12AsyncContextD1Ev) {}
 /* ---- (mkw-recomp) MKW's account and oe calls TOTK never made: the one user, offline ------------------------- */
 /* ListAllUsers(int* count, Uid* out, int max) -> Result */
 HLE(_ZN2nn7account12ListAllUsersEPiPNS0_3UidEi) {
+    pick_user();
     const int n = (int)ARG(2) > 0 ? 1 : 0;
     if (n && ARG(1)) {
         G64(ARG(1)) = user_uid[0];
diff --git a/readme.md b/readme.md
index 636384c2c..56f76f4da 100644
--- a/readme.md
+++ b/readme.md
@@ -148,6 +148,22 @@ with `--update <game folder>`.
 
 </details>
 
+### Profiles and imported saves
+
+The launcher (`hookshot.exe` on Windows, `hookshot` on Linux) has a **Profile** choice above **Play**. Each profile has
+saves of its own; **Play** starts the game with the one chosen. **New profile** makes one, which starts at an empty
+file select. **Manage** renames the chosen profile, imports a save into it, opens its save folder, or removes it.
+Removing a profile does not delete its saves: they are moved to `save-backups` in the saves folder.
+
+**Import a save** copies a save from a console or an emulator into the chosen profile. Choose the save's folder (the
+one with `account.sav`, `option.sav` and `slot_00` to `slot_05` in it) or an emulator's whole save folder; when it
+holds saves of several users, the launcher asks which one. The source is only read. The profile's saves before the
+import are moved to `save-backups` first.
+
+The default profile, first on the list and marked "(default)", has the saves from before profiles; it is called
+"Player" until you rename it. The game plays it when it is started without the launcher, so it cannot be removed. Profiles are kept in `profiles.txt` in the saves folder (the `user` folder in the game folder on Windows,
+`~/.local/share/hookshot` on Linux); a profile's saves are `save/<its id>`.
+
 ### Where the files go
 
 - The build reads your game and never changes it. It writes to the folder you choose and to the builder's own folder:
diff --git a/tests/launcher_profiles/LauncherProfilesTests.csproj b/tests/launcher_profiles/LauncherProfilesTests.csproj
new file mode 100644
index 000000000..b252754b3
--- /dev/null
+++ b/tests/launcher_profiles/LauncherProfilesTests.csproj
@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net8.0-windows</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="../../builder/HookshotBuilder/Profiles.cs" Link="Profiles.cs"/>
+  </ItemGroup>
+</Project>
diff --git a/tests/launcher_profiles/NuGet.Config b/tests/launcher_profiles/NuGet.Config
new file mode 100644
index 000000000..b1311ba1e
--- /dev/null
+++ b/tests/launcher_profiles/NuGet.Config
@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="utf-8"?>
+<configuration><packageSources><clear/></packageSources></configuration>
diff --git a/tests/launcher_profiles/Program.cs b/tests/launcher_profiles/Program.cs
new file mode 100644
index 000000000..95693651b
--- /dev/null
+++ b/tests/launcher_profiles/Program.cs
@@ -0,0 +1,140 @@
+// The Windows launcher's profiles (builder/HookshotBuilder/Profiles.cs): each one has saves of its own, a save from an
+// emulator is imported into one without losing the saves it had, and profiles.txt reads as the Linux launcher writes it
+// (builder/linux/profiles.py, tests/test_launcher_profiles.py).
+//
+//     dotnet run --project tests/launcher_profiles/LauncherProfilesTests.csproj
+using HookshotBuilder;
+
+static class Program
+{
+    static int checks;
+
+    static void Require(bool ok, string message)
+    {
+        if (!ok) throw new Exception(message);
+        checks++;
+    }
+
+    static void Throws<T>(Action action, string message) where T : Exception
+    {
+        try { action(); }
+        catch (T) { checks++; return; }
+        throw new Exception(message);
+    }
+
+    /// A save folder of the game as the console and emulators keep it
+    static string Save(string folder, int slots = 2, string marker = "a")
+    {
+        Directory.CreateDirectory(folder);
+        File.WriteAllText(Path.Combine(folder, "account.sav"), marker);
+        File.WriteAllText(Path.Combine(folder, "option.sav"), marker);
+        for (var n = 0; n < slots; n++)
+        {
+            var slot = Path.Combine(folder, $"slot_{n:00}");
+            Directory.CreateDirectory(slot);
+            File.WriteAllText(Path.Combine(slot, "progress.sav"), marker);
+            File.WriteAllText(Path.Combine(slot, "caption.sav"), marker);
+        }
+        return folder;
+    }
+
+    static int Main()
+    {
+        var root = Path.Combine(Path.GetTempPath(), "hookshot-profiles-" + Guid.NewGuid().ToString("N"));
+        try
+        {
+            Run(root);
+        }
+        catch (Exception x)
+        {
+            Console.Error.WriteLine("FAIL: " + x.Message);
+            return 1;
+        }
+        finally
+        {
+            try { Directory.Delete(root, recursive: true); } catch (Exception) { }
+        }
+        Console.WriteLine($"PASS: {checks} checks");
+        return 0;
+    }
+
+    static void Run(string root)
+    {
+        var game = Path.Combine(root, "game");
+        var user = Profiles.UserDir(game);
+        Require(user == Path.Combine(game, "user"), "The saves are not in the game folder's user folder.");
+
+        // the default profile is the user every build had (host/nn_applet.c)
+        var first = Profiles.Load(user);
+        Require(first.Count == 1 && first[0] == new Profiles.Profile(Profiles.Default, "Player"), "The default profile is not Player.");
+        Require(Profiles.Default == "5a3c9e1f0b7d24680000000000000001", "The default profile's id changed.");
+
+        // new profiles get save folders of their own
+        var a = Profiles.Add(user, "  Link  ");
+        var b = Profiles.Add(user, "Zelda");
+        var list = Profiles.Load(user);
+        Require(list.Select(p => p.Name).SequenceEqual(new[] { "Player", "Link", "Zelda" }), "The new profiles are not on the list.");
+        Require(new HashSet<string> { Profiles.Default, a, b }.Count == 3, "Two profiles share a save folder.");
+        Require(a == "5a3c9e1f0b7d24680000000000000002", "The second profile's id is not the one profiles.py makes.");
+        Throws<ArgumentException>(() => Profiles.Add(user, "link"), "A second profile called Link was made.");
+        Throws<ArgumentException>(() => Profiles.Add(user, "   "), "A profile with no name was made.");
+        Profiles.Rename(user, Profiles.Default, "Tim");
+        Require(Profiles.Load(user)[0].Name == "Tim", "The rename did not stick.");
+        Require(Profiles.ShownName(Profiles.Load(user)[0]) == "Tim (default)" && Profiles.ShownName(Profiles.Load(user)[1]) == "Link",
+                "The list does not say which profile is the default.");
+        Require(Profiles.Chosen(game, b) == b && Profiles.Chosen(game, "gone") == Profiles.Default && Profiles.Chosen(game, null) == Profiles.Default,
+                "Play does not start the chosen profile, or the default one when it is gone.");
+
+        // "Open save folder": the profile's saves, else the nearest folder above them; none is made
+        Require(Profiles.FolderToShow(user, b) == user && !Directory.Exists(Path.Combine(user, "save", b)), "Open save folder made a folder.");
+        Require(Profiles.FolderToShow(Path.Combine(root, "none"), b) == null, "Open save folder found a folder that is not there.");
+        Save(Path.Combine(user, "save", b));
+        Require(Profiles.FolderToShow(user, b) == Path.Combine(user, "save", b), "Open save folder does not show the profile's saves.");
+        Directory.Delete(Path.Combine(user, "save", b), recursive: true);
+
+        // profiles.txt as the Linux launcher writes it
+        var file = File.ReadAllLines(Path.Combine(user, "profiles.txt"));
+        Require(file.Length == 4 && file[0].StartsWith('#') && file[2] == a + " Link", "profiles.txt is not in profiles.py's form.");
+        File.WriteAllText(Path.Combine(user, "profiles.txt"),
+                          "# a comment\n5A3C9E1F0B7D24680000000000000005 Epona\nnot-an-id x\n5a3c9e1f0b7d24680000000000000001 Tim\n");
+        list = Profiles.Load(user);
+        Require(list.Count == 2 && list[0].Id == Profiles.Default && list[1] == new Profiles.Profile("5a3c9e1f0b7d24680000000000000005", "Epona"),
+                "A profiles.txt written by hand is not read as profiles.py reads it.");
+
+        // a removed profile keeps its saves, and its folder is not reused
+        var epona = list[1].Id;
+        Save(Path.Combine(user, "save", epona));
+        var moved = Profiles.Remove(user, epona);
+        Require(moved != null && File.Exists(Path.Combine(moved, "slot_00", "progress.sav")), "The removed profile's saves were not kept.");
+        Require(!Directory.Exists(Path.Combine(user, "save", epona)), "The removed profile's save folder is still there.");
+        Throws<ArgumentException>(() => Profiles.Remove(user, Profiles.Default), "The default profile was removed.");
+        Save(Path.Combine(user, "save", "5a3c9e1f0b7d24680000000000000002"));
+        Require(Profiles.Add(user, "Again") == "5a3c9e1f0b7d24680000000000000003", "A new profile took a folder that has saves.");
+
+        // an emulator's save folder lists one save for each of its users, the newest first
+        var emu = Path.Combine(root, "2026-11-09 save");
+        var users = Path.Combine(emu, "0000000000000000");
+        var older = Save(Path.Combine(users, "45EB517681BCEAF4B834E0FA511E3212", "0400486024DEC000"), slots: 6);
+        var newer = Save(Path.Combine(users, "533C42419DD767B01211726DADA4670A", "0400486024DEC000"), slots: 6, marker: "new");
+        Save(Path.Combine(users, "45EB517681BCEAF4B834E0FA511E3212", "0400C3F00006E000", "Play"));   // (another game's)
+        foreach (var f in Directory.EnumerateFiles(older, "*", SearchOption.AllDirectories)) File.SetLastWriteTime(f, new DateTime(2026, 11, 8, 22, 25, 0));
+        var found = Profiles.FindSaves(emu);
+        Require(found.SequenceEqual(new[] { newer, older }), "The emulator's two saves were not found, newest first.");
+        Require(Profiles.FindSaves(newer).SequenceEqual(new[] { newer }), "A save folder chosen itself was not found.");
+        Require(Profiles.FindSaves(Path.Combine(root, "nothing")).Count == 0, "A save was found where there is none.");
+        var line = Profiles.Describe(older, emu);
+        Require(line == Path.Combine("0000000000000000", "45EB517681BCEAF4B834E0FA511E3212", "0400486024DEC000") +
+                        "  (6 save slots, last saved 2026-11-08 22:25)", "The save's line reads: " + line);
+
+        // an import replaces the profile's saves and keeps the old ones; the source is only read
+        var own = Save(Path.Combine(user, "save", a), slots: 1, marker: "old");
+        moved = Profiles.Import(newer, user, a);
+        Require(File.ReadAllText(Path.Combine(own, "slot_05", "progress.sav")) == "new", "The import did not bring the save in.");
+        Require(moved != null && File.ReadAllText(Path.Combine(moved, "slot_00", "progress.sav")) == "old", "The profile's saves before were not kept.");
+        Require(File.Exists(Path.Combine(newer, "account.sav")), "The import moved the source.");
+        Require(!Directory.Exists(own + ".importing"), "The import left its staging folder.");
+        Require(Profiles.Import(newer, user, b) == null, "A profile with no saves kept a backup.");
+        Throws<ArgumentException>(() => Profiles.Import(own, user, a), "A profile's own saves were imported into it.");
+        Throws<ArgumentException>(() => Profiles.Import(root, user, a), "A folder with no save was imported.");
+    }
+}
diff --git a/tests/run_all.py b/tests/run_all.py
index 431618edd..ccf092d7b 100644
--- a/tests/run_all.py
+++ b/tests/run_all.py
@@ -35,6 +35,7 @@
     "tests/test_lower_depbar.py": ["--cxx", "clang++"],
     "tests/test_lower_register_markers.py": ["--cxx", "clang++"],
     "tests/test_text_speed.py": ["--cc", "gcc"],
+    "tests/test_account_profile.py": ["--cc", "gcc"],
     "tests/test_upscale_fallback.py": ["--cxx", "g++"],
     "tests/test_taau_env_lookup.py": ["--cxx", "g++"],
     "tests/test_target_overlap.py": ["--cxx", "g++"],
@@ -82,6 +83,7 @@
     # (Linux only)
     "tests/test_hookshot_launch.py": ({"windows"}, "the Linux launcher, a POSIX shell script"),
     "tests/test_linux_update.py": ({"windows"}, "the Linux builder's update and folder launcher, POSIX files and shell scripts"),
+    "tests/test_launcher_profiles.py": ({"windows"}, "the Linux launcher's profiles, POSIX paths (Windows: tests/launcher_profiles)"),
     "tests/test_linux_driver_fault_guard.py": ({"windows"}, "POSIX signals: the Linux guard"),
 }
 # (spirv-val: SPIRV-Tools comes with the Linux runner's packages, not on Windows)
diff --git a/tests/test_account_profile.py b/tests/test_account_profile.py
new file mode 100644
index 000000000..8717cc24e
--- /dev/null
+++ b/tests/test_account_profile.py
@@ -0,0 +1,75 @@
+"""The game's user is the launcher's profile: HOOKSHOT_PROFILE=<32 hex digits> is the save folder's name (save/<digits>),
+and anything else plays the default profile, the user every build had before profiles.
+
+This builds host/nn_applet.c's user_uid and pick_user as they are in the source, with nn_fs.c's folder naming, and checks
+which save folder each value leads to.
+
+python -I -B tests/test_account_profile.py [--cc gcc]
+"""
+import argparse
+import os
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+DEFAULT = "5a3c9e1f0b7d24680000000000000001"   # (builder/linux/profiles.py's DEFAULT)
+
+HARNESS = r'''
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+typedef long LONG;
+static LONG InterlockedExchange(volatile LONG *p, LONG v) { LONG o = *p; *p = v; return o; }
+static void hos_log(const char *f, ...) { (void)f; }
+%s
+int main(void) {
+    pick_user();
+    /* (host/nn_fs.c's MountSaveData: the uid's second word, then its first) */
+    printf("%%016llx%%016llx\n", (unsigned long long)user_uid[1], (unsigned long long)user_uid[0]);
+    return 0;
+}
+'''
+
+
+def source():
+    text = (ROOT / "host" / "nn_applet.c").read_text(encoding="utf-8")
+    start = text.index("static uint64_t user_uid[2]")
+    end = text.index("HLE(_ZN2nn7account10InitializeEv)", start)
+    return text[start:end]
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--cc", default="cc")
+    args = ap.parse_args()
+    failures = 0
+    with tempfile.TemporaryDirectory(prefix="hookshot-account-") as tmp:
+        c, exe = Path(tmp) / "t.c", Path(tmp) / "t"
+        c.write_text(HARNESS % source(), encoding="utf-8")
+        subprocess.run([args.cc, "-std=c11", "-Wall", "-Wextra", "-Werror", "-o", str(exe), str(c)], check=True)
+        cases = {
+            None: DEFAULT,
+            "": DEFAULT,
+            "5a3c9e1f0b7d24680000000000000002": "5a3c9e1f0b7d24680000000000000002",
+            "45EB517681BCEAF4B834E0FA511E3212": "45eb517681bceaf4b834e0fa511e3212",
+            "0" * 32: DEFAULT,
+            "5a3c9e1f0b7d2468000000000000002": DEFAULT,   # (31 digits)
+            "5a3c9e1f0b7d24680000000000000002x": DEFAULT,
+            "../../../../../../etc/passwd/xx": DEFAULT,
+        }
+        for value, want in cases.items():
+            env = {k: v for k, v in os.environ.items() if k != "HOOKSHOT_PROFILE"}
+            if value is not None:
+                env["HOOKSHOT_PROFILE"] = value
+            got = subprocess.run([str(exe)], env=env, capture_output=True, text=True, check=True).stdout.strip()
+            ok = got == want
+            failures += not ok
+            print("%s HOOKSHOT_PROFILE=%r: save/%s%s" % ("PASS" if ok else "FAIL", value, got, "" if ok else " (want %s)" % want))
+    return 1 if failures else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/tests/test_hookshot_launch.py b/tests/test_hookshot_launch.py
index 2e528ef0a..0ec2c5499 100644
--- a/tests/test_hookshot_launch.py
+++ b/tests/test_hookshot_launch.py
@@ -24,7 +24,8 @@ def game(folder):
         "printf 'LD_LIBRARY_PATH=%s\\n' \"${LD_LIBRARY_PATH-UNSET}\"\n"
         "printf 'HOOKSHOT_TOOLS=%s\\n' \"${HOOKSHOT_TOOLS-UNSET}\"\n"
         "printf 'PYTHONPATH=%s\\n' \"${PYTHONPATH-UNSET}\"\n"
-        "printf 'HOME=%s\\n' \"$HOME\"\n",
+        "printf 'HOME=%s\\n' \"$HOME\"\n"
+        "printf 'HOOKSHOT_PROFILE=%s\\n' \"${HOOKSHOT_PROFILE-UNSET}\"\n",
         encoding="utf-8",
     )
     exe.chmod(exe.stat().st_mode | stat.S_IEXEC)
@@ -70,6 +71,23 @@ def test_the_saved_folder_starts_without_the_builders_libraries(self):
         self.assertIn("PYTHONPATH=UNSET", lines)
         self.assertIn("HOME=%s" % os.environ["HOME"], lines)
 
+    def test_the_profile_the_launcher_chose_last_is_played(self):
+        with tempfile.TemporaryDirectory(prefix="hookshot-launch-") as tmp:
+            root = Path(tmp)
+            folder = root / "game"
+            game(folder)
+            ini = root / "builder.ini"
+            profile = "5a3c9e1f0b7d24680000000000000002"
+            ini.write_text("out=%s\nprofile=%s\n" % (folder, profile), encoding="utf-8")
+            ran = subprocess.run([str(LAUNCH)], env=self.env(HOOKSHOT_LAUNCH_CONFIG=str(ini), HOOKSHOT_PROFILE="stale"),
+                                 text=True, capture_output=True, check=False)
+            self.assertEqual(ran.returncode, 0, ran.stderr)
+            self.assertIn("HOOKSHOT_PROFILE=%s" % profile, ran.stdout.splitlines())
+            ini.write_text("out=%s\n" % folder, encoding="utf-8")
+            ran = subprocess.run([str(LAUNCH)], env=self.env(HOOKSHOT_LAUNCH_CONFIG=str(ini), HOOKSHOT_PROFILE="stale"),
+                                 text=True, capture_output=True, check=False)
+            self.assertIn("HOOKSHOT_PROFILE=UNSET", ran.stdout.splitlines())
+
     def test_play_starts_the_game_in_bin_not_the_launcher(self):
         with tempfile.TemporaryDirectory(prefix="hookshot-launch-") as tmp:
             root = Path(tmp)
diff --git a/tests/test_launcher_profiles.py b/tests/test_launcher_profiles.py
new file mode 100644
index 000000000..b8342843a
--- /dev/null
+++ b/tests/test_launcher_profiles.py
@@ -0,0 +1,122 @@
+"""The Linux launcher's profiles (builder/linux/profiles.py): each one has saves of its own, and a save from an emulator is
+imported into one without losing the saves it had.
+
+python -I -B tests/test_launcher_profiles.py
+"""
+import importlib.util
+import os
+from pathlib import Path
+import tempfile
+import unittest
+
+ROOT = Path(__file__).resolve().parents[1]
+spec = importlib.util.spec_from_file_location("launcher_profiles", ROOT / "builder" / "linux" / "profiles.py")
+profiles = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(profiles)
+
+
+def save(folder, slots=2, marker="a"):
+    """a save folder of the game as the console and emulators keep it"""
+    folder.mkdir(parents=True)
+    (folder / "account.sav").write_text(marker)
+    (folder / "option.sav").write_text(marker)
+    for n in range(slots):
+        slot = folder / ("slot_%02d" % n)
+        slot.mkdir()
+        (slot / "progress.sav").write_text(marker)
+        (slot / "caption.sav").write_text(marker)
+    return folder
+
+
+class ProfileTests(unittest.TestCase):
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory(prefix="hookshot-profiles-")
+        self.root = Path(self.tmp.name)
+        self.user = str(self.root / "user")
+
+    def tearDown(self):
+        self.tmp.cleanup()
+
+    def test_the_default_profile_is_the_user_every_build_had(self):
+        self.assertEqual(profiles.load(self.user), [(profiles.DEFAULT, "Player")])
+        self.assertEqual(profiles.DEFAULT, "5a3c9e1f0b7d24680000000000000001")   # (host/nn_applet.c's user_uid)
+
+    def test_new_profiles_get_save_folders_of_their_own(self):
+        a = profiles.add(self.user, "  Link  ")
+        b = profiles.add(self.user, "Zelda")
+        self.assertEqual(profiles.load(self.user), [(profiles.DEFAULT, "Player"), (a, "Link"), (b, "Zelda")])
+        self.assertEqual(len({profiles.DEFAULT, a, b}), 3)
+        for uid in (a, b):
+            self.assertRegex(uid, r"^[0-9a-f]{32}$")
+        with self.assertRaises(ValueError):
+            profiles.add(self.user, "link")
+        with self.assertRaises(ValueError):
+            profiles.add(self.user, "   ")
+        profiles.rename(self.user, profiles.DEFAULT, "Tim")
+        self.assertEqual(profiles.load(self.user)[0], (profiles.DEFAULT, "Tim"))
+        self.assertEqual(profiles.shown_name(profiles.DEFAULT, "Tim"), "Tim (default)")   # (why it cannot be removed)
+        self.assertEqual(profiles.shown_name(a, "Link"), "Link")
+
+    def test_a_removed_profile_keeps_its_saves_and_its_folder_is_not_reused(self):
+        uid = profiles.add(self.user, "Link")
+        save(Path(self.user) / "save" / uid)
+        moved = profiles.remove(self.user, uid)
+        self.assertTrue(os.path.isfile(os.path.join(moved, "slot_00", "progress.sav")))
+        self.assertFalse(os.path.exists(os.path.join(self.user, "save", uid)))
+        self.assertEqual(profiles.load(self.user), [(profiles.DEFAULT, "Player")])
+        with self.assertRaises(ValueError):
+            profiles.remove(self.user, profiles.DEFAULT)
+        save(Path(self.user) / "save" / uid)   # (a folder left over: a new profile does not take it)
+        self.assertNotEqual(profiles.add(self.user, "Again"), uid)
+
+    def test_an_emulators_save_folder_lists_one_save_for_each_of_its_users(self):
+        emu = self.root / "2026-11-09 save"
+        users = emu / "0000000000000000"
+        first = save(users / "45EB517681BCEAF4B834E0FA511E3212" / "0400486024DEC000", slots=6)
+        second = save(users / "533C42419DD767B01211726DADA4670A" / "0400486024DEC000", slots=6)
+        save(users / "45EB517681BCEAF4B834E0FA511E3212" / "0400C3F00006E000" / "Play")   # (another game's)
+        os.utime(first / "slot_00" / "progress.sav", (2e9, 2e9))
+        self.assertEqual(profiles.find_saves(str(emu)), [str(first), str(second)])
+        self.assertEqual(profiles.find_saves(str(second)), [str(second)])
+        self.assertEqual(profiles.find_saves(str(self.root / "nothing")), [])
+        self.assertTrue(profiles.describe(str(first), str(emu)).startswith(
+            "0000000000000000/45EB517681BCEAF4B834E0FA511E3212/0400486024DEC000  (6 save slots, last saved "))
+
+    def test_an_import_replaces_the_profiles_saves_and_keeps_the_old_ones(self):
+        uid = profiles.add(self.user, "Link")
+        own = save(Path(self.user) / "save" / uid, slots=1, marker="old")
+        source = save(self.root / "emu" / "0400486024DEC000", slots=3, marker="new")
+        moved = profiles.import_save(str(source), self.user, uid)
+        self.assertEqual((own / "slot_02" / "progress.sav").read_text(), "new")
+        self.assertEqual((Path(moved) / "slot_00" / "progress.sav").read_text(), "old")
+        self.assertTrue((source / "account.sav").exists())   # (the source is copied, not moved)
+        self.assertFalse(os.path.exists(str(own) + ".importing"))
+        other = profiles.add(self.user, "Zelda")
+        self.assertIsNone(profiles.import_save(str(source), self.user, other))   # (no saves before: nothing to keep)
+        with self.assertRaises(ValueError):
+            profiles.import_save(str(own), self.user, uid)
+        with self.assertRaises(ValueError):
+            profiles.import_save(str(self.root), self.user, uid)
+
+    def test_open_save_folder_shows_the_profiles_saves_and_makes_no_folder(self):
+        uid = profiles.add(self.user, "Link")
+        self.assertEqual(profiles.folder_to_show(self.user, uid), self.user)   # (no save folder yet: none is made)
+        self.assertFalse(os.path.exists(os.path.join(self.user, "save", uid)))
+        save(Path(self.user) / "save" / profiles.DEFAULT)
+        self.assertEqual(profiles.folder_to_show(self.user, uid), os.path.join(self.user, "save"))
+        save(Path(self.user) / "save" / uid)
+        self.assertEqual(profiles.folder_to_show(self.user, uid), os.path.join(self.user, "save", uid))
+        self.assertIsNone(profiles.folder_to_show(str(self.root / "none"), uid))
+
+    def test_the_user_folder_is_the_one_the_game_uses(self):
+        game = self.root / "game"
+        game.mkdir()
+        self.assertEqual(profiles.user_dir(str(game), {"XDG_DATA_HOME": "/data", "HOME": "/home/p"}), "/data/hookshot")
+        self.assertEqual(profiles.user_dir(str(game), {"XDG_DATA_HOME": "rel", "HOME": "/home/p"}),
+                         "/home/p/.local/share/hookshot")
+        (game / "user" / "save").mkdir(parents=True)   # (saves the game could not move: hos_main.c keeps using them)
+        self.assertEqual(profiles.user_dir(str(game), {"HOME": "/home/p"}), str(game / "user"))
+
+
+if __name__ == "__main__":
+    unittest.main()

From 30ee0b3dedacafff96e55339978288147f6da44b Mon Sep 17 00:00:00 2001
From: Tim Strulik <timstrulik@gmail.com>
Date: Mon, 9 Nov 2026 17:25:30 +0100
Subject: [PATCH 2/2] feat: the builder's Play shows the launcher when there
 are several profiles

Play on the builder's pages (the game already built, and after a build)
started the game with the profile chosen last, without showing it. With
one profile it still plays at once; with more, it opens the launcher's
page, where the profile is shown and can be changed before Play.

Assisted-by: Claude Code
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 builder/HookshotBuilder/MainWindow.xaml.cs |  7 +++++++
 builder/linux/hookshot_builder.py          | 15 ++++++++++++---
 2 files changed, 19 insertions(+), 3 deletions(-)

diff --git a/builder/HookshotBuilder/MainWindow.xaml.cs b/builder/HookshotBuilder/MainWindow.xaml.cs
index 61261d233..67bc49624 100644
--- a/builder/HookshotBuilder/MainWindow.xaml.cs
+++ b/builder/HookshotBuilder/MainWindow.xaml.cs
@@ -1207,8 +1207,15 @@ string Against(TimeSpan now)
     void OpenFolder(object sender, RoutedEventArgs e) =>
         Process.Start(new ProcessStartInfo("explorer.exe", $"\"{finished}\"") { UseShellExecute = true });
 
+    /// Play from the builder's pages: at once with one profile; with more, the launcher's page first, where the profile Play
+    /// starts is shown and can be changed (Profiles.cs)
     void Play(object sender, RoutedEventArgs e)
     {
+        if (Profiles.Load(Profiles.UserDir(finished)).Count > 1)
+        {
+            ShowLauncher(finished);
+            return;
+        }
         StartGame(finished);
         WindowState = WindowState.Minimized;
     }
diff --git a/builder/linux/hookshot_builder.py b/builder/linux/hookshot_builder.py
index 2a5759d8e..e175ca14b 100644
--- a/builder/linux/hookshot_builder.py
+++ b/builder/linux/hookshot_builder.py
@@ -231,7 +231,7 @@ def show_form(self):
         ttk.Label(f, text="Turns your own copy of Ocarina of Time into a game folder you can start on PC.").grid(
             row=1, column=0, columnspan=3, sticky="w", **self.pad)
         if game_ready(self.cfg.get("out")):
-            ttk.Button(f, text="Play the game built in %s" % self.cfg["out"], command=lambda: self.play_and_close(self.cfg["out"])).grid(
+            ttk.Button(f, text="Play the game built in %s" % self.cfg["out"], command=lambda: self.play_or_choose(self.cfg["out"])).grid(
                 row=2, column=0, columnspan=3, sticky="we", **self.pad)
         ttk.Label(f, text="Game files", font=("TkDefaultFont", 10, "bold")).grid(row=3, column=0, sticky="w", **self.pad)
         kinds = ttk.Frame(f)
@@ -589,7 +589,7 @@ def build(self):
         if mode == "up-to-date":
             folder = os.path.expanduser(self.out.get().strip())
             if game_ready(folder):
-                self.play_and_close(folder)
+                self.play_or_choose(folder)
             return
         if mode == "update-game":
             self.fetched = False
@@ -774,7 +774,7 @@ def on_exit(self, code):
                 add_to_menu(folder)
             except OSError:
                 pass
-            ttk.Button(self.buttons, text="Play", command=lambda: self.play_and_close(folder)).pack(side="right", padx=self.px(4))
+            ttk.Button(self.buttons, text="Play", command=lambda: self.play_or_choose(folder)).pack(side="right", padx=self.px(4))
             ttk.Button(self.buttons, text="Open folder", command=lambda: subprocess.Popen(["xdg-open", folder])).pack(side="right", padx=self.px(4))
         else:
             self.stage_text.set("The build stopped: %s" % getattr(self, "error", "see the lines above"))
@@ -785,6 +785,15 @@ def cancel(self):
             os.killpg(self.proc.pid, signal.SIGTERM)
             self.error = "Build cancelled. You can start again from the same folder."
 
+    def play_or_choose(self, folder):
+        """Play from the builder's pages: at once with one profile; with more, the launcher's page first, where the profile
+        Play starts is shown and can be changed"""
+        if len(profiles.load(profiles.user_dir(folder))) > 1:
+            self.launch_folder, self.build_button = folder, None
+            self.show_launch(folder)
+        else:
+            self.play_and_close(folder)
+
     def play_and_close(self, folder):
         play(folder)
         self.destroy()