diff --git a/Flow.Launcher.Infrastructure/UserSettings/Settings.cs b/Flow.Launcher.Infrastructure/UserSettings/Settings.cs
index fd535f21a6e..be5fcff9af0 100644
--- a/Flow.Launcher.Infrastructure/UserSettings/Settings.cs
+++ b/Flow.Launcher.Infrastructure/UserSettings/Settings.cs
@@ -423,6 +423,12 @@ public DoublePinyinSchemas DoublePinyinSchema
 
         public bool AlwaysPreview { get; set; } = false;
 
+        /// <summary>
+        /// Name of the syntax-highlighting theme used for code blocks in the markdown preview.
+        /// "Auto" follows the app colour scheme (light/dark); otherwise a <see cref="CodeHighlightThemes"/> name.
+        /// </summary>
+        public string CodeHighlightTheme { get; set; } = "Auto";
+
         public bool AlwaysStartEn { get; set; } = false;
 
         private SearchPrecisionScore _querySearchPrecision = SearchPrecisionScore.Regular;
@@ -696,6 +702,15 @@ public enum ColorSchemes
         Dark
     }
 
+    public enum CodeHighlightThemes
+    {
+        Auto,
+        VSCodeLight,
+        VSCodeDarkPlus,
+        CatppuccinMacchiato,
+        OneDark
+    }
+
     public enum SearchWindowScreens
     {
         RememberLastLaunchLocation,
diff --git a/Flow.Launcher.Plugin/Result.cs b/Flow.Launcher.Plugin/Result.cs
index 9404d110705..6a0542ebd1d 100644
--- a/Flow.Launcher.Plugin/Result.cs
+++ b/Flow.Launcher.Plugin/Result.cs
@@ -287,6 +287,18 @@ public string PluginDirectory
         /// </summary>
         public PreviewInfo Preview { get; set; } = PreviewInfo.Default;
 
+        /// <summary>
+        /// Controls whether Flow Launcher's preview pane is shown for this result.
+        /// </summary>
+        /// <remarks>
+        /// This is independent of <see cref="PreviewInfo.ContentType"/>, which only decides how the
+        /// preview is rendered. Use this to force the pane open (for example a result whose whole purpose
+        /// is its markdown preview) or to hide it on results that have nothing useful to preview.
+        /// </remarks>
+        /// <default><see cref="Flow.Launcher.Plugin.PreviewVisibility.Default"/></default>
+        [JsonConverter(typeof(JsonStringEnumConverter<PreviewVisibility>))]
+        public PreviewVisibility PreviewVisibility { get; set; } = PreviewVisibility.Default;
+
         /// <summary>
         /// Determines if the user selection count should be added to the score. This can be useful when set to false to allow the result sequence order to be the same everytime instead of changing based on selection.
         /// </summary>
@@ -365,6 +377,7 @@ public Result Clone()
                 ProgressBar = ProgressBar,
                 ProgressBarColor = ProgressBarColor,
                 Preview = Preview,
+                PreviewVisibility = PreviewVisibility,
                 AddSelectedCount = AddSelectedCount,
                 RecordKey = RecordKey,
                 ShowBadge = ShowBadge,
@@ -378,7 +391,7 @@ public Result Clone()
         public record PreviewInfo
         {
             /// <summary>
-            /// Full image used for preview panel
+            /// Shown in the preview panel. Falls back to the result icon when not set. 
             /// </summary>
             public string PreviewImagePath { get; set; } = null;
 
@@ -388,7 +401,8 @@ public record PreviewInfo
             public bool IsMedia { get; set; } = false;
 
             /// <summary>
-            /// Result description text that is shown at the bottom of the preview panel.
+            /// Text shown in the preview panel. How it is displayed depends on
+            /// <see cref="ContentType"/>.
             /// </summary>
             /// <remarks>
             /// When a value is not set, the <see cref="SubTitle"/> will be used.
@@ -406,6 +420,12 @@ public record PreviewInfo
             /// </summary>
             public string FilePath { get; set; } = null;
 
+            /// <summary>
+            /// Controls the preview rendering mode. See <see cref="PreviewContentType"/>.
+            /// </summary>
+            [JsonConverter(typeof(JsonStringEnumConverter<PreviewContentType>))]
+            public PreviewContentType ContentType { get; set; } = PreviewContentType.ImageWithText;
+
             /// <summary>
             /// Default instance of <see cref="PreviewInfo"/>
             /// </summary>
@@ -416,7 +436,52 @@ public record PreviewInfo
                 IsMedia = false,
                 PreviewDelegate = null,
                 FilePath = null,
+                ContentType = PreviewContentType.ImageWithText,
             };
         }
     }
+
+    /// <summary>
+    /// Supported preview description rendering modes.
+    /// </summary>
+    public enum PreviewContentType
+    {
+        /// <summary>
+        /// Shows the preview image above the result title, with the description
+        /// rendered as plain text below a separator.
+        /// </summary>
+        [JsonStringEnumMemberName("imageWithText")]
+        ImageWithText,
+
+        /// <summary>
+        /// Shows a scrollable panel with the description rendered as formatted markdown.
+        /// </summary>
+        [JsonStringEnumMemberName("markdown")]
+        Markdown,
+    }
+
+    /// <summary>
+    /// Controls whether the preview pane is shown for a <see cref="Result"/>.
+    /// </summary>
+    public enum PreviewVisibility
+    {
+        /// <summary>
+        /// Follow Flow Launcher's normal preview behaviour (the global "Always Preview" setting and the
+        /// user's manual preview toggle decide whether the pane is shown).
+        /// </summary>
+        [JsonStringEnumMemberName("default")]
+        Default,
+
+        /// <summary>
+        /// Never show the preview pane for this result, even when the global "Always Preview" setting is on.
+        /// </summary>
+        [JsonStringEnumMemberName("never")]
+        Never,
+
+        /// <summary>
+        /// Always show the preview pane for this result, even when the global "Always Preview" setting is off.
+        /// </summary>
+        [JsonStringEnumMemberName("always")]
+        Always,
+    }
 }
diff --git a/Flow.Launcher.Test/CodeHighlightThemeTest.cs b/Flow.Launcher.Test/CodeHighlightThemeTest.cs
new file mode 100644
index 00000000000..5e4a25144b3
--- /dev/null
+++ b/Flow.Launcher.Test/CodeHighlightThemeTest.cs
@@ -0,0 +1,58 @@
+using Flow.Launcher.Resources.Controls;
+using NUnit.Framework;
+using NUnit.Framework.Legacy;
+
+namespace Flow.Launcher.Test
+{
+    [TestFixture]
+    internal class CodeHighlightThemeTest
+    {
+        private string _savedThemeName;
+
+        [SetUp]
+        public void SetUp() => _savedThemeName = PreviewMarkdownScrollViewer.ActiveThemeName;
+
+        [TearDown]
+        public void TearDown() => PreviewMarkdownScrollViewer.ApplyCodeHighlightTheme(_savedThemeName, isDark: true);
+
+        [Test]
+        public void GivenAutoSetting_WhenAppIsDark_ThenActiveThemeIsADarkTheme()
+        {
+            PreviewMarkdownScrollViewer.ApplyCodeHighlightTheme("Auto", isDark: true);
+
+            ClassicAssert.AreEqual("VS Code Dark+", PreviewMarkdownScrollViewer.ActiveThemeName);
+        }
+
+        [Test]
+        public void GivenAutoSetting_WhenAppIsLight_ThenActiveThemeIsALightTheme()
+        {
+            PreviewMarkdownScrollViewer.ApplyCodeHighlightTheme("Auto", isDark: false);
+
+            ClassicAssert.AreEqual("VS Code Light", PreviewMarkdownScrollViewer.ActiveThemeName);
+        }
+
+        [Test]
+        public void GivenExplicitTheme_WhenApplied_ThenActiveThemeMatchesRegardlessOfAppScheme()
+        {
+            PreviewMarkdownScrollViewer.ApplyCodeHighlightTheme("OneDark", isDark: false);
+
+            ClassicAssert.AreEqual("One Dark", PreviewMarkdownScrollViewer.ActiveThemeName);
+        }
+
+        [Test]
+        public void GivenEmptySetting_WhenApplied_ThenFallsBackToAutoBehaviour()
+        {
+            PreviewMarkdownScrollViewer.ApplyCodeHighlightTheme("", isDark: false);
+
+            ClassicAssert.AreEqual("VS Code Light", PreviewMarkdownScrollViewer.ActiveThemeName);
+        }
+
+        [Test]
+        public void GivenUnrecognisedSetting_WhenApplied_ThenFallsBackToAutoBehaviour()
+        {
+            PreviewMarkdownScrollViewer.ApplyCodeHighlightTheme("BogusTheme", isDark: true);
+
+            ClassicAssert.AreEqual("VS Code Dark+", PreviewMarkdownScrollViewer.ActiveThemeName);
+        }
+    }
+}
diff --git a/Flow.Launcher.Test/MainViewModelPreviewTest.cs b/Flow.Launcher.Test/MainViewModelPreviewTest.cs
new file mode 100644
index 00000000000..c4cbc558ba3
--- /dev/null
+++ b/Flow.Launcher.Test/MainViewModelPreviewTest.cs
@@ -0,0 +1,320 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Threading.Tasks;
+using Flow.Launcher.Infrastructure.UserSettings;
+using Flow.Launcher.Plugin;
+using Flow.Launcher.ViewModel;
+using NUnit.Framework;
+using NUnit.Framework.Legacy;
+
+namespace Flow.Launcher.Test
+{
+    [TestFixture]
+    internal class MainViewModelPreviewTest
+    {
+        [Test]
+        public async Task GivenManualOverrideTrue_WhenNeverThenDefaultResultSelected_ThenInternalPreviewIsRestoredAsync()
+        {
+            var settings = new Settings
+            {
+                AlwaysPreview = false
+            };
+            var viewModel = CreatePreviewViewModel(settings, ResultAreaColumnPreviewShown);
+            SetManualPreviewOverride(viewModel, true);
+
+            viewModel.PreviewSelectedItem = ViewModel("Never", PreviewVisibility.Never, settings);
+            await InvokeUpdatePreviewAsync(viewModel);
+            ClassicAssert.IsFalse(viewModel.InternalPreviewVisible);
+
+            viewModel.PreviewSelectedItem = ViewModel("Normal", PreviewVisibility.Default, settings);
+            await InvokeUpdatePreviewAsync(viewModel);
+
+            ClassicAssert.IsTrue(viewModel.InternalPreviewVisible);
+        }
+
+        [Test]
+        public async Task GivenManualOverrideTrueAndExternalPreviewVisible_WhenNeverThenDefaultResultSelected_ThenPreviewIsRestoredAsync()
+        {
+            var settings = new Settings
+            {
+                AlwaysPreview = false
+            };
+            var viewModel = CreatePreviewViewModel(settings, ResultAreaColumnPreviewHidden);
+            SetExternalPreviewVisible(viewModel, true);
+            SetManualPreviewOverride(viewModel, true);
+
+            viewModel.PreviewSelectedItem = ViewModel("Never", PreviewVisibility.Never, settings);
+            await InvokeUpdatePreviewAsync(viewModel);
+            ClassicAssert.IsFalse(viewModel.ExternalPreviewVisible);
+            ClassicAssert.IsFalse(viewModel.InternalPreviewVisible);
+
+            viewModel.PreviewSelectedItem = ViewModel("Normal", PreviewVisibility.Default, settings);
+            await InvokeUpdatePreviewAsync(viewModel);
+
+            ClassicAssert.IsTrue(viewModel.InternalPreviewVisible);
+        }
+
+        [Test]
+        public async Task GivenPreviewHidden_WhenAlwaysVisibilityResultSelected_ThenInternalPreviewAutoOpensAsync()
+        {
+            var settings = new Settings
+            {
+                AlwaysPreview = false
+            };
+            var viewModel = CreatePreviewViewModel(settings, ResultAreaColumnPreviewHidden);
+
+            viewModel.PreviewSelectedItem = ViewModel("Forced", PreviewVisibility.Always, settings);
+            await InvokeUpdatePreviewAsync(viewModel);
+
+            ClassicAssert.IsTrue(viewModel.InternalPreviewVisible);
+        }
+
+        [Test]
+        public async Task GivenPreviewHidden_WhenMarkdownResultWithDefaultVisibilitySelected_ThenInternalPreviewStaysHiddenAsync()
+        {
+            // Content type only controls rendering; it must not force the pane open.
+            // Forcing is the job of PreviewVisibility.Always.
+            var settings = new Settings
+            {
+                AlwaysPreview = false
+            };
+            var viewModel = CreatePreviewViewModel(settings, ResultAreaColumnPreviewHidden);
+
+            viewModel.PreviewSelectedItem =
+                ViewModel("Markdown", PreviewVisibility.Default, settings, PreviewContentType.Markdown);
+            await InvokeUpdatePreviewAsync(viewModel);
+
+            ClassicAssert.IsFalse(viewModel.InternalPreviewVisible);
+        }
+
+        [Test]
+        public async Task GivenAlwaysResultSelected_WhenDefaultResultSelected_ThenInternalPreviewAutoClosesAsync()
+        {
+            var settings = new Settings
+            {
+                AlwaysPreview = false
+            };
+            var viewModel = CreatePreviewViewModel(settings, ResultAreaColumnPreviewHidden);
+
+            viewModel.PreviewSelectedItem = ViewModel("Forced", PreviewVisibility.Always, settings);
+            await InvokeUpdatePreviewAsync(viewModel);
+            ClassicAssert.IsTrue(viewModel.InternalPreviewVisible);
+
+            viewModel.PreviewSelectedItem = ViewModel("Normal", PreviewVisibility.Default, settings);
+            await InvokeUpdatePreviewAsync(viewModel);
+
+            ClassicAssert.IsFalse(viewModel.InternalPreviewVisible);
+        }
+
+        [Test]
+        public async Task GivenManualOverrideTrue_WhenDefaultResultSelected_ThenInternalPreviewStaysVisibleAsync()
+        {
+            var settings = new Settings
+            {
+                AlwaysPreview = false
+            };
+            var viewModel = CreatePreviewViewModel(settings, ResultAreaColumnPreviewShown);
+            SetManualPreviewOverride(viewModel, true);
+
+            viewModel.PreviewSelectedItem = ViewModel("Normal", PreviewVisibility.Default, settings);
+            await InvokeUpdatePreviewAsync(viewModel);
+
+            ClassicAssert.IsTrue(viewModel.InternalPreviewVisible);
+        }
+
+        [Test]
+        public async Task GivenAlwaysResultThenNever_WhenNormalResultSelected_ThenInternalPreviewStaysHiddenAsync()
+        {
+            var settings = new Settings
+            {
+                AlwaysPreview = false
+            };
+            var viewModel = CreatePreviewViewModel(settings, ResultAreaColumnPreviewHidden);
+
+            viewModel.PreviewSelectedItem = ViewModel("Forced", PreviewVisibility.Always, settings);
+            await InvokeUpdatePreviewAsync(viewModel);
+            ClassicAssert.IsTrue(viewModel.InternalPreviewVisible);
+
+            viewModel.PreviewSelectedItem = ViewModel("Never", PreviewVisibility.Never, settings);
+            await InvokeUpdatePreviewAsync(viewModel);
+            ClassicAssert.IsFalse(viewModel.InternalPreviewVisible);
+
+            viewModel.PreviewSelectedItem = ViewModel("Normal", PreviewVisibility.Default, settings);
+            await InvokeUpdatePreviewAsync(viewModel);
+
+            ClassicAssert.IsFalse(viewModel.InternalPreviewVisible);
+        }
+
+        [Test]
+        public async Task GivenManualOverrideFalseAndAlwaysPreviewOn_WhenDefaultResultSelected_ThenInternalPreviewStaysHiddenAsync()
+        {
+            // User closed the preview with F1 (_manualPreviewOverride = false) while
+            // AlwaysPreview is on. The manual override should still beat AlwaysPreview
+            // so selecting a normal result does not reopen the pane.
+            var settings = new Settings
+            {
+                AlwaysPreview = true
+            };
+            var viewModel = CreatePreviewViewModel(settings, ResultAreaColumnPreviewHidden);
+            SetManualPreviewOverride(viewModel, false);
+
+            viewModel.PreviewSelectedItem = ViewModel("Normal", PreviewVisibility.Default, settings);
+            await InvokeUpdatePreviewAsync(viewModel);
+
+            ClassicAssert.IsFalse(viewModel.InternalPreviewVisible);
+        }
+
+        [Test]
+        public async Task GivenAlwaysPreviewOnAndPreviewHidden_WhenNeverThenDefaultResultSelected_ThenInternalPreviewReopensAsync()
+        {
+            var settings = new Settings
+            {
+                AlwaysPreview = true
+            };
+            var viewModel = CreatePreviewViewModel(settings, ResultAreaColumnPreviewHidden);
+
+            viewModel.PreviewSelectedItem = ViewModel("Never", PreviewVisibility.Never, settings);
+            await InvokeUpdatePreviewAsync(viewModel);
+            ClassicAssert.IsFalse(viewModel.InternalPreviewVisible);
+
+            viewModel.PreviewSelectedItem = ViewModel("Normal", PreviewVisibility.Default, settings);
+            await InvokeUpdatePreviewAsync(viewModel);
+
+            ClassicAssert.IsTrue(viewModel.InternalPreviewVisible);
+        }
+
+        [Test]
+        public async Task GivenManualOverrideFalseAndAlwaysPreviewOn_WhenAlwaysResultSelected_ThenInternalPreviewReopensAsync()
+        {
+            // Always must force the pane open even when the user explicitly closed
+            // the preview with F1. Result-level visibility beats manual override.
+            var settings = new Settings
+            {
+                AlwaysPreview = true
+            };
+            var viewModel = CreatePreviewViewModel(settings, ResultAreaColumnPreviewHidden);
+            SetManualPreviewOverride(viewModel, false);
+
+            viewModel.PreviewSelectedItem = ViewModel("Normal", PreviewVisibility.Default, settings);
+            await InvokeUpdatePreviewAsync(viewModel);
+            ClassicAssert.IsFalse(viewModel.InternalPreviewVisible);
+
+            viewModel.PreviewSelectedItem = ViewModel("Forced", PreviewVisibility.Always, settings);
+            await InvokeUpdatePreviewAsync(viewModel);
+
+            ClassicAssert.IsTrue(viewModel.InternalPreviewVisible);
+        }
+
+        [Test]
+        public async Task GivenManualOverrideUnsetAndAlwaysPreviewOffAndAlwaysResult_WhenPreviewReset_ThenInternalPreviewOpens()
+        {
+            // ResetPreviewAsync clears _manualPreviewOverride (sets to null) and re-evaluates.
+            // With AlwaysPreview off but the result forcing its own preview (Always),
+            // the pane should open when the window reopens.
+            var settings = new Settings
+            {
+                AlwaysPreview = false
+            };
+            var viewModel = CreatePreviewViewModel(settings, ResultAreaColumnPreviewHidden);
+            viewModel.PreviewSelectedItem = ViewModel("Forced", PreviewVisibility.Always, settings);
+
+            await viewModel.ResetPreviewAsync();
+
+            ClassicAssert.IsTrue(viewModel.InternalPreviewVisible);
+        }
+
+        [Test]
+        public async Task GivenManualOverrideUnsetAndAlwaysPreviewOffAndDefaultResult_WhenPreviewReset_ThenInternalPreviewStaysHidden()
+        {
+            var settings = new Settings
+            {
+                AlwaysPreview = false
+            };
+            var viewModel = CreatePreviewViewModel(settings, ResultAreaColumnPreviewShown);
+            viewModel.PreviewSelectedItem = ViewModel("Normal", PreviewVisibility.Default, settings);
+
+            await viewModel.ResetPreviewAsync();
+
+            ClassicAssert.IsFalse(viewModel.InternalPreviewVisible);
+        }
+
+        [Test]
+        public async Task GivenManualOverrideFalseAndAlwaysPreviewOn_WhenNeverThenDefaultResult_ThenPreviewStaysHiddenAsync()
+        {
+            // Regression: user closes preview via F1 (_manualOverride = false),
+            // navigates through a Never result, then to a normal result.
+            // The AlwaysPreview restore path must not re-open the pane against
+            // the user's explicit intent.
+            var settings = new Settings
+            {
+                AlwaysPreview = true
+            };
+            var viewModel = CreatePreviewViewModel(settings, ResultAreaColumnPreviewHidden);
+            SetManualPreviewOverride(viewModel, false);
+
+            viewModel.PreviewSelectedItem = ViewModel("Never", PreviewVisibility.Never, settings);
+            await InvokeUpdatePreviewAsync(viewModel);
+            ClassicAssert.IsFalse(viewModel.InternalPreviewVisible);
+
+            viewModel.PreviewSelectedItem = ViewModel("Normal", PreviewVisibility.Default, settings);
+            await InvokeUpdatePreviewAsync(viewModel);
+
+            ClassicAssert.IsFalse(viewModel.InternalPreviewVisible);
+        }
+
+        private static MainViewModel CreatePreviewViewModel(Settings settings, int resultAreaColumn)
+        {
+            var viewModel = (MainViewModel)RuntimeHelpers.GetUninitializedObject(typeof(MainViewModel));
+            typeof(MainViewModel)
+                .GetField("<Settings>k__BackingField", BindingFlags.Instance | BindingFlags.NonPublic)
+                .SetValue(viewModel, settings);
+            viewModel.ResultAreaColumn = resultAreaColumn;
+            return viewModel;
+        }
+
+        private static ResultViewModel ViewModel(
+            string title,
+            PreviewVisibility visibility,
+            Settings settings,
+            PreviewContentType contentType = PreviewContentType.ImageWithText)
+            => new(
+                new Result
+                {
+                    Title = title,
+                    PreviewVisibility = visibility,
+                    Preview = new Result.PreviewInfo
+                    {
+                        ContentType = contentType
+                    }
+                },
+                settings);
+
+        private static int ResultAreaColumnPreviewShown
+            => (int)typeof(MainViewModel)
+                .GetField("ResultAreaColumnPreviewShown", BindingFlags.NonPublic | BindingFlags.Static)
+                .GetValue(null);
+
+        private static int ResultAreaColumnPreviewHidden
+            => (int)typeof(MainViewModel)
+                .GetField("ResultAreaColumnPreviewHidden", BindingFlags.NonPublic | BindingFlags.Static)
+                .GetValue(null);
+
+        private static async Task InvokeUpdatePreviewAsync(MainViewModel viewModel)
+        {
+            var task = (Task)typeof(MainViewModel)
+                .GetMethod("UpdatePreviewAsync", BindingFlags.NonPublic | BindingFlags.Instance)
+                .Invoke(viewModel, null);
+            await task;
+        }
+
+        private static void SetExternalPreviewVisible(MainViewModel viewModel, bool visible)
+            => typeof(MainViewModel)
+                .GetField("<ExternalPreviewVisible>k__BackingField", BindingFlags.Instance | BindingFlags.NonPublic)
+                .SetValue(viewModel, visible);
+
+        private static void SetManualPreviewOverride(MainViewModel viewModel, bool? value)
+            => typeof(MainViewModel)
+                .GetField("_manualPreviewOverride", BindingFlags.Instance | BindingFlags.NonPublic)
+                .SetValue(viewModel, value);
+    }
+}
diff --git a/Flow.Launcher.Test/Plugins/JsonRPCPluginTest.cs b/Flow.Launcher.Test/Plugins/JsonRPCPluginTest.cs
index 497f874e70f..94d8c8d5153 100644
--- a/Flow.Launcher.Test/Plugins/JsonRPCPluginTest.cs
+++ b/Flow.Launcher.Test/Plugins/JsonRPCPluginTest.cs
@@ -7,6 +7,7 @@
 using System.Threading;
 using System.Text;
 using System.Collections.Generic;
