diff --git a/dev/TabView/InteractionTests/TabViewTests.cs b/dev/TabView/InteractionTests/TabViewTests.cs
index 8c7336c0cf..f4fb8a8160 100644
--- a/dev/TabView/InteractionTests/TabViewTests.cs
+++ b/dev/TabView/InteractionTests/TabViewTests.cs
@@ -130,7 +130,9 @@ public void CloseSelectionTest()
                 Verify.AreEqual(selectedIndexTextBlock.DocumentText, "0");
 
                 Log.Comment("When the selected tab is closed, selection should move to the next one.");
+                // Use Tab's close button:
                 closeButton.InvokeAndWait();
+                VerifyElement.NotFound("FirstTab", FindBy.Name);
                 Verify.AreEqual(selectedIndexTextBlock.DocumentText, "0");
 
                 Log.Comment("Select last tab.");
@@ -140,9 +142,11 @@ public void CloseSelectionTest()
                 Verify.AreEqual(selectedIndexTextBlock.DocumentText, "3");
 
                 Log.Comment("When the selected tab is last and is closed, selection should move to the previous item.");
-                closeButton = FindCloseButton(lastTab);
-                Verify.IsNotNull(closeButton);
-                closeButton.InvokeAndWait();
+
+                // Use Middle Click to close the tab:
+                lastTab.Click(PointerButtons.Middle);
+                Wait.ForIdle();
+                VerifyElement.NotFound("LastTab", FindBy.Name);
                 Verify.AreEqual(selectedIndexTextBlock.DocumentText, "2");
             }
         }
