diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7e0494b0..a0903f5c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -13,6 +13,9 @@ and date.
 
 ### Added
 
+- A keyboard shortcut opens and closes the mini panel, Ctrl + Alt + M by
+  default, beside the mix's shortcuts and changed the same way. It opens the
+  panel by the clock, on the screen whose taskbar holds it.
 - The mini panel has spatial sound, between noise cancellation and the
   equaliser: Off, Windows Sonic or Dolby Atmos, whichever the system offers. It
   is left out where the system has none, and it stays when the headset is away,
@@ -73,6 +76,14 @@ and date.
 
 ### Changed
 
+- On Windows, the mini panel opens by Neap's icon, on the screen whose taskbar
+  holds it, rather than in the corner of the main screen. Opened from the
+  icon's menu, it goes in the corner of the screen the menu was on.
+- The mini panel fades up into place as it opens and fades away as it
+  closes. With "Show animations in Windows" off, it appears and goes at once.
+- A settings row whose control says more than a switch, such as the
+  microphone's "Muted by the boom arm" in the mini panel, puts the control
+  under the name rather than breaking the name mid-word.
 - The app's text is set in Figtree, and the name beside the mark in Outfit,
   in place of Inter. Both are carried inside the app, so Windows and Linux
   show the same letters. The text is a little rounder and a little wider.
diff --git a/src/Neap.Core/MiniPanel.cs b/src/Neap.Core/MiniPanel.cs
index 575c0e79..e47798ff 100644
--- a/src/Neap.Core/MiniPanel.cs
+++ b/src/Neap.Core/MiniPanel.cs
@@ -13,13 +13,20 @@ public enum TrayClick
 /// <summary>Decides where the mini panel opens, what a click on the tray icon does, and whether it opens the panel.</summary>
 /// <remarks>
 /// <para>
-/// The panel opens beside the notification area, as the system's own volume
-/// flyout does. A desktop does not say where its icons are, but it does say
-/// where its taskbar is: the work area is the screen less the bars, so the
-/// side a bar takes shows as a gap between the two. The panel goes in the
-/// corner next to that bar, on the side the icons are on: the right, except
-/// beside a bar on the left edge. With no bar to find, as with one that hides
-/// itself or a desktop that reports none, it goes bottom right.
+/// The panel opens by the icon that was clicked. A desktop does not say where
+/// its icons are, but a click on one lands on a taskbar, outside the work
+/// area, which is the screen less its bars. So a click on a bar puts the panel
+/// against that bar, centred on the click as far as the work area allows,
+/// which keeps it by the icon on whichever screen the notification area is.
+/// </para>
+/// <para>
+/// Without such a click, as from the icon's menu or on a desktop that does not
+/// say where the pointer is, the panel goes in a corner, as the system's own
+/// volume flyout does. The side a bar takes shows as a gap between the screen
+/// and its work area, and the panel goes in the corner next to that bar, on
+/// the side the icons are on: the right, except beside a bar on the left edge.
+/// With no bar to find, as with one that hides itself or a desktop that
+/// reports none, it goes bottom right.
 /// </para>
 /// <para>
 /// Clicking the icon while the panel is open first takes focus from the
@@ -38,13 +45,23 @@ public static class MiniPanel
     /// <param name="width">The panel's width, in pixels.</param>
     /// <param name="height">The panel's height, in pixels.</param>
     /// <param name="margin">The gap kept to the work area's edges, in pixels.</param>
-    public static Box Place(Box screen, Box work, int width, int height, int margin)
+    /// <param name="click">Where the pointer was when the icon was clicked, or null when that is not known.</param>
+    public static Box Place(Box screen, Box work, int width, int height, int margin, (int X, int Y)? click)
     {
         int w = Math.Min(width, work.Width - 2 * margin), h = Math.Min(height, work.Height - 2 * margin);
+        int right = work.X + work.Width - w - margin, bottom = work.Y + work.Height - h - margin;
+        if (click is { } c)
+        {
+            if (c.Y < work.Y || c.Y >= work.Y + work.Height)
+                return new(Math.Clamp(c.X - w / 2, work.X + margin, right), c.Y < work.Y ? work.Y + margin : bottom, w, h);
+            if (c.X < work.X || c.X >= work.X + work.Width)
+                return new(c.X < work.X ? work.X + margin : right, Math.Clamp(c.Y - h / 2, work.Y + margin, bottom), w, h);
+        }
+
         bool top = work.Y > screen.Y && work.Y + work.Height == screen.Y + screen.Height;
         bool left = work.X > screen.X && work.X + work.Width == screen.X + screen.Width;
-        int x = left ? work.X + margin : work.X + work.Width - w - margin;
-        int y = top ? work.Y + margin : work.Y + work.Height - h - margin;
+        int x = left ? work.X + margin : right;
+        int y = top ? work.Y + margin : bottom;
         return new(x, y, w, h);
     }
 
