diff --git a/osu.Game.Tests/Visual/Multiplayer/TestSceneDrawableRoomPlaylist.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneDrawableRoomPlaylist.cs
index 76353323d6..e2b4b2870f 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestSceneDrawableRoomPlaylist.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneDrawableRoomPlaylist.cs
@@ -56,6 +56,9 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
             AddStep("click", () => InputManager.Click(MouseButton.Left));
             AddAssert("no item selected", () => playlist.SelectedItem.Value == null);
+
+            AddStep("press down", () => InputManager.Key(Key.Down));
+            AddAssert("no item selected", () => playlist.SelectedItem.Value == null);
         }
 
         [Test]
@@ -73,6 +76,9 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
             AddStep("click", () => InputManager.Click(MouseButton.Left));
             AddAssert("no item selected", () => playlist.SelectedItem.Value == null);
+
+            AddStep("press down", () => InputManager.Key(Key.Down));
+            AddAssert("no item selected", () => playlist.SelectedItem.Value == null);
         }
 
         [Test]
@@ -91,6 +97,9 @@ namespace osu.Game.Tests.Visual.Multiplayer
 
             AddStep("click", () => InputManager.Click(MouseButton.Left));
             AddAssert("no item selected", () => playlist.SelectedItem.Value == null);
+
+            AddStep("press down", () => InputManager.Key(Key.Down));
+            AddAssert("no item selected", () => playlist.SelectedItem.Value == null);
         }
 
         [Test]
@@ -147,6 +156,40 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddAssert("item 1 is selected", () => playlist.SelectedItem.Value == playlist.Items[1]);
         }
 
