From a07caadb765a3baf426067837d8438e55cd50e1d Mon Sep 17 00:00:00 2001
From: Yair <39923744+yair100@users.noreply.github.com>
Date: Mon, 11 May 2026 22:56:17 -0400
Subject: [PATCH 1/2] Init tree view

---
 .../Sidebar/FlatSidebarItem.cs                |  46 +++
 .../Sidebar/ISidebarItemModel.cs              |  13 +-
 .../Sidebar/SidebarItem.Properties.cs         |  60 ++-
 src/Files.App.Controls/Sidebar/SidebarItem.cs | 258 +++++++-----
 .../Sidebar/SidebarStyles.xaml                | 245 ++++--------
 .../Sidebar/SidebarView.Properties.cs         |  20 +-
 .../Sidebar/SidebarView.xaml                  |   6 +-
 .../Sidebar/SidebarView.xaml.cs               |  13 +-
 .../Actions/Show/ToggleSidebarAction.cs       |  27 +-
 .../Data/Contracts/IGeneralSettingsService.cs |  35 --
 src/Files.App/Data/Items/DriveItem.cs         |  13 +-
 .../Data/Items/ExpandableSidebarItemBase.cs   | 292 ++++++++++++++
 src/Files.App/Data/Items/FileTagItem.cs       |   2 -
 .../Data/Items/IExpandableSidebarFolder.cs    |  14 +
 src/Files.App/Data/Items/LocationItem.cs      | 177 ++++++++-
 src/Files.App/Data/Items/WslDistroItem.cs     |   2 -
 .../Settings/GeneralSettingsService.cs        |  42 --
 .../Utils/Storage/Helpers/FolderHelpers.cs    |  79 ++++
 .../Settings/SettingsPageViewModel.cs         |   7 +-
 .../UserControls/SidebarViewModel.FlatTree.cs | 376 ++++++++++++++++++
 .../SidebarViewModel.TabExpansion.cs          | 268 +++++++++++++
 .../UserControls/SidebarViewModel.cs          | 179 ++++++---
 src/Files.App/Views/MainPage.xaml             |   6 +-
 src/Files.App/Views/MainPage.xaml.cs          |  27 ++
 .../Views/Settings/SettingsPage.xaml          |   2 +-
 25 files changed, 1744 insertions(+), 465 deletions(-)
 create mode 100644 src/Files.App.Controls/Sidebar/FlatSidebarItem.cs
 create mode 100644 src/Files.App/Data/Items/ExpandableSidebarItemBase.cs
 create mode 100644 src/Files.App/Data/Items/IExpandableSidebarFolder.cs
 create mode 100644 src/Files.App/ViewModels/UserControls/SidebarViewModel.FlatTree.cs
 create mode 100644 src/Files.App/ViewModels/UserControls/SidebarViewModel.TabExpansion.cs

diff --git a/src/Files.App.Controls/Sidebar/FlatSidebarItem.cs b/src/Files.App.Controls/Sidebar/FlatSidebarItem.cs
new file mode 100644
index 000000000000..3183ce30a205
--- /dev/null
+++ b/src/Files.App.Controls/Sidebar/FlatSidebarItem.cs
@@ -0,0 +1,46 @@
+// Copyright (c) Files Community
+// Licensed under the MIT License.
+
+namespace Files.App.Controls
+{
+	/// <summary>
+	/// Per-row wrapper used by the sidebar's virtualized ItemsRepeater. Carries the row's tree depth and section-gap flags so the underlying data items don't have to.
+	/// </summary>
+	public sealed class FlatSidebarItem : INotifyPropertyChanged
+	{
+		public ISidebarItemModel Item { get; }
+
+		public int Depth { get; }
+
+		// Caller-supplied at construction; hidden filesystem items are dimmed to match the file list's dimming convention.
+		public double RowOpacity { get; }
+
+		private static readonly PropertyChangedEventArgs SectionGapMarginChangedArgs = new(nameof(SectionGapMargin));
+
+		private bool _hasExpandedPredecessor;
+		public bool HasExpandedPredecessor
+		{
+			get => _hasExpandedPredecessor;
+			set
+			{
+				if (_hasExpandedPredecessor == value)
+					return;
+				_hasExpandedPredecessor = value;
+				PropertyChanged?.Invoke(this, SectionGapMarginChangedArgs);
+			}
+		}
+
+		public Thickness SectionGapMargin => _hasExpandedPredecessor
+			? new Thickness(0, 12, 0, 0)
+			: new Thickness(0);
+
+		public event PropertyChangedEventHandler? PropertyChanged;
+
+		public FlatSidebarItem(ISidebarItemModel item, int depth, double rowOpacity = 1.0)
+		{
+			Item = item;
+			Depth = depth;
+			RowOpacity = rowOpacity;
+		}
+	}
+}
diff --git a/src/Files.App.Controls/Sidebar/ISidebarItemModel.cs b/src/Files.App.Controls/Sidebar/ISidebarItemModel.cs
index 9e6791014aa7..eedd91e8f4d1 100644
--- a/src/Files.App.Controls/Sidebar/ISidebarItemModel.cs
+++ b/src/Files.App.Controls/Sidebar/ISidebarItemModel.cs
@@ -17,13 +17,18 @@ public interface ISidebarItemModel : INotifyPropertyChanged
 		bool IsExpanded { get; set; }
 
 		/// <summary>
-		/// Indicates whether the children should have an indentation or not.
+		/// Optional path associated with this sidebar item for drag/drop scenarios.
 		/// </summary>
-		bool PaddedItem { get; }
+		string? Path { get; }
 
 		/// <summary>
-		/// Optional path associated with this sidebar item for drag/drop scenarios.
+		/// Renders as expandable even when Children is empty (children load lazily on first expansion).
 		/// </summary>
-		string? Path { get; }
+		bool HasUnrealizedChildren => false;
+
+		/// <summary>
+		/// Expansion participant that keeps the regular row appearance (icon + normal text) instead of the section-header style.
+		/// </summary>
+		bool IsLeafWithChildren => false;
 	}
 }
diff --git a/src/Files.App.Controls/Sidebar/SidebarItem.Properties.cs b/src/Files.App.Controls/Sidebar/SidebarItem.Properties.cs
index 6b502408dac0..6d6565235a6a 100644
--- a/src/Files.App.Controls/Sidebar/SidebarItem.Properties.cs
+++ b/src/Files.App.Controls/Sidebar/SidebarItem.Properties.cs
@@ -13,7 +13,14 @@ public SidebarView? Owner
 			set { SetValue(OwnerProperty, value); }
 		}
 		public static readonly DependencyProperty OwnerProperty =
