diff --git a/source/Cute.Lib/Extensions/StringExtensions.cs b/source/Cute.Lib/Extensions/StringExtensions.cs
index cee3397..5d0f87a 100644
--- a/source/Cute.Lib/Extensions/StringExtensions.cs
+++ b/source/Cute.Lib/Extensions/StringExtensions.cs
@@ -64,6 +64,61 @@ public static string Snip(this string text, int snipTo)
         return text[..(snipTo - 1)] + "..";
     }
 
+    public static IEnumerable<string> GetFixedLines(this ReadOnlySpan<char> input, int maxLineLength = 80)
+    {
+        var lines = new List<string>();
+
+        while (!input.IsEmpty)
+        {
+            // Find the maximum slice we can take for this line
+            var length = Math.Min(maxLineLength, input.Length);
+            var slice = input[..length]; // Using the range operator here for slicing
+
+            // Find the first occurrence of \r or \n
+            var firstNewlineIndex = slice.IndexOfAny('\r', '\n');
+            // Find the last occurrence of a space
+            var lastSpaceIndex = slice.LastIndexOf(' ');
+
+            if (lastSpaceIndex != -1 && firstNewlineIndex > lastSpaceIndex)
+            {
+                lastSpaceIndex = -1;
+            }
+
+            if (lastSpaceIndex != -1 && length < maxLineLength)
+            {
+                lastSpaceIndex = -1;
+            }
+
+            // Break at the first newline character
+            if (firstNewlineIndex != -1 && (firstNewlineIndex < lastSpaceIndex || lastSpaceIndex == -1))
+            {
+                lines.Add(slice[..firstNewlineIndex].ToString());
+
+                // Handle \r\n as a single line break
+                if (firstNewlineIndex + 1 < input.Length && input[firstNewlineIndex] == '\r' && input[firstNewlineIndex + 1] == '\n')
+                    input = input[(firstNewlineIndex + 2)..]; // Skip \r\n using range
+                else
+                    input = input[(firstNewlineIndex + 1)..]; // Skip \r or \n using range
+
+                continue;
+            }
+
+            // Break at the last space if no newline is found earlier
+            if (lastSpaceIndex != -1)
+            {
+                lines.Add(slice[..lastSpaceIndex].ToString());
+                input = input[(lastSpaceIndex + 1)..]; // Skip the space using range
+                continue;
+            }
+
+            // If no space or newline was found, just break at max length
+            lines.Add(slice.ToString());
+            input = input[length..]; // Move to the next chunk using range operator
+        }
+
+        return lines;
+    }
+
     [GeneratedRegex(@"\s+")]
     private static partial Regex MultiWhiteSpace();
 
diff --git a/source/Cute/Commands/Chat/ChatCommand.cs b/source/Cute/Commands/Chat/ChatCommand.cs
index 84964b0..a295a22 100644
--- a/source/Cute/Commands/Chat/ChatCommand.cs
+++ b/source/Cute/Commands/Chat/ChatCommand.cs
@@ -15,6 +15,7 @@
 using Cute.Lib.Extensions;
 using Cute.Services;
 using Cute.Services.CliCommandInfo;
+using Cute.Services.Markdown;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 using OpenAI.Chat;
@@ -182,12 +183,13 @@ await AnsiConsole.Status()
             AnsiConsole.MarkupLine(_console.FormatToMarkup($"Presence Penalty  : {chatCompletionOptions.PresencePenalty}", Globals.StyleDim, Globals.StyleSubHeading));
             _console.WriteBlankLine();
             _console.WriteRuler();
-            _console.WriteBlankLine();
         }
 
+        _console.WriteBlankLine();
+
         if (settings.Key is not null)
         {
-            _console.WriteNormalWithHighlights($"Press {"<Enter>"} on a blank line to submit your prompt. (i.e. type your prompt and press {"<Enter>"} twice to submit your prompt).", Globals.StyleHeading);
+            _console.WriteNormalWithHighlights($"Press {"<Enter>"} on a blank line to submit your prompt. (i.e. type your prompt and press {"<Enter>"} twice).", Globals.StyleHeading);
             _console.WriteBlankLine();
         }
 
@@ -240,7 +242,25 @@ await AnsiConsole.Status()
 
             _console.WriteBlankLine();
 
-            if (botResponse.Answer is not null) _console.WriteSubHeading(botResponse.Answer);
+            if (botResponse.Answer is not null)
+            {
+                if (settings.Key == null)
+                {
+                    _console.WriteSubHeading(botResponse.Answer);
+                }
+                else
+                {
+                    MarkdownConsole.Write(botResponse.Answer);
+                }
+            }
+
+            if (botResponse.Type == "Exit")
+            {
+                _console.WriteBlankLine();
+                _console.WriteAlert($"{SayBye()}!");
+                _console.WriteBlankLine();
+                break;
+            }
 
             if (botResponse.Question is not null && botResponse.Question.Contains("Shall we give it a shot?"))
             {
@@ -249,8 +269,11 @@ await AnsiConsole.Status()
                 continue;
             }
 
-            _console.WriteBlankLine();
-            if (botResponse.Question is not null) _console.WriteSubHeading(botResponse.Question);
+            if (botResponse.Question is not null)
+            {
+                _console.WriteBlankLine();
+                _console.WriteSubHeading(botResponse.Question);
+            }
         }
 
         return 0;
@@ -380,7 +403,8 @@ When asked your name you always quote something profound from HHGTTG.
             "answer" is a JSON string and contains your best answer. Keep them punchy.
             "question" is a JSON string and contains your next question for the user to help them reach their goal.
             "queryOrCommand" is a JSON string and contains the accurate CLI command or GraphQl query that will achieve the goal.
-            "type" contains "GraphQL" or "CLI" depending on what is in "queryOrCommand".
+            "type" contains "GraphQL" or "CLI" to execte commands depending on what is in "queryOrCommand".
+            "type" contains "Exit" if the user wants to leave the conversation or quit the app.
             "queryOrCommand" and "type" MUST only supplied when you ask "Shall we give it a shot?" when the goal is clear to you.
             These fields MUST always contain valid JSON strings. No other data types are allowed in them.
             Only output the JSON structure, one object per response.