diff --git a/src/Neap.Desktop/Controls/MixKeysPanel.axaml b/src/Neap.Desktop/Controls/MixKeysPanel.axaml
index 742f216e..8938c902 100644
--- a/src/Neap.Desktop/Controls/MixKeysPanel.axaml
+++ b/src/Neap.Desktop/Controls/MixKeysPanel.axaml
@@ -30,6 +30,9 @@
                 <c:SettingsCard x:Name="CentreRow" loc:Uid.Value="Mix_CentreRow">
                     <Button x:Name="CentreKey" MinWidth="190" />
                 </c:SettingsCard>
+                <c:SettingsCard x:Name="MiniRow" loc:Uid.Value="Mix_MiniRow">
+                    <Button x:Name="MiniKey" MinWidth="190" />
+                </c:SettingsCard>
                 <c:SettingsCard loc:Uid.Value="Mix_KeysResetRow">
                     <Button x:Name="KeysReset" loc:Uid.Value="Mix_KeysReset" />
                 </c:SettingsCard>
diff --git a/src/Neap.Desktop/Controls/MixKeysPanel.axaml.cs b/src/Neap.Desktop/Controls/MixKeysPanel.axaml.cs
index 558d3249..a18edbb4 100644
--- a/src/Neap.Desktop/Controls/MixKeysPanel.axaml.cs
+++ b/src/Neap.Desktop/Controls/MixKeysPanel.axaml.cs
@@ -7,8 +7,8 @@
 namespace Neap.Desktop.Controls;
 
 /// <summary>
-/// The keys that move the game and chat mix from anywhere, and a way to
-/// change them.
+/// The keys that move the game and chat mix or open the mini panel from
+/// anywhere, and a way to change them.
 /// </summary>
 /// <remarks>
 /// <para>
@@ -49,6 +49,7 @@ public MixKeysPanel()
         Capture(GameKey, MixKey.TowardGame);
         Capture(ChatKey, MixKey.TowardChat);
         Capture(CentreKey, MixKey.Balanced);
+        Capture(MiniKey, MixKey.MiniPanel);
     }
 
     protected override void OnLoaded(RoutedEventArgs e)
@@ -144,6 +145,7 @@ private void Paint()
         Show(GameKey, GameRow, MixKey.TowardGame);
         Show(ChatKey, ChatRow, MixKey.TowardChat);
         Show(CentreKey, CentreRow, MixKey.Balanced);
+        Show(MiniKey, MiniRow, MixKey.MiniPanel);
 
         _painting = true;
         KeysOn.IsChecked = AppServices.Hotkeys.Enabled;
diff --git a/src/Neap.Desktop/Controls/SettingsCard.cs b/src/Neap.Desktop/Controls/SettingsCard.cs
index f4e82230..dd46757d 100644
--- a/src/Neap.Desktop/Controls/SettingsCard.cs
+++ b/src/Neap.Desktop/Controls/SettingsCard.cs
@@ -63,7 +63,8 @@ public Geometry? Icon
     /// <summary>
     /// The width below which the control moves under the name, so neither is
     /// squeezed. A panel whose rows are short, like the mini panel, sets it
-    /// to zero in a style to keep a switch beside its name.
+    /// to zero in a style to keep a switch beside its name while the name
+    /// still fits on one line.
     /// </summary>
     public double SideBySideWidth
     {
@@ -75,12 +76,16 @@ public double SideBySideWidth
 
     private Grid? _layout;
     private Control? _control;
+    private Control? _glyph;
+    private Control? _header;
 
     protected override void OnApplyTemplate(TemplateAppliedEventArgs e)
     {
         base.OnApplyTemplate(e);
         _layout = e.NameScope.Find<Grid>("Layout");
         _control = e.NameScope.Find<Control>("Control");
+        _glyph = e.NameScope.Find<Control>("Glyph");
+        _header = e.NameScope.Find<Control>("HeaderText");
         Place(Bounds.Width);
     }
 
@@ -113,7 +118,7 @@ protected override Size MeasureOverride(Size availableSize)
     private void Place(double width)
     {
         if (_layout is null || _control is null || width <= 0) return;
-        bool beside = width >= SideBySideWidth;
+        bool beside = width >= SideBySideWidth && NameFitsBeside(width);
         Grid.SetRow(_control, beside ? 0 : 1);
         Grid.SetColumn(_control, beside ? 2 : 1);
         Grid.SetColumnSpan(_control, beside ? 1 : 2);
@@ -128,4 +133,26 @@ private void Place(double width)
         // Likewise the gap above it when it sits under the name, so a row with nothing under it has no spare room.
         _control.Margin = beside ? new Thickness(Space.M, 0, 0, 0) : new Thickness(0, Space.S, 0, 0);
     }
+
+    /// <summary>Whether the name keeps to one line with the control beside it.</summary>
+    /// <remarks>
+    /// A control that says more than a switch, such as the reason the microphone
+    /// cannot be changed, can leave a short name a few letters wide, broken
+    /// mid-word. Then the control goes under the name instead.
+    /// </remarks>
+    private bool NameFitsBeside(double width)
+    {
+        if (_header is null || _control is null) return true;
+        _header.Measure(Size.Infinity);
+        _control.Measure(Size.Infinity);
+        double glyph = 0;
+        if (_glyph is { IsVisible: true })
+        {
+            _glyph.Measure(Size.Infinity);
+            glyph = _glyph.DesiredSize.Width;
+        }
+        double edges = Padding.Left + Padding.Right + BorderThickness.Left + BorderThickness.Right;
+        double control = _control.DesiredSize.Width - _control.Margin.Left - _control.Margin.Right;
+        return edges + glyph + _header.DesiredSize.Width + Space.M + control <= width;
+    }
 }
