diff --git a/src/Wpf.Ui.Gallery/App.xaml.cs b/src/Wpf.Ui.Gallery/App.xaml.cs
index b3fa34b84..c3311f208 100644
--- a/src/Wpf.Ui.Gallery/App.xaml.cs
+++ b/src/Wpf.Ui.Gallery/App.xaml.cs
@@ -29,6 +29,7 @@
 using Wpf.Ui.Gallery.Views.Pages.Icons;
 using Wpf.Ui.Gallery.Views.Pages.Media;
 using Wpf.Ui.Gallery.Views.Pages.Navigation;
+using Wpf.Ui.Gallery.Views.Pages.Samples;
 using Wpf.Ui.Gallery.Views.Pages.StatusAndInfo;
 using Wpf.Ui.Gallery.Views.Pages.Text;
 using Wpf.Ui.Gallery.Views.Pages.Windows;
@@ -49,7 +50,7 @@ public partial class App : Application
     // https://docs.microsoft.com/dotnet/core/extensions/logging
     private static readonly IHost _host = Host
         .CreateDefaultBuilder()
-        .ConfigureAppConfiguration(c => { c.SetBasePath(Path.GetDirectoryName(Assembly.GetEntryAssembly()!.Location)); })
+        .ConfigureAppConfiguration(c => { c.SetBasePath(AppContext.BaseDirectory); })
         .ConfigureServices((context, services) =>
         {
             // App Host
@@ -149,10 +150,17 @@ public partial class App : Application
             services.AddTransient<NavigationPage>();
             services.AddTransient<NavigationViewModel>();
             services.AddTransient<NavigationViewPage>();
+            services.AddTransient<MultilevelNavigationPage>();
             services.AddTransient<NavigationViewViewModel>();
             services.AddTransient<TabControlPage>();
             services.AddTransient<TabControlViewModel>();
 
+            // Multilevel navigation sample Pages
+            services.AddTransient<MultilevelNavigationSample>();
+            services.AddTransient<MultilevelNavigationSamplePage1>();
+            services.AddTransient<MultilevelNavigationSamplePage2>();
+            services.AddTransient<MultilevelNavigationSamplePage3>();
+
             // Status and Info
             services.AddTransient<StatusAndInfoPage>();
             services.AddTransient<StatusAndInfoViewModel>();
diff --git a/src/Wpf.Ui.Gallery/ViewModels/Pages/Navigation/MultilevelNavigationSample.cs b/src/Wpf.Ui.Gallery/ViewModels/Pages/Navigation/MultilevelNavigationSample.cs
new file mode 100644
index 000000000..976ded1d2
--- /dev/null
+++ b/src/Wpf.Ui.Gallery/ViewModels/Pages/Navigation/MultilevelNavigationSample.cs
@@ -0,0 +1,28 @@
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file, You can obtain one at https://opensource.org/licenses/MIT.
+// Copyright (C) Leszek Pomianowski and WPF UI Contributors.
+// All Rights Reserved.
+
+namespace Wpf.Ui.Gallery.ViewModels.Pages.Navigation;
+
+public partial class MultilevelNavigationSample
+{
+    public MultilevelNavigationSample(INavigationService navigationService)
+    {
+        _navigationService = navigationService;
+    }
+
+    private readonly INavigationService _navigationService;
+
+    [RelayCommand]
+    private void NavigateForward(Type type)
+    {
+        _navigationService.NavigateWithHierarchy(type);
+    }
+
+    [RelayCommand]
+    private void NavigateBack()
+    {
+        _navigationService.GoBack();
+    }
+}
diff --git a/src/Wpf.Ui.Gallery/ViewModels/Windows/MainWindowViewModel.cs b/src/Wpf.Ui.Gallery/ViewModels/Windows/MainWindowViewModel.cs
index 3a64ec25c..502b8006f 100644
--- a/src/Wpf.Ui.Gallery/ViewModels/Windows/MainWindowViewModel.cs
+++ b/src/Wpf.Ui.Gallery/ViewModels/Windows/MainWindowViewModel.cs
@@ -91,6 +91,7 @@ public MainWindowViewModel(IServiceProvider serviceProvider)
             {
                 new NavigationViewItem { Content = "BreadcrumbBar", TargetPageType = typeof(BreadcrumbBarPage) },
                 new NavigationViewItem { Content = "NavigationView", TargetPageType = typeof(NavigationViewPage) },
+                new NavigationViewItem { Content = "Multilevel navigation", TargetPageType = typeof(MultilevelNavigationPage) },
                 new NavigationViewItem { Content = "TabControl", TargetPageType = typeof(TabControlPage) },
             }},
             new NavigationViewItem {Content = "Status and Info", Icon = new SymbolIcon { Symbol = SymbolRegular.ChatBubblesQuestion24  }, TargetPageType = typeof(StatusAndInfoPage), MenuItems = new ObservableCollection<object>
diff --git a/src/Wpf.Ui.Gallery/Views/Pages/Navigation/MultilevelNavigationPage.xaml b/src/Wpf.Ui.Gallery/Views/Pages/Navigation/MultilevelNavigationPage.xaml
new file mode 100644
index 000000000..d3e8a0668
--- /dev/null
+++ b/src/Wpf.Ui.Gallery/Views/Pages/Navigation/MultilevelNavigationPage.xaml
@@ -0,0 +1,30 @@
+<Page
+    x:Class="Wpf.Ui.Gallery.Views.Pages.Navigation.MultilevelNavigationPage"
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+    xmlns:local="clr-namespace:Wpf.Ui.Gallery.Views.Pages.Navigation"
+    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+    xmlns:navigation="clr-namespace:Wpf.Ui.Gallery.ViewModels.Pages.Navigation"
+    xmlns:samples1="clr-namespace:Wpf.Ui.Gallery.Views.Pages.Samples"
+    xmlns:ui="http://schemas.lepo.co/wpfui/2022/xaml"
+    Title="MultilevelNavigationPage"
+    d:DataContext="{d:DesignInstance navigation:MultilevelNavigationSample,
+                                     IsDesignTimeCreatable=False}"
+    d:DesignHeight="450"
+    d:DesignWidth="800"
+    ui:Design.Background="{DynamicResource ApplicationBackgroundBrush}"
+    ui:Design.Foreground="{DynamicResource TextFillColorPrimaryBrush}"
+    Foreground="{DynamicResource TextFillColorPrimaryBrush}"
+    mc:Ignorable="d">
+
+    <Grid>
+        <Button
+            HorizontalAlignment="Center"
+            VerticalAlignment="Center"
+            Command="{Binding NavigateForwardCommand}"
+            CommandParameter="{x:Type samples1:MultilevelNavigationSamplePage1}"
+            Content="Navigate to the first page"
+            FontSize="24" />
+    </Grid>
+</Page>
diff --git a/src/Wpf.Ui.Gallery/Views/Pages/Navigation/MultilevelNavigationPage.xaml.cs b/src/Wpf.Ui.Gallery/Views/Pages/Navigation/MultilevelNavigationPage.xaml.cs
new file mode 100644
index 000000000..493b9245e
--- /dev/null
+++ b/src/Wpf.Ui.Gallery/Views/Pages/Navigation/MultilevelNavigationPage.xaml.cs
@@ -0,0 +1,22 @@
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file, You can obtain one at https://opensource.org/licenses/MIT.
+// Copyright (C) Leszek Pomianowski and WPF UI Contributors.
+// All Rights Reserved.
+
+using Wpf.Ui.Controls.Navigation;
+using Wpf.Ui.Gallery.ViewModels.Pages.Navigation;
+
+namespace Wpf.Ui.Gallery.Views.Pages.Navigation;
+
+public partial class MultilevelNavigationPage : INavigableView<MultilevelNavigationSample>
+{
+    public MultilevelNavigationPage(MultilevelNavigationSample viewModel)
+    {
+        ViewModel = viewModel;
+        DataContext = viewModel;
+
+        InitializeComponent();
+    }
+
+    public MultilevelNavigationSample ViewModel { get; }
+}
diff --git a/src/Wpf.Ui.Gallery/Views/Pages/Samples/MultilevelNavigationSamplePage1.xaml b/src/Wpf.Ui.Gallery/Views/Pages/Samples/MultilevelNavigationSamplePage1.xaml
new file mode 100644
index 000000000..78357bc1a
--- /dev/null
+++ b/src/Wpf.Ui.Gallery/Views/Pages/Samples/MultilevelNavigationSamplePage1.xaml
@@ -0,0 +1,39 @@
+<Page
+    x:Class="Wpf.Ui.Gallery.Views.Pages.Samples.MultilevelNavigationSamplePage1"
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+    xmlns:navigation="clr-namespace:Wpf.Ui.Gallery.ViewModels.Pages.Navigation"
+    xmlns:samples1="clr-namespace:Wpf.Ui.Gallery.Views.Pages.Samples"
+    xmlns:ui="http://schemas.lepo.co/wpfui/2022/xaml"
+    Title="MultilevelNavigationSamplePage"
+    d:DataContext="{d:DesignInstance navigation:MultilevelNavigationSample,
+                                     IsDesignTimeCreatable=False}"
+    d:DesignHeight="450"
+    d:DesignWidth="800"
+    ui:NavigationView.HeaderContent="Page 1"
+    mc:Ignorable="d">
+
+    <Grid>
+        <Grid.ColumnDefinitions>
+            <ColumnDefinition Width="*" />
+            <ColumnDefinition Width="*" />
+        </Grid.ColumnDefinitions>
+
+        <Button
+            Grid.Column="0"
+            HorizontalAlignment="Center"
+            Command="{Binding NavigateBackCommand}"
+            Content="Navigate back"
+            FontSize="24" />
+
+        <Button
+            Grid.Column="1"
+            HorizontalAlignment="Center"
+            Command="{Binding NavigateForwardCommand}"
+            CommandParameter="{x:Type samples1:MultilevelNavigationSamplePage2}"
+            Content="Navigate to the second page"
+            FontSize="24" />
+    </Grid>
+</Page>
diff --git a/src/Wpf.Ui.Gallery/Views/Pages/Samples/MultilevelNavigationSamplePage1.xaml.cs b/src/Wpf.Ui.Gallery/Views/Pages/Samples/MultilevelNavigationSamplePage1.xaml.cs
new file mode 100644
index 000000000..fce80d4bc
--- /dev/null
+++ b/src/Wpf.Ui.Gallery/Views/Pages/Samples/MultilevelNavigationSamplePage1.xaml.cs
@@ -0,0 +1,22 @@
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file, You can obtain one at https://opensource.org/licenses/MIT.
+// Copyright (C) Leszek Pomianowski and WPF UI Contributors.
+// All Rights Reserved.
+
+using Wpf.Ui.Controls.Navigation;
+using Wpf.Ui.Gallery.ViewModels.Pages.Navigation;
+
+namespace Wpf.Ui.Gallery.Views.Pages.Samples;
+
+public partial class MultilevelNavigationSamplePage1 : INavigableView<MultilevelNavigationSample>
+{
+    public MultilevelNavigationSamplePage1(MultilevelNavigationSample viewModel)
+    {
+        ViewModel = viewModel;
+        DataContext = viewModel;
+
+        InitializeComponent();
+    }
+
+    public MultilevelNavigationSample ViewModel { get; }
+}
diff --git a/src/Wpf.Ui.Gallery/Views/Pages/Samples/MultilevelNavigationSamplePage2.xaml b/src/Wpf.Ui.Gallery/Views/Pages/Samples/MultilevelNavigationSamplePage2.xaml
new file mode 100644
index 000000000..7a2b47bc0
--- /dev/null
+++ b/src/Wpf.Ui.Gallery/Views/Pages/Samples/MultilevelNavigationSamplePage2.xaml
@@ -0,0 +1,39 @@
+<Page
+    x:Class="Wpf.Ui.Gallery.Views.Pages.Samples.MultilevelNavigationSamplePage2"
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+    xmlns:local="clr-namespace:Wpf.Ui.Gallery.Views.Pages.Samples"
+    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+    xmlns:navigation="clr-namespace:Wpf.Ui.Gallery.ViewModels.Pages.Navigation"
+    xmlns:ui="http://schemas.lepo.co/wpfui/2022/xaml"
+    Title="MultilevelNavigationSamplePage2"
+    d:DataContext="{d:DesignInstance navigation:MultilevelNavigationSample,
+                                     IsDesignTimeCreatable=False}"
+    d:DesignHeight="450"
+    d:DesignWidth="800"
+    ui:NavigationView.HeaderContent="Page 2"
+    mc:Ignorable="d">
+
+    <Grid>
+        <Grid.ColumnDefinitions>
+            <ColumnDefinition Width="*" />
+            <ColumnDefinition Width="*" />
+        </Grid.ColumnDefinitions>
+
+        <Button
+            Grid.Column="0"
+            HorizontalAlignment="Center"
+            Command="{Binding NavigateBackCommand}"
+            Content="Navigate back"
+            FontSize="24" />
+
+        <Button
+            Grid.Column="1"
+            HorizontalAlignment="Center"
+            Command="{Binding NavigateForwardCommand}"
+            CommandParameter="{x:Type local:MultilevelNavigationSamplePage3}"
+            Content="Navigate to the third page"
+            FontSize="24" />
+    </Grid>
+</Page>
diff --git a/src/Wpf.Ui.Gallery/Views/Pages/Samples/MultilevelNavigationSamplePage2.xaml.cs b/src/Wpf.Ui.Gallery/Views/Pages/Samples/MultilevelNavigationSamplePage2.xaml.cs
new file mode 100644
index 000000000..65c9a2116
--- /dev/null
+++ b/src/Wpf.Ui.Gallery/Views/Pages/Samples/MultilevelNavigationSamplePage2.xaml.cs
@@ -0,0 +1,22 @@
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file, You can obtain one at https://opensource.org/licenses/MIT.
+// Copyright (C) Leszek Pomianowski and WPF UI Contributors.
+// All Rights Reserved.
+
+using Wpf.Ui.Controls.Navigation;
+using Wpf.Ui.Gallery.ViewModels.Pages.Navigation;
+
+namespace Wpf.Ui.Gallery.Views.Pages.Samples;
+
+public partial class MultilevelNavigationSamplePage2 : INavigableView<MultilevelNavigationSample>
+{
+    public MultilevelNavigationSamplePage2(MultilevelNavigationSample viewModel)
+    {
+        ViewModel = viewModel;
+        DataContext = viewModel;
+
+        InitializeComponent();
+    }
+
+    public MultilevelNavigationSample ViewModel { get; }
+}
diff --git a/src/Wpf.Ui.Gallery/Views/Pages/Samples/MultilevelNavigationSamplePage3.xaml b/src/Wpf.Ui.Gallery/Views/Pages/Samples/MultilevelNavigationSamplePage3.xaml
new file mode 100644
index 000000000..a15cd4dd1
--- /dev/null
+++ b/src/Wpf.Ui.Gallery/Views/Pages/Samples/MultilevelNavigationSamplePage3.xaml
@@ -0,0 +1,39 @@
+<Page
+    x:Class="Wpf.Ui.Gallery.Views.Pages.Samples.MultilevelNavigationSamplePage3"
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+    xmlns:local="clr-namespace:Wpf.Ui.Gallery.Views.Pages.Samples"
+    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+    xmlns:navigation="clr-namespace:Wpf.Ui.Gallery.ViewModels.Pages.Navigation"
+    xmlns:ui="http://schemas.lepo.co/wpfui/2022/xaml"
+    Title="MultilevelNavigationSamplePage3"
+    d:DataContext="{d:DesignInstance navigation:MultilevelNavigationSample,
+                                     IsDesignTimeCreatable=False}"
+    d:DesignHeight="450"
+    d:DesignWidth="800"
+    ui:NavigationView.HeaderContent="Page 3"
+    mc:Ignorable="d">
+
+    <Grid>
+        <Grid.ColumnDefinitions>
+            <ColumnDefinition Width="*" />
+            <ColumnDefinition Width="*" />
+        </Grid.ColumnDefinitions>
+
+        <Button
+            Grid.Column="0"
+            HorizontalAlignment="Center"
+            Command="{Binding NavigateBackCommand}"
+            Content="Navigate back"
+            FontSize="24" />
+
+        <Button
+            Grid.Column="1"
+            HorizontalAlignment="Center"
+            Command="{Binding NavigateForwardCommand}"
+            CommandParameter="{x:Type local:MultilevelNavigationSamplePage1}"
+            Content="Navigate to the third page"
+            FontSize="24" />
+    </Grid>
+</Page>
diff --git a/src/Wpf.Ui.Gallery/Views/Pages/Samples/MultilevelNavigationSamplePage3.xaml.cs b/src/Wpf.Ui.Gallery/Views/Pages/Samples/MultilevelNavigationSamplePage3.xaml.cs
new file mode 100644
index 000000000..548529966
--- /dev/null
+++ b/src/Wpf.Ui.Gallery/Views/Pages/Samples/MultilevelNavigationSamplePage3.xaml.cs
@@ -0,0 +1,22 @@
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file, You can obtain one at https://opensource.org/licenses/MIT.
+// Copyright (C) Leszek Pomianowski and WPF UI Contributors.
+// All Rights Reserved.
+
+using Wpf.Ui.Controls.Navigation;
+using Wpf.Ui.Gallery.ViewModels.Pages.Navigation;
+
+namespace Wpf.Ui.Gallery.Views.Pages.Samples;
+
+public partial class MultilevelNavigationSamplePage3 : INavigableView<MultilevelNavigationSample>
+{
+    public MultilevelNavigationSamplePage3(MultilevelNavigationSample viewModel)
+    {
+        ViewModel = viewModel;
+        DataContext = viewModel;
+
+        InitializeComponent();
+    }
+
+    public MultilevelNavigationSample ViewModel { get; }
+}
diff --git a/src/Wpf.Ui.Gallery/Views/Windows/MainWindow.xaml b/src/Wpf.Ui.Gallery/Views/Windows/MainWindow.xaml
index df1b99c8d..c1f8cd485 100644
--- a/src/Wpf.Ui.Gallery/Views/Windows/MainWindow.xaml
+++ b/src/Wpf.Ui.Gallery/Views/Windows/MainWindow.xaml
@@ -28,17 +28,15 @@
         <ui:NavigationView
             x:Name="NavigationView"
             Grid.Row="1"