+        [Test]
+        public void TestKeyboardSelection()
+        {
+            createPlaylist(p => p.AllowSelection = true);
+
+            AddStep("press down", () => InputManager.Key(Key.Down));
+            AddAssert("item 0 is selected", () => playlist.SelectedItem.Value == playlist.Items[0]);
+
+            AddStep("press down", () => InputManager.Key(Key.Down));
+            AddAssert("item 1 is selected", () => playlist.SelectedItem.Value == playlist.Items[1]);
+
+            AddStep("press up", () => InputManager.Key(Key.Up));
+            AddAssert("item 0 is selected", () => playlist.SelectedItem.Value == playlist.Items[0]);
+
+            AddUntilStep("navigate to last item via keyboard", () =>
+            {
+                InputManager.Key(Key.Down);
+                return playlist.SelectedItem.Value == playlist.Items.Last();
+            });
+            AddAssert("last item is selected", () => playlist.SelectedItem.Value == playlist.Items.Last());
+            AddUntilStep("last item is scrolled into view", () =>
+            {
+                var drawableItem = playlist.ItemMap[playlist.Items.Last()];
+                return playlist.ScreenSpaceDrawQuad.Contains(drawableItem.ScreenSpaceDrawQuad.TopLeft)
+                       && playlist.ScreenSpaceDrawQuad.Contains(drawableItem.ScreenSpaceDrawQuad.BottomRight);
+            });
+
+            AddStep("press down", () => InputManager.Key(Key.Down));
+            AddAssert("last item is selected", () => playlist.SelectedItem.Value == playlist.Items.Last());
+
+            AddStep("press up", () => InputManager.Key(Key.Up));
+            AddAssert("second last item is selected", () => playlist.SelectedItem.Value == playlist.Items.Reverse().ElementAt(1));
+        }
+
         [Test]
         public void TestDownloadButtonHiddenWhenBeatmapExists()
         {
diff --git a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayer.cs b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayer.cs
index 6a69917fb4..8e45d99eae 100644
--- a/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayer.cs
+++ b/osu.Game.Tests/Visual/Multiplayer/TestSceneMultiplayer.cs
@@ -7,6 +7,7 @@ using System.Linq;
 using NUnit.Framework;
 using osu.Framework.Allocation;
 using osu.Framework.Audio;
+using osu.Framework.Bindables;
 using osu.Framework.Extensions;
 using osu.Framework.Extensions.ObjectExtensions;
 using osu.Framework.Graphics.Containers;
@@ -17,6 +18,7 @@ using osu.Framework.Screens;
 using osu.Framework.Testing;
 using osu.Framework.Utils;
 using osu.Game.Beatmaps;
+using osu.Game.Configuration;
 using osu.Game.Graphics.UserInterface;
 using osu.Game.Online.API;
 using osu.Game.Online.API.Requests.Responses;
@@ -56,6 +58,9 @@ namespace osu.Game.Tests.Visual.Multiplayer
         private TestMultiplayerClient multiplayerClient => multiplayerComponents.MultiplayerClient;
         private TestMultiplayerRoomManager roomManager => multiplayerComponents.RoomManager;
 
+        [Resolved]
+        private OsuConfigManager config { get; set; }
+
         [BackgroundDependencyLoader]
         private void load(GameHost host, AudioManager audio)
         {
@@ -668,6 +673,43 @@ namespace osu.Game.Tests.Visual.Multiplayer
             AddUntilStep("wait for results", () => multiplayerComponents.CurrentScreen is ResultsScreen);
         }
 
+        [Test]
+        public void TestGameplayExitFlow()
+        {
+            Bindable<double> holdDelay = null;
+
+            AddStep("Set hold delay to zero", () =>
+            {
+                holdDelay = config.GetBindable<double>(OsuSetting.UIHoldActivationDelay);
+                holdDelay.Value = 0;
+            });
+
+            createRoom(() => new Room
+            {
+                Name = { Value = "Test Room" },
+                Playlist =
+                {
+                    new PlaylistItem(beatmaps.GetWorkingBeatmap(importedSet.Beatmaps.First(b => b.Ruleset.OnlineID == 0)).BeatmapInfo)
+                    {
+                        RulesetID = new OsuRuleset().RulesetInfo.OnlineID,
+                    }
+                }
+            });
+
+            enterGameplay();
+
+            AddUntilStep("wait for playing", () => this.ChildrenOfType<Player>().FirstOrDefault()?.LocalUserPlaying.Value == true);
+
+            AddStep("attempt exit without hold", () => InputManager.Key(Key.Escape));
+            AddAssert("still in gameplay", () => multiplayerComponents.CurrentScreen is Player);
+
+            AddStep("attempt exit with hold", () => InputManager.PressKey(Key.Escape));
+            AddUntilStep("wait for lounge", () => multiplayerComponents.CurrentScreen is Screens.OnlinePlay.Multiplayer.Multiplayer);
+
+            AddStep("stop holding", () => InputManager.ReleaseKey(Key.Escape));
+            AddStep("set hold delay to default", () => holdDelay.SetDefault());
+        }
+
         [Test]
         public void TestGameplayDoesntStartWithNonLoadedUser()
         {
diff --git a/osu.Game.Tests/Visual/Online/TestSceneChatOverlayV2.cs b/osu.Game.Tests/Visual/Online/TestSceneChatOverlayV2.cs
new file mode 100644
index 0000000000..7c77ac925e
--- /dev/null
+++ b/osu.Game.Tests/Visual/Online/TestSceneChatOverlayV2.cs
@@ -0,0 +1,422 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+using System;
+using System.Linq;
+using System.Collections.Generic;
+using System.Net;
+using NUnit.Framework;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Logging;
+using osu.Framework.Testing;
+using osu.Framework.Utils;
+using osu.Game.Configuration;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Online.API;
+using osu.Game.Online.API.Requests;
+using osu.Game.Online.API.Requests.Responses;
+using osu.Game.Online.Chat;
+using osu.Game.Overlays;
+using osu.Game.Overlays.Chat;
+using osu.Game.Overlays.Chat.Listing;
+using osu.Game.Overlays.Chat.ChannelList;
+using osuTK;
+using osuTK.Input;
+
+namespace osu.Game.Tests.Visual.Online
+{
+    [TestFixture]
+    public class TestSceneChatOverlayV2 : OsuManualInputManagerTestScene
+    {
+        private ChatOverlayV2 chatOverlay;
+        private ChannelManager channelManager;
+
+        private APIUser testUser;
+        private Channel testPMChannel;
+        private Channel[] testChannels;
+
+        private Channel testChannel1 => testChannels[0];
+        private Channel testChannel2 => testChannels[1];
+
+        [Resolved]
+        private OsuConfigManager config { get; set; } = null!;
+
+        [SetUp]
+        public void SetUp() => Schedule(() =>
+        {
+            testUser = new APIUser { Username = "test user", Id = 5071479 };
+            testPMChannel = new Channel(testUser);
+            testChannels = Enumerable.Range(1, 10).Select(createPublicChannel).ToArray();
+
+            Child = new DependencyProvidingContainer
+            {
+                RelativeSizeAxes = Axes.Both,
+                CachedDependencies = new (Type, object)[]
+                {
+                    (typeof(ChannelManager), channelManager = new ChannelManager()),
+                },
+                Children = new Drawable[]
+                {
+                    channelManager,
+                    chatOverlay = new ChatOverlayV2 { RelativeSizeAxes = Axes.Both },
+                },
+            };
+        });
+
+        [SetUpSteps]
+        public void SetUpSteps()
+        {
+            AddStep("Setup request handler", () =>
+            {
+                ((DummyAPIAccess)API).HandleRequest = req =>
+                {
+                    switch (req)
+                    {
+                        case GetUpdatesRequest getUpdates:
+                            getUpdates.TriggerFailure(new WebException());
+                            return true;
+
+                        case JoinChannelRequest joinChannel:
+                            joinChannel.TriggerSuccess();
+                            return true;
+
+                        case LeaveChannelRequest leaveChannel:
+                            leaveChannel.TriggerSuccess();
+                            return true;
+
+                        case GetMessagesRequest getMessages:
+                            getMessages.TriggerSuccess(createChannelMessages(getMessages.Channel));
+                            return true;
+
+                        case GetUserRequest getUser:
+                            if (getUser.Lookup == testUser.Username)
+                                getUser.TriggerSuccess(testUser);
+                            else
+                                getUser.TriggerFailure(new WebException());
+                            return true;
+
+                        case PostMessageRequest postMessage:
+                            postMessage.TriggerSuccess(new Message(RNG.Next(0, 10000000))
+                            {
+                                Content = postMessage.Message.Content,
+                                ChannelId = postMessage.Message.ChannelId,
+                                Sender = postMessage.Message.Sender,
+                                Timestamp = new DateTimeOffset(DateTime.Now),
+                            });
+                            return true;
+
+                        default:
+                            Logger.Log($"Unhandled Request Type: {req.GetType()}");
+                            return false;
+                    }
+                };
+            });
+
+            AddStep("Add test channels", () =>
+            {
+                (channelManager.AvailableChannels as BindableList<Channel>)?.AddRange(testChannels);
+            });
+        }
+
+        [Test]
+        public void TestShowHide()
+        {
+            AddStep("Show overlay", () => chatOverlay.Show());
+            AddAssert("Overlay is visible", () => chatOverlay.State.Value == Visibility.Visible);
+            AddStep("Hide overlay", () => chatOverlay.Hide());
+            AddAssert("Overlay is hidden", () => chatOverlay.State.Value == Visibility.Hidden);
+        }
+
+        [Test]
+        public void TestChatHeight()
+        {
+            BindableFloat configChatHeight = new BindableFloat();
+            config.BindWith(OsuSetting.ChatDisplayHeight, configChatHeight);
+            float newHeight = 0;
+
+            AddStep("Reset config chat height", () => configChatHeight.SetDefault());
+            AddStep("Show overlay", () => chatOverlay.Show());
+            AddAssert("Overlay uses config height", () => chatOverlay.Height == configChatHeight.Default);
+            AddStep("Click top bar", () =>
+            {
+                InputManager.MoveMouseTo(chatOverlayTopBar);
+                InputManager.PressButton(MouseButton.Left);
+            });
+            AddStep("Drag overlay to new height", () => InputManager.MoveMouseTo(chatOverlayTopBar, new Vector2(0, -300)));
+            AddStep("Stop dragging", () => InputManager.ReleaseButton(MouseButton.Left));
+            AddStep("Store new height", () => newHeight = chatOverlay.Height);
+            AddAssert("Config height changed", () => !configChatHeight.IsDefault && configChatHeight.Value == newHeight);
+            AddStep("Hide overlay", () => chatOverlay.Hide());
+            AddStep("Show overlay", () => chatOverlay.Show());
+            AddAssert("Overlay uses new height", () => chatOverlay.Height == newHeight);
+        }
+
+        [Test]
+        public void TestChannelSelection()
+        {
+            AddStep("Show overlay", () => chatOverlay.Show());
+            AddAssert("Listing is visible", () => listingVisibility == Visibility.Visible);
+            AddStep("Join channel 1", () => channelManager.JoinChannel(testChannel1));
+            AddStep("Select channel 1", () => clickDrawable(getChannelListItem(testChannel1)));
+            AddAssert("Listing is hidden", () => listingVisibility == Visibility.Hidden);
+            AddAssert("Loading is hidden", () => loadingVisibility == Visibility.Hidden);
+            AddAssert("Current channel is correct", () => channelManager.CurrentChannel.Value == testChannel1);
+            AddAssert("DrawableChannel is correct", () => currentDrawableChannel.Channel == testChannel1);
+        }
+
+        [Test]
+        public void TestSearchInListing()
+        {
+            AddStep("Show overlay", () => chatOverlay.Show());
+            AddAssert("Listing is visible", () => listingVisibility == Visibility.Visible);
+            AddStep("Search for 'number 2'", () => chatOverlayTextBox.Text = "number 2");
+            AddUntilStep("Only channel 2 visibile", () =>
+            {
+                IEnumerable<ChannelListingItem> listingItems = chatOverlay.ChildrenOfType<ChannelListingItem>()
+                                                                          .Where(item => item.IsPresent);
+                return listingItems.Count() == 1 && listingItems.Single().Channel == testChannel2;
+            });
+        }
+
+        [Test]
+        public void TestChannelCloseButton()
+        {
+            AddStep("Show overlay", () => chatOverlay.Show());
+            AddStep("Join PM and public channels", () =>
+            {
+                channelManager.JoinChannel(testChannel1);
+                channelManager.JoinChannel(testPMChannel);
+            });
+            AddStep("Select PM channel", () => clickDrawable(getChannelListItem(testPMChannel)));
+            AddStep("Click close button", () =>
+            {
+                ChannelListItemCloseButton closeButton = getChannelListItem(testPMChannel).ChildrenOfType<ChannelListItemCloseButton>().Single();
+                clickDrawable(closeButton);
+            });
+            AddAssert("PM channel closed", () => !channelManager.JoinedChannels.Contains(testPMChannel));
+            AddStep("Select normal channel", () => clickDrawable(getChannelListItem(testChannel1)));
+            AddStep("Click close button", () =>
+            {
+                ChannelListItemCloseButton closeButton = getChannelListItem(testChannel1).ChildrenOfType<ChannelListItemCloseButton>().Single();
+                clickDrawable(closeButton);
+            });
+            AddAssert("Normal channel closed", () => !channelManager.JoinedChannels.Contains(testChannel1));
+        }
+
+        [Test]
+        public void TestChatCommand()
+        {
+            AddStep("Show overlay", () => chatOverlay.Show());
+            AddStep("Join channel 1", () => channelManager.JoinChannel(testChannel1));
+            AddStep("Select channel 1", () => clickDrawable(getChannelListItem(testChannel1)));
+            AddStep("Open chat with user", () => channelManager.PostCommand($"chat {testUser.Username}"));
+            AddAssert("PM channel is selected", () =>
+                channelManager.CurrentChannel.Value.Type == ChannelType.PM && channelManager.CurrentChannel.Value.Users.Single() == testUser);
+            AddStep("Open chat with non-existent user", () => channelManager.PostCommand("chat user_doesnt_exist"));
+            AddAssert("Last message is error", () => channelManager.CurrentChannel.Value.Messages.Last() is ErrorMessage);
+
+            // Make sure no unnecessary requests are made when the PM channel is already open.
+            AddStep("Select channel 1", () => clickDrawable(getChannelListItem(testChannel1)));
+            AddStep("Unregister request handling", () => ((DummyAPIAccess)API).HandleRequest = null);
+            AddStep("Open chat with user", () => channelManager.PostCommand($"chat {testUser.Username}"));
+            AddAssert("PM channel is selected", () =>
+                channelManager.CurrentChannel.Value.Type == ChannelType.PM && channelManager.CurrentChannel.Value.Users.Single() == testUser);
+        }
+
+        [Test]
+        public void TestMultiplayerChannelIsNotShown()
+        {
+            Channel multiplayerChannel = null;
+
+            AddStep("Show overlay", () => chatOverlay.Show());
+            AddStep("Join multiplayer channel", () => channelManager.JoinChannel(multiplayerChannel = new Channel(new APIUser())
+            {
+                Name = "#mp_1",
+                Type = ChannelType.Multiplayer,
+            }));
+            AddAssert("Channel is joined", () => channelManager.JoinedChannels.Contains(multiplayerChannel));
+            AddUntilStep("Channel not present in listing", () => !chatOverlay.ChildrenOfType<ChannelListingItem>()
+                                                                             .Where(item => item.IsPresent)
+                                                                             .Select(item => item.Channel)
+                                                                             .Contains(multiplayerChannel));
+        }
+
+        [Test]
+        public void TestHighlightOnCurrentChannel()
+        {
+            Message message = null;
+
+            AddStep("Show overlay", () => chatOverlay.Show());
+            AddStep("Join channel 1", () => channelManager.JoinChannel(testChannel1));
+            AddStep("Select channel 1", () => clickDrawable(getChannelListItem(testChannel1)));
+            AddStep("Send message in channel 1", () =>
+            {
+                testChannel1.AddNewMessages(message = new Message
+                {
+                    ChannelId = testChannel1.Id,
+                    Content = "Message to highlight!",
+                    Timestamp = DateTimeOffset.Now,
+                    Sender = testUser,
+                });
+            });
+            AddStep("Highlight message", () => chatOverlay.HighlightMessage(message, testChannel1));
+        }
+
+        [Test]
+        public void TestHighlightOnAnotherChannel()
+        {
+            Message message = null;
+
+            AddStep("Show overlay", () => chatOverlay.Show());
+            AddStep("Join channel 1", () => channelManager.JoinChannel(testChannel1));
+            AddStep("Join channel 2", () => channelManager.JoinChannel(testChannel2));
+            AddStep("Select channel 1", () => clickDrawable(getChannelListItem(testChannel1)));
+            AddStep("Send message in channel 2", () =>
+            {
+                testChannel2.AddNewMessages(message = new Message
+                {
+                    ChannelId = testChannel2.Id,
+                    Content = "Message to highlight!",
+                    Timestamp = DateTimeOffset.Now,
+                    Sender = testUser,
+                });
+            });
+            AddStep("Highlight message", () => chatOverlay.HighlightMessage(message, testChannel2));
+            AddAssert("Channel 2 is selected", () => channelManager.CurrentChannel.Value == testChannel2);
+            AddAssert("Channel 2 is visible", () => currentDrawableChannel.Channel == testChannel2);
+        }
+
+        [Test]
+        public void TestHighlightOnLeftChannel()
+        {
+            Message message = null;
+
+            AddStep("Show overlay", () => chatOverlay.Show());
+            AddStep("Join channel 1", () => channelManager.JoinChannel(testChannel1));
+            AddStep("Join channel 2", () => channelManager.JoinChannel(testChannel2));
+            AddStep("Select channel 1", () => clickDrawable(getChannelListItem(testChannel1)));
+            AddStep("Send message in channel 2", () =>
+            {
+                testChannel2.AddNewMessages(message = new Message
+                {
+                    ChannelId = testChannel2.Id,
+                    Content = "Message to highlight!",
+                    Timestamp = DateTimeOffset.Now,
+                    Sender = testUser,
+                });
+            });
+            AddStep("Leave channel 2", () => channelManager.LeaveChannel(testChannel2));
+            AddStep("Highlight message", () => chatOverlay.HighlightMessage(message, testChannel2));
+            AddAssert("Channel 2 is selected", () => channelManager.CurrentChannel.Value == testChannel2);
+            AddAssert("Channel 2 is visible", () => currentDrawableChannel.Channel == testChannel2);
+        }
+
+        [Test]
+        public void TestHighlightWhileChatNeverOpen()
+        {
+            Message message = null;
+
+            AddStep("Join channel 1", () => channelManager.JoinChannel(testChannel1));
+            AddStep("Send message in channel 1", () =>
+            {
+                testChannel1.AddNewMessages(message = new Message
+                {
+                    ChannelId = testChannel1.Id,
+                    Content = "Message to highlight!",
+                    Timestamp = DateTimeOffset.Now,
+                    Sender = testUser,
+                });
+            });
+            AddStep("Highlight message", () => chatOverlay.HighlightMessage(message, testChannel1));
+        }
+
+        [Test]
+        public void TestHighlightWithNullChannel()
+        {
+            Message message = null;
+
+            AddStep("Join channel 1", () => channelManager.JoinChannel(testChannel1));
+            AddStep("Send message in channel 1", () =>
+            {
+                testChannel1.AddNewMessages(message = new Message
+                {
+                    ChannelId = testChannel1.Id,
+                    Content = "Message to highlight!",
+                    Timestamp = DateTimeOffset.Now,
+                    Sender = testUser,
+                });
+            });
+            AddStep("Set null channel", () => channelManager.CurrentChannel.Value = null);
+            AddStep("Highlight message", () => chatOverlay.HighlightMessage(message, testChannel1));
+        }
+
+        [Test]
+        public void TextBoxRetainsFocus()
+        {
+            AddStep("Show overlay", () => chatOverlay.Show());
+            AddAssert("TextBox is focused", () => InputManager.FocusedDrawable == chatOverlayTextBox);
+            AddStep("Join channel 1", () => channelManager.JoinChannel(testChannel1));
+            AddStep("Select channel 1", () => clickDrawable(getChannelListItem(testChannel1)));
+            AddAssert("TextBox is focused", () => InputManager.FocusedDrawable == chatOverlayTextBox);
+            AddStep("Click selector", () => clickDrawable(chatOverlay.ChildrenOfType<ChannelListSelector>().Single()));
+            AddAssert("TextBox is focused", () => InputManager.FocusedDrawable == chatOverlayTextBox);
+            AddStep("Click listing", () => clickDrawable(chatOverlay.ChildrenOfType<ChannelListing>().Single()));
+            AddAssert("TextBox is focused", () => InputManager.FocusedDrawable == chatOverlayTextBox);
+            AddStep("Click drawable channel", () => clickDrawable(chatOverlay.ChildrenOfType<DrawableChannel>().Single()));
+            AddAssert("TextBox is focused", () => InputManager.FocusedDrawable == chatOverlayTextBox);
+            AddStep("Click channel list", () => clickDrawable(chatOverlay.ChildrenOfType<ChannelList>().Single()));
+            AddAssert("TextBox is focused", () => InputManager.FocusedDrawable == chatOverlayTextBox);
+            AddStep("Click top bar", () => clickDrawable(chatOverlay.ChildrenOfType<ChatOverlayTopBar>().Single()));
+            AddAssert("TextBox is focused", () => InputManager.FocusedDrawable == chatOverlayTextBox);
+            AddStep("Hide overlay", () => chatOverlay.Hide());
+            AddAssert("TextBox is not focused", () => InputManager.FocusedDrawable == null);
+        }
+
+        private Visibility listingVisibility =>
+            chatOverlay.ChildrenOfType<ChannelListing>().Single().State.Value;
+
+        private Visibility loadingVisibility =>
+            chatOverlay.ChildrenOfType<LoadingLayer>().Single().State.Value;
+
+        private DrawableChannel currentDrawableChannel =>
+            chatOverlay.ChildrenOfType<Container<DrawableChannel>>().Single().Child;
+
+        private ChannelListItem getChannelListItem(Channel channel) =>
+            chatOverlay.ChildrenOfType<ChannelListItem>().Single(item => item.Channel == channel);
+
+        private ChatTextBox chatOverlayTextBox =>
+            chatOverlay.ChildrenOfType<ChatTextBox>().Single();
+
+        private ChatOverlayTopBar chatOverlayTopBar =>
+            chatOverlay.ChildrenOfType<ChatOverlayTopBar>().Single();
+
+        private void clickDrawable(Drawable d)
+        {
+            InputManager.MoveMouseTo(d);
+            InputManager.Click(MouseButton.Left);
+        }
+
+        private List<Message> createChannelMessages(Channel channel)
+        {
+            var message = new Message
+            {
+                ChannelId = channel.Id,
+                Content = $"Hello, this is a message in {channel.Name}",
+                Sender = testUser,
+                Timestamp = new DateTimeOffset(DateTime.Now),
+            };
+            return new List<Message> { message };
+        }
+
+        private Channel createPublicChannel(int id) => new Channel
+        {
+            Id = id,
+            Name = $"#channel-{id}",
+            Topic = $"We talk about the number {id} here",
+            Type = ChannelType.Public,
+        };
+    }
+}
diff --git a/osu.Game.Tests/Visual/UserInterface/TestSceneModSelectScreen.cs b/osu.Game.Tests/Visual/UserInterface/TestSceneModSelectScreen.cs
index bdb423a43c..c92a738b56 100644
--- a/osu.Game.Tests/Visual/UserInterface/TestSceneModSelectScreen.cs
+++ b/osu.Game.Tests/Visual/UserInterface/TestSceneModSelectScreen.cs
@@ -18,6 +18,7 @@ using osu.Game.Rulesets;
 using osu.Game.Rulesets.Mods;
 using osu.Game.Rulesets.Osu;
 using osu.Game.Rulesets.Osu.Mods;
+using osuTK;
 using osuTK.Input;
 
 namespace osu.Game.Tests.Visual.UserInterface
@@ -164,11 +165,19 @@ namespace osu.Game.Tests.Visual.UserInterface
             AddStep("select mod requiring configuration", () => SelectedMods.Value = new[] { new OsuModDifficultyAdjust() });
             assertCustomisationToggleState(disabled: false, active: true);
 
-            AddStep("dismiss mod customisation", () =>
+            AddStep("dismiss mod customisation via toggle", () =>
             {
                 InputManager.MoveMouseTo(modSelectScreen.ChildrenOfType<ShearedToggleButton>().Single());
                 InputManager.Click(MouseButton.Left);
             });
+            assertCustomisationToggleState(disabled: false, active: false);
+
+            AddStep("reset mods", () => SelectedMods.SetDefault());
+            AddStep("select mod requiring configuration", () => SelectedMods.Value = new[] { new OsuModDifficultyAdjust() });
+            assertCustomisationToggleState(disabled: false, active: true);
+
+            AddStep("dismiss mod customisation via keyboard", () => InputManager.Key(Key.Escape));
+            assertCustomisationToggleState(disabled: false, active: false);
 
             AddStep("append another mod not requiring config", () => SelectedMods.Value = SelectedMods.Value.Append(new OsuModFlashlight()).ToArray());
             assertCustomisationToggleState(disabled: false, active: false);
@@ -183,6 +192,29 @@ namespace osu.Game.Tests.Visual.UserInterface
             assertCustomisationToggleState(disabled: true, active: false); // config was dismissed without explicit user action.
         }
 
+        [Test]
+        public void TestDismissCustomisationViaDimmedArea()
+        {
+            createScreen();
+            assertCustomisationToggleState(disabled: true, active: false);
+
+            AddStep("select mod requiring configuration", () => SelectedMods.Value = new[] { new OsuModDifficultyAdjust() });
+            assertCustomisationToggleState(disabled: false, active: true);
+
+            AddStep("move mouse to settings area", () => InputManager.MoveMouseTo(this.ChildrenOfType<ModSettingsArea>().Single()));
+            AddStep("move mouse to dimmed area", () =>
+            {
+                InputManager.MoveMouseTo(new Vector2(
+                    modSelectScreen.ScreenSpaceDrawQuad.TopLeft.X,
+                    (modSelectScreen.ScreenSpaceDrawQuad.TopLeft.Y + modSelectScreen.ScreenSpaceDrawQuad.BottomLeft.Y) / 2));
+            });
+            AddStep("click", () => InputManager.Click(MouseButton.Left));
+            assertCustomisationToggleState(disabled: false, active: false);
+
+            AddStep("move mouse to first mod panel", () => InputManager.MoveMouseTo(modSelectScreen.ChildrenOfType<ModPanel>().First()));
+            AddAssert("first mod panel is hovered", () => modSelectScreen.ChildrenOfType<ModPanel>().First().IsHovered);
+        }
+
         /// <summary>
         /// Ensure that two mod overlays are not cross polluting via central settings instances.
         /// </summary>
diff --git a/osu.Game/Graphics/Containers/HoldToConfirmContainer.cs b/osu.Game/Graphics/Containers/HoldToConfirmContainer.cs
index 1b802a0a14..28afd082c3 100644
--- a/osu.Game/Graphics/Containers/HoldToConfirmContainer.cs
+++ b/osu.Game/Graphics/Containers/HoldToConfirmContainer.cs
@@ -10,12 +10,32 @@ using osu.Game.Configuration;
 
 namespace osu.Game.Graphics.Containers
 {
+    /// <summary>
+    /// A container which adds a common "hold-to-perform" pattern to a container.
+    /// </summary>
+    /// <remarks>
+    /// This container does not handle triggering the hold/abort operations.
+    /// To use this class, please call <see cref="BeginConfirm"/> and <see cref="AbortConfirm"/> when necessary.
+    ///
+    /// The <see cref="Progress"/> is exposed as a transforming bindable which smoothly tracks the progress of a hold operation.
+    /// It can be used for animating and displaying progress directly.
+    /// </remarks>
     public abstract class HoldToConfirmContainer : Container
     {
-        public Action Action;
+        public const double DANGEROUS_HOLD_ACTIVATION_DELAY = 500;
 
         private const int fadeout_delay = 200;
 
+        /// <summary>
+        /// Whether the associated action is considered dangerous, warranting a longer hold.
+        /// </summary>
+        public bool IsDangerousAction { get; }
+
+        /// <summary>
+        /// The action to perform when a hold successfully completes.
+        /// </summary>
+        public Action Action;
+
         /// <summary>
         /// Whether currently in a fired state (and the confirm <see cref="Action"/> has been sent).
         /// </summary>
@@ -23,46 +43,61 @@ namespace osu.Game.Graphics.Containers
 
         private bool confirming;
 
+        /// <summary>
+        /// The current activation delay for this control.
+        /// </summary>
+        public IBindable<double> HoldActivationDelay => holdActivationDelay;
+
+        /// <summary>
+        /// The progress of any ongoing hold operation. 0 means no hold has started; 1 means a hold has been completed.
+        /// </summary>
+        public IBindable<double> Progress => progress;
+
         /// <summary>
         /// Whether the overlay should be allowed to return from a fired state.
         /// </summary>
         protected virtual bool AllowMultipleFires => false;
 
-        /// <summary>
-        /// Specify a custom activation delay, overriding the game-wide user setting.
-        /// </summary>
-        /// <remarks>
-        /// This should be used in special cases where we want to be extra sure the user knows what they are doing. An example is when changes would be lost.
-        /// </remarks>
-        protected virtual double? HoldActivationDelay => null;
+        private readonly Bindable<double> progress = new BindableDouble();
 
-        public Bindable<double> Progress = new BindableDouble();
+        private readonly Bindable<double> holdActivationDelay = new Bindable<double>();
 
-        private Bindable<double> holdActivationDelay;
+        [Resolved]
+        private OsuConfigManager config { get; set; }
 
-        [BackgroundDependencyLoader]
-        private void load(OsuConfigManager config)
+        protected HoldToConfirmContainer(bool isDangerousAction = false)
         {
-            holdActivationDelay = HoldActivationDelay != null
-                ? new Bindable<double>(HoldActivationDelay.Value)
-                : config.GetBindable<double>(OsuSetting.UIHoldActivationDelay);
+            IsDangerousAction = isDangerousAction;
         }
 
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            if (IsDangerousAction)
+                holdActivationDelay.Value = DANGEROUS_HOLD_ACTIVATION_DELAY;
+            else
+                config.BindWith(OsuSetting.UIHoldActivationDelay, holdActivationDelay);
+        }
+
+        /// <summary>
+        /// Begin a new confirmation. Should be called when the container is interacted with (ie. the user presses a key).
+        /// </summary>
+        /// <remarks>
+        /// Calling this method when already in the process of confirming has no effect.
+        /// </remarks>
         protected void BeginConfirm()
         {
             if (confirming || (!AllowMultipleFires && Fired)) return;
 
             confirming = true;
 
-            this.TransformBindableTo(Progress, 1, holdActivationDelay.Value * (1 - Progress.Value), Easing.Out).OnComplete(_ => Confirm());
-        }
-
-        protected virtual void Confirm()
-        {
-            Action?.Invoke();
-            Fired = true;
+            this.TransformBindableTo(progress, 1, holdActivationDelay.Value * (1 - progress.Value), Easing.Out).OnComplete(_ => Confirm());
         }
 
+        /// <summary>
+        /// Abort any ongoing confirmation. Should be called when the container's interaction is no longer valid (ie. the user releases a key).
+        /// </summary>
         protected void AbortConfirm()
         {
             if (!AllowMultipleFires && Fired) return;
@@ -71,9 +106,19 @@ namespace osu.Game.Graphics.Containers
             Fired = false;
 
             this
-                .TransformBindableTo(Progress, Progress.Value)
+                .TransformBindableTo(progress, progress.Value)
                 .Delay(200)
-                .TransformBindableTo(Progress, 0, fadeout_delay, Easing.InSine);
+                .TransformBindableTo(progress, 0, fadeout_delay, Easing.InSine);
+        }
+
+        /// <summary>
+        /// A method which is invoked when the confirmation sequence completes successfully.
+        /// By default, will fire the associated <see cref="Action"/>.
+        /// </summary>
+        protected virtual void Confirm()
+        {
+            Action?.Invoke();
+            Fired = true;
         }
     }
 }
diff --git a/osu.Game/Online/API/APIAccess.cs b/osu.Game/Online/API/APIAccess.cs
index 8c9741b98b..62ddd49881 100644
--- a/osu.Game/Online/API/APIAccess.cs
+++ b/osu.Game/Online/API/APIAccess.cs
@@ -458,7 +458,7 @@ namespace osu.Game.Online.API
         public GuestUser()
         {
             Username = @"Guest";
-            Id = 1;
+            Id = SYSTEM_USER_ID;
         }
     }
 