diff --git a/src/Neap.Desktop/MainWindow.Tray.cs b/src/Neap.Desktop/MainWindow.Tray.cs
index 8bd64975..dfece074 100644
--- a/src/Neap.Desktop/MainWindow.Tray.cs
+++ b/src/Neap.Desktop/MainWindow.Tray.cs
@@ -1,5 +1,6 @@
 using System.ComponentModel;
 using System.Diagnostics;
+using System.Runtime.InteropServices;
 using System.Runtime.Versioning;
 using Avalonia;
 using Avalonia.Controls;
@@ -58,7 +59,7 @@ private void StartTray()
         var open = new NativeMenuItem(Strings.Get("Main_TrayOpen"));
         open.Click += (_, _) => Reveal();
         var mini = new NativeMenuItem(Strings.Get("Main_TrayMini"));
-        mini.Click += (_, _) => ToggleMini();
+        mini.Click += (_, _) => ToggleMini(PointerAt());
         mini.IsVisible = AppSettings.Current.MiniPanel;
         _miniItem = mini;
         var quit = new NativeMenuItem(Strings.Get("Main_TrayQuit"));
@@ -69,11 +70,8 @@ private void StartTray()
             Menu = new NativeMenu { open, mini, new NativeMenuItemSeparator(), quit },
         };
         if (Application.Current?.PlatformSettings is { } settings) settings.ColorValuesChanged += RepaintTrayPicture;
-        _tray.Clicked += (_, _) =>
-        {
-            if (MiniPanel.Click(AppSettings.Current.MiniPanel) == TrayClick.ToggleMiniPanel) ToggleMini();
-            else Reveal();
-        };
+        _tray.Clicked += (_, _) => Summon(PointerAt());
+        AppServices.Hotkeys.MiniPanelPressed += () => Summon(NotificationArea());
         if (Application.Current is { } app) TrayIcon.SetIcons(app, new TrayIcons { _tray });
 
         AppServices.Updates.Found += release => Dispatcher.UIThread.Post(() => TellAboutUpdate(release));
@@ -92,21 +90,29 @@ public void MiniPanelSettingChanged()
         if (!on) _mini?.Close();
     }
 
-    /// <summary>Opens the mini panel, or closes it when it is open.</summary>
+    /// <summary>Does what a click on the icon or the mini panel's key does: toggles the panel while it is on, or else brings the window forward.</summary>
+    private void Summon(PixelPoint? at)
+    {
+        if (MiniPanel.Click(AppSettings.Current.MiniPanel) == TrayClick.ToggleMiniPanel) ToggleMini(at);
+        else Reveal();
+    }
+
+    /// <summary>Opens the mini panel by the given point, or closes it when it is open.</summary>
+    /// <param name="click">Where the icon was clicked, or the notification area for its key; null puts it in the main screen's corner.</param>
     /// <remarks>
     /// A click on the icon takes focus from an open panel, which closes it
     /// before the click arrives; <see cref="MiniPanel.Opens"/> tells that
     /// click apart from one that asks to open it.
     /// </remarks>