+            EnableDebugMessages="True"
             FooterMenuItemsSource="{Binding ViewModel.FooterMenuItems, Mode=OneWay}"
-            IsBackButtonVisible="Collapsed"
+            IsBackButtonVisible="Visible"
             IsPaneToggleVisible="False"
             MenuItemsSource="{Binding ViewModel.MenuItems, Mode=OneWay}"
             PaneDisplayMode="Left"
             SelectionChanged="OnNavigationSelectionChanged">
             <ui:NavigationView.Header>
-                <ui:NavigationViewBreadcrumb
-                    Margin="42,32,0,0"
-                    FontSize="28"
-                    FontWeight="DemiBold" />
+                <ui:BreadcrumbBar Margin="42,32,0,0" />
             </ui:NavigationView.Header>
             <ui:NavigationView.AutoSuggestBox>
                 <ui:AutoSuggestBox
diff --git a/src/Wpf.Ui/Common/TypedEventHandler.cs b/src/Wpf.Ui/Common/TypedEventHandler.cs
new file mode 100644
index 000000000..b08cc263d
--- /dev/null
+++ b/src/Wpf.Ui/Common/TypedEventHandler.cs
@@ -0,0 +1,22 @@
+// Based on Windows UI Library
+// Copyright(c) Microsoft Corporation.All rights reserved.
+
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file, You can obtain one at https://opensource.org/licenses/MIT.
+// Copyright (C) Leszek Pomianowski and WPF UI Contributors.
+// All Rights Reserved.
+
+using System.Windows;
+
+namespace Wpf.Ui.Common;
+
+/// <summary>
+/// Represents a method that handles general events.
+/// </summary>
+/// <typeparam name="TSender"></typeparam>
+/// <typeparam name="TArgs"></typeparam>
+/// <param name="sender"></param>
+/// <param name="args"></param>
+public delegate void TypedEventHandler<in TSender, in TArgs>(TSender sender, TArgs args)
+    where TSender : DependencyObject
+    where TArgs : RoutedEventArgs;
diff --git a/src/Wpf.Ui/Contracts/INavigationService.cs b/src/Wpf.Ui/Contracts/INavigationService.cs
index 11f5272c0..e7fa730c6 100644
--- a/src/Wpf.Ui/Contracts/INavigationService.cs
+++ b/src/Wpf.Ui/Contracts/INavigationService.cs
@@ -43,4 +43,17 @@ public interface INavigationService
     /// </summary>
     /// <param name="pageIdOrTargetTag">Id or tag of the page.</param>
     bool Navigate(string pageIdOrTargetTag);
+
+    /// <summary>
+    /// Navigates the NavigationView to the previous journal entry. 
+    /// </summary>
+    /// <returns></returns>
+    bool GoBack();
+
+    /// <summary>
+    /// Synchronously adds an element to the navigation stack and navigates current navigation Frame to the
+    /// </summary>
+    /// <param name="pageType"></param>
+    /// <returns></returns>
+    bool NavigateWithHierarchy(Type pageType);
 }
diff --git a/src/Wpf.Ui/Controls/Navigation/INavigationView.cs b/src/Wpf.Ui/Controls/Navigation/INavigationView.cs
index 7861d8408..f1eea75ce 100644
--- a/src/Wpf.Ui/Controls/Navigation/INavigationView.cs
+++ b/src/Wpf.Ui/Controls/Navigation/INavigationView.cs
@@ -11,6 +11,7 @@
 using System.Windows;
 using System.Windows.Controls;
 using Wpf.Ui.Animations;
+using Wpf.Ui.Common;
 using Wpf.Ui.Contracts;
 
 namespace Wpf.Ui.Controls.Navigation;
@@ -23,7 +24,7 @@ public interface INavigationView
     /// <summary>
     /// Gets or sets the header content.
     /// </summary>
-    object Header { get; set; }
+    object? Header { get; set; }
 
     /// <summary>
     /// Gets or sets the <see cref="Header"/> visibility.
@@ -38,22 +39,22 @@ public interface INavigationView
     /// <summary>
     /// Gets the collection of menu items displayed in the NavigationView.
     /// </summary>
-    IList? MenuItems { get; set; }
+    IList MenuItems { get; set; }
 
     /// <summary>
     /// Gets or sets an object source used to generate the content of the NavigationView menu.
     /// </summary>
-    object MenuItemsSource { get; set; }
+    object? MenuItemsSource { get; set; }
 
     /// <summary>
     /// Gets the list of objects to be used as navigation items in the footer menu.
     /// </summary>
-    IList? FooterMenuItems { get; set; }
+    IList FooterMenuItems { get; set; }
 
     /// <summary>
     /// Gets or sets the object that represents the navigation items to be used in the footer menu.
     /// </summary>
-    object FooterMenuItemsSource { get; set; }
+    object? FooterMenuItemsSource { get; set; }
 
     /// <summary>
     /// Gets the selected item.
@@ -63,7 +64,7 @@ public interface INavigationView
     /// <summary>
     /// Gets or sets a UI element that is shown at the top of the control, below the pane if PaneDisplayMode is Top.
     /// </summary>
-    object ContentOverlay { get; set; }
+    object? ContentOverlay { get; set; }
 
     /// <summary>
     /// Gets a value that indicates whether the back button is enabled or disabled.
@@ -99,12 +100,12 @@ public interface INavigationView
     /// <summary>
     /// Gets or sets the content for the pane header.
     /// </summary>
-    object PaneHeader { get; set; }
+    object? PaneHeader { get; set; }
 
     /// <summary>
     /// Gets or sets the content for the pane footer.
     /// </summary>
-    object PaneFooter { get; set; }
+    object? PaneFooter { get; set; }
 
     /// <summary>
     /// Gets a value that specifies how the pane and content areas of a NavigationView are being shown.
@@ -115,17 +116,17 @@ public interface INavigationView
     /// <summary>
     /// Gets or sets an AutoSuggestBox to be displayed in the NavigationView.
     /// </summary>
-    AutoSuggestBox AutoSuggestBox { get; set; }
+    AutoSuggestBox? AutoSuggestBox { get; set; }
 
     /// <summary>
     /// Gets or sets an TitleBar to be displayed in the NavigationView.
     /// </summary>
-    TitleBar TitleBar { get; set; }
+    TitleBar? TitleBar { get; set; }
 
     /// <summary>
     /// Template Property for <see cref="MenuItems"/> and <see cref="FooterMenuItems"/>.
     /// </summary>
-    ControlTemplate ItemTemplate { get; set; }
+    ControlTemplate? ItemTemplate { get; set; }
 
     /// <summary>
     /// Gets or sets a value deciding how long the effect of the transition between the pages should take.
@@ -140,56 +141,57 @@ public interface INavigationView
     /// <summary>
     /// Occurs when the NavigationView pane is opened.
     /// </summary>
-    event NavigationViewEvent PaneOpened;
+    event TypedEventHandler<NavigationView, RoutedEventArgs> PaneOpened;
 
     /// <summary>
     /// Occurs when the NavigationView pane is closed.
     /// </summary>
-    event NavigationViewEvent PaneClosed;
+    event TypedEventHandler<NavigationView, RoutedEventArgs> PaneClosed;
 
     /// <summary>
     /// Occurs when the currently selected item changes.
     /// </summary>
-    event NavigationViewEvent SelectionChanged;
+    event TypedEventHandler<NavigationView, RoutedEventArgs> SelectionChanged;
 
     /// <summary>
     /// Occurs when an item in the menu receives an interaction such as a click or tap.
     /// </summary>
-    event NavigationViewEvent ItemInvoked;
+    event TypedEventHandler<NavigationView, RoutedEventArgs> ItemInvoked;
 
     /// <summary>
     /// Occurs when the back button receives an interaction such as a click or tap.
     /// </summary>
-    event NavigationViewEvent BackRequested;
+    event TypedEventHandler<NavigationView, RoutedEventArgs> BackRequested;
 
     /// <summary>
-    /// Gets a value that indicates whether there is at least one entry in back navigation history.
+    /// Occurs when a new navigation is requested
     /// </summary>
-    bool CanGoBack { get; }
+    event TypedEventHandler<NavigationView, NavigatingCancelEventArgs> Navigating;
 
     /// <summary>
-    /// Synchronously navigates current navigation Frame to the
-    /// given Element.
+    /// Gets a value that indicates whether there is at least one entry in back navigation history.
     /// </summary>
-    bool Navigate(Type pageType);
+    bool CanGoBack { get; }
 
     /// <summary>
     /// Synchronously navigates current navigation Frame to the
     /// given Element.
     /// </summary>
-    bool Navigate(Type pageType, object dataContext);
+    bool Navigate(Type pageType, object? dataContext = null);
 
     /// <summary>
     /// Synchronously navigates current navigation Frame to the
     /// given Element.
     /// </summary>
-    bool Navigate(string pageIdOrTargetTag);
+    bool Navigate(string pageIdOrTargetTag, object? dataContext = null);
 
     /// <summary>
-    /// Synchronously navigates current navigation Frame to the
-    /// given Element.
+    /// Synchronously adds an element to the navigation stack and navigates current navigation Frame to the
     /// </summary>
-    bool Navigate(string pageIdOrTargetTag, object dataContext);
+    /// <param name="pageType"></param>
+    /// <param name="dataContext"></param>
+    /// <returns></returns>
+    bool NavigateWithHierarchy(Type pageType, object? dataContext = null);
 
     /// <summary>
     /// Replaces the contents of the navigation frame, without changing the currently selected item or triggering an <see cref="SelectionChanged"/>.
@@ -199,12 +201,7 @@ public interface INavigationView
     /// <summary>
     /// Replaces the contents of the navigation frame, without changing the currently selected item or triggering an <see cref="SelectionChanged"/>.
     /// </summary>
-    bool ReplaceContent(UIElement pageInstanceToEmbed);
-
-    /// <summary>
-    /// Replaces the contents of the navigation frame, without changing the currently selected item or triggering an <see cref="SelectionChanged"/>.
-    /// </summary>
-    bool ReplaceContent(UIElement pageInstanceToEmbed, object dataContext);
+    bool ReplaceContent(UIElement pageInstanceToEmbed, object? dataContext = null);
 
     /// <summary>
     /// Navigates the NavigationView to the next journal entry.
diff --git a/src/Wpf.Ui/Controls/Navigation/INavigationViewItem.cs b/src/Wpf.Ui/Controls/Navigation/INavigationViewItem.cs
index 1ec705092..7b4d780ed 100644
--- a/src/Wpf.Ui/Controls/Navigation/INavigationViewItem.cs
+++ b/src/Wpf.Ui/Controls/Navigation/INavigationViewItem.cs
@@ -24,21 +24,26 @@ public interface INavigationViewItem
     /// </summary>
     string Id { get; }
 
+    /// <summary>
+    /// Get or sets content
+    /// </summary>
+    object Content { get; set; }
+
     /// <summary>
     /// Gets or sets the icon displayed in the MenuItem object.
     /// <para>If it's a <see cref="SymbolIcon"/>, additional effects will be applied.</para>
     /// </summary>
-    object Icon { get; set; }
+    object? Icon { get; set; }
 
     /// <summary>
     /// Gets the collection of menu items displayed in the NavigationView.
     /// </summary>
-    IList? MenuItems { get; set; }
+    IList MenuItems { get; set; }
 
     /// <summary>
     /// Gets or sets an object source used to generate the content of the NavigationView menu.
     /// </summary>
-    object MenuItemsSource { get; set; }
+    object? MenuItemsSource { get; set; }
 
     /// <summary>
     /// Gets information whether the current element is active.
@@ -48,27 +53,46 @@ public interface INavigationViewItem
     /// <summary>
     /// Gets information whether the sub-<see cref="MenuItems"/> are expanded.
     /// </summary>
-    bool IsExpanded { get; }
+    bool IsExpanded { get; internal set; }
 
     /// <summary>
     /// A unique tag used by the parent navigation system for the purpose of searching and navigating.
     /// </summary>
-    public string TargetPageTag { get; set; }
+    string TargetPageTag { get; set; }
 
     /// <summary>
     /// The type of the page to be navigated. (Should be derived from <see cref="FrameworkElement"/>).
     /// </summary>
-    public Type TargetPageType { get; set; }
+    Type? TargetPageType { get; set; }
 
     /// <summary>
     /// Template Property
     /// </summary>
-    public ControlTemplate Template { get; set; }
+    ControlTemplate? Template { get; set; }
+
+    /// <summary>
+    /// Gets parent if in <see cref="MenuItems"/> collection
+    /// </summary>
+    INavigationViewItem? NavigationViewItemParent { get; internal set; }
 
     /// <summary>
     /// Add / Remove ClickEvent handler.
     /// </summary>
     [Category("Behavior")]
-    public event RoutedEventHandler Click;
+    event RoutedEventHandler Click;
+
+    internal bool IsMenuElement {get; set; }
+    
+    /// <summary>
+    /// Correctly activates
+    /// </summary>
+    /// <param name="paneDisplayMode"></param>
+    void Activate(NavigationViewPaneDisplayMode paneDisplayMode);
+
+    /// <summary>
+    /// Correctly deactivates
+    /// </summary>
+    /// <param name="paneDisplayMode"></param>
+    void Deactivate(NavigationViewPaneDisplayMode paneDisplayMode);
 }
 
diff --git a/src/Wpf.Ui/Controls/Navigation/NavigationView.AttachedProperties.cs b/src/Wpf.Ui/Controls/Navigation/NavigationView.AttachedProperties.cs
new file mode 100644
index 000000000..6d25f6bd7
--- /dev/null
+++ b/src/Wpf.Ui/Controls/Navigation/NavigationView.AttachedProperties.cs
@@ -0,0 +1,22 @@
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file, You can obtain one at https://opensource.org/licenses/MIT.
+// Copyright (C) Leszek Pomianowski and WPF UI Contributors.
+// All Rights Reserved.
+
+using System.Windows;
+
+namespace Wpf.Ui.Controls.Navigation;
+
+public partial class NavigationView
+{
+    public static readonly DependencyProperty HeaderContentProperty = 
+        DependencyProperty.RegisterAttached(
+            "HeaderContent",
+            typeof(object),
+            typeof(FrameworkElement),
+            new FrameworkPropertyMetadata(null)
+        );
+
+    public static object? GetHeaderContent(FrameworkElement target) => target.GetValue(HeaderContentProperty);
+    public static void SetHeaderContent(FrameworkElement target, object headerContent) => target.SetValue(HeaderContentProperty, headerContent);
+}
diff --git a/src/Wpf.Ui/Controls/Navigation/NavigationView.Base.cs b/src/Wpf.Ui/Controls/Navigation/NavigationView.Base.cs
index d8906e2c9..9ac3ae058 100644
--- a/src/Wpf.Ui/Controls/Navigation/NavigationView.Base.cs
+++ b/src/Wpf.Ui/Controls/Navigation/NavigationView.Base.cs
@@ -8,10 +8,13 @@
 
 using System;
 using System.Collections;
+using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Collections.Specialized;
 using System.ComponentModel;
+using System.Diagnostics;
 using System.Windows;
+using Wpf.Ui.Common;
 
 namespace Wpf.Ui.Controls.Navigation;
 