@@ -264,27 +268,108 @@ public void AddButtonTest()
         [TestMethod]
         public void KeyboardTest()
         {
-            if (!PlatformConfiguration.IsOsVersionGreaterThanOrEqual(OSVersion.Redstone3))
-            {
-                Log.Warning("This test requires RS3+ functionality (specifically, KeyboardAccelerators)");
-                return;
-            }
-
             using (var setup = new TestSetupHelper("TabView Tests"))
             {
                 Log.Comment("Set focus inside the TabView");
                 UIObject tabContent = FindElement.ByName("FirstTabContent");
                 tabContent.SetFocus();
 
+                TabItem firstTab = FindElement.ByName<TabItem>("FirstTab");
+                TabItem secondTab = FindElement.ByName<TabItem>("SecondTab");
+                TabItem lastTab = FindElement.ByName<TabItem>("LastTab");
+
+                Button addButton = FindElement.ById<Button>("AddButton");
+
+                Verify.IsTrue(firstTab.IsSelected, "First Tab should be selected initially");
+                Button firstTabButton = FindElement.ByName<Button>("FirstTabButton");
+                Verify.IsTrue(firstTabButton.HasKeyboardFocus, "Focus should start in the First Tab");
+
+                // Ctrl+Tab to the second tab:
+                KeyboardHelper.PressKey(Key.Tab, ModifierKey.Control);
+                Verify.IsTrue(secondTab.IsSelected, "Ctrl+Tab should move selection to Second Tab");
+                Button secondTabButton = FindElement.ByName<Button>("SecondTabButton");
+                Verify.IsTrue(secondTabButton.HasKeyboardFocus, "Focus should move to the content of the Second Tab");
+
+                // Ctrl+Shift+Tab to the first tab:
+                KeyboardHelper.PressKey(Key.Tab, ModifierKey.Control | ModifierKey.Shift);
+                Verify.IsTrue(firstTab.IsSelected, "Ctrl+Shift+Tab should move selection to First Tab");
+                Verify.IsTrue(firstTabButton.HasKeyboardFocus, "Focus should move to the content of the First Tab");
+
+                // Ctrl+Shift+Tab to the last tab:
+                KeyboardHelper.PressKey(Key.Tab, ModifierKey.Control | ModifierKey.Shift);
+                Verify.IsTrue(lastTab.IsSelected, "Ctrl+Shift+Tab should move selection to Last Tab");
+                Verify.IsTrue(lastTab.HasKeyboardFocus, "Focus should move to the last tab (since it has no focusable content)");
+
+                // Ctrl+Tab to the first tab:
+                KeyboardHelper.PressKey(Key.Tab, ModifierKey.Control);
+                Verify.IsTrue(firstTab.IsSelected, "Ctrl+Tab should move selection to First Tab");
+                Verify.IsTrue(firstTab.HasKeyboardFocus, "Focus should move to the first tab");
+
+                KeyboardHelper.PressKey(Key.Up);
+                Verify.IsTrue(firstTab.HasKeyboardFocus, "Up key should not move focus");
+
+                KeyboardHelper.PressKey(Key.Down);
+                Verify.IsTrue(firstTab.HasKeyboardFocus, "Down key should not move focus");
+
+                KeyboardHelper.PressKey(Key.Right);
+                Verify.IsTrue(secondTab.HasKeyboardFocus, "Right Key should move focus to the second tab");
+
+                KeyboardHelper.PressKey(Key.Left);
+                Verify.IsTrue(firstTab.HasKeyboardFocus, "Left Key should move focus to the first tab");
+
+                addButton.SetFocus();
+                Verify.IsTrue(addButton.HasKeyboardFocus, "AddButton should have keyboard focus");
+
+                KeyboardHelper.PressKey(Key.Left);
+                Verify.IsTrue(lastTab.HasKeyboardFocus, "Left Key from AddButton should move focus to last tab");
+
+                KeyboardHelper.PressKey(Key.Right);
+                Verify.IsTrue(addButton.HasKeyboardFocus, "Right Key from Last Tab should move focus to Add Button");
+
+                firstTab.SetFocus();
+
+                // Ctrl+f4 to close the tab:
                 Log.Comment("Verify that pressing ctrl-f4 closes the tab");
-                KeyboardHelper.PressDownModifierKey(ModifierKey.Control);
-                TextInput.SendText("{F4}");
-                KeyboardHelper.ReleaseModifierKey(ModifierKey.Control);
+                KeyboardHelper.PressKey(Key.F4, ModifierKey.Control);
                 Wait.ForIdle();
 
-                ElementCache.Refresh();
-                UIObject firstTab = TryFindElement.ByName("FirstTab");
-                Verify.IsNull(firstTab);
+                VerifyElement.NotFound("FirstTab", FindBy.Name);
+            }
+        }
+
+        [TestMethod]
+        public void GamePadTest()
+        {
+            using (var setup = new TestSetupHelper("TabView Tests"))
+            {
+                Button tabContent = FindElement.ByName<Button>("FirstTabButton");
+                Button backButton = FindElement.ById<Button>("__BackButton");
+                TabItem firstTab = FindElement.ByName<TabItem>("FirstTab");
+                TabItem secondTab = FindElement.ByName<TabItem>("SecondTab");
+                TabItem lastTab = FindElement.ByName<TabItem>("LastTab");
+                Button addButton = FindElement.ById<Button>("AddButton");
+
+                firstTab.SetFocus();
+
+                GamepadHelper.PressButton(null, GamepadButton.LeftThumbstickRight);
+                Wait.ForIdle();
+                Verify.IsTrue(secondTab.HasKeyboardFocus, "GamePad Right should move focus to second tab");
+
+                GamepadHelper.PressButton(null, GamepadButton.LeftThumbstickLeft);
+                Wait.ForIdle();
+                Verify.IsTrue(firstTab.HasKeyboardFocus, "GamePad Left should move focus to first tab");
+
+                GamepadHelper.PressButton(null, GamepadButton.LeftThumbstickDown);
+                Wait.ForIdle();
+                Verify.IsTrue(tabContent.HasKeyboardFocus, "GamePad Down should move focus to tab content");
+
+                GamepadHelper.PressButton(null, GamepadButton.LeftThumbstickUp);
+                Wait.ForIdle();
+                Verify.IsTrue(firstTab.HasKeyboardFocus, "GamePad Up should move focus to tabs");
+
+                GamepadHelper.PressButton(null, GamepadButton.LeftThumbstickUp);
+                Wait.ForIdle();
+                Verify.IsTrue(backButton.HasKeyboardFocus, "GamePad Up should move to back button");
             }
         }
 
diff --git a/dev/TabView/TabView.cpp b/dev/TabView/TabView.cpp
index bd9881b1a3..4c26483f45 100644
--- a/dev/TabView/TabView.cpp
+++ b/dev/TabView/TabView.cpp
@@ -10,6 +10,7 @@
 #include "ResourceAccessor.h"
 #include "SharedHelpers.h"
 #include <Vector.h>
+#include "InspectingDataSource.h"
 
 static constexpr double c_tabMinimumWidth = 48.0;
 static constexpr double c_tabMaximumWidth = 200.0;
@@ -31,6 +32,35 @@ TabView::TabView()
 
     Loaded({ this, &TabView::OnLoaded });
     SizeChanged({ this, &TabView::OnSizeChanged });
