diff --git a/.editorconfig b/.editorconfig
index d808f24..4ccc4c0 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -12,6 +12,10 @@ dotnet_diagnostic.CA2007.severity = none
 # Font discovery failures are converted into dialog status here.
 dotnet_diagnostic.CA1031.severity = none
 
+[Views/TemplateFlyoutView.axaml.cs]
+# Drag continuations must resume on Avalonia's UI thread.
+dotnet_diagnostic.CA2007.severity = none
+
 [ViewModels/*.cs]
 # Reactive commands update bound properties after awaits and require the UI context.
 dotnet_diagnostic.CA2007.severity = none
diff --git a/Models/TemplateTextElementGenerator.cs b/Models/TemplateTextElementGenerator.cs
index 087e5b1..d90bf52 100644
--- a/Models/TemplateTextElementGenerator.cs
+++ b/Models/TemplateTextElementGenerator.cs
@@ -251,6 +251,15 @@ private void OnOptionsChanged(TemplateInfo info, NotifyCollectionChangedEventArg
             return;
         }
 
+        if (e.Action == NotifyCollectionChangedAction.Move &&
+            e.OldStartingIndex >= 0 &&
+            e.NewStartingIndex >= 0 &&
+            e.OldItems?.Count == 1)
+        {
+            RecordOptionMove(info, e.OldStartingIndex, e.NewStartingIndex);
+            return;
+        }
+
         if (info.SelectedIndex >= info.Options.Count)
         {
             SelectByMetadata(info, TemplateTextElement.PlaceholderText, -1);
@@ -319,6 +328,57 @@ private void RecordOptionRemoval(TemplateInfo info, string option, int removedIn
         NotifyChanged();
     }
 
+    private void RecordOptionMove(TemplateInfo info, int oldIndex, int newIndex)
+    {
+        if (oldIndex == newIndex)
+        {
+            return;
+        }
+
+        var oldSelectedIndex = info.SelectedIndex;
+        var newSelectedIndex = IndexAfterMove(oldSelectedIndex, oldIndex, newIndex);
+
+        RunUndoGroup(() =>
+        {
+            _editor.Document.UndoStack.Push(new TemplateOptionMoveOperation(
+                this,
+                info,
+                oldIndex,
+                newIndex,
+                info.SelectedText,
+                oldSelectedIndex,
+                newSelectedIndex));
+            ApplySelectionMetadata(info, info.SelectedText, newSelectedIndex);
+        });
+
+        NotifyChanged();
+    }
+
+    private static int IndexAfterMove(int index, int oldIndex, int newIndex)
+    {
+        if (index < 0)
+        {
+            return index;
+        }
+
+        if (index == oldIndex)
+        {
+            return newIndex;
+        }
+
+        if (oldIndex < newIndex && index > oldIndex && index <= newIndex)
+        {
+            return index - 1;
+        }
+
+        if (oldIndex > newIndex && index >= newIndex && index < oldIndex)
+        {
+            return index + 1;
+        }
+
+        return index;
+    }
+
     private void SelectByMetadata(TemplateInfo info, string text, int selectedIndex)
     {
         if (info.Anchor.Offset < 0)
@@ -801,4 +861,48 @@ private void ReplayCollectionChange(bool add)
             });
         }
     }
+
+    private sealed class TemplateOptionMoveOperation(
+        TemplateTextElementGenerator generator,
+        TemplateInfo template,
+        int oldIndex,
+        int newIndex,
+        string selectedText,
+        int oldSelectedIndex,
+        int newSelectedIndex) : IUndoableOperation
+    {
+        public void Undo()
+        {
+            ReplayMove(newIndex, oldIndex);
+            generator.ApplySelectionMetadata(
+                template,
+                selectedText,
+                oldSelectedIndex);
+            generator.ClampCaretOffset();
+            generator.TemplatesChanged?.Invoke();
+        }
+
+        public void Redo()
+        {
+            ReplayMove(oldIndex, newIndex);
+            generator.ApplySelectionMetadata(
+                template,
+                selectedText,
+                newSelectedIndex);
+            generator.ClampCaretOffset();
+            generator.TemplatesChanged?.Invoke();
+        }
+
+        private void ReplayMove(int sourceIndex, int targetIndex)
+        {
+            generator.ReplayOptionChange(() =>
+            {
+                if (sourceIndex >= 0 && sourceIndex < template.Options.Count &&
+                    targetIndex >= 0 && targetIndex < template.Options.Count)
+                {
+                    template.Options.Move(sourceIndex, targetIndex);
+                }
+            });
+        }
+    }
 }
diff --git a/Services/DragReorder.cs b/Services/DragReorder.cs
new file mode 100644
index 0000000..87f75e4
--- /dev/null
+++ b/Services/DragReorder.cs
@@ -0,0 +1,125 @@
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Input;
+using Avalonia.Layout;
+using Avalonia.VisualTree;
+
+namespace Inlay;
+
+internal static class DragReorder
+{
+    public static bool IsInButton(object? source, string styleClass) =>
+        source is Visual visual &&
+        (visual as Button ?? visual.FindAncestorOfType<Button>()) is { } button &&
+        button.Classes.Contains(styleClass);
+
+    public static TContainer? FindContainer<TContainer>(object? source)
+        where TContainer : Control =>
+        source is Visual visual
+            ? visual as TContainer ?? visual.FindAncestorOfType<TContainer>()
+            : null;
+
+    // A slot past the item being moved lands one index earlier once that item
+    // leaves its current place.
+    public static int SlotToIndex(int targetSlot, int sourceIndex, int count) =>
+        Math.Clamp(targetSlot > sourceIndex ? targetSlot - 1 : targetSlot, 0, count - 1);
+
+    public static int DropSlot(
+        ItemsControl items,
+        int count,
+        Point position,
+        Orientation orientation)
+    {
+        var pointer = orientation == Orientation.Horizontal ? position.X : position.Y;
+        var lastRealizedIndex = -1;
+        for (var index = 0; index < count; index++)
+        {
+            if (ContainerExtent(items, items, index, orientation) is not { } extent)
+            {
+                continue;
+            }
+
+            lastRealizedIndex = index;
+            if (pointer < extent.Start + extent.Size / 2)
+            {
+                return index;
+            }
+        }
+
+        return Math.Min(lastRealizedIndex + 1, count);
+    }
+
+    // Where a slot's drop indicator belongs along the axis, or null when neither
+    // the slot nor the item ahead of it has a realized container.
+    public static double? SlotOffset(
+        ItemsControl items,
+        int count,
+        int slot,
+        Orientation orientation,
+        Visual? relativeTo = null)
+    {
+        var origin = relativeTo ?? items;
+        if (slot < count && ContainerExtent(items, origin, slot, orientation) is { } extent)
+        {
+            return extent.Start;
+        }
+
+        if (slot > 0 && ContainerExtent(items, origin, slot - 1, orientation) is { } previous)
+        {
+            return previous.Start + previous.Size;
+        }
+
+        return null;
+    }
+
+    private static (double Start, double Size)? ContainerExtent(
+        ItemsControl items,
+        Visual relativeTo,
+        int index,
+        Orientation orientation)
+    {
+        if (items.ContainerFromIndex(index) is not Control container ||
+            container.TranslatePoint(new Point(0, 0), relativeTo) is not { } origin)
+        {
+            return null;
+        }
+
+        return orientation == Orientation.Horizontal
+            ? (origin.X, container.Bounds.Width)
+            : (origin.Y, container.Bounds.Height);
+    }
+}
+
+// Tracks the item a pointer press landed on until the pointer has travelled far
+// enough to mean a drag rather than a click.
+internal sealed class DragCandidate<TItem, TContainer>
+    where TItem : class
+    where TContainer : Control
+{
+    private const double DragThreshold = 6;
+
+    private (TItem Item, TContainer Container, PointerPressedEventArgs Trigger, Point Origin)?
+        _pending;
+
+    public void Arm(TItem item, TContainer container, PointerPressedEventArgs trigger, Point origin) =>
+        _pending = (item, container, trigger, origin);
+
+    public void Clear() => _pending = null;
+
+    public (TItem Item, TContainer Container, PointerPressedEventArgs Trigger)? TryStart(Point position)
+    {
+        if (_pending is not { } pending)
+        {
+            return null;
+        }
+
+        var delta = position - pending.Origin;
+        if (Math.Abs(delta.X) < DragThreshold && Math.Abs(delta.Y) < DragThreshold)
+        {
+            return null;
+        }
+
+        _pending = null;
+        return (pending.Item, pending.Container, pending.Trigger);
+    }
+}
diff --git a/Services/TemplateChoiceDragDrop.cs b/Services/TemplateChoiceDragDrop.cs
new file mode 100644
index 0000000..8f677dd
--- /dev/null
+++ b/Services/TemplateChoiceDragDrop.cs
@@ -0,0 +1,13 @@
+using Avalonia.Input;
+
+namespace Inlay;
+
+internal sealed class TemplateChoiceDragPayload
+{
+    public static readonly DataFormat<TemplateChoiceDragPayload> Format =
+        DataFormat.CreateInProcessFormat<TemplateChoiceDragPayload>(
+            "application/x-inlay-template-choice");
+
+    public required TemplateFlyoutView SourceView { get; init; }
+    public required string SourceChoice { get; init; }
+}
diff --git a/Tests/Behavior/Editor/TemplateTextElementGeneratorTests.cs b/Tests/Behavior/Editor/TemplateTextElementGeneratorTests.cs
index ca4a918..ab59334 100644
--- a/Tests/Behavior/Editor/TemplateTextElementGeneratorTests.cs
+++ b/Tests/Behavior/Editor/TemplateTextElementGeneratorTests.cs
@@ -161,6 +161,23 @@ public void RemovingAnEarlierChoicePreservesSelectionThroughUndoAndRedo()
         AssertTemplateState(editor, generator, viewModel, ["Two", "Three"], 1);
     }
 
+    [AvaloniaFact]
+    public void ReorderingTheSelectedChoiceIsUndoable()
+    {
+        var (editor, generator, viewModel) = CreateTemplate(
+            ["One", "Two", "Three"],
+            0);
+
+        viewModel.ReorderChoice("One", 3);
+        AssertTemplateState(editor, generator, viewModel, ["Two", "Three", "One"], 2);
+
+        editor.Undo();
+        AssertTemplateState(editor, generator, viewModel, ["One", "Two", "Three"], 0);
+
+        editor.Redo();
+        AssertTemplateState(editor, generator, viewModel, ["Two", "Three", "One"], 2);
+    }
+
     [AvaloniaTheory]
     [InlineData(1)]
     [InlineData(2)]
diff --git a/Tests/Behavior/TemplateFlyout/TemplateFlyoutChoiceDragDropTests.cs b/Tests/Behavior/TemplateFlyout/TemplateFlyoutChoiceDragDropTests.cs
new file mode 100644
index 0000000..5595f6f
--- /dev/null
+++ b/Tests/Behavior/TemplateFlyout/TemplateFlyoutChoiceDragDropTests.cs
@@ -0,0 +1,346 @@
+using System.Collections.ObjectModel;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Headless;
+using Avalonia.Headless.XUnit;
+using Avalonia.Input;
+using Avalonia.Input.Raw;
+using Avalonia.Threading;
+using Avalonia.VisualTree;
+using Inlay.ViewModels;
+using Xunit;
+
+namespace Inlay.Tests;
+
+public sealed class TemplateFlyoutChoiceDragDropTests
+{
+    [AvaloniaFact]
+    public void DroppingAChoicePastAnotherChoicesMidpointMovesItAfterThatChoice()
+    {
+        var options = new ObservableCollection<string>(["One", "Two", "Three"]);
+        var (window, view) = CreateView(options);
+        try
+        {
+            Drop(window, view, "One", Below(window, view, "Two"));
+
+            Assert.Equal(["Two", "One", "Three"], options);
+            Assert.Equal("One", view.OptionsList.SelectedItem);
+            Assert.True(FindChoiceItem(view, "One").IsSelected);
+        }
+        finally
+        {
+            window.Close();
+        }
+    }
+
+    [AvaloniaFact]
+    public void DroppingAChoiceBeforeAnotherChoicesMidpointMovesItAheadOfThatChoice()
+    {
+        var options = new ObservableCollection<string>(["One", "Two", "Three"]);
+        var (window, view) = CreateView(options);
+        try
+        {
+            Drop(window, view, "Three", Above(window, view, "One"));
+
+            Assert.Equal(["Three", "One", "Two"], options);
+        }
+        finally
+        {
+            window.Close();
+        }
+    }
+
+    [AvaloniaFact]
+    public void DragOverShowsDropIndicatorAndDragLeaveHidesIt()
+    {
+        var options = new ObservableCollection<string>(["One", "Two"]);
+        var (window, view) = CreateView(options);
+        try
+        {
+            using var transfer = CreateTransfer(view, "One");
+            var point = Below(window, view, "Two");
+
+            RaiseDrag(window, RawDragEventType.DragEnter, point, transfer);
+            RaiseDrag(window, RawDragEventType.DragOver, point, transfer);
+            Assert.True(view.ChoiceDropIndicator.IsVisible);
+
+            RaiseDrag(window, RawDragEventType.DragLeave, point, transfer);
+            Assert.False(view.ChoiceDropIndicator.IsVisible);
+        }
+        finally
+        {
+            window.Close();
+        }
+    }
+
+    [AvaloniaFact]
+    public void DraggingNearTheBottomStartsScrollingDownAndStopsOnLeave()
+    {
+        var choices = Enumerable.Range(1, 30).Select(index => $"Choice {index}").ToArray();
+        var (window, view) = CreateView(choices);
+        try
+        {
+            var scrollViewer = FindOptionsScrollViewer(view);
+            Assert.True(scrollViewer.Extent.Height > scrollViewer.Viewport.Height);
+            using var transfer = CreateTransfer(view, choices[0]);
+
+            var point = NearListEdge(window, view, bottom: true);
+            RaiseDrag(window, RawDragEventType.DragEnter, point, transfer);
+            RaiseDrag(window, RawDragEventType.DragOver, point, transfer);
+
+            Assert.True(scrollViewer.Offset.Y > 0);
+            Assert.True(view.IsAutoScrollingChoices);
+
+            RaiseDrag(window, RawDragEventType.DragLeave, point, transfer);
+            Assert.False(view.IsAutoScrollingChoices);
+        }
+        finally
+        {
+            window.Close();
+        }
+    }
+
+    [AvaloniaFact]
+    public void DraggingNearTheTopStartsScrollingUpAndStopsOnDrop()
+    {
+        var choices = Enumerable.Range(1, 30).Select(index => $"Choice {index}").ToArray();
+        var (window, view) = CreateView(choices);
+        try
+        {
+            var scrollViewer = FindOptionsScrollViewer(view);
+            var maximumOffset = scrollViewer.Extent.Height - scrollViewer.Viewport.Height;
+            Assert.True(maximumOffset > 0);
+            scrollViewer.Offset = scrollViewer.Offset.WithY(maximumOffset);
+            Settle(window);
+            using var transfer = CreateTransfer(view, choices[^1]);
+
+            var point = NearListEdge(window, view, bottom: false);
+            RaiseDrag(window, RawDragEventType.DragEnter, point, transfer);
+            RaiseDrag(window, RawDragEventType.DragOver, point, transfer);
+
+            Assert.True(scrollViewer.Offset.Y < maximumOffset);
+            Assert.True(view.IsAutoScrollingChoices);
+
+            RaiseDrag(window, RawDragEventType.Drop, point, transfer);
+            Assert.False(view.IsAutoScrollingChoices);
+        }
+        finally
+        {
+            window.Close();
+        }
+    }
+
+    [AvaloniaFact]
+    public void ReopeningTheFlyoutHighlightsTheReorderedChoice()
+    {
+        var options = new ObservableCollection<string>(["One", "Two", "Three"]);
+        var (window, view) = CreateView(options);
+        try
+        {
+            Drop(window, view, "One", Below(window, view, "Two"));
+
+            var oldViewModel = Assert.IsType<TemplateFlyoutViewModel>(view.DataContext);
+            oldViewModel.Disconnect();
+            view.DataContext = null;
+            view.DataContext = new TemplateFlyoutViewModel(options, 1, _ => { }, () => { });
+            Settle(window);
+
+            Assert.Equal("One", view.OptionsList.SelectedItem);
+            Assert.True(FindChoiceItem(view, "One").IsSelected);
+        }
+        finally
+        {
+            window.Close();
+        }
+    }
+
+    [AvaloniaFact]
+    public void DraggingAChoiceLeavesTheSelectedChoiceAlone()
+    {
+        var selections = new List<string>();
+        var options = new ObservableCollection<string>(["One", "Two", "Three"]);
+        var (window, view) = CreateView(options, selections);
+        try
+        {
+            var viewModel = Assert.IsType<TemplateFlyoutViewModel>(view.DataContext);
+            var start = Center(window, FindChoiceItem(view, "One"));
+
+            window.MouseDown(start, MouseButton.Left);
+            window.MouseMove(start + new Vector(0, 24));
+            window.MouseUp(start + new Vector(0, 24), MouseButton.Left);
+            Settle(window);
+
+            Assert.Equal("One", viewModel.SelectedChoice);
+            Assert.Equal("One", view.OptionsList.SelectedItem);
+            Assert.Empty(selections);
+        }
+        finally
+        {
+            window.Close();
+        }
+    }
+
+    [AvaloniaFact]
+    public void ClickingAChoiceSelectsItOnRelease()
+    {
+        var selections = new List<string>();
+        var options = new ObservableCollection<string>(["One", "Two", "Three"]);
+        var (window, view) = CreateView(options, selections);
+        try
+        {
+            var viewModel = Assert.IsType<TemplateFlyoutViewModel>(view.DataContext);
+            var point = Center(window, FindChoiceItem(view, "Two"));
+
+            window.MouseDown(point, MouseButton.Left);
+            Assert.Equal("One", viewModel.SelectedChoice);
+
+            window.MouseUp(point, MouseButton.Left);
+            Settle(window);
+
+            Assert.Equal("Two", viewModel.SelectedChoice);
+            Assert.Equal(["Two"], selections);
+        }
+        finally
+        {
+            window.Close();
+        }
+    }
+
+    [AvaloniaFact]
+    public void ClickingTheSelectedChoiceClearsIt()
+    {
+        var selections = new List<string>();
+        var options = new ObservableCollection<string>(["One", "Two", "Three"]);
+        var (window, view) = CreateView(options, selections);
+        try
+        {
+            var viewModel = Assert.IsType<TemplateFlyoutViewModel>(view.DataContext);
+            var point = Center(window, FindChoiceItem(view, "One"));
+
+            window.MouseDown(point, MouseButton.Left);
+            window.MouseUp(point, MouseButton.Left);
+            Settle(window);
+
+            Assert.Null(viewModel.SelectedChoice);
+            Assert.Equal([TemplateTextElement.PlaceholderText], selections);
+        }
+        finally
+        {
+            window.Close();
+        }
+    }
+
+    [AvaloniaFact]
+    public void AChoiceDragIsRejectedByAnotherFlyout()
+    {
+        var (sourceWindow, sourceView) = CreateView(["Source"]);
+        var (targetWindow, targetView) = CreateView(["Target"]);
+        try
+        {
+            var payload = new TemplateChoiceDragPayload
+            {
+                SourceView = sourceView,
+                SourceChoice = "Source"
+            };
+
+            Assert.True(sourceView.CanAcceptChoiceDrop(payload));
+            Assert.False(targetView.CanAcceptChoiceDrop(payload));
+        }
+        finally
+        {
+            sourceWindow.Close();
+            targetWindow.Close();
+        }
+    }
+
+    private static (Window Window, TemplateFlyoutView View) CreateView(
+        IEnumerable<string> choices,
+        List<string>? selections = null)
+    {
+        var options = choices as ObservableCollection<string> ?? [.. choices];
+        var viewModel = new TemplateFlyoutViewModel(
+            options,
+            0,
+            choice => selections?.Add(choice),
+            () => { });
+        var view = new TemplateFlyoutView { DataContext = viewModel };
+        var window = new Window { Content = view };
+        window.Show();
+        Settle(window);
+        return (window, view);
+    }
+
+    private static void Drop(
+        Window window,
+        TemplateFlyoutView view,
+        string choice,
+        Point point)
+    {
+        using var transfer = CreateTransfer(view, choice);
+        RaiseDrag(window, RawDragEventType.DragEnter, point, transfer);
+        RaiseDrag(window, RawDragEventType.DragOver, point, transfer);
+        RaiseDrag(window, RawDragEventType.Drop, point, transfer);
+        Settle(window);
+    }
+
+    private static DataTransfer CreateTransfer(TemplateFlyoutView view, string choice)
+    {
+        var transfer = new DataTransfer();
+        transfer.Add(DataTransferItem.Create(
+            TemplateChoiceDragPayload.Format,
+            new TemplateChoiceDragPayload { SourceView = view, SourceChoice = choice }));
+        return transfer;
+    }
+
+    private static void RaiseDrag(
+        Window window,
+        RawDragEventType type,
+        Point point,
+        DataTransfer transfer) =>
+        window.DragDrop(point, type, transfer, DragDropEffects.Move, RawInputModifiers.None);
+
+    private static Point Center(Window window, ListBoxItem item) =>
+        item.TranslatePoint(
+            new Point(item.Bounds.Width / 2, item.Bounds.Height / 2),
+            window)!.Value;
+
+    private static Point Above(Window window, TemplateFlyoutView view, string choice)
+    {
+        var item = FindChoiceItem(view, choice);
+        return item.TranslatePoint(
+            new Point(item.Bounds.Width / 2, 2),
+            window)!.Value;
+    }
+
+    private static Point Below(Window window, TemplateFlyoutView view, string choice)
+    {
+        var item = FindChoiceItem(view, choice);
+        return item.TranslatePoint(
+            new Point(item.Bounds.Width / 2, item.Bounds.Height - 2),
+            window)!.Value;
+    }
+
+    private static Point NearListEdge(
+        Window window,
+        TemplateFlyoutView view,
+        bool bottom) =>
+        view.OptionsList.TranslatePoint(
+            new Point(
+                view.OptionsList.Bounds.Width / 2,
+                bottom ? view.OptionsList.Bounds.Height - 2 : 2),
+            window)!.Value;
+
+    private static ScrollViewer FindOptionsScrollViewer(TemplateFlyoutView view) =>
+        Assert.Single(view.OptionsList.GetVisualDescendants().OfType<ScrollViewer>());
+
+    private static ListBoxItem FindChoiceItem(TemplateFlyoutView view, string choice) =>
+        Assert.Single(
+            view.GetVisualDescendants().OfType<ListBoxItem>(),
+            item => Equals(item.DataContext, choice));
+
+    private static void Settle(Window window)
+    {
+        window.UpdateLayout();
+        Dispatcher.UIThread.RunJobs();
+    }
+}
diff --git a/Tests/Behavior/TemplateFlyout/TemplateFlyoutLayoutAppearanceTests.cs b/Tests/Behavior/TemplateFlyout/TemplateFlyoutLayoutAppearanceTests.cs
index 1bf3349..c6445b1 100644
--- a/Tests/Behavior/TemplateFlyout/TemplateFlyoutLayoutAppearanceTests.cs
+++ b/Tests/Behavior/TemplateFlyout/TemplateFlyoutLayoutAppearanceTests.cs
@@ -27,14 +27,13 @@ public void LongOptionDoesNotChangeFlyoutWidth()
     public void OptionsListTracksWhetherChoicesExist()
     {
         var (template, content) = CreateTemplate([], -1);
-        var panel = Assert.IsType<StackPanel>(content);
-        var listBox = panel.Children.OfType<ListBox>().Single();
+        var listHost = content.FindControl<Panel>("OptionsListHost")!;
 
-        Assert.False(listBox.IsVisible);
+        Assert.False(listHost.IsVisible);
 
         template.Options.Add("Choice");
 
-        Assert.True(listBox.IsVisible);
+        Assert.True(listHost.IsVisible);
     }
 
     [AvaloniaFact]
diff --git a/Tests/Unit/ViewModels/TemplateFlyout/TemplateFlyoutViewModelTests.cs b/Tests/Unit/ViewModels/TemplateFlyout/TemplateFlyoutViewModelTests.cs
index fdf5d4b..73d8715 100644
--- a/Tests/Unit/ViewModels/TemplateFlyout/TemplateFlyoutViewModelTests.cs
+++ b/Tests/Unit/ViewModels/TemplateFlyout/TemplateFlyoutViewModelTests.cs
@@ -51,6 +51,37 @@ public void RemovingTheSelectedChoiceSelectsThePlaceholder()
         Assert.Equal(["One"], options);
     }
 
+    [Fact]
+    public void ReorderingAChoiceUsesDropSlotsAndKeepsTheSelectedChoice()
+    {
+        var selected = string.Empty;
+        var options = new ObservableCollection<string>(["One", "Two", "Three"]);
+        var viewModel = new TemplateFlyoutViewModel(
+            options,
+            1,
+            value => selected = value,
+            () => { });
+
+        viewModel.ReorderChoice("One", 3);
+
+        Assert.Equal(["Two", "Three", "One"], options);
+        Assert.Equal("Two", viewModel.SelectedChoice);
+        Assert.Equal(0, viewModel.SelectedIndex);
+        Assert.Equal("Two", selected);
+    }
+
+    [Fact]
+    public void ReorderingToAnAdjacentSlotLeavesTheOrderAlone()
+    {
+        var options = new ObservableCollection<string>(["One", "Two", "Three"]);
+        var viewModel = new TemplateFlyoutViewModel(options, 1, _ => { }, () => { });
+
+        viewModel.ReorderChoice("Two", 2);
+
+        Assert.Equal(["One", "Two", "Three"], options);
+        Assert.Equal("Two", viewModel.SelectedChoice);
+    }
+
     [Fact]
     public void RemoveTemplateCommandInvokesTheRemovalCallback()
     {
diff --git a/ViewModels/MainWindowViewModel.cs b/ViewModels/MainWindowViewModel.cs
index b391c35..298ab58 100644
--- a/ViewModels/MainWindowViewModel.cs
+++ b/ViewModels/MainWindowViewModel.cs
@@ -88,12 +88,7 @@ public void ReorderDocument(DocumentTabViewModel document, int targetSlot)
             return;
         }
 
-        // A slot is a gap between tabs, so a slot to the right of the tab being
-        // moved lands one index earlier once the tab leaves its current place.
-        var newIndex = Math.Clamp(
-            targetSlot > sourceIndex ? targetSlot - 1 : targetSlot,
-            0,
-            Documents.Count - 1);
+        var newIndex = DragReorder.SlotToIndex(targetSlot, sourceIndex, Documents.Count);
         if (newIndex != sourceIndex)
         {
             Documents.Move(sourceIndex, newIndex);
diff --git a/ViewModels/TemplateFlyoutViewModel.cs b/ViewModels/TemplateFlyoutViewModel.cs
index 6b89356..921a541 100644
--- a/ViewModels/TemplateFlyoutViewModel.cs
+++ b/ViewModels/TemplateFlyoutViewModel.cs
@@ -10,7 +10,9 @@ internal sealed partial class TemplateFlyoutViewModel : ReactiveObject
     private readonly Action<string> _selectOption;
     private readonly Action _removeTemplate;
     private string? _selectedChoice;
+    private (bool HasChoice, string? Choice) _heldSelection;
     private bool _isDisconnected;
+    private bool _isHoldingSelection;
 
     [Reactive(nameof(CanAddChoice))]
     private string _newChoice = string.Empty;
@@ -39,6 +41,12 @@ public string? SelectedChoice
         get => _selectedChoice;
         set
         {
+            if (_isHoldingSelection)
+            {
+                _heldSelection = (true, value);
+                return;
+            }
+
             if (_selectedChoice == value)
             {
                 return;
@@ -71,6 +79,28 @@ internal void SynchronizeSelectedIndex(int selectedIndex)
         this.RaisePropertyChanged(nameof(SelectedIndex));
     }
 
+    internal void BeginSelectionHold()
+    {
+        _isHoldingSelection = true;
+        _heldSelection = default;
+    }
+
+    internal void EndSelectionHold(bool applyHeldChoice)
+    {
+        if (!_isHoldingSelection)
+        {
+            return;
+        }
+
+        var (HasChoice, Choice) = _heldSelection;
+        _isHoldingSelection = false;
+        _heldSelection = default;
+        if (applyHeldChoice && HasChoice)
+        {
+            SelectedChoice = Choice;
+        }
+    }
+
     internal void SynchronizeOptions()
     {
         this.RaisePropertyChanged(nameof(HasOptions));
@@ -113,9 +143,40 @@ public void RemoveChoice(string choice)
         Options.RemoveAt(removedIndex);
     }
 
+    public void ReorderChoice(string choice, int targetSlot)
+    {
+        var sourceIndex = Options.IndexOf(choice);
+        if (sourceIndex < 0)
+        {
+            return;
+        }
+
+        var newIndex = DragReorder.SlotToIndex(targetSlot, sourceIndex, Options.Count);
+        if (newIndex != sourceIndex)
+        {
+            HoldSelection(() => Options.Move(sourceIndex, newIndex));
+        }
+    }
+
     [ReactiveCommand]
     private void RemoveTemplate() => _removeTemplate();
 
+    private void HoldSelection(Action action)
+    {
+        var wasHoldingSelection = _isHoldingSelection;
+        var heldSelection = _heldSelection;
+        _isHoldingSelection = true;
+        try
+        {
+            action();
+        }
+        finally
+        {
+            _isHoldingSelection = wasHoldingSelection;
+            _heldSelection = heldSelection;
+        }
+    }
+
     private void OnOptionsChanged(object? sender, NotifyCollectionChangedEventArgs e)
     {
         if (_selectedChoice is not null && !Options.Contains(_selectedChoice))
diff --git a/Views/MainWindow.axaml.cs b/Views/MainWindow.axaml.cs
index 44793e1..f9bfafa 100644
--- a/Views/MainWindow.axaml.cs
+++ b/Views/MainWindow.axaml.cs
@@ -3,6 +3,7 @@
 using Avalonia.Controls.Primitives;
 using Avalonia.Input;
 using Avalonia.Interactivity;
+using Avalonia.Layout;
 using Avalonia.Platform;
 using Avalonia.Styling;
 using Avalonia.Threading;
@@ -15,13 +16,9 @@ internal sealed partial class MainWindow : Window
 {
     private const double TabScrollStep = 96;
     private const double TabWheelScrollStep = 64;
-    private const double DragThreshold = 6;
+    private readonly DragCandidate<DocumentTabViewModel, TabStripItem> _dragCandidate = new();
     private bool _closeApproved;
     private bool _closePromptOpen;
-    private DocumentTabViewModel? _dragCandidate;
-    private TabStripItem? _dragCandidateItem;
-    private PointerPressedEventArgs? _dragTrigger;
-    private Point _dragStartPoint;
 
     internal MainWindowViewModel? ViewModel => DataContext as MainWindowViewModel;
 
@@ -222,48 +219,29 @@ private async void OnTabPointerPressed(object? sender, PointerPressedEventArgs e
             return;
         }
 
-        if (!properties.IsLeftButtonPressed || IsCloseButton(e.Source))
+        if (!properties.IsLeftButtonPressed ||
+            DragReorder.IsInButton(e.Source, "tab-close"))
         {
             return;
         }
 
-        if (FindTabItem(e.Source) is { DataContext: DocumentTabViewModel tab } tabItem)
+        if (DragReorder.FindContainer<TabStripItem>(e.Source) is
+            { DataContext: DocumentTabViewModel tab } tabItem)
         {
-            _dragCandidate = tab;
-            _dragCandidateItem = tabItem;
-            _dragTrigger = e;
-            _dragStartPoint = e.GetPosition(this);
+            _dragCandidate.Arm(tab, tabItem, e, e.GetPosition(this));
         }
     }
 
     private void OnWindowPointerMoved(object? sender, PointerEventArgs e)
     {
-        if (_dragCandidate is not { } tab ||
-            _dragCandidateItem is not { } tabItem ||
-            _dragTrigger is not { } trigger)
+        if (_dragCandidate.TryStart(e.GetPosition(this)) is { } candidate)
         {
-            return;
-        }
-
-        var delta = e.GetPosition(this) - _dragStartPoint;
-        if (Math.Abs(delta.X) < DragThreshold && Math.Abs(delta.Y) < DragThreshold)
-        {
-            return;
+            _ = StartTabDragAsync(candidate.Trigger, candidate.Item, candidate.Container);
         }
-
-        ClearDragCandidate();
-        _ = StartTabDragAsync(trigger, tab, tabItem);
     }
 
     private void OnWindowPointerReleased(object? sender, PointerReleasedEventArgs e) =>
-        ClearDragCandidate();
-
-    private void ClearDragCandidate()
-    {
-        _dragCandidate = null;
-        _dragCandidateItem = null;
-        _dragTrigger = null;
-    }
+        _dragCandidate.Clear();
 
     private async Task StartTabDragAsync(
         PointerPressedEventArgs trigger,
@@ -381,45 +359,24 @@ payload is not null &&
         ViewModel is { } viewModel &&
         (payload.SourceWindow == this || !viewModel.ContainsDocument(payload.SourceTab));
 
-    private static bool IsCloseButton(object? source) =>
-        source is Visual visual &&
-        (visual as Button ?? visual.FindAncestorOfType<Button>()) is { } button &&
-        button.Classes.Contains("tab-close");
-
-    private static TabStripItem? FindTabItem(object? source) =>
-        source is Visual visual
-            ? visual as TabStripItem ?? visual.FindAncestorOfType<TabStripItem>()
-            : null;
-
-    // Returns the gap the pointer sits in: 0 is before the first tab, Count is after the last.
-    private int CalculateTabDropIndex(Point pointInTabs)
-    {
-        var count = ViewModel?.Documents.Count ?? 0;
-        for (var index = 0; index < count; index++)
-        {
-            if (DocumentTabs.ContainerFromIndex(index) is Control container &&
-                container.TranslatePoint(new Point(0, 0), DocumentTabs) is { } origin &&
-                pointInTabs.X < origin.X + container.Bounds.Width / 2)
-            {
-                return index;
-            }
-        }
-
-        return count;
-    }
+    private int CalculateTabDropIndex(Point pointInTabs) => DragReorder.DropSlot(
+        DocumentTabs,
+        ViewModel?.Documents.Count ?? 0,
+        pointInTabs,
+        Orientation.Horizontal);
 
     private void ShowDropIndicator(int slot)
     {
-        var count = ViewModel?.Documents.Count ?? 0;
-        var isTrailingSlot = slot >= count;
-        if (DocumentTabs.ContainerFromIndex(isTrailingSlot ? count - 1 : slot) is not Control container ||
-            container.TranslatePoint(new Point(0, 0), DocumentTabs) is not { } origin)
+        if (DragReorder.SlotOffset(
+                DocumentTabs,
+                ViewModel?.Documents.Count ?? 0,
+                slot,
+                Orientation.Horizontal) is not { } x)
         {
             HideDropIndicator();
             return;
         }
 
-        var x = isTrailingSlot ? origin.X + container.Bounds.Width : origin.X;
         TabDropIndicator.Margin = new Thickness(Math.Max(0, x - 1), 0, 0, 0);
         TabDropIndicator.IsVisible = true;
     }
diff --git a/Views/TemplateFlyoutView.axaml b/Views/TemplateFlyoutView.axaml
index ec89dd7..51d1be5 100644
--- a/Views/TemplateFlyoutView.axaml
+++ b/Views/TemplateFlyoutView.axaml
@@ -4,51 +4,60 @@
              x:Class="Inlay.TemplateFlyoutView"
              x:DataType="vm:TemplateFlyoutViewModel">
   <StackPanel MinWidth="220" Width="220" MaxWidth="220" Spacing="4">
-    <ListBox x:Name="OptionsList"
-             Classes="themed-scrollbar persistent-scrollbar"
-             ItemsSource="{Binding Options}"
-             SelectedItem="{Binding SelectedChoice, Mode=TwoWay}"
-             IsVisible="{Binding HasOptions}"
-             SelectionMode="Single,Toggle"
-             MinWidth="220" Width="220" MaxWidth="220" MaxHeight="200"
-             HorizontalAlignment="Stretch"
-             ScrollViewer.HorizontalScrollBarVisibility="Disabled">
-      <ListBox.Styles>
-        <Style Selector="ListBoxItem">
-          <Setter Property="Padding" Value="0" />
-          <Setter Property="HorizontalContentAlignment" Value="Stretch" />
-        </Style>
-      </ListBox.Styles>
-      <ListBox.ItemTemplate>
-        <DataTemplate>
-          <Grid ColumnDefinitions="*,Auto">
-            <TextBlock Text="{Binding}" Margin="8,0"
-                       VerticalAlignment="Center" TextTrimming="CharacterEllipsis"
-                       TextWrapping="NoWrap" />
-            <Button Grid.Column="1"
-                    Classes="option-remove close-action"
-                    Width="24"
-                    Height="24"
-                    Padding="0"
-                    Margin="0,0,4,0"
-                    HorizontalContentAlignment="Center"
-                    VerticalContentAlignment="Center"
-                    ToolTip.Tip="Remove choice"
-                    AutomationProperties.Name="Remove choice"
-                    Click="RemoveOptionClicked">
-              <Path Classes="close-glyph"
-                    Width="10"
-                    Height="10"
-                    HorizontalAlignment="Center"
-                    VerticalAlignment="Center"
-                    Data="M 0,0 L 10,10 M 10,0 L 0,10"
-                    StrokeThickness="2"
-                    StrokeLineCap="Round" />
-            </Button>
-          </Grid>
-        </DataTemplate>
-      </ListBox.ItemTemplate>
-    </ListBox>
+    <Panel x:Name="OptionsListHost" IsVisible="{Binding HasOptions}">
+      <ListBox x:Name="OptionsList"
+               Classes="themed-scrollbar persistent-scrollbar"
+               ItemsSource="{Binding Options}"
+               SelectedItem="{Binding SelectedChoice, Mode=TwoWay}"
+               SelectionMode="Single,Toggle"
+               MinWidth="220" Width="220" MaxWidth="220" MaxHeight="200"
+               HorizontalAlignment="Stretch"
+               ScrollViewer.HorizontalScrollBarVisibility="Disabled">
+        <ListBox.Styles>
+          <Style Selector="ListBoxItem">
+            <Setter Property="Padding" Value="0" />
+            <Setter Property="HorizontalContentAlignment" Value="Stretch" />
+          </Style>
+        </ListBox.Styles>
+        <ListBox.ItemTemplate>
+          <DataTemplate>
+            <Grid ColumnDefinitions="*,Auto">
+              <TextBlock Text="{Binding}" Margin="8,0"
+                         VerticalAlignment="Center" TextTrimming="CharacterEllipsis"
+                         TextWrapping="NoWrap" />
+              <Button Grid.Column="1"
+                      Classes="option-remove close-action"
+                      Width="24"
+                      Height="24"
+                      Padding="0"
+                      Margin="0,0,4,0"
+                      HorizontalContentAlignment="Center"
+                      VerticalContentAlignment="Center"
+                      ToolTip.Tip="Remove choice"
+                      AutomationProperties.Name="Remove choice"
+                      Click="RemoveOptionClicked">
+                <Path Classes="close-glyph"
+                      Width="10"
+                      Height="10"
+                      HorizontalAlignment="Center"
+                      VerticalAlignment="Center"
+                      Data="M 0,0 L 10,10 M 10,0 L 0,10"
+                      StrokeThickness="2"
+                      StrokeLineCap="Round" />
+              </Button>
+            </Grid>
+          </DataTemplate>
+        </ListBox.ItemTemplate>
+      </ListBox>
+      <Border x:Name="ChoiceDropIndicator"
+              Height="2"
+              Background="{DynamicResource SystemControlHighlightAccentBrush}"
+              HorizontalAlignment="Stretch"
+              VerticalAlignment="Top"
+              IsVisible="False"
+              IsHitTestVisible="False"
+              ZIndex="10" />
+    </Panel>
     <Border Height="1" Margin="0,4"
             Background="{DynamicResource InlayShellBorderBrush}" />
     <TextBox x:Name="NewChoiceInput" Text="{Binding NewChoice, Mode=TwoWay}"
diff --git a/Views/TemplateFlyoutView.axaml.cs b/Views/TemplateFlyoutView.axaml.cs
index f9cd21e..e7f59c1 100644
--- a/Views/TemplateFlyoutView.axaml.cs
+++ b/Views/TemplateFlyoutView.axaml.cs
@@ -1,16 +1,83 @@
+using System.Collections.Specialized;
+using Avalonia;
 using Avalonia.Controls;
 using Avalonia.Input;
 using Avalonia.Interactivity;
+using Avalonia.Layout;
 using Avalonia.Threading;
+using Avalonia.VisualTree;
 using Inlay.ViewModels;
 
 namespace Inlay;
 
 internal sealed partial class TemplateFlyoutView : UserControl
 {
+    private const double AutoScrollEdgeSize = 24;
+    private const double AutoScrollStep = 12;
+    private static readonly TimeSpan AutoScrollInterval = TimeSpan.FromMilliseconds(50);
+    private readonly DragCandidate<string, ListBoxItem> _dragCandidate = new();
+    private readonly DispatcherTimer _autoScrollTimer;
+    private Point _lastDragPosition;
+    private int _autoScrollDirection;
+    private ScrollViewer? _choiceScrollViewer;
+    private TemplateFlyoutViewModel? _observedViewModel;
+
     public TemplateFlyoutView()
     {
         InitializeComponent();
+
+        _autoScrollTimer = new DispatcherTimer(DispatcherPriority.Input)
+        {
+            Interval = AutoScrollInterval
+        };
+        _autoScrollTimer.Tick += OnAutoScrollTick;
+
+        OptionsList.AddHandler(
+            PointerPressedEvent,
+            OnChoicePointerPressed,
+            RoutingStrategies.Tunnel,
+            handledEventsToo: true);
+
+        AddHandler(
+            PointerMovedEvent,
+            OnPointerMoved,
+            RoutingStrategies.Tunnel,
+            handledEventsToo: true);
+
+        AddHandler(
+            PointerReleasedEvent,
+            OnPointerReleased,
+            RoutingStrategies.Tunnel,
+            handledEventsToo: true);
+
+        DragDrop.SetAllowDrop(OptionsList, true);
+        OptionsList.AddHandler(DragDrop.DragOverEvent, OnChoiceDragOver);
+        OptionsList.AddHandler(DragDrop.DragLeaveEvent, OnChoiceDragLeave);
+        OptionsList.AddHandler(DragDrop.DropEvent, OnChoiceDrop);
+    }
+
+    protected override void OnDataContextChanged(EventArgs e)
+    {
+        base.OnDataContextChanged(e);
+        StopAutoScroll();
+
+        if (_observedViewModel is not null)
+        {
+            _observedViewModel.Options.CollectionChanged -= OnOptionsChanged;
+        }
+
+        _observedViewModel = DataContext as TemplateFlyoutViewModel;
+        if (_observedViewModel is not null)
+        {
+            _observedViewModel.Options.CollectionChanged += OnOptionsChanged;
+            ScheduleSelectionSynchronization(_observedViewModel);
+        }
+    }
+
+    protected override void OnDetachedFromVisualTree(VisualTreeAttachmentEventArgs e)
+    {
+        StopAutoScroll();
+        base.OnDetachedFromVisualTree(e);
     }
 
     private void RemoveOptionClicked(object? sender, RoutedEventArgs e)
@@ -36,4 +103,230 @@ private void NewChoiceKeyDown(object? sender, KeyEventArgs e)
 
     private void AddChoiceClicked(object? sender, RoutedEventArgs e) =>
         Dispatcher.UIThread.Post(() => NewChoiceInput.Focus());
+
+    private void OnOptionsChanged(object? sender, NotifyCollectionChangedEventArgs e)
+    {
+        if (e.Action == NotifyCollectionChangedAction.Move &&
+            _observedViewModel is { } viewModel)
+        {
+            ScheduleSelectionSynchronization(viewModel);
+        }
+    }
+
+    private void ScheduleSelectionSynchronization(TemplateFlyoutViewModel viewModel) =>
+        Dispatcher.UIThread.Post(
+            () =>
+            {
+                if (ReferenceEquals(DataContext, viewModel))
+                {
+                    OptionsList.SelectedItem = viewModel.SelectedChoice;
+                }
+            },
+            DispatcherPriority.Loaded);
+
+    private void OnChoicePointerPressed(object? sender, PointerPressedEventArgs e)
+    {
+        var properties = e.GetCurrentPoint(this).Properties;
+        if (!properties.IsLeftButtonPressed ||
+            DragReorder.IsInButton(e.Source, "option-remove") ||
+            DataContext is not TemplateFlyoutViewModel viewModel)
+        {
+            return;
+        }
+
+        if (DragReorder.FindContainer<ListBoxItem>(e.Source) is { DataContext: string choice } item)
+        {
+            _dragCandidate.Arm(choice, item, e, e.GetPosition(this));
+            viewModel.BeginSelectionHold();
+        }
+    }
+
+    private void OnPointerMoved(object? sender, PointerEventArgs e)
+    {
+        if (_dragCandidate.TryStart(e.GetPosition(this)) is not { } candidate)
+        {
+            return;
+        }
+
+        if (DataContext is TemplateFlyoutViewModel viewModel)
+        {
+            viewModel.EndSelectionHold(applyHeldChoice: false);
+            ScheduleSelectionSynchronization(viewModel);
+        }
+
+        _ = StartChoiceDragAsync(candidate.Trigger, candidate.Item, candidate.Container);
+    }
+
+    private void OnPointerReleased(object? sender, PointerReleasedEventArgs e)
+    {
+        _dragCandidate.Clear();
+        (DataContext as TemplateFlyoutViewModel)?.EndSelectionHold(applyHeldChoice: true);
+    }
+
+    private async Task StartChoiceDragAsync(
+        PointerPressedEventArgs trigger,
+        string choice,
+        ListBoxItem item)
+    {
+        using var dataTransfer = new DataTransfer();
+        dataTransfer.Add(DataTransferItem.Create(
+            TemplateChoiceDragPayload.Format,
+            new TemplateChoiceDragPayload { SourceView = this, SourceChoice = choice }));
+
+        item.Opacity = 0.5;
+        try
+        {
+            await DragDrop.DoDragDropAsync(trigger, dataTransfer, DragDropEffects.Move);
+        }
+        catch (Exception exception) when (exception is not OutOfMemoryException)
+        {
+            // The platform refused to start a drag; the choice stays where it is.
+        }
+        finally
+        {
+            item.Opacity = 1;
+            StopAutoScroll();
+            HideDropIndicator();
+        }
+    }
+
+    private void OnChoiceDragOver(object? sender, DragEventArgs e)
+    {
+        if (e.DataTransfer.TryGetValue(TemplateChoiceDragPayload.Format) is not { } payload ||
+            !CanAcceptChoiceDrop(payload))
+        {
+            e.DragEffects = DragDropEffects.None;
+            StopAutoScroll();
+            HideDropIndicator();
+            return;
+        }
+
+        var pointInList = e.GetPosition(OptionsList);
+        e.DragEffects = DragDropEffects.Move;
+        ShowDropIndicator(CalculateChoiceDropIndex(pointInList));
+        UpdateAutoScroll(pointInList);
+        e.Handled = true;
+    }
+
+    private void OnChoiceDragLeave(object? sender, DragEventArgs e)
+    {
+        StopAutoScroll();
+        HideDropIndicator();
+    }
+
+    private void OnChoiceDrop(object? sender, DragEventArgs e)
+    {
+        StopAutoScroll();
+        HideDropIndicator();
+        if (e.DataTransfer.TryGetValue(TemplateChoiceDragPayload.Format) is not { } payload ||
+            !CanAcceptChoiceDrop(payload) ||
+            DataContext is not TemplateFlyoutViewModel viewModel)
+        {
+            e.DragEffects = DragDropEffects.None;
+            return;
+        }
+
+        viewModel.ReorderChoice(
+            payload.SourceChoice,
+            CalculateChoiceDropIndex(e.GetPosition(OptionsList)));
+        e.DragEffects = DragDropEffects.Move;
+        e.Handled = true;
+    }
+
+    private void UpdateAutoScroll(Point pointInList)
+    {
+        _lastDragPosition = pointInList;
+        var edgeSize = Math.Min(AutoScrollEdgeSize, OptionsList.Bounds.Height / 2);
+        var direction = pointInList.Y <= edgeSize
+            ? -1
+            : pointInList.Y >= OptionsList.Bounds.Height - edgeSize
+                ? 1
+                : 0;
+
+        if (direction == 0)
+        {
+            StopAutoScroll();
+            return;
+        }
+
+        _autoScrollDirection = direction;
+        if (!_autoScrollTimer.IsEnabled && ScrollChoiceList())
+        {
+            _autoScrollTimer.Start();
+        }
+    }
+
+    private void OnAutoScrollTick(object? sender, EventArgs e)
+    {
+        if (!ScrollChoiceList())
+        {
+            StopAutoScroll();
+        }
+    }
+
+    private bool ScrollChoiceList()
+    {
+        var scrollViewer = _choiceScrollViewer ??= OptionsList.FindDescendantOfType<ScrollViewer>();
+        if (scrollViewer is null)
+        {
+            return false;
+        }
+
+        var maximumOffset = Math.Max(0, scrollViewer.Extent.Height - scrollViewer.Viewport.Height);
+        var newOffset = Math.Clamp(
+            scrollViewer.Offset.Y + _autoScrollDirection * AutoScrollStep,
+            0,
+            maximumOffset);
+        if (Math.Abs(newOffset - scrollViewer.Offset.Y) < 0.5)
+        {
+            return false;
+        }
+
+        scrollViewer.Offset = scrollViewer.Offset.WithY(newOffset);
+        OptionsList.UpdateLayout();
+        ShowDropIndicator(CalculateChoiceDropIndex(_lastDragPosition));
+        return true;
+    }
+
+    private void StopAutoScroll()
+    {
+        _autoScrollTimer.Stop();
+        _autoScrollDirection = 0;
+    }
+
+    internal bool IsAutoScrollingChoices => _autoScrollTimer.IsEnabled;
+
+    internal bool CanAcceptChoiceDrop(TemplateChoiceDragPayload? payload) =>
+        payload is not null &&
+        payload.SourceView == this &&
+        DataContext is TemplateFlyoutViewModel viewModel &&
+        viewModel.Options.Contains(payload.SourceChoice);
+
+    private int ChoiceCount => (DataContext as TemplateFlyoutViewModel)?.Options.Count ?? 0;
+
+    private int CalculateChoiceDropIndex(Point pointInList) => DragReorder.DropSlot(
+        OptionsList,
+        ChoiceCount,
+        pointInList,
+        Orientation.Vertical);
+
+    private void ShowDropIndicator(int slot)
+    {
+        if (DragReorder.SlotOffset(
+                OptionsList,
+                ChoiceCount,
+                slot,
+                Orientation.Vertical,
+                relativeTo: OptionsListHost) is not { } y)
+        {
+            HideDropIndicator();
+            return;
+        }
+
+        var maximumY = Math.Max(0, OptionsListHost.Bounds.Height - ChoiceDropIndicator.Height);
+        ChoiceDropIndicator.Margin = new Thickness(4, Math.Clamp(y - 1, 0, maximumY), 4, 0);
+        ChoiceDropIndicator.IsVisible = true;
+    }
+
+    private void HideDropIndicator() => ChoiceDropIndicator.IsVisible = false;
 }