-    private void ToggleMini()
+    private void ToggleMini(PixelPoint? click)
     {
         if (!MiniPanel.Opens(_mini is not null, Stopwatch.GetElapsedTime(_miniClosedAt)))
         {
             _mini?.Close();
             return;
         }
-        AppLog.Write("mini panel: opened from the notification area");
-        var panel = new MiniPanelWindow { Main = this };
+        AppLog.Write("mini panel: opened");
+        var panel = new MiniPanelWindow { Main = this, Click = click };
         panel.Closed += (_, _) =>
         {
             _miniClosedAt = panel.ClosedAt;
@@ -117,6 +123,68 @@ private void ToggleMini()
         panel.Activate();
     }
 
+    /// <summary>Where the pointer is on the desktop, in physical pixels, or null where that cannot be read.</summary>
+    /// <remarks>
+    /// The icon's click carries no place, and the toolkit has no pointer
+    /// outside its own windows, so Windows is asked. Elsewhere the panel goes
+    /// in the main screen's corner.
+    /// </remarks>
+    private static PixelPoint? PointerAt() =>
+        OperatingSystem.IsWindows() && GetCursorPos(out var at) ? new PixelPoint(at.X, at.Y) : null;
+
+    /// <summary>The clock's end of the main taskbar, in physical pixels, or null where that cannot be read.</summary>
+    /// <remarks>
+    /// A key press has no pointer on the taskbar to open by, so the panel goes
+    /// by the clock instead: on the taskbar that holds the notification area,
+    /// whichever screen that is. Windows gives that taskbar's place but not the
+    /// clock's, which sits at its right end, or its foot when it stands upright.
+    /// </remarks>
+    private static PixelPoint? NotificationArea()
+    {
+        var bar = new AppBarData { Size = (uint)Marshal.SizeOf<AppBarData>() };
+        if (!OperatingSystem.IsWindows() || SHAppBarMessage(GetTaskbarPosition, ref bar) == 0) return null;
+        var r = bar.Rect;
+        return r.Right - r.Left >= r.Bottom - r.Top
+            ? new PixelPoint(r.Right - 1, (r.Top + r.Bottom) / 2)
+            : new PixelPoint((r.Left + r.Right) / 2, r.Bottom - 1);
+    }
+
+    private const uint GetTaskbarPosition = 5;
+
+    [StructLayout(LayoutKind.Sequential)]
+    private struct NativeRect
+    {
+        public int Left;
+        public int Top;
+        public int Right;
+        public int Bottom;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    private struct AppBarData
+    {
+        public uint Size;
+        public IntPtr Window;
+        public uint CallbackMessage;
+        public uint Edge;
+        public NativeRect Rect;
+        public IntPtr Param;
+    }
+
+    [DllImport("shell32.dll")]
+    private static extern UIntPtr SHAppBarMessage(uint message, ref AppBarData data);
+
+    [StructLayout(LayoutKind.Sequential)]
+    private struct NativePoint
+    {
+        public int X;
+        public int Y;
+    }
+
+    [DllImport("user32.dll")]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    private static extern bool GetCursorPos(out NativePoint point);
+
     /// <summary>The notification-area glyph: light on a dark taskbar, dark on a light one.</summary>
     /// <remarks>
     /// Windows has a taskbar shade, set apart from the app's own theme. A Linux
diff --git a/src/Neap.Desktop/MiniPanelWindow.axaml b/src/Neap.Desktop/MiniPanelWindow.axaml
index acf92e93..d5cc0130 100644
--- a/src/Neap.Desktop/MiniPanelWindow.axaml
+++ b/src/Neap.Desktop/MiniPanelWindow.axaml
@@ -31,7 +31,7 @@
         in a window of its own so it can sit by the notification area and
         go away when it loses focus.
     -->
-    <Border Classes="card">
+    <Border x:Name="Card" Classes="card">
         <StackPanel Spacing="{StaticResource NeapSpaceM}">
 
             <!-- The headset, how it is connected, its battery, and the way to the window. -->
diff --git a/src/Neap.Desktop/MiniPanelWindow.axaml.cs b/src/Neap.Desktop/MiniPanelWindow.axaml.cs
index 6e76e160..1faa27a3 100644
--- a/src/Neap.Desktop/MiniPanelWindow.axaml.cs
+++ b/src/Neap.Desktop/MiniPanelWindow.axaml.cs
@@ -1,11 +1,15 @@
 using System.Diagnostics;
 using System.Globalization;
 using Avalonia;
+using Avalonia.Animation;
+using Avalonia.Animation.Easings;
 using Avalonia.Automation;
 using Avalonia.Controls;
 using Avalonia.Controls.ApplicationLifetimes;
 using Avalonia.Input;
+using Avalonia.Media;
 using Avalonia.Media.Imaging;
+using Avalonia.Styling;
 using Avalonia.Threading;
 using Avalonia.VisualTree;
 using Neap.Core;
@@ -33,6 +37,11 @@ namespace Neap.Desktop;
 /// went elsewhere meanwhile.
 /// </para>
 /// <para>
+/// It fades up into place as it opens and fades away as it closes, as the
+/// system's flyouts do, unless animation is off; see <see cref="Motion"/>.
+/// A close waits for the fade, except when the app is stopping.
+/// </para>
+/// <para>
 /// A pretend run with <see cref="Pretend.Mini"/> shows it alone as the app's
 /// only window, which stays open so it can be looked at or pictured.
 /// </para>
@@ -42,10 +51,18 @@ public partial class MiniPanelWindow : Window
     /// <summary>The gap kept between the panel and the edge of the work area, in device-independent pixels.</summary>
     private const double EdgeGap = 12;
 
+    /// <summary>How far the card moves as it fades in or out, in device-independent pixels.</summary>
+    private const double Rise = 12;
+
+    private static readonly TimeSpan Arrive = TimeSpan.FromMilliseconds(180);
+    private static readonly TimeSpan Leave = TimeSpan.FromMilliseconds(120);
+
     private readonly MainWindow? _main;
     private readonly BatteryMeter _battery = new("caption");
     private IDisposable? _recheck;
     private bool _painting;
+    private bool _leaving;
+    private bool _left;
 
     public MiniPanelWindow()
     {
@@ -75,6 +92,7 @@ public MiniPanelWindow()
             Close();
         };
         SizeChanged += (_, _) => Place();
+        ScalingChanged += (_, _) => Place();
     }
 
     /// <summary>
@@ -91,6 +109,9 @@ public MainWindow? Main
         }
     }
 