+
+    // KeyboardAccelerator is only available on RS3+
+    if (SharedHelpers::IsRS3OrHigher())
+    {
+        winrt::KeyboardAccelerator ctrlf4Accel;
+        ctrlf4Accel.Key(winrt::VirtualKey::F4);
+        ctrlf4Accel.Modifiers(winrt::VirtualKeyModifiers::Control);
+        ctrlf4Accel.Invoked({ this, &TabView::OnCtrlF4Invoked });
+        ctrlf4Accel.ScopeOwner(*this);
+        KeyboardAccelerators().Append(ctrlf4Accel);
+    }
+
+    // Ctrl+Tab as a KeyboardAccelerator only works on 19H1+
+    if (SharedHelpers::Is19H1OrHigher())
+    {
+        winrt::KeyboardAccelerator ctrlTabAccel;
+        ctrlTabAccel.Key(winrt::VirtualKey::Tab);
+        ctrlTabAccel.Modifiers(winrt::VirtualKeyModifiers::Control);
+        ctrlTabAccel.Invoked({ this, &TabView::OnCtrlTabInvoked });
+        ctrlTabAccel.ScopeOwner(*this);
+        KeyboardAccelerators().Append(ctrlTabAccel);
+
+        winrt::KeyboardAccelerator ctrlShiftTabAccel;
+        ctrlShiftTabAccel.Key(winrt::VirtualKey::Tab);
+        ctrlShiftTabAccel.Modifiers(winrt::VirtualKeyModifiers::Control | winrt::VirtualKeyModifiers::Shift);
+        ctrlShiftTabAccel.Invoked({ this, &TabView::OnCtrlShiftTabInvoked });
+        ctrlShiftTabAccel.ScopeOwner(*this);
+        KeyboardAccelerators().Append(ctrlShiftTabAccel);
+    }
 }
 
 void TabView::OnApplyTemplate()
@@ -58,6 +88,8 @@ void TabView::OnApplyTemplate()
             m_listViewDragItemsCompletedRevoker = listView.DragItemsCompleted(winrt::auto_revoke, { this, &TabView::OnListViewDragItemsCompleted });
             m_listViewDragOverRevoker = listView.DragOver(winrt::auto_revoke, { this, &TabView::OnListViewDragOver });
             m_listViewDropRevoker = listView.Drop(winrt::auto_revoke, { this, &TabView::OnListViewDrop });
+
+            m_listViewGettingFocusRevoker = listView.GettingFocus(winrt::auto_revoke, { this, &TabView::OnListViewGettingFocus });
         }
         return listView;
     }());
@@ -86,17 +118,65 @@ void TabView::OnApplyTemplate()
         return addButton;
     }());
 
-    if (SharedHelpers::IsRS3OrHigher())
+    UpdateItemsSource();
+}
+
+void TabView::OnListViewGettingFocus(const winrt::IInspectable& sender, const winrt::GettingFocusEventArgs& args)
+{
+    // TabViewItems overlap each other by one pixel in order to get the desired visuals for the separator.
+    // This causes problems with 2d focus navigation. Because the items overlap, pressing Down or Up from a
+    // TabViewItem navigates to the overlapping item which is not desired.
+    //
+    // To resolve this issue, we detect the case where Up or Down focus navigation moves from one TabViewItem
+    // to another.
+    // How we handle it, depends on the input device.
+    // For GamePad, we want to move focus to something in the direction of movement (other than the overlapping item)
+    // For Keyboard, we cancel the focus movement.
+
+    auto direction = args.Direction();
+    if (direction == winrt::FocusNavigationDirection::Up || direction == winrt::FocusNavigationDirection::Down)
     {
-        winrt::KeyboardAccelerator keyboardAccelerator;
-        keyboardAccelerator.Key(winrt::VirtualKey::F4);
-        keyboardAccelerator.Modifiers(winrt::VirtualKeyModifiers::Control);
-        keyboardAccelerator.Invoked({ this, &TabView::OnCtrlF4Invoked });
-        keyboardAccelerator.ScopeOwner(*this);
-        KeyboardAccelerators().Append(keyboardAccelerator);
+        auto oldItem = args.OldFocusedElement().try_as<winrt::TabViewItem>();
+        auto newItem = args.NewFocusedElement().try_as<winrt::TabViewItem>();
+        if (oldItem && newItem)
+        {
+            if (auto listView = m_listView.get())
+            {
+                bool oldItemIsFromThisTabView = listView.IndexFromContainer(oldItem) != -1;
+                bool newItemIsFromThisTabView = listView.IndexFromContainer(newItem) != -1;
+                if (oldItemIsFromThisTabView && newItemIsFromThisTabView)
+                {
+                    auto inputDevice = args.InputDevice();
+                    if (inputDevice == winrt::FocusInputDeviceKind::GameController)
+                    {
+                        auto listViewBoundsLocal = winrt::Rect{ 0, 0, static_cast<float>(listView.ActualWidth()), static_cast<float>(listView.ActualHeight()) };
+                        auto listViewBounds = listView.TransformToVisual(nullptr).TransformBounds(listViewBoundsLocal);
+                        winrt::FindNextElementOptions options;
+                        options.ExclusionRect(listViewBounds);
+                        auto next = winrt::FocusManager::FindNextElement(direction, options);
+                        if(auto args2 = args.try_as<winrt::IGettingFocusEventArgs2>())
+                        {
+                            args2.TrySetNewFocusedElement(next);
+                        }
+                        else
+                        {
+                            // Without TrySetNewFocusedElement, we cannot set focus while it is changing.
+                            m_dispatcherHelper.RunAsync([next]()
+                            {
+                                SetFocus(next, winrt::FocusState::Programmatic);
+                            });
+                        }
+                        args.Handled(true);
+                    }
+                    else
+                    {
+                        args.Cancel(true);
+                        args.Handled(true);
+                    }
+                }
+            }
+        }
     }
-
-    UpdateItemsSource();
 }
 
 void TabView::UpdateItemsSource()