-			DependencyProperty.Register(nameof(Owner), typeof(SidebarView), typeof(SidebarItem), new PropertyMetadata(null));
+			DependencyProperty.Register(nameof(Owner), typeof(SidebarView), typeof(SidebarItem), new PropertyMetadata(null, OnOwnerChanged));
+
+		// Owner is assigned by the hosting ItemsRepeater's ElementPrepared (top-level rows) or by the parent row (flyout children) — recycled containers can carry a stale Owner across realizations, so the chevron-column visual state must re-apply whenever Owner flips.
+		private static void OnOwnerChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+		{
+			if (d is SidebarItem item && item.Owner is { } owner)
+				VisualStateManager.GoToState(item, owner.SupportsExpansion ? "OwnerSupportsExpansion" : "OwnerDoesNotSupportExpansion", false);
+		}
 
 		public bool IsSelected
 		{
@@ -31,6 +38,37 @@ public bool IsExpanded
 		public static readonly DependencyProperty IsExpandedProperty =
 			DependencyProperty.Register(nameof(IsExpanded), typeof(bool), typeof(SidebarItem), new PropertyMetadata(true, OnPropertyChanged));
 
+		public int NestingLevel
+		{
+			get { return (int)GetValue(NestingLevelProperty); }
+			set { SetValue(NestingLevelProperty, value); }
+		}
+		public static readonly DependencyProperty NestingLevelProperty =
+			DependencyProperty.Register(nameof(NestingLevel), typeof(int), typeof(SidebarItem), new PropertyMetadata(0, OnNestingLevelChanged));
+
+		public double IndentWidth
+		{
+			get { return (double)GetValue(IndentWidthProperty); }
+			set { SetValue(IndentWidthProperty, value); }
+		}
+		public static readonly DependencyProperty IndentWidthProperty =
+			DependencyProperty.Register(nameof(IndentWidth), typeof(double), typeof(SidebarItem), new PropertyMetadata(0d));
+
+		private static void OnNestingLevelChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+		{
+			if (d is SidebarItem item && e.NewValue is int level)
+				item.IndentWidth = level * 16d;
+		}
+
+		// Dims icon + text + chevron + decorator only; the selection indicator and pointer-over fill stay at full opacity so a selected hidden row still reads as selected.
+		public double ContentOpacity
+		{
+			get { return (double)GetValue(ContentOpacityProperty); }
+			set { SetValue(ContentOpacityProperty, value); }
+		}
+		public static readonly DependencyProperty ContentOpacityProperty =
+			DependencyProperty.Register(nameof(ContentOpacity), typeof(double), typeof(SidebarItem), new PropertyMetadata(1.0));
+
 		public bool IsInFlyout
 		{
 			get { return (bool)GetValue(IsInFlyoutProperty); }
@@ -39,15 +77,6 @@ public bool IsInFlyout
 		public static readonly DependencyProperty IsInFlyoutProperty =
 			DependencyProperty.Register(nameof(IsInFlyout), typeof(bool), typeof(SidebarItem), new PropertyMetadata(false));
 
-		public double ChildrenPresenterHeight
-		{
-			get { return (double)GetValue(ChildrenPresenterHeightProperty); }
-			set { SetValue(ChildrenPresenterHeightProperty, value); }
-		}
-		// Using 30 as a default in case something goes wrong
-		public static readonly DependencyProperty ChildrenPresenterHeightProperty =
-			DependencyProperty.Register(nameof(ChildrenPresenterHeight), typeof(double), typeof(SidebarItem), new PropertyMetadata(30d));
-
 		public ISidebarItemModel? Item
 		{
 			get { return (ISidebarItemModel)GetValue(ItemProperty); }
@@ -94,17 +123,6 @@ public SidebarDisplayMode DisplayMode
 		[GeneratedDependencyProperty]
 		public partial object? ToolTip { get; set; }
 
-		public static void SetTemplateRoot(DependencyObject target, FrameworkElement value)
-		{
-			target.SetValue(TemplateRootProperty, value);
-		}
-		public static FrameworkElement GetTemplateRoot(DependencyObject target)
-		{
-			return (FrameworkElement)target.GetValue(TemplateRootProperty);
-		}
-		public static readonly DependencyProperty TemplateRootProperty =
-			DependencyProperty.Register("TemplateRoot", typeof(FrameworkElement), typeof(SidebarItem), new PropertyMetadata(null));
-
 		public static void OnPropertyChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
 		{
 			if (sender is not SidebarItem item) return;
diff --git a/src/Files.App.Controls/Sidebar/SidebarItem.cs b/src/Files.App.Controls/Sidebar/SidebarItem.cs
index 9ac319ab1aff..4edd80550dc5 100644
--- a/src/Files.App.Controls/Sidebar/SidebarItem.cs
+++ b/src/Files.App.Controls/Sidebar/SidebarItem.cs
@@ -16,7 +16,7 @@ public sealed partial class SidebarItem : Control
 	{
 		private const double DROP_REPOSITION_THRESHOLD = 0.2; // Percentage of top/bottom at which we consider a drop to be a reposition/insertion
 
-		public bool HasChildren => Item?.Children is IList enumerable && enumerable.Count > 0;
+		public bool HasChildren => (Item?.Children is IList enumerable && enumerable.Count > 0) || (Item?.HasUnrealizedChildren ?? false);
 		public bool IsGroupHeader => Item?.Children is not null;
 		public bool CollapseEnabled => DisplayMode != SidebarDisplayMode.Compact;
 
@@ -24,8 +24,10 @@ public sealed partial class SidebarItem : Control
 		private bool isPointerOver = false;
 		private bool isClicking = false;
 		private object? selectedChildItem = null;
-		private ItemsRepeater? childrenRepeater;
 		private ISidebarItemModel? lastSubscriber;
+		// Owner DisplayMode callback runs once per container, gated by isWiredUp. Template-child handlers (ElementBorder pointer events etc.) run once per template application, gated by isTemplateWired — they can't share the gate because Loaded can fire on a Visibility=Collapsed container before OnApplyTemplate has supplied any template children to hook up.
+		private bool isWiredUp;
+		private bool isTemplateWired;
 
 		public SidebarItem()
 		{
@@ -34,10 +36,20 @@ public SidebarItem()
 			PointerReleased += Item_PointerReleased;
 			KeyDown += (sender, args) =>
 			{
-				if (args.Key == Windows.System.VirtualKey.Enter)
+				switch (args.Key)
 				{
-					Clicked(PointerUpdateKind.Other);
-					args.Handled = true;
+					case Windows.System.VirtualKey.Enter:
+						Clicked(PointerUpdateKind.Other);
+						args.Handled = true;
+						break;
+					case Windows.System.VirtualKey.Right when HasChildren && CollapseEnabled && !IsExpanded:
+						IsExpanded = true;
+						args.Handled = true;
+						break;
+					case Windows.System.VirtualKey.Left when HasChildren && CollapseEnabled && IsExpanded:
+						IsExpanded = false;
+						args.Handled = true;
+						break;
 				}
 			};
 			DragStarting += SidebarItem_DragStarting;
@@ -50,6 +62,43 @@ protected override AutomationPeer OnCreateAutomationPeer()
 			return new SidebarItemAutomationPeer(this);
 		}
 
+		// Template-tied work needs to run *here* (not in Loaded) because Loaded can fire while the control is still not measured; template parts may not exist yet. Sub-rows realized later would otherwise keep isWiredUp=true with no handlers attached.
+		protected override void OnApplyTemplate()
+		{
+			base.OnApplyTemplate();
+
+			if (!isTemplateWired)
+			{
+				isTemplateWired = true;
+				if (GetTemplateChild("ElementBorder") is Border border)
+				{
+					border.PointerEntered += ItemBorder_PointerEntered;
+					border.PointerExited += ItemBorder_PointerExited;
+					border.PointerCanceled += ItemBorder_PointerCanceled;
+					border.PointerPressed += ItemBorder_PointerPressed;
+					border.ContextRequested += ItemBorder_ContextRequested;
+					border.DoubleTapped += ItemBorder_DoubleTapped;
+					border.DragLeave += ItemBorder_DragLeave;
+					border.DragOver += ItemBorder_DragOver;
+					border.Drop += ItemBorder_Drop;
+					border.AllowDrop = true;
+					border.IsTabStop = false;
+				}
+				if (GetTemplateChild("ChevronContainer") is Border chevronContainer)
+					chevronContainer.PointerPressed += ChevronContainer_PointerPressed;
+				if (GetTemplateChild("FlyoutChildrenPresenter") is ItemsRepeater flyoutRepeater)
+					flyoutRepeater.ElementPrepared += FlyoutChildrenPresenter_ElementPrepared;
+			}
+
+			if (Owner is null)
+				return;
+			VisualStateManager.GoToState(this, Owner.SupportsExpansion ? "OwnerSupportsExpansion" : "OwnerDoesNotSupportExpansion", false);
+			// Flyout items inherit DisplayMode=Compact from the parent SidebarView but render full-size inside the overlay; they must NOT enter the Compact visual state or their text gets hidden. This matches the !IsInFlyout guard in SidebarDisplayModeChanged.
+			if (!IsInFlyout)
+				VisualStateManager.GoToState(this, DisplayMode == SidebarDisplayMode.Compact ? "Compact" : "NonCompact", false);
+			UpdateExpansionState();
+		}
+
 		internal void Select()
 		{
 			if (Owner is not null)
@@ -58,32 +107,14 @@ internal void Select()
 
 		private void SidebarItem_Loaded(object sender, RoutedEventArgs e)
 		{
-			HookupOwners();
-
-			if (GetTemplateChild("ElementBorder") is Border border)
+			// Loaded fires every time ItemsRepeater recycles the container; only the per-row HandleItemChange runs each time.
+			if (!isWiredUp)
 			{
-				border.PointerEntered += ItemBorder_PointerEntered;
-				border.PointerExited += ItemBorder_PointerExited;
-				border.PointerCanceled += ItemBorder_PointerCanceled;
-				border.PointerPressed += ItemBorder_PointerPressed;
-				border.ContextRequested += ItemBorder_ContextRequested;
-				border.DragLeave += ItemBorder_DragLeave;
-				border.DragOver += ItemBorder_DragOver;
-				border.Drop += ItemBorder_Drop;
-				border.AllowDrop = true;
-				border.IsTabStop = false;
+				HookupOwners();
+				// HookupOwners can leave Owner null for static SidebarItems whose FindAscendant walk fires before they're parented into a SidebarView (rare). Leave isWiredUp=false so the next Loaded retries.
+				if (Owner is not null)
+					isWiredUp = true;
 			}
-
-			if (GetTemplateChild("ChildrenPresenter") is ItemsRepeater repeater)
-			{
-				childrenRepeater = repeater;
-				repeater.ElementPrepared += ChildrenPresenter_ElementPrepared;
-			}
-			if (GetTemplateChild("FlyoutChildrenPresenter") is ItemsRepeater flyoutRepeater)
-			{
-				flyoutRepeater.ElementPrepared += ChildrenPresenter_ElementPrepared;
-			}
-
 			HandleItemChange();
 		}
 
@@ -97,24 +128,26 @@ public void HandleItemChange()
 
 		private void HookupOwners()
 		{
-			FrameworkElement resolvingTarget = this;
-			if (GetTemplateRoot(Parent) is FrameworkElement element)
-			{
-				resolvingTarget = element;
-			}
-			Owner = resolvingTarget.FindAscendant<SidebarView>()!;
+			// Owner is pushed in by the hosting SidebarView's MenuItemsHost_ElementPrepared (top-level rows) or the parent SidebarItem's FlyoutChildrenPresenter_ElementPrepared (flyout children) before Loaded fires. Static SidebarItems declared directly in XAML (MainPage's SettingsButton in SidebarView.Footer) aren't realized through either path, so resolve Owner via a visual-tree walk for them. OwnerExpansionSupport state is applied by OnOwnerChanged.
+			if (Owner is null)
+				Owner = this.FindAscendant<SidebarView>();
+			if (Owner is null)
+				return;
 
 			Owner.RegisterPropertyChangedCallback(SidebarView.DisplayModeProperty, (sender, args) =>
 			{
 				DisplayMode = Owner.DisplayMode;
 			});
 			DisplayMode = Owner.DisplayMode;
+			// Setting the DP above only fires SidebarDisplayModeChanged (which calls GoToState) when the value actually changes from the default — sub-rows realized after Compact→Expanded never trigger it because both default and new value are Expanded. Force the state transition. Flyout items are skipped (same as in SidebarDisplayModeChanged) so they don't enter Compact and hide their text.
+			if (!IsInFlyout)
+				VisualStateManager.GoToState(this, DisplayMode == SidebarDisplayMode.Compact ? "Compact" : "NonCompact", false);
 
+			// Static SidebarItems (MainPage's SettingsButton inside SidebarView.Footer) sit outside MenuItemsHost, so SidebarView.OnSelectedItemChanged's broadcast can't reach them. The per-row callback fills that gap.
 			Owner.RegisterPropertyChangedCallback(SidebarView.SelectedItemProperty, (sender, args) =>
 			{
 				ReevaluateSelection();
 			});
-			ReevaluateSelection();
 		}
 
 		private void HookupItemChangeListener(ISidebarItemModel? oldItem, ISidebarItemModel? newItem)
@@ -123,18 +156,34 @@ private void HookupItemChangeListener(ISidebarItemModel? oldItem, ISidebarItemMo
 			{
 				if (lastSubscriber.Children is INotifyCollectionChanged observableCollection)
 					observableCollection.CollectionChanged -= ChildItems_CollectionChanged;
+				lastSubscriber.PropertyChanged -= Item_PropertyChanged;
 			}
 
 			if (oldItem != null)
 			{
 				if (oldItem.Children is INotifyCollectionChanged observableCollection)
 					observableCollection.CollectionChanged -= ChildItems_CollectionChanged;
+				oldItem.PropertyChanged -= Item_PropertyChanged;
 			}
 			if (newItem != null)
 			{
 				lastSubscriber = newItem;
 				if (newItem.Children is INotifyCollectionChanged observableCollection)
 					observableCollection.CollectionChanged += ChildItems_CollectionChanged;
+				newItem.PropertyChanged += Item_PropertyChanged;
+			}
+		}
+
+		private void Item_PropertyChanged(object? sender, PropertyChangedEventArgs e)
+		{
+			switch (e.PropertyName)
+			{
+				case nameof(ISidebarItemModel.HasUnrealizedChildren):
+				case nameof(ISidebarItemModel.IsLeafWithChildren):
+				case nameof(ISidebarItemModel.Children):
+					UpdateExpansionState();
+					ReevaluateSelection();
+					break;
 			}
 		}
 
@@ -171,14 +220,19 @@ private void SetFlyoutOpen(bool isOpen = true)
 			if (Item?.Children is null) return;
 
 			var flyoutOwner = (GetTemplateChild("ElementGrid") as FrameworkElement)!;
-			if (isOpen)
-			{
-				FlyoutBase.ShowAttachedFlyout(flyoutOwner);
-			}
-			else
+			try
 			{
-				FlyoutBase.GetAttachedFlyout(flyoutOwner).Hide();
+				if (isOpen)
+				{
+					FlyoutBase.ShowAttachedFlyout(flyoutOwner);
+				}
+				else
+				{
+					FlyoutBase.GetAttachedFlyout(flyoutOwner).Hide();
+				}
 			}
+			// ArgumentException when GetAttachedFlyout/ShowAttachedFlyout runs before the template is applied (e.g. DisplayMode toggled via ToggleSidebarAction at startup, before all containers have realized).
+			catch (ArgumentException) { }
 		}
 
 		private void ChildItems_CollectionChanged(object? sender, System.Collections.Specialized.NotifyCollectionChangedEventArgs e)
@@ -191,54 +245,57 @@ private void ChildItems_CollectionChanged(object? sender, System.Collections.Spe
 			}
 		}
 
+		// Entry point for SidebarView's SelectedItem PropertyChangedCallback to broadcast selection changes to every realized row, bypassing the per-row RegisterPropertyChangedCallback (which only attaches after Loaded).
+		internal void ReevaluateSelectionFromOwner() => ReevaluateSelection();
+
 		private void ReevaluateSelection()
 		{
-			if (!IsGroupHeader)
+			// Leaves-with-children (tree-view folder rows) can be selected themselves as well as host a selected descendant.
+			var isLeafWithChildren = Item?.IsLeafWithChildren == true;
+			var selected = Owner?.SelectedItem;
+			if (!IsGroupHeader || isLeafWithChildren)
 			{
-				IsSelected = Item == Owner?.SelectedItem;
+				// Item-null guard avoids the null==null match that paints cleared/recycled containers as selected when SelectedItem is also null (e.g. after collapsing the section that held the active path).
+				IsSelected = Item is not null && Item == selected;
 				if (IsSelected)
 				{
 					Owner?.UpdateSelectedItemContainer(this);
 				}
 			}
-			else if (Item?.Children is IList list)
+			else
 			{
-				if (list.Contains(Owner?.SelectedItem))
-				{
-					selectedChildItem = Owner?.SelectedItem;
-					SetFlyoutOpen(false);
-				}
-				else
-				{
-					selectedChildItem = null;
-				}
-				UpdateSelectionState();
+				// Recycled container previously bound to a selected leaf carries IsSelected=true into its new section-header binding; left unset, the header paints selected alongside the actual selected row after Compact↔overlay flips rebuild the flat list.
+				IsSelected = false;
 			}
+			if (IsGroupHeader && Item?.Children is IList list && selected is not null && list.Contains(selected))
+			{
+				selectedChildItem = selected;
+				SetFlyoutOpen(false);
+			}
+			else
+			{
+				selectedChildItem = null;
+			}
+			UpdateSelectionState();
 		}
 
-		private void ChildrenPresenter_ElementPrepared(ItemsRepeater sender, ItemsRepeaterElementPreparedEventArgs args)
+		// Flyout items live outside the flat list and need their selection state mirrored here so the realized row matches what the inline row would render.
+		private void FlyoutChildrenPresenter_ElementPrepared(ItemsRepeater sender, ItemsRepeaterElementPreparedEventArgs args)
 		{
-			if (args.Element is SidebarItem item)
+			if (args.Element is SidebarItem item && Item?.Children is IList enumerable)
 			{
-				if (Item?.Children is IList enumerable)
-				{
-					var newElement = enumerable[args.Index];
-					if (newElement == selectedChildItem)
-					{
-						(args.Element as SidebarItem)!.IsSelected = true;
-					}
-					else
-					{
-						(args.Element as SidebarItem)!.IsSelected = false;
-					}
-					item.HandleItemChange();
-				}
+				// Inherit the owning SidebarView so the flyout row's click routes to the correct view's RaiseItemInvoked instead of falling through to a FindAscendant walk that — inside a popup-hosted ItemsRepeater — can resolve to the wrong SidebarView entirely.
+				item.Owner = Owner;
+				var newElement = enumerable[args.Index];
+				item.IsSelected = newElement == selectedChildItem;
+				item.HandleItemChange();
 			}
 		}
 
 		internal void Clicked(PointerUpdateKind pointerUpdateKind)
 		{
-			if (IsGroupHeader)
+			// Section headers (Pinned, Drives, ...) toggle expansion on row click since they have no navigation target. Tree-view folder rows (leaves-with-children) only navigate — their expansion is reserved for the chevron click target.
+			if (IsGroupHeader && Item?.IsLeafWithChildren != true)
 			{
 				if (CollapseEnabled)
 				{
@@ -252,6 +309,21 @@ internal void Clicked(PointerUpdateKind pointerUpdateKind)
 			RaiseItemInvoked(pointerUpdateKind);
 		}
 
+		// Chevron press: suppress the bubbling press; otherwise ElementBorder treats the chevron click as a row click and raises ItemInvoked.
+		private void ChevronContainer_PointerPressed(object sender, Microsoft.UI.Xaml.Input.PointerRoutedEventArgs e)
+			=> e.Handled = TryToggleExpansion();
+
+		private void ItemBorder_DoubleTapped(object sender, Microsoft.UI.Xaml.Input.DoubleTappedRoutedEventArgs e)
+			=> e.Handled = TryToggleExpansion();
+
+		private bool TryToggleExpansion()
+		{
+			if (!HasChildren || !CollapseEnabled)
+				return false;
+			IsExpanded = !IsExpanded;
+			return true;
+		}
+
 		internal void RaiseItemInvoked(PointerUpdateKind pointerUpdateKind)
 		{
 			Owner?.RaiseItemInvoked(this, pointerUpdateKind);
@@ -259,32 +331,32 @@ internal void RaiseItemInvoked(PointerUpdateKind pointerUpdateKind)
 
 		private void SidebarDisplayModeChanged(SidebarDisplayMode oldValue)
 		{
-			var useAnimations = oldValue != SidebarDisplayMode.Minimal;
 			switch (DisplayMode)
 			{
 				case SidebarDisplayMode.Expanded:
-					UpdateExpansionState(useAnimations);
+					UpdateExpansionState();
 					UpdateSelectionState();
 					SetFlyoutOpen(false);
 					break;
 				case SidebarDisplayMode.Minimal:
-					UpdateExpansionState(useAnimations);
+					UpdateExpansionState();
 					SetFlyoutOpen(false);
 					break;
 				case SidebarDisplayMode.Compact:
-					UpdateExpansionState(useAnimations);
+					UpdateExpansionState();
 					UpdateSelectionState();
 					break;
 			}
 			if (!IsInFlyout)
 			{
-				VisualStateManager.GoToState(this, DisplayMode == SidebarDisplayMode.Compact ? "Compact" : "NonCompact", true);
+				VisualStateManager.GoToState(this, DisplayMode == SidebarDisplayMode.Compact ? "Compact" : "NonCompact", false);
 			}
 		}
 
 		private void UpdateSelectionState()
 		{
-			VisualStateManager.GoToState(this, ShouldShowSelectionIndicator() ? "Selected" : "Unselected", true);
+			// Containers re-bind constantly during fast scroll; play state changes without transitions so no implicit animations fire on each ItemsRepeater realization.
+			VisualStateManager.GoToState(this, ShouldShowSelectionIndicator() ? "Selected" : "Unselected", false);
 			UpdatePointerState();
 		}
 
@@ -305,40 +377,40 @@ private void UpdatePointerState(bool isPointerDown = false)
 			var useSelectedState = ShouldShowSelectionIndicator();
 			if (isPointerDown)
 			{
-				VisualStateManager.GoToState(this, useSelectedState ? "PressedSelected" : "Pressed", true);
+				VisualStateManager.GoToState(this, useSelectedState ? "PressedSelected" : "Pressed", false);
 			}
 			else if (isPointerOver)
 			{
-				VisualStateManager.GoToState(this, useSelectedState ? "PointerOverSelected" : "PointerOver", true);
+				VisualStateManager.GoToState(this, useSelectedState ? "PointerOverSelected" : "PointerOver", false);
 			}
 			else
 			{
-				VisualStateManager.GoToState(this, useSelectedState ? "NormalSelected" : "Normal", true);
+				VisualStateManager.GoToState(this, useSelectedState ? "NormalSelected" : "Normal", false);
 			}
 		}
 
-		private void UpdateExpansionState(bool useAnimations = true)
+		private void UpdateExpansionState()
 		{
+			if (Owner?.SupportsExpansion == false)
+			{
+				VisualStateManager.GoToState(this, "NoExpansion", false);
+				UpdateSelectionState();
+				return;
+			}
+
 			if (Item?.Children is null || !CollapseEnabled)
 			{
-				VisualStateManager.GoToState(this, Item?.PaddedItem == true ? "NoExpansionWithPadding" : "NoExpansion", useAnimations);
+				VisualStateManager.GoToState(this, "NoExpansion", false);
 			}
 			else if (!HasChildren)
 			{
-				VisualStateManager.GoToState(this, "NoChildren", useAnimations);
+				// Empty folder leaves render like normal leaves; empty group headers keep the section-heading style.
+				VisualStateManager.GoToState(this, Item?.IsLeafWithChildren == true ? "NoExpansion" : "NoChildren", false);
 			}
 			else
 			{
-				if (Item?.Children is IList enumerable && enumerable.Count > 0 && childrenRepeater is not null)
-				{
-					var firstChild = childrenRepeater.GetOrCreateElement(0);
-
-					// Collapsed elements might have a desired size of 0 so we need to have a sensible fallback
-					var childHeight = firstChild.DesiredSize.Height > 0 ? firstChild.DesiredSize.Height : 32;
-					ChildrenPresenterHeight = enumerable.Count * childHeight;
-				}
-				VisualStateManager.GoToState(this, IsExpanded ? "Expanded" : "Collapsed", useAnimations);
-				VisualStateManager.GoToState(this, IsExpanded ? "ExpandedIconNormal" : "CollapsedIconNormal", useAnimations);
+				VisualStateManager.GoToState(this, Item?.IsLeafWithChildren == true ? "LeafWithChildren" : (IsExpanded ? "Expanded" : "Collapsed"), false);
+				VisualStateManager.GoToState(this, IsExpanded ? "ExpandedIconNormal" : "CollapsedIconNormal", false);
 			}
 			UpdateSelectionState();
 		}
diff --git a/src/Files.App.Controls/Sidebar/SidebarStyles.xaml b/src/Files.App.Controls/Sidebar/SidebarStyles.xaml
index a51d65ef1ac2..7f5dd3738777 100644
--- a/src/Files.App.Controls/Sidebar/SidebarStyles.xaml
+++ b/src/Files.App.Controls/Sidebar/SidebarStyles.xaml
@@ -38,13 +38,16 @@
 
 	<DataTemplate x:Key="DefaultSidebarItemTemplate">
 		<local:SidebarItem
-			AutomationProperties.AutomationId="{Binding Text}"
-			Decorator="{Binding ItemDecorator}"
-			Icon="{Binding IconElement}"
-			IsExpanded="{Binding IsExpanded, Mode=TwoWay}"
-			Item="{Binding}"
-			Text="{Binding Text}"
-			ToolTip="{Binding ToolTip}" />
+			AutomationProperties.AutomationId="{Binding Item.Text}"
+			ContentOpacity="{Binding RowOpacity}"
+			Decorator="{Binding Item.ItemDecorator}"
+			Icon="{Binding Item.IconElement}"
+			IsExpanded="{Binding Item.IsExpanded, Mode=TwoWay}"
+			Item="{Binding Item}"
+			Margin="{Binding SectionGapMargin}"
+			NestingLevel="{Binding Depth}"
+			Text="{Binding Item.Text}"
+			ToolTip="{Binding Item.ToolTip}" />
 	</DataTemplate>
 
 	<Style TargetType="local:SidebarItem">
@@ -93,6 +96,10 @@
 								<Grid.ColumnDefinitions>
 									<!--  Selection Indicator  -->
 									<ColumnDefinition Width="3" />
+									<!--  Tree-view depth indent (content-only; row background still spans full width)  -->
+									<ColumnDefinition Width="Auto" />
+									<!--  Chevron. Fixed 16px so expandable and non-expandable rows stay aligned; the OwnerDoesNotSupportExpansion and Compact visual states collapse it to 0 when the chevron isn't applicable.  -->
+									<ColumnDefinition x:Name="ChevronColumnDefinition" Width="16" />
 									<!--  Icon  -->
 									<ColumnDefinition Width="Auto" />
 									<!--  Text  -->
@@ -115,28 +122,64 @@
 									RadiusX="2"
 									RadiusY="2" />
 
+								<!--  Depth indent spacer (width = NestingLevel * 16)  -->
+								<Border
+									Grid.Column="1"
+									Width="{TemplateBinding IndentWidth}" />
+
+								<!--  Own pointer surface so chevron clicks only toggle expansion (no row invoke / selection).  -->
+								<Border
+									x:Name="ChevronContainer"
+									Grid.Column="2"
+									HorizontalAlignment="Stretch"
+									VerticalAlignment="Stretch"
+									Background="Transparent"
+									Opacity="{TemplateBinding ContentOpacity}">
+									<!--  Chevron (rotates from right → down on expand).  -->
+									<FontIcon
+										x:Name="ExpandCollapseChevron"
+										Width="12"
+										Height="12"
+										HorizontalAlignment="Center"
+										VerticalAlignment="Center"
+										AutomationProperties.AccessibilityView="Raw"
+										FontFamily="{StaticResource SymbolThemeFontFamily}"
+										FontSize="10"
+										Foreground="{ThemeResource TextFillColorSecondaryBrush}"
+										Glyph="&#xE76C;"
+										IsTextScaleFactorEnabled="False"
+										RenderTransformOrigin="0.5,0.5"
+										Visibility="Collapsed">
+										<FontIcon.RenderTransform>
+											<RotateTransform x:Name="ExpandCollapseChevronRotateTransform" Angle="0" />
+										</FontIcon.RenderTransform>
+									</FontIcon>
+								</Border>
+
 								<!--  Icon  -->
 								<ContentPresenter
 									x:Name="IconPresenter"
-									Grid.Column="1"
+									Grid.Column="3"
 									Width="16"
 									Height="16"
-									Margin="8,0,0,0"
+									Margin="4,0,0,0"
 									HorizontalAlignment="Center"
 									VerticalAlignment="Center"
 									AutomationProperties.AccessibilityView="Raw"
-									Content="{TemplateBinding Icon}" />
+									Content="{TemplateBinding Icon}"
+									Opacity="{TemplateBinding ContentOpacity}" />
 
 								<!--  Text  -->
 								<TextBlock
 									x:Name="ItemNameTextBlock"
-									Grid.Column="2"
+									Grid.Column="4"
 									Margin="12,0,12,2"
 									HorizontalAlignment="Stretch"
 									VerticalAlignment="Center"
 									AutomationProperties.AccessibilityView="Raw"
 									FontFamily="{ThemeResource ContentControlThemeFontFamily}"
 									LineHeight="16"
+									Opacity="{TemplateBinding ContentOpacity}"
 									Text="{TemplateBinding Text}"
 									TextTrimming="CharacterEllipsis"
 									TextWrapping="NoWrap" />
@@ -144,42 +187,16 @@
 								<!--  Decorator  -->
 								<ContentPresenter
 									x:Name="ItemDecoratorPresenter"
-									Grid.Column="3"
+									Grid.Column="5"
 									Width="28"
 									Margin="0"
 									HorizontalContentAlignment="Center"
 									VerticalContentAlignment="Center"
 									BorderThickness="0"
 									Content="{TemplateBinding Decorator}"
+									Opacity="{TemplateBinding ContentOpacity}"
 									Visibility="Collapsed" />
 
-								<!--  Chevron  -->
-								<AnimatedIcon
-									x:Name="ExpandCollapseChevron"
-									Grid.Column="3"
-									Width="{StaticResource ExpanderChevronGlyphSize}"
-									Height="{StaticResource ExpanderChevronGlyphSize}"
-									Margin="0,0,8,0"
-									HorizontalAlignment="Center"
-									VerticalAlignment="Center"
-									AnimatedIcon.State="NormalOff"
-									AutomationProperties.AccessibilityView="Raw"
-									Foreground="{ThemeResource TextFillColorSecondaryBrush}"
-									RenderTransformOrigin="0.5, 0.5"
-									Visibility="Collapsed">
-									<animatedvisuals:AnimatedChevronUpDownSmallVisualSource />
-									<AnimatedIcon.FallbackIconSource>
-										<FontIconSource
-											FontFamily="{StaticResource SymbolThemeFontFamily}"
-											FontSize="12"
-											Glyph="{StaticResource ExpanderChevronDownGlyph}"
-											IsTextScaleFactorEnabled="False" />
-									</AnimatedIcon.FallbackIconSource>
-									<AnimatedIcon.RenderTransform>
-										<RotateTransform x:Name="ExpandCollapseChevronRotateTransform" Angle="0" />
-									</AnimatedIcon.RenderTransform>
-								</AnimatedIcon>
-
 								<!--  Overflow  -->
 								<FlyoutBase.AttachedFlyout>
 									<Flyout x:Name="ChildrenFlyout" Placement="Right">
@@ -193,9 +210,8 @@
 										<ItemsRepeater
 											x:Name="FlyoutChildrenPresenter"
 											HorizontalAlignment="Stretch"
-											local:SidebarItem.TemplateRoot="{Binding ElementName=RootPanel}"
 											AutomationProperties.AccessibilityView="Content"
-											ItemsSource="{Binding Children, Mode=OneWay}"
+											ItemsSource="{Binding Item.Children, Mode=OneWay}"
 											XYFocusKeyboardNavigation="Enabled">
 											<ItemsRepeater.ItemTemplate>
 												<DataTemplate>
@@ -216,23 +232,6 @@
 							</Grid>
 						</Border>
 
-						<!--  Children  -->
-						<ItemsRepeater
-							x:Name="ChildrenPresenter"
-							Grid.Row="2"
-							Margin="-4,2"
-							HorizontalAlignment="Stretch"
-							local:SidebarItem.TemplateRoot="{Binding ElementName=RootPanel}"
-							AutomationProperties.AccessibilityView="Content"
-							ItemTemplate="{StaticResource DefaultSidebarItemTemplate}"
-							ItemsSource="{Binding Children, Mode=OneWay}"
-							Visibility="Collapsed"
-							XYFocusKeyboardNavigation="Enabled">
-							<ItemsRepeater.Layout>
-								<StackLayout />
-							</ItemsRepeater.Layout>
-						</ItemsRepeater>
-
 						<VisualStateManager.VisualStateGroups>
 
 							<VisualStateGroup x:Name="ExpansionStates">
@@ -243,16 +242,8 @@
 									</VisualState.Setters>
 								</VisualState>
 
-								<VisualState x:Name="NoExpansionWithPadding">
-									<VisualState.Setters>
-										<Setter Target="RootPanel.Margin" Value="0,0,0,12" />
-										<Setter Target="ItemDecoratorPresenter.Visibility" Value="Visible" />
-									</VisualState.Setters>
-								</VisualState>
-
 								<VisualState x:Name="NoChildren">
 									<VisualState.Setters>
-										<Setter Target="IconPresenter.Visibility" Value="Collapsed" />
 										<Setter Target="ItemNameTextBlock.Margin" Value="8,0,12,0" />
 										<Setter Target="ItemNameTextBlock.FontSize" Value="12" />
 										<Setter Target="ItemNameTextBlock.FontWeight" Value="SemiBold" />
@@ -262,9 +253,6 @@
 
 								<VisualState x:Name="Expanded">
 									<VisualState.Setters>
-										<Setter Target="RootPanel.Margin" Value="0,0,0,12" />
-										<Setter Target="ChildrenPresenter.Visibility" Value="Visible" />
-										<Setter Target="IconPresenter.Visibility" Value="Collapsed" />
 										<Setter Target="ExpandCollapseChevron.Visibility" Value="Visible" />
 										<Setter Target="ItemNameTextBlock.Margin" Value="8,0,12,0" />
 										<Setter Target="ItemNameTextBlock.FontSize" Value="12" />
@@ -275,7 +263,6 @@
 
 								<VisualState x:Name="Collapsed">
 									<VisualState.Setters>
-										<Setter Target="IconPresenter.Visibility" Value="Collapsed" />
 										<Setter Target="ExpandCollapseChevron.Visibility" Value="Visible" />
 										<Setter Target="ItemNameTextBlock.Margin" Value="8,0,12,0" />
 										<Setter Target="ItemNameTextBlock.FontSize" Value="12" />
@@ -284,118 +271,33 @@
 									</VisualState.Setters>
 								</VisualState>
 
-								<VisualStateGroup.Transitions>
-									<VisualTransition From="Collapsed" To="Expanded">
-										<Storyboard>
-											<ObjectAnimationUsingKeyFrames Storyboard.TargetName="ChildrenPresenter" Storyboard.TargetProperty="Visibility">
-												<DiscreteObjectKeyFrame Value="Visible" />
-											</ObjectAnimationUsingKeyFrames>
-											<DoubleAnimationUsingKeyFrames
-												EnableDependentAnimation="True"
-												Storyboard.TargetName="ChildrenPresenter"
-												Storyboard.TargetProperty="MaxHeight">
-												<DiscreteDoubleKeyFrame KeyTime="0:0:0" Value="0" />
-												<SplineDoubleKeyFrame
-													KeySpline="0.1,0.9 0.2,1.0"
-													KeyTime="0:0:0.35"
-													Value="{Binding ChildrenPresenterHeight, RelativeSource={RelativeSource TemplatedParent}, Mode=OneWay}" />
-											</DoubleAnimationUsingKeyFrames>
-											<ObjectAnimationUsingKeyFrames Storyboard.TargetName="RootPanel" Storyboard.TargetProperty="Margin">
-												<DiscreteObjectKeyFrame Value="0,0,0,12" />
-											</ObjectAnimationUsingKeyFrames>
-										</Storyboard>
-									</VisualTransition>
-
-									<VisualTransition From="Expanded">
-										<Storyboard>
-											<ObjectAnimationUsingKeyFrames Storyboard.TargetName="ChildrenPresenter" Storyboard.TargetProperty="Visibility">
-												<DiscreteObjectKeyFrame Value="Visible" />
-											</ObjectAnimationUsingKeyFrames>
-											<DoubleAnimationUsingKeyFrames
-												EnableDependentAnimation="True"
-												Storyboard.TargetName="ChildrenPresenter"
-												Storyboard.TargetProperty="MaxHeight">
-												<DiscreteDoubleKeyFrame KeyTime="0:0:0" Value="{Binding ChildrenPresenterHeight, RelativeSource={RelativeSource TemplatedParent}, Mode=OneWay}" />
-												<SplineDoubleKeyFrame
-													KeySpline="0.1,0.9 0.2,1.0"
-													KeyTime="0:0:0.35"
-													Value="0" />
-											</DoubleAnimationUsingKeyFrames>
-										</Storyboard>
-									</VisualTransition>
-
-									<VisualTransition From="NoExpansion" To="Expanded">
-										<Storyboard>
-											<ObjectAnimationUsingKeyFrames Storyboard.TargetName="ChildrenPresenter" Storyboard.TargetProperty="Visibility">
-												<DiscreteObjectKeyFrame Value="Visible" />
-											</ObjectAnimationUsingKeyFrames>
-											<DoubleAnimationUsingKeyFrames
-												EnableDependentAnimation="True"
-												Storyboard.TargetName="ChildrenPresenter"
-												Storyboard.TargetProperty="MaxHeight">
-												<DiscreteDoubleKeyFrame KeyTime="0:0:0" Value="0" />
-												<SplineDoubleKeyFrame
-													KeySpline="0.1,0.9 0.2,1.0"
-													KeyTime="0:0:0.35"
-													Value="{Binding ChildrenPresenterHeight, RelativeSource={RelativeSource TemplatedParent}, Mode=OneWay}" />
-											</DoubleAnimationUsingKeyFrames>
-											<ObjectAnimationUsingKeyFrames Storyboard.TargetName="IconPresenter" Storyboard.TargetProperty="Visibility">
-												<DiscreteObjectKeyFrame Value="Collapsed" />
-											</ObjectAnimationUsingKeyFrames>
-											<ObjectAnimationUsingKeyFrames Storyboard.TargetName="ExpandCollapseChevron" Storyboard.TargetProperty="Visibility">
-												<DiscreteObjectKeyFrame Value="Visible" />
-											</ObjectAnimationUsingKeyFrames>
-											<ObjectAnimationUsingKeyFrames Storyboard.TargetName="ItemNameTextBlock" Storyboard.TargetProperty="Margin">
-												<DiscreteObjectKeyFrame Value="8,0,12,0" />
-											</ObjectAnimationUsingKeyFrames>
-											<ObjectAnimationUsingKeyFrames Storyboard.TargetName="ItemNameTextBlock" Storyboard.TargetProperty="FontWeight">
-												<DiscreteObjectKeyFrame Value="Semibold" />
-											</ObjectAnimationUsingKeyFrames>
-											<ObjectAnimationUsingKeyFrames Storyboard.TargetName="ItemNameTextBlock" Storyboard.TargetProperty="Foreground">
-												<DiscreteObjectKeyFrame Value="{ThemeResource TextFillColorTertiaryBrush}" />
-											</ObjectAnimationUsingKeyFrames>
-										</Storyboard>
-									</VisualTransition>
-
-									<VisualTransition From="NoExpansion" To="Compact">
-										<Storyboard>
-											<ObjectAnimationUsingKeyFrames Storyboard.TargetName="ChildrenPresenter" Storyboard.TargetProperty="Visibility">
-												<DiscreteObjectKeyFrame Value="Visible" />
-											</ObjectAnimationUsingKeyFrames>
-											<DoubleAnimationUsingKeyFrames
-												EnableDependentAnimation="True"
-												Storyboard.TargetName="ChildrenPresenter"
-												Storyboard.TargetProperty="MaxHeight">
-												<DiscreteDoubleKeyFrame KeyTime="0:0:0" Value="0" />
-												<SplineDoubleKeyFrame
-													KeySpline="0.1,0.9 0.2,1.0"
-													KeyTime="0:0:0.35"
-													Value="{Binding ChildrenPresenterHeight, RelativeSource={RelativeSource TemplatedParent}, Mode=OneWay}" />
-											</DoubleAnimationUsingKeyFrames>
-										</Storyboard>
-									</VisualTransition>
-								</VisualStateGroup.Transitions>
+								<!--  Tree-view folder rows: chevron toggle but keep regular item styling (icon visible, normal text). Children render in the outer flat list, not nested.  -->
+								<VisualState x:Name="LeafWithChildren">
+									<VisualState.Setters>
+										<Setter Target="ExpandCollapseChevron.Visibility" Value="Visible" />
+									</VisualState.Setters>
+								</VisualState>
 							</VisualStateGroup>
 
 							<VisualStateGroup x:Name="ExpansionIconStates">
 								<VisualState x:Name="ExpandedIconNormal">
 									<VisualState.Setters>
-										<Setter Target="ExpandCollapseChevron.(AnimatedIcon.State)" Value="NormalOn" />
+										<Setter Target="ExpandCollapseChevronRotateTransform.Angle" Value="90" />
 									</VisualState.Setters>
 								</VisualState>
 								<VisualState x:Name="ExpandedIconPressed">
 									<VisualState.Setters>
-										<Setter Target="ExpandCollapseChevron.(AnimatedIcon.State)" Value="PressedOn" />
+										<Setter Target="ExpandCollapseChevronRotateTransform.Angle" Value="90" />
 									</VisualState.Setters>
 								</VisualState>
 								<VisualState x:Name="CollapsedIconNormal">
 									<VisualState.Setters>
-										<Setter Target="ExpandCollapseChevron.(AnimatedIcon.State)" Value="NormalOff" />
+										<Setter Target="ExpandCollapseChevronRotateTransform.Angle" Value="0" />
 									</VisualState.Setters>
 								</VisualState>
 								<VisualState x:Name="CollapsedIconPressed">
 									<VisualState.Setters>
-										<Setter Target="ExpandCollapseChevron.(AnimatedIcon.State)" Value="PressedOff" />
+										<Setter Target="ExpandCollapseChevronRotateTransform.Angle" Value="0" />
 									</VisualState.Setters>
 								</VisualState>
 							</VisualStateGroup>
@@ -472,6 +374,19 @@
 										<Setter Target="RootPanel.MaxWidth" Value="48" />
 										<Setter Target="ItemNameTextBlock.Visibility" Value="Collapsed" />
 										<Setter Target="ItemDecoratorPresenter.Width" Value="0" />
+										<Setter Target="ChevronColumnDefinition.Width" Value="0" />
+										<Setter Target="IconPresenter.Margin" Value="8,0,0,0" />
+									</VisualState.Setters>
+								</VisualState>
+							</VisualStateGroup>
+
+							<!--  Owner-level toggle. Separate from per-row ExpansionStates so a leaf inside a tree (which is NoExpansion) still reserves the 16px chevron column for alignment with expandable siblings, while a Settings-style sidebar (SupportsExpansion=false) collapses it for every row.  -->
+							<VisualStateGroup x:Name="OwnerExpansionSupport">
+								<VisualState x:Name="OwnerSupportsExpansion" />
+								<VisualState x:Name="OwnerDoesNotSupportExpansion">
+									<VisualState.Setters>
+										<Setter Target="ChevronColumnDefinition.Width" Value="0" />
+										<Setter Target="IconPresenter.Margin" Value="8,0,0,0" />
 									</VisualState.Setters>
 								</VisualState>
 							</VisualStateGroup>
diff --git a/src/Files.App.Controls/Sidebar/SidebarView.Properties.cs b/src/Files.App.Controls/Sidebar/SidebarView.Properties.cs
index fafca7b10309..1b554ffc5e21 100644
--- a/src/Files.App.Controls/Sidebar/SidebarView.Properties.cs
+++ b/src/Files.App.Controls/Sidebar/SidebarView.Properties.cs
@@ -98,7 +98,22 @@ public ISidebarItemModel SelectedItem
 			}
 		}
 		public static readonly DependencyProperty SelectedItemProperty =
-			DependencyProperty.Register(nameof(SelectedItem), typeof(ISidebarItemModel), typeof(SidebarView), new PropertyMetadata(null));
+			DependencyProperty.Register(nameof(SelectedItem), typeof(ISidebarItemModel), typeof(SidebarView), new PropertyMetadata(null, OnSelectedItemChanged));
+
+		// Broadcasts SelectedItem changes to every realized row in MenuItemsHost instead of relying on each row's own RegisterPropertyChangedCallback. The per-row callback only registers after Loaded fires, so a row prepared but not yet loaded (or unloaded then re-loaded mid-recycle) can otherwise miss a SelectedItem change and keep its stale IsSelected — visible as multiple "selected" rows.
+		private static void OnSelectedItemChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+		{
+			if (d is not SidebarView view || view.MenuItemsHost is null)
+				return;
+			for (int i = 0; ; i++)
+			{
+				var element = view.MenuItemsHost.TryGetElement(i);
+				if (element is null)
+					break;
+				if (element is SidebarItem sidebarItem)
+					sidebarItem.ReevaluateSelectionFromOwner();
+			}
+		}
 
 		public object MenuItemsSource
 		{
@@ -108,6 +123,9 @@ public object MenuItemsSource
 		public static readonly DependencyProperty MenuItemsSourceProperty =
 			DependencyProperty.Register(nameof(MenuItemsSource), typeof(object), typeof(SidebarView), new PropertyMetadata(null));
 
+		// Off by default; flat-list sidebars (Settings) collapse the chevron column. Opt in for hierarchical sidebars (main tree view).
+		public bool SupportsExpansion { get; set; }
+
 		public static void OnPropertyChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
 		{
 			if (sender is not SidebarView control) return;
diff --git a/src/Files.App.Controls/Sidebar/SidebarView.xaml b/src/Files.App.Controls/Sidebar/SidebarView.xaml
index 6592aaf9a9e3..251a8bf0a74b 100644
--- a/src/Files.App.Controls/Sidebar/SidebarView.xaml
+++ b/src/Files.App.Controls/Sidebar/SidebarView.xaml
@@ -85,7 +85,8 @@
 					x:Name="MenuItemHostScrollViewer"
 					Padding="0,8,0,0"
 					ContextRequested="MenuItemHostScrollViewer_ContextRequested"
-					HorizontalScrollMode="Disabled"
+					HorizontalScrollBarVisibility="Visible"
+					HorizontalScrollMode="Enabled"
 					VerticalScrollBarVisibility="Auto"
 					XYFocusKeyboardNavigation="Enabled">
 					<ItemsRepeater
@@ -97,7 +98,6 @@
 						IsTabStop="True"
 						ItemTemplate="{StaticResource DefaultSidebarItemTemplate}"
 						ItemsSource="{x:Bind MenuItemsSource, Mode=OneWay}"
-						VerticalCacheLength="100"
 						XYFocusKeyboardNavigation="Enabled" />
 				</ScrollViewer>
 			</ItemsRepeaterScrollHost>
@@ -161,6 +161,8 @@
 				<VisualState x:Name="Compact">
 					<VisualState.Setters>
 						<Setter Target="PaneColumnDefinition.Width" Value="{StaticResource SidebarCompactOpenPaneLength}" />
+						<Setter Target="MenuItemHostScrollViewer.HorizontalScrollMode" Value="Disabled" />
+						<Setter Target="MenuItemHostScrollViewer.HorizontalScrollBarVisibility" Value="Disabled" />
 					</VisualState.Setters>
 				</VisualState>
 				<VisualState x:Name="MinimalCollapsed">
diff --git a/src/Files.App.Controls/Sidebar/SidebarView.xaml.cs b/src/Files.App.Controls/Sidebar/SidebarView.xaml.cs
index 76ca326d5ab8..7fdbfb613397 100644
--- a/src/Files.App.Controls/Sidebar/SidebarView.xaml.cs
+++ b/src/Files.App.Controls/Sidebar/SidebarView.xaml.cs
@@ -36,8 +36,8 @@ internal void UpdateSelectedItemContainer(SidebarItem container)
 
 		internal void RaiseItemInvoked(SidebarItem item, PointerUpdateKind pointerUpdateKind)
 		{
-			// Only leaves can be selected
-			if (item.Item is null || item.IsGroupHeader) return;
+			// Only true group headers (e.g. Pinned, Drives) suppress selection; leaves-with-children (tree-view folder rows) navigate AND get selected.
+			if (item.Item is null || (item.IsGroupHeader && item.Item.IsLeafWithChildren != true)) return;
 
 			SelectedItem = item.Item;
 			ItemInvoked?.Invoke(item, new(pointerUpdateKind));
@@ -136,6 +136,13 @@ private void SidebarView_Loaded(object sender, RoutedEventArgs e)
 			PaneColumnGrid.Translation = new System.Numerics.Vector3(0, 0, 32);
 		}
 
+		public double VerticalScrollOffset => MenuItemHostScrollViewer?.VerticalOffset ?? 0;
+
+		public void ScrollToVerticalOffset(double offset)
+		{
+			MenuItemHostScrollViewer?.ChangeView(null, offset, null, true);
+		}
+
 		private void SidebarResizer_ManipulationStarted(object sender, ManipulationStartedRoutedEventArgs e)
 		{
 			if (!CanResizePane)
@@ -268,6 +275,8 @@ private void MenuItemsHost_ElementPrepared(ItemsRepeater sender, ItemsRepeaterEl
 		{
 			if (args.Element is SidebarItem sidebarItem)
 			{
+				// Assign Owner from the hosting SidebarView rather than letting the row's HookupOwners FindAscendant walk resolve it: that walk picks up the WRONG SidebarView when this view is the nested SettingsSidebar inside SidebarControl.InnerContent (and a stale Owner from a prior realization can persist across container recycling). Owner drives both the click-routing target and the chevron-column visual state.
+				sidebarItem.Owner = this;
 				sidebarItem.HandleItemChange();
 			}
 		}
diff --git a/src/Files.App/Actions/Show/ToggleSidebarAction.cs b/src/Files.App/Actions/Show/ToggleSidebarAction.cs
index d81dd8751059..c2d0b6dd2851 100644
--- a/src/Files.App/Actions/Show/ToggleSidebarAction.cs
+++ b/src/Files.App/Actions/Show/ToggleSidebarAction.cs
@@ -11,6 +11,21 @@ internal sealed partial class ToggleSidebarAction : ObservableObject, IToggleAct
 	{
 		private IAppearanceSettingsService AppearanceSettingsService { get; } = Ioc.Default.GetRequiredService<IAppearanceSettingsService>();
 
+		// SidebarViewModel is registered in DI later than ToggleSidebarAction is constructed; resolve it lazily on first access so startup doesn't throw.
+		private SidebarViewModel? sidebarViewModel;
+		private SidebarViewModel SidebarViewModel
+		{
+			get
+			{
+				if (sidebarViewModel is null)
+				{
+					sidebarViewModel = Ioc.Default.GetRequiredService<SidebarViewModel>();
+					sidebarViewModel.PropertyChanged += SidebarViewModel_PropertyChanged;
+				}
+				return sidebarViewModel;
+			}
+		}
+
 		public string Label
 			=> Strings.ToggleSidebar.GetLocalizedResource();
 
@@ -26,6 +41,9 @@ public HotKey HotKey
 		public bool IsOn
 			=> AppearanceSettingsService.IsSidebarOpen;
 
+		public bool IsExecutable
+			=> SidebarViewModel.ActualDisplayMode != SidebarDisplayMode.Minimal;
+
 		public ToggleSidebarAction()
 		{
 			AppearanceSettingsService.PropertyChanged += AppearanceSettingsService_PropertyChanged;
@@ -33,8 +51,7 @@ public ToggleSidebarAction()
 
 		public Task ExecuteAsync(object? parameter = null)
 		{
-			var sidebarViewModel = Ioc.Default.GetRequiredService<SidebarViewModel>();
-			sidebarViewModel.SidebarDisplayMode = IsOn
+			SidebarViewModel.SidebarDisplayMode = IsOn
 				? SidebarDisplayMode.Compact
 				: SidebarDisplayMode.Expanded;
 
@@ -46,5 +63,11 @@ private void AppearanceSettingsService_PropertyChanged(object? sender, PropertyC
 			if (e.PropertyName is nameof(AppearanceSettingsService.IsSidebarOpen))
 				OnPropertyChanged(nameof(IsOn));
 		}
+
+		private void SidebarViewModel_PropertyChanged(object? sender, PropertyChangedEventArgs e)
+		{
+			if (e.PropertyName is nameof(SidebarViewModel.ActualDisplayMode))
+				OnPropertyChanged(nameof(IsExecutable));
+		}
 	}
 }
diff --git a/src/Files.App/Data/Contracts/IGeneralSettingsService.cs b/src/Files.App/Data/Contracts/IGeneralSettingsService.cs
index 6540eb042dcc..2c60203f60e6 100644
--- a/src/Files.App/Data/Contracts/IGeneralSettingsService.cs
+++ b/src/Files.App/Data/Contracts/IGeneralSettingsService.cs
@@ -130,71 +130,36 @@ public interface IGeneralSettingsService : IBaseSettingsService, INotifyProperty
 		/// </summary>
 		bool ShowPinnedSection { get; set; }
 
-		/// <summary>
-		/// Gets or sets a value indicating if the favorites section should be expanded.
-		/// </summary>
-		bool IsPinnedSectionExpanded { get; set; }
-
 		/// <summary>
 		/// Gets or sets a value indicating if the library section should be visible.
 		/// </summary>
 		bool ShowLibrarySection { get; set; }
 
-		/// <summary>
-		/// Gets or sets a value indicating if the library section should be expanded.
-		/// </summary>
-		bool IsLibrarySectionExpanded { get; set; }
-
 		/// <summary>
 		/// Gets or sets a value indicating if the drive section should be visible.
 		/// </summary>
 		bool ShowDrivesSection { get; set; }
 
-		/// <summary>
-		/// Gets or sets a value indicating if the drive section should be expanded.
-		/// </summary>
-		bool IsDriveSectionExpanded { get; set; }
-
 		/// <summary>
 		/// Gets or sets a value indicating if the cloud drive section should be visible.
 		/// </summary>
 		bool ShowCloudDrivesSection { get; set; }
 
-		/// <summary>
-		/// Gets or sets a value indicating if the cloud drive section should be expanded.
-		/// </summary>
-		bool IsCloudDriveSectionExpanded { get; set; }
-
 		/// <summary>
 		/// Gets or sets a value indicating if the network section should be visible.
 		/// </summary>
 		bool ShowNetworkSection { get; set; }
 
-		/// <summary>
-		/// Gets or sets a value indicating if the network section should be expanded.
-		/// </summary>
-		bool IsNetworkSectionExpanded { get; set; }
-
 		/// <summary>
 		/// Gets or sets a value indicating if the wsl section should be visible.
 		/// </summary>
 		bool ShowWslSection { get; set; }
 
-		/// <summary>
-		/// Gets or sets a value indicating if the wsl section should be expanded.
-		/// </summary>
-		bool IsWslSectionExpanded { get; set; }
-
 		/// <summary>
 		/// Gets or sets a value indicating if the tags section should be visible.
 		/// </summary>
 		bool ShowFileTagsSection { get; set; }
 
-		/// <summary>
-		/// Gets or sets a value indicating if the file tags section should be expanded.
-		/// </summary>
-		bool IsFileTagsSectionExpanded { get; set; }
-
 		/// <summary>
 		/// Gets or sets a value indicating whether or not to move shell extensions into a sub menu.
 		/// </summary>
diff --git a/src/Files.App/Data/Items/DriveItem.cs b/src/Files.App/Data/Items/DriveItem.cs
index c569c528fd37..0b6b73c4041a 100644
--- a/src/Files.App/Data/Items/DriveItem.cs
+++ b/src/Files.App/Data/Items/DriveItem.cs
@@ -12,7 +12,7 @@
 
 namespace Files.App.Data.Items
 {
-	public sealed partial class DriveItem : ObservableObject, INavigationControlItem, IFolder
+	public sealed partial class DriveItem : ExpandableSidebarItemBase, INavigationControlItem, IFolder, IExpandableSidebarFolder
 	{
 		private BitmapImage icon;
 		public BitmapImage Icon
@@ -178,7 +178,12 @@ public bool ShowStorageSense
 
 		public string Id => Path;
 		public string Name => Root.DisplayName;
-		public object? Children => null;
+
+		public object? Children => IsExpandableFolder ? (childItems ??= []) : null;
+		private BulkConcurrentObservableCollection<INavigationControlItem>? childItems;
+
+		protected override string ExpansionPath => path;
+		protected override BulkConcurrentObservableCollection<INavigationControlItem> EnsureChildItems() => childItems ??= [];
 
 		private object toolTip = "";
 		public object ToolTip
@@ -190,8 +195,6 @@ public object ToolTip
 			}
 		}
 
-		public bool IsExpanded { get => false; set { } }
-
 		public IconElement? IconElement
 		{
 			get
@@ -227,8 +230,6 @@ public FrameworkElement? ItemDecorator
 			}
 		}
 
-		public bool PaddedItem => false;
-
 		private void ItemDecorator_Click(object sender, RoutedEventArgs e)
 		{
 			DriveHelpers.EjectDeviceAsync(Path);
diff --git a/src/Files.App/Data/Items/ExpandableSidebarItemBase.cs b/src/Files.App/Data/Items/ExpandableSidebarItemBase.cs
new file mode 100644
index 000000000000..481927d113f7
--- /dev/null
+++ b/src/Files.App/Data/Items/ExpandableSidebarItemBase.cs
@@ -0,0 +1,292 @@
+// Copyright (c) Files Community
+// Licensed under the MIT License.
+
+using Files.App.Controls;
+using Microsoft.Extensions.Logging;
+using Microsoft.UI.Dispatching;
+using Microsoft.UI.Xaml.Media.Imaging;
+using System.IO;
+
+namespace Files.App.Data.Items
+{
+	/// <summary>
+	/// Shared expansion plumbing for tree-view-style sidebar items (LocationItem, DriveItem).
+	/// Stores IsExpandableFolder / HasUnrealizedChildren / IsExpanded and runs the async lazy
+	/// subfolder load on first expansion. Subclasses provide the path + child collection via
+	/// abstract members and keep their own Children getter (Home / non-expandable cases vary).
+	/// </summary>
+	public abstract partial class ExpandableSidebarItemBase : ObservableObject
+	{
+		protected abstract string ExpansionPath { get; }
+		protected abstract BulkConcurrentObservableCollection<INavigationControlItem> EnsureChildItems();
+
+		private bool isExpandableFolder;
+		public bool IsExpandableFolder
+		{
+			get => isExpandableFolder;
+			set
+			{
+				if (SetProperty(ref isExpandableFolder, value))
+				{
+					OnPropertyChanged(nameof(ISidebarItemModel.Children));
+					OnPropertyChanged(nameof(IsLeafWithChildren));
+					// Tab-state restoration may have flipped IsExpanded before expandability was known — drive the lazy load now.
+					if (value && isExpanded && !childrenLoaded && !childrenLoading)
+						_ = LoadSubfoldersAsync();
+				}
+			}
+		}
+
+		private bool hasUnrealizedChildren;
+		public bool HasUnrealizedChildren
+		{
+			get => hasUnrealizedChildren;
+			set => SetProperty(ref hasUnrealizedChildren, value);
+		}
+
+		public bool IsLeafWithChildren => IsExpandableFolder;
+
+		private bool childrenLoaded;
+		private bool childrenLoading;
+
+		private bool isExpanded;
+		public bool IsExpanded
+		{
+			get => isExpanded;
+			set
+			{
+				if (!SetProperty(ref isExpanded, value))
+					return;
+
+				if (value)
+				{
+					if (IsExpandableFolder && !childrenLoaded && !childrenLoading)
+					{
+						_ = LoadSubfoldersAsync();
+					}
+					else if (childrenLoaded)
+					{
+						// Re-expanded after a collapse: watcher was stopped, so do a single catch-up resync (bypassing the debounce) to pick up any changes that happened while invisible, then resume live watching.
+						StartWatchingSubfolders();
+						_ = ResyncSubfoldersAsync();
+					}
+				}
+				else
+				{
+					// Children aren't in the flat tree while collapsed; StopWatchingSubfolders disposes the watcher + debounce timer and cancels any in-flight resync via the generation counter.
+					StopWatchingSubfolders();
+				}
+			}
+		}
+
+		public async Task LoadSubfoldersAsync()
+		{
+			if (childrenLoaded || childrenLoading)
+				return;
+			childrenLoading = true;
+			try
+			{
+				await LocationItem.LoadSubfoldersIntoAsync(ExpansionPath, EnsureChildItems(), () =>
+				{
+					HasUnrealizedChildren = false;
+					childrenLoaded = true;
+					StartWatchingSubfolders();
+				});
+			}
+			finally
+			{
+				childrenLoading = false;
+			}
+		}
+
+		public bool IsLoaded => childrenLoaded;
+
+		// Wipes the cached child collection and (if still expanded) re-runs LoadSubfoldersAsync so the next enumeration picks up the latest IUserSettingsService.FoldersSettingsService filter flags. The tab-expansion tracker re-expands matching descendants as they get re-added, so deep subtrees fan back out without an explicit walk.
+		public async Task ReloadSubfoldersAsync()
+		{
+			if (!childrenLoaded)
+				return;
+			StopWatchingSubfoldersAndDescendants();
+			EnsureChildItems().Clear();
+			childrenLoaded = false;
+			if (IsExpanded && IsExpandableFolder)
+				await LoadSubfoldersAsync();
+		}
+
+		#region Subfolder watcher
+
+		// Generous debounce: the sidebar tree is a navigation aid, not a real-time mirror; waiting a few seconds before resyncing coalesces bursts (extract / clone / build) into a single enumeration.
+		private static readonly TimeSpan ResyncDebounce = TimeSpan.FromSeconds(3);
+
+		private FileSystemWatcher? subfolderWatcher;
+		private DispatcherQueueTimer? resyncDebounceTimer;
+		// Incremented every time the watcher (re)starts or stops. ResyncSubfoldersAsync captures the value on entry and aborts at every await if it no longer matches — this cancels in-flight resyncs when the row is collapsed, when ReloadSubfoldersAsync wipes ChildItems, or when a parent pruned this item out of the tree.
+		private int resyncGeneration;
+
+		// Starts watching the folder for child folder add / remove / rename so the sidebar reflects filesystem changes without an app restart. No-op when the path doesn't exist (drives that aren't ready, ejected media, etc.) or watcher construction fails (UnauthorizedAccessException on protected roots).
+		private void StartWatchingSubfolders()
+		{
+			if (subfolderWatcher is not null || !Directory.Exists(ExpansionPath))
+				return;
+
+			try
+			{
+				subfolderWatcher = new FileSystemWatcher(ExpansionPath) { NotifyFilter = NotifyFilters.DirectoryName };
+				subfolderWatcher.Created += OnSubfolderWatcherEvent;
+				subfolderWatcher.Deleted += OnSubfolderWatcherEvent;
+				subfolderWatcher.Renamed += OnSubfolderWatcherEvent;
+				subfolderWatcher.EnableRaisingEvents = true;
+			}
+			// FileSystemWatcher ctor throws ArgumentException for invalid paths, UnauthorizedAccessException for protected roots; either way fall back to no live updates for this subtree.
+			catch (Exception ex)
+			{
+				App.Logger?.LogDebug(ex, "Sidebar subfolder watcher start failed for {Path}", ExpansionPath);
+				subfolderWatcher?.Dispose();
+				subfolderWatcher = null;
+			}
+		}
+
+		private void StopWatchingSubfolders()
+		{
+			// Bumping the generation cancels any in-flight ResyncSubfoldersAsync after its next await — without this, a watcher tick fired just before collapse / prune would resume on the dispatcher and mutate ChildItems that nothing is observing.
+			Interlocked.Increment(ref resyncGeneration);
+
+			if (resyncDebounceTimer is not null)
+			{
+				try { resyncDebounceTimer.Stop(); }
+				catch (Exception ex) { App.Logger?.LogDebug(ex, "Sidebar subfolder debounce timer stop failed"); }
+				resyncDebounceTimer = null;
+			}
+
+			if (subfolderWatcher is null)
+				return;
+			// Dispose stops raising events and releases the OS notification subscription; the catch covers ObjectDisposedException / IOException if the watched folder has gone away.
+			try { subfolderWatcher.Dispose(); }
+			catch (Exception ex) { App.Logger?.LogDebug(ex, "Sidebar subfolder watcher dispose failed"); }
+			subfolderWatcher = null;
+		}
+
+		// Called by a parent's ReloadSubfoldersAsync (and by the section-sync remove paths in SidebarViewModel) before clearing/removing items; without this, descendants would be detached from the tree but keep firing into orphaned timers/handlers.
+		internal void StopWatchingSubfoldersAndDescendants()
+		{
+			StopWatchingSubfolders();
+			if (!childrenLoaded)
+				return;
+			foreach (var child in EnsureChildItems().OfType<ExpandableSidebarItemBase>())
+				child.StopWatchingSubfoldersAndDescendants();
+		}
+
+		// Fires on a thread-pool thread; FileSystemWatcher can fan out a single mkdir into Created + LastWrite. Marshal to UI + debounce so a burst yields one resync.
+		private void OnSubfolderWatcherEvent(object sender, FileSystemEventArgs e)
+		{
+			var dispatcher = MainWindow.Instance?.DispatcherQueue;
+			if (dispatcher is null)
+				return;
+			dispatcher.TryEnqueue(() =>
+			{
+				if (resyncDebounceTimer is null)
+				{
+					resyncDebounceTimer = dispatcher.CreateTimer();
+					resyncDebounceTimer.Interval = ResyncDebounce;
+					resyncDebounceTimer.Tick += async (t, _) => { t.Stop(); await ResyncSubfoldersAsync(); };
+				}
+				resyncDebounceTimer.Stop();
+				resyncDebounceTimer.Start();
+			});
+		}
+
+		// Reconciles ChildItems with the live filesystem state via a single merge walk over two name-sorted sequences (collection by LocationItem.Text, freshEntries by SubfolderEntry.Name, both OrdinalIgnoreCase). New rows paint with the cached generic folder icon up front; per-path custom icons are background-upgraded after — same two-phase paint as the initial load.
+		private async Task ResyncSubfoldersAsync()
+		{
+			// Children are off-screen while collapsed; the IsExpanded=true branch fires a catch-up resync when the row reopens.
+			if (!childrenLoaded || !IsExpanded)
+				return;
+
+			// Capture the current generation; if the watcher is stopped or restarted before we finish, the comparisons below short-circuit so we never mutate a collapsed / orphaned ChildItems.
+			var generation = Volatile.Read(ref resyncGeneration);
+
+			var showHidden = Ioc.Default.GetService<IUserSettingsService>()?.FoldersSettingsService?.ShowHiddenItems ?? false;
+			List<SubfolderEntry> freshEntries;
+			try
+			{
+				freshEntries = await Task.Run(() => FolderHelpers.EnumerateSubfolders(ExpansionPath, showHidden, showProtected: false, showDot: false));
+			}
+			// EnumerateSubfolders can throw UnauthorizedAccessException / IOException if the folder is in a bad state mid-resync; treat as "no change visible right now" rather than tearing down ChildItems.
+			catch (Exception ex)
+			{
+				App.Logger?.LogDebug(ex, "Sidebar subfolder resync enumeration failed for {Path}", ExpansionPath);
+				return;
+			}
+
+			if (IsResyncCancelled(generation))
+				return;
+
+			var iconBytes = await LocationItem.GetGenericSmallFolderIconBytesAsync();
+			var dispatcher = MainWindow.Instance?.DispatcherQueue;
+			if (dispatcher is null || IsResyncCancelled(generation))
+				return;
+
+			List<LocationItem>? inserted = null;
+
+			await dispatcher.EnqueueOrInvokeAsync(async () =>
+			{
+				if (IsResyncCancelled(generation))
+					return;
+
+				var collection = EnsureChildItems();
+				var cmp = StringComparer.OrdinalIgnoreCase;
+				BitmapImage? sharedIcon = null;
+				var iconAttempted = false;
+				var ci = 0;
+				var fi = 0;
+
+				void Prune()
+				{
+					if (collection[ci] is ExpandableSidebarItemBase orphan)
+						orphan.StopWatchingSubfoldersAndDescendants();
+					collection.RemoveAt(ci);
+				}
+
+				async Task InsertAsync(SubfolderEntry entry)
+				{
+					// Decode the shared bitmap lazily: a delete-only resync skips it entirely.
+					if (!iconAttempted)
+					{
+						iconAttempted = true;
+						if (iconBytes is not null)
+						{
+							try { sharedIcon = await iconBytes.ToBitmapAsync(); }
+							// BitmapImage.SetSourceAsync throws on corrupt bytes; let new rows render iconless rather than skip the structural sync.
+							catch (Exception ex) { App.Logger?.LogDebug(ex, "Sidebar resync shared folder icon decode failed"); }
+						}
+					}
+					var newItem = LocationItem.CreateSubfolder(entry, sharedIcon);
+					collection.Insert(ci, newItem);
+					(inserted ??= []).Add(newItem);
+					ci++;
+				}
+
+				while (ci < collection.Count && fi < freshEntries.Count)
+				{
+					if (IsResyncCancelled(generation))
+						return;
+					var order = cmp.Compare((collection[ci] as LocationItem)?.Text ?? string.Empty, freshEntries[fi].Name);
+					if (order == 0) { ci++; fi++; }
+					else if (order < 0) Prune();
+					else { await InsertAsync(freshEntries[fi]); fi++; }
+				}
+				while (ci < collection.Count && !IsResyncCancelled(generation)) Prune();
+				while (fi < freshEntries.Count && !IsResyncCancelled(generation)) { await InsertAsync(freshEntries[fi]); fi++; }
+			});
+
+			if (inserted is not null && !IsResyncCancelled(generation))
+				_ = LocationItem.UpgradeIconsAsync(inserted, iconBytes, dispatcher);
+		}
+
+		// Centralizes the "this resync is still relevant" check so every await/loop boundary aborts uniformly when the watcher was stopped or restarted under us.
+		private bool IsResyncCancelled(int generation)
+			=> generation != Volatile.Read(ref resyncGeneration) || !childrenLoaded || !IsExpanded;
+
+		#endregion
+	}
+}
diff --git a/src/Files.App/Data/Items/FileTagItem.cs b/src/Files.App/Data/Items/FileTagItem.cs
index 092f0ef105b3..3171a7e28ce4 100644
--- a/src/Files.App/Data/Items/FileTagItem.cs
+++ b/src/Files.App/Data/Items/FileTagItem.cs
@@ -57,7 +57,5 @@ public IconElement? IconElement
 		public object ToolTip => Text;
 
 		public bool IsExpanded { get => false; set { } }
-
-		public bool PaddedItem => false;
 	}
 }
diff --git a/src/Files.App/Data/Items/IExpandableSidebarFolder.cs b/src/Files.App/Data/Items/IExpandableSidebarFolder.cs
new file mode 100644
index 000000000000..6e2e1658ac49
--- /dev/null
+++ b/src/Files.App/Data/Items/IExpandableSidebarFolder.cs
@@ -0,0 +1,14 @@
+// Copyright (c) Files Community
+// Licensed under the MIT License.
+
+namespace Files.App.Data.Items
+{
+	/// <summary>
+	/// Sidebar items whose children load lazily on first expansion (DriveItem, LocationItem). Used by the sidebar VM to drive expandability setup without per-type switches.
+	/// </summary>
+	internal interface IExpandableSidebarFolder
+	{
+		bool IsExpandableFolder { get; set; }
+		bool HasUnrealizedChildren { get; set; }
+	}
+}
diff --git a/src/Files.App/Data/Items/LocationItem.cs b/src/Files.App/Data/Items/LocationItem.cs
index 0d5b2dc5bed2..6df43a36c31e 100644
--- a/src/Files.App/Data/Items/LocationItem.cs
+++ b/src/Files.App/Data/Items/LocationItem.cs
@@ -2,6 +2,8 @@
 // Licensed under the MIT License.
 
 using Files.App.Controls;
+using Microsoft.Extensions.Logging;
+using Microsoft.UI.Dispatching;
 using Microsoft.UI.Xaml;
 using Microsoft.UI.Xaml.Controls;
 using Microsoft.UI.Xaml.Markup;
@@ -10,7 +12,7 @@
 
 namespace Files.App.Data.Items
 {
-	public partial class LocationItem : ObservableObject, INavigationControlItem
+	public partial class LocationItem : ExpandableSidebarItemBase, INavigationControlItem, IExpandableSidebarFolder
 	{
 		public BitmapImage icon;
 		public BitmapImage Icon
@@ -62,9 +64,22 @@ public NavigationControlItemType ItemType
 
 		public bool IsDefaultLocation { get; set; }
 
-		public object? Children => Section == SectionType.Home ? null : ChildItems;
+		public object? Children
+		{
+			get
+			{
+				if (IsExpandableFolder)
+					return ChildItems ??= [];
+				if (Section == SectionType.Home)
+					return null;
+				return ChildItems;
+			}
+		}
 		public BulkConcurrentObservableCollection<INavigationControlItem>? ChildItems { get; set; }
 
+		protected override string ExpansionPath => path;
+		protected override BulkConcurrentObservableCollection<INavigationControlItem> EnsureChildItems() => ChildItems ??= [];
+
 		public IconElement? IconElement
 		{
 			get
@@ -79,13 +94,146 @@ public IconElement? IconElement
 
 		public bool SelectsOnInvoked { get; set; } = true;
 
-		private bool isExpanded;
-		public bool IsExpanded
+		// Shared by LocationItem + DriveItem. Enumerates off the UI thread, dispatches a single AddRange (one CollectionChanged event instead of N), paints with the cached generic folder icon, then upgrades per-path icons in the background. onLoaded runs on the UI thread alongside the AddRange so callers can flip their loaded/unrealized flags atomically with the visual update.
+		internal static async Task LoadSubfoldersIntoAsync(string enumerationPath, BulkConcurrentObservableCollection<INavigationControlItem> target, Action onLoaded)
+		{
+			try
+			{
+				var userSettings = Ioc.Default.GetService<IUserSettingsService>()?.FoldersSettingsService;
+				var showHidden = userSettings?.ShowHiddenItems ?? false;
+				var showProtected = userSettings?.ShowProtectedSystemFiles ?? false;
+				var showDot = userSettings?.ShowDotFiles ?? false;
+
+				var entries = await Task.Run(() => FolderHelpers.EnumerateSubfolders(enumerationPath, showHidden, showProtected, showDot));
+				var iconBytes = await GetGenericSmallFolderIconBytesAsync();
+
+				var dispatcher = MainWindow.Instance?.DispatcherQueue;
+				if (dispatcher is null)
+					return;
+
+				List<LocationItem>? createdChildren = null;
+				await dispatcher.EnqueueOrInvokeAsync(async () =>
+				{
+					BitmapImage? sharedIcon = null;
+					if (iconBytes is not null)
+					{
+						try { sharedIcon = await iconBytes.ToBitmapAsync(); }
+						// BitmapImage.SetSourceAsync throws on corrupt bytes; proceed without an icon.
+						catch (Exception ex) { App.Logger?.LogDebug(ex, "Sidebar subfolder shared folder icon decode failed"); }
+					}
+
+					createdChildren = new List<LocationItem>(entries.Count);
+					foreach (var entry in entries)
+						createdChildren.Add(CreateSubfolder(entry, sharedIcon));
+
+					target.AddRange(createdChildren);
+					onLoaded();
+				});
+
+				if (createdChildren is not null)
+					_ = UpgradeIconsAsync(createdChildren, iconBytes, dispatcher);
+			}
+			// FolderHelpers.EnumerateSubfolders / FileThumbnailHelper can throw UnauthorizedAccessException, IOException, or COMException on inaccessible / missing paths. Still run onLoaded on the dispatcher so the caller can clear HasUnrealizedChildren and mark childrenLoaded — otherwise the chevron stays and every subsequent click replays the failing enumeration.
+			catch (Exception ex)
+			{
+				App.Logger?.LogDebug(ex, "Sidebar subfolder enumeration failed for {Path}", enumerationPath);
+				await (MainWindow.Instance?.DispatcherQueue).EnqueueOrInvokeAsync(onLoaded);
+			}
+		}
+
+		// Dummy-path trick (matches IconCacheService) makes the shell return the generic folder icon, not anything path-specific. Cached process-wide so every sidebar expansion reuses the same bytes.
+		private static byte[]? cachedGenericSmallFolderIconBytes;
+		private static readonly SemaphoreSlim genericSmallFolderIconLock = new(1, 1);
+		private static readonly string genericFolderProbePath = System.IO.Path.Combine(System.IO.Path.GetPathRoot(Environment.SystemDirectory)!, "x46696c6573");
+
+		internal static async Task<byte[]?> GetGenericSmallFolderIconBytesAsync()
+		{
+			if (cachedGenericSmallFolderIconBytes is not null)
+				return cachedGenericSmallFolderIconBytes;
+
+			await genericSmallFolderIconLock.WaitAsync();
+			try
+			{
+				if (cachedGenericSmallFolderIconBytes is not null)
+					return cachedGenericSmallFolderIconBytes;
+
+				try
+				{
+					cachedGenericSmallFolderIconBytes = await FileThumbnailHelper.GetIconAsync(genericFolderProbePath, Constants.ShellIconSizes.Small, true, IconOptions.ReturnIconOnly | IconOptions.UseCurrentScale);
+				}
+				// FileThumbnailHelper.GetIconAsync can throw COMException when the shell handler is in a bad state; leave the cache null so children render without an icon.
+				catch (Exception ex) { App.Logger?.LogDebug(ex, "LocationItem: generic small folder icon load failed"); }
+
+				return cachedGenericSmallFolderIconBytes;
+			}
+			finally
+			{
+				genericSmallFolderIconLock.Release();
+			}
+		}
+
+		// Replaces the shared generic folder icon with a per-path one only where the shell resolves a different image (custom desktop.ini icons, library covers, etc.). Identical bytes are skipped cheaply so the UI thread only pays for items that actually differ.
+		internal static async Task UpgradeIconsAsync(List<LocationItem> children, byte[]? genericIconBytes, Microsoft.UI.Dispatching.DispatcherQueue dispatcher)
+		{
+			foreach (var item in children)
+			{
+				var path = item.Path;
+				if (string.IsNullOrEmpty(path))
+					continue;
+
+				byte[]? realBytes;
+				try
+				{
+					// Size + scale must match the generic-icon fetch in LoadSubfoldersIntoAsync so the byte-equality skip below is valid.
+					realBytes = await FileThumbnailHelper.GetIconAsync(path, Constants.ShellIconSizes.Small, true, IconOptions.ReturnIconOnly | IconOptions.UseCurrentScale);
+				}
+				// FileThumbnailHelper.GetIconAsync can throw COMException / UnauthorizedAccessException on inaccessible paths; keep the shared generic icon.
+				catch (Exception ex)
+				{
+					App.Logger?.LogDebug(ex, "LocationItem: real icon load failed for {Path}", path);
+					continue;
+				}
+
+				if (realBytes is null)
+					continue;
+				if (genericIconBytes is not null && realBytes.AsSpan().SequenceEqual(genericIconBytes))
+					continue;
+
+				await dispatcher.EnqueueOrInvokeAsync(async () =>
+				{
+					try
+					{
+						var bmp = await realBytes.ToBitmapAsync();
+						if (bmp is not null)
+							item.Icon = bmp;
+					}
+					// BitmapImage.SetSourceAsync throws on corrupt bytes; keep the generic icon.
+					catch (Exception ex) { App.Logger?.LogDebug(ex, "LocationItem: real icon decode failed for {Path}", path); }
+				}, Microsoft.UI.Dispatching.DispatcherQueuePriority.Low);
+			}
+		}
+
+		internal static LocationItem CreateSubfolder(SubfolderEntry entry, BitmapImage? sharedIcon = null)
 		{
-			get => isExpanded;
-			set => SetProperty(ref isExpanded, value);
+			return new LocationItem
+			{
+				Path = entry.Path,
+				Text = entry.Name,
+				IsExpandableFolder = true,
+				HasUnrealizedChildren = entry.HasSubfolders,
+				IsHidden = entry.IsHidden,
+				Icon = sharedIcon!,
+				MenuOptions = new ContextMenuOptions
+				{
+					IsLocationItem = true,
+					ShowProperties = true,
+					ShowShellItems = true,
+				},
+			};
 		}
 
+		public bool IsHidden { get; set; }
+
 		public bool IsInvalid { get; set; } = false;
 
 		public bool IsPinned => App.QuickAccessManager.Model.PinnedFolders.Contains(path);
@@ -106,22 +254,7 @@ public virtual object ToolTip
 			}
 		}
 
-		public FrameworkElement? ItemDecorator
-		{
-			get
-			{
-				if (Section == SectionType.Pinned)
-				{
-					return new ThemedIcon()
-					{
-						Style = Application.Current.Resources["SidebarFavouritesPinnedIcon"] as Style
-					};
-				}
-				return null;
-			}
-		}
-
-		public bool PaddedItem => Section == SectionType.Home;
+		public FrameworkElement? ItemDecorator => null;
 
 		public int CompareTo(INavigationControlItem? other)
 			=> Text.CompareTo(other.Text);
diff --git a/src/Files.App/Data/Items/WslDistroItem.cs b/src/Files.App/Data/Items/WslDistroItem.cs
index 4979369dda40..ef3603fbaedc 100644
--- a/src/Files.App/Data/Items/WslDistroItem.cs
+++ b/src/Files.App/Data/Items/WslDistroItem.cs
@@ -65,8 +65,6 @@ public IconElement? IconElement
 			}
 		}
 
-		public bool PaddedItem => false;
-
 		public int CompareTo(INavigationControlItem? other) => Text.CompareTo(other.Text);
 	}
 }
diff --git a/src/Files.App/Services/Settings/GeneralSettingsService.cs b/src/Files.App/Services/Settings/GeneralSettingsService.cs
index 92d6b14d805a..b857f302871e 100644
--- a/src/Files.App/Services/Settings/GeneralSettingsService.cs
+++ b/src/Files.App/Services/Settings/GeneralSettingsService.cs
@@ -161,84 +161,42 @@ public bool ShowPinnedSection
 			set => Set(value);
 		}
 
-		public bool IsPinnedSectionExpanded
-		{
-			get => Get(true);
-			set => Set(value);
-		}
-
 		public bool ShowLibrarySection
 		{
 			get => Get(false);
 			set => Set(value);
 		}
 
-		public bool IsLibrarySectionExpanded
-		{
-			get => Get(false);
-			set => Set(value);
-		}
-
 		public bool ShowDrivesSection
 		{
 			get => Get(true);
 			set => Set(value);
 		}
 
-		public bool IsDriveSectionExpanded
-		{
-			get => Get(false);
-			set => Set(value);
-		}
-
 		public bool ShowCloudDrivesSection
 		{
 			get => Get(true);
 			set => Set(value);
 		}
 
-		public bool IsCloudDriveSectionExpanded
-		{
-			get => Get(false);
-			set => Set(value);
-		}
-
 		public bool ShowNetworkSection
 		{
 			get => Get(true);
 			set => Set(value);
 		}
 
-		public bool IsNetworkSectionExpanded
-		{
-			get => Get(false);
-			set => Set(value);
-		}
-
 		public bool ShowWslSection
 		{
 			get => Get(true);
 			set => Set(value);
 		}
 
-		public bool IsWslSectionExpanded
-		{
-			get => Get(false);
-			set => Set(value);
-
-		}
 		public bool ShowFileTagsSection
 		{
 			get => Get(true);
 			set => Set(value);
 		}
 
-		public bool IsFileTagsSectionExpanded
-		{
-			get => Get(false);
-			set => Set(value);
-		}
-
 		public bool MoveShellExtensionsToSubMenu
 		{
 			get => Get(true);
diff --git a/src/Files.App/Utils/Storage/Helpers/FolderHelpers.cs b/src/Files.App/Utils/Storage/Helpers/FolderHelpers.cs
index 74f0a37099f1..9d7b30a095e1 100644
--- a/src/Files.App/Utils/Storage/Helpers/FolderHelpers.cs
+++ b/src/Files.App/Utils/Storage/Helpers/FolderHelpers.cs
@@ -5,6 +5,8 @@
 
 namespace Files.App.Utils.Storage
 {
+	public readonly record struct SubfolderEntry(string Path, string Name, bool HasSubfolders, bool IsHidden);
+
 	public static class FolderHelpers
 	{
 		public static bool CheckFolderAccessWithWin32(string path)
@@ -48,5 +50,82 @@ public static bool CheckForFilesFolders(string targetPath)
 			Win32PInvoke.FindClose(hFile);
 			return result;
 		}
+
+		public static List<SubfolderEntry> EnumerateSubfolders(string path, bool showHidden, bool showProtected, bool showDot, int limit = 1000)
+		{
+			var results = new List<SubfolderEntry>();
+			IntPtr hFind = OpenChildSearch(path, out var findData);
+			if (hFind.ToInt64() == -1)
+				return results;
+
+			try
+			{
+				do
+				{
+					if (findData.cFileName is "." or "..")
+						continue;
+					var attrs = (FileAttributes)findData.dwFileAttributes;
+					if ((attrs & FileAttributes.Directory) != FileAttributes.Directory)
+						continue;
+
+					var isHidden = (attrs & FileAttributes.Hidden) == FileAttributes.Hidden;
+					var isSystem = (attrs & FileAttributes.System) == FileAttributes.System;
+
+					if (!showDot && findData.cFileName.StartsWith('.'))
+						continue;
+					if (isHidden && !showHidden)
+						continue;
+					if (isHidden && isSystem && !showProtected)
+						continue;
+
+					var subPath = Path.Combine(path, findData.cFileName);
+					results.Add(new SubfolderEntry(subPath, findData.cFileName, HasSubfolders(subPath), isHidden));
+
+					if (results.Count == limit)
+						break;
+				}
+				while (Win32PInvoke.FindNextFile(hFind, out findData));
+			}
+			finally
+			{
+				Win32PInvoke.FindClose(hFind);
+			}
+
+			results.Sort((a, b) => StringComparer.OrdinalIgnoreCase.Compare(a.Name, b.Name));
+			return results;
+		}
+
+		public static bool HasSubfolders(string path)
+		{
+			IntPtr hFind = OpenChildSearch(path, out var findData);
+			if (hFind.ToInt64() == -1)
+				return false;
+
+			try
+			{
+				do
+				{
+					if (findData.cFileName is "." or "..")
+						continue;
+					if (((FileAttributes)findData.dwFileAttributes & FileAttributes.Directory) == FileAttributes.Directory)
+						return true;
+				}
+				while (Win32PInvoke.FindNextFile(hFind, out findData));
+				return false;
+			}
+			finally
+			{
+				Win32PInvoke.FindClose(hFind);
+			}
+		}
+
+		private static IntPtr OpenChildSearch(string path, out Win32PInvoke.WIN32_FIND_DATA findData)
+			=> Win32PInvoke.FindFirstFileExFromApp(
+				path + "\\*.*",
+				Win32PInvoke.FINDEX_INFO_LEVELS.FindExInfoBasic,
+				out findData,
+				Win32PInvoke.FINDEX_SEARCH_OPS.FindExSearchNameMatch,
+				IntPtr.Zero,
+				Win32PInvoke.FIND_FIRST_EX_LARGE_FETCH);
 	}
 }
diff --git a/src/Files.App/ViewModels/Settings/SettingsPageViewModel.cs b/src/Files.App/ViewModels/Settings/SettingsPageViewModel.cs
index 5532c272a065..fc9abcc113c2 100644
--- a/src/Files.App/ViewModels/Settings/SettingsPageViewModel.cs
+++ b/src/Files.App/ViewModels/Settings/SettingsPageViewModel.cs
@@ -10,6 +10,9 @@ public sealed partial class SettingsPageViewModel : ObservableObject
 	{
 		public ObservableCollection<SettingsNavigationItem> NavigationItems { get; } = [];
 
+		// Wrapped projection of NavigationItems for binding to SidebarView.MenuItemsSource (which renders FlatSidebarItem rows). Settings is a flat list so every entry sits at Depth=0.
+		public ObservableCollection<FlatSidebarItem> FlatNavigationItems { get; } = [];
+
 		public ObservableCollection<SettingsSearchResult> SearchResults { get; } = [];
 
 		private List<SettingsSearchResult>? _searchIndex;
@@ -43,6 +46,9 @@ public SettingsPageViewModel()
 			NavigationItems.Add(CreateNavigationItem(SettingsPageKind.AdvancedPage, "SettingsItemAdvanced", Strings.Advanced.GetLocalizedResource(), "App.ThemedIcons.Settings.Advanced"));
 			NavigationItems.Add(CreateNavigationItem(SettingsPageKind.AboutPage, "SettingsItemAbout", Strings.About.GetLocalizedResource(), "App.ThemedIcons.Info"));
 
+			foreach (var navItem in NavigationItems)
+				FlatNavigationItems.Add(new FlatSidebarItem(navItem, 0));
+
 			SetSelectedPage(SettingsPageKind.GeneralPage);
 		}
 
@@ -109,7 +115,6 @@ public sealed partial class SettingsNavigationItem : ObservableObject, ISidebarI
 
 		// ISidebarItemModel
 		public object? Children => null;
-		public bool PaddedItem => false;
 		public string? Path => null;
 		[ObservableProperty] private bool _isExpanded;
 
diff --git a/src/Files.App/ViewModels/UserControls/SidebarViewModel.FlatTree.cs b/src/Files.App/ViewModels/UserControls/SidebarViewModel.FlatTree.cs
new file mode 100644
index 000000000000..141005203df1
--- /dev/null
+++ b/src/Files.App/ViewModels/UserControls/SidebarViewModel.FlatTree.cs
@@ -0,0 +1,376 @@
+// Copyright (c) Files Community
+// Licensed under the MIT License.
+
+using Files.App.Controls;
+using Microsoft.UI.Xaml;
+using System.Collections.Specialized;
+
+namespace Files.App.ViewModels.UserControls
+{
+	public sealed partial class SidebarViewModel
+	{
+		private BulkConcurrentObservableCollection<FlatSidebarItem>? _flatSidebarItems;
+		public BulkConcurrentObservableCollection<FlatSidebarItem> FlatSidebarItems
+		{
+			get
+			{
+				if (_flatSidebarItems is null)
+					InitializeFlatTree();
+				return _flatSidebarItems!;
+			}
+		}
+
+		// SidebarDisplayMode rejects Minimal (it only tracks user preference), so the flat tree mirrors the SidebarView's live mode separately to know when sub-rows should hide.
+		private SidebarDisplayMode _actualDisplayMode;
+		public SidebarDisplayMode ActualDisplayMode
+		{
+			get => _actualDisplayMode;
+			set => SetProperty(ref _actualDisplayMode, value);
+		}
+
+		private bool IsCompactDisplayMode => ActualDisplayMode == SidebarDisplayMode.Compact;
+
+		private readonly Dictionary<ISidebarItemModel, FlatSidebarItem> _flatLookup = [];
+		private readonly Dictionary<INotifyCollectionChanged, ISidebarItemModel> _flatChildCollectionParents = [];
+		// Parallel reverse index so ResubscribeChildren resolves the prior collection in O(1) instead of scanning _flatChildCollectionParents.
+		private readonly Dictionary<ISidebarItemModel, INotifyCollectionChanged> _flatChildCollectionByItem = [];
+
+		private void InitializeFlatTree()
+		{
+			_flatSidebarItems = [];
+			PropertyChanged += FlatTree_VMPropertyChanged;
+			RebuildFlatTree();
+			sidebarItems.CollectionChanged += FlatTree_SidebarItemsChanged;
+		}
+
+		private void CollectVisibleSubtree(ISidebarItemModel item, int depth, List<FlatSidebarItem> sink)
+		{
+			if (depth > 0 && IsCompactDisplayMode)
+				return;
+			var rowOpacity = item is LocationItem { IsHidden: true } ? Constants.UI.DimItemOpacity : 1.0;
+			sink.Add(new FlatSidebarItem(item, depth, rowOpacity));
+			if (!item.IsExpanded)
+				return;
+			foreach (var child in EnumerateChildren(item))
+				CollectVisibleSubtree(child, depth + 1, sink);
+		}
+
+		private static IEnumerable<ISidebarItemModel> EnumerateChildren(ISidebarItemModel item)
+			=> item.Children as IEnumerable<ISidebarItemModel> ?? Array.Empty<ISidebarItemModel>();
+
+		private void RegisterNodes(IEnumerable<FlatSidebarItem> nodes)
+		{
+			foreach (var node in nodes)
+			{
+				_flatLookup[node.Item] = node;
+				SubscribeFlatItem(node.Item);
+			}
+		}
+
+		private void RebuildFlatTree()
+		{
+			if (_flatSidebarItems is null)
+				return;
+			_flatSidebarItems.BeginBulkOperation();
+			try
+			{
+				foreach (var node in _flatSidebarItems)
+					UnsubscribeFlatItem(node.Item);
+				_flatSidebarItems.Clear();
+				_flatLookup.Clear();
+				_flatChildCollectionByItem.Clear();
+				var batch = new List<FlatSidebarItem>();
+				foreach (var section in sidebarItems)
+					CollectVisibleSubtree(section, 0, batch);
+				RegisterNodes(batch);
+				_flatSidebarItems.AddRange(batch);
+			}
+			finally
+			{
+				_flatSidebarItems.EndBulkOperation();
+			}
+			UpdateSectionPredecessorFlags();
+			RefreshSelectionForCurrentPath();
+		}
+
+		private void FlatTree_VMPropertyChanged(object? sender, PropertyChangedEventArgs e)
+		{
+			if (e.PropertyName == nameof(ActualDisplayMode))
+				RebuildFlatTree();
+		}
+
+		private void FlatTree_SidebarItemsChanged(object? sender, NotifyCollectionChangedEventArgs e)
+		{
+			if (dispatcherQueue is null)
+				return;
+			dispatcherQueue.EnqueueOrInvokeAsync(() => HandleSidebarItemsChangedAsync(e));
+		}
+
+		private async Task HandleSidebarItemsChangedAsync(NotifyCollectionChangedEventArgs e)
+		{
+			switch (e.Action)
+			{
+				case NotifyCollectionChangedAction.Add:
+					int insertIndex = e.NewStartingIndex >= 0 ? FlatIndexOfSection(e.NewStartingIndex) : FlatSidebarItems.Count;
+					await BuildAndInsertChildrenAsync(insertIndex, CastModels(e.NewItems!), 0);
+					break;
+				case NotifyCollectionChangedAction.Remove:
+					RemoveSubtrees(e.OldItems!);
+					break;
+				default:
+					RebuildFlatTree();
+					return;
+			}
+			UpdateSectionPredecessorFlags();
+			RefreshSelectionForCurrentPath();
+		}
+
+		// The i-th depth=0 row in FlatSidebarItems is where section i begins, so one linear pass suffices.
+		private int FlatIndexOfSection(int sectionIndex)
+		{
+			int seen = 0;
+			for (int i = 0; i < FlatSidebarItems.Count; i++)
+			{
+				if (FlatSidebarItems[i].Depth != 0)
+					continue;
+				if (seen == sectionIndex)
+					return i;
+				seen++;
+			}
+			return FlatSidebarItems.Count;
+		}
+
+		// Walks forward from `start` and returns the index of the first row whose depth is at or above the parent's depth — i.e. the end of `start`'s subtree.
+		private int FindSubtreeEnd(int start, int parentDepth)
+		{
+			int end = start + 1;
+			while (end < FlatSidebarItems.Count && FlatSidebarItems[end].Depth > parentDepth)
+				end++;
+			return end;
+		}
+
+		// Unsubscribes and removes wrappers in [start, end). Caller picks whether `start` is the subtree root (full prune) or root+1 (collapse: keep the root, drop descendants).
+		private void RemoveSubtreeRange(int start, int end)
+		{
+			int count = end - start;
+			if (count <= 0)
+				return;
+			for (int i = start; i < end; i++)
+			{
+				var removed = FlatSidebarItems[i];
+				UnsubscribeFlatItem(removed.Item);
+				_flatLookup.Remove(removed.Item);
+			}
+			FlatSidebarItems.RemoveRange(start, count);
+		}
+
+		// _flatLookup gives the wrapper in O(1) but IndexOf into the observable list is still O(N); callers that need both the index and the node would otherwise repeat the miss-guard pair each time.
+		private bool TryGetFlatPosition(ISidebarItemModel item, out int start, out FlatSidebarItem node)
+		{
+			if (_flatLookup.TryGetValue(item, out node!))
+			{
+				start = FlatSidebarItems.IndexOf(node);
+				if (start >= 0)
+					return true;
+			}
+			start = -1;
+			node = null!;
+			return false;
+		}
+
+		private void RemoveSubtrees(System.Collections.IList items)
+		{
+			foreach (var raw in items)
+			{
+				if (raw is ISidebarItemModel item && TryGetFlatPosition(item, out var start, out var node))
+					RemoveSubtreeRange(start, FindSubtreeEnd(start, node.Depth));
+			}
+		}
+
+		// Lazily yields ISidebarItemModel entries from a non-generic CollectionChanged list; avoids the LINQ OfType iterator allocation on the hot mutation paths.
+		private static IEnumerable<ISidebarItemModel> CastModels(System.Collections.IList items)
+		{
+			foreach (var raw in items)
+				if (raw is ISidebarItemModel item)
+					yield return item;
+		}
+
+		// Collects fresh wrappers for the given children (skipping any already in the flat list) and inserts them. Returns immediately if there's nothing to add — avoids allocating the batch list in the common no-op path.
+		private async Task BuildAndInsertChildrenAsync(int insertAt, IEnumerable<ISidebarItemModel> children, int childDepth)
+		{
+			List<FlatSidebarItem>? batch = null;
+			foreach (var child in children)
+			{
+				if (_flatLookup.ContainsKey(child))
+					continue;
+				batch ??= [];
+				CollectVisibleSubtree(child, childDepth, batch);
+			}
+			if (batch is not null)
+				await InsertChunkedAsync(insertAt, batch);
+		}
+
+		private void SubscribeFlatItem(ISidebarItemModel item)
+		{
+			item.PropertyChanged += FlatTree_ItemPropertyChanged;
+			if (item.Children is INotifyCollectionChanged notify && !_flatChildCollectionParents.ContainsKey(notify))
+			{
+				notify.CollectionChanged += FlatTree_ChildCollectionChanged;
+				_flatChildCollectionParents[notify] = item;
+				_flatChildCollectionByItem[item] = notify;
+			}
+		}
+
+		private void UnsubscribeFlatItem(ISidebarItemModel item)
+		{
+			item.PropertyChanged -= FlatTree_ItemPropertyChanged;
+			if (item.Children is INotifyCollectionChanged notify && _flatChildCollectionParents.Remove(notify))
+			{
+				_flatChildCollectionByItem.Remove(item);
+				notify.CollectionChanged -= FlatTree_ChildCollectionChanged;
+			}
+		}
+
+		// IsExpandableFolder flips asynchronously on DriveItem/LocationItem after the item enters the flat tree, swapping Children from null to a real collection — re-subscribe to the new reference.
+		private void ResubscribeChildren(ISidebarItemModel item)
+		{
+			if (_flatChildCollectionByItem.Remove(item, out var oldCollection))
+			{
+				_flatChildCollectionParents.Remove(oldCollection);
+				oldCollection.CollectionChanged -= FlatTree_ChildCollectionChanged;
+			}
+			if (item.Children is INotifyCollectionChanged newCollection && !_flatChildCollectionParents.ContainsKey(newCollection))
+			{
+				newCollection.CollectionChanged += FlatTree_ChildCollectionChanged;
+				_flatChildCollectionParents[newCollection] = item;
+				_flatChildCollectionByItem[item] = newCollection;
+			}
+		}
+
+		private void FlatTree_ItemPropertyChanged(object? sender, PropertyChangedEventArgs e)
+		{
+			if (sender is not ISidebarItemModel item)
+				return;
+
+			if (e.PropertyName == nameof(ISidebarItemModel.Children) && _flatLookup.ContainsKey(item))
+				ResubscribeChildren(item);
+
+			if (e.PropertyName == nameof(ISidebarItemModel.IsExpanded) && dispatcherQueue is not null)
+				dispatcherQueue.EnqueueOrInvokeAsync(() => HandleItemExpansionChangedAsync(item));
+		}
+
+		private async Task HandleItemExpansionChangedAsync(ISidebarItemModel item)
+		{
+			if (!TryGetFlatPosition(item, out var start, out var node))
+				return;
+			if (item.IsExpanded)
+				await BuildAndInsertChildrenAsync(start + 1, EnumerateChildren(item), node.Depth + 1);
+			else
+				RemoveSubtreeRange(start + 1, FindSubtreeEnd(start, node.Depth));
+			if (node.Depth == 0)
+				UpdateSectionPredecessorFlags();
+			RefreshSelectionForCurrentPath();
+		}
+
+		private void FlatTree_ChildCollectionChanged(object? sender, NotifyCollectionChangedEventArgs e)
+		{
+			if (sender is not INotifyCollectionChanged notify)
+				return;
+			if (!_flatChildCollectionParents.TryGetValue(notify, out var parent))
+				return;
+			if (dispatcherQueue is null)
+				return;
+			dispatcherQueue.EnqueueOrInvokeAsync(async () => await HandleChildCollectionChangedAsync(parent, e));
+		}
+
+		// High-fanout folders (e.g. WinSxS) freeze the UI when ItemsRepeater receives one giant Add event. Splitting into chunks with a dispatcher yield turns it into a sequence of frame-sized layout passes.
+		private const int FlatTreeInsertChunkSize = 100;
+
+		private async Task HandleChildCollectionChangedAsync(ISidebarItemModel parent, NotifyCollectionChangedEventArgs e)
+		{
+			if (!parent.IsExpanded || !TryGetFlatPosition(parent, out var parentStart, out var parentNode))
+				return;
+			int childDepth = parentNode.Depth + 1;
+
+			switch (e.Action)
+			{
+				case NotifyCollectionChangedAction.Add:
+					await BuildAndInsertChildrenAsync(
+						FindChildInsertionIndex(parentStart, childDepth, e.NewStartingIndex),
+						CastModels(e.NewItems!),
+						childDepth);
+					break;
+				case NotifyCollectionChangedAction.Remove:
+					RemoveSubtrees(e.OldItems!);
+					break;
+				default:
+					// Reset / Move / Replace: rebuild the subtree from the parent's current children.
+					RemoveSubtreeRange(parentStart + 1, FindSubtreeEnd(parentStart, parentNode.Depth));
+					await BuildAndInsertChildrenAsync(parentStart + 1, EnumerateChildren(parent), childDepth);
+					break;
+			}
+			UpdateSectionPredecessorFlags();
+			RefreshSelectionForCurrentPath();
+		}
+
+		private async Task InsertChunkedAsync(int insertAt, List<FlatSidebarItem> batch)
+		{
+			if (batch.Count == 0)
+				return;
+			if (batch.Count <= FlatTreeInsertChunkSize)
+			{
+				RegisterNodes(batch);
+				FlatSidebarItems.InsertRange(insertAt, batch);
+				return;
+			}
+			for (int i = 0; i < batch.Count; i += FlatTreeInsertChunkSize)
+			{
+				var chunkEnd = Math.Min(i + FlatTreeInsertChunkSize, batch.Count);
+				var chunk = batch.GetRange(i, chunkEnd - i);
+				RegisterNodes(chunk);
+				FlatSidebarItems.InsertRange(insertAt + i, chunk);
+				if (chunkEnd < batch.Count)
+					await Task.Delay(1);
+			}
+		}
+
+		private void RefreshSelectionForCurrentPath()
+		{
+			if (!string.IsNullOrEmpty(CurrentPath))
+				UpdateSidebarSelectedItemFromArgs(CurrentPath);
+		}
+
+		// Inter-section gap (12px top margin) only appears after an expanded section. Home has no Children and counts as "expanded" so the first section still gets a gap.
+		private void UpdateSectionPredecessorFlags()
+		{
+			if (_flatSidebarItems is null)
+				return;
+			bool prevWasExpanded = false;
+			foreach (var node in _flatSidebarItems)
+			{
+				if (node.Depth != 0)
+					continue;
+				node.HasExpandedPredecessor = !IsCompactDisplayMode && prevWasExpanded;
+				prevWasExpanded = node.Item.Children is null ? true : node.Item.IsExpanded;
+			}
+		}
+
+		private int FindChildInsertionIndex(int parentStart, int childDepth, int sourceIndex)
+		{
+			int parentDepth = childDepth - 1;
+			int countSeen = 0;
+			int i = parentStart + 1;
+			while (i < FlatSidebarItems.Count && FlatSidebarItems[i].Depth > parentDepth)
+			{
+				if (FlatSidebarItems[i].Depth == childDepth)
+				{
+					if (sourceIndex >= 0 && countSeen == sourceIndex)
+						return i;
+					countSeen++;
+				}
+				i++;
+			}
+			return i;
+		}
+	}
+}
diff --git a/src/Files.App/ViewModels/UserControls/SidebarViewModel.TabExpansion.cs b/src/Files.App/ViewModels/UserControls/SidebarViewModel.TabExpansion.cs
new file mode 100644
index 000000000000..aeb09565f14e
--- /dev/null
+++ b/src/Files.App/ViewModels/UserControls/SidebarViewModel.TabExpansion.cs
@@ -0,0 +1,268 @@
+// Copyright (c) Files Community
+// Licensed under the MIT License.
+
+using Files.App.Controls;
+using System.Collections.Specialized;
+
+namespace Files.App.ViewModels.UserControls
+{
+	public sealed partial class SidebarViewModel
+	{
+		// Each tab is the sole source of truth for its own expansion (sections and folders alike); Pinned/Drives/CloudDrives are seeded as expanded so a fresh tab matches the historical defaults.
+		private static readonly string[] SectionKeyByEnum = BuildSectionKeyByEnum();
+		private static readonly string[] DefaultExpandedSectionKeys =
+		{
+			SectionKeyByEnum[(int)SectionType.Pinned],
+			SectionKeyByEnum[(int)SectionType.Drives],
+			SectionKeyByEnum[(int)SectionType.CloudDrives],
+		};
+
+		private static string[] BuildSectionKeyByEnum()
+		{
+			var values = Enum.GetValues<SectionType>();
+			var arr = new string[(int)values.Max() + 1];
+			foreach (var v in values)
+				arr[(int)v] = "section:" + v;
+			return arr;
+		}
+
+		private readonly Dictionary<TabBarItem, HashSet<string>> tabExpansionState = new();
+		private readonly HashSet<INotifyPropertyChanged> trackedItems = new();
+		private readonly HashSet<INotifyCollectionChanged> trackedChildCollections = new();
+		private TabBarItem? currentTab;
+		// Int counter (used with Interlocked) instead of a bool so a nested apply (e.g. TrackedChildren firing during a parent apply) can't reset the outer guard.
+		private int applyingTabStateDepth;
+		private bool tabTrackingInitialized;
+		private MainPageViewModel? mainPageViewModel;
+		private MainPageViewModel ResolveMainPageViewModel() => mainPageViewModel ??= Ioc.Default.GetRequiredService<MainPageViewModel>();
+
+		private bool IsApplyingTabState => applyingTabStateDepth > 0;
+
+		private static string? GetExpansionKey(INavigationControlItem item) => item switch
+		{
+			LocationItem { IsHeader: true } sect => SectionKeyByEnum[(int)sect.Section],
+			_ when !string.IsNullOrEmpty(item.Path) => item.Path,
+			_ => null,
+		};
+
+		// Defers MainPageViewModel resolution until the sidebar is hooked into MainPage to avoid DI bootstrap ordering issues.
+		public void EnsureTabExpansionTrackingInitialized()
+		{
+			if (tabTrackingInitialized)
+				return;
+			tabTrackingInitialized = true;
+			try
+			{
+				var mpvm = ResolveMainPageViewModel();
+				mpvm.PropertyChanged += MainPageViewModel_PropertyChanged;
+				MainPageViewModel.AppInstances.CollectionChanged += AppInstances_CollectionChanged;
+				currentTab = mpvm.SelectedTabItem;
+				foreach (var sectionObj in sidebarItems)
+					TrackSidebarItem(sectionObj);
+				ApplyTabExpansionState();
+			}
+			// InvalidOperationException from Ioc.Default.GetRequiredService when MainPageViewModel isn't registered yet (sidebar Loaded firing before DI bootstrap completes); clear the flag so a later Loaded retries.
+			catch (InvalidOperationException)
+			{
+				tabTrackingInitialized = false;
+			}
+		}
+
+		private void TeardownTabExpansionTracking()
+		{
+			if (!tabTrackingInitialized)
+				return;
+			if (mainPageViewModel is not null)
+				mainPageViewModel.PropertyChanged -= MainPageViewModel_PropertyChanged;
+			MainPageViewModel.AppInstances.CollectionChanged -= AppInstances_CollectionChanged;
+			foreach (var item in trackedItems)
+				item.PropertyChanged -= TrackedItem_PropertyChanged;
+			foreach (var col in trackedChildCollections)
+				col.CollectionChanged -= TrackedChildren_CollectionChanged;
+			trackedItems.Clear();
+			trackedChildCollections.Clear();
+		}
+
+		private void MainPageViewModel_PropertyChanged(object? sender, PropertyChangedEventArgs e)
+		{
+			if (e.PropertyName != nameof(MainPageViewModel.SelectedTabItem))
+				return;
+			var newTab = ResolveMainPageViewModel().SelectedTabItem;
+			if (ReferenceEquals(newTab, currentTab))
+				return;
+			currentTab = newTab;
+			ApplyTabExpansionState();
+		}
+
+		private void AppInstances_CollectionChanged(object? sender, NotifyCollectionChangedEventArgs e)
+		{
+			// Treat Replace identically to Remove so the replaced tab's state isn't kept under a dead key. Move never changes membership, so its OldItems are skipped.
+			if (e.Action is NotifyCollectionChangedAction.Remove or NotifyCollectionChangedAction.Replace && e.OldItems is not null)
+			{
+				foreach (var raw in e.OldItems)
+					if (raw is TabBarItem item)
+						tabExpansionState.Remove(item);
+			}
+			else if (e.Action == NotifyCollectionChangedAction.Reset)
+			{
+				tabExpansionState.Clear();
+			}
+		}
+
+		private HashSet<string> GetOrInitTabState(TabBarItem tab)
+		{
+			if (!tabExpansionState.TryGetValue(tab, out var state))
+			{
+				state = new HashSet<string>(DefaultExpandedSectionKeys, StringComparer.OrdinalIgnoreCase);
+				// Inherit whatever section state the user currently sees so a freshly opened tab matches expectation rather than snapping back to defaults.
+				foreach (var sectionObj in sidebarItems)
+				{
+					if (sectionObj is LocationItem section && section.IsExpanded)
+					{
+						var key = GetExpansionKey(section);
+						if (key is not null)
+							state.Add(key);
+					}
+				}
+				tabExpansionState[tab] = state;
+			}
+			return state;
+		}
+
+		internal void TrackSidebarItem(INavigationControlItem? item)
+		{
+			if (item is null || item is not INotifyPropertyChanged inpc)
+				return;
+			if (!trackedItems.Add(inpc))
+				return;
+			inpc.PropertyChanged += TrackedItem_PropertyChanged;
+			HookChildrenCollection(item);
+		}
+
+		// Symmetric counterpart to TrackSidebarItem: unsubscribes the item, drops it from the tracker HashSets, removes its key from every tab's expansion state, and recurses into already-loaded descendants so a watcher-driven prune doesn't strand subscriptions or stale keys.
+		internal void UntrackSidebarItem(INavigationControlItem? item)
+		{
+			if (item is null)
+				return;
+			if (item is INotifyPropertyChanged inpc && trackedItems.Remove(inpc))
+				inpc.PropertyChanged -= TrackedItem_PropertyChanged;
+			if (item.Children is INotifyCollectionChanged children && trackedChildCollections.Remove(children))
+				children.CollectionChanged -= TrackedChildren_CollectionChanged;
+			var key = GetExpansionKey(item);
+			if (key is not null)
+			{
+				foreach (var state in tabExpansionState.Values)
+					state.Remove(key);
+			}
+			if (item.Children is IEnumerable<INavigationControlItem> existing)
+			{
+				foreach (var child in existing)
+					UntrackSidebarItem(child);
+			}
+		}
+
+		// Runs both on initial track and when IsExpandableFolder flips true (the children collection materializes lazily). Reads via the Children property (not the raw ChildItems field) so subfolder LocationItems get their backing collection lazy-initialized and hooked — otherwise CollectionChanged fires later with no listener and deeper descendants are never tracked.
+		private void HookChildrenCollection(INavigationControlItem item)
+		{
+			if (item.Children is not INotifyCollectionChanged children)
+				return;
+			if (!trackedChildCollections.Add(children))
+				return;
+			children.CollectionChanged += TrackedChildren_CollectionChanged;
+			if (children is IEnumerable<INavigationControlItem> existing)
+			{
+				foreach (var child in existing)
+					TrackSidebarItem(child);
+			}
+		}
+
+		private void TrackedItem_PropertyChanged(object? sender, PropertyChangedEventArgs e)
+		{
+			if (sender is not INavigationControlItem item)
+				return;
+			switch (e.PropertyName)
+			{
+				case nameof(LocationItem.IsExpanded):
+					CaptureExpansionToCurrentTab(item);
+					break;
+				case nameof(LocationItem.IsExpandableFolder):
+					HookChildrenCollection(item);
+					break;
+			}
+		}
+
+		private void TrackedChildren_CollectionChanged(object? sender, NotifyCollectionChangedEventArgs e)
+		{
+			// Drop subscriptions + tab-state keys for items leaving the collection so a long-running session with frequent filesystem churn doesn't grow the tracker HashSets indefinitely.
+			if (e.OldItems is not null)
+			{
+				foreach (var raw in e.OldItems)
+					if (raw is INavigationControlItem removed)
+						UntrackSidebarItem(removed);
+			}
+			if (e.NewItems is null)
+				return;
+			foreach (var raw in e.NewItems)
+			{
+				if (raw is not INavigationControlItem added)
+					continue;
+				TrackSidebarItem(added);
+				if (currentTab is null)
+					continue;
+				var state = GetOrInitTabState(currentTab);
+				var key = GetExpansionKey(added);
+				if (key is null || !state.Contains(key))
+					continue;
+				Interlocked.Increment(ref applyingTabStateDepth);
+				try { added.IsExpanded = true; }
+				finally { Interlocked.Decrement(ref applyingTabStateDepth); }
+			}
+		}
+
+		private void CaptureExpansionToCurrentTab(INavigationControlItem item)
+		{
+			if (IsApplyingTabState || currentTab is null)
+				return;
+			var key = GetExpansionKey(item);
+			if (key is null)
+				return;
+			var state = GetOrInitTabState(currentTab);
+			if (item.IsExpanded)
+				state.Add(key);
+			else
+				state.Remove(key);
+		}
+
+		// Restores expansion for the initial pass over sidebarItems and for items realized later (async section sync, lazy-loaded subfolders).
+		private void ApplyTabExpansionState() => ApplyTabStateTo(sidebarItems);
+		private void ApplyTabStateToNewlyAddedItem(INavigationControlItem item) => ApplyTabStateTo([item]);
+
+		private void ApplyTabStateTo(IEnumerable<INavigationControlItem> items)
+		{
+			if (currentTab is null)
+				return;
+			var state = GetOrInitTabState(currentTab);
+			Interlocked.Increment(ref applyingTabStateDepth);
+			try
+			{
+				foreach (var item in items)
+					ApplyStateToItem(item, state);
+			}
+			finally
+			{
+				Interlocked.Decrement(ref applyingTabStateDepth);
+			}
+		}
+
+		private void ApplyStateToItem(INavigationControlItem item, HashSet<string> state)
+		{
+			var key = GetExpansionKey(item);
+			var shouldExpand = key is not null && state.Contains(key);
+			item.IsExpanded = shouldExpand;
+			if (!shouldExpand || GetChildren(item) is not { } children)
+				return;
+			foreach (var child in children)
+				ApplyStateToItem(child, state);
+		}
+	}
+}
diff --git a/src/Files.App/ViewModels/UserControls/SidebarViewModel.cs b/src/Files.App/ViewModels/UserControls/SidebarViewModel.cs
index 9f752a218828..4e2f4f6cee51 100644
--- a/src/Files.App/ViewModels/UserControls/SidebarViewModel.cs
+++ b/src/Files.App/ViewModels/UserControls/SidebarViewModel.cs
@@ -93,37 +93,84 @@ public void NotifyInstanceRelatedPropertiesChanged(string? arg)
 			OnPropertyChanged(nameof(SidebarSelectedItem));
 		}
 
+		private string? currentPath;
+		public string? CurrentPath
+		{
+			get => currentPath;
+			private set => SetProperty(ref currentPath, value);
+		}
+
 		public void UpdateSidebarSelectedItemFromArgs(string? arg)
 		{
 			var value = arg;
-
-			INavigationControlItem? item = null;
-			var filteredItems = sidebarItems
-				.Where(x => !string.IsNullOrWhiteSpace(x.Path))
-				.Concat(sidebarItems.Where(x => (x as LocationItem)?.ChildItems is not null).SelectMany(x => ((LocationItem)x).ChildItems).Where(x => !string.IsNullOrWhiteSpace(x.Path)))
-				.ToList();
+			CurrentPath = value;
 
 			if (string.IsNullOrEmpty(value))
-			{
-				//SidebarSelectedItem = sidebarItems.FirstOrDefault(x => x.Path.Equals("Home"));
 				return;
-			}
-
-			item = filteredItems.FirstOrDefault(x => x.Path.Equals(value, StringComparison.OrdinalIgnoreCase));
-			item ??= filteredItems.Where(x => value.StartsWith(x.Path + "\\", StringComparison.OrdinalIgnoreCase)).MaxBy(x => x.Path.Length);
-			item ??= filteredItems.FirstOrDefault(x => x.Path.Equals(Path.GetPathRoot(value), StringComparison.OrdinalIgnoreCase));
-
-			if (item is null && value == "Home")
-				item = filteredItems.FirstOrDefault(x => x.Path.Equals("Home"));
 
-			if (item is null && value == "Settings")
-				item = SettingsSidebarItem;
+			INavigationControlItem? item = value switch
+			{
+				"Home" => sidebarItems.FirstOrDefault(x => x.Path == "Home"),
+				"Settings" => SettingsSidebarItem,
+				_ => FindDeepestVisibleAncestor(value),
+			};
 
 			if (SidebarSelectedItem != item)
 				SidebarSelectedItem = item;
+		}
+
+		#region Deepest-visible-ancestor selection
+
+		// Walks only the currently-realized + expanded tree; navigating to a folder whose ancestors are collapsed selects the closest visible parent without forcing any expansion. Section-level descent skips the ancestor-prefix optimization because section paths (e.g. "Pinned") don't prefix their children's paths.
+		private INavigationControlItem? FindDeepestVisibleAncestor(string targetPath)
+		{
+			INavigationControlItem? best = null;
+			foreach (var section in sidebarItems)
+			{
+				if (PathIsAncestorOrMatch(section.Path, targetPath))
+					ConsiderAsBest(section, ref best);
+				if (!section.IsExpanded || GetChildren(section) is not { } children)
+					continue;
+				FindDeepestVisibleAncestorRecursive(children, targetPath, ref best);
+			}
+			return best;
+		}
+
+		private static void FindDeepestVisibleAncestorRecursive(IEnumerable<INavigationControlItem> items, string targetPath, ref INavigationControlItem? best)
+		{
+			foreach (var item in items)
+			{
+				if (!PathIsAncestorOrMatch(item.Path, targetPath))
+					continue;
+				ConsiderAsBest(item, ref best);
+				if (!item.IsExpanded || GetChildren(item) is not { } children)
+					continue;
+				FindDeepestVisibleAncestorRecursive(children, targetPath, ref best);
+			}
+		}
+
+		private static IEnumerable<INavigationControlItem>? GetChildren(INavigationControlItem item)
+			=> item.Children as IEnumerable<INavigationControlItem>;
+
+		// Caller has already verified PathIsAncestorOrMatch so candidate.Path is non-null and the recursive descent doesn't re-do that work.
+		private static void ConsiderAsBest(INavigationControlItem candidate, ref INavigationControlItem? best)
+		{
+			if (best is null || candidate.Path!.Length > (best.Path?.Length ?? 0))
+				best = candidate;
+		}
 
+		// Checks the boundary character directly instead of building "nodePath + sep" and calling StartsWith on the allocated string — saves one allocation per call inside the recursive walk.
+		private static bool PathIsAncestorOrMatch(string? nodePath, string targetPath)
+		{
+			if (string.IsNullOrEmpty(nodePath) || !targetPath.StartsWith(nodePath, StringComparison.OrdinalIgnoreCase))
+				return false;
+			if (targetPath.Length == nodePath.Length)
+				return true;
+			return nodePath[^1] == Path.DirectorySeparatorChar || targetPath[nodePath.Length] == Path.DirectorySeparatorChar;
 		}
 
+		#endregion
+
 		public bool IsSidebarOpen
 		{
 			get => UserSettingsService.AppearanceSettingsService.IsSidebarOpen;
@@ -343,6 +390,11 @@ private async Task SyncSidebarItemsAsync(LocationItem section, Func<IReadOnlyLis
 						foreach (INavigationControlItem elem in e.OldItems)
 						{
 							var match = section.ChildItems.FirstOrDefault(x => x.Path == elem.Path);
+							if (match is null)
+								continue;
+							// Tear down the matched item's watcher + descendants before removing it; without this the orphan keeps a live FileSystemWatcher and would fire resyncs into a detached ChildItems collection.
+							if (match is ExpandableSidebarItemBase expandable)
+								expandable.StopWatchingSubfoldersAndDescendants();
 							section.ChildItems.Remove(match);
 						}
 						if (e.Action != NotifyCollectionChangedAction.Remove)
@@ -363,6 +415,8 @@ private async Task SyncSidebarItemsAsync(LocationItem section, Func<IReadOnlyLis
 						{
 							if (!getElements().Any(x => x.Path == elem.Path))
 							{
+								if (elem is ExpandableSidebarItemBase expandable)
+									expandable.StopWatchingSubfoldersAndDescendants();
 								section.ChildItems.Remove(elem);
 							}
 						}
@@ -421,38 +475,26 @@ await lib.CheckDefaultSaveFolderAccess() &&
 				}
 			}
 
-			section.PropertyChanged += Section_PropertyChanged;
+			// Items rooted at a real filesystem path become tree-view expandable. Pinned stays a flat favorites list.
+			_ = ApplyTreeViewExpandabilityAsync(elem, section.Section);
+
+			// Hook both for per-tab expansion capture and restore.
+			TrackSidebarItem(elem);
+			TrackSidebarItem(section);
+			ApplyTabStateToNewlyAddedItem(elem);
+			ApplyTabStateToNewlyAddedItem(section);
 		}
 
-		private void Section_PropertyChanged(object? sender, PropertyChangedEventArgs e)
+		private static async Task ApplyTreeViewExpandabilityAsync(INavigationControlItem child, SectionType parentSection)
 		{
-			if (sender is LocationItem section && e.PropertyName == nameof(section.IsExpanded))
-			{
-				switch (section.Text)
-				{
-					case var text when text == Strings.Pinned.GetLocalizedResource():
-						UserSettingsService.GeneralSettingsService.IsPinnedSectionExpanded = section.IsExpanded;
-						break;
-					case var text when text == Strings.SidebarLibraries.GetLocalizedResource():
-						UserSettingsService.GeneralSettingsService.IsLibrarySectionExpanded = section.IsExpanded;
-						break;
-					case var text when text == Strings.Drives.GetLocalizedResource():
-						UserSettingsService.GeneralSettingsService.IsDriveSectionExpanded = section.IsExpanded;
-						break;
-					case var text when text == Strings.SidebarCloudDrives.GetLocalizedResource():
-						UserSettingsService.GeneralSettingsService.IsCloudDriveSectionExpanded = section.IsExpanded;
-						break;
-					case var text when text == Strings.Network.GetLocalizedResource():
-						UserSettingsService.GeneralSettingsService.IsNetworkSectionExpanded = section.IsExpanded;
-						break;
-					case var text when text == Strings.WSL.GetLocalizedResource():
-						UserSettingsService.GeneralSettingsService.IsWslSectionExpanded = section.IsExpanded;
-						break;
-					case var text when text == Strings.FileTags.GetLocalizedResource():
-						UserSettingsService.GeneralSettingsService.IsFileTagsSectionExpanded = section.IsExpanded;
-						break;
-				}
-			}
+			if (parentSection == SectionType.Pinned || child is not IExpandableSidebarFolder expandable)
+				return;
+			if (string.IsNullOrEmpty(child.Path) || !System.IO.Path.IsPathRooted(child.Path))
+				return;
+
+			var hasSubfolders = await Task.Run(() => FolderHelpers.HasSubfolders(child.Path));
+			expandable.IsExpandableFolder = true;
+			expandable.HasUnrealizedChildren = hasSubfolders;
 		}
 
 		private async Task<LocationItem> GetOrCreateSectionAsync(SectionType sectionType)
@@ -494,8 +536,6 @@ private async Task<LocationItem> CreateSectionAsync(SectionType sectionType)
 						section = BuildSection(Strings.Pinned.GetLocalizedResource(), sectionType, new ContextMenuOptions { ShowHideSection = true }, false);
 						icon = new BitmapImage(new Uri(Constants.FluentIconsPaths.StarIcon));
 						section.IsHeader = true;
-						section.IsExpanded = UserSettingsService.GeneralSettingsService.IsPinnedSectionExpanded;
-
 						break;
 					}
 
@@ -508,8 +548,6 @@ private async Task<LocationItem> CreateSectionAsync(SectionType sectionType)
 						section = BuildSection(Strings.SidebarLibraries.GetLocalizedResource(), sectionType, new ContextMenuOptions { IsLibrariesHeader = true, ShowHideSection = true }, false);
 						iconIdex = Constants.ImageRes.Libraries;
 						section.IsHeader = true;
-						section.IsExpanded = UserSettingsService.GeneralSettingsService.IsLibrarySectionExpanded;
-
 						break;
 					}
 