+    /// <summary>Gets where the pointer was when the icon was clicked, in physical pixels, or null when that is not known.</summary>
+    public PixelPoint? Click { get; init; }
+
     /// <summary>Gets when it closed, as a <see cref="Stopwatch"/> timestamp, so the icon's next click can tell whether that click was the one that did it.</summary>
     public long ClosedAt { get; private set; }
 
@@ -102,6 +123,7 @@ protected override void OnOpened(EventArgs e)
         AppServices.Mix.Changed += Paint;
         Paint();
         Place();
+        if (Motion.Enabled) _ = Fade(0, 1, Rise, 0, Arrive, new CubicEaseOut());
 
         // Focus begins on the dial, on the way to choose chat apps while the dial waits for
         // them, or else on the first thing that can take it. Given without the focus ring,
@@ -115,6 +137,15 @@ protected override void OnOpened(EventArgs e)
         if (Pretend.Snapshot is { } file) _ = SaveAndExit(file);
     }
 
+    /// <summary>Holds the close until the card has faded out, unless animation is off or the app is stopping.</summary>
+    protected override void OnClosing(WindowClosingEventArgs e)
+    {
+        base.OnClosing(e);
+        if (_left || !Motion.Enabled || e.CloseReason is WindowCloseReason.OSShutdown or WindowCloseReason.ApplicationShutdown) return;
+        e.Cancel = true;
+        if (!_leaving) _ = FadeAndClose();
+    }
+
     protected override void OnClosed(EventArgs e)
     {
         base.OnClosed(e);
@@ -127,6 +158,32 @@ protected override void OnClosed(EventArgs e)
 
     private void OnStatus(HeadsetStatus status) => Paint();
 
+    private async Task FadeAndClose()
+    {
+        _leaving = true;
+        Card.IsHitTestVisible = false;
+        await Fade(1, 0, 0, Rise / 2, Leave, new CubicEaseIn());
+        _left = true;
+        Close();
+    }
+
+    /// <summary>Moves the card's opacity and its offset below its place from one value to another.</summary>
+    private Task Fade(double fromOpacity, double toOpacity, double fromOffset, double toOffset, TimeSpan duration, Easing easing)
+    {
+        Card.RenderTransform ??= new TranslateTransform();
+        return new Animation
+        {
+            Duration = duration,
+            Easing = easing,
+            FillMode = FillMode.Both,
+            Children =
+            {
+                new KeyFrame { Cue = new Cue(0), Setters = { new Setter(OpacityProperty, fromOpacity), new Setter(TranslateTransform.YProperty, fromOffset) } },
+                new KeyFrame { Cue = new Cue(1), Setters = { new Setter(OpacityProperty, toOpacity), new Setter(TranslateTransform.YProperty, toOffset) } },
+            },
+        }.RunAsync(Card);
+    }
+
     /// <summary>Opens the main window, on a page if one is given, and puts this away.</summary>
     private void OpenWindow(string? page)
     {
@@ -143,16 +200,20 @@ private void CloseIfAway()
         Close();
     }
 
-    /// <summary>Puts the panel in the corner by the notification area, and keeps it there as it grows or shrinks.</summary>
+    /// <summary>Puts the panel by the icon, on the screen the icon was clicked on, and keeps it there as it grows or shrinks.</summary>
     private void Place()
     {
-        if (Screens.Primary is not { } screen || Bounds.Height <= 0) return;
+        var clicked = Click is { } click ? Screens.ScreenFromPoint(click) : null;
+        if ((clicked ?? Screens.Primary) is not { } screen || Bounds.Height <= 0) return;
         double scale = RenderScaling;
+        (int, int)? at = clicked is not null && Click is { } c ? (c.X, c.Y) : null;
         var box = MiniPanel.Place(Of(screen.Bounds), Of(screen.WorkingArea),
-            (int)Math.Ceiling(Bounds.Width * scale), (int)Math.Ceiling(Bounds.Height * scale), (int)Math.Round(EdgeGap * scale));
-        MaxHeight = box.Height / scale;
-        var at = new PixelPoint(box.X, box.Y);
-        if (Position != at) Position = at;
+            (int)Math.Ceiling(Bounds.Width * scale), (int)Math.Ceiling(Bounds.Height * scale), (int)Math.Round(EdgeGap * scale), at);
+        // Capped by the work area, never by the height it had: a row that grows after
+        // it opens, such as a switch moving under its name, needs the room.
+        MaxHeight = (screen.WorkingArea.Height / scale) - (2 * EdgeGap);
+        var position = new PixelPoint(box.X, box.Y);
+        if (Position != position) Position = position;
 
         static Box Of(PixelRect rect) => new(rect.X, rect.Y, rect.Width, rect.Height);
     }