@@ -328,9 +408,38 @@ void TabView::UpdateTabContent()
         {
             if (auto container = ContainerFromItem(SelectedItem()).as<winrt::ListViewItem>())
             {
+                // If the focus was in the old tab content, we will lose focus when it is removed from the visual tree.
+                // We should move the focus to the new tab content.
+                // The new tab content is not available at the time of the LosingFocus event, so we need to
+                // move focus later.
+                bool shouldMoveFocusToNewTab = false;
+                auto revoker = tabContentPresenter.LosingFocus(winrt::auto_revoke, [&shouldMoveFocusToNewTab](const winrt::IInspectable&, const winrt::LosingFocusEventArgs& args)
+                {
+                    shouldMoveFocusToNewTab = true;
+                });
+
                 tabContentPresenter.Content(container.Content());
                 tabContentPresenter.ContentTemplate(container.ContentTemplate());
                 tabContentPresenter.ContentTemplateSelector(container.ContentTemplateSelector());
+
+                // It is not ideal to call UpdateLayout here, but it is necessary to ensure that the ContentPresenter has expanded its content
+                // into the live visual tree.
+                tabContentPresenter.UpdateLayout();
+
+                if (shouldMoveFocusToNewTab)
+                {
+                    auto focusable = winrt::FocusManager::FindFirstFocusableElement(tabContentPresenter);
+                    if (!focusable)
+                    {
+                        // If there is nothing focusable in the new tab, just move focus to the TabView itself.
+                        focusable = winrt::FocusManager::FindFirstFocusableElement(*this);
+                    }
+
+                    if (focusable)
+                    {
+                        SetFocus(focusable, winrt::FocusState::Programmatic);
+                    }
+                }
             }
         }
     }
@@ -504,15 +613,98 @@ winrt::DependencyObject TabView::ContainerFromIndex(int index)
     return nullptr;
 }
 
-void TabView::OnCtrlF4Invoked(const winrt::KeyboardAccelerator& sender, const winrt::KeyboardAcceleratorInvokedEventArgs& args)
+int TabView::GetItemCount()
 {
+    if (auto itemssource = ItemsSource())
+    {
+        return winrt::make<InspectingDataSource>(ItemsSource()).Count();
+    }
+    else
+    {
+        return static_cast<int>(Items().Size());
+    }
+}
+
+bool TabView::SelectNextTab(int increment)
+{
+    bool handled = false;
+    const int itemsSize = GetItemCount();
+    if (itemsSize > 1)
+    {
+        auto index = SelectedIndex();
+        index = (index + increment + itemsSize) % itemsSize;
+        SelectedIndex(index);
+        handled = true;
+    }
+    return handled;
+}
+
+bool TabView::CloseCurrentTab()
+{
+    bool handled = false;
     if (auto selectedTab = SelectedItem().try_as<winrt::TabViewItem>())
     {
         if (selectedTab.IsCloseable())
         {
             // Close the tab on ctrl + F4
             CloseTab(selectedTab);
-            args.Handled(true);
+            handled = true;
+        }
+    }
+
+    return handled;
+}
+
+void TabView::OnKeyDown(winrt::KeyRoutedEventArgs const& args)
+{
+    if (auto coreWindow = winrt::CoreWindow::GetForCurrentThread())
+    {
+        if (args.Key() == winrt::VirtualKey::F4)
+        {
+            // Handle Ctrl+F4 on RS2 and lower
+            // On RS3+, it is handled by a KeyboardAccelerator
+            if (!SharedHelpers::IsRS3OrHigher())
+            {
+                auto isCtrlDown = (coreWindow.GetKeyState(winrt::VirtualKey::Control) & winrt::CoreVirtualKeyStates::Down) == winrt::CoreVirtualKeyStates::Down;
+                if (isCtrlDown)
+                {
+                    args.Handled(CloseCurrentTab());
+                }
+            }
+        }
+        else if (args.Key() == winrt::VirtualKey::Tab)
+        {
+            // Handle Ctrl+Tab/Ctrl+Shift+Tab on RS5 and lower
+            // On 19H1+, it is handled by a KeyboardAccelerator
+            if (!SharedHelpers::Is19H1OrHigher())
+            {
+                auto isCtrlDown = (coreWindow.GetKeyState(winrt::VirtualKey::Control) & winrt::CoreVirtualKeyStates::Down) == winrt::CoreVirtualKeyStates::Down;
+                auto isShiftDown = (coreWindow.GetKeyState(winrt::VirtualKey::Shift) & winrt::CoreVirtualKeyStates::Down) == winrt::CoreVirtualKeyStates::Down;
+
+                if (isCtrlDown && !isShiftDown)
+                {
+                    args.Handled(SelectNextTab(1));
+                }
+                else if (isCtrlDown && isShiftDown)
+                {
+                    args.Handled(SelectNextTab(-1));
+                }
+            }
         }
     }
 }