@@ -24,10 +27,14 @@ namespace Wpf.Ui.Controls.Navigation;
 [System.Drawing.ToolboxBitmap(typeof(NavigationView), "NavigationView.bmp")]
 public partial class NavigationView : System.Windows.Controls.Control, INavigationView
 {
-    private ObservableCollection<string>? _autoSuggestBoxItems;
+    private readonly ObservableCollection<string> _autoSuggestBoxItems = new();
+    private readonly ObservableCollection<NavigationViewBreadcrumbItem> _breadcrumbBarItems = new();
+
+    protected Dictionary<string, INavigationViewItem> PageIdOrTargetTagNavigationViewsDictionary = new();
+    protected Dictionary<Type, INavigationViewItem> PageTypeNavigationViewsDictionary = new();
 
     /// <inheritdoc/>
-    public INavigationViewItem? SelectedItem { get; private set; }
+    public INavigationViewItem? SelectedItem { get; protected set; }
 
     /// <summary>
     /// Static constructor which overrides default property metadata.
@@ -39,14 +46,10 @@ static NavigationView()
 
     public NavigationView()
     {
-        SelectedItem = null;
         NavigationParent = this;
 
-        SetValue(MenuItemsProperty,
-            new ObservableCollection<object>());
-
-        SetValue(FooterMenuItemsProperty,
-            new ObservableCollection<object>());
+        SetValue(MenuItemsProperty, new ObservableCollection<object>());
+        SetValue(FooterMenuItemsProperty, new ObservableCollection<object>());
 
         Loaded += OnLoaded;
         Unloaded += OnUnloaded;
@@ -58,33 +61,32 @@ protected override void OnInitialized(EventArgs e)
     {
         base.OnInitialized(e);
 
-        if (ItemTemplate != null)
-            UpdateMenuItemsTemplate();
-
-        if (Header is NavigationViewBreadcrumb navigationViewBreadcrumb)
-            navigationViewBreadcrumb.NavigationView = this;
-
-        if (MenuItems?.Count > 0)
-            OnMenuItemsChanged();
-
-        if (MenuItemsSource is IList menuItemsSourceList)
+        if (Header is BreadcrumbBar breadcrumbBar)
         {
-            if (MenuItems != null)
-                MenuItems = null;
+            breadcrumbBar.ItemsSource = _breadcrumbBarItems;
+            breadcrumbBar.ItemTemplate ??= Application.Current.TryFindResource("NavigationViewItemDataTemplate") as DataTemplate;
+            breadcrumbBar.ItemClicked += BreadcrumbBarOnItemClicked;
+        }
 
-            MenuItems = menuItemsSourceList;
+        if (AutoSuggestBox is not null)
+        {
+            AutoSuggestBox.ItemsSource = _autoSuggestBoxItems;
+            AutoSuggestBox.SuggestionChosen += AutoSuggestBoxOnSuggestionChosen;
         }
 
-        if (FooterMenuItems?.Count > 0)
-            OnFooterMenuItemsChanged();
+        InvalidateArrange();
+        InvalidateVisual();
+        UpdateLayout();
 
         UpdateAutoSuggestBoxSuggestions();
 
-        UpdateSelectionForMenuItems();
+        AddItemsToDictionaries();
     }
 
     private void OnLoaded(object sender, RoutedEventArgs e)
     {
+        NavigationStack.CollectionChanged += NavigationStackOnCollectionChanged;
+
         // TODO: Refresh
     }
 
@@ -93,11 +95,24 @@ private void OnLoaded(object sender, RoutedEventArgs e)
     /// </summary>
     protected virtual void OnUnloaded(object sender, RoutedEventArgs e)
     {
-        if (MenuItems is INotifyCollectionChanged menuItemsCollection)
-            menuItemsCollection.CollectionChanged -= OnMenuItemsCollectionChanged;
+        Loaded -= OnLoaded;
+        Unloaded -= OnUnloaded;
+        SizeChanged -= OnSizeChanged;
+
+        NavigationStack.CollectionChanged -= NavigationStackOnCollectionChanged;
 
-        if (FooterMenuItems is INotifyCollectionChanged footerMenuItemsCollection)
-            footerMenuItemsCollection.CollectionChanged -= OnFooterMenuItemsCollectionChanged;
+        PageIdOrTargetTagNavigationViewsDictionary.Clear();
+        PageTypeNavigationViewsDictionary.Clear();
+
+        ClearJournal();
+
+        if (AutoSuggestBox is not null)
+            AutoSuggestBox.SuggestionChosen -= AutoSuggestBoxOnSuggestionChosen;
+
+        if (Header is BreadcrumbBar breadcrumbBar)
+        {
+            breadcrumbBar.ItemClicked -= BreadcrumbBarOnItemClicked;
+        }
     }
 
     /// <summary>
@@ -114,6 +129,7 @@ protected virtual void OnSizeChanged(object sender, SizeChangedEventArgs e)
     protected virtual void OnBackButtonClick(object sender, RoutedEventArgs e)
     {
         GoBack();
+        OnBackRequested();
     }
 
     /// <summary>
@@ -121,33 +137,7 @@ protected virtual void OnBackButtonClick(object sender, RoutedEventArgs e)
     /// </summary>
     protected virtual void OnToggleButtonClick(object sender, RoutedEventArgs e)
     {
-#if DEBUG
-        System.Diagnostics.Debug.WriteLine("Toggle");
-#endif
-    }
-
-    /// <summary>
-    /// This virtual method is called when source of the menu items is changed.
-    /// </summary>
-    protected virtual void OnMenuItemsChanged()
-    {
-        InvalidateArrange();
-        InvalidateVisual();
-        UpdateLayout();
-
-        UpdateAutoSuggestBoxSuggestions();
-
-        UpdateSelectionForMenuItems();
-    }
-
-    /// <summary>
-    /// This virtual method is called when source of the footer menu items is changed.
-    /// </summary>
-    protected virtual void OnFooterMenuItemsChanged()
-    {
-        UpdateAutoSuggestBoxSuggestions();
-
-        UpdateSelectionForMenuItems();
+        Debug.WriteLine(EnableDebugMessages, "Toggle");
     }
 
     /// <summary>
@@ -181,22 +171,13 @@ internal void OnNavigationViewItemClick(NavigationViewItem navigationViewItem)
     {
         OnItemInvoked();
 
-        NavigateInternal(navigationViewItem, null, true, false);
+        NavigateInternal(navigationViewItem);
     }
 
-    private void UpdateMenuItemsTemplate()
+    protected virtual void BreadcrumbBarOnItemClicked(BreadcrumbBar sender, BreadcrumbBarItemClickedEventArgs e)
     {
-        if (MenuItems is IEnumerable enumerableItemsSource)
-            foreach (var singleMenuItem in enumerableItemsSource)
-                if (singleMenuItem is NavigationViewItem singleNavigationViewItem)
-                    if (ItemTemplate != null && singleNavigationViewItem.Template != ItemTemplate)
-                        singleNavigationViewItem.Template = ItemTemplate;
-
-        if (FooterMenuItems is IEnumerable enumerableFooterItemsSource)
-            foreach (var singleMenuItem in enumerableFooterItemsSource)
-                if (singleMenuItem is NavigationViewItem singleNavigationViewItem)
-                    if (ItemTemplate != null && singleNavigationViewItem.Template != ItemTemplate)
-                        singleNavigationViewItem.Template = ItemTemplate;
+        var item = (NavigationViewBreadcrumbItem)e.Item;
+        Navigate(item.PageId);
     }
 
     private void UpdateAutoSuggestBoxSuggestions()
@@ -204,38 +185,9 @@ private void UpdateAutoSuggestBoxSuggestions()
         if (AutoSuggestBox == null)
             return;
 
-        _autoSuggestBoxItems = new ObservableCollection<string>();
-
-        if (MenuItems is IEnumerable enumerableItemsSource)
-            foreach (var singleMenuItem in enumerableItemsSource)
-                if (singleMenuItem is NavigationViewItem singleNavigationViewItem)
-                {
-                    if (singleNavigationViewItem.Content is string content && singleNavigationViewItem.TargetPageType != null && !String.IsNullOrWhiteSpace(content))
-                        _autoSuggestBoxItems.Add(content);
-
-                    if (singleNavigationViewItem.MenuItems?.Count > 0)
-                        foreach (var subMenuItem in singleNavigationViewItem.MenuItems)
-                            if (subMenuItem is NavigationViewItem { Content: string subContent, TargetPageType: not null } && !String.IsNullOrWhiteSpace(subContent))
-                                _autoSuggestBoxItems.Add(subContent);
-                }
-
-        if (FooterMenuItems is IEnumerable enumerableFooterItemsSource)
-            foreach (var singleMenuItem in enumerableFooterItemsSource)
-                if (singleMenuItem is NavigationViewItem singleNavigationViewItem)
-                {
-                    if (singleNavigationViewItem.Content is string content && singleNavigationViewItem.TargetPageType != null && !String.IsNullOrWhiteSpace(content))
-                        _autoSuggestBoxItems.Add(content);
-
-                    if (singleNavigationViewItem.MenuItems?.Count > 0)
-                        foreach (var subMenuItem in singleNavigationViewItem.MenuItems)
-                            if (subMenuItem is NavigationViewItem { Content: string subContent, TargetPageType: not null } && !String.IsNullOrWhiteSpace(subContent))
-                                _autoSuggestBoxItems.Add(subContent);
-                }
-
-        AutoSuggestBox.ItemsSource = _autoSuggestBoxItems;
-
-        AutoSuggestBox.SuggestionChosen -= AutoSuggestBoxOnSuggestionChosen;
-        AutoSuggestBox.SuggestionChosen += AutoSuggestBoxOnSuggestionChosen;
+        _autoSuggestBoxItems.Clear();
+
+        AddItemsToAutoSuggestBoxItems();
     }
 
     /// <summary>
@@ -243,62 +195,151 @@ private void UpdateAutoSuggestBoxSuggestions()
     /// </summary>
     private void AutoSuggestBoxOnSuggestionChosen(object sender, RoutedEventArgs e)
     {
-        if (sender is not Controls.AutoSuggestBox autoSuggestBox)
+        if (sender is not AutoSuggestBox { ChosenSuggestion: string selectedSuggestBoxItem })
             return;
 
-        var selectedSuggestBoxItem = autoSuggestBox.ChosenSuggestion?.ToString() ?? String.Empty;
+        if (string.IsNullOrEmpty(selectedSuggestBoxItem))
+            return;
 
-        if (selectedSuggestBoxItem == String.Empty)
+        if (NavigateToMenuItemFromAutoSuggestBox(MenuItems, selectedSuggestBoxItem))
             return;
 
-        if (MenuItems is IEnumerable enumerableItemsSource)
-            foreach (var singleMenuItem in enumerableItemsSource)
-                if (singleMenuItem is NavigationViewItem singleNavigationViewItem)
-                {
-                    if (singleNavigationViewItem.Content is string content && content == selectedSuggestBoxItem)
-                    {
-                        NavigateInternal(singleNavigationViewItem, null, true, false);
-                        singleNavigationViewItem.BringIntoView();
-                        singleNavigationViewItem.Focus();
-
-                        return;
-                    }
-
-                    if (singleNavigationViewItem.MenuItems?.Count > 0)
-                        foreach (var subMenuItem in singleNavigationViewItem.MenuItems)
-                            if (subMenuItem is NavigationViewItem { Content: string subContent } subMenuNavigationViewItem && subContent == selectedSuggestBoxItem)
-                            {
-                                NavigateInternal(subMenuNavigationViewItem, null, true, false);
-                                subMenuNavigationViewItem.BringIntoView();
-                                subMenuNavigationViewItem.Focus();
-
-                                return;
-                            }
-                }
-
-        if (FooterMenuItems is IEnumerable enumerableFooterItemsSource)
-            foreach (var singleMenuItem in enumerableFooterItemsSource)
-                if (singleMenuItem is NavigationViewItem singleNavigationViewItem)
-                {
-                    if (singleNavigationViewItem.Content is string content && content == selectedSuggestBoxItem)
-                    {
-                        NavigateInternal(singleNavigationViewItem, null, true, false);
-                        singleNavigationViewItem.BringIntoView();
-                        singleNavigationViewItem.Focus();
-
-                        return;
-                    }
-
-                    if (singleNavigationViewItem.MenuItems?.Count > 0)
-                        foreach (var subMenuItem in singleNavigationViewItem.MenuItems)
-                            if (subMenuItem is NavigationViewItem { Content: string subContent } subMenuNavigationViewItem && subContent == selectedSuggestBoxItem)
-                            {
-                                NavigateInternal(subMenuNavigationViewItem, null, true, false);
-                                subMenuNavigationViewItem.BringIntoView();
-                                subMenuNavigationViewItem.Focus();
-
-                                return;
-                            }
-                }
+        NavigateToMenuItemFromAutoSuggestBox(FooterMenuItems, selectedSuggestBoxItem);
+    }
+
+    protected virtual void AddItemsToDictionaries(IList list)
+    {
+        for (var i = 0; i < list.Count; i++)
+        {
+            var singleMenuItem = list[i];
+
+            if (singleMenuItem is not INavigationViewItem singleNavigationViewItem)
+                continue;
+
+            if (!PageIdOrTargetTagNavigationViewsDictionary.ContainsKey(singleNavigationViewItem.Id))
+            {
+                PageIdOrTargetTagNavigationViewsDictionary.Add(singleNavigationViewItem.Id, singleNavigationViewItem);
+            }
+
+            if (!PageIdOrTargetTagNavigationViewsDictionary.ContainsKey(singleNavigationViewItem.TargetPageTag))
+            {
+                PageIdOrTargetTagNavigationViewsDictionary.Add(singleNavigationViewItem.TargetPageTag, singleNavigationViewItem);
+            }
+
+            if (singleNavigationViewItem.TargetPageType is not null && !PageTypeNavigationViewsDictionary.ContainsKey(singleNavigationViewItem.TargetPageType))
+            {
+                PageTypeNavigationViewsDictionary.Add(singleNavigationViewItem.TargetPageType, singleNavigationViewItem);
+            }
+
+            singleNavigationViewItem.IsMenuElement = true;
+
+            if (singleNavigationViewItem.MenuItems.Count <= 0)
+                continue;
+
+            AddItemsToDictionaries(singleNavigationViewItem.MenuItems);
+        }
+    }
+
+    protected virtual void AddItemsToDictionaries()
+    {
+        AddItemsToDictionaries(MenuItems);
+        AddItemsToDictionaries(FooterMenuItems);
+    }
+
+    protected virtual void AddItemsToAutoSuggestBoxItems(IList list)
+    {
+        for (var i = 0; i < list.Count; i++)
+        {
+            var singleMenuItem = list[i];
+
+            if (singleMenuItem is not NavigationViewItem singleNavigationViewItem)
+                continue;
+
+            if (singleNavigationViewItem is { Content: string content, TargetPageType: { } } &&
+                !string.IsNullOrWhiteSpace(content))
+                _autoSuggestBoxItems.Add(content);
+
+            if (singleNavigationViewItem.MenuItems.Count <= 0)
+                continue;
+
+            AddItemsToAutoSuggestBoxItems(singleNavigationViewItem.MenuItems);
+        }
+    }
+
+    protected virtual void AddItemsToAutoSuggestBoxItems()
+    {
+        AddItemsToAutoSuggestBoxItems(MenuItems);
+        AddItemsToAutoSuggestBoxItems(FooterMenuItems);
+    }
+
+    protected virtual bool NavigateToMenuItemFromAutoSuggestBox(IList list, string selectedSuggestBoxItem)
+    {
+        for (var i = 0; i < list.Count; i++)
+        {
+            var singleMenuItem = list[i];
+
+            if (singleMenuItem is not NavigationViewItem singleNavigationViewItem)
+                continue;
+
+            if (singleNavigationViewItem.Content is string content && content == selectedSuggestBoxItem)
+            {
+                NavigateInternal(singleNavigationViewItem);
+                singleNavigationViewItem.BringIntoView();
+                singleNavigationViewItem.Focus(); // TODO: Element or content?
+
+                return true;
+            }
+
+            if (singleNavigationViewItem.MenuItems.Count <= 0)
+                continue;
+
+            NavigateToMenuItemFromAutoSuggestBox(singleNavigationViewItem.MenuItems, selectedSuggestBoxItem);
+        }
+
+        return false;
+    }
+
+    protected virtual void UpdateMenuItemsTemplate(IList list)
+    {
+        for (var i = 0; i < list.Count; i++)
+        {
+            var singleMenuItem = list[i];
+
+            if (singleMenuItem is not NavigationViewItem singleNavigationViewItem)
+                continue;
+
+            if (ItemTemplate is not null && singleNavigationViewItem.Template != ItemTemplate)
+                singleNavigationViewItem.Template = ItemTemplate;
+        }
+    }
+
+    protected virtual void UpdateMenuItemsTemplate()
+    {
+        UpdateMenuItemsTemplate(MenuItems);
+        UpdateMenuItemsTemplate(FooterMenuItems);
+    }
+
+    [DebuggerStepThrough]
+    private void NavigationStackOnCollectionChanged(object? sender, NotifyCollectionChangedEventArgs e)
+    {
+        switch (e.Action)
+        {
+            case NotifyCollectionChangedAction.Add:
+                _breadcrumbBarItems.Add(new NavigationViewBreadcrumbItem((INavigationViewItem)e.NewItems![0]!));
+                break;
+            case NotifyCollectionChangedAction.Remove:
+                _breadcrumbBarItems.RemoveAt(e.OldStartingIndex);
+                break;
+            case NotifyCollectionChangedAction.Replace:
+                _breadcrumbBarItems[0] = new NavigationViewBreadcrumbItem((INavigationViewItem)e.NewItems![0]!);
+                break;
+            case NotifyCollectionChangedAction.Move:
+                break;
+            case NotifyCollectionChangedAction.Reset:
+                _breadcrumbBarItems.Clear();
+                break;
+            default:
+                throw new ArgumentOutOfRangeException();
+        }
     }
 }