diff --git a/osu.Game/Online/Chat/StandAloneChatDisplay.cs b/osu.Game/Online/Chat/StandAloneChatDisplay.cs
index 6a7da52416..df210fcaf8 100644
--- a/osu.Game/Online/Chat/StandAloneChatDisplay.cs
+++ b/osu.Game/Online/Chat/StandAloneChatDisplay.cs
@@ -14,6 +14,7 @@ using osu.Game.Graphics.UserInterface;
 using osu.Game.Overlays.Chat;
 using osu.Game.Resources.Localisation.Web;
 using osuTK.Graphics;
+using osuTK.Input;
 
 namespace osu.Game.Online.Chat
 {
@@ -119,6 +120,20 @@ namespace osu.Game.Online.Chat
 
         public class ChatTextBox : FocusedTextBox
         {
+            protected override bool OnKeyDown(KeyDownEvent e)
+            {
+                // Chat text boxes are generally used in places where they retain focus, but shouldn't block interaction with other
+                // elements on the same screen.
+                switch (e.Key)
+                {
+                    case Key.Up:
+                    case Key.Down:
+                        return false;
+                }
+
+                return base.OnKeyDown(e);
+            }
+
             protected override void LoadComplete()
             {
                 base.LoadComplete();
diff --git a/osu.Game/Overlays/Chat/ChannelList/ChannelListItem.cs b/osu.Game/Overlays/Chat/ChannelList/ChannelListItem.cs
index 7c4a72559b..c5ac87f527 100644
--- a/osu.Game/Overlays/Chat/ChannelList/ChannelListItem.cs
+++ b/osu.Game/Overlays/Chat/ChannelList/ChannelListItem.cs
@@ -25,14 +25,14 @@ namespace osu.Game.Overlays.Chat.ChannelList
         public event Action<Channel>? OnRequestSelect;
         public event Action<Channel>? OnRequestLeave;
 
+        public readonly Channel Channel;
+
         public readonly BindableInt Mentions = new BindableInt();
 
         public readonly BindableBool Unread = new BindableBool();
 
         public readonly BindableBool SelectorActive = new BindableBool();
 
-        private readonly Channel channel;
-
         private Box hoverBox = null!;
         private Box selectBox = null!;
         private OsuSpriteText text = null!;
@@ -46,7 +46,7 @@ namespace osu.Game.Overlays.Chat.ChannelList
 
         public ChannelListItem(Channel channel)
         {
-            this.channel = channel;
+            Channel = channel;
         }
 
         [BackgroundDependencyLoader]
@@ -92,7 +92,7 @@ namespace osu.Game.Overlays.Chat.ChannelList
                                 {
                                     Anchor = Anchor.CentreLeft,
                                     Origin = Anchor.CentreLeft,
-                                    Text = channel.Name,
+                                    Text = Channel.Name,
                                     Font = OsuFont.Torus.With(size: 17, weight: FontWeight.SemiBold),
                                     Colour = colourProvider.Light3,
                                     Margin = new MarginPadding { Bottom = 2 },
@@ -111,7 +111,7 @@ namespace osu.Game.Overlays.Chat.ChannelList
                                     Anchor = Anchor.CentreLeft,
                                     Origin = Anchor.CentreLeft,
                                     Margin = new MarginPadding { Right = 3 },
-                                    Action = () => OnRequestLeave?.Invoke(channel),
+                                    Action = () => OnRequestLeave?.Invoke(Channel),
                                 }
                             }
                         },
@@ -119,20 +119,16 @@ namespace osu.Game.Overlays.Chat.ChannelList
                 },
             };
 