+using System.Linq;
 
 namespace Flow.Launcher.Test.Plugins
 {
@@ -61,5 +62,120 @@ public async Task GivenVariousJsonText_WhenVariousNamingCase_ThenExpectNotNullRe
                 }
             })
         };
+
+        [Test]
+        public async Task GivenMarkdownPreviewContentType_WhenDeserializeJsonRpcResult_ThenPreviewContentTypeIsMarkdown()
+        {
+            const string resultText =
+                """
+                {
+                  "result": [
+                    {
+                      "title": "Answer",
+                      "subTitle": "*args in Python",
+                      "preview": {
+                        "description": "**`*args`** collects extra positional arguments.",
+                        "contentType": "markdown"
+                      }
+                    }
+                  ],
+                  "debugMessage": null
+                }
+                """;
+
+            var results = await QueryAsync(new Query
+            {
+                Search = resultText
+            }, default);
+
+            var result = results.Single();
+
+            ClassicAssert.AreEqual(PreviewContentType.Markdown, result.Preview.ContentType);
+            ClassicAssert.AreEqual("**`*args`** collects extra positional arguments.", result.Preview.Description);
+        }
+
+        [Test]
+        public async Task GivenNoPreviewContentType_WhenDeserializeJsonRpcResult_ThenPreviewContentTypeIsImageWithTextAsync()
+        {
+            const string resultText =
+                """
+                {
+                  "result": [
+                    {
+                      "title": "Answer",
+                      "subTitle": "Plain result",
+                      "preview": {
+                        "description": "Plain description."
+                      }
+                    }
+                  ],
+                  "debugMessage": null
+                }
+                """;
+
+            var results = await QueryAsync(new Query
+            {
+                Search = resultText
+            }, default);
+
+            var result = results.Single();
+
+            ClassicAssert.AreEqual(PreviewContentType.ImageWithText, result.Preview.ContentType);
+        }
+
+        [Test]
+        public async Task GivenPreviewVisibilityNever_WhenDeserializeJsonRpcResult_ThenPreviewVisibilityIsNeverAsync()
+        {
+            const string resultText =
+                """
+                {
+                  "result": [
+                    {
+                      "title": "Ask",
+                      "subTitle": "Type a question",
+                      "previewVisibility": "never"
+                    }
+                  ],
+                  "debugMessage": null
+                }
+                """;
+
+            var results = await QueryAsync(new Query
+            {
+                Search = resultText
+            }, default);
+
+            var result = results.Single();
+
+            ClassicAssert.AreEqual(PreviewVisibility.Never, result.PreviewVisibility);
+        }
+
+        [Test]
+        public async Task GivenPreviewVisibilityAlways_WhenDeserializeJsonRpcResult_ThenPreviewVisibilityIsAlwaysAsync()
+        {
+            const string resultText =
+                """
+                {
+                  "result": [
+                    {
+                      "title": "Answer",
+                      "subTitle": "Markdown answer",
+                      "preview": { "contentType": "markdown" },
+                      "previewVisibility": "always"
+                    }
+                  ],
+                  "debugMessage": null
+                }
+                """;
+
+            var results = await QueryAsync(new Query
+            {
+                Search = resultText
+            }, default);
+
+            var result = results.Single();
+
+            ClassicAssert.AreEqual(PreviewVisibility.Always, result.PreviewVisibility);
+        }
     }
 }
