diff --git a/CHANGELOG.md b/CHANGELOG.md
index bac15df..d96803c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,20 @@ All notable changes to Aperture Image Viewer are documented here. The format fol
 
 ## [Unreleased]
 
+## [0.8.4-beta1] - 2026-08-21
+
+### Fixed
+- **Tile-pane Up/Down** move in the same visual column (Explorer-style), including
+  across date-section headers, instead of jumping by linear item index. An empty
+  cell (short last row) lands on the nearest tile in that column, then the nearest
+  in the row — not a section header and not a random index.
+- **PageUp/PageDown** scroll roughly one viewport (regardless of zoom / tile size)
+  and keep the selection in the same column at the same screen Y. They no longer
+  skip N items or jump to a date-section header.
+- **Tab / Shift+Tab** cycle only the folder tree and the tile pane, do not change
+  either pane's selection, and skip the ribbon (hamburger / command bar / search).
+  Search stays on `/` and Ctrl+F.
+
 ## [0.8.3-beta1] - 2026-08-21
 
 ### Fixed
diff --git a/src/Aperture.App/Aperture.App.csproj b/src/Aperture.App/Aperture.App.csproj
index 2f98a89..874e3f9 100644
--- a/src/Aperture.App/Aperture.App.csproj
+++ b/src/Aperture.App/Aperture.App.csproj
@@ -16,7 +16,7 @@
     <UseWPF>true</UseWPF>
     <ApplicationIcon>Assets\aperture.ico</ApplicationIcon>
     <AssemblyName>Aperture</AssemblyName>
-    <Version>0.8.3-beta1</Version>
+    <Version>0.8.4-beta1</Version>
     <AssemblyTitle>Aperture Image Viewer</AssemblyTitle>
     <Product>Aperture Image Viewer</Product>
     <Description>A fast local image &amp; video browser for Windows.</Description>
diff --git a/src/Aperture.App/LibraryPaneFocus.cs b/src/Aperture.App/LibraryPaneFocus.cs
index 6bca3bc..bbd7ca0 100644
--- a/src/Aperture.App/LibraryPaneFocus.cs
+++ b/src/Aperture.App/LibraryPaneFocus.cs
@@ -38,6 +38,15 @@ internal enum Hit
     public static bool ShouldFocusContentsPane(DependencyObject? originalSource, IInputElement? currentFocus) =>
         ShouldFocusContentsPane(Classify(originalSource, currentFocus));
 