-            Action = () => OnRequestSelect?.Invoke(channel);
+            Action = () => OnRequestSelect?.Invoke(Channel);
         }
 
         protected override void LoadComplete()
         {
             base.LoadComplete();
 
-            selectedChannel.BindValueChanged(_ => updateSelectState(), true);
-            SelectorActive.BindValueChanged(_ => updateSelectState(), true);
-
-            Unread.BindValueChanged(change =>
-            {
-                text.FadeColour(change.NewValue ? colourProvider.Content1 : colourProvider.Light3, 300, Easing.OutQuint);
-            }, true);
+            selectedChannel.BindValueChanged(_ => updateState(), true);
+            SelectorActive.BindValueChanged(_ => updateState(), true);
+            Unread.BindValueChanged(_ => updateState(), true);
         }
 
         protected override bool OnHover(HoverEvent e)
@@ -151,10 +147,10 @@ namespace osu.Game.Overlays.Chat.ChannelList
 
         private Drawable createIcon()
         {
-            if (channel.Type != ChannelType.PM)
+            if (Channel.Type != ChannelType.PM)
                 return Drawable.Empty();
 
-            return new UpdateableAvatar(channel.Users.First(), isInteractive: false)
+            return new UpdateableAvatar(Channel.Users.First(), isInteractive: false)
             {
                 Size = new Vector2(20),
                 Margin = new MarginPadding { Right = 5 },
@@ -165,12 +161,19 @@ namespace osu.Game.Overlays.Chat.ChannelList
             };
         }
 