diff --git a/Flow.Launcher.Test/PreviewMarkdownScrollViewerTest.cs b/Flow.Launcher.Test/PreviewMarkdownScrollViewerTest.cs
new file mode 100644
index 00000000000..512ddd0463d
--- /dev/null
+++ b/Flow.Launcher.Test/PreviewMarkdownScrollViewerTest.cs
@@ -0,0 +1,117 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Windows;
+using System.Windows.Documents;
+using System.Windows.Media;
+using Flow.Launcher.Resources.Controls;
+using NUnit.Framework;
+using NUnit.Framework.Legacy;
+
+namespace Flow.Launcher.Test
+{
+    [TestFixture]
+    internal class PreviewMarkdownScrollViewerTest
+    {
+        [Test]
+        [Apartment(ApartmentState.STA)]
+        public void GivenMarkdownLink_WhenRendered_ThenHyperlinkUsesAccentForeground()
+        {
+            var accentBrush = new SolidColorBrush(Color.FromRgb(0x31, 0xA8, 0xFF));
+            var viewer = new PreviewMarkdownScrollViewer
+            {
+                MarkdownStyle = CreateMarkdownStyle(accentBrush),
+                Markdown = "Links should use the theme accent: [Flow Launcher](https://www.flowlauncher.com/)."
+            };
+
+            var hyperlink = EnumerateInlines(viewer.Document.Blocks).OfType<Hyperlink>().Single();
+            var foreground = (SolidColorBrush)hyperlink.Foreground;
+
+            ClassicAssert.AreEqual(accentBrush.Color, foreground.Color);
+        }
+
+        [Test]
+        [Apartment(ApartmentState.STA)]
+        public void GivenConstrainedPreviewWidth_WhenMarkdownIsRendered_ThenDocumentPageWidthMatchesViewerWidth()
+        {
+            var viewer = new PreviewMarkdownScrollViewer
+            {
+                Width = 280,
+                Height = 200,
+                Markdown = "This long paragraph should wrap inside the preview pane instead of clipping at the right edge."
+            };
+
+            viewer.Measure(new Size(280, 200));
+            viewer.Arrange(new Rect(0, 0, 280, 200));
+            viewer.UpdateLayout();
+
+            ClassicAssert.AreEqual(280, viewer.Document.PageWidth);
+            ClassicAssert.AreEqual(280, viewer.Document.MaxPageWidth);
+            ClassicAssert.AreEqual(280, viewer.Document.ColumnWidth);
+        }
+
+        private static Style CreateMarkdownStyle(Brush accentBrush)
+        {
+            var documentStyle = new Style(typeof(FlowDocument));
+            documentStyle.Setters.Add(new Setter(TextElement.ForegroundProperty, Brushes.LightGray));
+
+            var hyperlinkStyle = new Style(typeof(Hyperlink));
+            hyperlinkStyle.Setters.Add(new Setter(TextElement.ForegroundProperty, accentBrush));
+            hyperlinkStyle.Setters.Add(new Setter(Inline.TextDecorationsProperty, null));
+            documentStyle.Resources.Add(typeof(Hyperlink), hyperlinkStyle);
+
+            return documentStyle;
+        }
+
+        private static IEnumerable<Inline> EnumerateInlines(BlockCollection blocks)
+        {
+            foreach (var block in blocks)
+            {
+                switch (block)
+                {
+                    case Paragraph paragraph:
+                        foreach (var inline in EnumerateInlines(paragraph.Inlines))
+                        {
+                            yield return inline;
+                        }
+
+                        break;
+
+                    case Section section:
+                        foreach (var inline in EnumerateInlines(section.Blocks))
+                        {
+                            yield return inline;
+                        }
+
+                        break;
+
+                    case List list:
+                        foreach (var inline in list.ListItems
+                                     .Cast<ListItem>()
+                                     .SelectMany(item => EnumerateInlines(item.Blocks)))
+                        {
+                            yield return inline;
+                        }
+
+                        break;
+                }
+            }
+        }
+
+        private static IEnumerable<Inline> EnumerateInlines(InlineCollection inlines)
+        {
+            foreach (var inline in inlines)
+            {
+                yield return inline;
+                if (inline is Span span)
+                {
+                    foreach (var child in EnumerateInlines(span.Inlines))
+                    {
+                        yield return child;
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/Flow.Launcher.Test/PreviewMarkdownStyleTest.cs b/Flow.Launcher.Test/PreviewMarkdownStyleTest.cs
new file mode 100644
index 00000000000..5f218b3e1dc
--- /dev/null
+++ b/Flow.Launcher.Test/PreviewMarkdownStyleTest.cs
@@ -0,0 +1,64 @@
+using System.IO;
+using System.Linq;
+using System.Xml.Linq;
+using NUnit.Framework;
+using NUnit.Framework.Legacy;
+
+namespace Flow.Launcher.Test
+{
+    [TestFixture]
+    internal class PreviewMarkdownStyleTest
+    {
+        private static readonly XNamespace PresentationNamespace = "http://schemas.microsoft.com/winfx/2006/xaml/presentation";
+        private static readonly XNamespace XamlNamespace = "http://schemas.microsoft.com/winfx/2006/xaml";
+
+        [Test]
+        public void GivenPreviewMarkdownStyle_WhenRendered_ThenBodyAndBoldUseAppTextFont()
+        {
+            var style = GetPreviewMarkdownStyle();
+
+            ClassicAssert.AreEqual("{DynamicResource ContentControlThemeFontFamily}", GetSetterValue(style, "FontFamily"));
+            ClassicAssert.AreEqual("Normal", GetSetterValue(style, "FontWeight"));
+
+            var boldStyle = style.Descendants(PresentationNamespace + "Style")
+                .First(element => element.Attribute("TargetType")?.Value == "{x:Type Bold}");
+
+            ClassicAssert.AreEqual("{DynamicResource ContentControlThemeFontFamily}", GetSetterValue(boldStyle, "FontFamily"));
+            ClassicAssert.AreEqual("SemiBold", GetSetterValue(boldStyle, "FontWeight"));
+        }
+
+        private static XElement GetPreviewMarkdownStyle()
+        {
+            var baseThemePath = FindBaseThemePath();
+            var document = XDocument.Load(baseThemePath);
+
+            return document.Descendants(PresentationNamespace + "Style")
+                .First(element => element.Attribute(XamlNamespace + "Key")?.Value == "PreviewMarkdownStyle");
+        }
+
+        private static string FindBaseThemePath()
+        {
+            var directory = new DirectoryInfo(TestContext.CurrentContext.TestDirectory);
+            while (directory is not null)
+            {
+                var path = Path.Combine(directory.FullName, "Flow.Launcher", "Themes", "Base.xaml");
+                if (File.Exists(path))
+                {
+                    return path;
+                }
+
+                directory = directory.Parent;
+            }
+
+            throw new FileNotFoundException("Could not find Flow.Launcher/Themes/Base.xaml from test directory.");
+        }
+
+        private static string GetSetterValue(XElement style, string propertyName)
+        {
+            return style.Elements(PresentationNamespace + "Setter")
+                .Where(element => element.Attribute("Property")?.Value == propertyName)
+                .Select(element => element.Attribute("Value")?.Value)
+                .FirstOrDefault();
+        }
+    }
+}
diff --git a/Flow.Launcher/Flow.Launcher.csproj b/Flow.Launcher/Flow.Launcher.csproj
index 2a1332b4260..7b0f4a04db7 100644
--- a/Flow.Launcher/Flow.Launcher.csproj
+++ b/Flow.Launcher/Flow.Launcher.csproj
@@ -137,6 +137,7 @@
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
+    <PackageReference Include="AvalonEdit" Version="6.3.0.90" />
     <PackageReference Include="iNKORE.UI.WPF.Modern" Version="0.10.1" />
     <PackageReference Include="MdXaml" Version="1.27.0" />
     <PackageReference Include="MdXaml.AnimatedGif" Version="1.27.0" />
diff --git a/Flow.Launcher/Languages/en.xaml b/Flow.Launcher/Languages/en.xaml
index cf67bffeafa..0f8172f79df 100644
--- a/Flow.Launcher/Languages/en.xaml
+++ b/Flow.Launcher/Languages/en.xaml
@@ -322,6 +322,13 @@
     <system:String x:Key="ColorSchemeSystem">System Default</system:String>
     <system:String x:Key="ColorSchemeLight">Light</system:String>
     <system:String x:Key="ColorSchemeDark">Dark</system:String>
+    <system:String x:Key="CodeHighlightTheme">Code Highlight Theme</system:String>
+    <system:String x:Key="CodeHighlightThemeTooltip">Syntax highlighting theme for code blocks in the markdown preview pane.</system:String>
+    <system:String x:Key="CodeHighlightThemeAuto">Auto (match color scheme)</system:String>
+    <system:String x:Key="CodeHighlightThemeVSCodeLight">VS Code Light</system:String>
+    <system:String x:Key="CodeHighlightThemeVSCodeDarkPlus">VS Code Dark+</system:String>
+    <system:String x:Key="CodeHighlightThemeCatppuccinMacchiato">Catppuccin Macchiato</system:String>
+    <system:String x:Key="CodeHighlightThemeOneDark">One Dark</system:String>
     <system:String x:Key="SoundEffect">Sound Effect</system:String>
     <system:String x:Key="SoundEffectTip">Play a small sound when the search window opens</system:String>
     <system:String x:Key="SoundEffectVolume">Sound Effect Volume</system:String>
diff --git a/Flow.Launcher/MainWindow.xaml b/Flow.Launcher/MainWindow.xaml
index 2950d2f6555..79a74609730 100644
--- a/Flow.Launcher/MainWindow.xaml
+++ b/Flow.Launcher/MainWindow.xaml
@@ -3,6 +3,7 @@
     xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
     xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
     xmlns:converters="clr-namespace:Flow.Launcher.Converters"
+    xmlns:controls="clr-namespace:Flow.Launcher.Resources.Controls"
     xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
     xmlns:flowlauncher="clr-namespace:Flow.Launcher"
     xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
@@ -403,9 +404,9 @@
 
                 <Grid x:Name="ResultPreviewArea">
                     <Grid.ColumnDefinitions>
-                        <ColumnDefinition Width="*" MinWidth="80" />
+                        <ColumnDefinition Width="0.6*" MinWidth="80" />
                         <ColumnDefinition Width="Auto" />
-                        <ColumnDefinition Width="0.85*" MinWidth="244" />
+                        <ColumnDefinition Width="1.2*" MinWidth="320" />
                     </Grid.ColumnDefinitions>
 
                     <StackPanel
@@ -442,7 +443,9 @@
                         HorizontalAlignment="Center"
                         VerticalAlignment="Stretch"
                         Background="Transparent"
-                        ShowsPreview="True"
+                        FocusVisualStyle="{x:Null}"
+                        IsTabStop="False"
+                        ShowsPreview="False"
                         Visibility="{Binding InternalPreviewVisible, Converter={StaticResource BoolToVisibilityConverter}}">
                         <GridSplitter.Template>
                             <ControlTemplate TargetType="{x:Type GridSplitter}">
@@ -454,11 +457,12 @@
                     <Grid
                         x:Name="Preview"
                         Grid.Column="2"
+                        MinHeight="380"
+                        MaxHeight="{Binding ElementName=ResultListBox, Path=ActualHeight}"
                         VerticalAlignment="Stretch"
                         Style="{DynamicResource PreviewArea}"
                         Visibility="{Binding InternalPreviewVisible, Converter={StaticResource BoolToVisibilityConverter}}">
                         <Border
-                            MinHeight="380"
                             d:DataContext="{d:DesignInstance vm:ResultViewModel}"
                             DataContext="{Binding PreviewSelectedItem, Mode=OneWay}"
                             Visibility="{Binding ShowDefaultPreview}">
@@ -470,7 +474,10 @@
                                     <RowDefinition Height="*" />
                                     <RowDefinition Height="Auto" />
                                 </Grid.RowDefinitions>
-                                <Grid Grid.Row="0" VerticalAlignment="Center">
+                                <Grid
+                                    Grid.Row="0"
+                                    VerticalAlignment="Center"
+                                    Visibility="{Binding IsMarkdownPreview, Converter={StaticResource BoolToVisibilityConverter}, ConverterParameter=Inverted}">
                                     <Grid.RowDefinitions>
                                         <RowDefinition Height="Auto" />
                                         <RowDefinition Height="Auto" />
@@ -514,7 +521,20 @@
                                         TextAlignment="Center"
                                         TextWrapping="Wrap" />
                                 </Grid>
-                                <StackPanel Grid.Row="1">
+                                <controls:PreviewMarkdownScrollViewer
+                                    Grid.Row="0"
+                                    Grid.RowSpan="2"
+                                    Margin="8 10 0 10"
+                                    HorizontalScrollBarVisibility="Disabled"
+                                    Markdown="{Binding PreviewDescription}"
+                                    MarkdownStyle="{DynamicResource PreviewMarkdownStyle}"
+                                    VerticalScrollBarVisibility="Auto"
+                                    Visibility="{Binding IsMarkdownPreview, Converter={StaticResource BoolToVisibilityConverter}}">
+                                    <FrameworkElement.Resources>
+                                        <Style TargetType="{x:Type ScrollBar}" BasedOn="{StaticResource BaseScrollBarStyle}" />
+                                    </FrameworkElement.Resources>
+                                </controls:PreviewMarkdownScrollViewer>
+                                <StackPanel Grid.Row="1" Visibility="{Binding IsMarkdownPreview, Converter={StaticResource BoolToVisibilityConverter}, ConverterParameter=Inverted}">
                                     <StackPanel.Style>
                                         <Style TargetType="{x:Type StackPanel}">
                                             <Style.Triggers>
@@ -533,8 +553,6 @@
                             </Grid>
                         </Border>
                         <Border
-                            MinHeight="380"
-                            MaxHeight="{Binding ElementName=ResultListBox, Path=ActualHeight}"
                             Padding="0 0 10 10"
                             Visibility="{Binding ShowCustomizedPreview}">
                             <ContentControl Content="{Binding CustomizedPreviewControl}" />
diff --git a/Flow.Launcher/MainWindow.xaml.cs b/Flow.Launcher/MainWindow.xaml.cs
index 4866c0deae6..a8fe1420c6e 100644
--- a/Flow.Launcher/MainWindow.xaml.cs
+++ b/Flow.Launcher/MainWindow.xaml.cs
@@ -24,6 +24,7 @@
 using Flow.Launcher.Plugin;
 using Flow.Launcher.Plugin.SharedCommands;
 using Flow.Launcher.Plugin.SharedModels;
+using Flow.Launcher.Resources.Controls;
 using Flow.Launcher.ViewModel;
 using iNKORE.UI.WPF.Modern;
 using iNKORE.UI.WPF.Modern.Controls;
@@ -110,6 +111,8 @@ public MainWindow()
 
         private void ViewModel_ActualApplicationThemeChanged(object sender, ActualApplicationThemeChangedEventArgs args)
         {
+            // Keep the markdown preview's "Auto" code-highlight theme in step with the app colour scheme.
+            PreviewMarkdownScrollViewer.ApplyCodeHighlightTheme(_settings.CodeHighlightTheme, args.IsDark);
             _ = _theme.RefreshFrameAsync();
         }
 
@@ -200,6 +203,12 @@ private void OnLoaded(object sender, RoutedEventArgs e)
                 ThemeManager.Current.ApplicationTheme = ApplicationTheme.Dark;
             }
 
+            // Initialize the markdown preview code-highlight theme from settings, resolving "Auto"
+            // against the colour scheme just applied above.
+            PreviewMarkdownScrollViewer.ApplyCodeHighlightTheme(
+                _settings.CodeHighlightTheme,
+                ThemeManager.Current.ActualApplicationTheme == ApplicationTheme.Dark);
+
             // Force update position
             UpdatePosition();
 
@@ -207,7 +216,10 @@ private void OnLoaded(object sender, RoutedEventArgs e)
             SetupResizeMode();
 
             // Reset preview
-            _viewModel.ResetPreview();
+            // Can't await in sync startup code; fire-and-forget but safely log any failure
+            _ = _viewModel.ResetPreviewAsync().ContinueWith(static t =>
+                    App.API.LogError(ClassName, $"ResetPreviewAsync failed: {t.Exception}"),
+                CancellationToken.None, TaskContinuationOptions.OnlyOnFaulted, TaskScheduler.Default);
 
             // Since the default main window visibility is visible, so we need set focus during startup
             QueryTextBox.Focus();
@@ -241,7 +253,10 @@ private void OnLoaded(object sender, RoutedEventArgs e)
                                     Activate();
 
                                     // Reset preview
-                                    _viewModel.ResetPreview();
+                                    // Can't await in Dispatcher.Invoke; fire-and-forget but safely log any failure
+                                    _ = _viewModel.ResetPreviewAsync().ContinueWith(static t =>
+                                            App.API.LogError(ClassName, $"ResetPreviewAsync failed: {t.Exception}"),
+                                        CancellationToken.None, TaskContinuationOptions.OnlyOnFaulted, TaskScheduler.Default);
 
                                     // Select last query if need
                                     if (!_viewModel.LastQuerySelected)
@@ -438,6 +453,15 @@ private async void OnDeactivated(object sender, EventArgs e)
 
         private void OnKeyDown(object sender, KeyEventArgs e)
         {
+            // When a code-block in the markdown preview is focused
+            // Let it capture input of text navigation keys (arrows, page, home/end) instead
+            // Non-navigation keys pass through normally.
+            if (PreviewMarkdownScrollViewer.IsCodeBlockFocused(e.OriginalSource)
+                && PreviewMarkdownScrollViewer.IsCodeBlockNavigationKey(e.Key))
+            {
+                return;
+            }
+
             var specialKeyState = GlobalHotkey.CheckModifiers();
             switch (e.Key)
             {
diff --git a/Flow.Launcher/Resources/Controls/CodeHighlightTheme.cs b/Flow.Launcher/Resources/Controls/CodeHighlightTheme.cs
new file mode 100644
index 00000000000..376b20913fd
--- /dev/null
+++ b/Flow.Launcher/Resources/Controls/CodeHighlightTheme.cs
@@ -0,0 +1,161 @@
+using System.Windows.Media;
+
+namespace Flow.Launcher.Resources.Controls;
+
+internal sealed record CodeHighlightTheme(
+    string Name,
+    Color DefaultForeground,
+    Color Comment,
+    Color String,
+    Color Number,
+    Color Keyword,
+    Color ControlFlow,
+    Color Type,
+    Color Function,
+    Color Variable,
+    Color BuiltIn,
+    Color Punctuation,
+    Color Decorator,
+    Color Error)
+{
+    public bool TryGetColor(string highlightName, out Color color)
+    {
+        color = highlightName switch
+        {
+            "Comment" or "Comments" or "LineComment" or "BlockComment"
+                or "DocComment" or "DocString" or "DocText" => Comment,
+
+            "String" or "Strings" or "StringDQ" or "StringSQ" or "RawString"
+                or "TripleQuotedString" or "InterpolatedString" or "MultilineString"
+                or "Char" or "Character" => String,
+
+            "Number" or "Numbers" or "NumberLiteral" or "Digits"
+                or "HexNumber" or "HexLiteral" or "OctalNumber" or "BinaryNumber"
+                or "FloatNumber" or "DecimalNumber" => Number,
+
+            "Keyword" or "Keywords" or "AccessKeywords" or "TypeKeywords"
+                or "OperatorKeywords" or "ContextKeywords" or "MethodKeywords"
+                or "ReturnKeyword" or "ImportKeyword" or "StorageType" or "Modifier"
+                or "Modifiers" or "Visibility" or "NamespaceKeywords"
+                or "GetSetAddRemove" or "ParameterModifiers" or "CheckedKeyword"
+                or "UnsafeKeywords" or "SemanticKeywords"
+                or "JavaScriptKeyWords" or "JavaScriptKeywords"
+                or "Storage" or "ReservedWord" => Keyword,
+
+            "ControlKeyword" or "ConditionalSelectionKeywords" or "LoopKeywords"
+                or "ExceptionKeywords" or "ExceptionHandlingKeywords" or "GotoKeywords"
+                or "FlowControl" or "ControlFlow" => ControlFlow,
+
+            "Boolean" or "BooleanConstants" or "NullValue" or "Builtin" or "Builtins"
+                or "BuiltinFunction" or "BuiltinType" or "BuiltInTypes" or "Self"
+                or "This" or "True" or "False" or "None"
+                or "ThisOrBaseReference" or "NullOrValueKeywords" or "TrueFalse"
+                or "JavaScriptLiterals" or "JavaScriptIntrinsics" => BuiltIn,
+
+            "Type" or "Types" or "TypeName" or "Class" or "ClassName"
+                or "ReferenceTypes" or "ValueTypes" or "ValueTypeKeywords"
+                or "ReferenceTypeKeywords" or "Interface" or "Enum"
+                or "Struct" or "Trait" or "Generic" => Type,
+
+            "MethodCall" or "Method" or "MethodName" or "Function" or "Functions"
+                or "FunctionName" or "FunctionDeclaration" or "FunctionDefinition"
+                or "MethodDeclaration" or "MethodDefinition"
+                or "JavaScriptGlobalFunctions" => Function,
+
+            "Variable" or "Variables" or "Parameter" or "Parameters"
+                or "Property" or "Field" or "Identifier" or "Argument" => Variable,
+
+            "Decorator" or "Annotation" or "Preprocessor" or "PreprocessorDirective"
+                or "Attribute" or "Directive" or "Pragma" or "StringInterpolation"
+                or "Regex" => Decorator,
+
+            "Operator" or "Operators" or "Punctuation" or "Bracket" or "Brackets"
+                or "Semicolon" or "Comma" or "Dot" => Punctuation,
+
+            "Error" or "BraceMismatch" or "InvalidIdentifier" or "Invalid" => Error,
+
+            _ => default,
+        };
+        return color != default;
+    }
+
+    public static CodeHighlightTheme VSCodeDarkPlus { get; } = new(
+        Name: "VS Code Dark+",
+        DefaultForeground: Color.FromRgb(0xD4, 0xD4, 0xD4),
+        Comment:           Color.FromRgb(0x6A, 0x99, 0x55),
+        String:            Color.FromRgb(0xCE, 0x91, 0x78),
+        Number:            Color.FromRgb(0xB5, 0xCE, 0xA8),
+        Keyword:           Color.FromRgb(0x56, 0x9C, 0xD6),
+        ControlFlow:       Color.FromRgb(0xC5, 0x86, 0xC0),
+        Type:              Color.FromRgb(0x4E, 0xC9, 0xB0),
+        Function:          Color.FromRgb(0xDC, 0xDC, 0xAA),
+        Variable:          Color.FromRgb(0x9C, 0xDC, 0xFE),
+        BuiltIn:           Color.FromRgb(0x56, 0x9C, 0xD6),
+        Punctuation:       Color.FromRgb(0xD4, 0xD4, 0xD4),
+        Decorator:         Color.FromRgb(0xDC, 0xDC, 0xAA),
+        Error:             Color.FromRgb(0xF4, 0x47, 0x47));
+
+    public static CodeHighlightTheme CatppuccinMacchiato { get; } = new(
+        Name: "Catppuccin Macchiato",
+        DefaultForeground: Color.FromRgb(0xCA, 0xD3, 0xF5),
+        Comment:           Color.FromRgb(0x6E, 0x73, 0x8D),
+        String:            Color.FromRgb(0xA6, 0xDA, 0x95),
+        Number:            Color.FromRgb(0xF5, 0xA9, 0x7F),
+        Keyword:           Color.FromRgb(0xC6, 0xA0, 0xF6),
+        ControlFlow:       Color.FromRgb(0xC6, 0xA0, 0xF6),
+        Type:              Color.FromRgb(0xEE, 0xD4, 0x9F),
+        Function:          Color.FromRgb(0x8A, 0xAD, 0xF4),
+        Variable:          Color.FromRgb(0xCA, 0xD3, 0xF5),
+        BuiltIn:           Color.FromRgb(0x91, 0xD7, 0xE3),
+        Punctuation:       Color.FromRgb(0xB8, 0xC0, 0xE0),
+        Decorator:         Color.FromRgb(0xC6, 0xA0, 0xF6),
+        Error:             Color.FromRgb(0xED, 0x87, 0x96));
+
+    public static CodeHighlightTheme OneDark { get; } = new(
+        Name: "One Dark",
+        DefaultForeground: Color.FromRgb(0xAB, 0xB2, 0xBF),
+        Comment:           Color.FromRgb(0x7F, 0x84, 0x8E),
+        String:            Color.FromRgb(0x98, 0xC3, 0x79),
+        Number:            Color.FromRgb(0xD1, 0x9A, 0x66),
+        Keyword:           Color.FromRgb(0xC6, 0x78, 0xDD),
+        ControlFlow:       Color.FromRgb(0xC6, 0x78, 0xDD),
+        Type:              Color.FromRgb(0xE5, 0xC0, 0x7B),
+        Function:          Color.FromRgb(0x61, 0xAF, 0xEF),
+        Variable:          Color.FromRgb(0xAB, 0xB2, 0xBF),
+        BuiltIn:           Color.FromRgb(0x56, 0xB6, 0xC2),
+        Punctuation:       Color.FromRgb(0xAB, 0xB2, 0xBF),
+        Decorator:         Color.FromRgb(0xC6, 0x78, 0xDD),
+        Error:             Color.FromRgb(0xE0, 0x6C, 0x75));
+
+    // Light counterpart so "Auto" has something legible to fall back to on light colour schemes;
+    // the bundled dark themes wash out on a light background.
+    public static CodeHighlightTheme VSCodeLight { get; } = new(
+        Name: "VS Code Light",
+        DefaultForeground: Color.FromRgb(0x1F, 0x1F, 0x1F),
+        Comment:           Color.FromRgb(0x00, 0x80, 0x00),
+        String:            Color.FromRgb(0xA3, 0x15, 0x15),
+        Number:            Color.FromRgb(0x09, 0x86, 0x58),
+        Keyword:           Color.FromRgb(0x00, 0x00, 0xFF),
+        ControlFlow:       Color.FromRgb(0xAF, 0x00, 0xDB),
+        Type:              Color.FromRgb(0x26, 0x7F, 0x99),
+        Function:          Color.FromRgb(0x79, 0x5E, 0x26),
+        Variable:          Color.FromRgb(0x00, 0x10, 0x80),
+        BuiltIn:           Color.FromRgb(0x00, 0x00, 0xFF),
+        Punctuation:       Color.FromRgb(0x00, 0x00, 0x00),
+        Decorator:         Color.FromRgb(0x79, 0x5E, 0x26),
+        Error:             Color.FromRgb(0xCD, 0x31, 0x31));
+
+    /// <summary>
+    /// Resolves the configured code-highlight theme setting to a concrete theme. "Auto" (and any
+    /// unrecognised value) follows the app colour scheme: a light theme when the app renders light,
+    /// a dark theme otherwise. Explicit names always win.
+    /// </summary>
+    public static CodeHighlightTheme Resolve(string setting, bool isDark) => setting switch
+    {
+        nameof(VSCodeLight) => VSCodeLight,
+        nameof(VSCodeDarkPlus) => VSCodeDarkPlus,
+        nameof(CatppuccinMacchiato) => CatppuccinMacchiato,
+        nameof(OneDark) => OneDark,
+        _ => isDark ? VSCodeDarkPlus : VSCodeLight,
+    };
+}
diff --git a/Flow.Launcher/Resources/Controls/PreviewMarkdownScrollViewer.cs b/Flow.Launcher/Resources/Controls/PreviewMarkdownScrollViewer.cs
new file mode 100644
index 00000000000..1dad3e4b280
--- /dev/null
+++ b/Flow.Launcher/Resources/Controls/PreviewMarkdownScrollViewer.cs
@@ -0,0 +1,441 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Windows;
+using System.Windows.Documents;
+using System.Windows.Input;
+using System.Windows.Media;
+using System.Windows.Threading;
+using Flow.Launcher.Infrastructure.Logger;
+using ICSharpCode.AvalonEdit;
+using ICSharpCode.AvalonEdit.Document;
+using ICSharpCode.AvalonEdit.Highlighting;
+using ICSharpCode.AvalonEdit.Rendering;
+using MdXaml;
+
+namespace Flow.Launcher.Resources.Controls;
+
+public class PreviewMarkdownScrollViewer : MarkdownScrollViewer
+{
+    private static readonly string[] EmphasisMarkers = ["**", "__", "*", "_"];
+    private const double MinimumDocumentPageWidth = 64;
+
+    internal static CodeHighlightTheme ActiveTheme { get; private set; } = CodeHighlightTheme.VSCodeDarkPlus;
+
+    // Track in-flight BeginInvoke so rapid Markdown changes don't pile up traversals.
+    private DispatcherOperation _pendingFixOperation;
+
+    /// <summary>
+    /// Name of the code-highlight theme currently applied to embedded code blocks.
+    /// </summary>
+    public static string ActiveThemeName => ActiveTheme.Name;
+
+    /// <summary>
+    /// Applies the configured code-highlight theme to subsequently rendered code blocks.
+    /// </summary>
+    /// <param name="setting">The persisted Settings.CodeHighlightTheme value (e.g. "Auto", "OneDark").</param>
+    /// <param name="isDark">Whether the app currently renders with a dark colour scheme.</param>
+    public static void ApplyCodeHighlightTheme(string setting, bool isDark)
+        => ActiveTheme = CodeHighlightTheme.Resolve(setting, isDark);
+
+    /// <summary>
+    /// Returns true when <paramref name="source"/> (typically the focused element of a routed key
+    /// event) sits inside one of the code blocks embedded in a markdown preview.
+    /// </summary>
+    public static bool IsCodeBlockFocused(object source)
+    {
+        var element = source as DependencyObject;
+        while (element is not null)
+        {
+            if (element is TextEditor)
+            {
+                return true;
+            }
+
+            element = element is Visual
+                ? VisualTreeHelper.GetParent(element)
+                : LogicalTreeHelper.GetParent(element);
+        }
+
+        return false;
+    }
+
+    /// <summary>
+    /// Returns true when <paramref name="key"/> is used by the code-block for caret movement
+    /// These should be captured by the code block exclusively when its in focus.
+    /// </summary>
+    /// <remarks>
+    /// Modifier variants (Shift+Up, Ctrl+Left) are covered here too since WPF reports the
+    /// base key regardless of modifiers.
+    /// </remarks>
+    public static bool IsCodeBlockNavigationKey(Key key)
+    {
+        return key is 
+            Key.Up or Key.Down or Key.Left or Key.Right
+            or Key.PageUp or Key.PageDown
+            or Key.Home or Key.End;
+    }
+
+    static PreviewMarkdownScrollViewer()
+    {
+        // AvalonEdit ships no AHK highlighter; map AHK language tags to the C++ definition so
+        // MdXaml fenced blocks tagged ```ahk / ```autohotkey get C-style coloring instead of plain text.
+        var cpp = HighlightingManager.Instance.GetDefinition("C++");
+        if (cpp is not null)
+        {
+            foreach (var alias in new[] { "autohotkey", "AutoHotkey", "ahk", "AHK", "ahk2", "AHK2" })
+            {
+                if (HighlightingManager.Instance.GetDefinition(alias) is null)
+                {
+                    HighlightingManager.Instance.RegisterHighlighting(alias, [".ahk"], cpp);
+                }
+            }
+        }
+    }
+
+    protected override void OnPropertyChanged(DependencyPropertyChangedEventArgs e)
+    {
+        base.OnPropertyChanged(e);
+
+        if (e.Property == MarkdownProperty)
+        {
+            UpdateDocumentPageWidth(ActualWidth);
+            ScheduleCompatibilityFixes();
+        }
+    }
+
+    protected override void OnInitialized(EventArgs e)
+    {
+        base.OnInitialized(e);
+        CommandBindings.Add(new CommandBinding(NavigationCommands.GoToPage, OpenHyperlink));
+        UpdateDocumentPageWidth(ActualWidth);
+        ScheduleCompatibilityFixes();
+    }
+
+    private static void OpenHyperlink(object sender, ExecutedRoutedEventArgs e)
+    {
+        string rawUrl = null;
+
+        var uri = e.Parameter as Uri;
+        if (uri is null && e.Parameter is string s)
+        {
+            rawUrl = s;
+
+            try { uri = new Uri(s); }
+            catch (UriFormatException) { }
+        }
+
+        if (uri is null)
+        {
+            if (rawUrl is not null)
+            {
+                Log.Warn(nameof(PreviewMarkdownScrollViewer),
+                    $"Unable to parse hyperlink URL: \"{rawUrl}\"",
+                    nameof(OpenHyperlink));
+            }
+
+            return;
+        }
+
+        if (uri.IsAbsoluteUri && IsSafeScheme(uri.Scheme))
+        {
+            App.API.OpenWebUrl(uri);
+            App.API.HideMainWindow();
+            e.Handled = true;
+        }
+        else
+        {
+            Log.Warn(nameof(PreviewMarkdownScrollViewer),
+                $"Skipping hyperlink with scheme \"{uri.Scheme}\": {uri}",
+                nameof(OpenHyperlink));
+        }
+    }
+
+    private static bool IsSafeScheme(string scheme)
+    {
+        var lowered = scheme?.ToLowerInvariant() ?? "";
+        return lowered is not "javascript" and not "vbscript";
+    }
+
+    private void ScheduleCompatibilityFixes()
+    {
+        // Coalesce: if a traversal is already queued, let it run rather than piling up more.
+        if (_pendingFixOperation is { Status: DispatcherOperationStatus.Pending })
+            return;
+
+        _pendingFixOperation = Dispatcher.BeginInvoke(ApplyMarkdownCompatibilityFixes, DispatcherPriority.Loaded);
+    }
+
+    protected override Size ArrangeOverride(Size arrangeSize)
+    {
+        UpdateDocumentPageWidth(arrangeSize.Width);
+        var arranged = base.ArrangeOverride(arrangeSize);
+        UpdateDocumentPageWidth(arrangeSize.Width);
+        return arranged;
+    }
+
+    protected override void OnRenderSizeChanged(SizeChangedInfo sizeInfo)
+    {
+        base.OnRenderSizeChanged(sizeInfo);
+        UpdateDocumentPageWidth(sizeInfo.NewSize.Width);
+    }
+
+    private void UpdateDocumentPageWidth(double width)
+    {
+        if (Document is null || double.IsNaN(width) || double.IsInfinity(width) || width <= 0)
+        {
+            return;
+        }
+
+        var pageWidth = Math.Max(MinimumDocumentPageWidth, width);
+        if (!AreClose(Document.PageWidth, pageWidth))
+        {
+            Document.PageWidth = pageWidth;
+        }
+
+        if (!AreClose(Document.MaxPageWidth, pageWidth))
+        {
+            Document.MaxPageWidth = pageWidth;
+        }
+
+        if (!AreClose(Document.ColumnWidth, pageWidth))
+        {
+            Document.ColumnWidth = pageWidth;
+        }
+    }
+
+    private static bool AreClose(double left, double right)
+        => Math.Abs(left - right) < 0.5;
+
+    private void ApplyMarkdownCompatibilityFixes()
+    {
+        if (Document is null)
+        {
+            return;
+        }
+
+        ApplyMarkdownCompatibilityFixes(Document.Blocks);
+    }
+
+    private static void ApplyMarkdownCompatibilityFixes(BlockCollection blocks)
+    {
+        foreach (var block in blocks.ToList())
+        {
+            switch (block)
+            {
+                case Paragraph paragraph:
+                    ApplyMarkdownCompatibilityFixes(paragraph.Inlines);
+                    break;
+
+                case Section section:
+                    ApplyMarkdownCompatibilityFixes(section.Blocks);
+                    break;
+
+                case System.Windows.Documents.List list:
+                    foreach (var listItem in list.ListItems.ToList())
+                    {
+                        ApplyMarkdownCompatibilityFixes(listItem.Blocks);
+                    }
+
+                    break;
+
+                case Table table:
+                    foreach (var cell in table.RowGroups.ToList()
+                                 .SelectMany(rowGroup => rowGroup.Rows.ToList())
+                                 .SelectMany(row => row.Cells.ToList()))
+                    {
+                        ApplyMarkdownCompatibilityFixes(cell.Blocks);
+                    }
+
+                    break;
+
+                case BlockUIContainer { Child: TextEditor editor }:
+                    RetintEditor(editor);
+                    break;
+            }
+        }
+    }
+
+    private static void ApplyMarkdownCompatibilityFixes(InlineCollection inlineCollection)
+    {
+        foreach (var span in inlineCollection.OfType<Span>().Where(span => !IsCodeSpan(span)).ToList())
+        {
+            ApplyMarkdownCompatibilityFixes(span.Inlines);
+        }
+
+        var inlines = inlineCollection.ToList();
+        for (var i = 1; i < inlines.Count - 1; i++)
+        {
+            var inline = inlines[i];
+            if (!IsCodeSpan(inline) || inlines[i - 1] is not Run before || inlines[i + 1] is not Run after)
+            {
+                continue;
+            }
+
+            var marker = EmphasisMarkers.FirstOrDefault(value =>
+                before.Text.EndsWith(value, StringComparison.Ordinal) &&
+                after.Text.StartsWith(value, StringComparison.Ordinal));
+
+            if (marker is null)
+            {
+                continue;
+            }
+
+            before.Text = before.Text[..^marker.Length];
+            after.Text = after.Text[marker.Length..];
+
+            if (marker.Length == 2)
+            {
+                inline.FontWeight = FontWeights.SemiBold;
+            }
+            else
+            {
+                inline.FontStyle = FontStyles.Italic;
+            }
+        }
+
+        foreach (var run in inlineCollection.OfType<Run>().Where(run => run.Text.Length == 0).ToList())
+        {
+            inlineCollection.Remove(run);
+        }
+    }
+
+    private static bool IsCodeSpan(Inline inline)
+    {
+        return inline.Tag is string tag && tag.Equals("CodeSpan", StringComparison.Ordinal);
+    }
+
+    private static void RetintEditor(TextEditor editor)
+    {
+        var definition = editor.SyntaxHighlighting;
+        if (definition is null)
+        {
+            return;
+        }
+
+        var theme = ActiveTheme;
+
+        var defaultForeground = new SolidColorBrush(theme.DefaultForeground);
+        defaultForeground.Freeze();
+        editor.Foreground = defaultForeground;
+
+        var transformers = editor.TextArea.TextView.LineTransformers;
+        if (transformers.OfType<ThemedHighlightingColorizer>().Any(colorizer => colorizer.Theme == theme))
+        {
+            return;
+        }
+
+        // Colorize through a per-editor transformer instead of mutating the shared highlighting
+        // definition, so the tint cannot leak into other consumers of the same definition.
+        foreach (var colorizer in transformers.OfType<HighlightingColorizer>().ToList())
+        {
+            transformers.Remove(colorizer);
+        }
+
+        // Index 0 mirrors TextEditor's own colorizer placement: syntax colors must be applied
+        // before the selection colorizer so selected text still gets the selection foreground.
+        transformers.Insert(0, new ThemedHighlightingColorizer(definition, theme));
+    }
+
+    private sealed class ThemedHighlightingColorizer : HighlightingColorizer
+    {
+        private readonly Dictionary<HighlightingColor, HighlightingColor> _themedColors = new();
+
+        public ThemedHighlightingColorizer(IHighlightingDefinition definition, CodeHighlightTheme theme)
+            : base(definition)
+        {
+            Theme = theme;
+        }
+
+        public CodeHighlightTheme Theme { get; }
+
+        // Theme at the highlighter level rather than in ApplyColorToElement: the base colorizer
+        // skips styling-free colors (e.g. C#'s attribute-less "Punctuation") before they would
+        // ever reach ApplyColorToElement.
+        protected override IHighlighter CreateHighlighter(TextView textView, TextDocument document)
+            => new ThemedHighlighter(base.CreateHighlighter(textView, document), this);
+
+        private HighlightingColor ThemedColor(HighlightingColor color)
+        {
+            if (color?.Name is null || !Theme.TryGetColor(color.Name, out var target))
+            {
+                return color;
+            }
+
+            if (!_themedColors.TryGetValue(color, out var themed))
+            {
+                themed = color.Clone();
+                themed.Foreground = new SolidHighlightingBrush(target);
+                themed.Freeze();
+                _themedColors[color] = themed;
+            }
+
+            return themed;
+        }
+
+        private sealed class ThemedHighlighter : IHighlighter
+        {
+            private readonly IHighlighter _inner;
+            private readonly ThemedHighlightingColorizer _colorizer;
+
+            public ThemedHighlighter(IHighlighter inner, ThemedHighlightingColorizer colorizer)
+            {
+                _inner = inner;
+                _colorizer = colorizer;
+            }
+
+            public IDocument Document => _inner.Document;
+
+            public HighlightingColor DefaultTextColor => _colorizer.ThemedColor(_inner.DefaultTextColor);
+
+            public event HighlightingStateChangedEventHandler HighlightingStateChanged
+            {
+                add => _inner.HighlightingStateChanged += value;
+                remove => _inner.HighlightingStateChanged -= value;
+            }
+
+            public HighlightedLine HighlightLine(int lineNumber)
+            {
+                var line = _inner.HighlightLine(lineNumber);
+                foreach (var section in line.Sections)
+                {
+                    section.Color = _colorizer.ThemedColor(section.Color);
+                }
+
+                return line;
+            }
+
+            public IEnumerable<HighlightingColor> GetColorStack(int lineNumber) => _inner.GetColorStack(lineNumber);
+
+            public HighlightingColor GetNamedColor(string name) => _colorizer.ThemedColor(_inner.GetNamedColor(name));
+
+            public void UpdateHighlightingState(int lineNumber) => _inner.UpdateHighlightingState(lineNumber);
+
+            public void BeginHighlighting() => _inner.BeginHighlighting();
+
+            public void EndHighlighting() => _inner.EndHighlighting();
+
+            public void Dispose() => _inner.Dispose();
+        }
+    }
+
+    private sealed class SolidHighlightingBrush : HighlightingBrush
+    {
+        private readonly SolidColorBrush _brush;
+
+        public SolidHighlightingBrush(Color color)
+        {
+            _brush = new SolidColorBrush(color);
+            _brush.Freeze();
+        }
+
+        public override Brush GetBrush(ITextRunConstructionContext context) => _brush;
+
+        public override string ToString() => _brush.Color.ToString();
+
+        public override bool Equals(object obj)
+            => obj is SolidHighlightingBrush other && _brush.Color == other._brush.Color;
+
+        public override int GetHashCode() => _brush.Color.GetHashCode();
+    }
+}
diff --git a/Flow.Launcher/SettingPages/ViewModels/SettingsPaneThemeViewModel.cs b/Flow.Launcher/SettingPages/ViewModels/SettingsPaneThemeViewModel.cs
index f69774e8e20..c8c4d5fdf32 100644
--- a/Flow.Launcher/SettingPages/ViewModels/SettingsPaneThemeViewModel.cs
+++ b/Flow.Launcher/SettingPages/ViewModels/SettingsPaneThemeViewModel.cs
@@ -13,6 +13,7 @@
 using Flow.Launcher.Infrastructure.UserSettings;
 using Flow.Launcher.Plugin;
 using Flow.Launcher.Plugin.SharedModels;
+using Flow.Launcher.Resources.Controls;
 using Flow.Launcher.ViewModel;
 using iNKORE.UI.WPF.Modern;
 
@@ -143,6 +144,21 @@ public string ColorScheme
         }
     }
 
+    public class CodeHighlightThemeData : DropdownDataGeneric<CodeHighlightThemes> { }
+
+    public List<CodeHighlightThemeData> CodeHighlightThemes { get; } = DropdownDataGeneric<CodeHighlightThemes>.GetValues<CodeHighlightThemeData>("CodeHighlightTheme");
+    public string CodeHighlightTheme
+    {
+        get => Settings.CodeHighlightTheme;
+        set
+        {
+            Settings.CodeHighlightTheme = value;
+            PreviewMarkdownScrollViewer.ApplyCodeHighlightTheme(
+                value, ThemeManager.Current.ActualApplicationTheme == ApplicationTheme.Dark);
+            _ = _theme.RefreshFrameAsync();
+        }
+    }
+
     public List<string> TimeFormatList { get; } = new()
     {
         "h:mm",
diff --git a/Flow.Launcher/SettingPages/Views/SettingsPaneTheme.xaml b/Flow.Launcher/SettingPages/Views/SettingsPaneTheme.xaml
index 20b8dfb9ca2..edb87572a04 100644
--- a/Flow.Launcher/SettingPages/Views/SettingsPaneTheme.xaml
+++ b/Flow.Launcher/SettingPages/Views/SettingsPaneTheme.xaml
@@ -800,6 +800,24 @@
                     SelectedValuePath="Value" />
             </ui:SettingsCard>
 
+            <!--  Code highlight theme for markdown preview code blocks  -->
+            <ui:SettingsCard
+                Margin="0 14 0 0"
+                Description="{DynamicResource CodeHighlightThemeTooltip}"
+                Header="{DynamicResource CodeHighlightTheme}">
+                <ui:SettingsCard.HeaderIcon>
+                    <ui:FontIcon Glyph="&#xe943;" />
+                </ui:SettingsCard.HeaderIcon>
+
+                <ComboBox
+                    MinWidth="180"
+                    DisplayMemberPath="Display"
+                    FontSize="14"
+                    ItemsSource="{Binding CodeHighlightThemes}"
+                    SelectedValue="{Binding CodeHighlightTheme, Mode=TwoWay}"
+                    SelectedValuePath="Value" />
+            </ui:SettingsCard>
+
             <!--  Theme folder  -->
             <ui:SettingsCard Margin="0 14 0 0" Header="{DynamicResource ThemeFolder}">
                 <ui:SettingsCard.HeaderIcon>
diff --git a/Flow.Launcher/Themes/Base.xaml b/Flow.Launcher/Themes/Base.xaml
index c5b45890bf4..de9d040514c 100644
--- a/Flow.Launcher/Themes/Base.xaml
+++ b/Flow.Launcher/Themes/Base.xaml
@@ -363,6 +363,59 @@
             </Setter.Value>
         </Setter>
     </Style>
+
+    <!--  thumb for horizontal scrollbars (the draggable part) -->
+    <Style x:Key="BaseHorizontalThumbStyle" TargetType="{x:Type Thumb}">
+        <Setter Property="SnapsToDevicePixels" Value="True" />
+        <Setter Property="OverridesDefaultStyle" Value="true" />
+        <Setter Property="IsTabStop" Value="false" />
+        <Setter Property="Focusable" Value="false" />
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="{x:Type Thumb}">
+                    <Border
+                        Background="#898989"
+                        BorderBrush="Transparent"
+                        CornerRadius="2" />
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+    </Style>
+
+    <!--  horizontal scrollbar  -->
+    <Style x:Key="BaseHorizontalScrollBarStyle" TargetType="{x:Type ScrollBar}">
+        <Setter Property="Stylus.IsPressAndHoldEnabled" Value="false" />
+        <Setter Property="Stylus.IsFlicksEnabled" Value="false" />
+        <Setter Property="Background" Value="Black" />
+        <Setter Property="Height" Value="5" />
+        <Setter Property="MinHeight" Value="5" />
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="{x:Type ScrollBar}">
+                    <DockPanel>
+                        <Track
+                            x:Name="PART_Track"
+                            DockPanel.Dock="Bottom">
+                            <Track.Thumb>
+                                <Thumb Style="{DynamicResource HorizontalThumbStyle}" />
+                            </Track.Thumb>
+                        </Track>
+                    </DockPanel>
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+    </Style>
+
+    <!--  Dynamic-resource fallbacks for horizontal scrollbar — themes can override these keys.  -->
+    <Style
+        x:Key="HorizontalThumbStyle"
+        BasedOn="{StaticResource BaseHorizontalThumbStyle}"
+        TargetType="{x:Type Thumb}" />
+    <Style
+        x:Key="HorizontalScrollBarStyle"
+        BasedOn="{StaticResource BaseHorizontalScrollBarStyle}"
+        TargetType="{x:Type ScrollBar}" />
+
     <Style x:Key="BaseSeparatorStyle" TargetType="Rectangle" />
     <Style x:Key="HighlightStyle">
         <Setter Property="Inline.FontWeight" Value="Bold" />
@@ -578,6 +631,224 @@
         <Setter Property="UseLayoutRounding" Value="True" />
         <Setter Property="SnapsToDevicePixels" Value="True" />
     </Style>
+    <Style x:Key="PreviewMarkdownStyle" TargetType="{x:Type FlowDocument}">
+        <Setter Property="FontFamily" Value="{DynamicResource ContentControlThemeFontFamily}" />
+        <Setter Property="FontSize" Value="13.5" />
+        <Setter Property="FontWeight" Value="Normal" />
+        <Setter Property="Foreground" Value="{DynamicResource Color04B}" />
+        <Setter Property="PagePadding" Value="0 0 24 0" />
+        <Setter Property="TextAlignment" Value="Left" />
+
+        <Style.Resources>
+            <Style TargetType="{x:Type Bold}">
+                <Setter Property="FontFamily" Value="{DynamicResource ContentControlThemeFontFamily}" />
+                <Setter Property="FontWeight" Value="SemiBold" />
+            </Style>
+
+            <Style TargetType="{x:Type Section}">
+                <Style.Triggers>
+                    <Trigger Property="Tag" Value="Blockquote">
+                        <Setter Property="Margin" Value="0 2 0 10" />
+                        <Setter Property="Padding" Value="10 4 0 4" />
+                        <Setter Property="BorderBrush" Value="{DynamicResource BasicSystemAccentColor}" />
+                        <Setter Property="BorderThickness" Value="3 0 0 0" />
+                    </Trigger>
+                </Style.Triggers>
+            </Style>
+
+            <Style xmlns:avalonEdit="clr-namespace:ICSharpCode.AvalonEdit;assembly=ICSharpCode.AvalonEdit" TargetType="avalonEdit:TextEditor">
+                <Setter Property="Background" Value="{DynamicResource Color03B}" />
+                <Setter Property="Foreground" Value="{DynamicResource Color05B}" />
+                <Setter Property="BorderBrush" Value="{DynamicResource SeparatorForeground}" />
+                <Setter Property="BorderThickness" Value="1" />
+                <Setter Property="FontFamily" Value="Cascadia Code, Consolas" />
+                <Setter Property="FontSize" Value="12" />
+                <Setter Property="FontWeight" Value="Normal" />
+                <Setter Property="HorizontalScrollBarVisibility" Value="Auto" />
+                <Setter Property="VerticalScrollBarVisibility" Value="Auto" />
+                <Setter Property="Margin" Value="0 4 14 12" />
+                <Setter Property="Padding" Value="12 10" />
+                <Setter Property="Template">
+                    <Setter.Value>
+                        <ControlTemplate TargetType="avalonEdit:TextEditor">
+                            <Border Background="{TemplateBinding Background}"
+                                    BorderBrush="{TemplateBinding BorderBrush}"
+                                    BorderThickness="{TemplateBinding BorderThickness}"
+                                    CornerRadius="6"
+                                    SnapsToDevicePixels="True">
+                                <ScrollViewer x:Name="PART_ScrollViewer"
+                                              Background="Transparent"
+                                              CanContentScroll="True"
+                                              Content="{Binding TextArea, RelativeSource={RelativeSource TemplatedParent}}"
+                                              Focusable="False"
+                                              HorizontalContentAlignment="Left"
+                                              HorizontalScrollBarVisibility="{TemplateBinding HorizontalScrollBarVisibility}"
+                                              Padding="{TemplateBinding Padding}"
+                                              VerticalContentAlignment="Top"
+                                              VerticalScrollBarVisibility="{TemplateBinding VerticalScrollBarVisibility}">
+                                    <ScrollViewer.Template>
+                                        <ControlTemplate TargetType="{x:Type ScrollViewer}">
+                                            <Grid Background="{TemplateBinding Background}">
+                                                <Grid.ColumnDefinitions>
+                                                    <ColumnDefinition Width="*" />
+                                                    <ColumnDefinition Width="Auto" />
+                                                </Grid.ColumnDefinitions>
+                                                <Grid.RowDefinitions>
+                                                    <RowDefinition Height="*" />
+                                                    <RowDefinition Height="Auto" />
+                                                </Grid.RowDefinitions>
+                                                <ScrollContentPresenter x:Name="PART_ScrollContentPresenter"
+                                                                        Grid.Row="0"
+                                                                        Grid.Column="0"
+                                                                        Margin="{TemplateBinding Padding}"
+                                                                        CanContentScroll="{TemplateBinding CanContentScroll}"
+                                                                        Content="{TemplateBinding Content}"
+                                                                        ContentTemplate="{TemplateBinding ContentTemplate}" />
+                                                <ScrollBar x:Name="PART_VerticalScrollBar"
+                                                           Style="{DynamicResource ScrollBarStyle}"
+                                                           Grid.Row="0"
+                                                           Grid.Column="1"
+                                                           Cursor="Arrow"
+                                                           Maximum="{TemplateBinding ScrollableHeight}"
+                                                           Minimum="0"
+                                                           Orientation="Vertical"
+                                                           ViewportSize="{TemplateBinding ViewportHeight}"
+                                                           Visibility="{TemplateBinding ComputedVerticalScrollBarVisibility}"
+                                                           Value="{Binding VerticalOffset, Mode=OneWay, RelativeSource={RelativeSource TemplatedParent}}" />
+                                                <ScrollBar x:Name="PART_HorizontalScrollBar"
+                                                           Style="{DynamicResource HorizontalScrollBarStyle}"
+                                                           Grid.Row="1"
+                                                           Grid.Column="0"
+                                                           Cursor="Arrow"
+                                                           Maximum="{TemplateBinding ScrollableWidth}"
+                                                           Minimum="0"
+                                                           Orientation="Horizontal"
+                                                           ViewportSize="{TemplateBinding ViewportWidth}"
+                                                           Visibility="{TemplateBinding ComputedHorizontalScrollBarVisibility}"
+                                                           Value="{Binding HorizontalOffset, Mode=OneWay, RelativeSource={RelativeSource TemplatedParent}}" />
+                                            </Grid>
+                                        </ControlTemplate>
+                                    </ScrollViewer.Template>
+                                </ScrollViewer>
+                            </Border>
+                        </ControlTemplate>
+                    </Setter.Value>
+                </Setter>
+            </Style>
+
+            <Style TargetType="{x:Type Paragraph}">
+                <Setter Property="Margin" Value="0 0 0 10" />
+                <Setter Property="LineHeight" Value="20" />
+
+                <Style.Triggers>
+                    <Trigger Property="Tag" Value="Heading1">
+                        <Setter Property="Margin" Value="0 0 0 8" />
+                        <Setter Property="Foreground" Value="{DynamicResource Color05B}" />
+                        <Setter Property="FontSize" Value="16" />
+                        <Setter Property="FontWeight" Value="SemiBold" />
+                    </Trigger>
+
+                    <Trigger Property="Tag" Value="Heading2">
+                        <Setter Property="Margin" Value="0 0 0 8" />
+                        <Setter Property="Foreground" Value="{DynamicResource Color05B}" />
+                        <Setter Property="FontSize" Value="14" />
+                        <Setter Property="FontWeight" Value="SemiBold" />
+                    </Trigger>
+
+                    <Trigger Property="Tag" Value="Heading3">
+                        <Setter Property="Margin" Value="0 0 0 6" />
+                        <Setter Property="Foreground" Value="{DynamicResource Color05B}" />
+                        <Setter Property="FontSize" Value="13" />
+                        <Setter Property="FontWeight" Value="SemiBold" />
+                    </Trigger>
+
+                    <Trigger Property="Tag" Value="Heading4">
+                        <Setter Property="Margin" Value="0 0 0 6" />
+                        <Setter Property="Foreground" Value="{DynamicResource Color05B}" />
+                        <Setter Property="FontSize" Value="13" />
+                        <Setter Property="FontWeight" Value="SemiBold" />
+                    </Trigger>
+
+                    <Trigger Property="Tag" Value="Heading5">
+                        <Setter Property="Margin" Value="0 0 0 6" />
+                        <Setter Property="Foreground" Value="{DynamicResource Color05B}" />
+                        <Setter Property="FontSize" Value="13" />
+                        <Setter Property="FontWeight" Value="SemiBold" />
+                    </Trigger>
+
+                    <Trigger Property="Tag" Value="Heading6">
+                        <Setter Property="Margin" Value="0 0 0 6" />
+                        <Setter Property="Foreground" Value="{DynamicResource Color05B}" />
+                        <Setter Property="FontSize" Value="13" />
+                        <Setter Property="FontWeight" Value="SemiBold" />
+                    </Trigger>
+
+                    <Trigger Property="Tag" Value="CodeBlock">
+                        <Setter Property="Background" Value="{DynamicResource Color03B}" />
+                        <Setter Property="BorderBrush" Value="{DynamicResource SeparatorForeground}" />
+                        <Setter Property="BorderThickness" Value="1" />
+                        <Setter Property="Foreground" Value="{DynamicResource Color05B}" />
+                        <Setter Property="FontFamily" Value="Cascadia Code, Consolas" />
+                        <Setter Property="FontSize" Value="12" />
+                        <Setter Property="LineHeight" Value="18" />
+                        <Setter Property="Padding" Value="8" />
+                    </Trigger>
+                </Style.Triggers>
+            </Style>
+
+            <Style TargetType="{x:Type Run}">
+                <Style.Triggers>
+                    <Trigger Property="Tag" Value="CodeSpan">
+                        <Setter Property="Background" Value="{DynamicResource Color03B}" />
+                        <Setter Property="Foreground" Value="{DynamicResource Color05B}" />
+                        <Setter Property="FontFamily" Value="Cascadia Code, Consolas" />
+                        <Setter Property="FontSize" Value="12" />
+                    </Trigger>
+                </Style.Triggers>
+            </Style>
+
+            <Style TargetType="{x:Type Span}">
+                <Style.Triggers>
+                    <Trigger Property="Tag" Value="CodeSpan">
+                        <Setter Property="Background" Value="{DynamicResource Color03B}" />
+                        <Setter Property="Foreground" Value="{DynamicResource Color05B}" />
+                        <Setter Property="FontFamily" Value="Cascadia Code, Consolas" />
+                        <Setter Property="FontSize" Value="12" />
+                    </Trigger>
+                </Style.Triggers>
+            </Style>
+
+            <!--  Links keep their underline as a non-colour cue for accessibility.  -->
+            <Style TargetType="{x:Type Hyperlink}">
+                <Setter Property="Foreground" Value="{DynamicResource BasicSystemAccentColor}" />
+            </Style>
+
+            <Style TargetType="{x:Type List}">
+                <Setter Property="Margin" Value="16 0 0 10" />
+                <Setter Property="Padding" Value="8 0 0 0" />
+            </Style>
+
+            <Style TargetType="{x:Type BlockUIContainer}">
+                <Style.Triggers>
+                    <Trigger Property="Tag" Value="RuleSingle">
+                        <Setter Property="Margin" Value="0 2 0 10" />
+                    </Trigger>
+
+                    <Trigger Property="Tag" Value="RuleDouble">
+                        <Setter Property="Margin" Value="0 2 0 10" />
+                    </Trigger>
+
+                    <Trigger Property="Tag" Value="RuleBold">
+                        <Setter Property="Margin" Value="0 2 0 10" />
+                    </Trigger>
+
+                    <Trigger Property="Tag" Value="RuleBoldWithSingle">
+                        <Setter Property="Margin" Value="0 2 0 10" />
+                    </Trigger>
+                </Style.Triggers>
+            </Style>
+        </Style.Resources>
+    </Style>
     <!--  Style for old version themes  -->
     <Style
         x:Key="PreviewItemTitleStyle"
diff --git a/Flow.Launcher/Themes/BlurBlack Darker.xaml b/Flow.Launcher/Themes/BlurBlack Darker.xaml
index b6864198443..6a7b83cf0a0 100644
--- a/Flow.Launcher/Themes/BlurBlack Darker.xaml	
+++ b/Flow.Launcher/Themes/BlurBlack Darker.xaml	
@@ -137,6 +137,27 @@
         TargetType="{x:Type ScrollBar}">
         <Setter Property="Background" Value="#a0a0a0" />
     </Style>
+    <Style
+        x:Key="HorizontalScrollBarStyle"
+        BasedOn="{StaticResource BaseHorizontalScrollBarStyle}"
+        TargetType="{x:Type ScrollBar}" />
+    <Style
+        x:Key="HorizontalThumbStyle"
+        BasedOn="{StaticResource BaseHorizontalThumbStyle}"
+        TargetType="{x:Type Thumb}">
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="{x:Type Thumb}">
+                    <Border
+                        Background="#FFFFFF"
+                        BorderBrush="Transparent"
+                        BorderThickness="0"
+                        CornerRadius="2"
+                        Opacity="0.5" />
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+    </Style>
     <Style
         x:Key="SearchIconStyle"
         BasedOn="{StaticResource BaseSearchIconStyle}"
diff --git a/Flow.Launcher/Themes/BlurBlack.xaml b/Flow.Launcher/Themes/BlurBlack.xaml
index 5ce3932e1d0..69b1cb8485d 100644
--- a/Flow.Launcher/Themes/BlurBlack.xaml
+++ b/Flow.Launcher/Themes/BlurBlack.xaml
@@ -134,6 +134,27 @@
         TargetType="{x:Type ScrollBar}">
         <Setter Property="Background" Value="#a0a0a0" />
     </Style>
+    <Style
+        x:Key="HorizontalScrollBarStyle"
+        BasedOn="{StaticResource BaseHorizontalScrollBarStyle}"
+        TargetType="{x:Type ScrollBar}" />
+    <Style
+        x:Key="HorizontalThumbStyle"
+        BasedOn="{StaticResource BaseHorizontalThumbStyle}"
+        TargetType="{x:Type Thumb}">
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="{x:Type Thumb}">
+                    <Border
+                        Background="#ffffff"
+                        BorderBrush="Transparent"
+                        BorderThickness="0"
+                        CornerRadius="2"
+                        Opacity="0.5" />
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+    </Style>
     <Style
         x:Key="SearchIconStyle"
         BasedOn="{StaticResource BaseSearchIconStyle}"
diff --git a/Flow.Launcher/Themes/BlurWhite.xaml b/Flow.Launcher/Themes/BlurWhite.xaml
index 43cd8f4b53f..4fc566eef35 100644
--- a/Flow.Launcher/Themes/BlurWhite.xaml
+++ b/Flow.Launcher/Themes/BlurWhite.xaml
@@ -141,6 +141,26 @@
         TargetType="{x:Type ScrollBar}">
         <Setter Property="Background" Value="#a0a0a0" />
     </Style>
+    <Style
+        x:Key="HorizontalScrollBarStyle"
+        BasedOn="{StaticResource BaseHorizontalScrollBarStyle}"
+        TargetType="{x:Type ScrollBar}" />
+    <Style
+        x:Key="HorizontalThumbStyle"
+        BasedOn="{StaticResource BaseHorizontalThumbStyle}"
+        TargetType="{x:Type Thumb}">
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="{x:Type Thumb}">
+                    <Border
+                        Background="#3C000000"
+                        BorderBrush="Transparent"
+                        BorderThickness="0"
+                        CornerRadius="2" />
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+    </Style>
     <Style
         x:Key="SearchIconStyle"
         BasedOn="{StaticResource BaseSearchIconStyle}"
diff --git a/Flow.Launcher/Themes/Circle System.xaml b/Flow.Launcher/Themes/Circle System.xaml
index dd18ca9548a..c4df49b8001 100644
--- a/Flow.Launcher/Themes/Circle System.xaml	
+++ b/Flow.Launcher/Themes/Circle System.xaml	
@@ -120,6 +120,26 @@
         x:Key="ScrollBarStyle"
         BasedOn="{StaticResource BaseScrollBarStyle}"
         TargetType="{x:Type ScrollBar}" />
+    <Style
+        x:Key="HorizontalScrollBarStyle"
+        BasedOn="{StaticResource BaseHorizontalScrollBarStyle}"
+        TargetType="{x:Type ScrollBar}" />
+    <Style
+        x:Key="HorizontalThumbStyle"
+        BasedOn="{StaticResource BaseHorizontalThumbStyle}"
+        TargetType="{x:Type Thumb}">
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="{x:Type Thumb}">
+                    <Border
+                        Background="#a0a8b5"
+                        BorderBrush="Transparent"
+                        BorderThickness="0"
+                        CornerRadius="2" />
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+    </Style>
     <Style
         x:Key="SearchIconStyle"
         BasedOn="{StaticResource BaseSearchIconStyle}"
diff --git a/Flow.Launcher/Themes/Cyan Dark.xaml b/Flow.Launcher/Themes/Cyan Dark.xaml
index 64523653466..7878a8f3e74 100644
--- a/Flow.Launcher/Themes/Cyan Dark.xaml	
+++ b/Flow.Launcher/Themes/Cyan Dark.xaml	
@@ -130,6 +130,26 @@
         x:Key="ScrollBarStyle"
         BasedOn="{StaticResource BaseScrollBarStyle}"
         TargetType="{x:Type ScrollBar}" />
+    <Style
+        x:Key="HorizontalScrollBarStyle"
+        BasedOn="{StaticResource BaseHorizontalScrollBarStyle}"
+        TargetType="{x:Type ScrollBar}" />
+    <Style
+        x:Key="HorizontalThumbStyle"
+        BasedOn="{StaticResource BaseHorizontalThumbStyle}"
+        TargetType="{x:Type Thumb}">
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="{x:Type Thumb}">
+                    <Border
+                        Background="#768084"
+                        BorderBrush="Transparent"
+                        BorderThickness="0"
+                        CornerRadius="2" />
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+    </Style>
     <Style
         x:Key="SearchIconStyle"
         BasedOn="{StaticResource BaseSearchIconStyle}"
diff --git a/Flow.Launcher/Themes/Darker Glass.xaml b/Flow.Launcher/Themes/Darker Glass.xaml
index 9ffaaf5660a..4378e38f73d 100644
--- a/Flow.Launcher/Themes/Darker Glass.xaml	
+++ b/Flow.Launcher/Themes/Darker Glass.xaml	
@@ -115,6 +115,26 @@
         x:Key="ScrollBarStyle"
         BasedOn="{StaticResource BaseScrollBarStyle}"
         TargetType="{x:Type ScrollBar}" />
+    <Style
+        x:Key="HorizontalScrollBarStyle"
+        BasedOn="{StaticResource BaseHorizontalScrollBarStyle}"
+        TargetType="{x:Type ScrollBar}" />
+    <Style
+        x:Key="HorizontalThumbStyle"
+        BasedOn="{StaticResource BaseHorizontalThumbStyle}"
+        TargetType="{x:Type Thumb}">
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="{x:Type Thumb}">
+                    <Border
+                        Background="#393b40"
+                        BorderBrush="Transparent"
+                        BorderThickness="0"
+                        CornerRadius="2" />
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+    </Style>
     <Style
         x:Key="SearchIconStyle"
         BasedOn="{StaticResource BaseSearchIconStyle}"
diff --git a/Flow.Launcher/Themes/Darker.xaml b/Flow.Launcher/Themes/Darker.xaml
index 7d2614be897..cdda4ed3e4c 100644
--- a/Flow.Launcher/Themes/Darker.xaml
+++ b/Flow.Launcher/Themes/Darker.xaml
@@ -85,6 +85,14 @@
         x:Key="ScrollBarStyle"
         BasedOn="{StaticResource BaseScrollBarStyle}"
         TargetType="{x:Type ScrollBar}" />
+    <Style
+        x:Key="HorizontalScrollBarStyle"
+        BasedOn="{StaticResource BaseHorizontalScrollBarStyle}"
+        TargetType="{x:Type ScrollBar}" />
+    <Style
+        x:Key="HorizontalThumbStyle"
+        BasedOn="{StaticResource BaseHorizontalThumbStyle}"
+        TargetType="{x:Type Thumb}" />
     <Style
         x:Key="SeparatorStyle"
         BasedOn="{StaticResource BaseSeparatorStyle}"
diff --git a/Flow.Launcher/Themes/Discord Dark.xaml b/Flow.Launcher/Themes/Discord Dark.xaml
index c1336309bd7..3bf61fed28d 100644
--- a/Flow.Launcher/Themes/Discord Dark.xaml	
+++ b/Flow.Launcher/Themes/Discord Dark.xaml	
@@ -138,6 +138,26 @@
         x:Key="ScrollBarStyle"
         BasedOn="{StaticResource BaseScrollBarStyle}"
         TargetType="{x:Type ScrollBar}" />
+    <Style
+        x:Key="HorizontalScrollBarStyle"
+        BasedOn="{StaticResource BaseHorizontalScrollBarStyle}"
+        TargetType="{x:Type ScrollBar}" />
+    <Style
+        x:Key="HorizontalThumbStyle"
+        BasedOn="{StaticResource BaseHorizontalThumbStyle}"
+        TargetType="{x:Type Thumb}">
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="{x:Type Thumb}">
+                    <Border
+                        Background="#787881"
+                        BorderBrush="Transparent"
+                        BorderThickness="0"
+                        CornerRadius="2" />
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+    </Style>
     <Style
         x:Key="SeparatorStyle"
         BasedOn="{StaticResource BaseSeparatorStyle}"
diff --git a/Flow.Launcher/Themes/Dracula.xaml b/Flow.Launcher/Themes/Dracula.xaml
index 717d0aaebb7..a1acb5c4241 100644
--- a/Flow.Launcher/Themes/Dracula.xaml
+++ b/Flow.Launcher/Themes/Dracula.xaml
@@ -137,6 +137,26 @@
         x:Key="ScrollBarStyle"
         BasedOn="{StaticResource BaseScrollBarStyle}"
         TargetType="{x:Type ScrollBar}" />
+    <Style
+        x:Key="HorizontalScrollBarStyle"
+        BasedOn="{StaticResource BaseHorizontalScrollBarStyle}"
+        TargetType="{x:Type ScrollBar}" />
+    <Style
+        x:Key="HorizontalThumbStyle"
+        BasedOn="{StaticResource BaseHorizontalThumbStyle}"
+        TargetType="{x:Type Thumb}">
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="{x:Type Thumb}">
+                    <Border
+                        Background="#44475a"
+                        BorderBrush="Transparent"
+                        BorderThickness="0"
+                        CornerRadius="2" />
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+    </Style>
     <Style
         x:Key="SeparatorStyle"
         BasedOn="{StaticResource BaseSeparatorStyle}"
diff --git a/Flow.Launcher/Themes/Gray.xaml b/Flow.Launcher/Themes/Gray.xaml
index 5a928fa72d5..08be25ece1d 100644
--- a/Flow.Launcher/Themes/Gray.xaml
+++ b/Flow.Launcher/Themes/Gray.xaml
@@ -110,6 +110,26 @@
         x:Key="ScrollBarStyle"
         BasedOn="{StaticResource BaseScrollBarStyle}"
         TargetType="{x:Type ScrollBar}" />
+    <Style
+        x:Key="HorizontalScrollBarStyle"
+        BasedOn="{StaticResource BaseHorizontalScrollBarStyle}"
+        TargetType="{x:Type ScrollBar}" />
+    <Style
+        x:Key="HorizontalThumbStyle"
+        BasedOn="{StaticResource BaseHorizontalThumbStyle}"
+        TargetType="{x:Type Thumb}">
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="{x:Type Thumb}">
+                    <Border
+                        Background="#848890"
+                        BorderBrush="Transparent"
+                        BorderThickness="0"
+                        CornerRadius="2" />
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+    </Style>
     <Style
         x:Key="SearchIconStyle"
         BasedOn="{StaticResource BaseSearchIconStyle}"
diff --git a/Flow.Launcher/Themes/League.xaml b/Flow.Launcher/Themes/League.xaml
index 89c6691f85f..54e3e3c085a 100644
--- a/Flow.Launcher/Themes/League.xaml
+++ b/Flow.Launcher/Themes/League.xaml
@@ -107,6 +107,26 @@
         TargetType="{x:Type ScrollBar}">
         <Setter Property="Width" Value="4" />
     </Style>
+    <Style
+        x:Key="HorizontalScrollBarStyle"
+        BasedOn="{StaticResource BaseHorizontalScrollBarStyle}"
+        TargetType="{x:Type ScrollBar}" />
+    <Style
+        x:Key="HorizontalThumbStyle"
+        BasedOn="{StaticResource BaseHorizontalThumbStyle}"
+        TargetType="{x:Type Thumb}">
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="{x:Type Thumb}">
+                    <Border
+                        Background="#b88f3a"
+                        BorderBrush="Transparent"
+                        BorderThickness="0"
+                        CornerRadius="2" />
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+    </Style>
     <Style x:Key="HighlightStyle">
         <Setter Property="Inline.FontWeight" Value="Bold" />
     </Style>
diff --git a/Flow.Launcher/Themes/Midnight.xaml b/Flow.Launcher/Themes/Midnight.xaml
index 134b006d987..58eed2f036c 100644
--- a/Flow.Launcher/Themes/Midnight.xaml
+++ b/Flow.Launcher/Themes/Midnight.xaml
@@ -110,6 +110,26 @@
         x:Key="ScrollBarStyle"
         BasedOn="{StaticResource BaseScrollBarStyle}"
         TargetType="{x:Type ScrollBar}" />
+    <Style
+        x:Key="HorizontalScrollBarStyle"
+        BasedOn="{StaticResource BaseHorizontalScrollBarStyle}"
+        TargetType="{x:Type ScrollBar}" />
+    <Style
+        x:Key="HorizontalThumbStyle"
+        BasedOn="{StaticResource BaseHorizontalThumbStyle}"
+        TargetType="{x:Type Thumb}">
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="{x:Type Thumb}">
+                    <Border
+                        Background="#202938"
+                        BorderBrush="Transparent"
+                        BorderThickness="0"
+                        CornerRadius="2" />
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+    </Style>
     <Style
         x:Key="SearchIconStyle"
         BasedOn="{StaticResource BaseSearchIconStyle}"
diff --git a/Flow.Launcher/Themes/Nord Darker.xaml b/Flow.Launcher/Themes/Nord Darker.xaml
index 7bbc737d193..4ad123b244e 100644
--- a/Flow.Launcher/Themes/Nord Darker.xaml	
+++ b/Flow.Launcher/Themes/Nord Darker.xaml	
@@ -108,6 +108,26 @@
         TargetType="{x:Type ScrollBar}">
         <Setter Property="Width" Value="3" />
     </Style>
+    <Style
+        x:Key="HorizontalScrollBarStyle"
+        BasedOn="{StaticResource BaseHorizontalScrollBarStyle}"
+        TargetType="{x:Type ScrollBar}" />
+    <Style
+        x:Key="HorizontalThumbStyle"
+        BasedOn="{StaticResource BaseHorizontalThumbStyle}"
+        TargetType="{x:Type Thumb}">
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="{x:Type Thumb}">
+                    <Border
+                        Background="#B2B6BE"
+                        BorderBrush="Transparent"
+                        BorderThickness="0"
+                        CornerRadius="2" />
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+    </Style>
     <Style
         x:Key="SearchIconStyle"
         BasedOn="{StaticResource BaseSearchIconStyle}"
diff --git a/Flow.Launcher/Themes/Pink.xaml b/Flow.Launcher/Themes/Pink.xaml
index 619e10bd228..6eb4f93f849 100644
--- a/Flow.Launcher/Themes/Pink.xaml
+++ b/Flow.Launcher/Themes/Pink.xaml
@@ -98,6 +98,26 @@
         x:Key="ScrollBarStyle"
         BasedOn="{StaticResource BaseScrollBarStyle}"
         TargetType="{x:Type ScrollBar}" />
+    <Style
+        x:Key="HorizontalScrollBarStyle"
+        BasedOn="{StaticResource BaseHorizontalScrollBarStyle}"
+        TargetType="{x:Type ScrollBar}" />
+    <Style
+        x:Key="HorizontalThumbStyle"
+        BasedOn="{StaticResource BaseHorizontalThumbStyle}"
+        TargetType="{x:Type Thumb}">
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="{x:Type Thumb}">
+                    <Border
+                        Background="#e564b1"
+                        BorderBrush="Transparent"
+                        BorderThickness="0"
+                        CornerRadius="2" />
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+    </Style>
     <Geometry x:Key="SearchIconImg">F1 M20,20z M0,0z M14.75,1A5.24,5.24,0,0,0,10,4A5.24,5.24,0,0,0,0,6.25C0,11.75 10,19 10,19 10,19 20,11.75 20,6.25A5.25,5.25,0,0,0,14.75,1z</Geometry>
 
     <Style x:Key="SearchIconPosition" TargetType="{x:Type Canvas}">
diff --git a/Flow.Launcher/Themes/SlimLight.xaml b/Flow.Launcher/Themes/SlimLight.xaml
index ab7632f1227..b2c9decea6a 100644
--- a/Flow.Launcher/Themes/SlimLight.xaml
+++ b/Flow.Launcher/Themes/SlimLight.xaml
@@ -131,6 +131,26 @@
         x:Key="ScrollBarStyle"
         BasedOn="{StaticResource BaseScrollBarStyle}"
         TargetType="{x:Type ScrollBar}" />
+    <Style
+        x:Key="HorizontalScrollBarStyle"
+        BasedOn="{StaticResource BaseHorizontalScrollBarStyle}"
+        TargetType="{x:Type ScrollBar}" />
+    <Style
+        x:Key="HorizontalThumbStyle"
+        BasedOn="{StaticResource BaseHorizontalThumbStyle}"
+        TargetType="{x:Type Thumb}">
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="{x:Type Thumb}">
+                    <Border
+                        Background="#878687"
+                        BorderBrush="Transparent"
+                        BorderThickness="0"
+                        CornerRadius="2" />
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+    </Style>
     <Style
         x:Key="SearchIconStyle"
         BasedOn="{StaticResource BaseSearchIconStyle}"
diff --git a/Flow.Launcher/Themes/Sublime.xaml b/Flow.Launcher/Themes/Sublime.xaml
index 02fcb3a056c..1ae6a04ac16 100644
--- a/Flow.Launcher/Themes/Sublime.xaml
+++ b/Flow.Launcher/Themes/Sublime.xaml
@@ -135,6 +135,26 @@
         x:Key="ScrollBarStyle"
         BasedOn="{StaticResource BaseScrollBarStyle}"
         TargetType="{x:Type ScrollBar}" />
+    <Style
+        x:Key="HorizontalScrollBarStyle"
+        BasedOn="{StaticResource BaseHorizontalScrollBarStyle}"
+        TargetType="{x:Type ScrollBar}" />
+    <Style
+        x:Key="HorizontalThumbStyle"
+        BasedOn="{StaticResource BaseHorizontalThumbStyle}"
+        TargetType="{x:Type Thumb}">
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="{x:Type Thumb}">
+                    <Border
+                        Background="#6c7279"
+                        BorderBrush="Transparent"
+                        BorderThickness="0"
+                        CornerRadius="2" />
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+    </Style>
     <Style
         x:Key="SeparatorStyle"
         BasedOn="{StaticResource BaseSeparatorStyle}"
diff --git a/Flow.Launcher/Themes/ThemeBuilder/Template.xaml b/Flow.Launcher/Themes/ThemeBuilder/Template.xaml
index 8d1c4845a4e..9e8cfbb37d3 100644
--- a/Flow.Launcher/Themes/ThemeBuilder/Template.xaml
+++ b/Flow.Launcher/Themes/ThemeBuilder/Template.xaml
@@ -49,4 +49,15 @@
 
     <Style x:Key="ScrollBarStyle" BasedOn="{StaticResource BaseScrollBarStyle}" TargetType="{x:Type ScrollBar}">
     </Style>
+    <Style x:Key="HorizontalScrollBarStyle" BasedOn="{StaticResource BaseHorizontalScrollBarStyle}" TargetType="{x:Type ScrollBar}" />
+    <!--  Be careful: reducing height below default makes the horizontal thumb hard to grab  -->
+    <Style x:Key="HorizontalThumbStyle" BasedOn="{StaticResource BaseHorizontalThumbStyle}" TargetType="{x:Type Thumb}">
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="{x:Type Thumb}">
+                    <Border CornerRadius="2" Background="{%scrollbarColor%}" BorderBrush="Transparent" BorderThickness="0" />
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+    </Style>
 </ResourceDictionary>
diff --git a/Flow.Launcher/Themes/Ubuntu.xaml b/Flow.Launcher/Themes/Ubuntu.xaml
index 330d57b299c..dc2e8f3c9fd 100644
--- a/Flow.Launcher/Themes/Ubuntu.xaml
+++ b/Flow.Launcher/Themes/Ubuntu.xaml
@@ -127,6 +127,26 @@
         x:Key="ScrollBarStyle"
         BasedOn="{StaticResource BaseScrollBarStyle}"
         TargetType="{x:Type ScrollBar}" />
+    <Style
+        x:Key="HorizontalScrollBarStyle"
+        BasedOn="{StaticResource BaseHorizontalScrollBarStyle}"
+        TargetType="{x:Type ScrollBar}" />
+    <Style
+        x:Key="HorizontalThumbStyle"
+        BasedOn="{StaticResource BaseHorizontalThumbStyle}"
+        TargetType="{x:Type Thumb}">
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="{x:Type Thumb}">
+                    <Border
+                        Background="#262626"
+                        BorderBrush="Transparent"
+                        BorderThickness="0"
+                        CornerRadius="2" />
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+    </Style>
     <Style
         x:Key="SearchIconStyle"
         BasedOn="{StaticResource BaseSearchIconStyle}"
diff --git a/Flow.Launcher/Themes/Win10System.xaml b/Flow.Launcher/Themes/Win10System.xaml
index 3b066e15ac3..bbcb10c7a8b 100644
--- a/Flow.Launcher/Themes/Win10System.xaml
+++ b/Flow.Launcher/Themes/Win10System.xaml
@@ -154,6 +154,26 @@
         x:Key="ScrollBarStyle"
         BasedOn="{StaticResource BaseScrollBarStyle}"
         TargetType="{x:Type ScrollBar}" />
+    <Style
+        x:Key="HorizontalScrollBarStyle"
+        BasedOn="{StaticResource BaseHorizontalScrollBarStyle}"
+        TargetType="{x:Type ScrollBar}" />
+    <Style
+        x:Key="HorizontalThumbStyle"
+        BasedOn="{StaticResource BaseHorizontalThumbStyle}"
+        TargetType="{x:Type Thumb}">
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="{x:Type Thumb}">
+                    <Border
+                        Background="{DynamicResource ThumbColor}"
+                        BorderBrush="Transparent"
+                        BorderThickness="0"
+                        CornerRadius="2" />
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+    </Style>
     <Style
         x:Key="SeparatorStyle"
         BasedOn="{StaticResource BaseSeparatorStyle}"
diff --git a/Flow.Launcher/Themes/Win11Light.xaml b/Flow.Launcher/Themes/Win11Light.xaml
index acb0a2784e0..7ada6dcff4b 100644
--- a/Flow.Launcher/Themes/Win11Light.xaml
+++ b/Flow.Launcher/Themes/Win11Light.xaml
@@ -146,6 +146,26 @@
         x:Key="ScrollBarStyle"
         BasedOn="{StaticResource BaseScrollBarStyle}"
         TargetType="{x:Type ScrollBar}" />
+    <Style
+        x:Key="HorizontalScrollBarStyle"
+        BasedOn="{StaticResource BaseHorizontalScrollBarStyle}"
+        TargetType="{x:Type ScrollBar}" />
+    <Style
+        x:Key="HorizontalThumbStyle"
+        BasedOn="{StaticResource BaseHorizontalThumbStyle}"
+        TargetType="{x:Type Thumb}">
+        <Setter Property="Template">
+            <Setter.Value>
+                <ControlTemplate TargetType="{x:Type Thumb}">
+                    <Border
+                        Background="{DynamicResource ThumbColor}"
+                        BorderBrush="Transparent"
+                        BorderThickness="0"
+                        CornerRadius="2" />
+                </ControlTemplate>
+            </Setter.Value>
+        </Setter>
+    </Style>
     <Style
         x:Key="SearchIconStyle"
         BasedOn="{StaticResource BaseSearchIconStyle}"
diff --git a/Flow.Launcher/ViewModel/MainViewModel.cs b/Flow.Launcher/ViewModel/MainViewModel.cs
index 920e5be256c..0672364cf22 100644
--- a/Flow.Launcher/ViewModel/MainViewModel.cs
+++ b/Flow.Launcher/ViewModel/MainViewModel.cs
@@ -178,29 +178,8 @@ public MainViewModel()
             };
             _selectedResults = Results;
 
-            Results.PropertyChanged += (o, args) =>
-            {
-                switch (args.PropertyName)
-                {
-                    case nameof(Results.SelectedItem):
-                        _selectedItemFromQueryResults = true;
-                        PreviewSelectedItem = Results.SelectedItem;
-                        _ = UpdatePreviewAsync();
-                        break;
-                }
-            };
-
-            History.PropertyChanged += (o, args) =>
-            {
-                switch (args.PropertyName)
-                {
-                    case nameof(History.SelectedItem):
-                        _selectedItemFromQueryResults = false;
-                        PreviewSelectedItem = History.SelectedItem;
-                        _ = UpdatePreviewAsync();
-                        break;
-                }
-            };
+            Results.PropertyChanged += OnResultsPropertyChanged;
+            History.PropertyChanged += OnHistoryPropertyChanged;
 
             RegisterViewUpdate();
             _ = RegisterClockAndDateUpdateAsync();
@@ -350,7 +329,7 @@ private async Task ReloadPluginDataAsync()
         }
 
         [RelayCommand]
-        private void LoadHistory()
+        private async Task LoadHistoryAsync()
         {
             if (QueryResultsSelected())
             {
@@ -365,7 +344,7 @@ private void LoadHistory()
             {
                 SelectedResults = Results;
                 PreviewSelectedItem = Results.SelectedItem;
-                _ = UpdatePreviewAsync();
+                await UpdatePreviewAsync();
             }
         }
 
@@ -415,7 +394,7 @@ public void ForwardHistory()
         }
 
         [RelayCommand]
-        private void LoadContextMenu()
+        private async Task LoadContextMenuAsync()
         {
             // For Dialog Jump and right click mode, we need to navigate to the path
             if (_isDialogJump && Settings.DialogJumpResultBehaviour == DialogJumpResultBehaviours.RightClick)
@@ -447,7 +426,7 @@ private void LoadContextMenu()
             {
                 SelectedResults = Results;
                 PreviewSelectedItem = Results.SelectedItem;
-                _ = UpdatePreviewAsync();
+                await UpdatePreviewAsync();
             }
         }
 
@@ -655,13 +634,13 @@ private void SelectNextItem()
         }
 
         [RelayCommand]
-        private void Esc()
+        private async Task EscAsync()
         {
             if (!QueryResultsSelected())
             {
                 SelectedResults = Results;
                 PreviewSelectedItem = Results.SelectedItem;
-                _ = UpdatePreviewAsync();
+                await UpdatePreviewAsync();
             }
             else
             {
@@ -1026,6 +1005,30 @@ private static string VerifyOrSetDefaultHotkey(string hotkey, string defaultHotk
 
         #endregion
 
+        private async void OnResultsPropertyChanged(object sender, PropertyChangedEventArgs args)
+        {
+            switch (args.PropertyName)
+            {
+                case nameof(Results.SelectedItem):
+                    _selectedItemFromQueryResults = true;
+                    PreviewSelectedItem = Results.SelectedItem;
+                    await UpdatePreviewAsync();
+                    break;
+            }
+        }
+
+        private async void OnHistoryPropertyChanged(object sender, PropertyChangedEventArgs args)
+        {
+            switch (args.PropertyName)
+            {
+                case nameof(History.SelectedItem):
+                    _selectedItemFromQueryResults = false;
+                    PreviewSelectedItem = History.SelectedItem;
+                    await UpdatePreviewAsync();
+                    break;
+            }
+        }
+
         #region Preview
 
         private static readonly int ResultAreaColumnPreviewShown = 1;
@@ -1033,6 +1036,10 @@ private static string VerifyOrSetDefaultHotkey(string hotkey, string defaultHotk
 
         private bool? _selectedItemFromQueryResults;
 
+        // User explicitly toggled the preview on or off via F1 / Alt+P.
+        // null = no manual override; the global AlwaysPreview setting decides.
+        private bool? _manualPreviewOverride;
+
         private ResultViewModel _previewSelectedItem;
         public ResultViewModel PreviewSelectedItem
         {
@@ -1081,7 +1088,7 @@ when CanExternalPreviewSelectedResult(out var path):
                     if (InternalPreviewVisible)
                         HideInternalPreview();
 
-                    _ = OpenExternalPreviewAsync(path);
+                    await OpenExternalPreviewAsync(path);
                     break;
 
                 case true
@@ -1098,26 +1105,27 @@ when CanExternalPreviewSelectedResult(out var path):
             }
         }
 
-        private void HidePreview()
+        private async Task HidePreviewAsync()
         {
-            if (PluginManager.UseExternalPreview())
-                _ = CloseExternalPreviewAsync();
+            if (ExternalPreviewVisible)
+                await CloseExternalPreviewAsync();
 
             if (InternalPreviewVisible)
                 HideInternalPreview();
         }
 
         [RelayCommand]
-        private void TogglePreview()
+        private async Task TogglePreviewAsync()
         {
+            // Flip the override, then re-evaluate through UpdatePreviewAsync.
+            // Never/Always results automatically override the toggle from
+            // ShouldShowPreview, so there is no special-casing needed here.
             if (InternalPreviewVisible || ExternalPreviewVisible)
-            {
-                HidePreview();
-            }
+                _manualPreviewOverride = false;
             else
-            {
-                _ = ShowPreviewAsync();
-            }
+                _manualPreviewOverride = true;
+
+            await UpdatePreviewAsync();
         }
 
         private async Task OpenExternalPreviewAsync(string path, bool sendFailToast = true)
@@ -1148,52 +1156,33 @@ private void HideInternalPreview()
             ResultAreaColumn = ResultAreaColumnPreviewHidden;
         }
 
-        public void ResetPreview()
+        // Pure decision: should the pane be visible right now?
+        private bool ShouldShowPreview()
         {
-            switch (Settings.AlwaysPreview)
-            {
-                case true
-                    when PluginManager.AllowAlwaysPreview() && CanExternalPreviewSelectedResult(out var path):
-                    _ = OpenExternalPreviewAsync(path);
-                    break;
-                case true:
-                    ShowInternalPreview();
-                    break;
-                case false:
-                    HidePreview();
-                    break;
-            }
+            if (PreviewSelectedItem?.HidePreviewPane == true) return false;
+            if (PreviewSelectedItem?.ForcePreviewPane == true) return true;
+            return _manualPreviewOverride ?? Settings.AlwaysPreview;
         }
 
+        // Called on every selection change. Never/Always results override the
+        // pane immediately. Normal results leave the pane as-is and refresh.
         private async Task UpdatePreviewAsync()
         {
-            switch (PluginManager.UseExternalPreview())
+            if (ShouldShowPreview())
             {
-                case true
-                    when CanExternalPreviewSelectedResult(out var path):
-                    if (ExternalPreviewVisible)
-                    {
-                        _ = SwitchExternalPreviewAsync(path, false);
-                    }
-                    else if (InternalPreviewVisible)
-                    {
-                        HideInternalPreview();
-                        _ = OpenExternalPreviewAsync(path);
-                    }
-
-                    break;
-                case true
-                    when !CanExternalPreviewSelectedResult(out var _):
-                    if (ExternalPreviewVisible)
-                    {
-                        await CloseExternalPreviewAsync();
-                        ShowInternalPreview();
-                    }
-                    break;
-                case false
-                    when InternalPreviewVisible:
+                if (!InternalPreviewVisible && !ExternalPreviewVisible)
+                    await ShowPreviewAsync();
+                else if (InternalPreviewVisible)
                     PreviewSelectedItem?.LoadPreviewImage();
-                    break;
+                else if (ExternalPreviewVisible
+                         && PluginManager.UseExternalPreview()
+                         && CanExternalPreviewSelectedResult(out var path))
+                    await SwitchExternalPreviewAsync(path, false);
+            }
+            else
+            {
+                if (InternalPreviewVisible || ExternalPreviewVisible)
+                    await HidePreviewAsync();
             }
         }
 
@@ -1205,8 +1194,26 @@ private bool CanExternalPreviewSelectedResult(out string path)
 
         private bool QueryResultsPreviewed()
         {
-            var previewed = PreviewSelectedItem == Results.SelectedItem;
-            return previewed;
+            return PreviewSelectedItem == Results.SelectedItem;
+        }
+
+        // Called when the window reopens. Clears the manual F1 toggle then
+        // evaluates the pane state from scratch.
+        public async Task ResetPreviewAsync()
+        {
+            _manualPreviewOverride = null;
+
+            if (ShouldShowPreview())
+            {
+                if (PluginManager.AllowAlwaysPreview() && CanExternalPreviewSelectedResult(out var path))
+                    await OpenExternalPreviewAsync(path);
+                else
+                    ShowInternalPreview();
+            }
+            else
+            {
+                await HidePreviewAsync();
+            }
         }
 
         #endregion
@@ -2198,6 +2205,9 @@ public async void Hide(bool reset = true)
                     await CloseExternalPreviewAsync();
                 }
 
+                if (InternalPreviewVisible)
+                    HideInternalPreview();
+
                 BackToQueryResults();
 
                 switch (Settings.LastQueryMode)
diff --git a/Flow.Launcher/ViewModel/ResultViewModel.cs b/Flow.Launcher/ViewModel/ResultViewModel.cs
index 077acfce76f..fda21ad584e 100644
--- a/Flow.Launcher/ViewModel/ResultViewModel.cs
+++ b/Flow.Launcher/ViewModel/ResultViewModel.cs
@@ -290,6 +290,14 @@ public void LoadPreviewImage()
 
         public string PreviewDescription => Result.Preview?.Description ?? Result.SubTitle;
 
+        public bool IsMarkdownPreview => Result.Preview?.ContentType == PreviewContentType.Markdown;
+
+        // PreviewVisibility.Never opts the result out of the preview pane entirely; PreviewVisibility.Always
+        // forces it open. Both are independent of the content type, which only controls rendering.
+        public bool HidePreviewPane => Result.PreviewVisibility == PreviewVisibility.Never;
+
+        public bool ForcePreviewPane => Result.PreviewVisibility == PreviewVisibility.Always;
+
         public Result Result { get; }
         public int ResultProgress
         {
diff --git a/Flow.Launcher/packages.lock.json b/Flow.Launcher/packages.lock.json
index b4b929d1965..24de2f294c2 100644
--- a/Flow.Launcher/packages.lock.json
+++ b/Flow.Launcher/packages.lock.json
@@ -2,6 +2,12 @@
   "version": 1,
   "dependencies": {
     "net9.0-windows10.0.19041": {
+      "AvalonEdit": {
+        "type": "Direct",
+        "requested": "[6.3.0.90, )",
+        "resolved": "6.3.0.90",
+        "contentHash": "WVTb5MxwGqKdeasd3nG5udlV4t6OpvkFanziwI133K0/QJ5FvZmfzRQgpAjGTJhQfIA8GP7AzKQ3sTY9JOFk8Q=="
+      },
       "ChefKeys": {
         "type": "Direct",
         "requested": "[0.1.2, )",
@@ -167,11 +173,6 @@
         "resolved": "2.3.1",
         "contentHash": "imph3SJqFFgX8vc7XRBcftfgzIL7Q+uE0Tvk7dbY0KY0tcqUCs0ZmKV3Gt9QX2745v6bSw6ns8UHpXtiptHqdA=="
       },
-      "AvalonEdit": {
-        "type": "Transitive",
-        "resolved": "6.3.0.90",
-        "contentHash": "WVTb5MxwGqKdeasd3nG5udlV4t6OpvkFanziwI133K0/QJ5FvZmfzRQgpAjGTJhQfIA8GP7AzKQ3sTY9JOFk8Q=="
-      },
       "Ben.Demystifier": {
         "type": "Transitive",
         "resolved": "0.4.1",
@@ -1619,7 +1620,7 @@
           "FSharp.Core": "[9.0.303, )",
           "Flow.Launcher.Infrastructure": "[1.0.0, )",
           "Flow.Launcher.Localization": "[0.0.6, )",
-          "Flow.Launcher.Plugin": "[5.0.0, )",
+          "Flow.Launcher.Plugin": "[5.3.0, )",
           "Meziantou.Framework.Win32.Jobs": "[3.4.5, )",
           "Microsoft.IO.RecyclableMemoryStream": "[3.0.1, )",
           "SemanticVersioning": "[3.0.0, )",
@@ -1634,7 +1635,7 @@
           "BitFaster.Caching": "[2.5.4, )",
           "CommunityToolkit.Mvvm": "[8.4.0, )",
           "Flow.Launcher.Localization": "[0.0.6, )",
-          "Flow.Launcher.Plugin": "[5.0.0, )",
+          "Flow.Launcher.Plugin": "[5.3.0, )",
           "InputSimulator": "[1.0.4, )",
           "MemoryPack": "[1.21.4, )",
           "Microsoft.VisualStudio.Threading": "[17.14.15, )",