+
+void TabView::OnCtrlF4Invoked(const winrt::KeyboardAccelerator& sender, const winrt::KeyboardAcceleratorInvokedEventArgs& args)
+{
+    args.Handled(CloseCurrentTab());
+}
+
+void TabView::OnCtrlTabInvoked(const winrt::KeyboardAccelerator& sender, const winrt::KeyboardAcceleratorInvokedEventArgs& args)
+{
+    args.Handled(SelectNextTab(1));
+}
+
+void TabView::OnCtrlShiftTabInvoked(const winrt::KeyboardAccelerator& sender, const winrt::KeyboardAcceleratorInvokedEventArgs& args)
+{
+    args.Handled(SelectNextTab(-1));
+}
diff --git a/dev/TabView/TabView.h b/dev/TabView/TabView.h
index e73ac99026..b8cd2a1afd 100644
--- a/dev/TabView/TabView.h
+++ b/dev/TabView/TabView.h
@@ -10,6 +10,7 @@
 #include "TabView.properties.h"
 #include "TabViewTabClosingEventArgs.g.h"
 #include "TabViewTabDraggedOutsideEventArgs.g.h"
+#include "DispatcherHelper.h"
 
 class TabViewTabClosingEventArgs :
     public winrt::implementation::TabViewTabClosingEventArgsT<TabViewTabClosingEventArgs>
@@ -59,6 +60,9 @@ class TabView :
     winrt::DependencyObject ContainerFromItem(winrt::IInspectable const& item);
     winrt::DependencyObject ContainerFromIndex(int index);
 
+    // Control
+    void OnKeyDown(winrt::KeyRoutedEventArgs const& e);
+
     // Internal
     void OnItemsPropertyChanged(const winrt::DependencyPropertyChangedEventArgs& args);
     void OnItemsSourcePropertyChanged(const winrt::DependencyPropertyChangedEventArgs& args);
@@ -87,6 +91,11 @@ class TabView :
     void OnListViewDrop(const winrt::IInspectable& sender, const winrt::DragEventArgs& args);
 
     void OnCtrlF4Invoked(const winrt::KeyboardAccelerator& sender, const winrt::KeyboardAcceleratorInvokedEventArgs& args);
+    void OnCtrlTabInvoked(const winrt::KeyboardAccelerator& sender, const winrt::KeyboardAcceleratorInvokedEventArgs& args);
+    void OnCtrlShiftTabInvoked(const winrt::KeyboardAccelerator& sender, const winrt::KeyboardAcceleratorInvokedEventArgs& args);
+
+    bool CloseCurrentTab();
+    bool SelectNextTab(int increment);
 
     void UpdateItemsSource();
     void UpdateSelectedItem();
@@ -95,6 +104,10 @@ class TabView :
     void UpdateTabContent();
     void UpdateTabWidths();
 
+    void OnListViewGettingFocus(const winrt::IInspectable& sender, const winrt::GettingFocusEventArgs& args);
+
+    int GetItemCount();
+
     tracker_ref<winrt::ColumnDefinition> m_leftContentColumn{ this };
     tracker_ref<winrt::ColumnDefinition> m_tabColumn{ this };
     tracker_ref<winrt::ColumnDefinition> m_addButtonColumn{ this };
@@ -111,6 +124,7 @@ class TabView :
 
     winrt::ListView::Loaded_revoker m_listViewLoadedRevoker{};
     winrt::Selector::SelectionChanged_revoker m_listViewSelectionChangedRevoker{};
+    winrt::UIElement::GettingFocus_revoker m_listViewGettingFocusRevoker{};
 
     winrt::ListView::DragItemsStarting_revoker m_listViewDragItemsStartingRevoker{};
     winrt::ListView::DragItemsCompleted_revoker m_listViewDragItemsCompletedRevoker{};
@@ -123,4 +137,6 @@ class TabView :
 
     winrt::RepeatButton::Click_revoker m_scrollDecreaseClickRevoker{};
     winrt::RepeatButton::Click_revoker m_scrollIncreaseClickRevoker{};
+
+    DispatcherHelper m_dispatcherHelper{ *this };
 };
diff --git a/dev/TabView/TabView.xaml b/dev/TabView/TabView.xaml
index 7d6f909262..9160518b0c 100644
--- a/dev/TabView/TabView.xaml
+++ b/dev/TabView/TabView.xaml
@@ -19,9 +19,9 @@
                             <RowDefinition Height="Auto" />
                             <RowDefinition Height="*" />
                         </Grid.RowDefinitions>
-
                         <Grid x:Name="TabContainerGrid"