-        private void updateSelectState()
+        private void updateState()
         {
-            if (selectedChannel.Value == channel && !SelectorActive.Value)
+            bool selected = selectedChannel.Value == Channel && !SelectorActive.Value;
+
+            if (selected)
                 selectBox.FadeIn(300, Easing.OutQuint);
             else
                 selectBox.FadeOut(200, Easing.OutQuint);
+
+            if (Unread.Value || selected)
+                text.FadeColour(colourProvider.Content1, 300, Easing.OutQuint);
+            else
+                text.FadeColour(colourProvider.Light3, 200, Easing.OutQuint);
         }
     }
 }
diff --git a/osu.Game/Overlays/Chat/ChannelList/ChannelListSelector.cs b/osu.Game/Overlays/Chat/ChannelList/ChannelListSelector.cs
index 57ab7584b5..9cba93ffa5 100644
--- a/osu.Game/Overlays/Chat/ChannelList/ChannelListSelector.cs
+++ b/osu.Game/Overlays/Chat/ChannelList/ChannelListSelector.cs
@@ -21,6 +21,10 @@ namespace osu.Game.Overlays.Chat.ChannelList
 
         private Box hoverBox = null!;
         private Box selectBox = null!;
+        private OsuSpriteText text = null!;
+
+        [Resolved]
+        private OverlayColourProvider colourProvider { get; set; } = null!;
 
         [BackgroundDependencyLoader]
         private void load(OverlayColourProvider colourProvider)
@@ -46,11 +50,11 @@ namespace osu.Game.Overlays.Chat.ChannelList
                 {
                     RelativeSizeAxes = Axes.Both,
                     Padding = new MarginPadding { Left = 18, Right = 10 },
-                    Child = new OsuSpriteText
+                    Child = text = new OsuSpriteText
                     {
                         Anchor = Anchor.CentreLeft,
                         Origin = Anchor.CentreLeft,
-                        Text = "Add More Channels",
+                        Text = "Add more channels",
                         Font = OsuFont.Torus.With(size: 17, weight: FontWeight.SemiBold),
                         Colour = colourProvider.Light3,
                         Margin = new MarginPadding { Bottom = 2 },
@@ -68,9 +72,15 @@ namespace osu.Game.Overlays.Chat.ChannelList
             SelectorActive.BindValueChanged(selector =>
             {
                 if (selector.NewValue)
+                {
+                    text.FadeColour(colourProvider.Content1, 300, Easing.OutQuint);
                     selectBox.FadeIn(300, Easing.OutQuint);
+                }
                 else
+                {
+                    text.FadeColour(colourProvider.Light3, 200, Easing.OutQuint);
                     selectBox.FadeOut(200, Easing.OutQuint);
+                }
             }, true);
 
             Action = () => SelectorActive.Value = true;
diff --git a/osu.Game/Overlays/Chat/ChatOverlayTopBar.cs b/osu.Game/Overlays/Chat/ChatOverlayTopBar.cs
new file mode 100644
index 0000000000..3a8cd1fb91
--- /dev/null
+++ b/osu.Game/Overlays/Chat/ChatOverlayTopBar.cs
@@ -0,0 +1,83 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+#nullable enable
+
+using osu.Framework.Allocation;
+using osu.Framework.Extensions.Color4Extensions;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Graphics.Sprites;
+using osu.Framework.Graphics.Textures;
+using osu.Framework.Input.Events;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Sprites;
+using osuTK;
+using osuTK.Graphics;
+
+namespace osu.Game.Overlays.Chat
+{
+    public class ChatOverlayTopBar : Container
+    {
+        private Box background = null!;
+
+        private Color4 backgroundColour;
+
+        [BackgroundDependencyLoader]
+        private void load(OverlayColourProvider colourProvider, TextureStore textures)
+        {
+            Children = new Drawable[]
+            {
+                background = new Box
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Colour = backgroundColour = colourProvider.Background3,
+                },
+                new GridContainer
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    ColumnDimensions = new[]
+                    {
+                        new Dimension(GridSizeMode.Absolute, 50),
+                        new Dimension(),
+                    },
+                    Content = new[]
+                    {
+                        new Drawable[]
+                        {
+                            new Sprite
+                            {
+                                Anchor = Anchor.Centre,
+                                Origin = Anchor.Centre,
+                                Texture = textures.Get("Icons/Hexacons/messaging"),
+                                Size = new Vector2(18),
+                            },
+                            // Placeholder text
+                            new OsuSpriteText
+                            {
+                                Anchor = Anchor.CentreLeft,
+                                Origin = Anchor.CentreLeft,
+                                Text = "osu!chat",
+                                Font = OsuFont.Torus.With(size: 16, weight: FontWeight.SemiBold),
+                                Margin = new MarginPadding { Bottom = 2f },
+                            },
+                        },
+                    },
+                },
+            };
+        }
+
+        protected override bool OnHover(HoverEvent e)
+        {
+            background.FadeColour(backgroundColour.Lighten(0.1f), 300, Easing.OutQuint);
+            return base.OnHover(e);
+        }
+
+        protected override void OnHoverLost(HoverLostEvent e)
+        {
+            background.FadeColour(backgroundColour, 300, Easing.OutQuint);
+            base.OnHoverLost(e);
+        }
+    }
+}
diff --git a/osu.Game/Overlays/Chat/ChatTextBar.cs b/osu.Game/Overlays/Chat/ChatTextBar.cs
index ef20149dac..0fa3613d38 100644
--- a/osu.Game/Overlays/Chat/ChatTextBar.cs
+++ b/osu.Game/Overlays/Chat/ChatTextBar.cs
@@ -11,7 +11,8 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.UserInterface;
-using osu.Game.Graphics.Containers;
+using osu.Game.Graphics;
+using osu.Game.Graphics.Sprites;
 using osu.Game.Online.Chat;
 using osuTK;
 
@@ -25,14 +26,19 @@ namespace osu.Game.Overlays.Chat
 
         public event Action<string>? OnSearchTermsChanged;
 
+        public void TextBoxTakeFocus() => chatTextBox.TakeFocus();
+
+        public void TextBoxKillFocus() => chatTextBox.KillFocus();
+
         [Resolved]
         private Bindable<Channel> currentChannel { get; set; } = null!;
 
-        private OsuTextFlowContainer chattingTextContainer = null!;
+        private Container chattingTextContainer = null!;
+        private OsuSpriteText chattingText = null!;
         private Container searchIconContainer = null!;
         private ChatTextBox chatTextBox = null!;
 
-        private const float chatting_text_width = 180;
+        private const float chatting_text_width = 240;
         private const float search_icon_width = 40;
 
         [BackgroundDependencyLoader]
@@ -61,16 +67,20 @@ namespace osu.Game.Overlays.Chat
                     {
                         new Drawable[]
                         {
-                            chattingTextContainer = new OsuTextFlowContainer(t => t.Font = t.Font.With(size: 20))
+                            chattingTextContainer = new Container
                             {
-                                Masking = true,
-                                Width = chatting_text_width,
-                                Padding = new MarginPadding { Left = 10 },
                                 RelativeSizeAxes = Axes.Y,
-                                TextAnchor = Anchor.CentreRight,
-                                Anchor = Anchor.CentreLeft,
-                                Origin = Anchor.CentreLeft,
-                                Colour = colourProvider.Background1,
+                                Width = chatting_text_width,
+                                Masking = true,
+                                Padding = new MarginPadding { Right = 5 },
+                                Child = chattingText = new OsuSpriteText
+                                {
+                                    Font = OsuFont.Torus.With(size: 20),
+                                    Colour = colourProvider.Background1,
+                                    Anchor = Anchor.CentreRight,
+                                    Origin = Anchor.CentreRight,
+                                    Truncate = true,
+                                },
                             },
                             searchIconContainer = new Container
                             {
@@ -131,15 +141,15 @@ namespace osu.Game.Overlays.Chat
                 switch (newChannel?.Type)
                 {
                     case ChannelType.Public:
-                        chattingTextContainer.Text = $"chatting in {newChannel.Name}";
+                        chattingText.Text = $"chatting in {newChannel.Name}";
                         break;
 
                     case ChannelType.PM:
-                        chattingTextContainer.Text = $"chatting with {newChannel.Name}";
+                        chattingText.Text = $"chatting with {newChannel.Name}";
                         break;
 
                     default:
-                        chattingTextContainer.Text = string.Empty;
+                        chattingText.Text = string.Empty;
                         break;
                 }
             }, true);
diff --git a/osu.Game/Overlays/Chat/Listing/ChannelListingItem.cs b/osu.Game/Overlays/Chat/Listing/ChannelListingItem.cs
index 526cbcda87..1f0cbae7e2 100644
--- a/osu.Game/Overlays/Chat/Listing/ChannelListingItem.cs
+++ b/osu.Game/Overlays/Chat/Listing/ChannelListingItem.cs
@@ -25,11 +25,11 @@ namespace osu.Game.Overlays.Chat.Listing
         public event Action<Channel>? OnRequestJoin;
         public event Action<Channel>? OnRequestLeave;
 
-        public bool FilteringActive { get; set; }
-        public IEnumerable<string> FilterTerms => new[] { channel.Name, channel.Topic ?? string.Empty };
-        public bool MatchingFilter { set => this.FadeTo(value ? 1f : 0f, 100); }
+        public readonly Channel Channel;
 
-        private readonly Channel channel;
+        public bool FilteringActive { get; set; }
+        public IEnumerable<string> FilterTerms => new[] { Channel.Name, Channel.Topic ?? string.Empty };
+        public bool MatchingFilter { set => this.FadeTo(value ? 1f : 0f, 100); }
 
         private Box hoverBox = null!;
         private SpriteIcon checkbox = null!;
@@ -47,7 +47,7 @@ namespace osu.Game.Overlays.Chat.Listing
 
         public ChannelListingItem(Channel channel)
         {
-            this.channel = channel;
+            Channel = channel;
         }
 
         [BackgroundDependencyLoader]
@@ -94,7 +94,7 @@ namespace osu.Game.Overlays.Chat.Listing
                             {
                                 Anchor = Anchor.CentreLeft,
                                 Origin = Anchor.CentreLeft,
-                                Text = channel.Name,
+                                Text = Channel.Name,
                                 Font = OsuFont.Torus.With(size: text_size, weight: FontWeight.SemiBold),
                                 Margin = new MarginPadding { Bottom = 2 },
                             },
@@ -102,7 +102,7 @@ namespace osu.Game.Overlays.Chat.Listing
                             {
                                 Anchor = Anchor.CentreLeft,
                                 Origin = Anchor.CentreLeft,
-                                Text = channel.Topic,
+                                Text = Channel.Topic,
                                 Font = OsuFont.Torus.With(size: text_size),
                                 Margin = new MarginPadding { Bottom = 2 },
                             },
@@ -134,7 +134,7 @@ namespace osu.Game.Overlays.Chat.Listing
         {
             base.LoadComplete();
 
-            channelJoined = channel.Joined.GetBoundCopy();
+            channelJoined = Channel.Joined.GetBoundCopy();
             channelJoined.BindValueChanged(change =>
             {
                 const double duration = 500;
@@ -155,7 +155,7 @@ namespace osu.Game.Overlays.Chat.Listing
                 }
             }, true);
 
-            Action = () => (channelJoined.Value ? OnRequestLeave : OnRequestJoin)?.Invoke(channel);
+            Action = () => (channelJoined.Value ? OnRequestLeave : OnRequestJoin)?.Invoke(Channel);
         }
 
         protected override bool OnHover(HoverEvent e)
