diff --git a/Quantum.Editor.Avalonia/App.axaml.cs b/Quantum.Editor.Avalonia/App.axaml.cs
index eb0838b..2d7501e 100644
--- a/Quantum.Editor.Avalonia/App.axaml.cs
+++ b/Quantum.Editor.Avalonia/App.axaml.cs
@@ -1,6 +1,7 @@
 using global::Avalonia.Controls.ApplicationLifetimes;
 using global::Avalonia.Markup.Xaml;
 using Quantum.Editor.Avalonia.Services;
+using Quantum.Editor.Avalonia.Services.Workspaces;
 
 namespace Quantum.Editor.Avalonia;
 
@@ -8,6 +9,8 @@ public partial class App : global::Avalonia.Application
 {
     public EditorWorkspace? Workspace { get; private set; }
 
+    public WorkspaceProfileManager? WorkspaceProfiles { get; private set; }
+
     public override void Initialize()
     {
         AvaloniaXamlLoader.Load(this);
@@ -19,7 +22,8 @@ public override void OnFrameworkInitializationCompleted()
         {
             Workspace = new EditorWorkspace();
             Workspace.NewDocument();
-            desktop.MainWindow = new MainWindow(Workspace);
+            WorkspaceProfiles = new WorkspaceProfileManager();
+            desktop.MainWindow = new MainWindow(Workspace, WorkspaceProfiles);
         }
 
         base.OnFrameworkInitializationCompleted();
diff --git a/Quantum.Editor.Avalonia/MainWindow.axaml b/Quantum.Editor.Avalonia/MainWindow.axaml
index 59638c2..45377e7 100644
--- a/Quantum.Editor.Avalonia/MainWindow.axaml
+++ b/Quantum.Editor.Avalonia/MainWindow.axaml
@@ -42,7 +42,7 @@
         </Style>
     </Window.Styles>
 
-    <Grid RowDefinitions="Auto,48,*,5,300,28">
+    <Grid x:Name="WorkbenchGrid" RowDefinitions="Auto,48,*,5,300,28">
         <Border
             x:Name="MenuBarRegion"
             Grid.Row="0"
@@ -50,7 +50,7 @@
             BorderBrush="#2B3948"
             BorderThickness="0,0,0,1">
             <Menu>
-                <MenuItem Header="_File">
+                <MenuItem x:Name="FileMenu" Header="_File">
                     <MenuItem Header="_New Track    Ctrl+N" Click="OnNewDocumentClick" />
                     <MenuItem Header="_Open…    Ctrl+O" Click="OnOpenDocumentClick" />
                     <Separator />
@@ -59,11 +59,11 @@
                     <Separator />
                     <MenuItem Header="E_xit" Click="OnExitClick" />
                 </MenuItem>
-                <MenuItem Header="_Edit">
+                <MenuItem x:Name="EditMenu" Header="_Edit">
                     <MenuItem x:Name="UndoMenuItem" Header="_Undo    Ctrl+Z" Click="OnUndoClick" />
                     <MenuItem x:Name="RedoMenuItem" Header="_Redo    Ctrl+Y" Click="OnRedoClick" />
                 </MenuItem>
-                <MenuItem Header="_View">
+                <MenuItem x:Name="ViewMenu" Header="_View">
                     <MenuItem Header="_Fit Track    F" Click="OnFitViewportClick" />
                     <MenuItem Header="Toggle Transported _Frames" Click="OnMenuShowFramesClick" />
                     <MenuItem Header="Math _Plots" Click="OnShowEngineeringPlotsClick" />
@@ -79,12 +79,12 @@
             BorderThickness="0,0,0,1"
             Padding="10,7">
             <Grid ColumnDefinitions="Auto,Auto,Auto,16,Auto,Auto,16,Auto,Auto,*,Auto">
-                <Button Classes="toolbar" Content="New" Click="OnNewDocumentClick" />
-                <Button Grid.Column="1" Classes="toolbar" Content="Open" Click="OnOpenDocumentClick" />
-                <Button Grid.Column="2" Classes="toolbar" Content="Save" Click="OnSaveDocumentClick" />
+                <Button x:Name="NewButton" Classes="toolbar" Content="New" Click="OnNewDocumentClick" />
+                <Button x:Name="OpenButton" Grid.Column="1" Classes="toolbar" Content="Open" Click="OnOpenDocumentClick" />
+                <Button x:Name="SaveButton" Grid.Column="2" Classes="toolbar" Content="Save" Click="OnSaveDocumentClick" />
                 <Button x:Name="UndoButton" Grid.Column="4" Classes="toolbar" Content="Undo" Click="OnUndoClick" />
                 <Button x:Name="RedoButton" Grid.Column="5" Classes="toolbar" Content="Redo" Click="OnRedoClick" />
-                <Button Grid.Column="7" Classes="toolbar" Content="Fit" Click="OnFitViewportClick" />
+                <Button x:Name="FitButton" Grid.Column="7" Classes="toolbar" Content="Fit" Click="OnFitViewportClick" />
                 <CheckBox
                     x:Name="ShowFramesCheckBox"
                     Grid.Column="8"
@@ -106,14 +106,14 @@
             </Grid>
         </Border>
 
-        <Grid Grid.Row="2" ColumnDefinitions="320,5,*,5,340">
+        <Grid x:Name="ContentPaneGrid" Grid.Row="2" ColumnDefinitions="320,5,*,5,340">
             <controls:RoutePaneControl
                 x:Name="RoutePane"
                 Grid.Column="0"
                 NodeSelected="OnGraphNodeSelected"
                 SectionPointerChanged="OnSectionPointerChanged" />
 
-            <GridSplitter Grid.Column="1" ResizeDirection="Columns" Background="#2B3948" />
+            <GridSplitter x:Name="RouteSplitter" Grid.Column="1" ResizeDirection="Columns" Background="#2B3948" />
 
             <controls:ViewportPaneControl
                 x:Name="ViewportPane"
@@ -121,12 +121,12 @@
                 SectionPointerChanged="OnSectionPointerChanged"
                 SampleSelected="OnViewportSampleSelected" />
 
-            <GridSplitter Grid.Column="3" ResizeDirection="Columns" Background="#2B3948" />
+            <GridSplitter x:Name="InspectorSplitter" Grid.Column="3" ResizeDirection="Columns" Background="#2B3948" />
 
             <controls:InspectorPaneControl x:Name="InspectorPane" Grid.Column="4" />
         </Grid>
 
-        <GridSplitter Grid.Row="3" ResizeDirection="Rows" Background="#2B3948" />
+        <GridSplitter x:Name="BottomPanelSplitter" Grid.Row="3" ResizeDirection="Rows" Background="#2B3948" />
 
         <Border
             x:Name="BottomPanelRegion"
@@ -134,14 +134,14 @@
             Classes="panel"
             BorderThickness="0,1,0,0">
             <TabControl x:Name="BottomWorkspaceTabs" SelectedIndex="0">
-                <TabItem Header="MATH PLOTS">
+                <TabItem x:Name="MathPlotsTab" Header="MATH PLOTS">
                     <controls:MathPlotsPaneControl
                         x:Name="MathPlotsPane"
                         SectionPointerChanged="OnSectionPointerChanged"
                         StationChanged="OnEngineeringPlotStationChanged"
                         StationSelected="OnEngineeringPlotStationSelected" />
                 </TabItem>
-                <TabItem Header="DIAGNOSTICS">
+                <TabItem x:Name="DiagnosticsTab" Header="DIAGNOSTICS">
                     <controls:DiagnosticsPaneControl x:Name="DiagnosticsPane" />
                 </TabItem>
             </TabControl>
diff --git a/Quantum.Editor.Avalonia/MainWindow.axaml.cs b/Quantum.Editor.Avalonia/MainWindow.axaml.cs
index 6ab6e11..1a7d5e0 100644
--- a/Quantum.Editor.Avalonia/MainWindow.axaml.cs
+++ b/Quantum.Editor.Avalonia/MainWindow.axaml.cs
@@ -9,6 +9,7 @@
 using Quantum.Editor.Avalonia.Services;
 using Quantum.Editor.Avalonia.Services.Commands;
 using Quantum.Editor.Avalonia.Services.Documents;
+using Quantum.Editor.Avalonia.Services.Workspaces;
 
 namespace Quantum.Editor.Avalonia;
 
@@ -21,27 +22,41 @@ public partial class MainWindow : Window
     };
 
     private readonly EditorWorkspace workspace;
+    private readonly WorkspaceProfileManager workspaceProfiles;
 
     public MainWindow()
-        : this(CreateWorkspace())
+        : this(CreateWorkspace(), new WorkspaceProfileManager())
     {
     }
 
     public MainWindow(EditorWorkspace workspace)
+        : this(workspace, new WorkspaceProfileManager())
+    {
+    }
+
+    public MainWindow(
+        EditorWorkspace workspace,
+        WorkspaceProfileManager workspaceProfiles)
     {
         this.workspace = workspace ?? throw new ArgumentNullException(nameof(workspace));
+        this.workspaceProfiles = workspaceProfiles ??
+            throw new ArgumentNullException(nameof(workspaceProfiles));
         InitializeComponent();
 
         this.workspace.WorkspaceChanged += OnWorkspaceChanged;
         this.workspace.StationCursorChanged += OnStationCursorChanged;
         this.workspace.SectionHighlightChanged += OnSectionHighlightChanged;
+        this.workspaceProfiles.CurrentProfileChanged += OnCurrentProfileChanged;
         this.workspace.Viewport.SetActiveViewport(ViewportPane);
         this.workspace.Commands.Register(new EditorCommand(
             EditorCommandIds.FitViewport,
             _ => ViewportPane.FitToTrack()));
+        ApplyWorkspaceProfile(this.workspaceProfiles.CurrentProfile);
         UpdateWorkspaceView();
     }
 
+    public WorkspaceProfileManager WorkspaceProfiles => workspaceProfiles;
+
     private static EditorWorkspace CreateWorkspace()
     {
         var result = new EditorWorkspace();
@@ -54,6 +69,66 @@ private void OnWorkspaceChanged(object? sender, EventArgs eventArgs)
         UpdateWorkspaceView();
     }
 
+    private void OnCurrentProfileChanged(object? sender, EventArgs eventArgs)
+    {
+        ApplyWorkspaceProfile(workspaceProfiles.CurrentProfile);
+        UpdateWorkspaceView();
+    }
+
+    private void ApplyWorkspaceProfile(WorkspaceProfile profile)
+    {
+        bool showRoute = profile.IsPaneVisibleByDefault(WorkspacePaneIds.Route);
+        bool showViewport = profile.IsPaneVisibleByDefault(WorkspacePaneIds.Viewport);
+        bool showInspector = profile.IsPaneVisibleByDefault(WorkspacePaneIds.Inspector);
+        bool showMathPlots = profile.IsPaneVisibleByDefault(WorkspacePaneIds.MathPlots);
+        bool showDiagnostics = profile.IsPaneVisibleByDefault(WorkspacePaneIds.Diagnostics);
+        bool showBottomPanel = showMathPlots || showDiagnostics;
+
+        RoutePane.IsVisible = showRoute;
+        ViewportPane.IsVisible = showViewport;
+        InspectorPane.IsVisible = showInspector;
+        RouteSplitter.IsVisible = showRoute && showViewport;
+        InspectorSplitter.IsVisible = showViewport && showInspector;
+        MathPlotsTab.IsVisible = showMathPlots;
+        DiagnosticsTab.IsVisible = showDiagnostics;
+        BottomPanelRegion.IsVisible = showBottomPanel;
+        BottomPanelSplitter.IsVisible = showBottomPanel;
+        if (showBottomPanel &&
+            BottomWorkspaceTabs.SelectedItem is Control selectedTab &&
+            !selectedTab.IsVisible)
+        {
+            BottomWorkspaceTabs.SelectedItem = showMathPlots ? MathPlotsTab : DiagnosticsTab;
+        }
+
+        ContentPaneGrid.ColumnDefinitions[0].Width = new GridLength(showRoute ? 320 : 0);
+        ContentPaneGrid.ColumnDefinitions[1].Width = new GridLength(showRoute && showViewport ? 5 : 0);
+        ContentPaneGrid.ColumnDefinitions[2].Width = showViewport
+            ? new GridLength(1, GridUnitType.Star)
+            : new GridLength(0);
+        ContentPaneGrid.ColumnDefinitions[3].Width = new GridLength(showViewport && showInspector ? 5 : 0);
+        ContentPaneGrid.ColumnDefinitions[4].Width = new GridLength(showInspector ? 340 : 0);
+        WorkbenchGrid.RowDefinitions[3].Height = new GridLength(showBottomPanel ? 5 : 0);
+        WorkbenchGrid.RowDefinitions[4].Height = new GridLength(showBottomPanel ? 300 : 0);
+
+        bool showFileCommands = profile.HasCommandGroup(WorkspaceCommandGroupIds.File);
+        bool showEditCommands = profile.HasCommandGroup(WorkspaceCommandGroupIds.Edit);
+        bool showViewCommands = profile.HasCommandGroup(WorkspaceCommandGroupIds.View);
+        FileMenu.IsVisible = showFileCommands;
+        EditMenu.IsVisible = showEditCommands;
+        ViewMenu.IsVisible = showViewCommands;
+        NewButton.IsVisible = showFileCommands;
+        OpenButton.IsVisible = showFileCommands;
+        SaveButton.IsVisible = showFileCommands;
+        UndoButton.IsVisible = showEditCommands;
+        RedoButton.IsVisible = showEditCommands;
+        FitButton.IsVisible = showViewCommands;
+        ShowFramesCheckBox.IsVisible = showViewCommands;
+        ProjectionComboBox.IsVisible = showViewCommands;
+
+        ShowFramesCheckBox.IsChecked = profile.IsOverlayEnabledByDefault(
+            WorkspaceOverlayIds.TransportedFrames);
+    }
+
     private void UpdateWorkspaceView()
     {
         TrackEditorDocument? document = workspace.ActiveDocument;
diff --git a/Quantum.Editor.Avalonia/Services/Workspaces/WorkspaceCompositionIds.cs b/Quantum.Editor.Avalonia/Services/Workspaces/WorkspaceCompositionIds.cs
new file mode 100644
index 0000000..81bc0db
--- /dev/null
+++ b/Quantum.Editor.Avalonia/Services/Workspaces/WorkspaceCompositionIds.cs
@@ -0,0 +1,31 @@
+namespace Quantum.Editor.Avalonia.Services.Workspaces;
+
+/// <summary>
+/// Pane identifiers understood by the current workbench composition root.
+/// </summary>
+public static class WorkspacePaneIds
+{
+    public const string Route = "route";
+    public const string Viewport = "viewport";
+    public const string Inspector = "inspector";
+    public const string MathPlots = "math-plots";
+    public const string Diagnostics = "diagnostics";
+}
+
+/// <summary>
+/// Command group identifiers understood by the current workbench shell.
+/// </summary>
+public static class WorkspaceCommandGroupIds
+{
+    public const string File = "file";
+    public const string Edit = "edit";
+    public const string View = "view";
+}
+
+/// <summary>
+/// Overlay identifiers whose initial state can be supplied by a workspace profile.
+/// </summary>
+public static class WorkspaceOverlayIds
+{
+    public const string TransportedFrames = "transported-frames";
+}
diff --git a/Quantum.Editor.Avalonia/Services/Workspaces/WorkspaceProfile.cs b/Quantum.Editor.Avalonia/Services/Workspaces/WorkspaceProfile.cs
new file mode 100644
index 0000000..9b2d662
--- /dev/null
+++ b/Quantum.Editor.Avalonia/Services/Workspaces/WorkspaceProfile.cs
@@ -0,0 +1,151 @@
+using System.Collections.ObjectModel;
+
+namespace Quantum.Editor.Avalonia.Services.Workspaces;
+
+/// <summary>
+/// Immutable editor-composition metadata for one workspace.
+/// </summary>
+public sealed class WorkspaceProfile
+{
+    private readonly HashSet<string> availablePaneSet;
+    private readonly HashSet<string> defaultVisiblePaneSet;
+    private readonly HashSet<string> commandGroupSet;
+
+    public WorkspaceProfile(
+        WorkspaceProfileId id,
+        string displayName,
+        string? icon = null,
+        IEnumerable<string>? availablePanes = null,
+        IEnumerable<string>? defaultVisiblePanes = null,
+        IEnumerable<string>? commandGroups = null,
+        IReadOnlyDictionary<string, bool>? overlayDefaults = null,
+        bool isAvailable = true,
+        bool isVisible = true)
+    {
+        if (id.IsEmpty)
+        {
+            throw new ArgumentException("A workspace profile identifier cannot be empty.", nameof(id));
+        }
+
+        if (string.IsNullOrWhiteSpace(displayName))
+        {
+            throw new ArgumentException("A workspace display name cannot be empty.", nameof(displayName));
+        }
+
+        Id = id;
+        DisplayName = displayName.Trim();
+        Icon = icon;
+        IsAvailable = isAvailable;
+        IsVisible = isVisible;
+
+        string[] panes = CopyDistinctIdentifiers(availablePanes, nameof(availablePanes));
+        string[] visiblePanes = CopyDistinctIdentifiers(defaultVisiblePanes, nameof(defaultVisiblePanes));
+        string[] groups = CopyDistinctIdentifiers(commandGroups, nameof(commandGroups));
+        availablePaneSet = new HashSet<string>(panes, StringComparer.Ordinal);
+        defaultVisiblePaneSet = new HashSet<string>(visiblePanes, StringComparer.Ordinal);
+        commandGroupSet = new HashSet<string>(groups, StringComparer.Ordinal);
+
+        string? unavailableDefault = visiblePanes.FirstOrDefault(pane => !availablePaneSet.Contains(pane));
+        if (unavailableDefault != null)
+        {
+            throw new ArgumentException(
+                $"Default-visible pane '{unavailableDefault}' is not an available pane.",
+                nameof(defaultVisiblePanes));
+        }
+
+        AvailablePanes = Array.AsReadOnly(panes);
+        DefaultVisiblePanes = Array.AsReadOnly(visiblePanes);
+        CommandGroups = Array.AsReadOnly(groups);
+        DefaultPaneVisibility = new ReadOnlyDictionary<string, bool>(
+            panes.ToDictionary(pane => pane, defaultVisiblePaneSet.Contains, StringComparer.Ordinal));
+        OverlayDefaults = CopyOverlayDefaults(overlayDefaults);
+    }
+
+    public WorkspaceProfileId Id { get; }
+
+    public string DisplayName { get; }
+
+    public string? Icon { get; }
+
+    /// <summary>
+    /// Whether the profile contains enough functionality to be activated.
+    /// </summary>
+    public bool IsAvailable { get; }
+
+    /// <summary>
+    /// Whether the profile should be offered by a future workspace switcher.
+    /// </summary>
+    public bool IsVisible { get; }
+
+    public IReadOnlyList<string> AvailablePanes { get; }
+
+    public IReadOnlyList<string> DefaultVisiblePanes { get; }
+
+    public IReadOnlyDictionary<string, bool> DefaultPaneVisibility { get; }
+
+    public IReadOnlyList<string> CommandGroups { get; }
+
+    public IReadOnlyDictionary<string, bool> OverlayDefaults { get; }
+
+    public bool HasPane(string paneId) =>
+        !string.IsNullOrWhiteSpace(paneId) && availablePaneSet.Contains(paneId);
+
+    public bool IsPaneVisibleByDefault(string paneId) =>
+        !string.IsNullOrWhiteSpace(paneId) && defaultVisiblePaneSet.Contains(paneId);
+
+    public bool HasCommandGroup(string commandGroupId) =>
+        !string.IsNullOrWhiteSpace(commandGroupId) && commandGroupSet.Contains(commandGroupId);
+
+    public bool IsOverlayEnabledByDefault(string overlayId) =>
+        !string.IsNullOrWhiteSpace(overlayId) &&
+        OverlayDefaults.TryGetValue(overlayId, out bool isEnabled) &&
+        isEnabled;
+
+    private static string[] CopyDistinctIdentifiers(IEnumerable<string>? values, string parameterName)
+    {
+        if (values is null)
+        {
+            return Array.Empty<string>();
+        }
+
+        var result = new List<string>();
+        var seen = new HashSet<string>(StringComparer.Ordinal);
+        foreach (string? value in values)
+        {
+            if (string.IsNullOrWhiteSpace(value))
+            {
+                throw new ArgumentException("Composition identifiers cannot be empty.", parameterName);
+            }
+
+            string trimmed = value.Trim();
+            if (seen.Add(trimmed))
+            {
+                result.Add(trimmed);
+            }
+        }
+
+        return result.ToArray();
+    }
+
+    private static IReadOnlyDictionary<string, bool> CopyOverlayDefaults(
+        IReadOnlyDictionary<string, bool>? overlayDefaults)
+    {
+        var result = new Dictionary<string, bool>(StringComparer.Ordinal);
+        if (overlayDefaults != null)
+        {
+            foreach ((string key, bool value) in overlayDefaults)
+            {
+                if (string.IsNullOrWhiteSpace(key))
+                {
+                    throw new ArgumentException(
+                        "Overlay identifiers cannot be empty.",
+                        nameof(overlayDefaults));
+                }
+
+                result.Add(key.Trim(), value);
+            }
+        }
+
+        return new ReadOnlyDictionary<string, bool>(result);
+    }
+}
diff --git a/Quantum.Editor.Avalonia/Services/Workspaces/WorkspaceProfileCatalog.cs b/Quantum.Editor.Avalonia/Services/Workspaces/WorkspaceProfileCatalog.cs
new file mode 100644
index 0000000..929fa35
--- /dev/null
+++ b/Quantum.Editor.Avalonia/Services/Workspaces/WorkspaceProfileCatalog.cs
@@ -0,0 +1,136 @@
+namespace Quantum.Editor.Avalonia.Services.Workspaces;
+
+/// <summary>
+/// Registration and lookup boundary for editor workspace profiles.
+/// </summary>
+public sealed class WorkspaceProfileCatalog
+{
+    private readonly Dictionary<WorkspaceProfileId, WorkspaceProfile> profilesById = new();
+    private readonly List<WorkspaceProfile> profiles = new();
+    private WorkspaceProfileId defaultProfileId;
+
+    public IReadOnlyList<WorkspaceProfile> Profiles => profiles.AsReadOnly();
+
+    public IReadOnlyList<WorkspaceProfile> AvailableProfiles =>
+        profiles.Where(profile => profile.IsAvailable).ToArray();
+
+    public IReadOnlyList<WorkspaceProfile> VisibleProfiles =>
+        profiles.Where(profile => profile.IsVisible).ToArray();
+
+    public WorkspaceProfileId DefaultProfileId => defaultProfileId;
+
+    public WorkspaceProfile DefaultProfile
+    {
+        get
+        {
+            if (defaultProfileId.IsEmpty)
+            {
+                throw new InvalidOperationException("The workspace profile catalog has no available default profile.");
+            }
+
+            return Get(defaultProfileId);
+        }
+    }
+
+    public static WorkspaceProfileCatalog CreateDefault()
+    {
+        var result = new WorkspaceProfileCatalog();
+        result.Register(CreateTrackProfile(), makeDefault: true);
+        result.Register(CreateFutureProfile(WorkspaceProfileId.Train, "Train", "train"));
+        result.Register(CreateFutureProfile(WorkspaceProfileId.Support, "Support", "support"));
+        result.Register(CreateFutureProfile(WorkspaceProfileId.Terrain, "Terrain", "terrain"));
+        result.Register(CreateFutureProfile(WorkspaceProfileId.Simulation, "Simulation", "simulation"));
+        return result;
+    }
+
+    public void Register(WorkspaceProfile profile, bool makeDefault = false)
+    {
+        ArgumentNullException.ThrowIfNull(profile);
+        if (profilesById.ContainsKey(profile.Id))
+        {
+            throw new InvalidOperationException(
+                $"Workspace profile '{profile.Id}' is already registered.");
+        }
+
+        if (makeDefault && !profile.IsAvailable)
+        {
+            throw new InvalidOperationException("An unavailable workspace profile cannot be the default.");
+        }
+
+        profilesById.Add(profile.Id, profile);
+        profiles.Add(profile);
+
+        if (makeDefault || (defaultProfileId.IsEmpty && profile.IsAvailable))
+        {
+            defaultProfileId = profile.Id;
+        }
+    }
+
+    public void SetDefault(WorkspaceProfileId id)
+    {
+        WorkspaceProfile profile = Get(id);
+        if (!profile.IsAvailable)
+        {
+            throw new InvalidOperationException("An unavailable workspace profile cannot be the default.");
+        }
+
+        defaultProfileId = id;
+    }
+
+    public bool Contains(WorkspaceProfileId id) => profilesById.ContainsKey(id);
+
+    public bool TryGet(WorkspaceProfileId id, out WorkspaceProfile profile) =>
+        profilesById.TryGetValue(id, out profile!);
+
+    public WorkspaceProfile Get(WorkspaceProfileId id)
+    {
+        if (!profilesById.TryGetValue(id, out WorkspaceProfile? profile))
+        {
+            throw new KeyNotFoundException($"Workspace profile '{id}' is not registered.");
+        }
+
+        return profile;
+    }
+
+    private static WorkspaceProfile CreateTrackProfile()
+    {
+        string[] panes =
+        {
+            WorkspacePaneIds.Route,
+            WorkspacePaneIds.Viewport,
+            WorkspacePaneIds.Inspector,
+            WorkspacePaneIds.MathPlots,
+            WorkspacePaneIds.Diagnostics
+        };
+
+        return new WorkspaceProfile(
+            WorkspaceProfileId.Track,
+            "Track",
+            icon: "track",
+            availablePanes: panes,
+            defaultVisiblePanes: panes,
+            commandGroups: new[]
+            {
+                WorkspaceCommandGroupIds.File,
+                WorkspaceCommandGroupIds.Edit,
+                WorkspaceCommandGroupIds.View
+            },
+            overlayDefaults: new Dictionary<string, bool>
+            {
+                [WorkspaceOverlayIds.TransportedFrames] = true
+            });
+    }
+
+    private static WorkspaceProfile CreateFutureProfile(
+        WorkspaceProfileId id,
+        string displayName,
+        string icon)
+    {
+        return new WorkspaceProfile(
+            id,
+            displayName,
+            icon,
+            isAvailable: false,
+            isVisible: false);
+    }
+}
diff --git a/Quantum.Editor.Avalonia/Services/Workspaces/WorkspaceProfileId.cs b/Quantum.Editor.Avalonia/Services/Workspaces/WorkspaceProfileId.cs
new file mode 100644
index 0000000..eb8574d
--- /dev/null
+++ b/Quantum.Editor.Avalonia/Services/Workspaces/WorkspaceProfileId.cs
@@ -0,0 +1,50 @@
+namespace Quantum.Editor.Avalonia.Services.Workspaces;
+
+/// <summary>
+/// Stable identifier for an editor workspace profile.
+/// </summary>
+public readonly struct WorkspaceProfileId : IEquatable<WorkspaceProfileId>
+{
+    private readonly string? value;
+
+    public WorkspaceProfileId(string value)
+    {
+        if (string.IsNullOrWhiteSpace(value))
+        {
+            throw new ArgumentException("A workspace profile identifier cannot be empty.", nameof(value));
+        }
+
+        this.value = value.Trim();
+    }
+
+    public static WorkspaceProfileId Track { get; } = new("track");
+
+    public static WorkspaceProfileId Train { get; } = new("train");
+
+    public static WorkspaceProfileId Support { get; } = new("support");
+
+    public static WorkspaceProfileId Terrain { get; } = new("terrain");
+
+    public static WorkspaceProfileId Simulation { get; } = new("simulation");
+
+    public string Value => value ?? string.Empty;
+
+    public bool IsEmpty => string.IsNullOrEmpty(value);
+
+    public bool Equals(WorkspaceProfileId other) =>
+        string.Equals(Value, other.Value, StringComparison.Ordinal);
+
+    public override bool Equals(object? obj) =>
+        obj is WorkspaceProfileId other && Equals(other);
+
+    public override int GetHashCode() =>
+        StringComparer.Ordinal.GetHashCode(Value);
+
+    public override string ToString() => Value;
+
+    public static bool operator ==(WorkspaceProfileId left, WorkspaceProfileId right) =>
+        left.Equals(right);
+
+    public static bool operator !=(WorkspaceProfileId left, WorkspaceProfileId right) =>
+        !left.Equals(right);
+}
diff --git a/Quantum.Editor.Avalonia/Services/Workspaces/WorkspaceProfileManager.cs b/Quantum.Editor.Avalonia/Services/Workspaces/WorkspaceProfileManager.cs
new file mode 100644
index 0000000..2151bd4
--- /dev/null
+++ b/Quantum.Editor.Avalonia/Services/Workspaces/WorkspaceProfileManager.cs
@@ -0,0 +1,76 @@
+namespace Quantum.Editor.Avalonia.Services.Workspaces;
+
+/// <summary>
+/// Owns the active editor composition profile without owning editor documents or state.
+/// </summary>
+public sealed class WorkspaceProfileManager
+{
+    private WorkspaceProfile currentProfile;
+
+    public WorkspaceProfileManager()
+        : this(WorkspaceProfileCatalog.CreateDefault())
+    {
+    }
+
+    public WorkspaceProfileManager(
+        WorkspaceProfileCatalog catalog,
+        WorkspaceProfileId? initialProfileId = null)
+    {
+        Catalog = catalog ?? throw new ArgumentNullException(nameof(catalog));
+        WorkspaceProfile selectedProfile = initialProfileId.HasValue
+            ? Catalog.Get(initialProfileId.Value)
+            : Catalog.DefaultProfile;
+        if (!selectedProfile.IsAvailable)
+        {
+            throw new InvalidOperationException(
+                $"Workspace profile '{selectedProfile.Id}' is not available.");
+        }
+
+        currentProfile = selectedProfile;
+    }
+
+    public event EventHandler? CurrentProfileChanged;
+
+    public WorkspaceProfileCatalog Catalog { get; }
+
+    public WorkspaceProfile CurrentProfile => currentProfile;
+
+    public WorkspaceProfile ActiveProfile => currentProfile;
+
+    public WorkspaceProfileId CurrentProfileId => currentProfile.Id;
+
+    public bool TrySwitchTo(WorkspaceProfileId id)
+    {
+        if (!Catalog.TryGet(id, out WorkspaceProfile profile) || !profile.IsAvailable)
+        {
+            return false;
+        }
+
+        SetCurrentProfile(profile);
+        return true;
+    }
+
+    public void SwitchTo(WorkspaceProfileId id)
+    {
+        WorkspaceProfile profile = Catalog.Get(id);
+        if (!profile.IsAvailable)
+        {
+            throw new InvalidOperationException($"Workspace profile '{id}' is not available.");
+        }
+
+        SetCurrentProfile(profile);
+    }
+
+    public void ResetToDefault() => SwitchTo(Catalog.DefaultProfileId);
+
+    private void SetCurrentProfile(WorkspaceProfile profile)
+    {
+        if (currentProfile.Id == profile.Id)
+        {
+            return;
+        }
+
+        currentProfile = profile;
+        CurrentProfileChanged?.Invoke(this, EventArgs.Empty);
+    }
+}
diff --git a/Quantum.Tests/Editor/WorkspaceProfileInfrastructureTests.cs b/Quantum.Tests/Editor/WorkspaceProfileInfrastructureTests.cs
new file mode 100644
index 0000000..e98418a
--- /dev/null
+++ b/Quantum.Tests/Editor/WorkspaceProfileInfrastructureTests.cs
@@ -0,0 +1,99 @@
+using Quantum.Editor.Avalonia.Services.Workspaces;
+
+namespace Quantum.Tests;
+
+public sealed class WorkspaceProfileInfrastructureTests
+{
+    [Fact]
+    public void Catalog_RegistersAndLooksUpProfileByStableIdentifier()
+    {
+        var catalog = new WorkspaceProfileCatalog();
+        var profile = new WorkspaceProfile(
+            new WorkspaceProfileId("custom"),
+            "Custom",
+            availablePanes: new[] { WorkspacePaneIds.Viewport },
+            defaultVisiblePanes: new[] { WorkspacePaneIds.Viewport });
+
+        catalog.Register(profile);
+
+        Assert.True(catalog.Contains(profile.Id));
+        Assert.True(catalog.TryGet(profile.Id, out WorkspaceProfile lookedUp));
+        Assert.Same(profile, lookedUp);
+        Assert.Same(profile, catalog.Get(profile.Id));
+        Assert.Throws<InvalidOperationException>(() => catalog.Register(profile));
+    }
+
+    [Fact]
+    public void DefaultCatalog_SelectsCompleteTrackWorkspaceAndHidesFutureDefinitions()
+    {
+        WorkspaceProfileCatalog catalog = WorkspaceProfileCatalog.CreateDefault();
+
+        Assert.Equal(WorkspaceProfileId.Track, catalog.DefaultProfileId);
+        WorkspaceProfile track = catalog.DefaultProfile;
+        Assert.Equal("Track", track.DisplayName);
+        Assert.True(track.IsAvailable);
+        Assert.True(track.IsVisible);
+        Assert.Equal(5, track.AvailablePanes.Count);
+        Assert.All(track.AvailablePanes, pane => Assert.True(track.IsPaneVisibleByDefault(pane)));
+        Assert.True(track.HasCommandGroup(WorkspaceCommandGroupIds.File));
+        Assert.True(track.HasCommandGroup(WorkspaceCommandGroupIds.Edit));
+        Assert.True(track.HasCommandGroup(WorkspaceCommandGroupIds.View));
+        Assert.True(track.IsOverlayEnabledByDefault(WorkspaceOverlayIds.TransportedFrames));
+
+        Assert.Equal(5, catalog.Profiles.Count);
+        Assert.Collection(catalog.AvailableProfiles, profile => Assert.Equal(WorkspaceProfileId.Track, profile.Id));
+        Assert.Collection(catalog.VisibleProfiles, profile => Assert.Equal(WorkspaceProfileId.Track, profile.Id));
+        Assert.False(catalog.Get(WorkspaceProfileId.Train).IsAvailable);
+        Assert.False(catalog.Get(WorkspaceProfileId.Support).IsVisible);
+        Assert.False(catalog.Get(WorkspaceProfileId.Terrain).IsAvailable);
+        Assert.False(catalog.Get(WorkspaceProfileId.Simulation).IsVisible);
+    }
+
+    [Fact]
+    public void Manager_UsesCatalogDefaultProfile()
+    {
+        WorkspaceProfileCatalog catalog = WorkspaceProfileCatalog.CreateDefault();
+
+        var manager = new WorkspaceProfileManager(catalog);
+
+        Assert.Same(catalog.DefaultProfile, manager.CurrentProfile);
+        Assert.Same(manager.CurrentProfile, manager.ActiveProfile);
+        Assert.Equal(WorkspaceProfileId.Track, manager.CurrentProfileId);
+    }
+
+    [Fact]
+    public void Manager_SwitchesOnlyToAvailableRegisteredProfilesAndNotifiesOnce()
+    {
+        var catalog = new WorkspaceProfileCatalog();
+        var track = new WorkspaceProfile(WorkspaceProfileId.Track, "Track");
+        var alternate = new WorkspaceProfile(new WorkspaceProfileId("alternate"), "Alternate");
+        var unavailable = new WorkspaceProfile(
+            WorkspaceProfileId.Train,
+            "Train",
+            isAvailable: false,
+            isVisible: false);
+        catalog.Register(track, makeDefault: true);
+        catalog.Register(alternate);
+        catalog.Register(unavailable);
+        var manager = new WorkspaceProfileManager(catalog);
+        int notifications = 0;
+        manager.CurrentProfileChanged += (_, _) => notifications++;
+
+        Assert.True(manager.TrySwitchTo(alternate.Id));
+        Assert.Same(alternate, manager.CurrentProfile);
+        Assert.Equal(1, notifications);
+
+        manager.SwitchTo(alternate.Id);
+        Assert.Equal(1, notifications);
+
+        Assert.False(manager.TrySwitchTo(unavailable.Id));
+        Assert.False(manager.TrySwitchTo(new WorkspaceProfileId("missing")));
+        Assert.Same(alternate, manager.CurrentProfile);
+        Assert.Equal(1, notifications);
+        Assert.Throws<InvalidOperationException>(() => manager.SwitchTo(unavailable.Id));
+
+        manager.ResetToDefault();
+        Assert.Same(track, manager.CurrentProfile);
+        Assert.Equal(2, notifications);
+    }
+}
diff --git a/README.md b/README.md
index fa8e54c..e6be1c6 100644
--- a/README.md
+++ b/README.md
@@ -14,7 +14,7 @@ Quantum CoasterWorks is an early-stage coaster design and simulation backend. Th
 
 - `Quantum.Core`, `Quantum.Math`, `Quantum.Splines`, `Quantum.Track`, `Quantum.FVD`, `Quantum.Physics`, and `Quantum.IO` contain backend/domain logic.
 - `Quantum.Debug` contains backend diagnostics and command-line tooling.
-- `Quantum.Editor.Avalonia` contains a standalone editor workbench for Track Layout Package V2 files, backend compilation, document/outliner/inspector workflows, undo/redo, an Avalonia-drawn technical viewport, and the snapshot-driven [M159 Interactive Math Plot Workspace](docs/editor/m159-interactive-math-plots.md).
+- `Quantum.Editor.Avalonia` contains a standalone editor workbench for Track Layout Package V2 files, backend compilation, document/outliner/inspector workflows, undo/redo, an Avalonia-drawn technical viewport, the snapshot-driven [M159 Interactive Math Plot Workspace](docs/editor/m159-interactive-math-plots.md), and [M161 workspace profile infrastructure](docs/editor/m161-workspace-profile-infrastructure.md).
 - `Quantum.Tests` contains automated tests and contract fixtures.
 - `Assets` contains the current Unity debug visualizer/prototype assets.
 
@@ -117,6 +117,8 @@ See [`docs/editor/m157-graph-authoring.md`](docs/editor/m157-graph-authoring.md)
 
 M160 keeps this layout and behavior intact while extracting the Route, Viewport, Inspector, Math Plots, and Diagnostics regions into reusable Avalonia controls. See [`docs/editor/m160-pane-extraction.md`](docs/editor/m160-pane-extraction.md) for the pane contracts and unchanged backend boundary.
 
+M161 adds profile registration, lookup, default selection, and switching infrastructure around that composition. Track remains the only available workspace and preserves the M160 workbench exactly; Train, Support, Terrain, and Simulation are hidden definitions pending meaningful vertical slices. See [`docs/editor/m161-workspace-profile-infrastructure.md`](docs/editor/m161-workspace-profile-infrastructure.md).
+
 From a fresh checkout:
 
 ```powershell
diff --git a/docs/editor/m161-workspace-profile-infrastructure.md b/docs/editor/m161-workspace-profile-infrastructure.md
new file mode 100644
index 0000000..7f12df0
--- /dev/null
+++ b/docs/editor/m161-workspace-profile-infrastructure.md
@@ -0,0 +1,53 @@
+# Milestone 161 Workspace Profile Infrastructure
+
+M161 introduces editor workspace profiles without changing the M160 workbench
+layout or any track-authoring behavior. The Track workspace is the default and
+only available profile. It composes the same Route, Viewport, Inspector, Math
+Plots, and Diagnostics panes, the same command surfaces, and the same default
+transported-frame overlay as M160.
+
+## Profile model
+
+The infrastructure lives in `Quantum.Editor.Avalonia.Services.Workspaces`:
+
+- `WorkspaceProfileId` provides stable identifiers for Track and the planned
+  Train, Support, Terrain, and Simulation workspaces.
+- `WorkspaceProfile` is immutable composition metadata: display name, icon key,
+  available panes, default pane visibility, command groups, overlay defaults,
+  and availability/switcher visibility.
+- `WorkspaceProfileCatalog` registers profiles, rejects duplicate identifiers,
+  performs lookup, and identifies the default profile.
+- `WorkspaceProfileManager` selects the catalog default, exposes the current
+  profile, and validates and notifies profile changes.
+
+`WorkspaceProfileCatalog.CreateDefault()` registers all five named definitions.
+Track is available and visible. Train, Support, Terrain, and Simulation are
+deliberately unavailable and hidden until each has a meaningful vertical slice.
+
+## Workbench integration
+
+`MainWindow` remains the composition root and now receives a
+`WorkspaceProfileManager` alongside the existing `EditorWorkspace`. It maps
+known pane, command-group, and overlay identifiers onto the already extracted
+controls. The Track metadata exactly matches the M160 composition, so no
+workspace selector or other visible UI is added in M161.
+
+Additional profiles can be registered in the catalog and selected through the
+manager without adding profile-specific branching to `MainWindow`. New pane
+types will still require a future composition extension when their vertical
+slice exists; M161 does not add placeholder panes.
+
+## Preserved boundaries
+
+The workspace profile layer contains composition metadata only. It does not own
+or modify:
+
+- `EditorWorkspace`, `TrackAuthoringGraph`, or the authoring model;
+- compilation, `EngineeringSnapshot`, sampling, or engineering calculations;
+- selection, synchronized Math Plot interaction, or viewport rendering;
+- undo/redo, Track Layout Package V2 persistence, or document state; or
+- docking, floating panes, layout persistence, or pane extraction.
+
+Registration, lookup, default selection, unavailable future definitions, and
+switch notifications are covered by
+`Quantum.Tests/Editor/WorkspaceProfileInfrastructureTests.cs`.