-                            Background="{ThemeResource TabViewBackground}">
+                            Background="{ThemeResource TabViewBackground}"
+                            XYFocusKeyboardNavigation="Enabled" >
                             <Grid.ColumnDefinitions>
                                 <ColumnDefinition Width="Auto" x:Name="LeftContentColumn"/>
                                 <ColumnDefinition Width="Auto" x:Name="TabColumn"/>
@@ -45,6 +45,7 @@
                                 ItemTemplateSelector="{TemplateBinding ItemTemplateSelector}"/>
 
                             <Button
+                                
                                 Grid.Column="2"
                                 x:Name="AddButton"
                                 Content="&#xE710;"
@@ -77,7 +78,7 @@
         <Setter Property="VerticalAlignment" Value="Top" />
         <Setter Property="Padding" Value="{ThemeResource TabViewHeaderPadding}" />
         <Setter Property="IsTabStop" Value="False" />
-        <Setter Property="TabNavigation" Value="Local" />
+        <Setter Property="TabNavigation" Value="Once" />
         <Setter Property="IsSwipeEnabled" Value="False" />
         <Setter Property="SingleSelectionFollowsFocus" Value="False"/>
         <Setter Property="ScrollViewer.HorizontalScrollBarVisibility" Value="Hidden" />
@@ -111,7 +112,6 @@
         <Setter Property="Template">
             <Setter.Value>
                 <ControlTemplate TargetType="primitives:TabViewListView">
-
                     <Border BorderBrush="{TemplateBinding BorderBrush}" Background="{TemplateBinding Background}" BorderThickness="{TemplateBinding BorderThickness}" CornerRadius="{TemplateBinding CornerRadius}">
                         <ScrollViewer x:Name="ScrollViewer"
                             Grid.Column="1"
diff --git a/dev/TabView/TabViewItem.cpp b/dev/TabView/TabViewItem.cpp
index fb2464564f..d7332eda0d 100644
--- a/dev/TabView/TabViewItem.cpp
+++ b/dev/TabView/TabViewItem.cpp
@@ -47,24 +47,29 @@ void TabViewItem::OnLoaded(const winrt::IInspectable& sender, const winrt::Route
     UpdateCloseButton();
 }
 
+bool TabViewItem::CanClose()
+{
+    bool canClose = false;
+    if (auto tabView = SharedHelpers::GetAncestorOfType<winrt::TabView>(winrt::VisualTreeHelper::GetParent(*this)))
+    {
+        // IsCloseable defaults to true, but if it hasn't been set then CanCloseTabs should override it.
+        canClose =
+            IsCloseable()
+            && (ReadLocalValue(IsCloseableProperty()) != winrt::DependencyProperty::UnsetValue()
+                || tabView.CanCloseTabs());
+    }
+    return canClose;
+}
+
 void TabViewItem::UpdateCloseButton()
 {
     if (auto&& closeButton = m_closeButton.get())
     {
-        if (auto tabView = SharedHelpers::GetAncestorOfType<winrt::TabView>(winrt::VisualTreeHelper::GetParent(*this)))
-        {
-            // IsCloseable defaults to true, but if it hasn't been set then CanCloseTabs should override it.
-            bool canClose =
-                IsCloseable()
-                && (ReadLocalValue(IsCloseableProperty()) != winrt::DependencyProperty::UnsetValue()
-                   || tabView.CanCloseTabs());
-
-            closeButton.Visibility(canClose ? winrt::Visibility::Visible : winrt::Visibility::Collapsed);
-        }
+        closeButton.Visibility(CanClose() ? winrt::Visibility::Visible : winrt::Visibility::Collapsed);
     }
 }
 
-void TabViewItem::OnCloseButtonClick(const winrt::IInspectable&, const winrt::RoutedEventArgs&)
+void TabViewItem::TryClose()
 {
     if (auto tabView = SharedHelpers::GetAncestorOfType<winrt::TabView>(winrt::VisualTreeHelper::GetParent(*this)))
     {
@@ -79,6 +84,11 @@ void TabViewItem::OnCloseButtonClick(const winrt::IInspectable&, const winrt::Ro
     }
 }
 
+void TabViewItem::OnCloseButtonClick(const winrt::IInspectable&, const winrt::RoutedEventArgs&)
+{
+    TryClose();
+}
+
 void TabViewItem::OnCloseButtonPropertyChanged(const winrt::DependencyObject&, const winrt::DependencyProperty&)
 {
     UpdateCloseButton();
@@ -123,3 +133,76 @@ void TabViewItem::OnHeaderPropertyChanged(const winrt::DependencyPropertyChanged
         }
     }
 }