diff --git a/osu.Game/Overlays/ChatOverlayV2.cs b/osu.Game/Overlays/ChatOverlayV2.cs
new file mode 100644
index 0000000000..4c7fa0f802
--- /dev/null
+++ b/osu.Game/Overlays/ChatOverlayV2.cs
@@ -0,0 +1,314 @@
+// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
+// See the LICENCE file in the repository root for full licence text.
+
+#nullable enable
+
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.Specialized;
+using System.Diagnostics;
+using System.Linq;
+using osu.Framework.Allocation;
+using osu.Framework.Bindables;
+using osu.Framework.Graphics;
+using osu.Framework.Graphics.Containers;
+using osu.Framework.Graphics.Shapes;
+using osu.Framework.Input.Events;
+using osu.Framework.Localisation;
+using osu.Game.Configuration;
+using osu.Game.Graphics.Containers;
+using osu.Game.Graphics.UserInterface;
+using osu.Game.Localisation;
+using osu.Game.Online.Chat;
+using osu.Game.Overlays.Chat;
+using osu.Game.Overlays.Chat.ChannelList;
+using osu.Game.Overlays.Chat.Listing;
+
+namespace osu.Game.Overlays
+{
+    public class ChatOverlayV2 : OsuFocusedOverlayContainer, INamedOverlayComponent
+    {
+        public string IconTexture => "Icons/Hexacons/messaging";
+        public LocalisableString Title => ChatStrings.HeaderTitle;
+        public LocalisableString Description => ChatStrings.HeaderDescription;
+
+        private ChatOverlayTopBar topBar = null!;
+        private ChannelList channelList = null!;
+        private LoadingLayer loading = null!;
+        private ChannelListing channelListing = null!;
+        private ChatTextBar textBar = null!;
+        private Container<DrawableChannel> currentChannelContainer = null!;
+
+        private readonly BindableFloat chatHeight = new BindableFloat();
+
+        private bool isDraggingTopBar;
+        private float dragStartChatHeight;
+
+        private const int transition_length = 500;
+        private const float default_chat_height = 0.4f;
+        private const float top_bar_height = 40;
+        private const float side_bar_width = 190;
+        private const float chat_bar_height = 60;
+
+        private readonly BindableBool selectorActive = new BindableBool();
+
+        [Resolved]
+        private OsuConfigManager config { get; set; } = null!;
+
+        [Resolved]
+        private ChannelManager channelManager { get; set; } = null!;
+
+        [Cached]
+        private readonly OverlayColourProvider colourProvider = new OverlayColourProvider(OverlayColourScheme.Pink);
+
+        [Cached]
+        private readonly Bindable<Channel> currentChannel = new Bindable<Channel>();
+
+        public ChatOverlayV2()
+        {
+            Height = default_chat_height;
+
+            Masking = true;
+
+            const float corner_radius = 7f;
+
+            CornerRadius = corner_radius;
+
+            // Hack to hide the bottom edge corner radius off-screen.
+            Margin = new MarginPadding { Bottom = -corner_radius };
+            Padding = new MarginPadding { Bottom = corner_radius };
+
+            Anchor = Anchor.BottomCentre;
+            Origin = Anchor.BottomCentre;
+        }
+
+        [BackgroundDependencyLoader]
+        private void load()
+        {
+            // Required for the pop in/out animation
+            RelativePositionAxes = Axes.Both;
+
+            Children = new Drawable[]
+            {
+                topBar = new ChatOverlayTopBar
+                {
+                    RelativeSizeAxes = Axes.X,
+                    Height = top_bar_height,
+                },
+                channelList = new ChannelList
+                {
+                    RelativeSizeAxes = Axes.Y,
+                    Width = side_bar_width,
+                    Padding = new MarginPadding { Top = top_bar_height },
+                    SelectorActive = { BindTarget = selectorActive },
+                },
+                new Container
+                {
+                    RelativeSizeAxes = Axes.Both,
+                    Anchor = Anchor.TopRight,
+                    Origin = Anchor.TopRight,
+                    Padding = new MarginPadding
+                    {
+                        Top = top_bar_height,
+                        Left = side_bar_width,
+                        Bottom = chat_bar_height,
+                    },
+                    Children = new Drawable[]
+                    {
+                        new Box
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                            Colour = colourProvider.Background4,
+                        },
+                        currentChannelContainer = new Container<DrawableChannel>
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                        },
+                        loading = new LoadingLayer(true),
+                        channelListing = new ChannelListing
+                        {
+                            RelativeSizeAxes = Axes.Both,
+                        },
+                    },
+                },
+                textBar = new ChatTextBar
+                {
+                    RelativeSizeAxes = Axes.X,
+                    Anchor = Anchor.BottomRight,
+                    Origin = Anchor.BottomRight,
+                    Padding = new MarginPadding { Left = side_bar_width },
+                    ShowSearch = { BindTarget = selectorActive },
+                },
+            };
+        }
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            loading.Show();
+
+            config.BindWith(OsuSetting.ChatDisplayHeight, chatHeight);
+
+            chatHeight.BindValueChanged(height => { Height = height.NewValue; }, true);
+
+            currentChannel.BindTo(channelManager.CurrentChannel);
+            channelManager.CurrentChannel.BindValueChanged(currentChannelChanged, true);
+            channelManager.JoinedChannels.BindCollectionChanged(joinedChannelsChanged, true);
+            channelManager.AvailableChannels.BindCollectionChanged(availableChannelsChanged, true);
+
+            channelList.OnRequestSelect += channel =>
+            {
+                // Manually selecting a channel should dismiss the selector
+                selectorActive.Value = false;
+                channelManager.CurrentChannel.Value = channel;
+            };
+            channelList.OnRequestLeave += channel => channelManager.LeaveChannel(channel);
+
+            channelListing.OnRequestJoin += channel => channelManager.JoinChannel(channel);
+            channelListing.OnRequestLeave += channel => channelManager.LeaveChannel(channel);
+
+            textBar.OnSearchTermsChanged += searchTerms => channelListing.SearchTerm = searchTerms;
+            textBar.OnChatMessageCommitted += handleChatMessage;
+
+            selectorActive.BindValueChanged(v => channelListing.State.Value = v.NewValue ? Visibility.Visible : Visibility.Hidden, true);
+        }
+
+        /// <summary>
+        /// Highlights a certain message in the specified channel.
+        /// </summary>
+        /// <param name="message">The message to highlight.</param>
+        /// <param name="channel">The channel containing the message.</param>
+        public void HighlightMessage(Message message, Channel channel)
+        {
+            Debug.Assert(channel.Id == message.ChannelId);
+
+            if (currentChannel.Value?.Id != channel.Id)
+            {
+                if (!channel.Joined.Value)
+                    channel = channelManager.JoinChannel(channel);
+
+                channelManager.CurrentChannel.Value = channel;
+            }
+
+            selectorActive.Value = false;
+
+            channel.HighlightedMessage.Value = message;
+
+            Show();
+        }
+
+        protected override bool OnDragStart(DragStartEvent e)
+        {
+            isDraggingTopBar = topBar.IsHovered;
+
+            if (!isDraggingTopBar)
+                return base.OnDragStart(e);
+
+            dragStartChatHeight = chatHeight.Value;
+            return true;
+        }
+
+        protected override void OnDrag(DragEvent e)
+        {
+            if (!isDraggingTopBar)
+                return;
+
+            float targetChatHeight = dragStartChatHeight - (e.MousePosition.Y - e.MouseDownPosition.Y) / Parent.DrawSize.Y;
+            chatHeight.Value = targetChatHeight;
+        }
+
+        protected override void OnDragEnd(DragEndEvent e)
+        {
+            isDraggingTopBar = false;
+            base.OnDragEnd(e);
+        }
+
+        protected override void PopIn()
+        {
+            base.PopIn();
+
+            this.MoveToY(0, transition_length, Easing.OutQuint);
+            this.FadeIn(transition_length, Easing.OutQuint);
+        }
+
+        protected override void PopOut()
+        {
+            base.PopOut();
+
+            this.MoveToY(Height, transition_length, Easing.InSine);
+            this.FadeOut(transition_length, Easing.InSine);
+
+            textBar.TextBoxKillFocus();
+        }
+
+        protected override void OnFocus(FocusEvent e)
+        {
+            textBar.TextBoxTakeFocus();
+            base.OnFocus(e);
+        }
+
+        private void currentChannelChanged(ValueChangedEvent<Channel> channel)
+        {
+            Channel? newChannel = channel.NewValue;
+
+            loading.Show();
+
+            // Channel is null when leaving the currently selected channel
+            if (newChannel == null)
+            {
+                // Find another channel to switch to
+                newChannel = channelManager.JoinedChannels.FirstOrDefault(c => c != channel.OldValue);
+
+                if (newChannel == null)
+                    selectorActive.Value = true;
+                else
+                    currentChannel.Value = newChannel;
+
+                return;
+            }
+
+            LoadComponentAsync(new DrawableChannel(newChannel), loaded =>
+            {
+                currentChannelContainer.Clear();
+                currentChannelContainer.Add(loaded);
+                loading.Hide();
+            });
+        }
+
+        private void joinedChannelsChanged(object sender, NotifyCollectionChangedEventArgs args)
+        {
+            switch (args.Action)
+            {
+                case NotifyCollectionChangedAction.Add:
+                    IEnumerable<Channel> joinedChannels = filterChannels(args.NewItems);
+                    foreach (var channel in joinedChannels)
+                        channelList.AddChannel(channel);
+                    break;
+
+                case NotifyCollectionChangedAction.Remove:
+                    IEnumerable<Channel> leftChannels = filterChannels(args.OldItems);
+                    foreach (var channel in leftChannels)
+                        channelList.RemoveChannel(channel);
+                    break;
+            }
+        }
+
+        private void availableChannelsChanged(object sender, NotifyCollectionChangedEventArgs args)
+            => channelListing.UpdateAvailableChannels(channelManager.AvailableChannels);
+
+        private IEnumerable<Channel> filterChannels(IList channels)
+            => channels.Cast<Channel>().Where(c => c.Type == ChannelType.Public || c.Type == ChannelType.PM);
+
+        private void handleChatMessage(string message)
+        {
+            if (string.IsNullOrWhiteSpace(message))
+                return;
+
+            if (message[0] == '/')
+                channelManager.PostCommand(message.Substring(1));
+            else
+                channelManager.PostMessage(message);
+        }
+    }
+}
diff --git a/osu.Game/Overlays/Dialog/PopupDialogDangerousButton.cs b/osu.Game/Overlays/Dialog/PopupDialogDangerousButton.cs
index adc627e15b..6239c5e409 100644
--- a/osu.Game/Overlays/Dialog/PopupDialogDangerousButton.cs
+++ b/osu.Game/Overlays/Dialog/PopupDialogDangerousButton.cs
@@ -42,7 +42,10 @@ namespace osu.Game.Overlays.Dialog
 
         private class DangerousConfirmContainer : HoldToConfirmContainer
         {
-            protected override double? HoldActivationDelay => 500;
+            public DangerousConfirmContainer()
+                : base(isDangerousAction: true)
+            {
+            }
 
             protected override bool OnMouseDown(MouseDownEvent e)
             {
diff --git a/osu.Game/Overlays/Mods/ModSelectScreen.cs b/osu.Game/Overlays/Mods/ModSelectScreen.cs
index 8060bca65f..a1b4d7d8a0 100644
--- a/osu.Game/Overlays/Mods/ModSelectScreen.cs
+++ b/osu.Game/Overlays/Mods/ModSelectScreen.cs
@@ -18,6 +18,7 @@ using osu.Game.Configuration;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.UserInterface;
+using osu.Game.Input.Bindings;
 using osu.Game.Rulesets.Mods;
 using osuTK;
 using osuTK.Input;
@@ -217,7 +218,7 @@ namespace osu.Game.Overlays.Mods
             foreach (var mod in SelectedMods.Value)
             {
                 anyCustomisableMod |= mod.GetSettingsSourceProperties().Any();
-                anyModWithRequiredCustomisationAdded |= !valueChangedEvent.OldValue.Contains(mod) && mod.RequiresConfiguration;
+                anyModWithRequiredCustomisationAdded |= valueChangedEvent.OldValue.All(m => m.GetType() != mod.GetType()) && mod.RequiresConfiguration;
             }
 
             if (anyCustomisableMod)
@@ -315,6 +316,17 @@ namespace osu.Game.Overlays.Mods
             }
         }
 