@@ -522,8 +560,6 @@ private async Task<LocationItem> CreateSectionAsync(SectionType sectionType)
 						section = BuildSection(Strings.Drives.GetLocalizedResource(), sectionType, new ContextMenuOptions { ShowHideSection = true }, false);
 						iconIdex = Constants.ImageRes.ThisPC;
 						section.IsHeader = true;
-						section.IsExpanded = UserSettingsService.GeneralSettingsService.IsDriveSectionExpanded;
-
 						break;
 					}
 
@@ -536,8 +572,6 @@ private async Task<LocationItem> CreateSectionAsync(SectionType sectionType)
 						section = BuildSection(Strings.SidebarCloudDrives.GetLocalizedResource(), sectionType, new ContextMenuOptions { ShowHideSection = true }, false);
 						icon = new BitmapImage(new Uri(Constants.FluentIconsPaths.CloudDriveIcon));
 						section.IsHeader = true;
-						section.IsExpanded = UserSettingsService.GeneralSettingsService.IsCloudDriveSectionExpanded;
-
 						break;
 					}
 
@@ -550,8 +584,6 @@ private async Task<LocationItem> CreateSectionAsync(SectionType sectionType)
 						section = BuildSection(Strings.Network.GetLocalizedResource(), sectionType, new ContextMenuOptions { ShowHideSection = true }, false);
 						iconIdex = Constants.ImageRes.Network;
 						section.IsHeader = true;