@@ -436,13 +460,13 @@ If a fiels is a Link to another entry then the child entry fields are valid to u
             When generating CLI commands with parameters, the use of single quotes (') to delimit a string is NOT supported.
             Always use doube quotes (") to delimit strings for commands and escape any double quotes with a slash (\")
             Never escape double quotes unless they are inside unescaped quotes on the command line
-            Regex expressions are currently NOT supported in edit or find or replace expressions. Don't suggest them
+            Regex expressions are NOT supported in edit or find or replace expressions. Don't suggest them ever.
             """";
     }
 
     private static string BuildContentTypesPromptInfo(IEnumerable<ContentType> contentTypes)
     {
-        string[] excludePrefix = ["ux", "ui", "cute", "meta"];
+        string[] excludePrefix = ["ux", "ui", "meta"];
 
         var sbContentTypesInfo = new StringBuilder();
         foreach (var contentType in contentTypes.OrderBy(ct => ct.Id()))
diff --git a/source/Cute/Commands/_Legacy/WebCommand.cs b/source/Cute/Commands/_Legacy/WebCommand.cs
index 963bf47..c75df2d 100644
--- a/source/Cute/Commands/_Legacy/WebCommand.cs
+++ b/source/Cute/Commands/_Legacy/WebCommand.cs
@@ -217,7 +217,7 @@ private async Task DisplaySettings(HttpContext context)
     private const string _prettifyColors = """
         <style>
         .atv,.str{color:#ec7600}.kwd{color:#93c763}.com{color:#66747b}.typ{color:#678cb1}.lit{color:#facd22}.pln,.pun{color:#f1f2f3}.tag{color:#8ac763}
-        .atn{color:#e0e2e4}.dec{color:purple}pre.prettyprint{border:0 solid #888}ol.linenums{margin-top:0;margin-bottom:0}.prettyprint{background:#000}
+        .atn{color:#e0e2e4}.dec{color:{_highlighted}}pre.prettyprint{border:0 solid #888}ol.linenums{margin-top:0;margin-bottom:0}.prettyprint{background:#000}
         li.L0,li.L1,li.L2,li.L3,li.L4,li.L5,li.L6,li.L7,li.L8,li.L9{color:#555;list-style-type:decimal}
         li.L1,li.L3,li.L5,li.L7,li.L9{background:#111}@media print{.kwd,.tag,.typ{font-weight:700}.atv,.str{color:#060}.kwd,.tag{color:#006}
         .com{color:#600;font-style:italic}.typ{color:#404}.lit{color:#044}.pun{color:#440}.pln{color:#000}.atn{color:#404}}
diff --git a/source/Cute/Cute.csproj b/source/Cute/Cute.csproj
index cb92dea..7bf37b1 100644
--- a/source/Cute/Cute.csproj
+++ b/source/Cute/Cute.csproj
@@ -31,6 +31,7 @@
 		<None Include="..\..\README.md" Pack="true" PackagePath="\" />
 	</ItemGroup>
 	<ItemGroup>
+		<PackageReference Include="Markdig" Version="0.37.0" />
 		<PackageReference Include="Microsoft.AspNetCore.DataProtection" Version="8.0.8" />
 		<PackageReference Include="Microsoft.AspNetCore.DataProtection.Extensions" Version="8.0.8" />
 		<PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="8.0.0" />
@@ -38,6 +39,7 @@
 		<PackageReference Include="ReadLine" Version="2.0.1" />
 		<PackageReference Include="Spectre.Console" Version="0.49.1" />
 		<PackageReference Include="Spectre.Console.Cli" Version="0.49.1" />
+		<PackageReference Include="Spectre.Console.ImageSharp" Version="0.49.1" />
 		<PackageReference Include="System.CommandLine" Version="2.0.0-beta4.22272.1" />
 		<PackageReference Include="System.Formats.Asn1" Version="8.0.1" />
 	</ItemGroup>
diff --git a/source/Cute/Services/Markdown/Converters/AnsiSupportConverter.cs b/source/Cute/Services/Markdown/Converters/AnsiSupportConverter.cs
new file mode 100644
index 0000000..581d8b4
--- /dev/null
+++ b/source/Cute/Services/Markdown/Converters/AnsiSupportConverter.cs
@@ -0,0 +1,11 @@
+using Spectre.Console;
+
+namespace Cute.Services.Markdown.Console.Converters;
+
+internal static class AnsiSupportConverter
+{
+    internal static AnsiSupport FromAnsiSupported(bool ansiSupported) =>
+        ansiSupported
+            ? AnsiSupport.Yes
+            : AnsiSupport.No;
+}
diff --git a/source/Cute/Services/Markdown/Converters/ColorSystemSupportConverter.cs b/source/Cute/Services/Markdown/Converters/ColorSystemSupportConverter.cs
new file mode 100644
index 0000000..d677abe
--- /dev/null
+++ b/source/Cute/Services/Markdown/Converters/ColorSystemSupportConverter.cs
@@ -0,0 +1,20 @@
+using Cute.Services.Markdown.Console.Renderers;
+using Spectre.Console;
+
+namespace Cute.Services.Markdown.Console.Converters;
+
+internal static class ColorSystemSupportConverter
+{
+    internal static ColorSystemSupport FromColorSystem(ColorSystem colorSystem)
+    {
+        return (colorSystem) switch
+        {
+            ColorSystem.EightBit => ColorSystemSupport.EightBit,
+            ColorSystem.Legacy => ColorSystemSupport.Legacy,
+            ColorSystem.NoColors => ColorSystemSupport.NoColors,
+            ColorSystem.Standard => ColorSystemSupport.Standard,
+            ColorSystem.TrueColor => ColorSystemSupport.TrueColor,
+            _ => ColorSystemSupport.Detect
+        };
+    }
+}
diff --git a/source/Cute/Services/Markdown/Extensions/ObjectExtenions.cs b/source/Cute/Services/Markdown/Extensions/ObjectExtenions.cs
new file mode 100644
index 0000000..9030ac6
--- /dev/null
+++ b/source/Cute/Services/Markdown/Extensions/ObjectExtenions.cs
@@ -0,0 +1,9 @@
+using System;
+
+namespace Cute.Services.Markdown.Console.Extensions;
+
+public static class ObjectExtensions
+{
+    public static string ToNotNullString(this object obj) =>
+        obj.ToString() ?? string.Empty;
+}
diff --git a/source/Cute/Services/Markdown/Formatters/NumberFormatter.cs b/source/Cute/Services/Markdown/Formatters/NumberFormatter.cs
new file mode 100644
index 0000000..236ddea
--- /dev/null
+++ b/source/Cute/Services/Markdown/Formatters/NumberFormatter.cs
@@ -0,0 +1,24 @@
+using Cute.Services.Markdown.Console.Renderers.CharacterSets;
+
+namespace Cute.Services.Markdown.Console.Formatters;
+
+public class NumberFormatter
+{
+    public string Format(int number, CharacterSet characterSet)
+    {
+        // TODO: There is no fallback if the users font does not support nerd fonts.
+        // Detecting support could be very hard.
+        // Nerd font may need to be a opt in/out feature.
+        return number.ToString()
+            .Replace("0", characterSet.Zero)
+            .Replace("1", characterSet.One)
+            .Replace("2", characterSet.Two)
+            .Replace("3", characterSet.Three)
+            .Replace("4", characterSet.Four)
+            .Replace("5", characterSet.Five)
+            .Replace("6", characterSet.Six)
+            .Replace("7", characterSet.Seven)
+            .Replace("8", characterSet.Eight)
+            .Replace("9", characterSet.Nine);
+    }
+}
diff --git a/source/Cute/Services/Markdown/MarkdownConsole.cs b/source/Cute/Services/Markdown/MarkdownConsole.cs
new file mode 100644
index 0000000..a939741
--- /dev/null
+++ b/source/Cute/Services/Markdown/MarkdownConsole.cs
@@ -0,0 +1,67 @@
+using Cute.Constants;
+using Cute.Services.Markdown.Console.Renderers;
+
+namespace Cute.Services.Markdown;
+
+/// <summary>
+/// Renders markdown in the terminal.
+/// </summary>
+public static class MarkdownConsole
+{
+    private const UseNerdFonts UseNerdFontsDefault = UseNerdFonts.No;
+    private static UseNerdFonts UseNerdFontsField = UseNerdFontsDefault;
+    private static AnsiRenderer DefaultRenderer = GetAnsiRenderer();
+
+    /// <summary>
+    /// Configure Nerd Fonts usage for special characters, like list bullets.
+    /// <see href="https://www.nerdfonts.com/">Nerd Fonts</see> are awesome, but not supported by all fonts.
+    /// </summary>
+    public static UseNerdFonts UseNerdFonts
+    {
+        get => UseNerdFontsField;
+        set
+        {
+            UseNerdFontsField = value;
+            DefaultRenderer = GetAnsiRenderer();
+        }
+    }
+
+    /// <summary>
+    /// Writes formatted markdown in the console.
+    /// </summary>
+    /// <param name="markdown">Markdown to format.</param>
+    public static void Write(string markdown)
+    {
+        DefaultRenderer.Write(markdown);
+    }
+
+    /// <summary>
+    /// Writes formatted markdown in the console.
+    /// </summary>
+    /// <param name="markdown">Markdown to format.</param>
+    /// <param name="writer">
+    ///     Override the default console.
+    ///     <remarks>
+    ///     Useful for test and debugging only.
+    ///     </remarks>
+    /// </param>
+    public static void Write(string markdown, TextWriter writer)
+    {
+        GetAnsiRenderer(writer).Write(markdown);
+    }
+
+    private static AnsiRenderer GetAnsiRenderer()
+    {
+        return new AnsiRendererBuilder()
+            .SetNerdFontsUsage(UseNerdFontsField)
+            .Build();
+    }
+
+    private static AnsiRenderer GetAnsiRenderer(TextWriter writer)
+    {
+        return new AnsiRendererBuilder()
+            .SetNerdFontsUsage(UseNerdFontsField)
+            .RedirectOutput(writer)
+            .Build();
+    }
+}
\ No newline at end of file
diff --git a/source/Cute/Services/Markdown/Options/FeatureFlags.cs b/source/Cute/Services/Markdown/Options/FeatureFlags.cs
new file mode 100644
index 0000000..d22b5a4
--- /dev/null
+++ b/source/Cute/Services/Markdown/Options/FeatureFlags.cs
@@ -0,0 +1,39 @@
+namespace Cute.Services.Markdown.Console.Options;
+
+/// <summary>
+/// Flags that modify the behaviour of the AnsiRenderer.
+/// </summary>
+internal static class FeatureFlags
+{
+    private const string ThrowOnSupportedEnvironmentVariable = "MORELLO_MARKDOWN_CONSOLE_THROW_ON_UNSUPPORTED_TYPE";
+    private const string ForceBasicSyntaxHighlighterEnvironmentVariable = "MORELLO_MARKDOWN_CONSOLE_FORCE_BASIC_SYNTAX_HIGHLIGHTER";
+    private const string ForceAnsiColourEnvironmentVariable = "MORELLO_MARKDOWN_CONSOLE_FORCE_ANSI_COLOUR";
+    private const string True = "true";
+    private const string Yes = "yes";
+    private const string On = "on";
+    private const string Enabled = "enabled";
+    private const string Active = "active";
+
+    /// <summary>
+    /// Disables MarkdownConsole's default behaviour of falling back to plain text when it encounters
+    /// an unsupported Markdown type.
+    /// </summary>
+    public static bool ThrowOnUnsupportedMarkdownType =>
+        EnvironmentVariablePresentAndActive(ThrowOnSupportedEnvironmentVariable);
+
+    public static bool ForceBasicSyntaxHighlighter =>
+        EnvironmentVariablePresentAndActive(ForceBasicSyntaxHighlighterEnvironmentVariable);
+
+    public static bool ForceAnsiColour =>
+        EnvironmentVariablePresentAndActive(ForceAnsiColourEnvironmentVariable);
+
+    private static bool EnvironmentVariablePresentAndActive(string environmentVariableName)
+    {
+        var value = Environment
+            .GetEnvironmentVariable(environmentVariableName)?
+            .ToLower()
+            ?? string.Empty;
+
+        return value is True or Yes or On or Enabled or Active;
+    }
+}
diff --git a/source/Cute/Services/Markdown/Parsers/MarkdownParsers.cs b/source/Cute/Services/Markdown/Parsers/MarkdownParsers.cs
new file mode 100644
index 0000000..405ecbe
--- /dev/null
+++ b/source/Cute/Services/Markdown/Parsers/MarkdownParsers.cs
@@ -0,0 +1,24 @@
+using Markdig;
+using Markdig.Syntax;
+
+namespace Cute.Services.Markdown.Console.Parsers;
+
+/// <summary>
+/// Parses raw markdown text and returns an abstract-syntax-tree representation.
+/// </summary>
+public class MarkdownParser
+{
+    private readonly static MarkdownPipeline _markdownPipeline = new MarkdownPipelineBuilder()
+        .UseAdvancedExtensions()
+        .Build();
+
+    /// <summary>
+    /// Converts markdown into a document.
+    /// /// </summary>
+    /// <param name="markdown">Raw markdown text</param>
+    /// <returns>ABT markdown document</returns>
+    public MarkdownDocument ConvertToMarkdownDocument(string markdown)
+    {
+        return Markdig.Markdown.Parse(markdown, _markdownPipeline);
+    }
+}
diff --git a/source/Cute/Services/Markdown/Renderers/AnsiRenderer.FencedCodes.cs b/source/Cute/Services/Markdown/Renderers/AnsiRenderer.FencedCodes.cs
new file mode 100644
index 0000000..fe452b5
--- /dev/null
+++ b/source/Cute/Services/Markdown/Renderers/AnsiRenderer.FencedCodes.cs
@@ -0,0 +1,25 @@
+using Markdig.Syntax;
+using Cute.Services.Markdown.Console.Options;
+using Spectre.Console;
+
+namespace Cute.Services.Markdown.Console.Renderers;
+
+public partial class AnsiRenderer
+{
+    private void WriteFencedCodeBlock(FencedCodeBlock block)
+    {
+        var code = string.Join("\n", block.Lines.Lines).TrimEnd();
+        var lang = block.Info;
+        var highlightedCode = _syntaxHighlighter.GetHighlightedSyntax(code, lang, FeatureFlags.ForceBasicSyntaxHighlighter);
+
+        // The syntax highlighter will use Ansi escape codes to add colour to the output, if it can.
+        // Although the escape codes are not printed directly AnsiConsole will count them towards
+        // the line limit.  This will lead to unexpected line breaks.  To work around this we override
+        // the buffer width while writing syntax.
+        _console.Profile.Width = int.MaxValue;
+
+        _console.WriteLine(highlightedCode);
+
+        _console.Profile.Width = GetConsoleWidth();
+    }
+}
diff --git a/source/Cute/Services/Markdown/Renderers/AnsiRenderer.Headers.cs b/source/Cute/Services/Markdown/Renderers/AnsiRenderer.Headers.cs
new file mode 100644
index 0000000..c47f9d4
--- /dev/null
+++ b/source/Cute/Services/Markdown/Renderers/AnsiRenderer.Headers.cs
@@ -0,0 +1,29 @@
+using Cute.Constants;
+using Markdig.Syntax;
+using Spectre.Console;
+
+namespace Cute.Services.Markdown.Console.Renderers;
+
+public partial class AnsiRenderer
+{
+    private void WriteHeadingBlock(HeadingBlock block)
+    {
+        var rawContent = block.Inline?.FirstChild?.ToString();
+
+        if (rawContent is not null)
+        {
+            var escapedHeader = rawContent.EscapeMarkup();
+
+            if (block.Level == 1)
+            {
+                _console
+                    .Write(new Text(escapedHeader, Globals.StyleHeading));
+                return;
+            }
+
+            // Levels 2 through 6 are rendered with a common format.
+            // We could differentiate by colour and font weight.
+            _console.MarkupLine($"[bold {_highlighted}]{escapedHeader}[/]");
+        }
+    }
+}
\ No newline at end of file
diff --git a/source/Cute/Services/Markdown/Renderers/AnsiRenderer.Inlines.cs b/source/Cute/Services/Markdown/Renderers/AnsiRenderer.Inlines.cs
new file mode 100644
index 0000000..6ef1ea6
--- /dev/null
+++ b/source/Cute/Services/Markdown/Renderers/AnsiRenderer.Inlines.cs
@@ -0,0 +1,134 @@
+using Cute.Constants;
+using Cute.Lib.Extensions;
+using Markdig.Extensions.TaskLists;
+using Markdig.Syntax.Inlines;
+using Spectre.Console;
+using System.Text;
+
+namespace Cute.Services.Markdown.Console.Renderers;
+
+public partial class AnsiRenderer
+{
+    private bool _isQuote = false;
+
+    private void WriteInlines(IEnumerable<Inline> inlines,
+        string? markupTag = null, int indent = 0)
+    {
+        foreach (var inline in inlines)
+        {
+            switch (inline)
+            {
+                case LiteralInline literal:
+                    WriteLiteralInline(literal.ToString(), markupTag, indent: indent);
+                    break;
+
+                case EmphasisInline emphasis:
+                    WriteEmphasisInline(emphasis, markupTag);
+                    break;
+
+                case CodeInline code:
+                    WriteCodeInline(code);
+                    break;
+
+                case LinkInline link:
+                    WriteInlineLink(link);
+                    break;
+
+                case AutolinkInline link:
+                    WriteAutoInlineLink(link);
+                    break;
+
+                case LineBreakInline:
+                    if (_isQuote)
+                    {
+                        var _quoteLinePrefix = $"[{_highlighted}] {_characterSet.QuotePrefix} [/]";
+                        _console.Markup($"\n{_quoteLinePrefix}");
+                        break;
+                    }
+                    _console.WriteLine();
+                    break;
+
+                case TaskList task:
+                    var bullet = task.Checked ? _characterSet.TaskListBulletDone : _characterSet.TaskListBulletToDo;
+                    _console.Markup($"[{_highlighted}]{bullet.EscapeMarkup()}[/]");
+                    break;
+
+                default:
+                    // We shouldn't be able to get here.
+                    ThrowOrFallbackToPlainText(inline);
+                    break;
+            }
+        }
+    }
+
+    private static string _defaultColor = Globals.StyleSubHeading.Foreground.ToString();
+
+    private void WriteLiteralInline(string content, string? markupTag = null, int indent = 0)
+    {
+        var result = content.EscapeMarkup();
+        var indentation = indent == 0 ? string.Empty : new string(' ', 4 + (indent * 3));
+        var currentLine = 1;
+        var maxchars = 80 - indentation.Length;
+
+        foreach (var line in result.AsSpan().GetFixedLines(maxchars))
+        {
+            var loopIndentation = currentLine == 1 ? string.Empty : indentation;
+            if (markupTag is not null)
+            {
+                _console.Markup($"{loopIndentation}[{markupTag.Trim()} {_defaultColor}]{line}[/]");
+                _console.WriteLine();
+                continue;
+            }
+            if (currentLine > 1)
+            {
+                _console.WriteLine();
+            }
+            _console.Markup($"{loopIndentation}[{_defaultColor}]{line}[/]");
+            currentLine++;
+        }
+    }
+
+    private void WriteEmphasisInline(EmphasisInline emphasis, string? markupTag = null)
+    {
+        switch (emphasis.DelimiterChar)
+        {
+            case '*':
+                markupTag += "bold ";
+                WriteInlines(emphasis, markupTag);
+                break;
+
+            case '_':
+                markupTag += "italic ";
+                WriteInlines(emphasis, markupTag);
+                break;
+
+            case '~':
+                markupTag += "strikethrough ";
+                WriteInlines(emphasis, markupTag);
+                break;
+
+            default:
+                // We shouldn't be able to get here.
+                // All cases of emphasis should be handled above.
+                var exceptionMessage = $"Unsupported emphasis delimited found: {emphasis.DelimiterChar}.";
+                var fallbackText = emphasis?.ToString() ?? string.Empty;
+                ThrowOrFallbackToPlainText(exceptionMessage, fallbackText);
+                break;
+        }
+    }
+
+    private void WriteCodeInline(CodeInline code)
+    {
+        var sb = new StringBuilder();
+
+        sb.Append("[{_highlighted}]");
+        sb.Append(_characterSet.InlineCodeOpening);
+        sb.Append("[invert]");
+        sb.Append(code.Content.EscapeMarkup());
+        sb.Append("[/]");
+        sb.Append(_characterSet.InlineCodeClosing);
+        sb.Append("[/]");
+
+        _console.Markup(sb.ToString());
+    }
+}
\ No newline at end of file
diff --git a/source/Cute/Services/Markdown/Renderers/AnsiRenderer.Links.cs b/source/Cute/Services/Markdown/Renderers/AnsiRenderer.Links.cs
new file mode 100644
index 0000000..089f4c9
--- /dev/null
+++ b/source/Cute/Services/Markdown/Renderers/AnsiRenderer.Links.cs
@@ -0,0 +1,114 @@
+using Markdig.Syntax;
+using Markdig.Syntax.Inlines;
+using Spectre.Console;
+
+namespace Cute.Services.Markdown.Console.Renderers;
+
+public partial class AnsiRenderer
+{
+    private const string CannotDownloadMessage = "Cannot download image";
+    private readonly HttpClient _client = new();
+
+    private void WriteInlineLink(LinkInline link)
+    {
+        var label = link.Label; // ?? link.Descendants().FirstOrDefault()?.ToString();
+        var url = link.Url;
+
+        if (label is null)
+        {
+            // Label may be contain a series of sub items, with different formats.
+            var writer = new StringWriter();
+            var subRenderer = new AnsiRendererBuilder()
+                .InheritSettings(_console)
+                .RedirectOutput(writer)
+                .Build();
+
+            subRenderer.WriteInlines(link.Descendants<Inline>());
+            label = writer.ToString();
+        }
+
+        if (label is null && url is null)
+        {
+            // I'm not sure this is possible.
+            // Without a label and uri there is nothing to show.
+            return;
+        }
+
+        // TODO: Temp fix.  Requires more thought.
+        label ??= "link label missing";
+        url ??= "link uri missing";
+
+        if (link.IsImage)
+        {
+            WriteInlineImageLink(label, url);
+        }
+        else
+        {
+            WriteInlineTextLink(label, url);
+        }
+    }
+
+    private void WriteAutoInlineLink(AutolinkInline link)
+    {
+        // Auto links use the url as the label.
+        // Source: https://spec.commonmark.org/0.30/#autolinks
+        var label = link.Url;
+        var url = label;
+
+        WriteInlineTextLink(label, url);
+    }
+
+    private void WriteInlineTextLink(string label, string url)
+    {
+        _console.Markup($"[{_highlighted} link={url}]{label.EscapeMarkup()}[/]");
+    }
+
+    private void WriteInlineImageLink(string label, string url)
+    {
+        try
+        {
+            var data = File.Exists(url)
+                ? OpenImage(url)
+                : DownloadImage(url);
+
+            if (data is null)
+            {
+                throw new Exception("Cannot download image");
+            }
+
+            var image = new CanvasImage(data);
+            _console.Write(image);
+        }
+        catch
+        {
+            WriteInlineLinkFallback(label, url);
+        }
+    }
+
+    private Stream? OpenImage(string path) => new FileInfo(path).OpenRead();
+
+    private Stream? DownloadImage(string url) => _client.GetStreamAsync(url).Result;
+
+    private void WriteInlineLinkFallback(string label, string uri)
+    {
+        var exceptionMessage = $"Cannot create image link from uri: {uri}.  Falling back to plain text.";
+        var fallbackMarkup = new Markup($"[{_highlighted} italic]{label.EscapeMarkup()}[/]");
+        ThrowOrFallbackToPlainText(exceptionMessage, fallbackMarkup);
+    }
+
+    private void WriteLinkReferenceDefinitionBlock(LinkReferenceDefinitionGroup linkBlock)
+    {
+        foreach (var item in linkBlock)
+        {
+            if (item is LinkReferenceDefinition linkReference)
+            {
+                var escapedTitle = linkReference.Label.EscapeMarkup();
+                _console.Markup($"[link={linkReference.Url}]{escapedTitle}[/]");
+                continue;
+            }
+
+            // We shouldn't be able to get here.
+            ThrowOrFallbackToPlainText(item);
+        }
+    }
+}
\ No newline at end of file
diff --git a/source/Cute/Services/Markdown/Renderers/AnsiRenderer.Lists.cs b/source/Cute/Services/Markdown/Renderers/AnsiRenderer.Lists.cs
new file mode 100644
index 0000000..6792b06
--- /dev/null
+++ b/source/Cute/Services/Markdown/Renderers/AnsiRenderer.Lists.cs
@@ -0,0 +1,49 @@
+using Markdig.Extensions.TaskLists;
+using Markdig.Syntax;
+using Spectre.Console;
+
+namespace Cute.Services.Markdown.Console.Renderers;
+
+public partial class AnsiRenderer
+{
+    private void WriteListBlock(ListBlock block, int indent = 0)
+    {
+        var numberedListCounter = 1;
+
+        foreach (var item in block)
+        {
+            var indentation = new string(' ', indent * 3);
+            var listBullet = $"{indentation} [{_highlighted}]{_characterSet.ListBullet}[/]  ";
+            var bullet = (block.BulletType) switch
+            {
+                '-' => IsTaskList(item) ? "{indentation}  " : listBullet,
+                '1' => $"{indentation} [{_highlighted}]{_numberFormatter.Format(numberedListCounter++, _characterSet)}. [/]",
+                _ => listBullet
+            };
+
+            _console.Markup(bullet);
+
+            foreach (var subItem in (ListItemBlock)item)
+            {
+                if (subItem is ParagraphBlock paragraphBlock)
+                {
+                    WriteParagraphBlock(paragraphBlock, indent: indent);
+                    continue;
+                }
+                else if (subItem is ListBlock subListBlock)
+                {
+                    WriteListBlock(subListBlock, indent + 1);
+                    continue;
+                }
+
+                ThrowOrFallbackToPlainText(subItem);
+            }
+        }
+        _console.WriteLine();
+
+        static bool IsTaskList(Block itemToCheck)
+        {
+            return itemToCheck.Descendants().OfType<TaskList>().Any();
+        }
+    }
+}
\ No newline at end of file
diff --git a/source/Cute/Services/Markdown/Renderers/AnsiRenderer.Paragraphs.cs b/source/Cute/Services/Markdown/Renderers/AnsiRenderer.Paragraphs.cs
new file mode 100644
index 0000000..9d626d9
--- /dev/null
+++ b/source/Cute/Services/Markdown/Renderers/AnsiRenderer.Paragraphs.cs
@@ -0,0 +1,28 @@
+using Markdig.Syntax;
+using Markdig.Syntax.Inlines;
+using Cute.Services.Markdown.Console.Extensions;
+using Spectre.Console;
+
+namespace Cute.Services.Markdown.Console.Renderers;
+
+public partial class AnsiRenderer
+{
+    internal void WriteParagraphBlock(ParagraphBlock block,
+        bool suppressNewLine = false, string? markupTag = null, int indent = 0)
+    {
+        if (block.Inline is not null)
+        {
+            WriteInlines(block.Inline, markupTag, indent: indent);
+
+            if (!suppressNewLine)
+            {
+                _console.Write("\n");
+            }
+
+            return;
+        }
+
+        // We shouldn't be able to get here.
+        ThrowOrFallbackToPlainText(block);
+    }
+}
\ No newline at end of file
diff --git a/source/Cute/Services/Markdown/Renderers/AnsiRenderer.Quotes.cs b/source/Cute/Services/Markdown/Renderers/AnsiRenderer.Quotes.cs
new file mode 100644
index 0000000..b7a57f9
--- /dev/null
+++ b/source/Cute/Services/Markdown/Renderers/AnsiRenderer.Quotes.cs
@@ -0,0 +1,27 @@
+using Markdig.Syntax;
+using Spectre.Console;
+
+namespace Cute.Services.Markdown.Console.Renderers;
+
+public partial class AnsiRenderer
+{
+    private void WriteQuoteBlock(QuoteBlock block)
+    {
+        foreach (var subBlock in block)
+        {
+            if (subBlock is ParagraphBlock paragraph)
+            {
+                _isQuote = true;
+
+                _console.Markup($"[{_highlighted}] {_characterSet.QuotePrefix} [/]");
+                WriteParagraphBlock(paragraph);
+
+                _isQuote = false;
+                return;
+            }
+
+            // We shouldn't be able to get here.
+            ThrowOrFallbackToPlainText(subBlock);
+        }
+    }
+}
diff --git a/source/Cute/Services/Markdown/Renderers/AnsiRenderer.Tables.cs b/source/Cute/Services/Markdown/Renderers/AnsiRenderer.Tables.cs
new file mode 100644
index 0000000..746f3fb
--- /dev/null
+++ b/source/Cute/Services/Markdown/Renderers/AnsiRenderer.Tables.cs
@@ -0,0 +1,60 @@
+using Markdig.Syntax;
+using Spectre.Console;
+using MarkdownTable = Markdig.Extensions.Tables;
+
+namespace Cute.Services.Markdown.Console.Renderers;
+
+public partial class AnsiRenderer
+{
+    private void WriteTableBlock(MarkdownTable.Table block)
+    {
+        var table = new Table().Border(TableBorder.Rounded);
+
+        foreach (var item in block)
+        {
+            if (item is MarkdownTable.TableRow row)
+            {
+                var rows = new List<Markup>();
+
+                foreach (var cellItem in row)
+                {
+                    if (cellItem is MarkdownTable.TableCell cell)
+                    {
+                        foreach (var paragraphItem in cell)
+                        {
+                            if (paragraphItem is ParagraphBlock paragraph)
+                            {
+                                // We use a new instace of this class to generate the contents of
+                                // each cell.  This is because we need to avoid calling write and
+                                // markup methods while building our table.
+                                var buffer = new StringWriter();
+                                var subRenderer = new AnsiRendererBuilder()
+                                    .RedirectOutput(buffer)
+                                    .Build();
+                                subRenderer.WriteParagraphBlock(paragraph, suppressNewLine: true);
+
+                                var escapedBuffer = buffer.ToString().EscapeMarkup();
+                                if (row.IsHeader)
+                                {
+                                    table.AddColumn($"[{_highlighted}]{escapedBuffer}[/]");
+                                }
+                                else
+                                {
+                                    rows.Add(new Markup(escapedBuffer));
+                                }
+                            }
+                        }
+                    }
+
+                }
+
+                if (rows.Any())
+                {
+                    table.AddRow(rows);
+                }
+            }
+        }
+
+        _console.Write(table);
+    }
+}
diff --git a/source/Cute/Services/Markdown/Renderers/AnsiRenderer.ThematicBreaks.cs b/source/Cute/Services/Markdown/Renderers/AnsiRenderer.ThematicBreaks.cs
new file mode 100644
index 0000000..6b9a15b
--- /dev/null
+++ b/source/Cute/Services/Markdown/Renderers/AnsiRenderer.ThematicBreaks.cs
@@ -0,0 +1,16 @@
+using Markdig.Syntax;
+using Spectre.Console;
+
+namespace Cute.Services.Markdown.Console.Renderers;
+
+public partial class AnsiRenderer
+{
+    private void WriteThematicBreakBlock(ThematicBreakBlock thematicBreakBlock)
+    {
+        const char lineCharacter = '═';
+        var charactersRequired = GetConsoleWidth() - 2;
+        var line = new string(lineCharacter, charactersRequired);
+
+        _console.MarkupLine($"[{_highlighted}] {line}[/]");
+    }
+}
diff --git a/source/Cute/Services/Markdown/Renderers/AnsiRenderer.cs b/source/Cute/Services/Markdown/Renderers/AnsiRenderer.cs
new file mode 100644
index 0000000..dacb411
--- /dev/null
+++ b/source/Cute/Services/Markdown/Renderers/AnsiRenderer.cs
@@ -0,0 +1,136 @@
+using Cute.Constants;
+using Cute.Services.Markdown.Console.Formatters;
+using Cute.Services.Markdown.Console.Options;
+using Cute.Services.Markdown.Console.Parsers;
+using Cute.Services.Markdown.Console.Renderers.CharacterSets;
+using Cute.Services.Markdown.Console.SyntaxHighlighters;
+using Markdig.Syntax;
+using Spectre.Console;
+using MarkdownTable = Markdig.Extensions.Tables;
+
+namespace Cute.Services.Markdown.Console.Renderers;
+
+/// <summary>
+/// Renders Markdown in the terminal, using Ansi Escape Codes to apply formatting.
+/// </summary>
+public partial class AnsiRenderer
+{
+    private readonly MarkdownParser _markdownParser;
+    private readonly SyntaxHighlighter _syntaxHighlighter;
+    private readonly NumberFormatter _numberFormatter;
+    private readonly CharacterSet _characterSet;
+    private readonly IAnsiConsole _console;
+
+    private string _markdown = string.Empty;
+
+    private string _highlighted = Globals.StyleAlertAccent.Foreground.ToString();
+
+    internal AnsiRenderer(
+        MarkdownParser markdownParser,
+        SyntaxHighlighter syntaxHighlighter,
+        NumberFormatter numberFormatter,
+        CharacterSet characterSet,
+        IAnsiConsole console)
+    {
+        _markdownParser = markdownParser;
+        _syntaxHighlighter = syntaxHighlighter;
+        _numberFormatter = numberFormatter;
+        _characterSet = characterSet;
+        _console = console;
+    }
+
+    public void Write(string markdown)
+    {
+        _markdown = markdown;
+        var doc = _markdownParser.ConvertToMarkdownDocument(markdown);
+        WriteBlocks(doc);
+    }
+
+    private void WriteBlocks(IEnumerable<Block> blocks)
+    {
+        foreach (var block in blocks)
+        {
+            switch (block)
+            {
+                case HeadingBlock headingBlock:
+                    WriteHeadingBlock(headingBlock);
+                    break;
+
+                case ParagraphBlock paragraphBlock:
+                    WriteParagraphBlock(paragraphBlock);
+                    break;
+
+                case QuoteBlock quoteBlock:
+                    WriteQuoteBlock(quoteBlock);
+                    break;
+
+                case ListBlock listBlock:
+                    WriteListBlock(listBlock);
+                    break;
+
+                case MarkdownTable.Table tableBlock:
+                    WriteTableBlock(tableBlock);
+                    break;
+
+                case FencedCodeBlock fencedCodeBlock:
+                    WriteFencedCodeBlock(fencedCodeBlock);
+                    break;
+
+                case LinkReferenceDefinitionGroup linkBlock:
+                    WriteLinkReferenceDefinitionBlock(linkBlock);
+                    break;
+
+                case ThematicBreakBlock thematicBreakBlock:
+                    WriteThematicBreakBlock(thematicBreakBlock);
+                    break;
+
+                default:
+                    // We shouldn't be able to get here.
+                    // The case above should handle all possibilities.
+                    ThrowOrFallbackToPlainText(block);
+                    break;
+            };
+
+            _console.WriteLine();
+        }
+    }
+
+    private int GetConsoleWidth()
+    {
+        return _console.Profile.Width;
+    }
+
+    private void ThrowOrFallbackToPlainText(MarkdownObject markdownObject)
+    {
+        var span = markdownObject.Span;
+
+        if (FeatureFlags.ThrowOnUnsupportedMarkdownType)
+        {
+            var exceptionMessage = $"Unsupported markdown type {markdownObject.GetType()} found from character {span.Start} to {span.End}: {span}.";
+            throw new Exception(exceptionMessage);
+        }
+
+        // Cannot use ranges here - not support supported by NetStandard2.0.
+        _console.Write($"[{_defaultColor}]{_markdown.Substring(span.Start, span.Length)}[/]");
+    }
+
+    private void ThrowOrFallbackToPlainText(string exceptionMessage, string fallbackText)
+    {
+        if (FeatureFlags.ThrowOnUnsupportedMarkdownType)
+        {
+            throw new Exception(exceptionMessage);
+        }
+
+        _console.Write(fallbackText);
+    }
+
+    private void ThrowOrFallbackToPlainText(string exceptionMessage, Markup fallbackMarkupText)
+    {
+        if (FeatureFlags.ThrowOnUnsupportedMarkdownType)
+        {
+            throw new Exception(exceptionMessage);
+        }
+
+        _console.Write(fallbackMarkupText);
+    }
+}
\ No newline at end of file
diff --git a/source/Cute/Services/Markdown/Renderers/AnsiRendererBuilder.cs b/source/Cute/Services/Markdown/Renderers/AnsiRendererBuilder.cs
new file mode 100644
index 0000000..5032d13
--- /dev/null
+++ b/source/Cute/Services/Markdown/Renderers/AnsiRendererBuilder.cs
@@ -0,0 +1,90 @@
+using Cute.Services.Markdown.Console.Converters;
+using Cute.Services.Markdown.Console.Formatters;
+using Cute.Services.Markdown.Console.Options;
+using Cute.Services.Markdown.Console.Parsers;
+using Cute.Services.Markdown.Console.Renderers.CharacterSets;
+using Cute.Services.Markdown.Console.SyntaxHighlighters;
+using Spectre.Console;
+
+namespace Cute.Services.Markdown.Console.Renderers;
+
+/// <summary>
+/// Creates an AnsiRenderer.
+/// </summary>
+public class AnsiRendererBuilder
+{
+    private static readonly SyntaxHighlighter SyntaxHighlighter = new();
+    private static readonly NumberFormatter NumberFormatter = new();
+    private static readonly MarkdownParser Parser = new();
+
+    private AnsiSupport _ansiSupport = AnsiSupport.Detect;
+    private ColorSystemSupport _colorSystem = ColorSystemSupport.Detect;
+    private CharacterSet _characterSet = new AsciiCharacterSet();
+    private TextWriter? _writer;
+
+    /// <summary>
+    /// Adds a customer writer.
+    /// Allows the caller to divert the renderer output.
+    /// Useful for testing and debugging.
+    /// </summary>
+    /// <param name="writer">Ansi formatted string will be built using the supplied writer</param>
+    public AnsiRendererBuilder RedirectOutput(TextWriter writer)
+    {
+        _writer = writer;
+        return this;
+    }
+
+    /// <summary>
+    /// Clone capabilities from an existing console.
+    /// </summary>
+    /// <param name="console">Copy configuration from this console.</param>
+    public AnsiRendererBuilder InheritSettings(IAnsiConsole console)
+    {
+        _colorSystem = ColorSystemSupportConverter.FromColorSystem(console.Profile.Capabilities.ColorSystem);
+        _ansiSupport = AnsiSupportConverter.FromAnsiSupported(console.Profile.Capabilities.Ansi);
+
+        return this;
+    }
+
+    public  AnsiRendererBuilder SetNerdFontsUsage(UseNerdFonts useNerdFonts)
+    {
+        _characterSet = useNerdFonts == UseNerdFonts.Yes
+            ? new NerdFontCharacterSet()
+            : new AsciiCharacterSet();
+        return this;
+    }
+
+
+    /// <summary>
+    /// Builds and returns an AnsiRenderer.
+    /// </summary>
+    public AnsiRenderer Build()
+    {
+        var console = GetConsole();
+        return new AnsiRenderer(Parser, SyntaxHighlighter, NumberFormatter, _characterSet, console);
+    }
+
+    private IAnsiConsole GetConsole()
+    {
+        if (_writer is null)
+        {
+            return AnsiConsole.Console;
+        }
+
+        if (FeatureFlags.ForceAnsiColour)
+        {
+            _ansiSupport = AnsiSupport.Yes;
+            _colorSystem = ColorSystemSupport.TrueColor;
+        }
+
+        var console = AnsiConsole.Create(new AnsiConsoleSettings
+        {
+            ColorSystem = _colorSystem,
+            Ansi = _ansiSupport,
+            Interactive = InteractionSupport.No,
+            Out = new AnsiConsoleOutput(_writer)
+        });
+
+        return console;
+    }
+}
diff --git a/source/Cute/Services/Markdown/Renderers/CharacterSets/AsciiCharacterSet.cs b/source/Cute/Services/Markdown/Renderers/CharacterSets/AsciiCharacterSet.cs
new file mode 100644
index 0000000..a5070a3
--- /dev/null
+++ b/source/Cute/Services/Markdown/Renderers/CharacterSets/AsciiCharacterSet.cs
@@ -0,0 +1,21 @@
+namespace Cute.Services.Markdown.Console.Renderers.CharacterSets;
+
+public class AsciiCharacterSet : CharacterSet
+{
+    public override string Zero { get; } = "0";
+    public override string One { get; } = "1";
+    public override string Two { get; } = "2";
+    public override string Three { get; } = "3";
+    public override string Four { get; } = "4";
+    public override string Five { get; } = "5";
+    public override string Six { get; } = "6";
+    public override string Seven { get; } = "7";
+    public override string Eight { get; } = "8";
+    public override string Nine { get; } = "9";
+    public override string InlineCodeOpening { get; } = "├";
+    public override string InlineCodeClosing { get; } = "┤";
+    public override string ListBullet { get; } = "•";
+    public override string QuotePrefix { get; } = "»";
+    public override string TaskListBulletDone { get; } = "[✓]";
+    public override string TaskListBulletToDo { get; } = "[ ]";
+}
\ No newline at end of file
diff --git a/source/Cute/Services/Markdown/Renderers/CharacterSets/CharacterSet.cs b/source/Cute/Services/Markdown/Renderers/CharacterSets/CharacterSet.cs
new file mode 100644
index 0000000..6d0ef9d
--- /dev/null
+++ b/source/Cute/Services/Markdown/Renderers/CharacterSets/CharacterSet.cs
@@ -0,0 +1,21 @@
+namespace Cute.Services.Markdown.Console.Renderers.CharacterSets;
+
+public abstract class CharacterSet
+{
+    public virtual string Zero { get; } = "0";
+    public virtual string One { get; } = "1";
+    public virtual string Two { get; } = "2";
+    public virtual string Three { get; } = "3";
+    public virtual string Four { get; } = "4";
+    public virtual string Five { get; } = "5";
+    public virtual string Six { get; } = "6";
+    public virtual string Seven { get; } = "7";
+    public virtual string Eight { get; } = "8";
+    public virtual string Nine { get; } = "9";
+    public virtual string InlineCodeOpening { get; } = "";
+    public virtual string InlineCodeClosing { get; } = "";
+    public virtual string ListBullet { get; } = "";
+    public virtual string QuotePrefix { get; } = "❯";
+    public virtual string TaskListBulletDone { get; } = "[x]";
+    public virtual string TaskListBulletToDo { get; } = "[ ]";
+}
diff --git a/source/Cute/Services/Markdown/Renderers/CharacterSets/NerdFontCharacterSet.cs b/source/Cute/Services/Markdown/Renderers/CharacterSets/NerdFontCharacterSet.cs
new file mode 100644
index 0000000..df8822a
--- /dev/null
+++ b/source/Cute/Services/Markdown/Renderers/CharacterSets/NerdFontCharacterSet.cs
@@ -0,0 +1,21 @@
+namespace Cute.Services.Markdown.Console.Renderers.CharacterSets;
+
+public class NerdFontCharacterSet : CharacterSet
+{
+    public override string Zero { get; } = "";
+    public override string One { get; } = "";
+    public override string Two { get; } = "";
+    public override string Three { get; } = "";
+    public override string Four { get; } = "";
+    public override string Five { get; } = "";
+    public override string Six { get; } = "";
+    public override string Seven { get; } = "";
+    public override string Eight { get; } = "";
+    public override string Nine { get; } = "";
+    public override string InlineCodeOpening { get; } = "";
+    public override string InlineCodeClosing { get; } = "";
+    public override string ListBullet { get; } = "";
+    public override string QuotePrefix { get; } = "❯";
+    public override string TaskListBulletDone { get; } = "";
+    public override string TaskListBulletToDo { get; } = "";
+}
diff --git a/source/Cute/Services/Markdown/SyntaxHighlighters/BasicSyntaxHighlighter.cs b/source/Cute/Services/Markdown/SyntaxHighlighters/BasicSyntaxHighlighter.cs
new file mode 100644
index 0000000..db55876
--- /dev/null
+++ b/source/Cute/Services/Markdown/SyntaxHighlighters/BasicSyntaxHighlighter.cs
@@ -0,0 +1,34 @@
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using Spectre.Console;
+
+namespace Cute.Services.Markdown.Console.SyntaxHighlighters;
+
+/// <summary>
+/// Provides very basic syntax highlighting.  Recommend as a fallback option, should other
+/// highlighters fail.
+/// </summary>
+public class BasicSyntaxHighlighter : ISyntaxHighlighter
+{
+    private const string EscapeCode = "\u001b";
+    private const string Grey = "244";
+
+    /// <inheritdoc/>
+    public bool TryGetHighlightSyntax(
+        string code,
+        string? language,
+        [NotNullWhen(returnValue: true)]
+        out string? highlightedCode)
+    {
+        var lineNumber = 1;
+        var lines = code.Replace("\r\n", string.Empty).Split('\n');
+
+        highlightedCode = string.Empty;
+        foreach (var line in lines)
+        {
+            var rightAlignedLineNumber = lineNumber++.ToString().PadLeft(4);
+            highlightedCode += $"{EscapeCode}[38;5;{Grey}m{rightAlignedLineNumber} {EscapeCode}[0m{line}\n";
+        }
+        return true;
+    }
+}
diff --git a/source/Cute/Services/Markdown/SyntaxHighlighters/BatSyntaxHighlighter.cs b/source/Cute/Services/Markdown/SyntaxHighlighters/BatSyntaxHighlighter.cs
new file mode 100644
index 0000000..80c49b8
--- /dev/null
+++ b/source/Cute/Services/Markdown/SyntaxHighlighters/BatSyntaxHighlighter.cs
@@ -0,0 +1,70 @@
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.Text;
+using Spectre.Console;
+
+namespace Cute.Services.Markdown.Console.SyntaxHighlighters;
+
+/// <summary>
+/// A wrapper around Bat.  A cli tool that provides syntax highlighting.
+///
+/// <remarks>
+/// Requires Bat.exe to available in the current working directory or via the path
+/// environmental variable.
+/// </remarks>
+///
+/// <seealso href="https://github.com/sharkdp/bat">Bat/seealso>
+/// </summary>
+public class BatSyntaxHighlighter : ISyntaxHighlighter
+{
+    /// <inheritdoc/>
+    public bool TryGetHighlightSyntax(
+        string code,
+        string? language,
+        [NotNullWhen(returnValue: true)]
+        out string? highlightedCode)
+    {
+        try
+        {
+            var info = new ProcessStartInfo
+            {
+                FileName = "bat.exe",
+                // We cannot use ArgumentList here, because .NetStandard2.0 does not support it.
+                Arguments = GetBatArguments(language),
+                RedirectStandardOutput = true,
+                RedirectStandardInput = true,
+                CreateNoWindow = true
+            };
+            var process = Process.Start(info) ?? throw new Exception("Cannot start Bat");
+            var writer = process.StandardInput;
+            var output = process.StandardOutput;
+
+            writer.WriteLine(code);
+            writer.Close();
+            process.WaitForExit();
+
+            highlightedCode = output.ReadToEnd();
+            return true;
+        }
+        catch
+        {
+            highlightedCode = null;
+            return false;
+        }
+    }
+
+    private string GetBatArguments(string? language)
+    {
+        var arguments = new StringBuilder();
+
+        arguments.Append("--number");
+        arguments.Append("--color always");
+        arguments.Append($"--terminal-width ${System.Console.BufferWidth}");
+        // Can be langague name or common file extension.
+        // See Bat --list-languages for support language codes.
+        // This can throw, which will result in falling back to the basic syntax highlighter.
+        arguments.Append($"--language {language ?? "unknown"}");
+
+        return arguments.ToString();
+    }
+}
diff --git a/source/Cute/Services/Markdown/SyntaxHighlighters/ISyntaxHighlighter.cs b/source/Cute/Services/Markdown/SyntaxHighlighters/ISyntaxHighlighter.cs
new file mode 100644
index 0000000..35b0621
--- /dev/null
+++ b/source/Cute/Services/Markdown/SyntaxHighlighters/ISyntaxHighlighter.cs
@@ -0,0 +1,22 @@
+using System.Diagnostics.CodeAnalysis;
+
+namespace Cute.Services.Markdown.Console.SyntaxHighlighters;
+
+/// <summary>
+/// Highlights syntax in a given code sample.
+/// </summary>
+public interface ISyntaxHighlighter
+{
+    /// <summary>
+    /// Attempts to highlight syntax for a given code example.
+    /// </summary>
+    /// <param name="code"Code to highlight></param>
+    /// <param name="language">Language is used to provide a hint to the highlighter</param>
+    /// <param name="highlightedCode">Code with syntax highlighted</param>
+    /// <returns></returns>
+    public bool TryGetHighlightSyntax(
+        string code,
+        string? language,
+        [NotNullWhen(returnValue: true)]
+        out string? highlightedCode);
+}
diff --git a/source/Cute/Services/Markdown/SyntaxHighlighters/SyntaxHighlighter.cs b/source/Cute/Services/Markdown/SyntaxHighlighters/SyntaxHighlighter.cs
new file mode 100644
index 0000000..e0e21e3
--- /dev/null
+++ b/source/Cute/Services/Markdown/SyntaxHighlighters/SyntaxHighlighter.cs
@@ -0,0 +1,42 @@
+using System.Collections.Generic;
+
+namespace Cute.Services.Markdown.Console.SyntaxHighlighters;
+
+public class SyntaxHighlighter
+{
+    // Order is important here.
+    // Syntax highlighters are tried from first until last.
+    private readonly List<ISyntaxHighlighter> _highlighters = new()
+    {
+        new BatSyntaxHighlighter(),
+        new BasicSyntaxHighlighter()
+    };
+
+    /// <summary>
+    /// Highlights syntax within a code block.
+    /// </summary>
+    /// <param name="code">Highlight the syntax within this code block</param>
+    /// <param name="language">Hint provided to the syntax highlighter</param>
+    /// <param name="forceBasicHighlighter">Ensure we use the basic highlighter.  Useful for test environments where Bat may not be installed.</param>
+    /// <returns></returns>
+    public string GetHighlightedSyntax(string code, string? language, bool forceBasicHighlighter)
+    {
+        if (forceBasicHighlighter)
+        {
+            if (_highlighters.Last().TryGetHighlightSyntax(code, language, out var highlightedCode))
+            {
+                return highlightedCode;
+            }
+        }
+
+        foreach (var highlighter in _highlighters)
+        {
+            if (highlighter.TryGetHighlightSyntax(code, language, out var highlightedCode))
+            {
+                return highlightedCode;
+            }
+        }
+
+        throw new Exception("Syntax highlighting failed");
+    }
+}
diff --git a/source/Cute/Services/Markdown/UseNerdFonts.cs b/source/Cute/Services/Markdown/UseNerdFonts.cs
new file mode 100644
index 0000000..be7ec7d
--- /dev/null
+++ b/source/Cute/Services/Markdown/UseNerdFonts.cs
@@ -0,0 +1,19 @@
+namespace Cute.Services.Markdown;
+
+/// <summary>
+/// <see href="https://www.nerdfonts.com/">Nerd Fonts</see>
+/// provide additional glyphs that help us render beautiful output in the terminal.  However not all
+/// fonts supports these characters.
+/// </summary>
+public enum UseNerdFonts
+{
+    /// <summary>
+    /// Use Nerd Fonts to render special characters, like list bullets.
+    /// </summary>
+    Yes,
+
+    /// <summary>
+    /// Use glyphs from the standard and extended ASCII table to render special characters, like list bullets.
+    /// </summary>
+    No
+}
\ No newline at end of file