+        public override bool OnPressed(KeyBindingPressEvent<GlobalAction> e)
+        {
+            if (e.Action == GlobalAction.Back && customisationVisible.Value)
+            {
+                customisationVisible.Value = false;
+                return true;
+            }
+
+            return base.OnPressed(e);
+        }
+
         internal class ColumnScrollContainer : OsuScrollContainer<ColumnFlowContainer>
         {
             public ColumnScrollContainer()
@@ -452,6 +464,8 @@ namespace osu.Game.Overlays.Mods
 
             public Action? OnClicked { get; set; }
 
+            public override bool HandlePositionalInput => base.HandlePositionalInput && HandleMouse.Value;
+
             protected override bool Handle(UIEvent e)
             {
                 if (!HandleMouse.Value)
diff --git a/osu.Game/Rulesets/Edit/ExpandingToolboxContainer.cs b/osu.Game/Rulesets/Edit/ExpandingToolboxContainer.cs
index e807dbd482..c6cc09a16c 100644
--- a/osu.Game/Rulesets/Edit/ExpandingToolboxContainer.cs
+++ b/osu.Game/Rulesets/Edit/ExpandingToolboxContainer.cs
@@ -1,7 +1,6 @@
 // Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
-using System.Linq;
 using osu.Framework.Graphics;
 using osu.Framework.Input.Events;
 using osu.Game.Graphics.Containers;
@@ -25,7 +24,7 @@ namespace osu.Game.Rulesets.Edit
 
         public override bool ReceivePositionalInputAt(Vector2 screenSpacePos) => base.ReceivePositionalInputAt(screenSpacePos) && anyToolboxHovered(screenSpacePos);
 
-        private bool anyToolboxHovered(Vector2 screenSpacePos) => FillFlow.Children.Any(d => d.ScreenSpaceDrawQuad.Contains(screenSpacePos));
+        private bool anyToolboxHovered(Vector2 screenSpacePos) => FillFlow.ScreenSpaceDrawQuad.Contains(screenSpacePos);
 
         protected override bool OnMouseDown(MouseDownEvent e) => true;
 
diff --git a/osu.Game/Screens/Edit/Compose/Components/DragBox.cs b/osu.Game/Screens/Edit/Compose/Components/DragBox.cs
index eaee2cd1e2..ecbac82db0 100644
--- a/osu.Game/Screens/Edit/Compose/Components/DragBox.cs
+++ b/osu.Game/Screens/Edit/Compose/Components/DragBox.cs
@@ -9,7 +9,8 @@ using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Primitives;
 using osu.Framework.Graphics.Shapes;
 using osu.Framework.Input.Events;
-using osuTK.Graphics;
+using osu.Framework.Layout;
+using osuTK;
 
 namespace osu.Game.Screens.Edit.Compose.Components
 {
@@ -41,17 +42,7 @@ namespace osu.Game.Screens.Edit.Compose.Components
             InternalChild = Box = CreateBox();
         }
 
-        protected virtual Drawable CreateBox() => new Container
-        {
-            Masking = true,
-            BorderColour = Color4.White,
-            BorderThickness = SelectionBox.BORDER_RADIUS,
-            Child = new Box
-            {
-                RelativeSizeAxes = Axes.Both,
-                Alpha = 0.1f
-            }
-        };
+        protected virtual Drawable CreateBox() => new BoxWithBorders();
 
         private RectangleF? dragRectangle;
 
@@ -111,5 +102,75 @@ namespace osu.Game.Screens.Edit.Compose.Components
         public override void Show() => State = Visibility.Visible;
 
         public event Action<Visibility> StateChanged;
+
+        public class BoxWithBorders : CompositeDrawable
+        {
+            private readonly LayoutValue cache = new LayoutValue(Invalidation.RequiredParentSizeToFit);
+
+            public BoxWithBorders()
+            {
+                AddLayout(cache);
+            }
+
+            protected override void Update()
+            {
+                base.Update();
+
+                if (!cache.IsValid)
+                {
+                    createContent();
+                    cache.Validate();
+                }
+            }
+
+            private void createContent()
+            {
+                if (DrawSize == Vector2.Zero)
+                {
+                    ClearInternal();
+                    return;
+                }
+
+                // Make lines the same width independent of display resolution.
+                float lineThickness = DrawWidth > 0
+                    ? DrawWidth / ScreenSpaceDrawQuad.Width * 2
+                    : DrawHeight / ScreenSpaceDrawQuad.Height * 2;
+
+                Padding = new MarginPadding(-lineThickness / 2);
+
+                InternalChildren = new Drawable[]
+                {
+                    new Box
+                    {
+                        RelativeSizeAxes = Axes.X,
+                        Height = lineThickness,
+                    },
+                    new Box
+                    {
+                        RelativeSizeAxes = Axes.X,
+                        Height = lineThickness,
+                        Anchor = Anchor.BottomRight,
+                        Origin = Anchor.BottomRight,
+                    },
+                    new Box
+                    {
+                        RelativeSizeAxes = Axes.Y,
+                        Width = lineThickness,
+                    },
+                    new Box
+                    {
+                        RelativeSizeAxes = Axes.Y,
+                        Width = lineThickness,
+                        Anchor = Anchor.BottomRight,
+                        Origin = Anchor.BottomRight,
+                    },
+                    new Box
+                    {
+                        RelativeSizeAxes = Axes.Both,
+                        Alpha = 0.1f
+                    }
+                };
+            }
+        }
     }
 }
diff --git a/osu.Game/Screens/OnlinePlay/DrawableRoomPlaylist.cs b/osu.Game/Screens/OnlinePlay/DrawableRoomPlaylist.cs
index 57bb4253cb..2a72fc6eb1 100644
--- a/osu.Game/Screens/OnlinePlay/DrawableRoomPlaylist.cs
+++ b/osu.Game/Screens/OnlinePlay/DrawableRoomPlaylist.cs
@@ -6,7 +6,10 @@ using System.Linq;
 using osu.Framework.Bindables;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