+    /// <summary>
+    /// True when keyboard focus is arriving from outside a pane onto an item
+    /// that is not the current selection. WPF <see cref="ListBox"/> /
+    /// <see cref="TreeView"/> often focus (and therefore select) the first
+    /// item on entry — redirect so Tab does not change the pane's selection.
+    /// </summary>
+    public static bool ShouldKeepExistingSelection(bool fromOutside, bool newFocusIsItem, bool newFocusIsSelected) =>
+        fromOutside && newFocusIsItem && !newFocusIsSelected;
+
     public static Hit Classify(DependencyObject? originalSource, IInputElement? currentFocus)
     {
         // A dialog keeps focus even if the click somehow reached the pane
diff --git a/src/Aperture.App/MainWindow.xaml b/src/Aperture.App/MainWindow.xaml
index 4eb60bf..c1e8f0a 100644
--- a/src/Aperture.App/MainWindow.xaml
+++ b/src/Aperture.App/MainWindow.xaml
@@ -287,11 +287,12 @@
 
         <!-- Toolbar -->
         <Border DockPanel.Dock="Top" Background="{StaticResource Panel}" BorderBrush="{StaticResource Line}"
-                BorderThickness="0,0,0,1">
+                BorderThickness="0,0,0,1" KeyboardNavigation.TabNavigation="None">
             <DockPanel Margin="12,10">
                 <!-- Settings (right) -->
                 <ToggleButton x:Name="SettingsToggle" DockPanel.Dock="Right" Content="☰"
                               FontSize="16" Padding="12,4" Style="{StaticResource ToolToggle}" Margin="6,0,0,0"
+                              IsTabStop="False"
                               ToolTip="Menu" />
 
                 <!-- Search (right, left of settings) -->
@@ -314,12 +315,13 @@
                         </TextBlock>
                         <TextBox x:Name="SearchBox" Background="Transparent" BorderThickness="0"
                                  VerticalContentAlignment="Center" Margin="7,0,26,0" FontSize="12"
+                                 IsTabStop="False"
                                  GotKeyboardFocus="OnSearchFocus" LostKeyboardFocus="OnSearchBlur"
                                  KeyDown="OnSearchKeyDown"
                                  Text="{Binding SearchInput, UpdateSourceTrigger=PropertyChanged}" />
                         <Button Content="✕" Command="{Binding ClearSearchCommand}" HorizontalAlignment="Right"
                                 Width="24" Background="Transparent" BorderThickness="0" Foreground="{StaticResource Muted}"
-                                Cursor="Hand" />
+                                IsTabStop="False" Cursor="Hand" />
                     </Grid>
                 </Border>
 
@@ -525,7 +527,7 @@
 
         <!-- Status bar -->
         <Border DockPanel.Dock="Bottom" Background="{StaticResource Panel}" BorderBrush="{StaticResource Line}"
-                BorderThickness="0,1,0,0">
+                BorderThickness="0,1,0,0" KeyboardNavigation.TabNavigation="None">
             <Grid Margin="12,6">
                 <TextBlock Text="{Binding StatusText}" Foreground="{StaticResource Ink}" FontSize="12"
                            VerticalAlignment="Center" />
@@ -571,14 +573,14 @@
 
             <!-- Roots pane -->
             <Border Grid.Column="0" Background="{StaticResource CanvasPanel}" BorderBrush="{StaticResource CanvasLine}"
-                    BorderThickness="0,0,1,0">
+                    BorderThickness="0,0,1,0" KeyboardNavigation.TabNavigation="Once">
                 <DockPanel>
                     <!-- Libraries: a saved view over one or more folders. Only the built-in "Everything"
                          (the union of every included folder) exists for now; add/remove comes later. -->
                     <TextBlock DockPanel.Dock="Top" Text="LIBRARIES" Foreground="{StaticResource CanvasMuted}"
                                FontSize="11" FontWeight="SemiBold" Margin="14,12,14,6" />
                     <Button x:Name="EverythingButton" DockPanel.Dock="Top" Command="{Binding NavigateHomeCommand}"
-                            Margin="8,0,8,2" KeyboardNavigation.TabIndex="0" PreviewKeyDown="OnEverythingKeyDown"
+                            Margin="8,0,8,2" KeyboardNavigation.TabIndex="0"
                             HorizontalContentAlignment="Stretch" Cursor="Hand" Padding="0" BorderThickness="0"
                             Foreground="{StaticResource CanvasInk}" FontSize="14"
                             ToolTip="Show everything across all folders">
@@ -616,7 +618,9 @@
                     <TreeView x:Name="FolderTreeView" ItemsSource="{Binding FolderTree}"
                               BorderThickness="0" Background="Transparent" Foreground="{StaticResource CanvasInk}"
                               FontSize="14"
-                              SelectedItemChanged="OnTreeSelectedChanged" PreviewKeyDown="OnTreeKeyDown">
+                              KeyboardNavigation.TabNavigation="Once"
+                              SelectedItemChanged="OnTreeSelectedChanged" PreviewKeyDown="OnTreeKeyDown"
+                              PreviewGotKeyboardFocus="OnTreePreviewGotKeyboardFocus">
                         <TreeView.ItemContainerStyle>
                             <Style TargetType="TreeViewItem">
                                 <Setter Property="IsExpanded" Value="{Binding IsExpanded, Mode=TwoWay}" />
@@ -749,7 +753,7 @@
             </Border>
 
             <GridSplitter Grid.Column="1" Width="4" HorizontalAlignment="Center" VerticalAlignment="Stretch"
-                          Background="Transparent" />
+                          Background="Transparent" Focusable="False" IsTabStop="False" />
 
             <!-- Thumbnail grid + preview pane; cells/splitter configured in code (ConfigurePreviewLayout) -->
             <Grid x:Name="ContentGrid" Grid.Column="2">
@@ -763,10 +767,12 @@
                      SelectedItem="{Binding SelectedItem, Mode=TwoWay}"
                      SelectionMode="Extended"
                      Focusable="True"
+                     KeyboardNavigation.TabNavigation="Once"
                      SelectionChanged="OnGridSelectionChanged"
                      PreviewMouseRightButtonDown="OnGridRightButtonDown"
                      PreviewMouseLeftButtonDown="OnGridPreviewLeftDown"
                      PreviewMouseMove="OnGridPreviewMove"
+                     PreviewGotKeyboardFocus="OnGridPreviewGotKeyboardFocus"
                      Background="{StaticResource CanvasBg}" BorderThickness="0" Padding="6"
                      ItemContainerStyle="{StaticResource TileContainer}"
                      ScrollViewer.HorizontalScrollBarVisibility="Disabled"
@@ -958,12 +964,14 @@
                 </Grid>
 
                 <!-- Drag handle between the browser and the preview (left edge for right-dock, top for bottom) -->
-                <GridSplitter x:Name="PreviewSplitter" Visibility="Collapsed" Background="{StaticResource CanvasLine}" />
+                <GridSplitter x:Name="PreviewSplitter" Visibility="Collapsed" Background="{StaticResource CanvasLine}"
+                              Focusable="False" IsTabStop="False" />
 
             <!-- Preview / inspector pane (docks right or bottom; cell + size set in ConfigurePreviewLayout) -->
             <Border x:Name="PreviewPane" Visibility="Collapsed"
                     Background="{StaticResource CanvasPanel}"
-                    BorderBrush="{StaticResource CanvasLine}" BorderThickness="1">
+                    BorderBrush="{StaticResource CanvasLine}" BorderThickness="1"
+                    KeyboardNavigation.TabNavigation="None">
                 <DockPanel>
                     <Grid DockPanel.Dock="Top" Margin="14,12,10,10">
                         <TextBlock Text="PREVIEW" Foreground="{StaticResource CanvasMuted}" FontSize="11" FontWeight="SemiBold"
@@ -1092,6 +1100,7 @@
 
         <!-- Quick-look overlay -->
         <Grid x:Name="QuickLookOverlay" Background="#EE0E1014" MouseDown="OnQuickLookBackgroundClick"
+              KeyboardNavigation.TabNavigation="None"
               Visibility="{Binding QuickLookOpen, Converter={StaticResource BoolToVis}}">
             <!-- Transparent hit-target over the central image area, so the tile context menu
                  (right-click) and double-click-to-open work regardless of how the image letterboxes.
diff --git a/src/Aperture.App/MainWindow.xaml.cs b/src/Aperture.App/MainWindow.xaml.cs
index 5c73b8c..39aa55c 100644
--- a/src/Aperture.App/MainWindow.xaml.cs
+++ b/src/Aperture.App/MainWindow.xaml.cs
@@ -41,25 +41,12 @@ private void OnLoaded(object sender, RoutedEventArgs e)
         ViewModel.PropertyChanged += OnViewModelPropertyChanged;
         ConfigurePreviewLayout(ViewModel.PreviewMode);
 
-        // Land keyboard focus on the "Everything" library so a single Tab drops into the grid.
+        // Land keyboard focus on the "Everything" library so a single Tab drops into the grid
+        // without changing either pane's selection (ribbon is not a Tab stop).
         Dispatcher.BeginInvoke(new Action(() => EverythingButton.Focus()),
             System.Windows.Threading.DispatcherPriority.Loaded);
     }
 
-    /// <summary>Tab from the "Everything" library jumps straight to the grid's first item.</summary>
-    private void OnEverythingKeyDown(object sender, KeyEventArgs e)
-    {
-        if (e.Key == Key.Tab && (Keyboard.Modifiers & ModifierKeys.Shift) == 0 && ViewModel is not null)
-        {
-            ItemsList.Focus();
-            var first = ViewModel.MoveCursorToFirstItem(); // selects the first tile
-            GridScroll()?.ScrollToTop();
-            if (first is not null)
-                try { ItemsList.ScrollIntoView(first); } catch { }
-            e.Handled = true;
-        }
-    }
-
     private void OnViewModelPropertyChanged(object? sender, System.ComponentModel.PropertyChangedEventArgs e)
     {
         if (e.PropertyName == nameof(MainViewModel.PreviewMode) && ViewModel is not null)
@@ -310,6 +297,67 @@ private void OnTreeKeyDown(object sender, KeyEventArgs e)
         }
     }
 
