diff --git a/.github/workflows/source-regressions.yml b/.github/workflows/source-regressions.yml
index 2c7c0f566..c0bd85a0c 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 3d281e968..a433df10d 100644
--- a/builder/HookshotBuilder/MainWindow.xaml
+++ b/builder/HookshotBuilder/MainWindow.xaml
@@ -276,7 +276,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 5dfc532d0..1c29b1326 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,6 +432,7 @@ 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)
         public bool Dlss { get; set; }   // (NVIDIA DLSS ticked: NVIDIA's license was accepted)
     }
     static string SettingsPath => System.IO.Path.Combine(
@@ -266,9 +440,7 @@ sealed class BuilderSettings
 
     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;
         DlssTick.IsChecked = s.Dlss;
         if (s.Romfs != null && s.Exefs != null && Directory.Exists(s.Romfs) && File.Exists(System.IO.Path.Combine(s.Exefs, "main")))
@@ -288,12 +460,34 @@ 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,
-                                          Dlss = DlssTick.IsChecked == true };
+                                          Profile = SavedProfile(), Dlss = DlssTick.IsChecked == true };
             Directory.CreateDirectory(System.IO.Path.GetDirectoryName(SettingsPath)!);
             File.WriteAllText(SettingsPath, System.Text.Json.JsonSerializer.Serialize(s));
         }
@@ -1037,8 +1231,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/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 a4d235a7b..e175ca14b 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)
 
@@ -222,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)
@@ -369,13 +378,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
@@ -429,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
@@ -614,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"))
@@ -625,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()
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 c397da347..ef1dc86bf 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>
@@ -167,10 +167,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;
@@ -179,6 +205,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);
@@ -190,6 +217,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);
 }
@@ -336,6 +364,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 896d57c91..b2ba4b861 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 8d5d3bc16..0dd98d585 100644
--- a/tests/run_all.py
+++ b/tests/run_all.py
@@ -40,6 +40,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_audio_in.py": ["--cc", "gcc", "--cxx", "g++"],
     "tests/test_upscale_fallback.py": ["--cxx", "g++"],
     "tests/test_taau_env_lookup.py": ["--cxx", "g++"],
@@ -99,6 +100,7 @@
     "tests/test_appimage_source_headers.py": ({"windows"}, "the AppImage source-copy block uses POSIX Bash and cp"),
     "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_oot_saves.py": ({"windows"}, "the save script's folder discovery is the Linux one (on Windows Hookshot's saves are in the game folder: --hookshot)"),
     "tests/test_linux_driver_fault_guard.py": ({"windows"}, "POSIX signals: the Linux guard"),
 }
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()