+using osu.Framework.Input.Bindings;
+using osu.Framework.Input.Events;
 using osu.Game.Graphics.Containers;
+using osu.Game.Input.Bindings;
 using osu.Game.Online.Rooms;
 using osuTK;
 
@@ -15,7 +18,7 @@ namespace osu.Game.Screens.OnlinePlay
     /// <summary>
     /// A scrollable list which displays the <see cref="PlaylistItem"/>s in a <see cref="Room"/>.
     /// </summary>
-    public class DrawableRoomPlaylist : OsuRearrangeableListContainer<PlaylistItem>
+    public class DrawableRoomPlaylist : OsuRearrangeableListContainer<PlaylistItem>, IKeyBindingHandler<GlobalAction>
     {
         /// <summary>
         /// The currently-selected item. Selection is visually represented with a border.
@@ -169,5 +172,78 @@ namespace osu.Game.Screens.OnlinePlay
         });
 
         protected virtual DrawableRoomPlaylistItem CreateDrawablePlaylistItem(PlaylistItem item) => new DrawableRoomPlaylistItem(item);
+
+        protected override void LoadComplete()
+        {
+            base.LoadComplete();
+
+            // schedules added as the properties may change value while the drawable items haven't been created yet.
+            SelectedItem.BindValueChanged(_ => Scheduler.AddOnce(scrollToSelection));
+            Items.BindCollectionChanged((_, __) => Scheduler.AddOnce(scrollToSelection), true);
+        }
+
+        private void scrollToSelection()
+        {
+            // SelectedItem and ItemMap/drawable items are managed separately,
+            // so if the item can't be unmapped to a drawable, don't try to scroll to it.
+            // best effort is made to not drop any updates, by subscribing to both sources.
+            if (SelectedItem.Value == null || !ItemMap.TryGetValue(SelectedItem.Value, out var drawableItem))
+                return;
+
+            // ScrollIntoView does not handle non-loaded items appropriately, delay scroll until the item finishes loading.
+            // see: https://github.com/ppy/osu-framework/issues/5158
+            if (!drawableItem.IsLoaded)
+                drawableItem.OnLoadComplete += _ => ScrollContainer.ScrollIntoView(drawableItem);
+            else
+                ScrollContainer.ScrollIntoView(drawableItem);
+        }
+
+        #region Key selection logic (shared with BeatmapCarousel and RoomsContainer)
+
+        public bool OnPressed(KeyBindingPressEvent<GlobalAction> e)
+        {
+            switch (e.Action)
+            {
+                case GlobalAction.SelectNext:
+                    selectNext(1);
+                    return true;
+
+                case GlobalAction.SelectPrevious:
+                    selectNext(-1);
+                    return true;
+            }
+
+            return false;
+        }
+
+        public void OnReleased(KeyBindingReleaseEvent<GlobalAction> e)
+        {
+        }
+
+        private void selectNext(int direction)
+        {
+            if (!AllowSelection)
+                return;
+
+            var visibleItems = ListContainer.AsEnumerable().Where(r => r.IsPresent);
+
+            PlaylistItem item;
+
+            if (SelectedItem.Value == null)
+                item = visibleItems.FirstOrDefault()?.Model;
+            else
+            {
+                if (direction < 0)
+                    visibleItems = visibleItems.Reverse();
+
+                item = visibleItems.SkipWhile(r => r.Model != SelectedItem.Value).Skip(1).FirstOrDefault()?.Model;
+            }
+
+            // we already have a valid selection only change selection if we still have a room to switch to.
+            if (item != null)
+                SelectedItem.Value = item;
+        }
+
+        #endregion
     }
 }
diff --git a/osu.Game/Screens/OnlinePlay/Lounge/Components/RoomsContainer.cs b/osu.Game/Screens/OnlinePlay/Lounge/Components/RoomsContainer.cs
index 175cd2c44e..74e4225f11 100644
--- a/osu.Game/Screens/OnlinePlay/Lounge/Components/RoomsContainer.cs
+++ b/osu.Game/Screens/OnlinePlay/Lounge/Components/RoomsContainer.cs
@@ -139,7 +139,7 @@ namespace osu.Game.Screens.OnlinePlay.Lounge.Components
             return base.OnClick(e);
         }
 
-        #region Key selection logic (shared with BeatmapCarousel)
+        #region Key selection logic (shared with BeatmapCarousel and DrawableRoomPlaylist)
 
         public bool OnPressed(KeyBindingPressEvent<GlobalAction> e)
         {
diff --git a/osu.Game/Screens/Play/HUD/HoldForMenuButton.cs b/osu.Game/Screens/Play/HUD/HoldForMenuButton.cs
index 3da63ec2cc..2ba76d0896 100644
--- a/osu.Game/Screens/Play/HUD/HoldForMenuButton.cs
+++ b/osu.Game/Screens/Play/HUD/HoldForMenuButton.cs
@@ -12,13 +12,14 @@ using osu.Framework.Graphics.Sprites;
 using osu.Framework.Graphics.UserInterface;
 using osu.Framework.Input.Bindings;
 using osu.Framework.Input.Events;
+using osu.Framework.Threading;
 using osu.Framework.Utils;
-using osu.Game.Configuration;
 using osu.Game.Graphics;
 using osu.Game.Graphics.Containers;
 using osu.Game.Graphics.Sprites;
 using osu.Game.Input.Bindings;
 using osuTK;
+using osuTK.Graphics;
 
 namespace osu.Game.Screens.Play.HUD
 {
@@ -28,20 +29,22 @@ namespace osu.Game.Screens.Play.HUD
 
         public readonly Bindable<bool> IsPaused = new Bindable<bool>();
 
-        private readonly Button button;
+        private HoldButton button;
 
-        public Action Action
-        {
-            set => button.Action = value;
-        }
+        public Action Action { get; set; }
 
-        private readonly OsuSpriteText text;
+        private OsuSpriteText text;
 
         public HoldForMenuButton()
         {
             Direction = FillDirection.Horizontal;
             Spacing = new Vector2(20, 0);
             Margin = new MarginPadding(10);
+        }
+
+        [BackgroundDependencyLoader(true)]
+        private void load(Player player)
+        {
             Children = new Drawable[]
             {
                 text = new OsuSpriteText
@@ -50,25 +53,20 @@ namespace osu.Game.Screens.Play.HUD
                     Anchor = Anchor.CentreLeft,
                     Origin = Anchor.CentreLeft
                 },
-                button = new Button
+                button = new HoldButton(player?.Configuration.AllowRestart == false)
                 {
                     HoverGained = () => text.FadeIn(500, Easing.OutQuint),
                     HoverLost = () => text.FadeOut(500, Easing.OutQuint),
-                    IsPaused = { BindTarget = IsPaused }
+                    IsPaused = { BindTarget = IsPaused },
+                    Action = () => Action(),
                 }
             };
             AutoSizeAxes = Axes.Both;
         }
 
-        [Resolved]
-        private OsuConfigManager config { get; set; }
-
-        private Bindable<double> activationDelay;
-
         protected override void LoadComplete()
         {
-            activationDelay = config.GetBindable<double>(OsuSetting.UIHoldActivationDelay);
-            activationDelay.BindValueChanged(v =>
+            button.HoldActivationDelay.BindValueChanged(v =>
             {
                 text.Text = v.NewValue > 0
                     ? "hold for menu"
@@ -102,7 +100,7 @@ namespace osu.Game.Screens.Play.HUD
             }
         }
 
-        private class Button : HoldToConfirmContainer, IKeyBindingHandler<GlobalAction>
+        private class HoldButton : HoldToConfirmContainer, IKeyBindingHandler<GlobalAction>
         {
             private SpriteIcon icon;
             private CircularProgress circularProgress;
@@ -115,6 +113,16 @@ namespace osu.Game.Screens.Play.HUD
             public Action HoverGained;
             public Action HoverLost;
 
+            private const double shake_duration = 20;
+
+            private bool pendingAnimation;
+            private ScheduledDelegate shakeOperation;
+
+            public HoldButton(bool isDangerousAction)
+                : base(isDangerousAction)
+            {
+            }
+
             [BackgroundDependencyLoader]
             private void load(OsuColour colours)
             {
@@ -161,11 +169,38 @@ namespace osu.Game.Screens.Play.HUD
 
             private void bind()
             {
-                circularProgress.Current.BindTo(Progress);
-                Progress.ValueChanged += progress => icon.Scale = new Vector2(1 + (float)progress.NewValue * 0.2f);
+                ((IBindable<double>)circularProgress.Current).BindTo(Progress);
+                Progress.ValueChanged += progress =>
+                {
+                    icon.Scale = new Vector2(1 + (float)progress.NewValue * 0.2f);
+
+                    if (IsDangerousAction)
+                    {
+                        Colour = Interpolation.ValueAt(progress.NewValue, Color4.White, Color4.Red, 0, 1, Easing.OutQuint);
+
+                        if (progress.NewValue > 0 && progress.NewValue < 1)
+                        {
+                            shakeOperation ??= Scheduler.AddDelayed(shake, shake_duration, true);
+                        }
+                        else
+                        {
+                            Child.MoveTo(Vector2.Zero, shake_duration * 2, Easing.OutQuint);
+                            shakeOperation?.Cancel();
+                            shakeOperation = null;
+                        }
+                    }
+                };
             }
 
-            private bool pendingAnimation;
+            private void shake()
+            {
+                const float shake_magnitude = 8;
+
+                Child.MoveTo(new Vector2(
+                    RNG.NextSingle(-1, 1) * (float)Progress.Value * shake_magnitude,
+                    RNG.NextSingle(-1, 1) * (float)Progress.Value * shake_magnitude
+                ), shake_duration);
+            }
 
             protected override void Confirm()
             {