diff --git a/src/Wpf.Ui/Controls/Navigation/NavigationView.Events.cs b/src/Wpf.Ui/Controls/Navigation/NavigationView.Events.cs
index 07e01bc64..c5111849a 100644
--- a/src/Wpf.Ui/Controls/Navigation/NavigationView.Events.cs
+++ b/src/Wpf.Ui/Controls/Navigation/NavigationView.Events.cs
@@ -6,7 +6,9 @@
 // Copyright (C) Leszek Pomianowski and WPF UI Contributors.
 // All Rights Reserved.
 
+using System.Diagnostics;
 using System.Windows;
+using Wpf.Ui.Common;
 
 namespace Wpf.Ui.Controls.Navigation;
 
@@ -16,104 +18,136 @@ public partial class NavigationView
     /// Property for <see cref="PaneOpened"/>.
     /// </summary>
     public static readonly RoutedEvent PaneOpenedEvent = EventManager.RegisterRoutedEvent(nameof(PaneOpened),
-        RoutingStrategy.Bubble, typeof(NavigationViewEvent), typeof(NavigationView));
+        RoutingStrategy.Bubble, typeof(TypedEventHandler<NavigationView, RoutedEventArgs>), typeof(NavigationView));
 
     /// <summary>
     /// Property for <see cref="PaneClosed"/>.
     /// </summary>
     public static readonly RoutedEvent PaneClosedEvent = EventManager.RegisterRoutedEvent(nameof(PaneClosed),
-        RoutingStrategy.Bubble, typeof(NavigationViewEvent), typeof(NavigationView));
+        RoutingStrategy.Bubble, typeof(TypedEventHandler<NavigationView, RoutedEventArgs>), typeof(NavigationView));
 
     /// <summary>
     /// Property for <see cref="SelectionChanged"/>.
     /// </summary>
     public static readonly RoutedEvent SelectionChangedEvent = EventManager.RegisterRoutedEvent(nameof(SelectionChanged),
-        RoutingStrategy.Bubble, typeof(NavigationViewEvent), typeof(NavigationView));
+        RoutingStrategy.Bubble, typeof(TypedEventHandler<NavigationView, RoutedEventArgs>), typeof(NavigationView));
 
     /// <summary>
     /// Property for <see cref="ItemInvoked"/>.
     /// </summary>
     public static readonly RoutedEvent ItemInvokedEvent = EventManager.RegisterRoutedEvent(nameof(ItemInvoked),
-        RoutingStrategy.Bubble, typeof(NavigationViewEvent), typeof(NavigationView));
+        RoutingStrategy.Bubble, typeof(TypedEventHandler<NavigationView, RoutedEventArgs>), typeof(NavigationView));
 
     /// <summary>
     /// Property for <see cref="BackRequested"/>.
     /// </summary>
     public static readonly RoutedEvent BackRequestedEvent = EventManager.RegisterRoutedEvent(nameof(BackRequested),
-        RoutingStrategy.Bubble, typeof(NavigationViewEvent), typeof(NavigationView));
+        RoutingStrategy.Bubble, typeof(TypedEventHandler<NavigationView, RoutedEventArgs>), typeof(NavigationView));
+    /// <summary>
+    /// Property for <see cref="Navigating"/>.
+    /// </summary>
+    public static readonly RoutedEvent NavigatingEvent = EventManager.RegisterRoutedEvent(nameof(Navigating),
+        RoutingStrategy.Bubble, typeof(TypedEventHandler<NavigationView, NavigatingCancelEventArgs>), typeof(NavigationView));
 
     /// <inheritdoc/>
-    public event NavigationViewEvent PaneOpened
+    public event TypedEventHandler<NavigationView, RoutedEventArgs> PaneOpened
     {
         add => AddHandler(PaneOpenedEvent, value);
         remove => RemoveHandler(PaneOpenedEvent, value);
     }
 
     /// <inheritdoc/>
-    public event NavigationViewEvent PaneClosed
+    public event TypedEventHandler<NavigationView, RoutedEventArgs> PaneClosed
     {
         add => AddHandler(PaneClosedEvent, value);
         remove => RemoveHandler(PaneClosedEvent, value);
     }
 
     /// <inheritdoc/>
-    public event NavigationViewEvent SelectionChanged
+    public event TypedEventHandler<NavigationView, RoutedEventArgs> SelectionChanged
     {
         add => AddHandler(SelectionChangedEvent, value);
         remove => RemoveHandler(SelectionChangedEvent, value);
     }
 
     /// <inheritdoc/>
-    public event NavigationViewEvent ItemInvoked
+    public event TypedEventHandler<NavigationView, RoutedEventArgs> ItemInvoked
     {
         add => AddHandler(ItemInvokedEvent, value);
         remove => RemoveHandler(ItemInvokedEvent, value);
     }
 
     /// <inheritdoc/>
-    public event NavigationViewEvent BackRequested
+    public event TypedEventHandler<NavigationView, RoutedEventArgs> BackRequested
     {
         add => AddHandler(BackRequestedEvent, value);
         remove => RemoveHandler(BackRequestedEvent, value);
     }
 
+    /// <inheritdoc/>
+    public event TypedEventHandler<NavigationView, NavigatingCancelEventArgs> Navigating
+    {
+        add => AddHandler(NavigatingEvent, value);
+        remove => RemoveHandler(NavigatingEvent, value);
+    }
+
     /// <summary>
     /// Raises the pane opened event.
     /// </summary>
+    [DebuggerStepThrough]
     protected virtual void OnPaneOpened()
     {
-        RaiseEvent(new RoutedEventArgs(PaneOpenedEvent));
+        RaiseEvent(new RoutedEventArgs(PaneOpenedEvent, this));
     }
 
     /// <summary>
     /// Raises the pane closed event.
     /// </summary>
+    [DebuggerStepThrough]
     protected virtual void OnPaneClosed()
     {
-        RaiseEvent(new RoutedEventArgs(PaneClosedEvent));
+        RaiseEvent(new RoutedEventArgs(PaneClosedEvent, this));
     }
 
     /// <summary>
     /// Raises the selection changed event.
     /// </summary>
+    [DebuggerStepThrough]
     protected virtual void OnSelectionChanged()
     {
-        RaiseEvent(new RoutedEventArgs(SelectionChangedEvent));
+        RaiseEvent(new RoutedEventArgs(SelectionChangedEvent, this));
     }
 
     /// <summary>
     /// Raises the item invoked event.
     /// </summary>
+    [DebuggerStepThrough]
     protected virtual void OnItemInvoked()
     {
-        RaiseEvent(new RoutedEventArgs(ItemInvokedEvent));
+        RaiseEvent(new RoutedEventArgs(ItemInvokedEvent, this));
     }
 
     /// <summary>
     /// Raises the back requested event.
     /// </summary>
+    [DebuggerStepThrough]
     protected virtual void OnBackRequested()
     {
         RaiseEvent(new RoutedEventArgs(BackRequestedEvent));
     }
+
+    /// <summary>
+    /// Raises the navigating requested event.
+    /// </summary>
+    /// <param name="sourcePageType"></param>
+    /// <returns></returns>
+    [DebuggerStepThrough]
+    protected virtual bool OnNavigating(object sourcePageType)
+    {
+        var eventArgs = new NavigatingCancelEventArgs(NavigatingEvent, this, sourcePageType);
+
+        RaiseEvent(eventArgs);
+
+        return eventArgs.Cancel;
+    }
 }
diff --git a/src/Wpf.Ui/Controls/Navigation/NavigationView.Navigation.cs b/src/Wpf.Ui/Controls/Navigation/NavigationView.Navigation.cs
index c4bf5b936..56412eecd 100644
--- a/src/Wpf.Ui/Controls/Navigation/NavigationView.Navigation.cs
+++ b/src/Wpf.Ui/Controls/Navigation/NavigationView.Navigation.cs
@@ -6,31 +6,30 @@
 // Copyright (C) Leszek Pomianowski and WPF UI Contributors.
 // All Rights Reserved.
 
-#nullable enable
-
 using System;
-using System.Collections;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Diagnostics;
 using System.Windows;