diff --git a/src/Neap.Desktop/Strings/en-US/Resources.resw b/src/Neap.Desktop/Strings/en-US/Resources.resw
index 9b54de65..76132b3c 100644
--- a/src/Neap.Desktop/Strings/en-US/Resources.resw
+++ b/src/Neap.Desktop/Strings/en-US/Resources.resw
@@ -172,7 +172,7 @@
     <value>Keyboard shortcuts</value>
   </data>
   <data name="Mix_KeysCard.Description" xml:space="preserve">
-    <value>Move the mix while you play.</value>
+    <value>Move the mix or open the mini panel while you play.</value>
   </data>
   <data name="Mix_KeysCard.Header" xml:space="preserve">
     <value>Keyboard shortcuts</value>
@@ -186,8 +186,11 @@
   <data name="Mix_CentreRow.Header" xml:space="preserve">
     <value>Back to balanced</value>
   </data>
+  <data name="Mix_MiniRow.Header" xml:space="preserve">
+    <value>Open the mini panel</value>
+  </data>
   <data name="Mix_KeysResetRow.Description" xml:space="preserve">
-    <value>Ctrl + Alt + Page Down, Page Up and Home.</value>
+    <value>Ctrl + Alt + Page Down, Page Up, Home and M.</value>
   </data>
   <data name="Mix_KeysResetRow.Header" xml:space="preserve">
     <value>Default shortcuts</value>
diff --git a/src/Neap.Desktop/Themes/Neap.axaml b/src/Neap.Desktop/Themes/Neap.axaml
index 4baa0f38..e2c54d5c 100644
--- a/src/Neap.Desktop/Themes/Neap.axaml
+++ b/src/Neap.Desktop/Themes/Neap.axaml
@@ -69,7 +69,8 @@
 
         <!--
             A row of settings: icon, name, what it does, and its control on the
-            right. The control keeps its own size and the name gives way to it.
+            right. The control keeps its own size and the name gives way to it,
+            until the name would wrap, when the control moves under it.
             It is an inset: a quiet fill one step above whatever it sits on, so
             it reads the same on the page and on a card, with no edge of its own
             except in high contrast, where the fill steps vanish.
@@ -93,11 +94,11 @@
                             MinHeight="{TemplateBinding MinHeight}"
                             Padding="{TemplateBinding Padding}">
                         <Grid x:Name="Layout" VerticalAlignment="Center" ColumnDefinitions="Auto,*,Auto" RowDefinitions="Auto,Auto">
-                            <PathIcon Width="20" Height="20" Margin="0,0,12,0" VerticalAlignment="Center"
+                            <PathIcon x:Name="Glyph" Width="20" Height="20" Margin="0,0,12,0" VerticalAlignment="Center"
                                       Foreground="{DynamicResource NeapTextSecondaryBrush}"
                                       Data="{TemplateBinding Icon}" IsVisible="{TemplateBinding Icon, Converter={x:Static ObjectConverters.IsNotNull}}" />
                             <StackPanel Grid.Column="1" VerticalAlignment="Center" Spacing="2" MinWidth="0">
-                                <TextBlock Text="{TemplateBinding Header}" />
+                                <TextBlock x:Name="HeaderText" Text="{TemplateBinding Header}" />
                                 <TextBlock Text="{TemplateBinding Description}" Classes="caption secondary"
                                            IsVisible="{TemplateBinding Description, Converter={x:Static StringConverters.IsNotNullOrEmpty}}" />
                                 <ContentPresenter Content="{TemplateBinding Below}"