-						section.IsExpanded = UserSettingsService.GeneralSettingsService.IsNetworkSectionExpanded;
-
 						break;
 					}
 
@@ -564,8 +596,6 @@ private async Task<LocationItem> CreateSectionAsync(SectionType sectionType)
 						section = BuildSection(Strings.WSL.GetLocalizedResource(), sectionType, new ContextMenuOptions { ShowHideSection = true }, false);
 						icon = new BitmapImage(new Uri(Constants.WslIconsPaths.GenericIcon));
 						section.IsHeader = true;
-						section.IsExpanded = UserSettingsService.GeneralSettingsService.IsWslSectionExpanded;
-
 						break;
 					}
 
@@ -578,8 +608,6 @@ private async Task<LocationItem> CreateSectionAsync(SectionType sectionType)
 						section = BuildSection(Strings.FileTags.GetLocalizedResource(), sectionType, new ContextMenuOptions { IsTagsHeader = true, ShowHideSection = true }, false);
 						icon = new BitmapImage(new Uri(Constants.FluentIconsPaths.FileTagsIcon));
 						section.IsHeader = true;
-						section.IsExpanded = UserSettingsService.GeneralSettingsService.IsFileTagsSectionExpanded;
-
 						break;
 					}
 			}
@@ -693,6 +721,34 @@ private async void UserSettingsService_OnSettingChangedEvent(object sender, Sett
 					OnPropertyChanged(nameof(ShowFileTagsSection));
 					OnPropertyChanged(nameof(AreSectionsHidden));
 					break;
+				case nameof(UserSettingsService.FoldersSettingsService.ShowHiddenItems):
+					await ReloadFilteredSubfoldersAsync();
+					break;
+			}
+		}
+
+		// Reloads the shallowest already-loaded subfolder in each branch; descendants come back via tab-state restoration as the rebuilt children get re-added, so we don't waste shell calls on items that will be discarded by their parent's reload.
+		private async Task ReloadFilteredSubfoldersAsync()
+		{
+			var topmost = new List<ExpandableSidebarItemBase>();
+			foreach (var section in sidebarItems)
+				CollectTopmostLoaded(section, topmost);
+
+			foreach (var item in topmost)
+				await item.ReloadSubfoldersAsync();
+		}
+
+		private static void CollectTopmostLoaded(INavigationControlItem item, List<ExpandableSidebarItemBase> sink)
+		{
+			if (item is ExpandableSidebarItemBase expandable && expandable.IsLoaded)
+			{
+				sink.Add(expandable);
+				return;
+			}
+			if (item.Children is IEnumerable<INavigationControlItem> children)
+			{
+				foreach (var child in children)
+					CollectTopmostLoaded(child, sink);
 			}
 		}
 