-using System.Windows.Navigation;
-using Wpf.Ui.Animations;
 using Wpf.Ui.Contracts;
 
 namespace Wpf.Ui.Controls.Navigation;
 
 public partial class NavigationView
 {
-    private IServiceProvider? _serviceProvider = null;
+    protected readonly List<string> Journal = new(50);
+    protected readonly ObservableCollection<INavigationViewItem> NavigationStack = new();
 
-    private IPageService? _pageService = null;
+    private readonly Dictionary<INavigationViewItem, List<INavigationViewItem?[]>> _complexNavigationStackHistory = new();
 
-    private readonly List<string> _journal = new();
+    private IServiceProvider? _serviceProvider;
+    private IPageService? _pageService;
 
-    private int _currentIndexInJournal = 0;
+    private int _currentIndexInJournal;
 
     /// <inheritdoc />
     public bool CanGoBack
-        => _journal.Count > 1 && _currentIndexInJournal >= 0;
+        => Journal.Count > 1 && _currentIndexInJournal >= 0;
 
     /// <inheritdoc />
     public void SetPageService(IPageService pageService)
@@ -41,75 +40,41 @@ public void SetServiceProvider(IServiceProvider serviceProvider)
         => _serviceProvider = serviceProvider;
 
     /// <inheritdoc />
-    public bool Navigate(Type pageType)
-        => Navigate(pageType, null!);
-
-    /// <inheritdoc />
-    public bool Navigate(Type pageType, object dataContext)
+    public virtual bool Navigate(Type pageType, object? dataContext = null)
     {
-        if (MenuItems is IEnumerable enumerableMenuItems)
-            foreach (var singleMenuItem in enumerableMenuItems)
-                if (singleMenuItem is NavigationViewItem singleNavigationViewItem)
-                {
-                    if (singleNavigationViewItem.TargetPageType != null && singleNavigationViewItem.TargetPageType == pageType)
-                        return NavigateInternal(singleNavigationViewItem, dataContext, true, true); ;
-
-                    if (singleNavigationViewItem?.MenuItems?.Count > 0)
-                        foreach (var subMenuItem in singleNavigationViewItem.MenuItems)
-                            if (subMenuItem is NavigationViewItem subMenuNavigationViewItem)
-                                if (subMenuNavigationViewItem.TargetPageType != null && subMenuNavigationViewItem.TargetPageType == pageType)
-                                    return NavigateInternal(subMenuNavigationViewItem, dataContext, true, true);
-                }
-
-        if (FooterMenuItems is IEnumerable enumerableFooterMenuItems)
-            foreach (var singleMenuItem in enumerableFooterMenuItems)
-                if (singleMenuItem is NavigationViewItem singleNavigationViewItem)
-                {
-                    if (singleNavigationViewItem.TargetPageType != null && singleNavigationViewItem.TargetPageType == pageType)
-                        return NavigateInternal(singleNavigationViewItem, dataContext, true, true);
-
-                    if (singleNavigationViewItem?.MenuItems?.Count > 0)
-                        foreach (var subMenuItem in singleNavigationViewItem.MenuItems)
-                            if (subMenuItem is NavigationViewItem subMenuNavigationViewItem)
-                                if (subMenuNavigationViewItem.TargetPageType != null && subMenuNavigationViewItem.TargetPageType == pageType)
-                                    return NavigateInternal(subMenuNavigationViewItem, dataContext, true, true);
-                }
-
-        return false;
+        if (!PageTypeNavigationViewsDictionary.TryGetValue(pageType, out var navigationViewItem))
+            return TryToNavigateWithoutINavigationViewItem(pageType, false, dataContext);
+
+        return NavigateInternal(navigationViewItem, dataContext);
     }
 
     /// <inheritdoc />
-    public bool Navigate(string pageIdOrTargetTag)
-        => Navigate(pageIdOrTargetTag, null!);
+    public virtual bool Navigate(string pageIdOrTargetTag, object? dataContext = null)
+    {
+        if (!PageIdOrTargetTagNavigationViewsDictionary.TryGetValue(pageIdOrTargetTag, out var navigationViewItem))
+            return false;
+
+        return NavigateInternal(navigationViewItem, dataContext);
+    }
 
     /// <inheritdoc />
-    public bool Navigate(string pageIdOrTargetTag, object dataContext)
+    public virtual bool NavigateWithHierarchy(Type pageType, object? dataContext = null)
     {
-        if (MenuItems is IEnumerable enumerableMenuItems)
-            foreach (var singleMenuItem in enumerableMenuItems)
-                if (singleMenuItem is NavigationViewItem singleNavigationViewItem)
-                    if (singleNavigationViewItem.Id == pageIdOrTargetTag || singleNavigationViewItem?.TargetPageTag == pageIdOrTargetTag)
-                        return NavigateInternal(singleNavigationViewItem, dataContext, true, true);
-
-        if (FooterMenuItems is IEnumerable enumerableFooterMenuItems)
-            foreach (var singleMenuItem in enumerableFooterMenuItems)
-                if (singleMenuItem is NavigationViewItem singleNavigationViewItem)
-                    if (singleNavigationViewItem.Id == pageIdOrTargetTag ||
-                        singleNavigationViewItem?.TargetPageTag == pageIdOrTargetTag)
-                        return NavigateInternal(singleNavigationViewItem, dataContext, true, true);
-
-        return false;
+        if (!PageTypeNavigationViewsDictionary.TryGetValue(pageType, out var navigationViewItem))
+            return TryToNavigateWithoutINavigationViewItem(pageType, true, dataContext);
+
+        return NavigateInternal(navigationViewItem, dataContext, true);
     }
 
     /// <inheritdoc />
-    public bool ReplaceContent(Type? pageTypeToEmbed)
+    public virtual bool ReplaceContent(Type? pageTypeToEmbed)
     {
         if (pageTypeToEmbed == null)
             return false;
 
         if (_serviceProvider != null)
         {
-            UpdateContent(_serviceProvider.GetService(pageTypeToEmbed) ?? null!, null!);
+            UpdateContent(_serviceProvider.GetService(pageTypeToEmbed));
 
             return true;
         }
@@ -117,19 +82,13 @@ public bool ReplaceContent(Type? pageTypeToEmbed)
         if (_pageService == null)
             return false;
 
-        UpdateContent(_pageService.GetPage(pageTypeToEmbed) ?? null!, null!);
+        UpdateContent(_pageService.GetPage(pageTypeToEmbed));
 
         return true;
     }
 
     /// <inheritdoc />
-    public bool ReplaceContent(UIElement pageInstanceToEmbed)
-    {
-        return ReplaceContent(pageInstanceToEmbed, null!);
-    }
-
-    /// <inheritdoc />
-    public bool ReplaceContent(UIElement pageInstanceToEmbed, object dataContext)
+    public virtual bool ReplaceContent(UIElement pageInstanceToEmbed, object? dataContext = null)
     {
         UpdateContent(pageInstanceToEmbed, dataContext);
 
@@ -137,272 +96,285 @@ public bool ReplaceContent(UIElement pageInstanceToEmbed, object dataContext)
     }
 
     /// <inheritdoc />
-    public bool GoForward()
+    public virtual bool GoForward()
     {
-        if (_journal.Count <= 1)
+        throw new NotImplementedException();
+
+        if (Journal.Count <= 1)
             return false;
 
         _currentIndexInJournal += 1;
 
-        if (_currentIndexInJournal > _journal.Count - 1)
+        if (_currentIndexInJournal > Journal.Count - 1)
             return false;
 
-        return Navigate(_journal[_currentIndexInJournal], null!);
+        return Navigate(Journal[_currentIndexInJournal]);
     }
 
     /// <inheritdoc />
-    public bool GoBack()
+    public virtual bool GoBack()
     {
-        if (_journal.Count <= 1)
+        if (Journal.Count <= 1)
             return false;
 
-        _currentIndexInJournal -= 1;
-
-        if (_currentIndexInJournal < 0)
-            return false;
+        var itemId = Journal[Journal.Count - 2];
 
-        return Navigate(_journal[_currentIndexInJournal], null!);
+        return NavigateInternal(PageIdOrTargetTagNavigationViewsDictionary[itemId], null, false, true);
     }
 
     /// <inheritdoc />
-    public void ClearJournal()
+    public virtual void ClearJournal()
     {
-        _journal.Clear();
         _currentIndexInJournal = 0;
+
+        Journal.Clear();
+        _complexNavigationStackHistory.Clear();
     }
 
-    private bool NavigateInternal(INavigationViewItem viewItem, object? dataContext, bool notifyAboutUpdate, bool bringIntoView)
+    private bool TryToNavigateWithoutINavigationViewItem(Type pageType, bool addToNavigationStack, object? dataContext = null)
     {
-        if (viewItem == SelectedItem)
+        var navigationViewItem = new NavigationViewItem(pageType);
+
+        if (!NavigateInternal(navigationViewItem, dataContext, addToNavigationStack))
             return false;
 
-        UpdateJournal(viewItem);
+        PageTypeNavigationViewsDictionary.Add(pageType, navigationViewItem);
+        PageIdOrTargetTagNavigationViewsDictionary.Add(navigationViewItem.Id, navigationViewItem);
 
-        IsBackEnabled = _journal.Count > 0;
+        return true;
+    }
 
-#if DEBUG
-        System.Diagnostics.Debug.WriteLine($"DEBUG | {viewItem.Id} - {viewItem.TargetPageTag ?? "NO_TAG"} | NAVIGATED");
-#endif
+    private bool NavigateInternal(INavigationViewItem viewItem, object? dataContext = null, bool addToNavigationStack = false, bool isBackwardsNavigated = false)
+    {
+        if (NavigationStack.Count > 0 && NavigationStack[NavigationStack.Count -1] == viewItem)
+            return false;
 
-        RenderSelectedItemContent(viewItem, dataContext);
+        Debug.WriteLineIf(EnableDebugMessages, $"DEBUG | {viewItem.Id} - {(string.IsNullOrEmpty(viewItem.TargetPageTag) ? "NO_TAG" : viewItem.TargetPageTag)} - {viewItem.TargetPageType} | NAVIGATED");
 
-        if (!notifyAboutUpdate)
-            return true;
+        var pageInstance = GetNavigationItemInstance(viewItem);
+
+        if (OnNavigating(pageInstance))
+        {
+            Debug.WriteLineIf(EnableDebugMessages, "Navigation canceled");
+            return false;
+        }
 
-        SelectedItem = viewItem;
+        ApplyAttachedProperties(viewItem, pageInstance);
+        UpdateContent(pageInstance, dataContext);
 
-        UpdateSelectionForMenuItems();
-        OnSelectionChanged();
+        AddToNavigationStack(viewItem, addToNavigationStack, isBackwardsNavigated);
+        AddToJournal(viewItem, isBackwardsNavigated);
 
-        if (bringIntoView && viewItem is FrameworkElement frameworkElement)
+        if (SelectedItem != NavigationStack[0] && NavigationStack[0].IsMenuElement)
         {
-            frameworkElement.BringIntoView();
-            frameworkElement.Focus(); // TODO: Element or content?
+            SelectedItem = NavigationStack[0];
+            OnSelectionChanged();
         }
-
+        
         return true;
     }
 
-    private void UpdateJournal(INavigationViewItem viewItem)
+    private void AddToJournal(INavigationViewItem viewItem, bool isBackwardsNavigated)
     {
-#if DEBUG
-        System.Diagnostics.Debug.WriteLine($"JOURNAL INDEX {_currentIndexInJournal}");
-        if (_journal.Count > 0)
-            System.Diagnostics.Debug.WriteLine($"JOURNAL LAST ELEMENT {_journal[_journal.Count - 1]}");
-#endif
-
-        if (_journal.Count == 0)
+        if (isBackwardsNavigated)
         {
-            _currentIndexInJournal = 0;
-            _journal.Add(viewItem.Id);
+            Journal.RemoveAt(Journal.LastIndexOf(Journal[Journal.Count - 2]));
+            Journal.RemoveAt(Journal.LastIndexOf(Journal[Journal.Count - 1]));
 
-            return;
+            _currentIndexInJournal -= 2;
         }
 
-        // TODO: Fix at last position
+        Journal.Add(viewItem.Id);
+        _currentIndexInJournal++;
+
+        IsBackEnabled = CanGoBack;
 
-        if (_currentIndexInJournal == _journal.Count - 1)
+#if DEBUG
+        Debug.WriteLineIf(EnableDebugMessages, $"JOURNAL INDEX {_currentIndexInJournal}");
+        if (Journal.Count > 0)
+            Debug.WriteLineIf(EnableDebugMessages, $"JOURNAL LAST ELEMENT {Journal[Journal.Count - 1]}");
+#endif
+    }
+
+    private object GetNavigationItemInstance(INavigationViewItem viewItem)
+    {
+        if (viewItem.TargetPageType is null)
+            throw new ArgumentNullException(nameof(viewItem.TargetPageType));
+
+        if (_serviceProvider is not null)
         {
-            _journal.Add(viewItem.Id);
+            return _serviceProvider.GetService(viewItem.TargetPageType) ??
+                   new ArgumentNullException($"{nameof(_serviceProvider.GetService)} returned null");
+        }
 
-            _currentIndexInJournal++;
+        if (_pageService is not null)
+        {
+            return _pageService.GetPage(viewItem.TargetPageType) ??
+                   throw new ArgumentNullException($"{nameof(_pageService.GetPage)} returned null");
         }
 
-        if (_journal.Count > 20)
-            _journal.RemoveAt(0);
+        return NavigationViewActivator.CreateInstance(viewItem.TargetPageType) ??
+               throw new ArgumentException("Failed to create instance of the page");
     }
 
-    private void RenderSelectedItemContent(INavigationViewItem viewItem, object? dataContext)
+    private static void ApplyAttachedProperties(INavigationViewItem viewItem, object pageInstance)
     {
-        if (_serviceProvider != null)
-        {
-            if (viewItem.TargetPageType == null)
-                return;
+        if (pageInstance is FrameworkElement frameworkElement && GetHeaderContent(frameworkElement) is {} headerContent)
+            viewItem.Content = headerContent;
+    }
 
-            UpdateContent(_serviceProvider.GetService(viewItem.TargetPageType) ?? null!, dataContext);
+    private void UpdateContent(object? content, object? dataContext = null)
+    {
+        if (dataContext is not null && content is FrameworkElement frameworkViewContent)
+            frameworkViewContent.DataContext = dataContext;
 
-            return;
-        }
+        NavigationViewContentPresenter.Navigate(content);
+    }
 
-        if (_pageService != null)
-        {
-            if (viewItem.TargetPageType == null)
-                return;
+    #region Navigation stack methods
 
-            UpdateContent(_pageService.GetPage(viewItem.TargetPageType) ?? null!, dataContext);
+    private void AddToNavigationStack(INavigationViewItem viewItem, bool addToNavigationStack, bool isBackwardsNavigated)
+    {
+        if (isBackwardsNavigated)
+            RecreateNavigationStackFromHistory(viewItem);
 
-            return;
+        if (addToNavigationStack && !NavigationStack.Contains(viewItem))
+        {
+            viewItem.Activate(PaneDisplayMode);
+            NavigationStack.Add(viewItem);
         }
 
-        if (viewItem.TargetPageType == null)
-            return;
-
-        var pageInstance = NavigationViewActivator.CreateInstance(viewItem.TargetPageType);
-
-        if (pageInstance == null)
-            return;
+        if (!addToNavigationStack)
+            UpdateCurrentNavigationStackItem(viewItem);
 
-        UpdateContent(pageInstance, dataContext);
+        ClearNavigationStack(viewItem);
     }
 
-    private void UpdateContent(object? content, object? dataContext)
+    private void UpdateCurrentNavigationStackItem(INavigationViewItem viewItem)
     {
-        if (NavigationViewContentPresenter == null)
+        if (NavigationStack.Contains(viewItem))
             return;
 
-        NotifyContentAboutNavigatingFrom(NavigationViewContentPresenter?.Content ?? null);
+        if (NavigationStack.Count > 1)
+            AddToNavigationStackHistory(viewItem);
 
-        if (dataContext != null && content is FrameworkElement frameworkViewContent)
-            frameworkViewContent.DataContext = dataContext;
+        if (NavigationStack.Count == 0)
+        {
+            viewItem.Activate(PaneDisplayMode);
+            NavigationStack.Add(viewItem);
+        }
+        else
+        {
+            ReplaceThirstElementInNavigationStack(viewItem);
+        }
 
-        NavigationViewContentPresenter!.Navigate(content);
+        ClearNavigationStack(1);
     }
 
-    protected virtual void OnNavigationViewContentPresenterNavigated(object sender, NavigationEventArgs e)
+    private void RecreateNavigationStackFromHistory(INavigationViewItem item)
     {
-        if (sender is not NavigationViewContentPresenter contentPresenter)
+        if (!_complexNavigationStackHistory.TryGetValue(item, out var historyList) || historyList.Count == 0)
             return;
 
-        NotifyContentAboutNavigatingTo(contentPresenter?.Content ?? null);
+        var latestHistory = historyList[historyList.Count - 1];
+        var startIndex = 0;
+
+        if (latestHistory[0]!.IsMenuElement)
+        {
+            startIndex = 1;
+            ReplaceThirstElementInNavigationStack(latestHistory[0]!);
+        }
+
+        for (int i = startIndex; i < latestHistory.Length; i++)
+        {
+            if (latestHistory[i] is null)
+                break;
 
-        if (contentPresenter != null)
-            ApplyTransitionEffectToNavigatedPage(contentPresenter);
+            AddToNavigationStack(latestHistory[i]!, true, false);
+        }
+
+        historyList.Remove(latestHistory);
+        /*if (historyList.Count == 0)
+            _complexNavigationStackHistory.Remove(item);
+        */
+
+#if NET6_0_OR_GREATER
+        System.Buffers.ArrayPool<INavigationViewItem>.Shared.Return(latestHistory!, true);
+#endif
+
+        AddToNavigationStack(item, true, false);
     }
 
-    private void NotifyContentAboutNavigatingFrom(object? content)
+    private void AddToNavigationStackHistory(INavigationViewItem viewItem)
     {
-        if (content is INavigationAware navigationAwareNavigationContent)
-            navigationAwareNavigationContent.OnNavigatedFrom();
+        var lastItem = NavigationStack[NavigationStack.Count - 1];
+        var startIndex = NavigationStack.IndexOf(viewItem);
+
+        if (startIndex < 0)
+            startIndex = 0;
+        
+        if (!_complexNavigationStackHistory.TryGetValue(lastItem, out var historyList))
+        {
+            historyList = new List<INavigationViewItem?[]>(5);
+            _complexNavigationStackHistory.Add(lastItem,  historyList);
+        }
+
+        int arrayLength = NavigationStack.Count - 1 - startIndex;
+        INavigationViewItem[] array;
+
+        //Initializing an array every time well... not an ideal
+
+#if NET6_0_OR_GREATER
+        array = System.Buffers.ArrayPool<INavigationViewItem>.Shared.Rent(arrayLength);
+#else
+        array = new INavigationViewItem[arrayLength];
+#endif
 
-        if (content is INavigableView<object> navigableView && navigableView.ViewModel is INavigationAware navigationAwareNavigableViewViewModel)
-            navigationAwareNavigableViewViewModel.OnNavigatedFrom();
+        historyList.Add(array);
+        var latestHistory = historyList[historyList.Count - 1];
 
-        if (content is FrameworkElement { DataContext: INavigationAware navigationAwareCurrentContent })
-            navigationAwareCurrentContent.OnNavigatedFrom();
+        int i = 0;
+        for (int j = startIndex; j < NavigationStack.Count - 1; j++)
+        {
+            latestHistory[i] = NavigationStack[j];
+            i++;
+        }
     }
 
-    private void NotifyContentAboutNavigatingTo(object? content)
+    private void ClearNavigationStack(int navigationStackItemIndex)
     {
-        if (content is INavigationAware navigationAwareNavigationContent)
-            navigationAwareNavigationContent.OnNavigatedTo();
+        var navigationStackCount = NavigationStack.Count;
+        var length = navigationStackCount - navigationStackItemIndex;
 
-        if (content is INavigableView<object> navigableView && navigableView.ViewModel is INavigationAware navigationAwareNavigableViewViewModel)
-            navigationAwareNavigableViewViewModel.OnNavigatedTo();
+        if (length == 0)
+            return;
 
-        if (content is FrameworkElement { DataContext: INavigationAware navigationAwareCurrentContent })
-            navigationAwareCurrentContent.OnNavigatedTo();
+        for (int j = navigationStackCount - 1; j >= navigationStackCount - length; j--)
+        {
+            NavigationStack.Remove(NavigationStack[j]);
+        }
     }
 
-    private void ApplyTransitionEffectToNavigatedPage(NavigationViewContentPresenter contentPresenter)
+    private void ClearNavigationStack(INavigationViewItem item)
     {
-        if (TransitionDuration < 1)
+        var navigationStackCount = NavigationStack.Count;
+        if (navigationStackCount <= 1)
             return;
 
-        if (contentPresenter.Content == null)
+        var index = NavigationStack.IndexOf(item);
+        if (index >= navigationStackCount - 1)
             return;
 
-        Transitions.ApplyTransition(contentPresenter.Content, TransitionType, TransitionDuration);
+        AddToNavigationStackHistory(item);
+        ClearNavigationStack(++index);
     }
 
-    private void UpdateSelectionForMenuItems()
+    private void ReplaceThirstElementInNavigationStack(INavigationViewItem newItem)
     {
-        if (MenuItems is IEnumerable enumerableMenuItems)
-        {
-            foreach (var singleMenuItem in enumerableMenuItems)
-            {
-                if (singleMenuItem is not NavigationViewItem navigationViewItem)
-                    continue;
-
-                if (navigationViewItem == SelectedItem)
-                {
-                    navigationViewItem.IsActive = true;
-
-                    if (navigationViewItem.Icon is SymbolIcon symbolIcon && PaneDisplayMode == NavigationViewPaneDisplayMode.LeftFluent)
-                        symbolIcon.Filled = true;
-                }
-                else
-                {
-                    navigationViewItem.IsActive = false;
-
-                    if (navigationViewItem.Icon is SymbolIcon symbolIcon && PaneDisplayMode == NavigationViewPaneDisplayMode.LeftFluent)
-                        symbolIcon.Filled = false;
-                }
-
-                if (navigationViewItem.MenuItems is IEnumerable enumerableSubMenuItems)
-                {
-                    foreach (var singleSubMenuItem in enumerableSubMenuItems)
-                    {
-                        if (singleSubMenuItem is not NavigationViewItem navigationViewSubItem)
-                            continue;
-
-                        if (!navigationViewItem.IsExpanded && navigationViewSubItem == SelectedItem)
-                        {
-                            navigationViewItem.IsExpanded = true;
-                            //navigationViewItem.BringIntoView();
-                        }
-
-                        navigationViewSubItem.IsActive = navigationViewSubItem == SelectedItem;
-                    }
-                }
-            }
-        }
-
-        if (FooterMenuItems is IEnumerable enumerableFooterMenuItems)
-        {
-            foreach (var singleFooterMenuItem in enumerableFooterMenuItems)
-            {
-                if (singleFooterMenuItem is not NavigationViewItem navigationViewItem)
-                    continue;
-
-                if (navigationViewItem == SelectedItem)
-                {
-                    navigationViewItem.IsActive = true;
-
-                    if (navigationViewItem.Icon is SymbolIcon symbolIcon && PaneDisplayMode == NavigationViewPaneDisplayMode.LeftFluent)
-                        symbolIcon.Filled = true;
-                }
-                else
-                {
-                    navigationViewItem.IsActive = false;
-                }
-
-                if (navigationViewItem.MenuItems is IEnumerable enumerableSubMenuItems)
-                {
-                    foreach (var singleSubMenuItem in enumerableSubMenuItems)
-                    {
-                        if (singleSubMenuItem is not NavigationViewItem navigationViewSubItem)
-                            continue;
-
-                        if (!navigationViewItem.IsExpanded && navigationViewSubItem == SelectedItem)
-                        {
-                            navigationViewItem.IsExpanded = true;
-                            //navigationViewItem.BringIntoView();
-                        }
-
-                        navigationViewSubItem.IsActive = navigationViewSubItem == SelectedItem;
-                    }
-                }
-            }
-        }
+        NavigationStack[0].Deactivate(PaneDisplayMode);
+        NavigationStack[0] = newItem;
+        NavigationStack[0].Activate(PaneDisplayMode);
     }
+
+    #endregion
 }
diff --git a/src/Wpf.Ui/Controls/Navigation/NavigationView.Parent.cs b/src/Wpf.Ui/Controls/Navigation/NavigationView.Parent.cs
index ffe8f0b0e..ba4595976 100644
--- a/src/Wpf.Ui/Controls/Navigation/NavigationView.Parent.cs
+++ b/src/Wpf.Ui/Controls/Navigation/NavigationView.Parent.cs
@@ -33,8 +33,7 @@ internal INavigationView NavigationParent
     /// </summary>
     /// <param name="navigationItem"></param>
     /// <returns>Instance of the <see cref="NavigationView"/> or <see langword="null"/>.</returns>
-    internal static NavigationView? GetNavigationParent<T>(T navigationItem)
-        where T : DependencyObject, INavigationViewItem
+    internal static NavigationView? GetNavigationParent<T>(T navigationItem) where T : DependencyObject, INavigationViewItem
     {
         if (navigationItem.GetValue(NavigationParentProperty) is NavigationView navigationView)
             return navigationView;
diff --git a/src/Wpf.Ui/Controls/Navigation/NavigationView.Properties.cs b/src/Wpf.Ui/Controls/Navigation/NavigationView.Properties.cs
index 0b0ecabf2..007a06bea 100644
--- a/src/Wpf.Ui/Controls/Navigation/NavigationView.Properties.cs
+++ b/src/Wpf.Ui/Controls/Navigation/NavigationView.Properties.cs
@@ -6,8 +6,8 @@
 // Copyright (C) Leszek Pomianowski and WPF UI Contributors.
 // All Rights Reserved.
 
+using System;
 using System.Collections;
-using System.Collections.Specialized;
 using System.ComponentModel;
 using System.Windows;
 using System.Windows.Controls;
@@ -17,19 +17,26 @@ namespace Wpf.Ui.Controls.Navigation;
 
 public partial class NavigationView
 {
+    /// <summary>
+    /// Property for <see cref="Header"/>.
+    /// </summary>
+    public static readonly DependencyProperty EnableDebugMessagesProperty =
+        DependencyProperty.Register(nameof(EnableDebugMessages), typeof(bool), typeof(NavigationView),
+            new FrameworkPropertyMetadata(false));
+
     /// <summary>
     /// Property for <see cref="Header"/>.
     /// </summary>
     public static readonly DependencyProperty HeaderProperty = DependencyProperty.Register(nameof(Header),
         typeof(object), typeof(NavigationView),
-        new FrameworkPropertyMetadata(((object)null!)));
+        new FrameworkPropertyMetadata(null));
 
     /// <summary>
     /// Property for <see cref="HeaderVisibility"/>.
     /// </summary>
     public static readonly DependencyProperty HeaderVisibilityProperty = DependencyProperty.Register(nameof(HeaderVisibility),
         typeof(Visibility), typeof(NavigationView),
-        new FrameworkPropertyMetadata(System.Windows.Visibility.Visible));
+        new FrameworkPropertyMetadata(Visibility.Visible));
 
     /// <summary>
     /// Property for <see cref="AlwaysShowHeader"/>.
@@ -42,36 +49,36 @@ public partial class NavigationView
     /// Property for <see cref="MenuItems"/>.
     /// </summary>
     public static readonly DependencyProperty MenuItemsProperty = DependencyProperty.Register(nameof(MenuItems),
-        typeof(IList), typeof(NavigationView),
-        new PropertyMetadata(OnMenuItemsPropertyChanged));
+        typeof(IList), typeof(NavigationView), new FrameworkPropertyMetadata(Array.Empty<object>()));
 
     /// <summary>
     /// Property for <see cref="MenuItemsSource"/>.
     /// </summary>