+
+void TabViewItem::OnPointerPressed(winrt::PointerRoutedEventArgs const& args)
+{
+    __super::OnPointerPressed(args);
+
+    if (args.GetCurrentPoint(nullptr).Properties().PointerUpdateKind() == winrt::PointerUpdateKind::MiddleButtonPressed)
+    {
+        if (CapturePointer(args.Pointer()))
+        {
+            m_hasPointerCapture = true;
+            m_isMiddlePointerButtonPressed = true;
+        }
+    }
+}
+
+void TabViewItem::OnPointerReleased(winrt::PointerRoutedEventArgs const& args)
+{
+    __super::OnPointerReleased(args);
+
+    if (m_hasPointerCapture)
+    {
+        if (args.GetCurrentPoint(nullptr).Properties().PointerUpdateKind() == winrt::PointerUpdateKind::MiddleButtonReleased)
+        {
+            bool wasPressed = m_isMiddlePointerButtonPressed;
+            m_isMiddlePointerButtonPressed = false;
+            ReleasePointerCapture(args.Pointer());
+
+            if (wasPressed)
+            {
+                if (CanClose())
+                {
+                    TryClose();
+                }
+            }
+        }
+    }
+}
+
+void TabViewItem::OnPointerEntered(winrt::PointerRoutedEventArgs const& args)
+{
+    __super::OnPointerEntered(args);
+
+    if (m_hasPointerCapture)
+    {
+        m_isMiddlePointerButtonPressed = true;
+    }
+}
+
+void TabViewItem::OnPointerExited(winrt::PointerRoutedEventArgs const& args)
+{
+    __super::OnPointerExited(args);
+
+    m_isMiddlePointerButtonPressed = false;
+}
+
+void TabViewItem::OnPointerCanceled(winrt::PointerRoutedEventArgs const& args)
+{
+    __super::OnPointerCanceled(args);
+
+    if (m_hasPointerCapture)
+    {
+        ReleasePointerCapture(args.Pointer());
+        m_isMiddlePointerButtonPressed = false;
+    }
+}
+
+void TabViewItem::OnPointerCaptureLost(winrt::PointerRoutedEventArgs const& args)
+{
+    __super::OnPointerCaptureLost(args);
+
+    m_hasPointerCapture = false;
+    m_isMiddlePointerButtonPressed = false;
+}
diff --git a/dev/TabView/TabViewItem.h b/dev/TabView/TabViewItem.h
index 256f6201b5..2eb07746f2 100644
--- a/dev/TabView/TabViewItem.h
+++ b/dev/TabView/TabViewItem.h
@@ -27,11 +27,20 @@ class TabViewItem :
     void OnIsCloseablePropertyChanged(const winrt::DependencyPropertyChangedEventArgs& args);
     void OnHeaderPropertyChanged(const winrt::DependencyPropertyChangedEventArgs& args);
 
+    void OnPointerEntered(winrt::PointerRoutedEventArgs const& args);
+    void OnPointerExited(winrt::PointerRoutedEventArgs const& args);
+    void OnPointerPressed(winrt::PointerRoutedEventArgs const& args);
+    void OnPointerReleased(winrt::PointerRoutedEventArgs const& args);
+    void OnPointerCanceled(winrt::PointerRoutedEventArgs const& args);
+    void OnPointerCaptureLost(winrt::PointerRoutedEventArgs const& args);
+
  private:
     tracker_ref<winrt::Button> m_closeButton{ this };
     tracker_ref<winrt::ToolTip> m_toolTip{ this };
 
+    bool CanClose();
     void UpdateCloseButton();
+    void TryClose();
 
     bool m_firstTimeSettingToolTip{ true };
 
@@ -41,4 +50,7 @@ class TabViewItem :
     void OnLoaded(const winrt::IInspectable& sender, const winrt::RoutedEventArgs& args);
     void OnCloseButtonPropertyChanged(const winrt::DependencyObject& sender, const winrt::DependencyProperty& args);
     void OnCloseButtonClick(const winrt::IInspectable& sender, const winrt::RoutedEventArgs& args);
+
+    bool m_hasPointerCapture = false;
+    bool m_isMiddlePointerButtonPressed = false;
 };
diff --git a/dev/TabView/TabView_themeresources.xaml b/dev/TabView/TabView_themeresources.xaml
index 19f675db78..c467fba471 100644
--- a/dev/TabView/TabView_themeresources.xaml
+++ b/dev/TabView/TabView_themeresources.xaml
@@ -34,7 +34,7 @@
         <ResourceDictionary x:Key="HighContrast">
             <StaticResource x:Key="TabViewBackground"                        ResourceKey="SystemControlBackgroundBaseLowBrush" />
             <StaticResource x:Key="TabViewItemHeaderBackground"              ResourceKey="SystemControlTransparentBrush" />