@@ -708,6 +764,7 @@ public void Dispose()
 			WSLDistroManager.DataChanged -= Manager_DataChanged;
 			App.FileTagsManager.DataChanged -= Manager_DataChanged;
 
+			TeardownTabExpansionTracking();
 			dispatcherQueue = null;
 		}
 
diff --git a/src/Files.App/Views/MainPage.xaml b/src/Files.App/Views/MainPage.xaml
index ae1ccb82940a..d17f92490ce0 100644
--- a/src/Files.App/Views/MainPage.xaml
+++ b/src/Files.App/Views/MainPage.xaml
@@ -185,10 +185,11 @@
 			ItemDropped="SidebarControl_ItemDropped"
 			ItemInvoked="SidebarControl_ItemInvoked"
 			Loaded="SidebarControl_Loaded"
-			MenuItemsSource="{x:Bind SidebarAdaptiveViewModel.SidebarItems, Mode=OneWay}"
+			MenuItemsSource="{x:Bind SidebarAdaptiveViewModel.FlatSidebarItems, Mode=OneWay}"
 			OpenPaneLength="{x:Bind UserSettingsService.AppearanceSettingsService.SidebarWidth, Mode=TwoWay}"
 			PaneBackgroundBrush="{ThemeResource App.Theme.Sidebar.BackgroundBrush}"