-    public static readonly DependencyProperty MenuItemsSourceProperty = DependencyProperty.Register(nameof(MenuItemsSource),
+    public static readonly DependencyProperty MenuItemsSourceProperty = DependencyProperty.Register(
+        nameof(MenuItemsSource),
         typeof(object), typeof(NavigationView),
-        new FrameworkPropertyMetadata(((object)null!), OnMenuItemsSourcePropertyChanged));
+        new FrameworkPropertyMetadata(null, OnMenuItemsSourcePropertyChanged));
 
     /// <summary>
     /// Property for <see cref="FooterMenuItems"/>.
     /// </summary>
-    public static readonly DependencyProperty FooterMenuItemsProperty = DependencyProperty.Register(nameof(FooterMenuItemsProperty),
-        typeof(IList), typeof(NavigationView),
-        new PropertyMetadata(OnFooterMenuItemsPropertyChanged));
+    public static readonly DependencyProperty FooterMenuItemsProperty = DependencyProperty.Register(
+        nameof(FooterMenuItemsProperty),
+        typeof(IList), typeof(NavigationView), new FrameworkPropertyMetadata(Array.Empty<object>()));
 
     /// <summary>
     /// Property for <see cref="FooterMenuItemsSource"/>.
     /// </summary>
     public static readonly DependencyProperty FooterMenuItemsSourceProperty = DependencyProperty.Register(nameof(FooterMenuItemsSource),
         typeof(object), typeof(NavigationView),
-        new FrameworkPropertyMetadata(((object)null!), OnFooterMenuItemsSourcePropertyChanged));
+        new FrameworkPropertyMetadata(null, OnFooterMenuItemsSourcePropertyChanged));
 
     /// <summary>
     /// Property for <see cref="ContentOverlay"/>.
     /// </summary>
     public static readonly DependencyProperty ContentOverlayProperty = DependencyProperty.Register(nameof(ContentOverlay),
         typeof(object), typeof(NavigationView),
-        new FrameworkPropertyMetadata(((object)null!)));
+        new FrameworkPropertyMetadata(null));
 
     /// <summary>
     /// Property for <see cref="IsBackEnabled"/>.
@@ -120,14 +127,14 @@ public partial class NavigationView
     /// </summary>
     public static readonly DependencyProperty PaneHeaderProperty = DependencyProperty.Register(nameof(PaneHeader),
         typeof(object), typeof(NavigationView),
-        new FrameworkPropertyMetadata(((object)null!)));
+        new FrameworkPropertyMetadata(null));
 
     /// <summary>
     /// Property for <see cref="PaneFooter"/>.
     /// </summary>
     public static readonly DependencyProperty PaneFooterProperty = DependencyProperty.Register(nameof(PaneFooter),
         typeof(object), typeof(NavigationView),
-        new FrameworkPropertyMetadata(((object)null!)));
+        new FrameworkPropertyMetadata(null));
 
     /// <summary>
     /// Property for <see cref="PaneDisplayMode"/>.
@@ -141,14 +148,14 @@ public partial class NavigationView
     /// </summary>
     public static readonly DependencyProperty AutoSuggestBoxProperty = DependencyProperty.Register(nameof(AutoSuggestBox),
         typeof(AutoSuggestBox), typeof(NavigationView),
-        new FrameworkPropertyMetadata(((AutoSuggestBox)null!)));
+        new FrameworkPropertyMetadata(null));
 
     /// <summary>
     /// Property for <see cref="TitleBar"/>.
     /// </summary>
     public static readonly DependencyProperty TitleBarProperty = DependencyProperty.Register(nameof(TitleBar),
         typeof(TitleBar), typeof(NavigationView),
-        new FrameworkPropertyMetadata(((TitleBar)null!)));
+        new FrameworkPropertyMetadata(null));
 
     /// <summary>
     /// Property for <see cref="ItemTemplate"/>.
@@ -156,7 +163,7 @@ public partial class NavigationView
     public static readonly DependencyProperty ItemTemplateProperty = DependencyProperty.Register(nameof(ItemTemplate),
         typeof(ControlTemplate), typeof(NavigationView),
         new FrameworkPropertyMetadata(
-            (ControlTemplate)null!,  // default value
+            null,
             FrameworkPropertyMetadataOptions.AffectsMeasure,
             new PropertyChangedCallback(OnItemTemplatePropertyChanged)));
 
@@ -174,8 +181,17 @@ public partial class NavigationView
         typeof(TransitionType), typeof(NavigationView),
         new FrameworkPropertyMetadata(TransitionType.FadeInWithSlide));
 
+    /// <summary>
+    /// Enables or disables debugging messages for this control
+    /// </summary>
+    public bool EnableDebugMessages
+    {
+        get => (bool) GetValue(EnableDebugMessagesProperty);
+        set => SetValue(EnableDebugMessagesProperty, value);
+    }
+
     /// <inheritdoc/>
-    public object Header
+    public object? Header
     {
         get => GetValue(HeaderProperty);
         set => SetValue(HeaderProperty, value);
@@ -196,15 +212,15 @@ public bool AlwaysShowHeader
     }
 
     /// <inheritdoc/>
-    public IList? MenuItems
+    public IList MenuItems
     {
-        get => (IList?)GetValue(MenuItemsProperty);
+        get => (IList)GetValue(MenuItemsProperty);
         set => SetValue(MenuItemsProperty, value);
     }
 
     /// <inheritdoc/>
     [Bindable(true)]
-    public object MenuItemsSource
+    public object? MenuItemsSource
     {
         get => GetValue(MenuItemsSourceProperty);
         set
@@ -217,15 +233,15 @@ public object MenuItemsSource
     }
 
     /// <inheritdoc/>
-    public IList? FooterMenuItems
+    public IList FooterMenuItems
     {
-        get => (IList?)GetValue(FooterMenuItemsProperty);
+        get => (IList)GetValue(FooterMenuItemsProperty);
         set => SetValue(FooterMenuItemsProperty, value);
     }
 
     /// <inheritdoc/>
     [Bindable(true)]
-    public object FooterMenuItemsSource
+    public object? FooterMenuItemsSource
     {
         get => GetValue(FooterMenuItemsSourceProperty);
         set
@@ -238,7 +254,7 @@ public object FooterMenuItemsSource
     }
 
     /// <inheritdoc/>
-    public object ContentOverlay
+    public object? ContentOverlay
     {
         get => GetValue(ContentOverlayProperty);
         set => SetValue(ContentOverlayProperty, value);
@@ -287,14 +303,14 @@ public double OpenPaneLength
     }
 
     /// <inheritdoc/>
-    public object PaneHeader
+    public object? PaneHeader
     {
         get => GetValue(PaneHeaderProperty);
         set => SetValue(PaneHeaderProperty, value);
     }
 
     /// <inheritdoc/>
-    public object PaneFooter
+    public object? PaneFooter
     {
         get => GetValue(PaneFooterProperty);
         set => SetValue(PaneFooterProperty, value);
@@ -308,21 +324,21 @@ public NavigationViewPaneDisplayMode PaneDisplayMode
     }
 
     /// <inheritdoc/>
-    public AutoSuggestBox AutoSuggestBox
+    public AutoSuggestBox? AutoSuggestBox
     {
         get => (AutoSuggestBox)GetValue(AutoSuggestBoxProperty);
         set => SetValue(AutoSuggestBoxProperty, value);
     }
 
     /// <inheritdoc/>
-    public TitleBar TitleBar
+    public TitleBar? TitleBar
     {
         get => (TitleBar)GetValue(TitleBarProperty);
         set => SetValue(TitleBarProperty, value);
     }
 
     /// <inheritdoc/>
-    public ControlTemplate ItemTemplate
+    public ControlTemplate? ItemTemplate
     {
         get => (ControlTemplate)GetValue(ItemTemplateProperty);
         set => SetValue(ItemTemplateProperty, value);
@@ -343,71 +359,23 @@ public TransitionType TransitionType
         set => SetValue(TransitionTypeProperty, value);
     }
 
-    private static void OnMenuItemsPropertyChanged(DependencyObject? d, DependencyPropertyChangedEventArgs e)
+    private static void OnMenuItemsSourcePropertyChanged(DependencyObject? d, DependencyPropertyChangedEventArgs e)
     {
-        if (d is not NavigationView navigationView)
+        if (d is not NavigationView navigationView || e.NewValue is not IList enumerableNewValue)
             return;
 
-        if (e.OldValue is INotifyCollectionChanged oldMenuItemsCollection)
-            oldMenuItemsCollection.CollectionChanged -= navigationView.OnMenuItemsCollectionChanged;
-
-        if (e.NewValue is INotifyCollectionChanged newMenuItemsCollection)
-            newMenuItemsCollection.CollectionChanged += navigationView.OnMenuItemsCollectionChanged;
-
-        navigationView.OnMenuItemsChanged();
-    }
-
-    protected virtual void OnMenuItemsCollectionChanged(object? sender, NotifyCollectionChangedEventArgs e)
-    {
-    }
-
-    private static void OnMenuItemsSourcePropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
-    {
-        if (d is not NavigationView navigationView)
-            return;
-
-        if (e.NewValue is not IList enumerableNewValue)
-            return;
-
-        if (navigationView.MenuItems != null)
-            navigationView.MenuItems = null;
-
         navigationView.MenuItems = enumerableNewValue;
     }
 
-    private static void OnFooterMenuItemsPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+    private static void OnFooterMenuItemsSourcePropertyChanged(DependencyObject? d, DependencyPropertyChangedEventArgs e)
     {
-        if (d is not NavigationView navigationView)
+        if (d is not NavigationView navigationView || e.NewValue is not IList enumerableNewValue)
             return;
 
-        if (e.OldValue is INotifyCollectionChanged oldMenuItemsCollection)
-            oldMenuItemsCollection.CollectionChanged -= navigationView.OnFooterMenuItemsCollectionChanged;
-
-        if (e.NewValue is INotifyCollectionChanged newMenuItemsCollection)
-            newMenuItemsCollection.CollectionChanged += navigationView.OnFooterMenuItemsCollectionChanged;
-
-        navigationView.OnFooterMenuItemsChanged();
-    }
-
-    private static void OnFooterMenuItemsSourcePropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
-    {
-        if (d is not NavigationView navigationView)
-            return;
-
-        if (e.NewValue is not IList enumerableNewValue)
-            return;
-
-        if (navigationView.FooterMenuItems != null)
-            navigationView.FooterMenuItems = null;
-
         navigationView.FooterMenuItems = enumerableNewValue;
     }
 