diff --git a/src/Neap.Services/MixHotkeys.cs b/src/Neap.Services/MixHotkeys.cs
index 433b01a9..b77306b8 100644
--- a/src/Neap.Services/MixHotkeys.cs
+++ b/src/Neap.Services/MixHotkeys.cs
@@ -1,7 +1,7 @@
 namespace Neap.Services;
 
 /// <summary>
-/// Global keyboard shortcuts that move the mix, whichever system takes the keys.
+/// Global keyboard shortcuts that move the mix or open the mini panel, whichever system takes the keys.
 /// </summary>
 /// <remarks>
 /// <para>
@@ -36,6 +36,8 @@ protected MixHotkeys(MixService mix)
     /// <summary>A key was registered, refused, changed, or given up.</summary>
     public event Action? Changed;
 
+    public event Action? MiniPanelPressed;
+
     public bool Supported => true;
 
     public bool Enabled { get; private set; }
@@ -88,7 +90,11 @@ public void ResetToDefaults()
     protected abstract void LetGo();
 
     /// <summary>One of the keys was pressed; may be called from any thread.</summary>
-    protected void Pressed(MixKey which) => Platform.Post(() => Move(which));
+    protected void Pressed(MixKey which) => Platform.Post(() =>
+    {
+        if (which == MixKey.MiniPanel) MiniPanelPressed?.Invoke();
+        else Move(which);
+    });
 
     private void Begin()
     {
diff --git a/src/Neap.Services/Platform.cs b/src/Neap.Services/Platform.cs
index be12cd2f..0137a18c 100644
--- a/src/Neap.Services/Platform.cs
+++ b/src/Neap.Services/Platform.cs
@@ -90,6 +90,9 @@ public interface IHotkeys : IDisposable
     /// <summary>A key was registered, refused, changed, or given up.</summary>
     event Action? Changed;
 
+    /// <summary>The mini panel's key was pressed; raised on the interface thread.</summary>
+    event Action? MiniPanelPressed;
+
     /// <summary>Whether this system can register keys at all.</summary>
     bool Supported { get; }
 
@@ -186,6 +189,7 @@ private sealed class NoSpatial : ISpatialAudio
     private sealed class NoHotkeys : IHotkeys
     {
         public event Action? Changed { add { } remove { } }
+        public event Action? MiniPanelPressed { add { } remove { } }
         public bool Supported => false;
         public bool Enabled => false;
         public Shortcut Key(MixKey which) => MixShortcuts.Defaults[which];
diff --git a/src/Neap.Services/Shortcut.cs b/src/Neap.Services/Shortcut.cs
index fd6f7467..fb6c8f21 100644
--- a/src/Neap.Services/Shortcut.cs
+++ b/src/Neap.Services/Shortcut.cs
@@ -1,7 +1,7 @@
 namespace Neap.Services;
 
-/// <summary>Which way a shortcut moves the mix.</summary>
-public enum MixKey { TowardGame, TowardChat, Balanced }
+/// <summary>What a shortcut does: moves the mix one way or the other, centres it, or opens the mini panel.</summary>
+public enum MixKey { TowardGame, TowardChat, Balanced, MiniPanel }
 
 /// <summary>
 /// One key combination. Modifiers are the RegisterHotKey flags; Key is a
@@ -56,7 +56,7 @@ public override string ToString()
     };
 }
 
-/// <summary>The shortcuts the mix starts with.</summary>
+/// <summary>The shortcuts the app starts with.</summary>
 public static class MixShortcuts
 {
     public static readonly IReadOnlyDictionary<MixKey, Shortcut> Defaults =
@@ -65,5 +65,6 @@ public static class MixShortcuts
             [MixKey.TowardGame] = new(Shortcut.Control | Shortcut.Alt, 0x22),   // Page Down
             [MixKey.TowardChat] = new(Shortcut.Control | Shortcut.Alt, 0x21),   // Page Up
             [MixKey.Balanced] = new(Shortcut.Control | Shortcut.Alt, 0x24),     // Home
+            [MixKey.MiniPanel] = new(Shortcut.Control | Shortcut.Alt, 0x4D),    // M
         };
 }