+    /// <summary>
+    /// Tabbing into the tree must not change its selection. WPF TreeView focuses
+    /// (and selects) the first node when nothing is selected — keep Everything /
+    /// the current folder.
+    /// </summary>
+    private void OnTreePreviewGotKeyboardFocus(object sender, KeyboardFocusChangedEventArgs e)
+    {
+        if (e.NewFocus is not System.Windows.Controls.TreeViewItem item)
+            return;
+        if (!LibraryPaneFocus.ShouldKeepExistingSelection(
+                fromOutside: !IsInTree(e.OldFocus as DependencyObject),
+                newFocusIsItem: true,
+                newFocusIsSelected: item.IsSelected))
+            return;
+
+        e.Handled = true;
+        if (FolderTreeView.SelectedItem is FolderNodeVm selected
+            && FindTreeViewItem(FolderTreeView, selected) is { } keep)
+            keep.Focus();
+        else
+            FolderTreeView.Focus();
+    }
+
+    private static System.Windows.Controls.TreeViewItem? FindTreeViewItem(
+        System.Windows.Controls.ItemsControl parent, FolderNodeVm node)
+    {
+        if (parent.ItemContainerGenerator.ContainerFromItem(node) is System.Windows.Controls.TreeViewItem match)
+            return match;
+        var count = parent.Items.Count;
+        for (var i = 0; i < count; i++)
+        {
+            if (parent.ItemContainerGenerator.ContainerFromIndex(i) is not System.Windows.Controls.TreeViewItem child)
+                continue;
+            if (FindTreeViewItem(child, node) is { } found)
+                return found;
+        }
+        return null;
+    }
+
+    /// <summary>
+    /// Tabbing into the grid must not change its selection. WPF ListBox focuses
+    /// (and selects) the first tile when focus lands on an unselected container.
+    /// </summary>
+    private void OnGridPreviewGotKeyboardFocus(object sender, KeyboardFocusChangedEventArgs e)
+    {
+        if (e.NewFocus is not System.Windows.Controls.ListBoxItem item)
+            return;
+        if (!LibraryPaneFocus.ShouldKeepExistingSelection(
+                fromOutside: !IsDescendantOf(e.OldFocus as DependencyObject, ItemsList),
+                newFocusIsItem: true,
+                newFocusIsSelected: item.IsSelected))
+            return;
+
+        e.Handled = true;
+        if (ItemsList.SelectedItem is { } selected
+            && ItemsList.ItemContainerGenerator.ContainerFromItem(selected) is System.Windows.Controls.ListBoxItem keep)
+            keep.Focus();
+        else
+            ItemsList.Focus();
+    }
+
     private void OnSearchFocus(object sender, RoutedEventArgs e) => ViewModel?.OpenQuickPicks();
 
     private void OnSearchBlur(object sender, KeyboardFocusChangedEventArgs e)
@@ -787,6 +835,9 @@ private void ZoomWithAnchor(bool zoomIn)
         return (hit as System.Windows.Controls.ListBoxItem)?.DataContext as TileVm;
     }
 
+    /// <summary>Last visual column walked by Up/Down / Page — used when leaving a section header.</summary>
+    private int _lastNavCol;
+
     /// <summary>Explorer-style arrow navigation over the grid, plus Ctrl+C / Ctrl+X on the selection.</summary>
     private void OnGridKeyDown(object sender, KeyEventArgs e)
     {
@@ -830,6 +881,13 @@ private void OnGridKeyDown(object sender, KeyEventArgs e)
             return;
         }
 
+        if (e.Key is Key.PageUp or Key.PageDown)
+        {
+            MoveGridPage(e.Key == Key.PageDown ? +1 : -1);
+            e.Handled = true;
+            return;
+        }
+
         // On a section header, Left/Right collapse/expand it (rather than moving the cursor).
         if (ViewModel.CursorIsHeader && (e.Key == Key.Left || e.Key == Key.Right))
         {
@@ -839,20 +897,29 @@ private void OnGridKeyDown(object sender, KeyEventArgs e)
             return;
         }
 
+        if (e.Key is Key.Up or Key.Down)
+        {
+            // Keyboard focus follows the scroll: if the cursor tile was scrolled out of
+            // view (wheel, scrollbar, Ctrl+End…), re-anchor to a visible tile first so the
+            // arrow doesn't jump back to wherever the cursor used to be.
+            if (!ViewModel.CursorIsHeader && !IsSelectedVisible() && TopVisibleItem() is { } top)
+                ViewModel.SetCursorToItem(top);
+
+            MoveGridVertical(e.Key == Key.Down ? +1 : -1);
+            ItemsList.Focus();
+            e.Handled = true;
+            return;
+        }
+
         var direction = e.Key switch
         {
             Key.Left => "left",
             Key.Right => "right",
-            Key.Up => "up",
-            Key.Down => "down",
             _ => null,
         };
 
         if (direction is not null)
         {
-            // Keyboard focus follows the scroll: if the cursor tile was scrolled out of
-            // view (wheel, scrollbar, Ctrl+End…), re-anchor to a visible tile first so the
-            // arrow doesn't jump back to wherever the cursor used to be.
             if (!ViewModel.CursorIsHeader && !IsSelectedVisible() && TopVisibleItem() is { } top)
                 ViewModel.SetCursorToItem(top);
 
@@ -874,6 +941,266 @@ private void OnGridKeyDown(object sender, KeyEventArgs e)
         }
     }
 