-			SelectedItem="{x:Bind SidebarAdaptiveViewModel.SidebarSelectedItem, Mode=TwoWay}">
+			SelectedItem="{x:Bind SidebarAdaptiveViewModel.SidebarSelectedItem, Mode=TwoWay}"
+			SupportsExpansion="True">
 
 			<!--  Inner Content  -->
 			<controls:SidebarView.InnerContent>
@@ -303,7 +304,6 @@
 						Style="{StaticResource App.Theme.CaptionTextBlockStyle}"
 						Text="{helpers:ResourceString Name=SectionsHiddenMessage}"
 						TextAlignment="Center" />
-
 				</StackPanel>
 			</controls:SidebarView.SidebarContent>
 
diff --git a/src/Files.App/Views/MainPage.xaml.cs b/src/Files.App/Views/MainPage.xaml.cs
index af82440752c6..220d4bc4bc89 100644
--- a/src/Files.App/Views/MainPage.xaml.cs
+++ b/src/Files.App/Views/MainPage.xaml.cs
@@ -35,6 +35,9 @@ public sealed partial class MainPage : Page
 
 		private DispatcherQueueTimer _updateDateDisplayTimer;
 
+		private readonly Dictionary<TabBarItem, double> _sidebarScrollByTab = new();
+		private TabBarItem? _previousSidebarTab;
+
 		public MainPage()
 		{
 			InitializeComponent();
@@ -338,6 +341,12 @@ private void SidebarControl_Loaded(object sender, RoutedEventArgs e)
 		{
 			// Set the correct tab margin on startup
 			SidebarAdaptiveViewModel.UpdateTabControlMargin();
+			SidebarAdaptiveViewModel.EnsureTabExpansionTrackingInitialized();
+
+			// VM.SidebarDisplayMode rejects Minimal (it only tracks user preference) so the flat tree mirrors SidebarView.DisplayMode separately.
+			SidebarAdaptiveViewModel.ActualDisplayMode = SidebarControl.DisplayMode;
+			SidebarControl.RegisterPropertyChangedCallback(SidebarView.DisplayModeProperty, (_, _) =>
+				SidebarAdaptiveViewModel.ActualDisplayMode = SidebarControl.DisplayMode);
 		}
 
 		private void RootGrid_SizeChanged(object sender, SizeChangedEventArgs e) => LoadPaneChanged();
@@ -425,6 +434,24 @@ private async void ViewModel_PropertyChanged(object? sender, PropertyChangedEven
 		{
 			if (e.PropertyName == nameof(ViewModel.ShouldPreviewPaneBeActive) && ViewModel.ShouldPreviewPaneBeActive)
 				await Ioc.Default.GetRequiredService<InfoPaneViewModel>().UpdateSelectedItemPreviewAsync();
+			else if (e.PropertyName == nameof(ViewModel.SelectedTabItem))
+				HandleSidebarTabChange();
+		}
+
+		private void HandleSidebarTabChange()
+		{
+			if (_previousSidebarTab is not null)
+				_sidebarScrollByTab[_previousSidebarTab] = SidebarControl.VerticalScrollOffset;
+
+			var newTab = ViewModel.SelectedTabItem;
+			_previousSidebarTab = newTab;
+
+			if (newTab is null)
+				return;
+
+			var savedOffset = _sidebarScrollByTab.GetValueOrDefault(newTab);
+			// Defer to after the flat-tree's tab-state restoration dispatcher work so the content extent has caught up before scrolling.
+			DispatcherQueue.TryEnqueue(DispatcherQueuePriority.Low, () => SidebarControl.ScrollToVerticalOffset(savedOffset));
 		}
 
 		private void RootGrid_PreviewKeyDown(object sender, KeyRoutedEventArgs e)
diff --git a/src/Files.App/Views/Settings/SettingsPage.xaml b/src/Files.App/Views/Settings/SettingsPage.xaml
index 470b3bda5b16..1cd07311366f 100644
--- a/src/Files.App/Views/Settings/SettingsPage.xaml
+++ b/src/Files.App/Views/Settings/SettingsPage.xaml
@@ -53,7 +53,7 @@
 			x:Name="SettingsSidebar"
 			CanResizePane="False"
 			ItemInvoked="SettingsSidebar_ItemInvoked"
-			MenuItemsSource="{x:Bind ViewModel.NavigationItems}"
+			MenuItemsSource="{x:Bind ViewModel.FlatNavigationItems}"
 			OpenPaneLength="240">
 
 			<controls:SidebarView.Header>

From 1ee5429df5432bd8fb6045d332c3640fc4b8e67b Mon Sep 17 00:00:00 2001
From: Saravanan G <workbysaran@gmail.com>
Date: Mon, 8 Jun 2026 21:35:41 +0530
Subject: [PATCH 2/2] Code Quality: Improved Tree View IO (#18565)

---
 .../ViewModels/UserControls/SidebarViewModel.FlatTree.cs  | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/Files.App/ViewModels/UserControls/SidebarViewModel.FlatTree.cs b/src/Files.App/ViewModels/UserControls/SidebarViewModel.FlatTree.cs
index 141005203df1..594a4d6067f1 100644
--- a/src/Files.App/ViewModels/UserControls/SidebarViewModel.FlatTree.cs
+++ b/src/Files.App/ViewModels/UserControls/SidebarViewModel.FlatTree.cs
@@ -323,14 +323,20 @@ private async Task InsertChunkedAsync(int insertAt, List<FlatSidebarItem> batch)
 				FlatSidebarItems.InsertRange(insertAt, batch);
 				return;
 			}
+			var currentInsertAt = insertAt;
 			for (int i = 0; i < batch.Count; i += FlatTreeInsertChunkSize)
 			{
 				var chunkEnd = Math.Min(i + FlatTreeInsertChunkSize, batch.Count);
 				var chunk = batch.GetRange(i, chunkEnd - i);
 				RegisterNodes(chunk);
-				FlatSidebarItems.InsertRange(insertAt + i, chunk);
+				FlatSidebarItems.InsertRange(currentInsertAt, chunk);
 				if (chunkEnd < batch.Count)
+				{
 					await Task.Delay(1);
+					currentInsertAt = FlatSidebarItems.IndexOf(batch[chunkEnd - 1]) + 1;
+					if (currentInsertAt <= 0)
+						return;
+				}
 			}
 		}