-    protected virtual void OnFooterMenuItemsCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
-    {
-    }
-
-    private static void OnPaneDisplayModePropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+    private static void OnPaneDisplayModePropertyChanged(DependencyObject? d, DependencyPropertyChangedEventArgs e)
     {
         if (d is not NavigationView navigationView)
             return;
@@ -415,7 +383,7 @@ private static void OnPaneDisplayModePropertyChanged(DependencyObject d, Depende
         navigationView.OnPaneDisplayModeChanged();
     }
 
-    private static void OnItemTemplatePropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
+    private static void OnItemTemplatePropertyChanged(DependencyObject? d, DependencyPropertyChangedEventArgs e)
     {
         if (d is not NavigationView navigationView)
             return;
diff --git a/src/Wpf.Ui/Controls/Navigation/NavigationView.TemplateParts.cs b/src/Wpf.Ui/Controls/Navigation/NavigationView.TemplateParts.cs
index 84efd5bad..5ae6c5f2e 100644
--- a/src/Wpf.Ui/Controls/Navigation/NavigationView.TemplateParts.cs
+++ b/src/Wpf.Ui/Controls/Navigation/NavigationView.TemplateParts.cs
@@ -6,15 +6,16 @@
 // Copyright (C) Leszek Pomianowski and WPF UI Contributors.
 // All Rights Reserved.
 
+using System;
 using System.Windows;
 
 namespace Wpf.Ui.Controls.Navigation;
 
-[TemplatePart(Name = "PART_NavigationViewContentPresenter", Type = typeof(NavigationViewContentPresenter))]
-[TemplatePart(Name = "PART_MenuItemsItemsControl", Type = typeof(System.Windows.Controls.ItemsControl))]
-[TemplatePart(Name = "PART_FooterMenuItemsItemsControl", Type = typeof(System.Windows.Controls.ItemsControl))]
-[TemplatePart(Name = "PART_BackButton", Type = typeof(System.Windows.Controls.Button))]
-[TemplatePart(Name = "PART_ToggleButton", Type = typeof(System.Windows.Controls.Button))]
+[TemplatePart(Name = TemplateElementNavigationViewContentPresenter, Type = typeof(NavigationViewContentPresenter))]
+[TemplatePart(Name = TemplateElementMenuItemsItemsControl, Type = typeof(System.Windows.Controls.ItemsControl))]
+[TemplatePart(Name = TemplateElementFooterMenuItemsItemsControl, Type = typeof(System.Windows.Controls.ItemsControl))]
+[TemplatePart(Name = TemplateElementBackButton, Type = typeof(System.Windows.Controls.Button))]
+[TemplatePart(Name = TemplateElementToggleButton, Type = typeof(System.Windows.Controls.Button))]
 public partial class NavigationView
 {
     /// <summary>
@@ -45,67 +46,62 @@ public partial class NavigationView
     /// <summary>
     /// Control responsible for rendering the content.
     /// </summary>
-    protected NavigationViewContentPresenter NavigationViewContentPresenter;
+    protected NavigationViewContentPresenter NavigationViewContentPresenter = null!;
 
     /// <summary>
     /// Control located at the top of the pane with left arrow icon.
     /// </summary>
-    protected System.Windows.Controls.ItemsControl MenuItemsItemsControl;
+    protected System.Windows.Controls.ItemsControl MenuItemsItemsControl = null!;
 
     /// <summary>
     /// Control located at the top of the pane with hamburger icon.
     /// </summary>
-    protected System.Windows.Controls.ItemsControl FooterMenuItemsItemsControl;
+    protected System.Windows.Controls.ItemsControl FooterMenuItemsItemsControl = null!;
 
     /// <summary>
     /// Control located at the top of the pane with left arrow icon.
     /// </summary>
-    protected System.Windows.Controls.Button BackButton;
+    protected System.Windows.Controls.Button? BackButton;
 
     /// <summary>
     /// Control located at the top of the pane with hamburger icon.
     /// </summary>
-    protected System.Windows.Controls.Button ToggleButton;
+    protected System.Windows.Controls.Button? ToggleButton;
 
     /// <inheritdoc />
     public override void OnApplyTemplate()
     {
         base.OnApplyTemplate();
 
-        if (GetTemplateChild(TemplateElementNavigationViewContentPresenter) is NavigationViewContentPresenter navigationViewContentPresenter)
-            NavigationViewContentPresenter = navigationViewContentPresenter;
+        NavigationViewContentPresenter = GetTemplateChild<NavigationViewContentPresenter>(TemplateElementNavigationViewContentPresenter);
+        MenuItemsItemsControl = GetTemplateChild<System.Windows.Controls.ItemsControl>(TemplateElementMenuItemsItemsControl);
+        FooterMenuItemsItemsControl = GetTemplateChild<System.Windows.Controls.ItemsControl>(TemplateElementFooterMenuItemsItemsControl);
 
-        if (GetTemplateChild(TemplateElementMenuItemsItemsControl) is System.Windows.Controls.ItemsControl menuItemsItemsControl)
-            MenuItemsItemsControl = menuItemsItemsControl;
-
-        if (GetTemplateChild(TemplateElementFooterMenuItemsItemsControl) is System.Windows.Controls.ItemsControl footerMenuItemsItemsControl)
-            FooterMenuItemsItemsControl = footerMenuItemsItemsControl;
+        MenuItemsItemsControl.ItemsSource = MenuItems;
+        FooterMenuItemsItemsControl.ItemsSource = FooterMenuItems;
 
         if (GetTemplateChild(TemplateElementBackButton) is System.Windows.Controls.Button backButton)
+        {
             BackButton = backButton;
 
-        if (GetTemplateChild(TemplateElementToggleButton) is System.Windows.Controls.Button toggleButton)
-            ToggleButton = toggleButton;
-
-        if (NavigationViewContentPresenter != null)
-            NavigationViewContentPresenter.Navigated += OnNavigationViewContentPresenterNavigated;
-
-        if (MenuItemsItemsControl != null)
-            MenuItemsItemsControl.ItemsSource = MenuItems;
-
-        if (FooterMenuItemsItemsControl != null)
-            FooterMenuItemsItemsControl.ItemsSource = FooterMenuItems;
-
-        if (BackButton != null)
-        {
             BackButton.Click -= OnBackButtonClick;
             BackButton.Click += OnBackButtonClick;
         }
 
-        if (ToggleButton != null)
+        if (GetTemplateChild(TemplateElementToggleButton) is System.Windows.Controls.Button toggleButton)
         {
+            ToggleButton = toggleButton;
+
             ToggleButton.Click -= OnToggleButtonClick;
             ToggleButton.Click += OnToggleButtonClick;
         }
     }
+
+    protected T GetTemplateChild<T>(string name) where T : DependencyObject
+    {
+        if (GetTemplateChild(name) is not T dependencyObject)
+            throw new ArgumentNullException(name);
+
+        return dependencyObject;
+    }
 }
diff --git a/src/Wpf.Ui/Controls/Navigation/NavigationViewActivator.cs b/src/Wpf.Ui/Controls/Navigation/NavigationViewActivator.cs
index 59bbde6f2..5d4a2ecbc 100644
--- a/src/Wpf.Ui/Controls/Navigation/NavigationViewActivator.cs
+++ b/src/Wpf.Ui/Controls/Navigation/NavigationViewActivator.cs
@@ -17,23 +17,13 @@ namespace Wpf.Ui.Controls.Navigation;
 /// </summary>
 internal static class NavigationViewActivator
 {
-    /// <summary>
-    /// Creates new instance of type derived from <see cref="FrameworkElement"/>.
-    /// </summary>
-    /// <param name="pageType"><see cref="FrameworkElement"/> to instantiate.</param>
-    /// <returns>Instance of the <see cref="FrameworkElement"/> object or <see langword="null"/>.</returns>
-    public static FrameworkElement CreateInstance(Type pageType)
-    {
-        return CreateInstance(pageType, null!);
-    }
-
     /// <summary>
     /// Creates new instance of type derived from <see cref="FrameworkElement"/>.
     /// </summary>
     /// <param name="pageType"><see cref="FrameworkElement"/> to instantiate.</param>
     /// <param name="dataContext">Additional context to set.</param>
     /// <returns>Instance of the <see cref="FrameworkElement"/> object or <see langword="null"/>.</returns>
-    public static FrameworkElement CreateInstance(Type pageType, object? dataContext)
+    public static FrameworkElement? CreateInstance(Type pageType, object? dataContext = null)
     {
         if (!typeof(FrameworkElement).IsAssignableFrom(pageType))
             throw new InvalidCastException(
@@ -42,7 +32,7 @@ public static FrameworkElement CreateInstance(Type pageType, object? dataContext
         if (DesignerHelper.IsInDesignMode)
             return new Page { Content = new TextBlock { Text = "Pages are not rendered while using the Designer. Edit the page template directly." } };
 
-        var instance = null as FrameworkElement;
+        FrameworkElement? instance;
 
 #if NET48_OR_GREATER || NETCOREAPP3_0_OR_GREATER
         if (ControlsServices.ControlsServiceProvider != null)
diff --git a/src/Wpf.Ui/Controls/Navigation/NavigationViewBreadcrumb.cs b/src/Wpf.Ui/Controls/Navigation/NavigationViewBreadcrumb.cs
deleted file mode 100644
index aacdc183e..000000000
--- a/src/Wpf.Ui/Controls/Navigation/NavigationViewBreadcrumb.cs
+++ /dev/null
@@ -1,99 +0,0 @@
-// Based on Windows UI Library
-// Copyright(c) Microsoft Corporation.All rights reserved.
-
-// This Source Code Form is subject to the terms of the MIT License.
-// If a copy of the MIT was not distributed with this file, You can obtain one at https://opensource.org/licenses/MIT.
-// Copyright (C) Leszek Pomianowski and WPF UI Contributors.
-// All Rights Reserved.
-
-
-using System;
-using System.Windows;
-
-namespace Wpf.Ui.Controls.Navigation;
-
-/// <summary>
-/// Breadcrumb control allows you to keep track and maintain awareness of your locations within <see cref="INavigationView"/>.
-/// </summary>
-public class NavigationViewBreadcrumb : System.Windows.Controls.Control
-{
-    /// <summary>
-    /// Property for <see cref="NavigationView"/>.
-    /// </summary>
-    public static readonly DependencyProperty NavigationViewProperty = DependencyProperty.Register(nameof(NavigationView),
-        typeof(INavigationView), typeof(NavigationViewBreadcrumb),
-        new PropertyMetadata(((NavigationViewBreadcrumb)null!), OnNavigationViewPropertyChanged));
-
-    /// <summary>
-    /// Property for <see cref="Text"/>.
-    /// </summary>
-    public static readonly DependencyProperty TextProperty = DependencyProperty.Register(nameof(Text),
-        typeof(string), typeof(NavigationViewBreadcrumb),
-        new PropertyMetadata(String.Empty));
-
-
-    /// <summary>
-    /// Pinned navigation control.
-    /// </summary>
-    public INavigationView NavigationView
-    {
-        get => (INavigationView)GetValue(NavigationViewProperty);
-        set => SetValue(NavigationViewProperty, value);
-    }
-
-    /// <summary>
-    /// Primary breadcrumb navigation element.
-    /// </summary>
-    public string Text
-    {
-        get => (string)GetValue(TextProperty);
-        set => SetValue(TextProperty, value);
-    }
-
-    public NavigationViewBreadcrumb()
-    {
-        if (NavigationView != null)
-            UpdateRenderedItems();
-    }
-
-    /// <summary>
-    /// This virtual method is called when the <see cref="NavigationView"/> is changed.
-    /// </summary>
-    protected virtual void OnNavigationViewChanged()
-    {
-        if (NavigationView == null)
-            return;
-
-        NavigationView.SelectionChanged -= OnNavigationViewSelectionChanged;
-        NavigationView.SelectionChanged += OnNavigationViewSelectionChanged;
-    }
-
-    /// <summary>
-    /// This virtual method is called when the <see cref="INavigationView.SelectedItem"/> of the <see cref="NavigationView"/> is changed.
-    /// </summary>
-    protected virtual void OnNavigationViewSelectionChanged(object sender, RoutedEventArgs e)
-    {
-        UpdateRenderedItems();
-    }
-
-    private static void OnNavigationViewPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
-    {
-        if (d is not NavigationViewBreadcrumb breadcrumb)
-            return;
-
-        breadcrumb.OnNavigationViewChanged();
-    }
-
-    private void UpdateRenderedItems()
-    {
-        if (NavigationView.SelectedItem is not NavigationViewItem navigationViewItem)
-        {
-            Text = String.Empty;
-
-            return;
-        }
-
-        // TODO: Multilevel
-        Text = navigationViewItem.Content?.ToString() ?? String.Empty;
-    }
-}
diff --git a/src/Wpf.Ui/Controls/Navigation/NavigationViewBreadcrumbItem.cs b/src/Wpf.Ui/Controls/Navigation/NavigationViewBreadcrumbItem.cs
new file mode 100644
index 000000000..3db4041e3
--- /dev/null
+++ b/src/Wpf.Ui/Controls/Navigation/NavigationViewBreadcrumbItem.cs
@@ -0,0 +1,18 @@
+// This Source Code Form is subject to the terms of the MIT License.
+// If a copy of the MIT was not distributed with this file, You can obtain one at https://opensource.org/licenses/MIT.
+// Copyright (C) Leszek Pomianowski and WPF UI Contributors.
+// All Rights Reserved.
+
+namespace Wpf.Ui.Controls.Navigation;
+
+internal class NavigationViewBreadcrumbItem
+{
+    public NavigationViewBreadcrumbItem(INavigationViewItem  item)
+    {
+        Content = item.Content;
+        PageId = item.Id;
+    }
+
+    public object Content { get; }
+    public string PageId { get; }
+}
diff --git a/src/Wpf.Ui/Controls/Navigation/NavigationViewContentPresenter.cs b/src/Wpf.Ui/Controls/Navigation/NavigationViewContentPresenter.cs
index 3fd80966c..47578afa5 100644
--- a/src/Wpf.Ui/Controls/Navigation/NavigationViewContentPresenter.cs
+++ b/src/Wpf.Ui/Controls/Navigation/NavigationViewContentPresenter.cs
@@ -6,14 +6,47 @@
 // Copyright (C) Leszek Pomianowski and WPF UI Contributors.
 // All Rights Reserved.
 
+using System;
+using System.ComponentModel;
 using System.Windows;
 using System.Windows.Controls;
 using System.Windows.Navigation;
+using Wpf.Ui.Animations;
 
 namespace Wpf.Ui.Controls.Navigation;
 
 public class NavigationViewContentPresenter : Frame
 {
+    /// <summary>
+    /// Property for <see cref="TransitionDuration"/>.
+    /// </summary>
+    public static readonly DependencyProperty TransitionDurationProperty =
+        DependencyProperty.Register(nameof(TransitionDuration), typeof(int), typeof(NavigationViewContentPresenter),
+            new FrameworkPropertyMetadata(200));
+
+    /// <summary>
+    /// Property for <see cref="TransitionType"/>.
+    /// </summary>
+    public static readonly DependencyProperty TransitionTypeProperty =
+        DependencyProperty.Register(nameof(TransitionType), typeof(TransitionType),
+            typeof(NavigationViewContentPresenter), new FrameworkPropertyMetadata(TransitionType.FadeInWithSlide));
+
+    [Bindable(true), Category("Appearance")]
+    public int TransitionDuration
+    {
+        get => (int)GetValue(TransitionDurationProperty);
+        set => SetValue(TransitionDurationProperty, value);
+    }
+
+    /// <summary>
+    /// Gets or sets type of <see cref="NavigationViewContentPresenter"/> transitions during navigation.
+    /// </summary>
+    public TransitionType TransitionType
+    {
+        get => (TransitionType)GetValue(TransitionTypeProperty);
+        set => SetValue(TransitionTypeProperty, value);
+    }
+
     static NavigationViewContentPresenter()
     {
         DefaultStyleKeyProperty.OverrideMetadata(
@@ -32,4 +65,47 @@ static NavigationViewContentPresenter()
             typeof(NavigationViewContentPresenter),
             new FrameworkPropertyMetadata(JournalOwnership.UsesParentJournal));
     }
+
+    protected override void OnInitialized(EventArgs e)
+    {
+        base.OnInitialized(e);
+
+        Navigating += static (_, eventArgs) =>
+        {
+            if (eventArgs.Content is null)
+                return;
+
+            NotifyContentAboutNavigatingTo(eventArgs.Content);
+        };
+
+        Navigated += (sender, eventArgs) =>
+        {
+            var self = (NavigationViewContentPresenter)sender;
+
+            if (eventArgs.Content is null)
+                return;
+
+            self.ApplyTransitionEffectToNavigatedPage(eventArgs.Content);
+        };
+    }
+
+    private static void NotifyContentAboutNavigatingTo(object content)
+    {
+        if (content is INavigationAware navigationAwareNavigationContent)
+            navigationAwareNavigationContent.OnNavigatedTo();
+
+        if (content is INavigableView<object> { ViewModel: INavigationAware navigationAwareNavigableViewViewModel })
+            navigationAwareNavigableViewViewModel.OnNavigatedTo();
+
+        if (content is FrameworkElement { DataContext: INavigationAware navigationAwareCurrentContent })
+            navigationAwareCurrentContent.OnNavigatedTo();
+    }
+
+    private void ApplyTransitionEffectToNavigatedPage(object content)
+    {
+        if (TransitionDuration < 1)
+            return;
+
+        Transitions.ApplyTransition(content, TransitionType, TransitionDuration);
+    }
 }
diff --git a/src/Wpf.Ui/Controls/Navigation/NavigationViewEvent.cs b/src/Wpf.Ui/Controls/Navigation/NavigationViewEventArgs.cs
similarity index 54%
rename from src/Wpf.Ui/Controls/Navigation/NavigationViewEvent.cs
rename to src/Wpf.Ui/Controls/Navigation/NavigationViewEventArgs.cs
index eacce83bf..4c9b544bf 100644
--- a/src/Wpf.Ui/Controls/Navigation/NavigationViewEvent.cs
+++ b/src/Wpf.Ui/Controls/Navigation/NavigationViewEventArgs.cs
@@ -6,17 +6,17 @@
 // Copyright (C) Leszek Pomianowski and WPF UI Contributors.
 // All Rights Reserved.
 
-using System.Diagnostics.CodeAnalysis;
 using System.Windows;
 
 namespace Wpf.Ui.Controls.Navigation;
 
-/// <summary>
-/// Event triggered by NavigationView.
-/// </summary>
-/// <param name="sender">Current navigation instance.</param>
-#if NET5_0_OR_GREATER
-public delegate void NavigationViewEvent([NotNull] object sender, RoutedEventArgs e);
-#else
-public delegate void NavigationViewEvent(object sender, RoutedEventArgs e);
-#endif
+public class NavigatingCancelEventArgs : RoutedEventArgs
+{
+    public NavigatingCancelEventArgs(RoutedEvent routedEvent, object source, object sourcePageType) : base(routedEvent, source)
+    {
+        SourcePageType = sourcePageType;
+    }
+
+    public bool Cancel { get; set; }
+    public object SourcePageType { get; }
+}
diff --git a/src/Wpf.Ui/Controls/Navigation/NavigationViewItem.cs b/src/Wpf.Ui/Controls/Navigation/NavigationViewItem.cs
index fc550cee3..ab051cf92 100644
--- a/src/Wpf.Ui/Controls/Navigation/NavigationViewItem.cs
+++ b/src/Wpf.Ui/Controls/Navigation/NavigationViewItem.cs
@@ -31,14 +31,14 @@ public class NavigationViewItem : System.Windows.Controls.Primitives.ButtonBase,
     /// </summary>
     public static readonly DependencyProperty MenuItemsProperty = DependencyProperty.Register(nameof(MenuItems),
         typeof(IList), typeof(NavigationViewItem),
-        new PropertyMetadata(OnMenuItemsPropertyChanged));
+        new PropertyMetadata(new ObservableCollection<object>(), OnMenuItemsPropertyChanged));
 
     /// <summary>
     /// Property for <see cref="MenuItemsSource"/>.
     /// </summary>
     public static readonly DependencyProperty MenuItemsSourceProperty = DependencyProperty.Register(nameof(MenuItemsSource),
         typeof(object), typeof(NavigationViewItem),
-        new PropertyMetadata(((object)null!), OnMenuItemsSourcePropertyChanged));
+        new PropertyMetadata(null, OnMenuItemsSourcePropertyChanged));
 
     /// <summary>
     /// Property for <see cref="HasMenuItems"/>.
@@ -63,30 +63,30 @@ public class NavigationViewItem : System.Windows.Controls.Primitives.ButtonBase,
     /// </summary>
     public static readonly DependencyProperty IconProperty = DependencyProperty.Register(nameof(Icon),
         typeof(object), typeof(NavigationViewItem),
-        new PropertyMetadata((object)null!));
+        new PropertyMetadata(null));
 
     /// <summary>
     /// Property for <see cref="TargetPageTag"/>.
     /// </summary>
     public static readonly DependencyProperty TargetPageTagProperty = DependencyProperty.Register(nameof(TargetPageTag),
-        typeof(string), typeof(NavigationViewItem), new PropertyMetadata(String.Empty));
+        typeof(string), typeof(NavigationViewItem), new PropertyMetadata(string.Empty));
 
     /// <summary>
     /// Property for <see cref="TargetPageType"/>.
     /// </summary>
     public static readonly DependencyProperty TargetPageTypeProperty = DependencyProperty.Register(nameof(TargetPageType),
-        typeof(Type), typeof(NavigationViewItem), new PropertyMetadata((Type)null!));
+        typeof(Type), typeof(NavigationViewItem), new PropertyMetadata(null));
 
     /// <inheritdoc/>
-    public IList? MenuItems
+    public IList MenuItems
     {
-        get => (IList?)GetValue(MenuItemsProperty);
+        get => (IList)GetValue(MenuItemsProperty);
         set => SetValue(MenuItemsProperty, value);
     }
 
     /// <inheritdoc/>
     [Bindable(true)]
-    public object MenuItemsSource
+    public object? MenuItemsSource
     {
         get => GetValue(MenuItemsSourceProperty);
         set
@@ -113,7 +113,7 @@ public bool HasMenuItems
     public bool IsActive
     {
         get => (bool)GetValue(IsActiveProperty);
-        internal set => SetValue(IsActiveProperty, value);
+        set => SetValue(IsActiveProperty, value);
     }
 
     /// <inheritdoc />
@@ -121,12 +121,12 @@ public bool IsActive
     public bool IsExpanded
     {
         get => (bool)GetValue(IsExpandedProperty);
-        internal set => SetValue(IsExpandedProperty, value);
+        set => SetValue(IsExpandedProperty, value);
     }
 
     /// <inheritdoc />
     [Bindable(true), Category("Appearance")]
-    public object Icon
+    public object? Icon
     {
         get => GetValue(IconProperty);
         set => SetValue(IconProperty, value);
@@ -140,12 +140,18 @@ public string TargetPageTag
     }
 
     /// <inheritdoc />
-    public Type TargetPageType
+    public Type? TargetPageType
     {
         get => (Type)GetValue(TargetPageTypeProperty);
         set => SetValue(TargetPageTypeProperty, value);
     }
 
+    /// <inheritdoc />
+    public INavigationViewItem? NavigationViewItemParent { get; set; }
+
+    /// <inheritdoc />
+    public bool IsMenuElement { get; set; }
+
     /// <inheritdoc />
     public string Id { get; }
 
@@ -158,19 +164,40 @@ public NavigationViewItem()
     {
         Id = Guid.NewGuid().ToString("n");
 
-        SetValue(MenuItemsProperty,
-            new ObservableCollection<object>());
+        //Just in case
+        Unloaded += static (sender, _) => ((NavigationViewItem)sender).NavigationViewItemParent = null;
     }
 
-    public NavigationViewItem(string name, SymbolRegular icon, Type targetPageType)
+    public NavigationViewItem(Type targetPageType) : this()
     {
-        Id = Guid.NewGuid().ToString("n");
+        SetValue(TargetPageTypeProperty, targetPageType);
+    }
 
-        SetValue(MenuItemsProperty,
-            new ObservableCollection<object>());
+    public NavigationViewItem(string name, SymbolRegular icon, Type targetPageType) : this(targetPageType)
+    {
         SetValue(ContentProperty, name);
         SetValue(IconProperty, new SymbolIcon { Symbol = icon });
-        SetValue(TargetPageTypeProperty, targetPageType);
+    }
+
+    /// <inheritdoc />
+    public void Activate(NavigationViewPaneDisplayMode paneDisplayMode)
+    {
+        IsActive = true;
+
+        if (Icon is SymbolIcon symbolIcon && paneDisplayMode == NavigationViewPaneDisplayMode.LeftFluent)
+            symbolIcon.Filled = true;
+
+        if (NavigationViewItemParent is not null)
+            NavigationViewItemParent.IsExpanded = true;
+    }
+
+    /// <inheritdoc />
+    public void Deactivate(NavigationViewPaneDisplayMode paneDisplayMode)
+    {
+        IsActive = false;
+
+        if (Icon is SymbolIcon symbolIcon && paneDisplayMode == NavigationViewPaneDisplayMode.LeftFluent)
+            symbolIcon.Filled = false;
     }
 
     /// <inheritdoc />
@@ -178,19 +205,10 @@ protected override void OnInitialized(EventArgs e)
     {
         base.OnInitialized(e);
 
-        if (MenuItems?.Count > 0)
-            HasMenuItems = true;
-
-        if (MenuItemsSource is IList menuItemsSourceList)
+        if (string.IsNullOrWhiteSpace(TargetPageTag) && Content is not null)
         {
-            if (MenuItems != null)
-                MenuItems = null;
-
-            MenuItems = menuItemsSourceList;
+            TargetPageTag = Content as string ?? Content.ToString()?.ToLower().Trim() ?? string.Empty;
         }
-
-        if (String.IsNullOrWhiteSpace(TargetPageTag))
-            TargetPageTag = Content?.ToString()!.ToLower()!.Trim() ?? String.Empty;
     }
 
     /// <inheritdoc />
@@ -206,7 +224,7 @@ protected override void OnClick()
     }
 
     /// <summary>
-    /// Is called when mouse is cliked down.
+    /// Is called when mouse is clicked down.
     /// </summary>
     protected override void OnMouseDown(MouseButtonEventArgs e)
     {
@@ -224,12 +242,11 @@ protected override void OnMouseDown(MouseButtonEventArgs e)
             return;
         }
 
-        var parentNativagionView = NavigationView.GetNavigationParent(this);
+        var parentNavigationView = NavigationView.GetNavigationParent(this);
 
-        if (parentNativagionView?.IsPaneOpen ?? false || parentNativagionView?.PaneDisplayMode != NavigationViewPaneDisplayMode.Left)
+        if (parentNavigationView?.IsPaneOpen ?? parentNavigationView?.PaneDisplayMode != NavigationViewPaneDisplayMode.Left)
         {
             base.OnMouseDown(e);
-
             return;
         }
 
@@ -238,7 +255,6 @@ protected override void OnMouseDown(MouseButtonEventArgs e)
         if (!mouseOverChevron)
         {
             base.OnMouseDown(e);
-
             return;
         }
 
@@ -254,20 +270,25 @@ private static void OnMenuItemsPropertyChanged(DependencyObject d, DependencyPro
         if (d is not NavigationViewItem navigationViewItem)
             return;
 
-        navigationViewItem.HasMenuItems = navigationViewItem.MenuItems?.Count > 0;
+        navigationViewItem.HasMenuItems = navigationViewItem.MenuItems.Count > 0;
+
+        foreach (var menuItem in navigationViewItem.MenuItems)
+        {
+            if (menuItem is not INavigationViewItem item)
+                continue;
+
+            item.NavigationViewItemParent = navigationViewItem;
+        }
     }
 
     private static void OnMenuItemsSourcePropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
     {
-        if (d is not NavigationViewItem navigationViewItem)
+        if (d is not NavigationViewItem navigationViewItem || e.NewValue is not IList enumerableNewValue)
             return;
 
-        if (e.NewValue is not IList enumerableNewValue)
-            return;
-
-        if (navigationViewItem.MenuItems != null)
-            navigationViewItem.MenuItems = null;
-
         navigationViewItem.MenuItems = enumerableNewValue;
+
+        if (navigationViewItem.MenuItems.Count > 0)
+            navigationViewItem.HasMenuItems = true;
     }
 }
diff --git a/src/Wpf.Ui/Services/NavigationService.cs b/src/Wpf.Ui/Services/NavigationService.cs
index 52978f758..9aac962bf 100644
--- a/src/Wpf.Ui/Services/NavigationService.cs
+++ b/src/Wpf.Ui/Services/NavigationService.cs
@@ -4,6 +4,7 @@
 // All Rights Reserved.
 
 using System;
+using System.Diagnostics.CodeAnalysis;
 using Wpf.Ui.Contracts;
 using Wpf.Ui.Controls.Navigation;
 
@@ -22,12 +23,12 @@ public partial class NavigationService : INavigationService
     /// <summary>
     /// Locally attached page service.
     /// </summary>
-    private IPageService _pageService;
+    private IPageService? _pageService;
 
     /// <summary>
     /// Control representing navigation.
     /// </summary>
-    protected INavigationView NavigationControl;
+    protected INavigationView? NavigationControl;
 
     public NavigationService(IServiceProvider serviceProvider)
     {
@@ -37,7 +38,7 @@ public NavigationService(IServiceProvider serviceProvider)
     /// <inheritdoc />
     public INavigationView GetNavigationControl()
     {
-        return NavigationControl;
+        return NavigationControl ?? throw new ArgumentNullException(nameof(NavigationControl));
     }
 
     /// <inheritdoc />
@@ -61,28 +62,55 @@ public void SetPageService(IPageService pageService)
         if (NavigationControl == null)
         {
             _pageService = pageService;
-
             return;
         }
 
-        NavigationControl.SetPageService(_pageService);
+        ThrowIfPageServiceIsNull();
+
+        NavigationControl.SetPageService(_pageService!);
     }
 
     /// <inheritdoc />
     public bool Navigate(Type pageType)
     {
-        if (NavigationControl == null)
-            return false;
+        ThrowIfNavigationControlIsNull();
 
-        return NavigationControl.Navigate(pageType);
+        return NavigationControl!.Navigate(pageType);
     }
 
     /// <inheritdoc />
     public bool Navigate(string pageTag)
     {
-        if (NavigationControl == null)
-            return false;
+        ThrowIfNavigationControlIsNull();
+
+        return NavigationControl!.Navigate(pageTag);
+    }
+
+    /// <inheritdoc />
+    public bool GoBack()
+    {
+        ThrowIfNavigationControlIsNull();
+
+        return NavigationControl!.GoBack();
+    }
+
+    /// <inheritdoc />
+    public bool NavigateWithHierarchy(Type pageType)
+    {
+        ThrowIfNavigationControlIsNull();
+
+        return NavigationControl!.NavigateWithHierarchy(pageType);
+    }
 
-        return NavigationControl.Navigate(pageTag);
+    private void ThrowIfNavigationControlIsNull()
+    {
+        if (NavigationControl is null)
+            throw new ArgumentNullException(nameof(NavigationControl));
+    }
+
+    private void ThrowIfPageServiceIsNull()
+    {
+        if (_pageService is null)
+            throw new ArgumentNullException(nameof(_pageService));
     }
 }