+    /// <summary>
+    /// Same-column Up/Down. Headers are not stops — the next/prev section's tile
+    /// in this column is. Empty cells (short last row) fall back to the nearest
+    /// tile in the column, then the nearest in the row.
+    /// </summary>
+    private void MoveGridVertical(int sign)
+    {
+        if (ViewModel is null || !TryBuildCells(out var cells, out var items))
+            return;
+
+        int? pick;
+        if (ViewModel.CursorIsHeader)
+            pick = PickFromHeader(cells, sign);
+        else if (CurrentCellIndex(items) is { } cur)
+            pick = TileSpatialNavigation.PickVertical(cells, cur, sign);
+        else
+            pick = items.Count > 0 ? 0 : null;
+
+        ApplyTilePick(cells, items, pick, scrollIntoView: true);
+    }
+
+    /// <summary>
+    /// Scroll roughly one viewport, then select the tile in the same column at
+    /// the same screen Y. Not skip-N-items and not a jump onto a section header.
+    /// </summary>
+    private void MoveGridPage(int sign)
+    {
+        if (ViewModel is null)
+            return;
+
+        var sv = GridScroll();
+        var viewH = sv?.ViewportHeight ?? 0;
+        if (viewH <= 0)
+            viewH = Math.Max(ItemsList.ActualHeight, 1);
+
+        if (!TryBuildCells(out var cells, out var items))
+            return;
+
+        var cur = CurrentCellIndex(items);
+        if (cur is null && ViewModel.CursorIsHeader)
+            cur = PickFromHeader(cells, sign);
+        if (cur is null)
+            return;
+
+        var offset = sv?.VerticalOffset ?? 0;
+        var pick = TileSpatialNavigation.PickPage(cells, cur.Value, offset, viewH, sign);
+
+        // Prefer the realized tile's viewport slot so refine survives header-height drift.
+        var (anchorX, anchorViewportY) = ViewportAnchor(items[cur.Value], cells[cur.Value], offset);
+
+        var max = Math.Max(0, (sv?.ExtentHeight ?? 0) - viewH);
+        sv?.ScrollToVerticalOffset(Math.Clamp(offset + sign * viewH, 0, max));
+
+        ApplyTilePick(cells, items, pick, scrollIntoView: false);
+        ItemsList.Focus();
+
+        // After the panel lays out the new page, land on the realized tile in
+        // the same column at the same screen Y (layout Y can drift vs. scroll).
+        Dispatcher.BeginInvoke(
+            new Action(() => RefinePageSelection(anchorX, anchorViewportY)),
+            System.Windows.Threading.DispatcherPriority.Loaded);
+    }
+
+    private (double X, double Y) ViewportAnchor(
+        IGridItem current, TileSpatialNavigation.Cell estimated, double scrollOffset)
+    {
+        var realized = CollectRealizedCells();
+        for (var i = 0; i < realized.Items.Count; i++)
+        {
+            if (ReferenceEquals(realized.Items[i], current))
+                return (realized.Cells[i].CenterX, realized.Cells[i].CenterY);
+        }
+        return (estimated.CenterX, estimated.CenterY - scrollOffset);
+    }
+
+    private void RefinePageSelection(double columnX, double viewportY)
+    {
+        if (ViewModel is null)
+            return;
+        var realized = CollectRealizedCells();
+        if (realized.Cells.Count == 0)
+            return;
+        var pick = TileSpatialNavigation.PickAtColumn(realized.Cells, columnX, viewportY);
+        if (pick is int i)
+            ApplyTilePick(realized.Cells, realized.Items, i, scrollIntoView: false);
+    }
+
+    private int? PickFromHeader(IReadOnlyList<TileSpatialNavigation.Cell> cells, int sign)
+    {
+        if (ViewModel is null || cells.Count == 0)
+            return null;
+
+        var first = ViewModel.FirstVisibleTileIndex(ViewModel.CursorSection);
+        if (sign > 0)
+        {
+            if (first is not int f || f >= cells.Count)
+                return null;
+            return CellInRowNearestColumn(cells, cells[f].Row, _lastNavCol) ?? f;
+        }
+
+        // Up: last row of the previous section, same column, else nearest in that row.
+        if (first is not int start || start <= 0)
+            return null;
+        return CellInRowNearestColumn(cells, cells[start - 1].Row, _lastNavCol) ?? start - 1;
+    }
+
+    private static int? CellInRowNearestColumn(
+        IReadOnlyList<TileSpatialNavigation.Cell> cells, int row, int col)
+    {
+        var rowCells = cells.Where(c => c.Row == row).ToList();
+        if (rowCells.Count == 0)
+            return null;
+        var same = rowCells.FirstOrDefault(c => c.Col == col);
+        if (same.Width > 0)
+            return same.Index;
+        return rowCells.MinBy(c => (Math.Abs(c.Col - col), c.Index)).Index;
+    }
+
+    private void ApplyTilePick(
+        IReadOnlyList<TileSpatialNavigation.Cell> cells,
+        IReadOnlyList<IGridItem> items,
+        int? pick,
+        bool scrollIntoView)
+    {
+        if (ViewModel is null || pick is not int i || i < 0 || i >= items.Count)
+            return;
+        _lastNavCol = cells[i].Col;
+        ViewModel.SetCursorToItem(items[i]);
+        if (scrollIntoView)
+        {
+            try { ItemsList.ScrollIntoView(items[i]); } catch { /* virtualized generator can throw mid-refresh */ }
+        }
+    }
+
+    private bool TryBuildCells(
+        out IReadOnlyList<TileSpatialNavigation.Cell> cells,
+        out IReadOnlyList<IGridItem> items)
+    {
+        cells = [];
+        items = [];
+        if (ViewModel is null)
+            return false;
+
+        var layout = ViewModel.GetVisibleTileLayout();
+        items = layout.Tiles;
+        if (items.Count == 0)
+            return false;
+
+        var columns = VisualColumnCount();
+        var (tileW, tileH) = MeasureTileSize();
+        var headerH = layout.HasHeaders ? MeasureSectionHeaderHeight() : 0;
+        cells = TileSpatialNavigation.LayoutWrap(layout.SectionCounts, columns, tileW, tileH, headerH);
+        return cells.Count > 0;
+    }
+
+    private int? CurrentCellIndex(IReadOnlyList<IGridItem> items)
+    {
+        if (ViewModel?.SelectedItem is not IGridItem sel)
+            return null;
+        for (var i = 0; i < items.Count; i++)
+        {
+            if (ReferenceEquals(items[i], sel))
+                return i;
+        }
+        return null;
+    }
+
+    private (IReadOnlyList<TileSpatialNavigation.Cell> Cells, IReadOnlyList<IGridItem> Items) CollectRealizedCells()
+    {
+        var cells = new List<TileSpatialNavigation.Cell>();
+        var items = new List<IGridItem>();
+        CollectRealizedTileRects(ItemsList, ItemsList, cells, items);
+        return (cells, items);
+    }
+
+    private static void CollectRealizedTileRects(
+        DependencyObject node,
+        UIElement origin,
+        List<TileSpatialNavigation.Cell> cells,
+        List<IGridItem> items)
+    {
+        if (node is System.Windows.Controls.ListBoxItem { IsVisible: true, DataContext: IGridItem item } li)
+        {
+            // Origin is the ListBox: coordinates are viewport-relative (scroll already applied).
+            var tl = li.TranslatePoint(new Point(0, 0), origin);
+            cells.Add(new TileSpatialNavigation.Cell(
+                cells.Count, Row: 0, Col: 0, tl.X, tl.Y, li.ActualWidth, li.ActualHeight));
+            items.Add(item);
+            return;
+        }
+
+        var count = VisualTreeHelper.GetChildrenCount(node);
+        for (var i = 0; i < count; i++)
+            CollectRealizedTileRects(VisualTreeHelper.GetChild(node, i), origin, cells, items);
+    }
+
+    private int VisualColumnCount()
+    {
+        var realized = new List<Rect>();
+        CollectRealizedItemRects(ItemsList, ItemsList, realized);
+        if (realized.Count > 0)
+        {
+            var itemW = realized.Max(r => r.Width);
+            var fitted = (int)((ItemsList.ActualWidth - 12) / Math.Max(1, itemW));
+            var fullestRow = realized
+                .GroupBy(r => Math.Round(r.Y / 8.0) * 8.0)
+                .Select(g => g.Count())
+                .DefaultIfEmpty(1)
+                .Max();
+            return Math.Max(1, Math.Max(fullestRow, fitted));
+        }
+        return ColumnsPerRow();
+    }
+
+    private (double Width, double Height) MeasureTileSize()
+    {
+        var realized = new List<Rect>();
+        CollectRealizedItemRects(ItemsList, ItemsList, realized);
+        if (realized.Count > 0)
+            return (realized[0].Width, realized[0].Height);
+        var outer = (ViewModel?.TileSize ?? 200) + 20;
+        return (outer, outer + 18);
+    }
+
+    private double MeasureSectionHeaderHeight()
+    {
+        var header = FindFirstSectionHeader(ItemsList);
+        if (header is { ActualHeight: > 0 } h)
+            return h.ActualHeight + h.Margin.Top + h.Margin.Bottom;
+        return 44;
+    }
+
+    private static System.Windows.Controls.Primitives.ToggleButton? FindFirstSectionHeader(DependencyObject node)
+    {
+        if (node is System.Windows.Controls.Primitives.ToggleButton header
+            && header.TemplatedParent is System.Windows.Controls.GroupItem)
+            return header;
+
+        var count = VisualTreeHelper.GetChildrenCount(node);
+        for (var i = 0; i < count; i++)
+        {
+            if (FindFirstSectionHeader(VisualTreeHelper.GetChild(node, i)) is { } found)
+                return found;
+        }
+        return null;
+    }
+
+    private static void CollectRealizedItemRects(DependencyObject node, UIElement origin, List<Rect> rects)
+    {
+        if (node is System.Windows.Controls.ListBoxItem { IsVisible: true, DataContext: IGridItem } li)
+        {
+            rects.Add(new Rect(li.TranslatePoint(new Point(0, 0), origin), li.RenderSize));
+            return;
+        }
+
+        var count = VisualTreeHelper.GetChildrenCount(node);
+        for (var i = 0; i < count; i++)
+            CollectRealizedItemRects(VisualTreeHelper.GetChild(node, i), origin, rects);
+    }
+
     /// <summary>Home/End: move the cursor to the first/last stop and scroll the grid to that extreme.</summary>
     private void JumpCursor(bool toEnd)
     {
diff --git a/src/Aperture.App/TileSpatialNavigation.cs b/src/Aperture.App/TileSpatialNavigation.cs
new file mode 100644
index 0000000..a3f0477
--- /dev/null
+++ b/src/Aperture.App/TileSpatialNavigation.cs
@@ -0,0 +1,198 @@
+namespace Aperture.App;
+
+/// <summary>
+/// Explorer-style 2D pick over a wrapping, date-sectioned tile grid.
+/// Operates on layout rectangles so Up/Down / PageUp/PageDown follow
+/// visual columns rather than ListBox item index.
+/// </summary>
+internal static class TileSpatialNavigation
+{
+    internal readonly record struct Cell(
+        int Index,
+        int Row,
+        int Col,
+        double X,
+        double Y,
+        double Width,
+        double Height)
+    {
+        public double CenterX => X + Width / 2;
+        public double CenterY => Y + Height / 2;
+    }
+
+    /// <summary>
+    /// Wrap tiles into a column grid. Each section starts on a new row after an
+    /// optional header gap (headers are not cells — crossing them is fine).
+    /// A zero-count section still consumes <paramref name="headerHeight"/> so
+    /// Page distance matches a collapsed date bucket.
+    /// </summary>
+    public static IReadOnlyList<Cell> LayoutWrap(
+        IReadOnlyList<int> sectionCounts,
+        int columns,
+        double tileWidth,
+        double tileHeight,
+        double headerHeight)
+    {
+        ArgumentNullException.ThrowIfNull(sectionCounts);
+        columns = Math.Max(1, columns);
+        tileWidth = Math.Max(1, tileWidth);
+        tileHeight = Math.Max(1, tileHeight);
+        headerHeight = Math.Max(0, headerHeight);
+
+        var cells = new List<Cell>();
+        var index = 0;
+        var row = 0;
+        var y = 0.0;
+
+        foreach (var count in sectionCounts)
+        {
+            y += headerHeight;
+            if (count <= 0)
+                continue;
+
+            for (var i = 0; i < count; i++)
+            {
+                var col = i % columns;
+                if (i > 0 && col == 0)
+                {
+                    row++;
+                    y += tileHeight;
+                }
+
+                cells.Add(new Cell(index, row, col, col * tileWidth, y, tileWidth, tileHeight));
+                index++;
+            }
+
+            row++;
+            y += tileHeight;
+        }
+
+        return cells;
+    }
+
+    /// <summary>
+    /// One visual row up (<paramref name="sign"/> = -1) or down (+1) in the same
+    /// column. Empty cell (short last row, end of a section): nearest tile in
+    /// that column, then nearest in the adjacent row.
+    /// </summary>
+    public static int? PickVertical(IReadOnlyList<Cell> cells, int currentIndex, int sign)
+    {
+        if (!TryCurrent(cells, currentIndex, out var cur) || sign == 0)
+            return null;
+
+        sign = Math.Sign(sign);
+        var targetRow = cur.Row + sign;
+        var adjacent = cells.Where(c => c.Row == targetRow).ToList();
+
+        if (CellInColumn(adjacent, cur.Col) is { } sameColOnRow)
+            return sameColOnRow.Index;
+
+        var further = cells
+            .Where(c => c.Col == cur.Col && c.Row * sign > cur.Row * sign)
+            .OrderBy(c => Math.Abs(c.Row - cur.Row))
+            .ThenBy(c => c.Index)
+            .FirstOrDefault();
+        if (further.Width > 0)
+            return further.Index;
+
+        if (adjacent.Count > 0)
+            return adjacent.MinBy(c => (Math.Abs(c.Col - cur.Col), c.Index)).Index;
+
+        return null;
+    }
+
+    /// <summary>
+    /// After moving the viewport by one page, pick the tile in the same column
+    /// closest to the same vertical position within the viewport. Not "skip N
+    /// items" and not a jump onto a section header.
+    /// </summary>
+    public static int? PickPage(
+        IReadOnlyList<Cell> cells,
+        int currentIndex,
+        double viewportTop,
+        double viewportHeight,
+        int sign)
+    {
+        if (!TryCurrent(cells, currentIndex, out var cur) || sign == 0)
+            return null;
+
+        sign = Math.Sign(sign);
+        viewportHeight = Math.Max(1, viewportHeight);
+        var yInViewport = cur.CenterY - viewportTop;
+        var newViewportTop = viewportTop + sign * viewportHeight;
+        var targetY = newViewportTop + yInViewport;
+
+        var sameCol = cells
+            .Where(c => c.Col == cur.Col && c.Index != cur.Index)
+            .Where(c => sign > 0 ? c.CenterY > cur.CenterY : c.CenterY < cur.CenterY)
+            .ToList();
+        if (sameCol.Count > 0)
+            return ClosestToY(sameCol, targetY, sign).Index;
+
+        var others = cells
+            .Where(c => c.Index != cur.Index)
+            .Where(c => sign > 0 ? c.CenterY > cur.CenterY : c.CenterY < cur.CenterY)
+            .ToList();
+        if (others.Count == 0)
+            return null;
+
+        var rowY = others.MinBy(c => Math.Abs(c.CenterY - targetY)).CenterY;
+        var slop = Math.Max(cur.Height * 0.5, 1);
+        var row = others.Where(c => Math.Abs(c.CenterY - rowY) <= slop).ToList();
+        return row.MinBy(c => (Math.Abs(c.Col - cur.Col), c.Index)).Index;
+    }
+
+    /// <summary>
+    /// Among laid-out (or realized) cells, pick the same-column cell closest to
+    /// <paramref name="targetY"/>; if that column is empty, the nearest cell on
+    /// the row closest to that Y. Used after a one-viewport scroll to land on
+    /// the same screen slot.
+    /// </summary>
+    public static int? PickAtColumn(IReadOnlyList<Cell> cells, double columnX, double targetY)
+    {
+        if (cells is null || cells.Count == 0)
+            return null;
+
+        var tileW = Math.Max(cells[0].Width, 1);
+        var sameCol = cells.Where(c => Math.Abs(c.CenterX - columnX) <= tileW * 0.5).ToList();
+        if (sameCol.Count > 0)
+            return sameCol.MinBy(c => (Math.Abs(c.CenterY - targetY), c.Index)).Index;
+
+        var rowY = cells.MinBy(c => Math.Abs(c.CenterY - targetY)).CenterY;
+        var slop = Math.Max(cells[0].Height * 0.5, 1);
+        var row = cells.Where(c => Math.Abs(c.CenterY - rowY) <= slop).ToList();
+        return row.MinBy(c => (Math.Abs(c.CenterX - columnX), c.Index)).Index;
+    }
+
+    private static bool TryCurrent(IReadOnlyList<Cell> cells, int currentIndex, out Cell cur)
+    {
+        if (cells is null || currentIndex < 0 || currentIndex >= cells.Count)
+        {
+            cur = default;
+            return false;
+        }
+
+        cur = cells[currentIndex];
+        return true;
+    }
+
+    private static Cell? CellInColumn(List<Cell> row, int col)
+    {
+        foreach (var c in row)
+        {
+            if (c.Col == col)
+                return c;
+        }
+
+        return null;
+    }
+
+    private static Cell ClosestToY(List<Cell> cells, double targetY, int sign) =>
+        cells.MinBy(c =>
+        {
+            var d = Math.Abs(c.CenterY - targetY);
+            // Ties: prefer the cell further in the page direction so we actually move a page.
+            var bias = sign > 0 ? -c.Y : c.Y;
+            return (d, bias, c.Index);
+        });
+}
diff --git a/src/Aperture.App/ViewModels/MainViewModel.cs b/src/Aperture.App/ViewModels/MainViewModel.cs
index 2504671..0d73261 100644
--- a/src/Aperture.App/ViewModels/MainViewModel.cs
+++ b/src/Aperture.App/ViewModels/MainViewModel.cs
@@ -1435,6 +1435,89 @@ private static void PutFileOnClipboard(TileVm? tile, bool cut)
     /// <summary>The section the cursor is on (a header), for scrolling a collapsed title into view.</summary>
     public SectionVm? CursorSection => _cursorSection;
 
+    /// <summary>
+    /// Visible tiles in grid order plus per-section counts (0 for a collapsed
+    /// date bucket). Used by Explorer-style 2D Up/Down and PageUp/PageDown.
+    /// </summary>
+    internal readonly record struct VisibleTileLayout(
+        IReadOnlyList<IGridItem> Tiles,
+        IReadOnlyList<int> SectionCounts,
+        IReadOnlyList<SectionVm?> Sections,
+        bool HasHeaders);
+
+    internal VisibleTileLayout GetVisibleTileLayout()
+    {
+        var tiles = new List<IGridItem>();
+        var counts = new List<int>();
+        var sections = new List<SectionVm?>();
+        var nav = BuildNav();
+        var n = 0;
+        SectionVm? current = null;
+        var seenHeader = false;
+
+        void Flush()
+        {
+            counts.Add(n);
+            sections.Add(current);
+            n = 0;
+        }
+
+        foreach (var s in nav)
+        {
+            if (s.IsHeader)
+            {
+                if (seenHeader || n > 0)
+                    Flush();
+                current = s.Section;
+                seenHeader = true;
+                continue;
+            }
+
+            current = s.Section;
+            tiles.Add(s.Item!);
+            n++;
+        }
+
+        if (seenHeader || n > 0)
+            Flush();
+        else if (tiles.Count > 0)
+        {
+            counts.Add(tiles.Count);
+            sections.Add(tiles[0].Section);
+        }
+
+        return new VisibleTileLayout(tiles, counts, sections, seenHeader);
+    }
+
+    /// <summary>
+    /// First visible-tile index of <paramref name="section"/>, or the first tile
+    /// after it when the section is collapsed. Null when there is no tile past
+    /// that header.
+    /// </summary>
+    internal int? FirstVisibleTileIndex(SectionVm? section)
+    {
+        var layout = GetVisibleTileLayout();
+        if (section is null)
+            return layout.Tiles.Count > 0 ? 0 : null;
+
+        var idx = 0;
+        var seen = false;
+        for (var i = 0; i < layout.SectionCounts.Count; i++)
+        {
+            if (ReferenceEquals(layout.Sections[i], section))
+            {
+                seen = true;
+                if (layout.SectionCounts[i] > 0)
+                    return idx;
+            }
+            else if (seen && layout.SectionCounts[i] > 0)
+                return idx;
+            idx += layout.SectionCounts[i];
+        }
+
+        return seen ? null : (layout.Tiles.Count > 0 ? 0 : null);
+    }
+
     /// <summary>
     /// The linear sequence the keyboard walks: each section's header, then that
     /// section's tiles when it's expanded (collapsed sections contribute only a header).
@@ -1477,7 +1560,11 @@ private int FindCursor(List<NavStop> nav)
         return 0;
     }
 