diff --git a/tests/Neap.Core.Tests/MiniPanelTests.cs b/tests/Neap.Core.Tests/MiniPanelTests.cs
index 34c9a24c..918dd32f 100644
--- a/tests/Neap.Core.Tests/MiniPanelTests.cs
+++ b/tests/Neap.Core.Tests/MiniPanelTests.cs
@@ -7,39 +7,72 @@ public class MiniPanelTests
     [Fact]
     public void BesideATaskbarAtTheFootItIsBottomRight() =>
         Assert.Equal(new Box(1568, 570, 340, 450),
-            MiniPanel.Place(Screen, new Box(0, 0, 1920, 1032), 340, 450, 12));
+            MiniPanel.Place(Screen, new Box(0, 0, 1920, 1032), 340, 450, 12, null));
 
     [Fact]
     public void BesideATaskbarAtTheTopItIsTopRight() =>
         Assert.Equal(new Box(1568, 60, 340, 450),
-            MiniPanel.Place(Screen, new Box(0, 48, 1920, 1032), 340, 450, 12));
+            MiniPanel.Place(Screen, new Box(0, 48, 1920, 1032), 340, 450, 12, null));
 
     [Fact]
     public void BesideATaskbarOnTheRightItIsBottomRight() =>
         Assert.Equal(new Box(1520, 618, 340, 450),
-            MiniPanel.Place(Screen, new Box(0, 0, 1872, 1080), 340, 450, 12));
+            MiniPanel.Place(Screen, new Box(0, 0, 1872, 1080), 340, 450, 12, null));
 
     [Fact]
     public void BesideATaskbarOnTheLeftItIsBottomLeft() =>
         Assert.Equal(new Box(60, 618, 340, 450),
-            MiniPanel.Place(Screen, new Box(48, 0, 1872, 1080), 340, 450, 12));
+            MiniPanel.Place(Screen, new Box(48, 0, 1872, 1080), 340, 450, 12, null));
 
     [Fact]
     public void WithNoTaskbarToFindItIsBottomRight() =>
-        Assert.Equal(new Box(1568, 618, 340, 450), MiniPanel.Place(Screen, Screen, 340, 450, 12));
+        Assert.Equal(new Box(1568, 618, 340, 450), MiniPanel.Place(Screen, Screen, 340, 450, 12, null));
 
     [Fact]
     public void OnASecondScreenItStaysOnThatScreen()
     {
         var second = new Box(1920, 0, 2560, 1440);
         Assert.Equal(new Box(4128, 930, 340, 450),
-            MiniPanel.Place(second, new Box(1920, 0, 2560, 1392), 340, 450, 12));
+            MiniPanel.Place(second, new Box(1920, 0, 2560, 1392), 340, 450, 12, null));
     }
 
     [Fact]
     public void ItNeverGrowsPastTheWorkArea() =>
         Assert.Equal(new Box(12, 12, 676, 376),
-            MiniPanel.Place(new Box(0, 0, 700, 400), new Box(0, 0, 700, 400), 800, 800, 12));
+            MiniPanel.Place(new Box(0, 0, 700, 400), new Box(0, 0, 700, 400), 800, 800, 12, null));
+
+    [Fact]
+    public void AClickOnATaskbarAtTheFootPutsItAboveTheClick() =>
+        Assert.Equal(new Box(1430, 570, 340, 450),
+            MiniPanel.Place(Screen, new Box(0, 0, 1920, 1032), 340, 450, 12, (1600, 1056)));
+
+    [Fact]
+    public void AClickOnATaskbarAtTheTopPutsItBelowTheClick() =>
+        Assert.Equal(new Box(830, 60, 340, 450),
+            MiniPanel.Place(Screen, new Box(0, 48, 1920, 1032), 340, 450, 12, (1000, 20)));
+
+    [Fact]
+    public void AClickNearTheEndOfTheTaskbarKeepsItInsideTheWorkArea() =>
+        Assert.Equal(new Box(1568, 570, 340, 450),
+            MiniPanel.Place(Screen, new Box(0, 0, 1920, 1032), 340, 450, 12, (1900, 1056)));
+
+    [Fact]
+    public void AClickOnATaskbarOnTheLeftPutsItBesideTheClick() =>
+        Assert.Equal(new Box(60, 400, 340, 450),
+            MiniPanel.Place(Screen, new Box(48, 0, 1872, 1080), 340, 450, 12, (24, 625)));
+
+    [Fact]
+    public void AClickOnATaskbarOnASecondScreenPutsItThereAboveTheClick()
+    {
+        var second = new Box(1920, 0, 2560, 1440);
+        Assert.Equal(new Box(4030, 930, 340, 450),
+            MiniPanel.Place(second, new Box(1920, 0, 2560, 1392), 340, 450, 12, (4200, 1416)));
+    }
+
+    [Fact]
+    public void AClickInsideTheWorkAreaLeavesItInTheCorner() =>
+        Assert.Equal(new Box(1568, 570, 340, 450),
+            MiniPanel.Place(Screen, new Box(0, 0, 1920, 1032), 340, 450, 12, (900, 500)));
 
     [Fact]
     public void AClickOpensAClosedPanel() =>