diff --git a/src/Wpf.Ui/Styles/Controls/BreadcrumbBar.xaml b/src/Wpf.Ui/Styles/Controls/BreadcrumbBar.xaml
index 2d26c1cf0..ecabfe128 100644
--- a/src/Wpf.Ui/Styles/Controls/BreadcrumbBar.xaml
+++ b/src/Wpf.Ui/Styles/Controls/BreadcrumbBar.xaml
@@ -13,7 +13,7 @@
     <Style x:Key="DefaultUiBreadcrumbButtonStyle" TargetType="{x:Type ButtonBase}">
         <Setter Property="Foreground">
             <Setter.Value>
-                <SolidColorBrush Color="{DynamicResource TextFillColorSecondary}" />
+                <SolidColorBrush Color="{DynamicResource TextFillColorTertiary}" />
             </Setter.Value>
         </Setter>
         <Setter Property="Background" Value="Transparent" />
diff --git a/src/Wpf.Ui/Styles/Controls/NavigationView.xaml b/src/Wpf.Ui/Styles/Controls/NavigationView.xaml
index e7c297f38..fe2fadf23 100644
--- a/src/Wpf.Ui/Styles/Controls/NavigationView.xaml
+++ b/src/Wpf.Ui/Styles/Controls/NavigationView.xaml
@@ -621,7 +621,9 @@
                     <navigation:NavigationViewContentPresenter
                         x:Name="PART_NavigationViewContentPresenter"
                         Grid.Row="1"
-                        Margin="{TemplateBinding Padding}" />
+                        Margin="{TemplateBinding Padding}"
+                        TransitionDuration="{TemplateBinding TransitionDuration}"
+                        TransitionType="{TemplateBinding TransitionType}" />
 
                     <!--  Overlay  -->
                     <ContentPresenter
@@ -1095,7 +1097,9 @@
                 <navigation:NavigationViewContentPresenter
                     x:Name="PART_NavigationViewContentPresenter"
                     Grid.Row="1"
-                    Margin="{TemplateBinding Padding}" />
+                    Margin="{TemplateBinding Padding}"
+                    TransitionDuration="{TemplateBinding TransitionDuration}"
+                    TransitionType="{TemplateBinding TransitionType}" />
 
                 <!--  Overlay  -->
                 <ContentPresenter
diff --git a/src/Wpf.Ui/Styles/Controls/NavigationViewBreadcrumb.xaml b/src/Wpf.Ui/Styles/Controls/NavigationViewBreadcrumb.xaml
deleted file mode 100644
index 40868f61c..000000000
--- a/src/Wpf.Ui/Styles/Controls/NavigationViewBreadcrumb.xaml
+++ /dev/null
@@ -1,42 +0,0 @@
-<!--
-    This Source Code Form is subject to the terms of the MIT License.
-    If a copy of the MIT was not distributed with this file, You can obtain one at https://opensource.org/licenses/MIT.
-    Copyright (C) Leszek Pomianowski and WPF UI Contributors.
-    All Rights Reserved.
--->
-
-<ResourceDictionary
-    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
-    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-    xmlns:navigation="clr-namespace:Wpf.Ui.Controls.Navigation">
-
-    <Style TargetType="{x:Type navigation:NavigationViewBreadcrumb}">
-        <Setter Property="Foreground">
-            <Setter.Value>
-                <SolidColorBrush Color="{DynamicResource TextFillColorPrimary}" />
-            </Setter.Value>
-        </Setter>
-        <Setter Property="Background" Value="Transparent" />
-        <Setter Property="FontSize" Value="16" />
-        <Setter Property="FontWeight" Value="Regular" />
-        <Setter Property="HorizontalAlignment" Value="Left" />
-        <Setter Property="VerticalAlignment" Value="Center" />
-        <Setter Property="FocusVisualStyle" Value="{x:Null}" />
-        <Setter Property="IsTabStop" Value="False" />
-        <Setter Property="SnapsToDevicePixels" Value="True" />
-        <Setter Property="OverridesDefaultStyle" Value="True" />
-        <Setter Property="Template">
-            <Setter.Value>
-                <ControlTemplate TargetType="{x:Type navigation:NavigationViewBreadcrumb}">
-                    <TextBlock
-                        Margin="{TemplateBinding Padding}"
-                        FontSize="{TemplateBinding FontSize}"
-                        FontWeight="{TemplateBinding FontWeight}"
-                        Foreground="{TemplateBinding Foreground}"
-                        Text="{TemplateBinding Text}" />
-                </ControlTemplate>
-            </Setter.Value>
-        </Setter>
-    </Style>
-
-</ResourceDictionary>
\ No newline at end of file
diff --git a/src/Wpf.Ui/Styles/Controls/NavigationViewBreadcrumbItem.xaml b/src/Wpf.Ui/Styles/Controls/NavigationViewBreadcrumbItem.xaml
new file mode 100644
index 000000000..f483140d6
--- /dev/null
+++ b/src/Wpf.Ui/Styles/Controls/NavigationViewBreadcrumbItem.xaml
@@ -0,0 +1,17 @@
+<!--
+    This Source Code Form is subject to the terms of the MIT License.
+    If a copy of the MIT was not distributed with this file, You can obtain one at https://opensource.org/licenses/MIT.
+    Copyright (C) Leszek Pomianowski and WPF UI Contributors.
+    All Rights Reserved.
+-->
+
+<ResourceDictionary
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:navigation="clr-namespace:Wpf.Ui.Controls.Navigation">
+
+    <DataTemplate x:Key="NavigationViewItemDataTemplate" DataType="{x:Type navigation:NavigationViewBreadcrumbItem}">
+        <TextBlock Text="{Binding Content}" />
+    </DataTemplate>
+
+</ResourceDictionary>
\ No newline at end of file
diff --git a/src/Wpf.Ui/Styles/Wpf.Ui.xaml b/src/Wpf.Ui/Styles/Wpf.Ui.xaml
index 86d1b702c..956245665 100644
--- a/src/Wpf.Ui/Styles/Wpf.Ui.xaml
+++ b/src/Wpf.Ui/Styles/Wpf.Ui.xaml
@@ -53,7 +53,7 @@
         <ResourceDictionary Source="pack://application:,,,/Wpf.Ui;component/Styles/Controls/NavigationViewContentPresenter.xaml" />
         <ResourceDictionary Source="pack://application:,,,/Wpf.Ui;component/Styles/Controls/NavigationViewItemHeader.xaml" />
         <ResourceDictionary Source="pack://application:,,,/Wpf.Ui;component/Styles/Controls/NavigationViewItemSeparator.xaml" />
-        <ResourceDictionary Source="pack://application:,,,/Wpf.Ui;component/Styles/Controls/NavigationViewBreadcrumb.xaml" />
+        <ResourceDictionary Source="pack://application:,,,/Wpf.Ui;component/Styles/Controls/NavigationViewBreadcrumbItem.xaml" />
         <ResourceDictionary Source="pack://application:,,,/Wpf.Ui;component/Styles/Controls/BreadcrumbBar.xaml" />
         <ResourceDictionary Source="pack://application:,,,/Wpf.Ui;component/Styles/Controls/NavigationView.xaml" />