-            <StaticResource x:Key="TabViewItemHeaderBackgroundSelected"      ResourceKey="SystemControlBackgroundAltHighBrush" />
+            <StaticResource x:Key="TabViewItemHeaderBackgroundSelected"      ResourceKey="SystemControlHighlightBaseHighBrush" />
             <StaticResource x:Key="TabViewItemHeaderBackgroundPointerOver"   ResourceKey="SystemControlHighlightListLowBrush" />
             <StaticResource x:Key="TabViewItemHeaderBackgroundPressed"       ResourceKey="SystemControlHighlightListMediumBrush" />
             <StaticResource x:Key="TabViewItemHeaderForeground"              ResourceKey="SystemControlForegroundBaseMediumBrush" />
diff --git a/dev/TabView/TestUI/TabViewPage.xaml b/dev/TabView/TestUI/TabViewPage.xaml
index 8e8f1f84f2..77c40eb12b 100644
--- a/dev/TabView/TestUI/TabViewPage.xaml
+++ b/dev/TabView/TestUI/TabViewPage.xaml
@@ -91,15 +91,33 @@
                     </controls:TabViewItem>
 
                     <controls:TabViewItem x:Name="SecondTab" AutomationProperties.Name="SecondTab" Icon="Shop" Header="Shop" IsCloseable="True">
-                        <TextBlock Padding="16">Shop text</TextBlock>
+                        <StackPanel>
+                            <TextBlock Padding="16">Shop text</TextBlock>
+                            <Button Content="SecondTabButton" AutomationProperties.Name="SecondTabButton" />
+                        </StackPanel>
+                        
                     </controls:TabViewItem>
 
                     <controls:TabViewItem x:Name="LongHeaderTab" AutomationProperties.Name="LongHeaderTab" Icon="Emoji" Header="Longer Header">
-                        <TextBlock Padding="16">Emoji text</TextBlock>
+                        <StackPanel>
+                            <TextBlock Padding="16">Emoji text</TextBlock>
+                            <Button Content="Button 3" />
+                        </StackPanel>
+                        
                     </controls:TabViewItem>
 
                     <controls:TabViewItem x:Name="NotCloseableTab" AutomationProperties.Name="NotCloseableTab" Icon="Video" Header="Video" IsCloseable="False">
-                        <TextBlock Padding="16">This tab can't be closed.</TextBlock>
+                        <StackPanel>
+                            <TextBlock Padding="16">This tab can't be closed.</TextBlock>
+                            <controls:TabView x:Name="innerTabView" >
+                                <controls:TabView.ItemTemplate>
+                                    <DataTemplate x:DataType="local:TabDataItem">
+                                        <controls:TabViewItem Header="{x:Bind Header}" Content="{x:Bind Content}" Icon="Accept" />
+                                    </DataTemplate>
+                                </controls:TabView.ItemTemplate>
+                            </controls:TabView>
+                        </StackPanel>
+                        
                     </controls:TabViewItem>
 
                     <controls:TabViewItem x:Name="LastTab" AutomationProperties.Name="LastTab" Icon="Contact" Header="Contact">
diff --git a/dev/TabView/TestUI/TabViewPage.xaml.cs b/dev/TabView/TestUI/TabViewPage.xaml.cs
index 4b669a3519..271069e83a 100644
--- a/dev/TabView/TestUI/TabViewPage.xaml.cs
+++ b/dev/TabView/TestUI/TabViewPage.xaml.cs
@@ -17,6 +17,12 @@
 
 namespace MUXControlsTestApp
 {
+    public class TabDataItem
+    {
+        public string Header { get; set; }
+        public string Content { get; set; }
+    }
+
     [TopLevelTestPage(Name = "TabView")]
     public sealed partial class TabViewPage : TestPage
     {
@@ -25,6 +31,25 @@ public sealed partial class TabViewPage : TestPage
         public TabViewPage()
         {
             this.InitializeComponent();
+            
+            this.innerTabView.ItemsSource = new []
+            {
+                new TabDataItem 
+                {
+                    Header = "Header 1",
+                    Content = "Content 1"
+                },
+                new TabDataItem
+                {
+                    Header = "Header 2",
+                    Content = "Content 2"
+                },
+                new TabDataItem
+                {
+                    Header = "Header 3",
+                    Content = "Content 3"
+                }
+            };
         }
 
         public void CanCloseCheckBox_CheckChanged(object sender, RoutedEventArgs e)
diff --git a/test/MUXControls.Test/Common/KeyboardHelper.cs b/test/MUXControls.Test/Common/KeyboardHelper.cs
index c8ad7bd695..b949eb2723 100644
--- a/test/MUXControls.Test/Common/KeyboardHelper.cs
+++ b/test/MUXControls.Test/Common/KeyboardHelper.cs
@@ -38,6 +38,7 @@ public enum Key
         Space,
         Backspace,
         F10,
+        F4,
         F6
     }
 
@@ -69,6 +70,7 @@ public class KeyboardHelper
             { Key.Space, "{SPACE}" },
             { Key.Backspace, "{BACKSPACE}" },
             { Key.F10, "{F10}" },
+            { Key.F4, "{F4}" },
             { Key.F6, "{F6}" },
         };