-    /// <summary>Moves the keyboard cursor. Returns the item/section to scroll into view.</summary>
+    /// <summary>
+    /// Moves the keyboard cursor Left/Right along visual order (including date-section
+    /// headers). Up/Down and PageUp/PageDown are layout-based in the view
+    /// (<c>TileSpatialNavigation</c>) so they stay in column.
+    /// </summary>
     public object? MoveGrid(string direction, int columns)
     {
         var nav = BuildNav();
diff --git a/tests/Aperture.Core.Tests/LibraryPaneFocusTests.cs b/tests/Aperture.Core.Tests/LibraryPaneFocusTests.cs
index 46ac10e..90082cc 100644
--- a/tests/Aperture.Core.Tests/LibraryPaneFocusTests.cs
+++ b/tests/Aperture.Core.Tests/LibraryPaneFocusTests.cs
@@ -9,6 +9,11 @@ namespace Aperture.Core.Tests;
 /// folder in the tree → click empty tile-pane canvas → arrows / PageUp /
 /// PageDown / scroll keys move the grid, not the tree. Clicking a folder,
 /// a tile, a section header, the search box, or a dialog must stay as today.
+///
+/// Tab / Shift+Tab (manual): tree arrows keep the folder; Tab to the grid
+/// keeps the selected tile; Up/Down stay in column; Page is ~one screen
+/// same column; Tab back to the tree keeps the folder; ribbon is never a
+/// Tab stop. Search stays on / and Ctrl+F.
 /// </summary>
 public class LibraryPaneFocusTests
 {
@@ -35,4 +40,19 @@ public void Dialog_DoesNotClaim() =>
     [Fact]
     public void Classify_NullSourceIsCanvas() =>
         Assert.Equal(LibraryPaneFocus.Hit.Canvas, LibraryPaneFocus.Classify(null, null));
+
+    [Fact]
+    public void TabIntoPane_KeepsSelection_WhenFirstItemWouldTakeFocus() =>
+        Assert.True(LibraryPaneFocus.ShouldKeepExistingSelection(
+            fromOutside: true, newFocusIsItem: true, newFocusIsSelected: false));
+
+    [Fact]
+    public void TabIntoPane_AllowsFocusOnAlreadySelectedItem() =>
+        Assert.False(LibraryPaneFocus.ShouldKeepExistingSelection(
+            fromOutside: true, newFocusIsItem: true, newFocusIsSelected: true));
+
+    [Fact]
+    public void ArrowsInsidePane_DoNotRedirect() =>
+        Assert.False(LibraryPaneFocus.ShouldKeepExistingSelection(
+            fromOutside: false, newFocusIsItem: true, newFocusIsSelected: false));
 }
diff --git a/tests/Aperture.Core.Tests/TileSpatialNavigationTests.cs b/tests/Aperture.Core.Tests/TileSpatialNavigationTests.cs
new file mode 100644
index 0000000..70535bd
--- /dev/null
+++ b/tests/Aperture.Core.Tests/TileSpatialNavigationTests.cs
@@ -0,0 +1,165 @@
+using Aperture.App;
+
+namespace Aperture.Core.Tests;
+
+/// <summary>
+/// Explorer-style spatial pick: same visual column, page = one viewport.
+/// Live WPF (realized containers, scroll offset, Tab focus) is a manual path.
+/// </summary>
+public class TileSpatialNavigationTests
+{
+    // 4-column wrap, two date sections: 6 + 8 tiles. Header is a gap, not a cell.
+    //
+    //   [A0 A1 A2 A3]
+    //   [A4 A5      ]
+    //   ---- header ----
+    //   [B0 B1 B2 B3]
+    //   [B4 B5 B6 B7]
+    private static IReadOnlyList<TileSpatialNavigation.Cell> TwoSections() =>
+        TileSpatialNavigation.LayoutWrap([6, 8], columns: 4, tileWidth: 100, tileHeight: 100, headerHeight: 50);
+
+    [Fact]
+    public void Layout_AssignsColumnsAndSkipsHeaders()
+    {
+        var cells = TwoSections();
+        Assert.Equal(14, cells.Count);
+        Assert.Equal(1, cells[5].Col);          // A5
+        Assert.Equal(0, cells[6].Col);          // B0 — new section, col 0
+        Assert.True(cells[6].Y > cells[5].Y);   // header gap between sections
+        Assert.Equal(cells[1].X, cells[7].X);   // A1 and B1 share a column
+    }
+
+    [Fact]
+    public void Down_SameColumn_NextRow()
+    {
+        var cells = TwoSections();
+        // A1 (row 0, col 1) → A5 (row 1, col 1)
+        Assert.Equal(5, TileSpatialNavigation.PickVertical(cells, 1, +1));
+    }
+
+    [Fact]
+    public void Up_SameColumn_PreviousRow()
+    {
+        var cells = TwoSections();
+        Assert.Equal(1, TileSpatialNavigation.PickVertical(cells, 5, -1));
+    }
+
+    [Fact]
+    public void Down_CrossesSectionHeader_SameColumn()
+    {
+        var cells = TwoSections();
+        // A5 (col 1) → B1 (col 1), not a header and not B0
+        Assert.Equal(7, TileSpatialNavigation.PickVertical(cells, 5, +1));
+    }
+
+    [Fact]
+    public void Down_EmptyCell_PrefersSameColumnInNextSection()
+    {
+        var cells = TwoSections();
+        // A3 (col 3) — next row of A is short. Nearest in that column is B3.
+        Assert.Equal(9, TileSpatialNavigation.PickVertical(cells, 3, +1));
+    }
+
+    [Fact]
+    public void Down_EmptyCell_FallsBackToNearestInRow_WhenColumnEnds()
+    {
+        var cells = TileSpatialNavigation.LayoutWrap([6], columns: 4, tileWidth: 100, tileHeight: 100, headerHeight: 0);
+        // A3 (col 3) — no further col-3 tile. Nearest on the short row is A5 (col 1).
+        Assert.Equal(5, TileSpatialNavigation.PickVertical(cells, 3, +1));
+    }
+
+    [Fact]
+    public void Down_IsNotLinearIndexPlusOne()
+    {
+        var cells = TileSpatialNavigation.LayoutWrap([12], columns: 4, tileWidth: 100, tileHeight: 100, headerHeight: 0);
+        // Index 5 is row 1 col 1 → row 2 col 1 is index 9, not 6.
+        Assert.Equal(9, TileSpatialNavigation.PickVertical(cells, 5, +1));
+        Assert.NotEqual(6, TileSpatialNavigation.PickVertical(cells, 5, +1));
+    }
+
+    [Fact]
+    public void Vertical_StaysPut_AtEndOfColumn()
+    {
+        var cells = TwoSections();
+        Assert.Null(TileSpatialNavigation.PickVertical(cells, 13, +1)); // last tile
+        Assert.Null(TileSpatialNavigation.PickVertical(cells, 0, -1));  // first tile
+    }
+
+    [Fact]
+    public void PageDown_OneViewport_SameColumn_SameViewportY()
+    {
+        var cells = TwoSections();
+        // A1 at Y=50 (after header), center 100. Viewport 0..200.
+        // New viewport 200..400; same screen Y → target center 300.
+        // Same column: A1 (100), A5 (200), B1 (350), B5 (450). Closest to 300 is B1.
+        var pick = TileSpatialNavigation.PickPage(cells, currentIndex: 1, viewportTop: 0, viewportHeight: 200, sign: +1);
+        Assert.Equal(7, pick);
+    }
+
+    [Fact]
+    public void PageDown_IsNotSkipNItems()
+    {
+        var cells = TwoSections();
+        // Skip-8-items from A1 would land on B3 (index 9). Same-column page lands on B1 (7).
+        var pick = TileSpatialNavigation.PickPage(cells, currentIndex: 1, viewportTop: 0, viewportHeight: 200, sign: +1);
+        Assert.NotEqual(1 + 8, pick);
+        Assert.Equal(7, pick);
+    }
+
+    [Fact]
+    public void PageDown_DoesNotLandOnAHeader()
+    {
+        var cells = TwoSections();
+        var pick = TileSpatialNavigation.PickPage(cells, currentIndex: 1, viewportTop: 0, viewportHeight: 200, sign: +1);
+        Assert.NotNull(pick);
+        Assert.InRange(pick.Value, 0, cells.Count - 1);
+        // Every returned index is a tile cell — headers were never laid out.
+        Assert.Equal(cells[pick.Value].Col, cells[1].Col);
+    }
+
+    [Fact]
+    public void PageUp_MirrorsPageDown()
+    {
+        var cells = TwoSections();
+        // B1 center 350 in a viewport starting at 200. PageUp → viewport 0,
+        // target center 150. A1 (100) and A5 (200) tie; prefer the page
+        // direction (up) so we actually move a viewport, landing on A1.
+        var pick = TileSpatialNavigation.PickPage(cells, currentIndex: 7, viewportTop: 200, viewportHeight: 200, sign: -1);
+        Assert.Equal(1, pick);
+    }
+
+    [Fact]
+    public void Page_AtEnd_StaysInColumn()
+    {
+        var cells = TwoSections();
+        Assert.Null(TileSpatialNavigation.PickPage(cells, 13, viewportTop: 300, viewportHeight: 200, sign: +1));
+    }
+
+    [Fact]
+    public void PickAtColumn_SameColumnClosestY()
+    {
+        var cells = TwoSections();
+        // Column X of col 1 is 150. Target Y = 350 (B1 center).
+        Assert.Equal(7, TileSpatialNavigation.PickAtColumn(cells, columnX: 150, targetY: 350));
+    }
+
+    [Fact]
+    public void PickAtColumn_EmptyColumn_NearestInRow()
+    {
+        // Realized short last row only (the page after a scroll). Col 3 is empty
+        // on this page, so land on the nearest tile in the row (index 1).
+        var row = TileSpatialNavigation.LayoutWrap([2], columns: 4, tileWidth: 100, tileHeight: 100, headerHeight: 0);
+        Assert.Equal(1, TileSpatialNavigation.PickAtColumn(row, columnX: 350, targetY: 50));
+    }
+
+    [Fact]
+    public void CollapsedSection_ConsumesHeaderGap_ButNoCells()
+    {
+        var cells = TileSpatialNavigation.LayoutWrap([4, 0, 4], columns: 4, tileWidth: 100, tileHeight: 100, headerHeight: 40);
+        Assert.Equal(8, cells.Count);
+        // First tile of the third section sits below two headers + one tile row.
+        Assert.Equal(40 + 100 + 40 + 40, cells[4].Y);
+        // Down from last tile of section 0 (index 1, col 1) crosses the collapsed bucket to col 1 of section 2.
+        Assert.Equal(5, TileSpatialNavigation.PickVertical(cells, 1, +1));
+    }
+}