diff --git a/src/OpenIPC.Viewer.App/Controls/TerminalView.cs b/src/OpenIPC.Viewer.App/Controls/TerminalView.cs
index 17f881b..42f6aaa 100644
--- a/src/OpenIPC.Viewer.App/Controls/TerminalView.cs
+++ b/src/OpenIPC.Viewer.App/Controls/TerminalView.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Globalization;
+using System.Linq;
 using System.Text;
 using Avalonia;
 using Avalonia.Controls;
@@ -19,19 +20,50 @@ namespace OpenIPC.Viewer.App.Controls;
 /// </summary>
 public sealed class TerminalView : Control
 {
-    // Fixed 16-color ANSI palette (terminals don't follow the app theme).
-    private static readonly Color[] Palette =
+    public static readonly StyledProperty<TerminalTheme> ColorThemeProperty =
+        AvaloniaProperty.Register<TerminalView, TerminalTheme>(nameof(ColorTheme), TerminalTheme.Default,
+            // A binding that briefly resolves to nothing (a combo box between selections) must not
+            // leave the renderer without a palette.
+            coerce: (_, theme) => theme ?? TerminalTheme.Default);
+
+    /// <summary>The palette the grid is drawn with (terminals don't follow the app theme).</summary>
+    public TerminalTheme ColorTheme
     {
-        Color.Parse("#1e1e1e"), Color.Parse("#cd3131"), Color.Parse("#0dbc79"), Color.Parse("#e5e510"),
-        Color.Parse("#2472c8"), Color.Parse("#bc3fbc"), Color.Parse("#11a8cd"), Color.Parse("#cccccc"),
-        Color.Parse("#666666"), Color.Parse("#f14c4c"), Color.Parse("#23d18b"), Color.Parse("#f5f543"),
-        Color.Parse("#3b8eea"), Color.Parse("#d670d6"), Color.Parse("#29b8db"), Color.Parse("#ffffff"),
-    };
+        get => GetValue(ColorThemeProperty);
+        set => SetValue(ColorThemeProperty, value);
+    }
+
+    public static readonly StyledProperty<TerminalCursorStyle> CursorStyleProperty =
+        AvaloniaProperty.Register<TerminalView, TerminalCursorStyle>(nameof(CursorStyle));
+
+    public TerminalCursorStyle CursorStyle
+    {
+        get => GetValue(CursorStyleProperty);
+        set => SetValue(CursorStyleProperty, value);
+    }
+
+    public static readonly StyledProperty<bool> CursorBlinkProperty =
+        AvaloniaProperty.Register<TerminalView, bool>(nameof(CursorBlink));
+
+    public bool CursorBlink
+    {
+        get => GetValue(CursorBlinkProperty);
+        set => SetValue(CursorBlinkProperty, value);
+    }
 
-    private static readonly Color DefaultFg = Color.Parse("#d4d4d4");
-    private static readonly Color DefaultBg = Color.Parse("#0c0f14");
-    private static readonly IBrush DefaultFgBrush = new SolidColorBrush(DefaultFg);
-    private static readonly IBrush CursorBrush = new SolidColorBrush(Color.Parse("#d4d4d4"));
+    public static readonly StyledProperty<bool> FitToEmulatorProperty =
+        AvaloniaProperty.Register<TerminalView, bool>(nameof(FitToEmulator));
+
+    /// <summary>
+    /// Size the control to the emulator's grid instead of filling the space it is given — for a
+    /// fixed-size sample such as the settings preview. A live terminal leaves this off and
+    /// resizes the emulator to fit the control instead.
+    /// </summary>
+    public bool FitToEmulator
+    {
+        get => GetValue(FitToEmulatorProperty);
+        set => SetValue(FitToEmulatorProperty, value);
+    }
 
     public static readonly StyledProperty<TerminalEmulator?> EmulatorProperty =
         AvaloniaProperty.Register<TerminalView, TerminalEmulator?>(nameof(Emulator));
@@ -73,13 +105,29 @@ public double TerminalFontSize
     // If any of them resolves we get real monospace metrics; DrawRow below is correct either way.
     private const string MonoFamilies = "Cascadia Mono,Consolas,Menlo,Droid Sans Mono,Roboto Mono,monospace";
 
-    private readonly Typeface _typeface = new(new FontFamily(MonoFamilies));
-    private readonly Typeface _boldTypeface =
-        new(new FontFamily(MonoFamilies), weight: FontWeight.Bold);
+    private static readonly FontFamily Mono = new(MonoFamilies);
+    private readonly Typeface _typeface = new(Mono);
+    private readonly Typeface _boldTypeface = new(Mono, weight: FontWeight.Bold);
+    private readonly Typeface _italicTypeface = new(Mono, FontStyle.Italic);
+    private readonly Typeface _boldItalicTypeface = new(Mono, FontStyle.Italic, FontWeight.Bold);
+
+    // Only the attributes that change the glyph itself; colors are part of the key separately and
+    // lines (underline, strikethrough) are drawn over the glyph.
+    private const TerminalAttributes GlyphStyle = TerminalAttributes.Bold | TerminalAttributes.Italic;
 
     private double _cellWidth;
     private double _cellHeight;
-    private readonly Dictionary<(char Char, byte Foreground, bool Bold), FormattedText> _glyphs = new();
+    private readonly Dictionary<(char Char, uint Rgb, TerminalAttributes Style), FormattedText> _glyphs = new();
+    // One brush per color: 256-color and truecolor output can use many, and allocating a brush per
+    // cell per repaint is what the cache is for.
+    private readonly Dictionary<uint, IBrush> _brushes = new();
+
+    // Blink phase. The cursor is drawn while this is true; typing or new output sets it back so
+    // the cursor never vanishes at the moment you are looking for it.
+    private DispatcherTimer? _blinkTimer;
+    private bool _blinkOn = true;
+    private static readonly TimeSpan BlinkInterval = TimeSpan.FromMilliseconds(530);
+
     private TerminalEmulator? _subscribed;
     // Rows the view is scrolled back by; 0 is the live screen.
     private int _scrollOffset;
@@ -120,8 +168,6 @@ private enum Handle { None, Start, End }
     // radius wins, so the handles stay catchable without hijacking taps elsewhere.
     private const double HandleTouchSlop = 30;
 
-    private static readonly IBrush SelectionBrush =
-        new SolidColorBrush(Color.FromArgb(0x66, 0x3b, 0x8e, 0xea));
     private static readonly IBrush HandleBrush = new SolidColorBrush(Color.Parse("#3b8eea"));
 
     public TerminalView()
@@ -142,10 +188,38 @@ protected override void OnPropertyChanged(AvaloniaPropertyChangedEventArgs chang
             _glyphs.Clear();
             EnsureMetrics();
             RecomputeGrid();
+            InvalidateMeasure();
+            InvalidateVisual();
+            return;
+        }
+
+        if (change.Property == ColorThemeProperty)
+        {
+            // Cached glyphs and brushes are keyed by resolved color; the old theme's are dead weight.
+            _glyphs.Clear();
+            _brushes.Clear();
+            InvalidateVisual();
+            return;
+        }
+
+        if (change.Property == CursorStyleProperty)
+        {
             InvalidateVisual();
             return;
         }
 
+        if (change.Property == CursorBlinkProperty)
+        {
+            UpdateBlinkTimer();
+            return;
+        }
+
+        if (change.Property == FitToEmulatorProperty)
+        {
+            InvalidateMeasure();
+            return;
+        }
+
         if (change.Property != EmulatorProperty)
             return;
 
@@ -155,21 +229,123 @@ protected override void OnPropertyChanged(AvaloniaPropertyChangedEventArgs chang
         if (_subscribed is not null)
             _subscribed.Updated += OnEmulatorUpdated;
         RecomputeGrid();
+        InvalidateMeasure();
         InvalidateVisual();
     }
 
+    protected override Size MeasureOverride(Size availableSize)
+    {
+        if (!FitToEmulator || Emulator is not { } emu)
+            return base.MeasureOverride(availableSize);
+        return new Size(emu.Columns * _cellWidth, emu.Rows * _cellHeight);
+    }
+
+    protected override void OnAttachedToVisualTree(VisualTreeAttachmentEventArgs e)
+    {
+        base.OnAttachedToVisualTree(e);
+        UpdateBlinkTimer();
+    }
+
+    protected override void OnDetachedFromVisualTree(VisualTreeAttachmentEventArgs e)
+    {
+        base.OnDetachedFromVisualTree(e);
+        _blinkTimer?.Stop();
+    }
+
+    private void UpdateBlinkTimer()
+    {
+        _blinkOn = true;
+        if (!CursorBlink || VisualRoot is null)
+        {
+            _blinkTimer?.Stop();
+            InvalidateVisual();
+            return;
+        }
+
+        if (_blinkTimer is null)
+        {
+            _blinkTimer = new DispatcherTimer { Interval = BlinkInterval };
+            _blinkTimer.Tick += (_, _) =>
+            {
+                _blinkOn = !_blinkOn;
+                InvalidateVisual();
+            };
+        }
+        _blinkTimer.Stop();
+        _blinkTimer.Start();
+    }
+
+    // Show the cursor now and start the blink cycle over.
+    private void WakeCursor()
+    {
+        if (!CursorBlink || _blinkTimer is null)
+            return;
+        _blinkOn = true;
+        _blinkTimer.Stop();
+        _blinkTimer.Start();
+    }
+
     // Updated fires on the UI thread (the VM marshals shell data), so a direct
     // invalidate is safe.
-    private void OnEmulatorUpdated() => InvalidateVisual();
+    private void OnEmulatorUpdated()
+    {
+        // Switching screens changes what the row indices mean — the alternate screen has no
+        // history — so a selection or a scrolled-back view from before is meaningless after.
+        var alternate = _subscribed?.IsAlternateScreen ?? false;
+        if (alternate != _wasAlternate)
+        {
+            _wasAlternate = alternate;
+            _scrollOffset = 0;
+            ClearSelection();
+        }
+
+        WakeCursor();
+        InvalidateVisual();
+    }
+
+    private bool _wasAlternate;
+
+    // Wheel and touch scrolling. On the alternate screen there is no history to show, so — like
+    // xterm's alternateScroll — the gesture becomes cursor keys and the tool (less, vi, htop)
+    // scrolls its own content. Positive rows are "back in time", i.e. up.
+    private void ScrollOrSendKeys(int rows)
+    {
+        if (rows == 0)
+            return;
+        if (Emulator is { IsAlternateScreen: true } emu)
+        {
+            var key = emu.CursorKey(rows > 0 ? 'A' : 'B');
+            Input?.Invoke(this, string.Concat(Enumerable.Repeat(key, Math.Abs(rows))));
+            return;
+        }
+        ScrollBy(rows);
+    }
 
     private void EnsureMetrics()
     {
         var sample = new FormattedText("M", CultureInfo.InvariantCulture, FlowDirection.LeftToRight,
-            _typeface, TerminalFontSize, DefaultFgBrush);
+            _typeface, TerminalFontSize, Brushes.White);
         _cellWidth = sample.Width;
         _cellHeight = sample.Height;
     }
 
+    private IBrush BrushFor(uint argb)
+    {
+        if (_brushes.TryGetValue(argb, out var brush))
+            return brush;
+        if (_brushes.Count > 4096)
+            _brushes.Clear();
+        brush = new SolidColorBrush(Color.FromUInt32(argb));
+        _brushes[argb] = brush;
+        return brush;
+    }
+
+    private IBrush OpaqueBrush(uint rgb) => BrushFor(0xFF00_0000 | rgb);
+
+    // A coordinate rounded to the nearest physical pixel at the render scale of this frame.
+    private double _renderScale = 1;
+    private double Snap(double v) => Math.Round(v * _renderScale) / _renderScale;
+
     private void RecomputeGrid()
     {
         if (_cellWidth <= 0 || _cellHeight <= 0)
@@ -188,7 +364,8 @@ private void RecomputeGrid()
     public override void Render(DrawingContext context)
     {
         base.Render(context);
-        context.FillRectangle(new SolidColorBrush(DefaultBg), new Rect(Bounds.Size));
+        _renderScale = TopLevel.GetTopLevel(this)?.RenderScaling ?? 1;
+        context.FillRectangle(OpaqueBrush(ColorTheme.Background), new Rect(Bounds.Size));
 
         var emu = Emulator;
         if (emu is null)
@@ -500,7 +677,7 @@ private static (int Start, int End) SelectedColumns(
     protected override void OnPointerWheelChanged(PointerWheelEventArgs e)
     {
         base.OnPointerWheelChanged(e);
-        ScrollBy((int)Math.Round(e.Delta.Y) * 3);
+        ScrollOrSendKeys((int)Math.Round(e.Delta.Y) * 3);
         e.Handled = true;
     }
 
@@ -586,7 +763,7 @@ protected override void OnPointerMoved(PointerEventArgs e)
 
         // Pull down to go back in time, the way every list on the platform behaves.
         _dragAnchorY += rows * _cellHeight;
-        ScrollBy(rows);
+        ScrollOrSendKeys(rows);
     }
 
     // Dragging a selection against either edge walks the view, so it can run past the top of the
@@ -712,21 +889,34 @@ protected override void OnHolding(HoldingRoutedEventArgs e)
 
     private void DrawRow(DrawingContext context, TerminalCell[] cells, double y, int selStart, int selEnd)
     {
-        // Background fills first (only non-default cells).
-        for (var c = 0; c < cells.Length; c++)
+        var theme = ColorTheme;
+
+        // Background fills first — only where a cell's background differs from the screen's,
+        // which is also what makes an inverse cell on the default colors show up. A run of cells
+        // sharing a color is one rectangle, and every edge is snapped to a device pixel: cell
+        // widths are fractional, and abutting rectangles with antialiased edges left a visible
+        // seam between every pair of colored cells.
+        var top = Snap(y);
+        var bottom = Snap(y + _cellHeight);
+        for (var c = 0; c < cells.Length;)
         {
-            var cell = cells[c];
-            if (cell.Background == TerminalPalette.DefaultBackground)
-                continue;
-            context.FillRectangle(
-                new SolidColorBrush(Palette[cell.Background & 0x0F]),
-                new Rect(c * _cellWidth, y, _cellWidth, _cellHeight));
+            var (_, bg) = theme.ColorsOf(cells[c]);
+            var end = c + 1;
+            while (end < cells.Length && theme.ColorsOf(cells[end]).Background == bg)
+                end++;
+            if (bg != theme.Background)
+            {
+                var left = Snap(c * _cellWidth);
+                context.FillRectangle(OpaqueBrush(bg),
+                    new Rect(left, top, Snap(end * _cellWidth) - left, bottom - top));
+            }
+            c = end;
         }
 
         // Selection sits over the cell backgrounds and under the glyphs, so highlighted text
         // stays readable and coloured output keeps its own background showing through.
         if (selEnd > selStart)
-            context.FillRectangle(SelectionBrush,
+            context.FillRectangle(BrushFor(theme.Selection),
                 new Rect(selStart * _cellWidth, y, (selEnd - selStart) * _cellWidth, _cellHeight));
 
         // One character at a time, each pinned to its own cell.
@@ -744,41 +934,264 @@ private void DrawRow(DrawingContext context, TerminalCell[] cells, double y, int
         for (var c = 0; c < cells.Length; c++)
         {
             var cell = cells[c];
+            var (fg, _) = theme.ColorsOf(cell);
+            var x = c * _cellWidth;
+
             // Everything at or below U+0020 is blank or a control code: nothing to paint, and a
-            // default-constructed cell carries NUL rather than a space.
-            if (cell.Char <= ' ')
-                continue;
-            context.DrawText(GlyphFor(cell), new Point(c * _cellWidth, y));
+            // default-constructed cell carries NUL rather than a space. Hidden text (SGR 8) has
+            // already been given the background color, so it paints as nothing too.
+            if (cell.Char > ' ' && (cell.Attributes & TerminalAttributes.Hidden) == 0)
+                DrawCellChar(context, cell.Char, fg, cell.Attributes, x, y);
+
+            DrawLines(context, cell.Attributes, fg, x, y);
+        }
+    }
+
+    // Underline and strikethrough are drawn by hand rather than as text decorations: they have to
+    // run under blanks too (an underlined field in a form is mostly spaces) and join up from one
+    // cell to the next.
+    private void DrawLines(DrawingContext context, TerminalAttributes attrs, uint fg, double x, double y)
+    {
+        if ((attrs & (TerminalAttributes.Underline | TerminalAttributes.Strikethrough)) == 0 ||
+            (attrs & TerminalAttributes.Hidden) != 0)
+            return;
+
+        var thickness = Math.Max(1, Math.Round(TerminalFontSize / 14));
+        var brush = OpaqueBrush(fg);
+        if ((attrs & TerminalAttributes.Underline) != 0)
+            context.FillRectangle(brush, new Rect(x, y + _cellHeight - thickness * 2, _cellWidth, thickness));
+        if ((attrs & TerminalAttributes.Strikethrough) != 0)
+            context.FillRectangle(brush, new Rect(x, y + _cellHeight / 2, _cellWidth, thickness));
+    }
+
+    private void DrawCellChar(DrawingContext context, char ch, uint rgb, TerminalAttributes attrs, double x, double y)
+    {
+        if (!DrawBoxChar(context, ch, rgb, x, y))
+            context.DrawText(GlyphFor(ch, rgb, attrs), new Point(x, y));
+    }
+
+    // --- Box drawing -----------------------------------------------------
+    //
+    // Line and block characters are drawn as rectangles instead of being taken from the font. A
+    // font's │ is only as tall as its glyph box, which is shorter than the cell once line spacing
+    // is added, so every frame a full-screen tool drew came out as dashes with gaps between rows —
+    // and where the font has no such glyph at all, as whatever the fallback font made of it.
+    // Drawn, the strokes meet the cell edges exactly and join up with their neighbours.
+
+    // Light/heavy lines as four arms from the cell centre: 0 none, 1 light, 2 heavy.
+    // Packed as up | down << 2 | left << 4 | right << 6.
+    private static readonly Dictionary<char, int> BoxArms = BuildBoxArms();
+
+    private static Dictionary<char, int> BuildBoxArms()
+    {
+        static int A(int up, int down, int left, int right) => up | (down << 2) | (left << 4) | (right << 6);
+        var map = new Dictionary<char, int>();
+        void Both(char light, char heavy, int up, int down, int left, int right)
+        {
+            map[light] = A(up, down, left, right);
+            map[heavy] = A(up * 2, down * 2, left * 2, right * 2);
         }
+        Both('─', '━', 0, 0, 1, 1);
+        Both('│', '┃', 1, 1, 0, 0);
+        Both('┌', '┏', 0, 1, 0, 1);
+        Both('┐', '┓', 0, 1, 1, 0);
+        Both('└', '┗', 1, 0, 0, 1);
+        Both('┘', '┛', 1, 0, 1, 0);
+        Both('├', '┣', 1, 1, 0, 1);
+        Both('┤', '┫', 1, 1, 1, 0);
+        Both('┬', '┳', 0, 1, 1, 1);
+        Both('┴', '┻', 1, 0, 1, 1);
+        Both('┼', '╋', 1, 1, 1, 1);
+        Both('╴', '╸', 0, 0, 1, 0);
+        Both('╵', '╹', 1, 0, 0, 0);
+        Both('╶', '╺', 0, 0, 0, 1);
+        Both('╷', '╻', 0, 1, 0, 0);
+        // Rounded corners, drawn square: at terminal sizes the difference is a pixel or two.
+        map['╭'] = map['┌'];
+        map['╮'] = map['┐'];
+        map['╰'] = map['└'];
+        map['╯'] = map['┘'];
+        return map;
     }
 
-    private FormattedText GlyphFor(TerminalCell cell)
+    // Double lines as explicit segments, four characters each: H or V, the line's level
+    // (a/b = the two parallel strokes either side of the centre), then where it starts and ends
+    // (L/R or T/B = the cell edges, a/b = the near and far stroke of the crossing direction).
+    private static readonly Dictionary<char, string[]> BoxDouble = new()
     {
-        var key = (cell.Char, cell.Foreground, cell.Bold);
+        ['═'] = new[] { "HaLR", "HbLR" },
+        ['║'] = new[] { "VaTB", "VbTB" },
+        ['╔'] = new[] { "HaaR", "HbbR", "VaaB", "VbbB" },
+        ['╗'] = new[] { "HaLb", "HbLa", "VabB", "VbaB" },
+        ['╚'] = new[] { "HabR", "HbaR", "VaTb", "VbTa" },
+        ['╝'] = new[] { "HaLa", "HbLb", "VaTa", "VbTb" },
+        ['╠'] = new[] { "VaTB", "VbTa", "VbbB", "HabR", "HbbR" },
+        ['╣'] = new[] { "VbTB", "VaTa", "VabB", "HaLa", "HbLa" },
+        ['╦'] = new[] { "HaLR", "HbLa", "HbbR", "VabB", "VbbB" },
+        ['╩'] = new[] { "HbLR", "HaLa", "HabR", "VaTa", "VbTa" },
+        ['╬'] = new[] { "HaLa", "HabR", "HbLa", "HbbR", "VaTa", "VabB", "VbTa", "VbbB" },
+    };
+
+    private bool DrawBoxChar(DrawingContext context, char ch, uint rgb, double x, double y)
+    {
+        if (ch < '─' || ch > '▟')
+            return false;
+
+        var left = Snap(x);
+        var right = Snap(x + _cellWidth);
+        var top = Snap(y);
+        var bottom = Snap(y + _cellHeight);
+        var brush = OpaqueBrush(rgb);
+        var light = Math.Max(1, Math.Round(TerminalFontSize / 14));
+        var cx = (left + right) / 2;
+        var cy = (top + bottom) / 2;
+
+        if (BoxArms.TryGetValue(ch, out var arms))
+        {
+            // Each arm runs from its edge to just past the centre, so the joint is filled
+            // whatever mix of weights meets there.
+            void Arm(int weight, bool horizontal, double from, double to)
+            {
+                if (weight == 0)
+                    return;
+                var t = weight == 2 ? light * 2 : light;
+                if (horizontal)
+                    FillSnapped(context, brush, from, cy - t / 2, to, cy + t / 2);
+                else
+                    FillSnapped(context, brush, cx - t / 2, from, cx + t / 2, to);
+            }
+
+            Arm(arms & 3, false, top, cy + light);
+            Arm((arms >> 2) & 3, false, cy - light, bottom);
+            Arm((arms >> 4) & 3, true, left, cx + light);
+            Arm((arms >> 6) & 3, true, cx - light, right);
+            return true;
+        }
+
+        if (BoxDouble.TryGetValue(ch, out var segments))
+        {
+            var gap = light * 1.5;
+            double Level(char s, double centre) => s == 'a' ? centre - gap : centre + gap;
+            // Ends at a stroke reach half a stroke further, so two strokes meeting at a corner
+            // close it instead of leaving a notch.
+            double End(char s, double edgeLow, double edgeHigh, double centre) => s switch
+            {
+                'L' or 'T' => edgeLow,
+                'R' or 'B' => edgeHigh,
+                'a' => centre - gap - light / 2,
+                _ => centre + gap + light / 2,
+            };
+
+            foreach (var s in segments)
+            {
+                if (s[0] == 'H')
+                {
+                    var level = Level(s[1], cy);
+                    FillSnapped(context, brush, End(s[2], left, right, cx), level - light / 2,
+                        End(s[3], left, right, cx), level + light / 2);
+                }
+                else
+                {
+                    var level = Level(s[1], cx);
+                    FillSnapped(context, brush, level - light / 2, End(s[2], top, bottom, cy),
+                        level + light / 2, End(s[3], top, bottom, cy));
+                }
+            }
+            return true;
+        }
+
+        // Block elements: full, halves, and the three shades as translucent fills.
+        switch (ch)
+        {
+            case '█': FillSnapped(context, brush, left, top, right, bottom); return true;
+            case '▀': FillSnapped(context, brush, left, top, right, cy); return true;
+            case '▄': FillSnapped(context, brush, left, cy, right, bottom); return true;
+            case '▌': FillSnapped(context, brush, left, top, cx, bottom); return true;
+            case '▐': FillSnapped(context, brush, cx, top, right, bottom); return true;
+            case '░': FillSnapped(context, BrushFor(0x4000_0000 | rgb), left, top, right, bottom); return true;
+            case '▒': FillSnapped(context, BrushFor(0x8000_0000 | rgb), left, top, right, bottom); return true;
+            case '▓': FillSnapped(context, BrushFor(0xC000_0000 | rgb), left, top, right, bottom); return true;
+            default: return false;
+        }
+    }
+
+    // Both ends go to the pixel grid, and a stroke never collapses below one physical pixel: a
+    // one-pixel line centred on a whole pixel has both ends at .5, which round to the same value
+    // and left thin verticals simply missing at small font sizes.
+    private void FillSnapped(DrawingContext context, IBrush brush, double x0, double y0, double x1, double y1)
+    {
+        var pixel = 1 / _renderScale;
+        x0 = Snap(x0);
+        y0 = Snap(y0);
+        x1 = Math.Max(Snap(x1), x0 + pixel);
+        y1 = Math.Max(Snap(y1), y0 + pixel);
+        context.FillRectangle(brush, new Rect(x0, y0, x1 - x0, y1 - y0));
+    }
+
+    private FormattedText GlyphFor(char ch, uint rgb, TerminalAttributes attrs)
+    {
+        var style = attrs & GlyphStyle;
+        var key = (ch, rgb, style);
         if (_glyphs.TryGetValue(key, out var cached))
             return cached;
 
         // Cheap insurance against a pathological stream of distinct glyphs; the working set of a
-        // shell session is a few hundred entries.
+        // shell session is a few hundred entries, more with 256-color or truecolor output.
         if (_glyphs.Count > 4096)
             _glyphs.Clear();
 
-        var brush = cell.Foreground == TerminalPalette.DefaultForeground
-            ? DefaultFgBrush
-            : new SolidColorBrush(Palette[cell.Foreground & 0x0F]);
-        var text = new FormattedText(cell.Char.ToString(), CultureInfo.InvariantCulture,
-            FlowDirection.LeftToRight, cell.Bold ? _boldTypeface : _typeface, TerminalFontSize, brush);
+        var typeface = style switch
+        {
+            TerminalAttributes.Bold => _boldTypeface,
+            TerminalAttributes.Italic => _italicTypeface,
+            GlyphStyle => _boldItalicTypeface,
+            _ => _typeface,
+        };
+        var text = new FormattedText(ch.ToString(), CultureInfo.InvariantCulture,
+            FlowDirection.LeftToRight, typeface, TerminalFontSize, OpaqueBrush(rgb));
         _glyphs[key] = text;
         return text;
     }
 
     private void DrawCursor(DrawingContext context, TerminalEmulator emu)
     {
+        if (!emu.CursorVisible || (CursorBlink && !_blinkOn))
+            return;
+
+        var theme = ColorTheme;
         var x = emu.CursorColumn * _cellWidth;
         var y = emu.CursorRow * _cellHeight;
-        // Hollow block so the character under the cursor stays readable.
-        context.DrawRectangle(null, new Pen(CursorBrush, 1),
-            new Rect(x, y, _cellWidth, _cellHeight));
+        var cursor = OpaqueBrush(theme.Cursor);
+        var thickness = Math.Max(2, Math.Round(TerminalFontSize / 7));
+
+        switch (CursorStyle)
+        {
+            case TerminalCursorStyle.Block:
+            {
+                // Solid box, and the character under it redrawn in the screen color so it stays
+                // readable — the way a hardware terminal inverts the cell.
+                context.FillRectangle(cursor, new Rect(x, y, _cellWidth, _cellHeight));
+                // The column runs one past the last cell while a wrap is pending.
+                var row = emu.GetRow(emu.CursorRow);
+                var cell = emu.CursorColumn < row.Length ? row[emu.CursorColumn] : TerminalCell.Blank;
+                if (cell.Char > ' ')
+                {
+                    var (_, bg) = theme.ColorsOf(cell);
+                    DrawCellChar(context, cell.Char, bg, cell.Attributes, x, y);
+                }
+                break;
+            }
+            case TerminalCursorStyle.Bar:
+                context.FillRectangle(cursor, new Rect(x, y, thickness, _cellHeight));
+                break;
+            case TerminalCursorStyle.Underline:
+                context.FillRectangle(cursor, new Rect(x, y + _cellHeight - thickness, _cellWidth, thickness));
+                break;
+            default:
+                // Hollow box so the character under the cursor stays readable.
+                context.DrawRectangle(null, new Pen(cursor, 1), new Rect(x, y, _cellWidth, _cellHeight));
+                break;
+        }
     }
 
     protected override void OnTextInput(TextInputEventArgs e)
@@ -832,24 +1245,53 @@ protected override void OnKeyDown(KeyEventArgs e)
             return;
         }
 
-        var seq = e.Key switch
+        var seq = SequenceFor(e.Key, e.KeyModifiers);
+        if (seq is not null)
+        {
+            Input?.Invoke(this, seq);
+            e.Handled = true;
+        }
+    }
+
+    /// <summary>
+    /// The bytes a non-text key sends, or null for keys that arrive as text input. Cursor keys
+    /// follow the mode the remote asked for (ESC O A once an ncurses tool has switched to
+    /// application keys); the rest are the fixed xterm spellings mc, htop and vi look for — F10
+    /// is how mc is quit.
+    /// </summary>
+    public string? SequenceFor(Key key, KeyModifiers modifiers)
+    {
+        var emu = Emulator;
+        string Cursor(char final) => emu?.CursorKey(final) ?? "\x1b[" + final;
+        return key switch
         {
             Key.Enter => "\r",
             Key.Back => "\x7f",
-            Key.Tab => "\t",
+            Key.Tab => modifiers.HasFlag(KeyModifiers.Shift) ? "\x1b[Z" : "\t",
             Key.Escape => "\x1b",
-            Key.Up => "\x1b[A",
-            Key.Down => "\x1b[B",
-            Key.Right => "\x1b[C",
-            Key.Left => "\x1b[D",
-            Key.Home => "\x1b[H",
-            Key.End => "\x1b[F",
+            Key.Up => Cursor('A'),
+            Key.Down => Cursor('B'),
+            Key.Right => Cursor('C'),
+            Key.Left => Cursor('D'),
+            Key.Home => Cursor('H'),
+            Key.End => Cursor('F'),
+            Key.Insert => "\x1b[2~",
+            Key.Delete => "\x1b[3~",
+            Key.PageUp => "\x1b[5~",
+            Key.PageDown => "\x1b[6~",
+            Key.F1 => "\x1bOP",
+            Key.F2 => "\x1bOQ",
+            Key.F3 => "\x1bOR",
+            Key.F4 => "\x1bOS",
+            Key.F5 => "\x1b[15~",
+            Key.F6 => "\x1b[17~",
+            Key.F7 => "\x1b[18~",
+            Key.F8 => "\x1b[19~",
+            Key.F9 => "\x1b[20~",
+            Key.F10 => "\x1b[21~",
+            Key.F11 => "\x1b[23~",
+            Key.F12 => "\x1b[24~",
             _ => null,
         };
-        if (seq is not null)
-        {
-            Input?.Invoke(this, seq);
-            e.Handled = true;
-        }
     }
 }
diff --git a/src/OpenIPC.Viewer.App/Services/Localizer.cs b/src/OpenIPC.Viewer.App/Services/Localizer.cs
index 2731cfd..709f040 100644
--- a/src/OpenIPC.Viewer.App/Services/Localizer.cs
+++ b/src/OpenIPC.Viewer.App/Services/Localizer.cs
@@ -258,6 +258,20 @@ private static LangCode DetectSystem()
         ["Settings.Ssh.StrictHostKey"] = "Strict host-key checking",
         ["Settings.Ssh.DefaultPort"] = "Default SSH port",
         ["Settings.Ssh.TerminalFontSize"] = "Terminal font size",
+        ["Settings.Ssh.Theme"] = "Terminal theme",
+        ["Settings.Ssh.Theme.default"] = "Classic",
+        ["Settings.Ssh.Theme.gruvbox-dark"] = "Gruvbox Dark",
+        ["Settings.Ssh.Theme.dracula"] = "Dracula",
+        ["Settings.Ssh.Theme.solarized-dark"] = "Solarized Dark",
+        ["Settings.Ssh.Theme.solarized-light"] = "Solarized Light",
+        ["Settings.Ssh.Theme.phosphor"] = "Green phosphor",
+        ["Settings.Ssh.CursorStyle"] = "Cursor",
+        ["Settings.Ssh.Cursor.Outline"] = "Outline",
+        ["Settings.Ssh.Cursor.Block"] = "Block",
+        ["Settings.Ssh.Cursor.Bar"] = "Bar",
+        ["Settings.Ssh.Cursor.Underline"] = "Underline",
+        ["Settings.Ssh.CursorBlink"] = "Blinking cursor",
+        ["Settings.Ssh.Scrollback"] = "History lines",
         ["Settings.Ssh.MajesticPath"] = "majestic.yaml path",
         ["Settings.Ssh.ResetHostKeys"] = "Forget all host keys",
         ["Settings.Ssh.HostKeysCleared"] = "All pinned host keys were forgotten.",
@@ -899,6 +913,20 @@ private static LangCode DetectSystem()
         ["Settings.Ssh.StrictHostKey"] = "Строгая проверка host-key",
         ["Settings.Ssh.DefaultPort"] = "SSH-порт по умолчанию",
         ["Settings.Ssh.TerminalFontSize"] = "Размер шрифта терминала",
+        ["Settings.Ssh.Theme"] = "Тема терминала",
+        ["Settings.Ssh.Theme.default"] = "Классическая",
+        ["Settings.Ssh.Theme.gruvbox-dark"] = "Gruvbox Dark",
+        ["Settings.Ssh.Theme.dracula"] = "Dracula",
+        ["Settings.Ssh.Theme.solarized-dark"] = "Solarized Dark",
+        ["Settings.Ssh.Theme.solarized-light"] = "Solarized Light",
+        ["Settings.Ssh.Theme.phosphor"] = "Зелёный люминофор",
+        ["Settings.Ssh.CursorStyle"] = "Курсор",
+        ["Settings.Ssh.Cursor.Outline"] = "Контур",
+        ["Settings.Ssh.Cursor.Block"] = "Блок",
+        ["Settings.Ssh.Cursor.Bar"] = "Черта",
+        ["Settings.Ssh.Cursor.Underline"] = "Подчёркивание",
+        ["Settings.Ssh.CursorBlink"] = "Мигающий курсор",
+        ["Settings.Ssh.Scrollback"] = "Строк в истории",
         ["Settings.Ssh.MajesticPath"] = "Путь к majestic.yaml",
         ["Settings.Ssh.ResetHostKeys"] = "Забыть все host-ключи",
         ["Settings.Ssh.HostKeysCleared"] = "Все запомненные host-ключи забыты.",
diff --git a/src/OpenIPC.Viewer.App/Services/UserSettings.cs b/src/OpenIPC.Viewer.App/Services/UserSettings.cs
index bb14822..c122e28 100644
--- a/src/OpenIPC.Viewer.App/Services/UserSettings.cs
+++ b/src/OpenIPC.Viewer.App/Services/UserSettings.cs
@@ -48,6 +48,12 @@ public sealed record UserSettings(
     // only ever appears when the user asks for it with the key-bar button — which is what you
     // want while selecting text, because the keyboard's inset resizes the grid under you.
     bool SshTerminalAutoKeyboard = true,
+    // Terminal look: a TerminalTheme.Id, a TerminalCursorStyle name (outline = the original
+    // hollow box), blink, and how many rows of history the terminal keeps.
+    string SshTerminalTheme = "default",
+    string SshTerminalCursorStyle = "outline",
+    bool SshTerminalCursorBlink = false,
+    int SshTerminalScrollback = 1000,
     string MajesticConfigPath = "/etc/majestic.yaml",
     // Local AI analytics (Phase 15.2). "auto" lets the detector pick the
     // platform execution provider with a CPU fallback; "force-cpu" pins CPU.
diff --git a/src/OpenIPC.Viewer.App/ViewModels/SettingsPageViewModel.cs b/src/OpenIPC.Viewer.App/ViewModels/SettingsPageViewModel.cs
index 0ac2d52..d5b64c0 100644
--- a/src/OpenIPC.Viewer.App/ViewModels/SettingsPageViewModel.cs
+++ b/src/OpenIPC.Viewer.App/ViewModels/SettingsPageViewModel.cs
@@ -13,6 +13,7 @@
 using OpenIPC.Viewer.Core.Onvif.Discovery;
 using OpenIPC.Viewer.Core.Platform;
 using OpenIPC.Viewer.Core.Ssh;
+using OpenIPC.Viewer.Core.Ssh.Terminal;
 
 namespace OpenIPC.Viewer.App.ViewModels;
 
@@ -69,10 +70,46 @@ public sealed partial class SettingsPageViewModel : ViewModelBase, IBackNavigabl
     // SSH section (Phase 13).
     [ObservableProperty] private bool _sshStrictHostKey = true;
     [ObservableProperty] private int _sshDefaultPort = 22;
-    [ObservableProperty] private int _sshTerminalFontSize = 14;
+    [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(SshTerminalPreviewFontSize))]
+    private int _sshTerminalFontSize = 14;
     [ObservableProperty] private string _majesticConfigPath = "/etc/majestic.yaml";
     [ObservableProperty] private bool _hostKeysJustCleared;
 
+    // Terminal look. The preview is a fixed sample screen drawn by the real TerminalView, so
+    // what the user picks here is exactly what the terminal will show.
+    [ObservableProperty] private TerminalThemeOption? _sshTerminalTheme;
+    [ObservableProperty] private TerminalCursorStyleOption? _sshTerminalCursorStyle;
+    [ObservableProperty] private bool _sshTerminalCursorBlink;
+    [ObservableProperty] private int _sshTerminalScrollback = TerminalEmulator.DefaultScrollbackLimit;
+    public IReadOnlyList<TerminalThemeOption> TerminalThemeOptions { get; }
+    public IReadOnlyList<TerminalCursorStyleOption> TerminalCursorStyleOptions { get; }
+    public TerminalEmulator TerminalPreview { get; } = CreateTerminalPreview();
+    public double SshTerminalPreviewFontSize => SshTerminalFontSize;
+
+    // A prompt, a colored `ls`, both rows of the ANSI palette and the renditions — enough to
+    // judge a theme by. Kept within 44 columns so it fits a phone.
+    private static TerminalEmulator CreateTerminalPreview()
+    {
+        const string prompt = "\x1b[1;32mroot@openipc\x1b[0m:\x1b[1;34m~\x1b[0m# ";
+        var preview = new TerminalEmulator(44, 7);
+        preview.Feed(
+            prompt + "ls\r\n" +
+            "\x1b[1;34mbin\x1b[0m  \x1b[1;36mlib\x1b[0m  \x1b[1;32mmajestic\x1b[0m  majestic.yaml\r\n" +
+            "\x1b[31mred \x1b[32mgreen \x1b[33myellow \x1b[34mblue \x1b[35mmagenta \x1b[36mcyan\x1b[0m\r\n" +
+            "\x1b[91mred \x1b[92mgreen \x1b[93myellow \x1b[94mblue \x1b[95mmagenta \x1b[96mcyan\x1b[0m\r\n" +
+            "\x1b[1mbold\x1b[0m \x1b[2mdim\x1b[0m \x1b[3mitalic\x1b[0m \x1b[4munderline\x1b[0m \x1b[7m inverse \x1b[0m\r\n");
+        for (var i = 0; i < 44; i++)
+        {
+            // A truecolor ramp, to show 24-bit output comes through.
+            var r = 255 - i * 255 / 43;
+            var b = i * 255 / 43;
+            preview.Feed($"\x1b[48;2;{r};64;{b}m ");
+        }
+        preview.Feed("\x1b[0m\r\n" + prompt);
+        return preview;
+    }
+
     // Notifications (Phase 19.3).
     [ObservableProperty] private bool _notificationsEnabled = true;
     [ObservableProperty] private bool _notifyOnMotion = true;
@@ -226,6 +263,17 @@ public SettingsPageViewModel(
         };
         StartupLayoutOptions.Add(new StartupLayoutOption(Localizer.Instance["Settings.Appearance.StartupLayout.LastUsed"], 0));
 
+        TerminalThemeOptions = TerminalTheme.BuiltIn
+            .Select(t => new TerminalThemeOption(Localizer.Instance[$"Settings.Ssh.Theme.{t.Id}"], t))
+            .ToList();
+        TerminalCursorStyleOptions = new[]
+        {
+            TerminalCursorStyle.Outline, TerminalCursorStyle.Block,
+            TerminalCursorStyle.Bar, TerminalCursorStyle.Underline,
+        }
+            .Select(c => new TerminalCursorStyleOption(Localizer.Instance[$"Settings.Ssh.Cursor.{c}"], c))
+            .ToList();
+
         Load();
     }
 
@@ -261,6 +309,14 @@ private void Load()
             SshStrictHostKey = s.SshStrictHostKey;
             SshDefaultPort = s.SshDefaultPort;
             SshTerminalFontSize = s.SshTerminalFontSize;
+            var theme = TerminalTheme.ById(s.SshTerminalTheme);
+            SshTerminalTheme = TerminalThemeOptions.FirstOrDefault(o => o.Theme == theme) ?? TerminalThemeOptions[0];
+            SshTerminalCursorStyle =
+                TerminalCursorStyleOptions.FirstOrDefault(o =>
+                    string.Equals(o.Style.ToString(), s.SshTerminalCursorStyle, StringComparison.OrdinalIgnoreCase))
+                ?? TerminalCursorStyleOptions[0];
+            SshTerminalCursorBlink = s.SshTerminalCursorBlink;
+            SshTerminalScrollback = s.SshTerminalScrollback;
             MajesticConfigPath = s.MajesticConfigPath;
             NotificationsEnabled = s.NotificationsEnabled;
             NotifyOnMotion = s.NotifyOnMotion;
@@ -296,6 +352,10 @@ private void Load()
     partial void OnSshStrictHostKeyChanged(bool value) => Persist();
     partial void OnSshDefaultPortChanged(int value) => Persist();
     partial void OnSshTerminalFontSizeChanged(int value) => Persist();
+    partial void OnSshTerminalThemeChanged(TerminalThemeOption? value) => Persist();
+    partial void OnSshTerminalCursorStyleChanged(TerminalCursorStyleOption? value) => Persist();
+    partial void OnSshTerminalCursorBlinkChanged(bool value) => Persist();
+    partial void OnSshTerminalScrollbackChanged(int value) => Persist();
     partial void OnMajesticConfigPathChanged(string value) => Persist();
     partial void OnNotificationsEnabledChanged(bool value) => Persist();
     partial void OnNotifyOnMotionChanged(bool value) => Persist();
@@ -331,6 +391,12 @@ private void Persist()
             SshStrictHostKey = SshStrictHostKey,
             SshDefaultPort = SshDefaultPort,
             SshTerminalFontSize = SshTerminalFontSize,
+            SshTerminalTheme = SshTerminalTheme?.Theme.Id ?? TerminalTheme.DefaultId,
+            SshTerminalCursorStyle = (SshTerminalCursorStyle?.Style ?? TerminalCursorStyle.Outline)
+                .ToString().ToLowerInvariant(),
+            SshTerminalCursorBlink = SshTerminalCursorBlink,
+            SshTerminalScrollback = Math.Clamp(SshTerminalScrollback,
+                TerminalEmulator.MinScrollbackLimit, TerminalEmulator.MaxScrollbackLimit),
             MajesticConfigPath = MajesticConfigPath,
             NotificationsEnabled = NotificationsEnabled,
             NotifyOnMotion = NotifyOnMotion,
@@ -579,3 +645,5 @@ public sealed record IdleTimeoutOption(string Display, int Minutes);
 // Value is the persisted UserSettings.StartupPage; Id is the LayoutId (0 = last used).
 public sealed record StartPageOption(string Display, string Value);
 public sealed record StartupLayoutOption(string Display, int Id);
+public sealed record TerminalThemeOption(string Display, TerminalTheme Theme);
+public sealed record TerminalCursorStyleOption(string Display, TerminalCursorStyle Style);
diff --git a/src/OpenIPC.Viewer.App/ViewModels/SshTerminalViewModel.cs b/src/OpenIPC.Viewer.App/ViewModels/SshTerminalViewModel.cs
index df14d8c..e6da43e 100644
--- a/src/OpenIPC.Viewer.App/ViewModels/SshTerminalViewModel.cs
+++ b/src/OpenIPC.Viewer.App/ViewModels/SshTerminalViewModel.cs
@@ -31,9 +31,12 @@ public sealed partial class SshTerminalViewModel : ViewModelBase, IAsyncDisposab
     private int _columns = 80;
     private int _rows = 24;
 
-    public TerminalEmulator Emulator { get; } = new(80, 24);
+    public TerminalEmulator Emulator { get; }
     public string Title => $"SSH — {_camera.Name}";
     public double FontSize { get; }
+    public TerminalTheme Theme { get; }
+    public TerminalCursorStyle CursorStyle { get; }
+    public bool CursorBlink { get; }
 
     /// <summary>Whether a tap on the terminal is allowed to raise the soft keyboard.</summary>
     public bool AutoKeyboard => _settings.Current.SshTerminalAutoKeyboard;
@@ -59,6 +62,18 @@ public SshTerminalViewModel(
         _settings = settings;
         FontSize = fontSize >= 8 ? fontSize : 14;
         _logger = logger;
+
+        var s = settings.Current;
+        Emulator = new TerminalEmulator(80, 24, s.SshTerminalScrollback);
+        Theme = TerminalTheme.ById(s.SshTerminalTheme);
+        CursorStyle = Enum.TryParse<TerminalCursorStyle>(s.SshTerminalCursorStyle, ignoreCase: true, out var style)
+            ? style
+            : TerminalCursorStyle.Outline;
+        CursorBlink = s.SshTerminalCursorBlink;
+
+        // Status queries (cursor position, device attributes) are answered over the same shell;
+        // a tool that asks and gets no answer can sit waiting for one.
+        Emulator.Reply += reply => _ = SendAsync(reply);
     }
 
     public async Task ConnectAsync()
diff --git a/src/OpenIPC.Viewer.App/Views/Dialogs/SshTerminalContent.axaml.cs b/src/OpenIPC.Viewer.App/Views/Dialogs/SshTerminalContent.axaml.cs
index 832bc40..c59923e 100644
--- a/src/OpenIPC.Viewer.App/Views/Dialogs/SshTerminalContent.axaml.cs
+++ b/src/OpenIPC.Viewer.App/Views/Dialogs/SshTerminalContent.axaml.cs
@@ -7,6 +7,7 @@
 using Avalonia.Input;
 using Avalonia.Input.Platform;
 using Avalonia.Interactivity;
+using Avalonia.Media;
 using OpenIPC.Viewer.App.Controls;
 using OpenIPC.Viewer.App.Services;
 using OpenIPC.Viewer.App.ViewModels;
@@ -79,19 +80,24 @@ private void SetUpImeProxy()
         this.FindControl<Button>("KeyShowKeyboard")!.Click += (_, _) => FocusInput();
 
         _ctrlKey = this.FindControl<ToggleButton>("KeyCtrl");
-        WireKey("KeyEsc", "\x1b");
-        WireKey("KeyTab", "\t");
-        WireKey("KeyArrowUp", "\x1b[A");
-        WireKey("KeyArrowDown", "\x1b[B");
-        WireKey("KeyArrowRight", "\x1b[C");
-        WireKey("KeyArrowLeft", "\x1b[D");
+        WireKey("KeyEsc", () => "\x1b");
+        WireKey("KeyTab", () => "\t");
+        // Arrows follow the cursor-key mode at the moment of the tap: a full-screen tool may have
+        // switched to the ESC O spelling since the bar was wired.
+        WireKey("KeyArrowUp", () => CursorKey('A'));
+        WireKey("KeyArrowDown", () => CursorKey('B'));
+        WireKey("KeyArrowRight", () => CursorKey('C'));
+        WireKey("KeyArrowLeft", () => CursorKey('D'));
     }
 
-    private void WireKey(string buttonName, string sequence)
+    private string CursorKey(char final) =>
+        (DataContext as SshTerminalViewModel)?.Emulator.CursorKey(final) ?? "\x1b[" + final;
+
+    private void WireKey(string buttonName, Func<string> sequence)
     {
         this.FindControl<Button>(buttonName)!.Click += (_, _) =>
         {
-            SendInput(sequence);
+            SendInput(sequence());
             // The key-bar buttons are not focusable, so the proxy still holds focus; this only
             // matters for bringing a dismissed keyboard back, which is opt-in.
             AutoFocusInput();
@@ -116,6 +122,12 @@ protected override void OnAttachedToVisualTree(VisualTreeAttachmentEventArgs e)
 
         _term.Emulator = vm.Emulator;
         _term.TerminalFontSize = vm.FontSize;
+        _term.ColorTheme = vm.Theme;
+        _term.CursorStyle = vm.CursorStyle;
+        _term.CursorBlink = vm.CursorBlink;
+        // The strip around the grid (whatever is left when the size isn't a whole number of
+        // cells) takes the theme's background rather than the original dark one.
+        Background = new SolidColorBrush(Color.FromUInt32(0xFF00_0000 | vm.Theme.Background));
         _term.Input += (_, text) => SendInput(text);
         _term.PasteRequested += (_, _) => _ = PasteAsync();
         _term.CopyRequested += (_, _) => _ = CopyAsync(_term.GetSelectedText());
@@ -386,20 +398,9 @@ private void OnProxyKeyDown(object? sender, KeyEventArgs e)
             return;
         }
 
-        var seq = e.Key switch
-        {
-            Key.Enter => "\r",
-            Key.Back => "\x7f",
-            Key.Tab => "\t",
-            Key.Escape => "\x1b",
-            Key.Up => "\x1b[A",
-            Key.Down => "\x1b[B",
-            Key.Right => "\x1b[C",
-            Key.Left => "\x1b[D",
-            Key.Home => "\x1b[H",
-            Key.End => "\x1b[F",
-            _ => null,
-        };
+        // Same table as the terminal's own key handler, so a hardware keyboard on a phone gets the
+        // cursor-key mode and the F-keys too.
+        var seq = _term?.SequenceFor(e.Key, e.KeyModifiers);
         if (seq is not null)
         {
             SendInput(seq);
diff --git a/src/OpenIPC.Viewer.App/Views/Pages/SettingsPage.axaml b/src/OpenIPC.Viewer.App/Views/Pages/SettingsPage.axaml
index 83d1640..8010d0a 100644
--- a/src/OpenIPC.Viewer.App/Views/Pages/SettingsPage.axaml
+++ b/src/OpenIPC.Viewer.App/Views/Pages/SettingsPage.axaml
@@ -3,6 +3,7 @@
              xmlns:vm="using:OpenIPC.Viewer.App.ViewModels"
              xmlns:svc="using:OpenIPC.Viewer.App.Services"
              xmlns:conv="using:OpenIPC.Viewer.App.Converters"
+             xmlns:controls="using:OpenIPC.Viewer.App.Controls"
              x:Class="OpenIPC.Viewer.App.Views.Pages.SettingsPage"
              x:DataType="vm:SettingsPageViewModel">
 
@@ -405,6 +406,53 @@
                            Minimum="8" Maximum="32" Increment="1" FormatString="0" MinWidth="120" />
           </Grid>
 
+          <Grid ColumnDefinitions="*,Auto">
+            <TextBlock Grid.Column="0" Classes="field-label"
+                       Text="{Binding [Settings.Ssh.Theme], Source={x:Static svc:Localizer.Instance}}" />
+            <ComboBox Grid.Column="1"
+                      ItemsSource="{Binding TerminalThemeOptions}"
+                      SelectedItem="{Binding SshTerminalTheme, Mode=TwoWay}"
+                      DisplayMemberBinding="{Binding Display}"
+                      MinWidth="160" />
+          </Grid>
+
+          <Grid ColumnDefinitions="*,Auto">
+            <TextBlock Grid.Column="0" Classes="field-label"
+                       Text="{Binding [Settings.Ssh.CursorStyle], Source={x:Static svc:Localizer.Instance}}" />
+            <ComboBox Grid.Column="1"
+                      ItemsSource="{Binding TerminalCursorStyleOptions}"
+                      SelectedItem="{Binding SshTerminalCursorStyle, Mode=TwoWay}"
+                      DisplayMemberBinding="{Binding Display}"
+                      MinWidth="160" />
+          </Grid>
+
+          <CheckBox IsChecked="{Binding SshTerminalCursorBlink}"
+                    Content="{Binding [Settings.Ssh.CursorBlink], Source={x:Static svc:Localizer.Instance}}"
+                    Foreground="{StaticResource TextPrimaryBrush}" />
+
+          <Grid ColumnDefinitions="*,Auto">
+            <TextBlock Grid.Column="0" Classes="field-label"
+                       Text="{Binding [Settings.Ssh.Scrollback], Source={x:Static svc:Localizer.Instance}}" />
+            <NumericUpDown Grid.Column="1" Value="{Binding SshTerminalScrollback, Mode=TwoWay}"
+                           Minimum="100" Maximum="50000"
+                           Increment="500" FormatString="0" MinWidth="120" />
+          </Grid>
+
+          <!-- Live preview: the real terminal control over a fixed sample screen. -->
+          <Border HorizontalAlignment="Left"
+                  CornerRadius="{StaticResource RadiusSm}"
+                  BorderBrush="{StaticResource BorderWeakBrush}" BorderThickness="1"
+                  ClipToBounds="True">
+            <controls:TerminalView Emulator="{Binding TerminalPreview}"
+                                   ColorTheme="{Binding SshTerminalTheme.Theme}"
+                                   CursorStyle="{Binding SshTerminalCursorStyle.Style}"
+                                   CursorBlink="{Binding SshTerminalCursorBlink}"
+                                   TerminalFontSize="{Binding SshTerminalPreviewFontSize}"
+                                   FitToEmulator="True"
+                                   Focusable="False"
+                                   IsHitTestVisible="False" />
+          </Border>
+
           <StackPanel Spacing="6">
             <TextBlock Classes="field-label"
                        Text="{Binding [Settings.Ssh.MajesticPath], Source={x:Static svc:Localizer.Instance}}" />
diff --git a/src/OpenIPC.Viewer.Core/Ssh/Terminal/TerminalCell.cs b/src/OpenIPC.Viewer.Core/Ssh/Terminal/TerminalCell.cs
index c38831b..e296f21 100644
--- a/src/OpenIPC.Viewer.Core/Ssh/Terminal/TerminalCell.cs
+++ b/src/OpenIPC.Viewer.Core/Ssh/Terminal/TerminalCell.cs
@@ -1,19 +1,91 @@
+using System;
+
 namespace OpenIPC.Viewer.Core.Ssh.Terminal;
 
 /// <summary>One character cell in the terminal grid.</summary>
-public readonly record struct TerminalCell(char Char, byte Foreground, byte Background, bool Bold)
+public readonly record struct TerminalCell(
+    char Char, TerminalColor Foreground, TerminalColor Background, TerminalAttributes Attributes)
 {
     public static readonly TerminalCell Blank =
-        new(' ', TerminalPalette.DefaultForeground, TerminalPalette.DefaultBackground, false);
+        new(' ', TerminalColor.Default, TerminalColor.Default, TerminalAttributes.None);
+
+    public bool Bold => (Attributes & TerminalAttributes.Bold) != 0;
+}
+
+/// <summary>SGR rendition flags carried by a <see cref="TerminalCell"/>.</summary>
+[Flags]
+public enum TerminalAttributes : byte
+{
+    None = 0,
+    Bold = 1,
+    Dim = 2,
+    Italic = 4,
+    Underline = 8,
+    Inverse = 16,
+    Hidden = 32,
+    Strikethrough = 64,
 }
 
 /// <summary>
-/// Color indices used by <see cref="TerminalCell"/>. 0–7 are the standard ANSI
-/// colors, 8–15 their bright variants; two sentinels mark "use the theme
-/// default". The renderer maps these to brushes.
+/// A cell color as the remote asked for it: the theme default, a palette index (0–15 are the
+/// theme's ANSI colors, 16–255 the fixed xterm cube and gray ramp), or a 24-bit RGB value.
+/// Turning it into a pixel is the theme's job (<see cref="TerminalTheme.Resolve"/>), so a
+/// screen keeps its meaning when the user switches themes.
 /// </summary>
+public readonly record struct TerminalColor
+{
+    private const uint KindMask = 0xFF00_0000;
+    private const uint IndexedKind = 0x0100_0000;
+    private const uint RgbKind = 0x0200_0000;
+
+    private readonly uint _value;
+
+    private TerminalColor(uint value) => _value = value;
+
+    public static TerminalColor Default => default;
+
+    public static TerminalColor FromIndex(int index) => new(IndexedKind | (uint)(index & 0xFF));
+
+    public static TerminalColor FromRgb(int r, int g, int b) =>
+        new(RgbKind | (Channel(r) << 16) | (Channel(g) << 8) | Channel(b));
+
+    public bool IsDefault => _value == 0;
+    public bool IsIndexed => (_value & KindMask) == IndexedKind;
+    public bool IsRgb => (_value & KindMask) == RgbKind;
+
+    /// <summary>Palette index; meaningful when <see cref="IsIndexed"/>.</summary>
+    public int Index => (int)(_value & 0xFF);
+
+    /// <summary>0xRRGGBB; meaningful when <see cref="IsRgb"/>.</summary>
+    public uint Rgb => _value & 0x00FF_FFFF;
+
+    private static uint Channel(int v) => (uint)Math.Clamp(v, 0, 255);
+}
+
+/// <summary>The fixed part of the xterm 256-color palette.</summary>
 public static class TerminalPalette
 {
-    public const byte DefaultForeground = 0xFF;
-    public const byte DefaultBackground = 0xFE;
+    private static readonly int[] CubeSteps = { 0, 95, 135, 175, 215, 255 };
+
+    /// <summary>
+    /// 0xRRGGBB for palette indices 16–255: a 6×6×6 color cube followed by a 24-step gray ramp.
+    /// Indices 0–15 are theme colors and are not answered here.
+    /// </summary>
+    public static uint Xterm256(int index)
+    {
+        if (index is < 16 or > 255)
+            throw new ArgumentOutOfRangeException(nameof(index));
+
+        if (index >= 232)
+        {
+            var gray = (uint)(8 + (index - 232) * 10);
+            return (gray << 16) | (gray << 8) | gray;
+        }
+
+        var cube = index - 16;
+        var r = (uint)CubeSteps[cube / 36];
+        var g = (uint)CubeSteps[cube / 6 % 6];
+        var b = (uint)CubeSteps[cube % 6];
+        return (r << 16) | (g << 8) | b;
+    }
 }
diff --git a/src/OpenIPC.Viewer.Core/Ssh/Terminal/TerminalEmulator.cs b/src/OpenIPC.Viewer.Core/Ssh/Terminal/TerminalEmulator.cs
index 0786dda..05c7cfe 100644
--- a/src/OpenIPC.Viewer.Core/Ssh/Terminal/TerminalEmulator.cs
+++ b/src/OpenIPC.Viewer.Core/Ssh/Terminal/TerminalEmulator.cs
@@ -7,22 +7,31 @@
 namespace OpenIPC.Viewer.Core.Ssh.Terminal;
 
 /// <summary>
-/// A deliberately small VT/ANSI terminal emulator (phase-13 §13.3 "basic VT" —
-/// no alt-screen, mouse, or full ncurses). Feeds UTF-8 bytes through a state
-/// machine that maintains a character grid: printable text, the common control
-/// codes, CSI cursor/erase moves, and SGR colors. Unknown escapes are consumed
-/// and ignored rather than corrupting the screen.
+/// A small VT/xterm terminal emulator (phase-13 §13.3). Feeds UTF-8 bytes through a state
+/// machine that maintains a character grid: printable text, the common control codes, CSI
+/// cursor/erase/insert/delete, scroll regions, the alternate screen full-screen tools draw on,
+/// the DEC line-drawing charset, and SGR renditions (16/256/truecolor, bold, dim, italic,
+/// underline, inverse, hidden, strikethrough). Mouse reporting is not modelled. Unknown escapes
+/// are consumed and ignored rather than corrupting the screen.
 /// </summary>
 public sealed class TerminalEmulator
 {
     private const char Esc = '\x1b';
     private const char Bel = '\x07';
 
-    private enum State { Ground, Escape, Csi, String }
+    private enum State { Ground, Escape, EscapeIntermediate, Csi, String }
 
+    // The grid being drawn and written: the main screen, or the alternate one while a full-screen
+    // tool is running. The main screen waits in _mainScreen meanwhile, and only it has history —
+    // a redraw of vi's screen scrolling past is not something anyone wants to scroll back through.
     private TerminalCell[][] _screen = Array.Empty<TerminalCell[]>();
+    private TerminalCell[][]? _mainScreen;
     private readonly List<TerminalCell[]> _scrollback = new();
-    private const int MaxScrollback = 1000;
+    private int _scrollbackLimit;
+
+    public const int DefaultScrollbackLimit = 1000;
+    public const int MinScrollbackLimit = 100;
+    public const int MaxScrollbackLimit = 50_000;
 
     // Rows that ran out of width and carried on in the row below (autowrap), as opposed to rows a
     // line break ended. Copying needs the difference: a long command wraps across two or three rows
@@ -34,22 +43,49 @@ private enum State { Ground, Escape, Csi, String }
 
     private int _cursorRow;
     private int _cursorCol;
-    private int _savedRow;
-    private int _savedCol;
 
-    private byte _fg = TerminalPalette.DefaultForeground;
-    private byte _bg = TerminalPalette.DefaultBackground;
-    private bool _bold;
+    private TerminalColor _fg;
+    private TerminalColor _bg;
+    private TerminalAttributes _attrs;
+
+    // Scroll region (DECSTBM), inclusive. Line feeds at its bottom scroll only the rows inside it,
+    // which is how a full-screen tool keeps a header and a status line still while a list moves.
+    private int _scrollTop;
+    private int _scrollBottom;
+    private bool _originMode;
+    private bool _autoWrap = true;
+
+    // Character sets: G0 and G1 are each either ASCII or DEC special graphics (the line-drawing
+    // set behind every box in mc and htop); SO/SI pick which one is in use.
+    private bool _g0Graphics;
+    private bool _g1Graphics;
+    private bool _shiftOut;
+
+    private char _lastPrinted;
+
+    private struct SavedCursor
+    {
+        public int Row, Col;
+        public TerminalColor Fg, Bg;
+        public TerminalAttributes Attrs;
+        public bool OriginMode, G0Graphics, G1Graphics, ShiftOut;
+    }
+
+    private SavedCursor _saved;
+    // The cursor the main screen had when ?1049 switched away from it.
+    private SavedCursor _mainCursor;
 
     private State _state = State.Ground;
     private readonly StringBuilder _params = new();
     private bool _privateSeq;
+    private char _escIntermediate;
     // How much of an unterminated escape we are willing to swallow before deciding the stream
     // lied to us and going back to printing. Without a ceiling one malformed sequence eats the
     // rest of the session: every byte after it disappears into the parser and the screen stops
     // changing at all.
     private const int MaxSequenceLength = 4096;
-    private const int MaxParamsLength = 64;
+    // Room for a truecolor foreground and background plus a few flags in one SGR.
+    private const int MaxParamsLength = 128;
     private int _stringLength;
 
     private readonly Decoder _decoder = Encoding.UTF8.GetDecoder();
@@ -57,8 +93,9 @@ private enum State { Ground, Escape, Csi, String }
 
     public int Columns { get; private set; }
     public int Rows { get; private set; }
+    // While a wrap is pending the column is one past the last cell; nothing outside needs that.
     public int CursorRow => _cursorRow;
-    public int CursorColumn => _cursorCol;
+    public int CursorColumn => Math.Min(_cursorCol, Math.Max(0, Columns - 1));
 
     /// <summary>
     /// The remote turned on bracketed paste (CSI ?2004h): pasted text is to be sent between
@@ -66,6 +103,32 @@ private enum State { Ground, Escape, Csi, String }
     /// </summary>
     public bool BracketedPaste { get; private set; }
 
+    /// <summary>False while the remote has hidden the cursor (CSI ?25l) — full-screen tools do.</summary>
+    public bool CursorVisible { get; private set; } = true;
+
+    /// <summary>A full-screen tool switched to the alternate screen (CSI ?1049h and friends).</summary>
+    public bool IsAlternateScreen => _mainScreen is not null;
+
+    /// <summary>
+    /// The remote asked for "application" cursor keys (DECCKM, CSI ?1h): arrows are to be sent as
+    /// ESC O A rather than ESC [ A. ncurses tools switch this on and only recognise that spelling.
+    /// </summary>
+    public bool ApplicationCursorKeys { get; private set; }
+
+    /// <summary>
+    /// How many rows that scrolled off the top are remembered. Lowering it drops the oldest rows
+    /// straight away.
+    /// </summary>
+    public int ScrollbackLimit
+    {
+        get => _scrollbackLimit;
+        set
+        {
+            _scrollbackLimit = Math.Clamp(value, MinScrollbackLimit, MaxScrollbackLimit);
+            TrimScrollback();
+        }
+    }
+
     /// <summary>
     /// True when <paramref name="row"/> (from <see cref="GetRow"/> or
     /// <see cref="GetScrollbackRow"/>) continues in the next row — the text ran past the right
@@ -76,16 +139,32 @@ private enum State { Ground, Escape, Csi, String }
     /// <summary>Raised after a <see cref="Feed(byte[])"/> batch mutates the grid.</summary>
     public event Action? Updated;
 
-    public TerminalEmulator(int columns, int rows) => Resize(columns, rows);
+    /// <summary>
+    /// Bytes the terminal itself has to send back to the remote — answers to status queries
+    /// (cursor position, device attributes). Raised while feeding.
+    /// </summary>
+    public event Action<string>? Reply;
+
+    public TerminalEmulator(int columns, int rows, int scrollbackLimit = DefaultScrollbackLimit)
+    {
+        ScrollbackLimit = scrollbackLimit;
+        Resize(columns, rows);
+    }
 
     public TerminalCell[] GetRow(int row) => _screen[row];
 
-    /// <summary>Rows that have scrolled off the top and are still remembered.</summary>
-    public int ScrollbackRows => _scrollback.Count;
+    /// <summary>
+    /// Rows that have scrolled off the top and are still remembered. None while the alternate
+    /// screen is up: what is on it is all there is.
+    /// </summary>
+    public int ScrollbackRows => IsAlternateScreen ? 0 : _scrollback.Count;
 
     /// <summary>One remembered row; index 0 is the oldest.</summary>
     public TerminalCell[] GetScrollbackRow(int index) => _scrollback[index];
 
+    /// <summary>What a cursor key (A/B/C/D, H/F) sends in the current cursor-key mode.</summary>
+    public string CursorKey(char final) => (ApplicationCursorKeys ? "\x1bO" : "\x1b[") + final;
+
     public void Resize(int columns, int rows)
     {
         columns = Math.Max(1, columns);
@@ -93,23 +172,44 @@ public void Resize(int columns, int rows)
         if (columns == Columns && rows == Rows)
             return;
 
-        var had = _screen.Length > 0;
+        if (_mainScreen is null)
+        {
+            _screen = ResizeMain(_screen, columns, rows, ref _cursorRow);
+        }
+        else
+        {
+            // The tool on the alternate screen redraws itself when told the new size; all that
+            // matters here is that nothing is out of range until it does.
+            _mainScreen = ResizeMain(_mainScreen, columns, rows, ref _mainCursor.Row);
+            _screen = ResizeKeepingTop(_screen, columns, rows);
+            _cursorRow = Math.Clamp(_cursorRow, 0, rows - 1);
+        }
+
+        Columns = columns;
+        Rows = rows;
+        _cursorCol = Math.Min(_cursorCol, columns - 1);
+        _scrollTop = 0;
+        _scrollBottom = rows - 1;
+        Updated?.Invoke();
+    }
+
+    private TerminalCell[][] ResizeMain(TerminalCell[][] screen, int columns, int rows, ref int cursorRow)
+    {
+        var had = screen.Length > 0;
+        var oldRows = screen.Length;
 
         // Losing rows takes them off the TOP, the way a real terminal does it: the interesting end
         // of a shell session is the bottom one. Keeping the top instead would drop the prompt every
         // time the view got shorter — which on a phone is every time the soft keyboard opens.
-        var drop = had ? Math.Max(0, Rows - rows) : 0;
+        var drop = had ? Math.Max(0, oldRows - rows) : 0;
         for (var r = 0; r < drop; r++)
-        {
-            _scrollback.Add(_screen[r]);
-            if (_scrollback.Count > MaxScrollback)
-                _scrollback.RemoveAt(0);
-        }
+            _scrollback.Add(screen[r]);
+        TrimScrollback();
 
         // And they come back when the view grows again. Without this the trip is one-way: showing
         // and hiding the keyboard once ate a few rows of output for good, and doing it a few times
         // scrolled a long listing off the top with no way to get it back.
-        var restore = had ? Math.Min(Math.Max(0, rows - Rows), _scrollback.Count) : 0;
+        var restore = had ? Math.Min(Math.Max(0, rows - oldRows), _scrollback.Count) : 0;
 
         var next = new TerminalCell[rows][];
         for (var r = 0; r < rows; r++)
@@ -124,26 +224,37 @@ public void Resize(int columns, int rows)
             else
             {
                 var from = r - restore + drop;
-                source = had && from < Rows ? _screen[from] : null;
+                source = had && from < oldRows ? screen[from] : null;
             }
 
             if (source is not null)
-            {
-                Array.Copy(source, next[r], Math.Min(columns, source.Length));
-                if (IsWrapped(source))
-                    MarkWrapped(next[r], true);
-            }
+                CopyRow(source, next[r], columns);
         }
 
         if (restore > 0)
             _scrollback.RemoveRange(_scrollback.Count - restore, restore);
 
-        Columns = columns;
-        Rows = rows;
-        _screen = next;
-        _cursorRow = Math.Clamp(_cursorRow - drop + restore, 0, rows - 1);
-        _cursorCol = Math.Min(_cursorCol, columns - 1);
-        Updated?.Invoke();
+        cursorRow = Math.Clamp(cursorRow - drop + restore, 0, rows - 1);
+        return next;
+    }
+
+    private TerminalCell[][] ResizeKeepingTop(TerminalCell[][] screen, int columns, int rows)
+    {
+        var next = new TerminalCell[rows][];
+        for (var r = 0; r < rows; r++)
+        {
+            next[r] = NewBlankRow(columns);
+            if (r < screen.Length)
+                CopyRow(screen[r], next[r], columns);
+        }
+        return next;
+    }
+
+    private void CopyRow(TerminalCell[] source, TerminalCell[] target, int columns)
+    {
+        Array.Copy(source, target, Math.Min(columns, source.Length));
+        if (IsWrapped(source))
+            MarkWrapped(target, true);
     }
 
     public void Feed(byte[] bytes) => Feed(bytes.AsSpan());
@@ -173,6 +284,7 @@ private void ProcessChar(char c)
         {
             case State.Ground: ProcessGround(c); break;
             case State.Escape: ProcessEscape(c); break;
+            case State.EscapeIntermediate: ProcessEscapeIntermediate(c); break;
             case State.Csi: ProcessCsi(c); break;
             case State.String: ProcessString(c); break;
         }
@@ -184,9 +296,12 @@ private void ProcessGround(char c)
         {
             case Esc: _state = State.Escape; break;
             case '\r': _cursorCol = 0; break;
-            case '\n': LineFeed(); break;
-            case '\b': if (_cursorCol > 0) _cursorCol--; break;
+            // VT and FF are line feeds on every terminal that matters.
+            case '\n' or '\v' or '\f': LineFeed(); break;
+            case '\b': if (_cursorCol > 0) _cursorCol = Math.Min(_cursorCol, Columns - 1) - 1; break;
             case '\t': _cursorCol = Math.Min(Columns - 1, (_cursorCol / 8 + 1) * 8); break;
+            case '\x0e': _shiftOut = true; break;  // SO — G1
+            case '\x0f': _shiftOut = false; break; // SI — G0
             case Bel: break;
             default:
                 if (!char.IsControl(c))
@@ -197,6 +312,7 @@ private void ProcessGround(char c)
 
     private void ProcessEscape(char c)
     {
+        _state = State.Ground;
         switch (c)
         {
             case '[':
@@ -210,16 +326,31 @@ private void ProcessEscape(char c)
                 _stringLength = 0;
                 _state = State.String;
                 break;
-            case 'c': // RIS — full reset
-                ResetScreen();
-                BracketedPaste = false;
-                _state = State.Ground;
-                break;
-            default:
-                // Charset selection ESC( / ESC) and other two-char escapes —
-                // ignore the parameter byte and return to ground.
-                _state = State.Ground;
+            // Escapes with an intermediate byte — charset designation ESC ( 0, ESC # 8 and the
+            // like — are three characters long. Treating them as two printed the third: every
+            // ncurses "back to normal" (ESC ( B) left a stray B on the screen.
+            case >= ' ' and <= '/':
+                _escIntermediate = c;
+                _state = State.EscapeIntermediate;
                 break;
+            case '7': SaveCursor(ref _saved); break;
+            case '8': RestoreCursor(_saved); break;
+            case 'D': LineFeed(); break;                      // IND
+            case 'E': _cursorCol = 0; LineFeed(); break;      // NEL
+            case 'M': ReverseIndex(); break;                  // RI
+            case 'c': FullReset(); break;                     // RIS
+            default: break; // ESC = / ESC > (keypad modes) and the rest: nothing to draw.
+        }
+    }
+
+    private void ProcessEscapeIntermediate(char c)
+    {
+        _state = State.Ground;
+        switch (_escIntermediate)
+        {
+            case '(': _g0Graphics = c == '0'; break;
+            case ')': _g1Graphics = c == '0'; break;
+            default: break;
         }
     }
 
@@ -269,10 +400,10 @@ private void ProcessCsi(char c)
         }
         if ((c >= '0' && c <= '9') || c == ';' || c == ':')
         {
-            // Sub-parameters (SGR 38:5:n) read the same as the ';' spelling for the colours we
-            // model, so they are folded into one syntax rather than given a parser of their own.
+            // ':' separates sub-parameters (SGR 38:2::r:g:b). They are kept as written: only SGR
+            // reads them, and everything else looks at the number before the first colon.
             if (_params.Length < MaxParamsLength)
-                _params.Append(c == ':' ? ';' : c);
+                _params.Append(c);
             return;
         }
         // Intermediate bytes (0x20–0x2F) belong to sequences we don't implement — consume them
@@ -296,125 +427,400 @@ private void ProcessCsi(char c)
 
     private void DispatchCsi(char final, int[] ps)
     {
-        // Private sequences (ESC[?…) are mode toggles. The one we model is bracketed paste; the
-        // rest (cursor visibility, alt screen, …) are consumed and ignored.
         if (_privateSeq)
         {
-            if (final is 'h' or 'l' && Array.IndexOf(ps, 2004) >= 0)
-                BracketedPaste = final == 'h';
+            if (final is 'h' or 'l')
+                foreach (var mode in ps)
+                    SetPrivateMode(mode, final == 'h');
+            // Everything else private (DA2 queries, xterm key-modifier options, …) is ignored.
             return;
         }
 
+        var n = Arg(ps, 0, 1);
         switch (final)
         {
-            case 'm': ApplySgr(ps); break;
-            case 'H' or 'f':
-                _cursorRow = ClampRow(Arg(ps, 0, 1) - 1);
-                _cursorCol = ClampCol(Arg(ps, 1, 1) - 1);
-                break;
-            case 'A': _cursorRow = ClampRow(_cursorRow - Arg(ps, 0, 1)); break;
-            case 'B': _cursorRow = ClampRow(_cursorRow + Arg(ps, 0, 1)); break;
-            case 'C': _cursorCol = ClampCol(_cursorCol + Arg(ps, 0, 1)); break;
-            case 'D': _cursorCol = ClampCol(_cursorCol - Arg(ps, 0, 1)); break;
-            case 'G': _cursorCol = ClampCol(Arg(ps, 0, 1) - 1); break;
-            case 'd': _cursorRow = ClampRow(Arg(ps, 0, 1) - 1); break;
+            case 'm': ApplySgr(_params.ToString()); break;
+            case 'H' or 'f': MoveTo(Arg(ps, 0, 1) - 1, Arg(ps, 1, 1) - 1); break;
+            case 'A': CursorUp(n); break;
+            case 'B' or 'e': CursorDown(n); break;
+            case 'C' or 'a': _cursorCol = ClampCol(_cursorCol + n); break;
+            case 'D': _cursorCol = ClampCol(Math.Min(_cursorCol, Columns - 1) - n); break;
+            case 'E': CursorDown(n); _cursorCol = 0; break;
+            case 'F': CursorUp(n); _cursorCol = 0; break;
+            case 'G' or '`': _cursorCol = ClampCol(n - 1); break;
+            case 'd': MoveTo(n - 1, _cursorCol); break;
             case 'J': EraseInDisplay(Arg(ps, 0, 0)); break;
             case 'K': EraseInLine(Arg(ps, 0, 0)); break;
-            case 's': _savedRow = _cursorRow; _savedCol = _cursorCol; break;
-            case 'u': _cursorRow = ClampRow(_savedRow); _cursorCol = ClampCol(_savedCol); break;
+            case 'L': InsertLines(n); break;
+            case 'M': DeleteLines(n); break;
+            case '@': InsertChars(n); break;
+            case 'P': DeleteChars(n); break;
+            case 'X': EraseChars(n); break;
+            case 'S': ScrollUp(n); break;
+            case 'T': ShiftDown(_scrollTop, _scrollBottom, n); break;
+            case 'b': RepeatLast(n); break;
+            case 'r': SetScrollRegion(Arg(ps, 0, 1) - 1, Arg(ps, 1, Rows) - 1); break;
+            case 's': SaveCursor(ref _saved); break;
+            case 'u': RestoreCursor(_saved); break;
+            case 'n': DeviceStatus(Arg(ps, 0, 0)); break;
+            case 'c' when Arg(ps, 0, 0) == 0: Reply?.Invoke("\x1b[?1;2c"); break; // a VT100 with AVO
             default: break; // unsupported — ignore
         }
     }
 
-    private void ApplySgr(int[] ps)
+    private void SetPrivateMode(int mode, bool on)
+    {
+        switch (mode)
+        {
+            case 1: ApplicationCursorKeys = on; break;
+            case 6:
+                _originMode = on;
+                MoveTo(0, 0);
+                break;
+            case 7: _autoWrap = on; break;
+            case 25: CursorVisible = on; break;
+            case 47 or 1047: SwitchScreen(on, saveCursor: false); break;
+            case 1049: SwitchScreen(on, saveCursor: true); break;
+            case 2004: BracketedPaste = on; break;
+            default: break; // mouse modes, focus events, … — not modelled
+        }
+    }
+
+    // ?1049 is "save the cursor, switch to a cleared alternate screen" and, on the way back,
+    // "switch back and restore the cursor". ?47 / ?1047 switch without the cursor dance.
+    private void SwitchScreen(bool alternate, bool saveCursor)
+    {
+        if (alternate == IsAlternateScreen)
+            return;
+
+        if (alternate)
+        {
+            if (saveCursor)
+                SaveCursor(ref _mainCursor);
+            _mainScreen = _screen;
+            _screen = new TerminalCell[Rows][];
+            for (var r = 0; r < Rows; r++)
+                _screen[r] = NewBlankRow(Columns);
+        }
+        else
+        {
+            _screen = _mainScreen!;
+            _mainScreen = null;
+            if (saveCursor)
+                RestoreCursor(_mainCursor);
+        }
+        _scrollTop = 0;
+        _scrollBottom = Rows - 1;
+    }
+
+    private void DeviceStatus(int query)
+    {
+        switch (query)
+        {
+            case 5: Reply?.Invoke("\x1b[0n"); break; // "terminal OK"
+            case 6:
+                var row = _originMode ? _cursorRow - _scrollTop : _cursorRow;
+                Reply?.Invoke(string.Format(CultureInfo.InvariantCulture, "\x1b[{0};{1}R", row + 1, CursorColumn + 1));
+                break;
+        }
+    }
+
+    // SGR arrives in two spellings for the extended colors: the common ';' one, where 38;5;n and
+    // 38;2;r;g;b borrow the parameters that follow, and the ITU ':' one, where the whole color
+    // sits inside a single parameter (38:5:n, 38:2::r:g:b, 38:2:r:g:b).
+    private void ApplySgr(string raw)
     {
-        if (ps.Length == 0)
+        if (raw.Length == 0)
         {
             ResetAttributes();
             return;
         }
 
-        for (var i = 0; i < ps.Length; i++)
+        var parts = raw.Split(';');
+        for (var i = 0; i < parts.Length; i++)
         {
-            var p = ps[i];
+            var part = parts[i];
+            if (part.IndexOf(':') >= 0)
+            {
+                ApplySgrWithSubParams(part.Split(':'));
+                continue;
+            }
+
+            var p = ParseInt(part);
             switch (p)
             {
                 case 0: ResetAttributes(); break;
-                case 1: _bold = true; break;
-                case 22: _bold = false; break;
-                case >= 30 and <= 37: _fg = (byte)(p - 30); break;
-                case 39: _fg = TerminalPalette.DefaultForeground; break;
-                case >= 40 and <= 47: _bg = (byte)(p - 40); break;
-                case 49: _bg = TerminalPalette.DefaultBackground; break;
-                case >= 90 and <= 97: _fg = (byte)(p - 90 + 8); break;
-                case >= 100 and <= 107: _bg = (byte)(p - 100 + 8); break;
-                case 38: i = ConsumeExtendedColor(ps, i, out _fg); break;
-                case 48: i = ConsumeExtendedColor(ps, i, out _bg); break;
+                case 1: _attrs |= TerminalAttributes.Bold; break;
+                case 2: _attrs |= TerminalAttributes.Dim; break;
+                case 3: _attrs |= TerminalAttributes.Italic; break;
+                case 4 or 21: _attrs |= TerminalAttributes.Underline; break;
+                case 7: _attrs |= TerminalAttributes.Inverse; break;
+                case 8: _attrs |= TerminalAttributes.Hidden; break;
+                case 9: _attrs |= TerminalAttributes.Strikethrough; break;
+                case 22: _attrs &= ~(TerminalAttributes.Bold | TerminalAttributes.Dim); break;
+                case 23: _attrs &= ~TerminalAttributes.Italic; break;
+                case 24: _attrs &= ~TerminalAttributes.Underline; break;
+                case 27: _attrs &= ~TerminalAttributes.Inverse; break;
+                case 28: _attrs &= ~TerminalAttributes.Hidden; break;
+                case 29: _attrs &= ~TerminalAttributes.Strikethrough; break;
+                case >= 30 and <= 37: _fg = TerminalColor.FromIndex(p - 30); break;
+                case 39: _fg = TerminalColor.Default; break;
+                case >= 40 and <= 47: _bg = TerminalColor.FromIndex(p - 40); break;
+                case 49: _bg = TerminalColor.Default; break;
+                case >= 90 and <= 97: _fg = TerminalColor.FromIndex(p - 90 + 8); break;
+                case >= 100 and <= 107: _bg = TerminalColor.FromIndex(p - 100 + 8); break;
+                case 38: i = ConsumeExtendedColor(parts, i, ref _fg); break;
+                case 48: i = ConsumeExtendedColor(parts, i, ref _bg); break;
                 default: break;
             }
         }
     }
 
-    // 38/48 ; 5 ; n  (256-color)  or  38/48 ; 2 ; r ; g ; b  (truecolor). We map
-    // a low index to its palette slot and fall back to default for the rest.
-    private static int ConsumeExtendedColor(int[] ps, int i, out byte color)
+    private void ApplySgrWithSubParams(string[] sub)
     {
-        color = TerminalPalette.DefaultForeground;
-        if (i + 1 >= ps.Length)
+        switch (ParseInt(sub[0]))
+        {
+            case 38: _fg = ExtendedColor(sub) ?? _fg; break;
+            case 48: _bg = ExtendedColor(sub) ?? _bg; break;
+            // 4:0 is "no underline"; 4:1..4:5 are underline styles, all drawn as one line here.
+            case 4:
+                if (sub.Length > 1 && ParseInt(sub[1]) == 0)
+                    _attrs &= ~TerminalAttributes.Underline;
+                else
+                    _attrs |= TerminalAttributes.Underline;
+                break;
+            default: break;
+        }
+    }
+
+    // ';' spelling: 38;5;n or 38;2;r;g;b. Returns the index of the last parameter consumed. A
+    // truncated sequence leaves the color as it was rather than guessing.
+    private static int ConsumeExtendedColor(string[] parts, int i, ref TerminalColor color)
+    {
+        if (i + 1 >= parts.Length)
             return i;
 
-        var mode = ps[i + 1];
-        if (mode == 5 && i + 2 < ps.Length)
+        switch (ParseInt(parts[i + 1]))
         {
-            var n = ps[i + 2];
-            color = n < 16 ? (byte)n : TerminalPalette.DefaultForeground;
-            return i + 2;
+            case 5 when i + 2 < parts.Length:
+                color = TerminalColor.FromIndex(Math.Clamp(ParseInt(parts[i + 2]), 0, 255));
+                return i + 2;
+            case 2 when i + 4 < parts.Length:
+                color = TerminalColor.FromRgb(
+                    ParseInt(parts[i + 2]), ParseInt(parts[i + 3]), ParseInt(parts[i + 4]));
+                return i + 4;
+            default:
+                return i + 1;
         }
-        if (mode == 2 && i + 4 < ps.Length)
-            return i + 4; // truecolor not represented — leave default
+    }
 
-        return i + 1;
+    // ':' spelling — sub[0] is 38/48, then 5:n, 2:r:g:b, or 2:colorspace:r:g:b.
+    private static TerminalColor? ExtendedColor(string[] sub)
+    {
+        if (sub.Length < 2)
+            return null;
+
+        var mode = ParseInt(sub[1]);
+        var args = sub.Length - 2;
+        if (mode == 5 && args >= 1)
+            return TerminalColor.FromIndex(Math.Clamp(ParseInt(sub[2]), 0, 255));
+        if (mode == 2 && args >= 3)
+        {
+            // With four arguments the first is the color-space id, usually left empty.
+            var r = args >= 4 ? 3 : 2;
+            return TerminalColor.FromRgb(ParseInt(sub[r]), ParseInt(sub[r + 1]), ParseInt(sub[r + 2]));
+        }
+        return null;
     }
 
     private void PutChar(char c)
     {
         if (_cursorCol >= Columns)
         {
-            MarkWrapped(_screen[_cursorRow], true);
-            _cursorCol = 0;
-            LineFeed();
+            if (_autoWrap)
+            {
+                MarkWrapped(_screen[_cursorRow], true);
+                _cursorCol = 0;
+                LineFeed();
+            }
+            else
+            {
+                // No autowrap: the last column is overwritten until something moves the cursor.
+                _cursorCol = Columns - 1;
+            }
         }
-        _screen[_cursorRow][_cursorCol] = new TerminalCell(c, _fg, _bg, _bold);
+
+        var graphics = _shiftOut ? _g1Graphics : _g0Graphics;
+        _screen[_cursorRow][_cursorCol] =
+            new TerminalCell(graphics ? DecSpecialGraphics(c) : c, _fg, _bg, _attrs);
         _cursorCol++;
+        _lastPrinted = c;
+    }
+
+    // REP — the last printed character again, n times. ncurses uses it to draw long runs of the
+    // same character (a horizontal rule, a blank stretch of a status line).
+    private void RepeatLast(int n)
+    {
+        if (_lastPrinted == '\0')
+            return;
+        for (var i = 0; i < Math.Min(n, Columns * Rows); i++)
+            PutChar(_lastPrinted);
     }
 
+    // The DEC special graphics set: the lower-case letters and a few symbols turn into the
+    // box-drawing pieces full-screen tools draw their frames with.
+    private static char DecSpecialGraphics(char c) => c switch
+    {
+        '`' => '◆', 'a' => '▒', 'b' => '␉', 'c' => '␌', 'd' => '␍', 'e' => '␊', 'f' => '°',
+        'g' => '±', 'h' => '␤', 'i' => '␋', 'j' => '┘', 'k' => '┐', 'l' => '┌', 'm' => '└',
+        'n' => '┼', 'o' => '⎺', 'p' => '⎻', 'q' => '─', 'r' => '⎼', 's' => '⎽', 't' => '├',
+        'u' => '┤', 'v' => '┴', 'w' => '┬', 'x' => '│', 'y' => '≤', 'z' => '≥', '{' => 'π',
+        '|' => '≠', '}' => '£', '~' => '·',
+        _ => c,
+    };
+
     private void LineFeed()
     {
-        if (_cursorRow >= Rows - 1)
-            ScrollUp();
-        else
+        if (_cursorRow == _scrollBottom)
+            ScrollUp(1);
+        else if (_cursorRow < Rows - 1)
             _cursorRow++;
     }
 
-    private void ScrollUp()
+    private void ReverseIndex()
     {
-        _scrollback.Add(_screen[0]);
-        if (_scrollback.Count > MaxScrollback)
-            _scrollback.RemoveAt(0);
+        if (_cursorRow == _scrollTop)
+            ShiftDown(_scrollTop, _scrollBottom, 1);
+        else if (_cursorRow > 0)
+            _cursorRow--;
+    }
 
-        for (var r = 1; r < Rows; r++)
-            _screen[r - 1] = _screen[r];
-        _screen[Rows - 1] = NewBlankRow(Columns);
+    // Scroll the region up by n. Rows leaving the very top of the main screen become history;
+    // anything scrolled inside a smaller region, or on the alternate screen, is just gone.
+    private void ScrollUp(int n)
+    {
+        n = Math.Min(n, _scrollBottom - _scrollTop + 1);
+        if (!IsAlternateScreen && _scrollTop == 0)
+        {
+            for (var r = 0; r < n; r++)
+                _scrollback.Add(_screen[r]);
+            TrimScrollback();
+        }
+        ShiftUp(_scrollTop, _scrollBottom, n);
+    }
+
+    // Rows from..to (inclusive) move up by n; blank rows fill in at the bottom of the range.
+    private void ShiftUp(int from, int to, int n)
+    {
+        n = Math.Min(n, to - from + 1);
+        if (n <= 0)
+            return;
+        for (var r = from; r <= to - n; r++)
+            _screen[r] = _screen[r + n];
+        for (var r = to - n + 1; r <= to; r++)
+            _screen[r] = NewErasedRow();
+    }
+
+    // Rows from..to (inclusive) move down by n; blank rows fill in at the top of the range.
+    private void ShiftDown(int from, int to, int n)
+    {
+        n = Math.Min(n, to - from + 1);
+        if (n <= 0)
+            return;
+        for (var r = to; r >= from + n; r--)
+            _screen[r] = _screen[r - n];
+        for (var r = from; r < from + n; r++)
+            _screen[r] = NewErasedRow();
+    }
+
+    // IL / DL work from the cursor row to the bottom of the scroll region, and do nothing when
+    // the cursor is outside it.
+    private void InsertLines(int n)
+    {
+        if (_cursorRow < _scrollTop || _cursorRow > _scrollBottom)
+            return;
+        ShiftDown(_cursorRow, _scrollBottom, n);
+        _cursorCol = 0;
+    }
+
+    private void DeleteLines(int n)
+    {
+        if (_cursorRow < _scrollTop || _cursorRow > _scrollBottom)
+            return;
+        ShiftUp(_cursorRow, _scrollBottom, n);
+        _cursorCol = 0;
+    }
+
+    private void InsertChars(int n)
+    {
+        var row = _screen[_cursorRow];
+        var col = Math.Min(_cursorCol, Columns - 1);
+        n = Math.Min(n, Columns - col);
+        Array.Copy(row, col, row, col + n, Columns - col - n);
+        for (var c = col; c < col + n; c++)
+            row[c] = BlankCell();
+    }
+
+    private void DeleteChars(int n)
+    {
+        var row = _screen[_cursorRow];
+        var col = Math.Min(_cursorCol, Columns - 1);
+        n = Math.Min(n, Columns - col);
+        Array.Copy(row, col + n, row, col, Columns - col - n);
+        for (var c = Columns - n; c < Columns; c++)
+            row[c] = BlankCell();
+    }
+
+    private void EraseChars(int n)
+    {
+        var row = _screen[_cursorRow];
+        var col = Math.Min(_cursorCol, Columns - 1);
+        for (var c = col; c < Math.Min(Columns, col + n); c++)
+            row[c] = BlankCell();
+    }
+
+    private void SetScrollRegion(int top, int bottom)
+    {
+        bottom = Math.Min(bottom, Rows - 1);
+        if (top < 0 || top >= bottom)
+            return;
+        _scrollTop = top;
+        _scrollBottom = bottom;
+        MoveTo(0, 0);
+    }
+
+    // CUP / VPA. In origin mode rows count from the top of the scroll region and stay inside it.
+    private void MoveTo(int row, int col)
+    {
+        if (_originMode)
+            _cursorRow = Math.Clamp(row + _scrollTop, _scrollTop, _scrollBottom);
+        else
+            _cursorRow = ClampRow(row);
+        _cursorCol = ClampCol(col);
+    }
+
+    // Cursor up/down stop at the scroll margins when they start inside the region.
+    private void CursorUp(int n)
+    {
+        var limit = _cursorRow >= _scrollTop ? _scrollTop : 0;
+        _cursorRow = Math.Max(limit, _cursorRow - n);
+    }
+
+    private void CursorDown(int n)
+    {
+        var limit = _cursorRow <= _scrollBottom ? _scrollBottom : Rows - 1;
+        _cursorRow = Math.Min(limit, _cursorRow + n);
     }
 
     private void EraseInLine(int mode)
     {
         var row = _screen[_cursorRow];
+        var col = Math.Min(_cursorCol, Columns - 1);
         var (from, to) = mode switch
         {
-            1 => (0, _cursorCol),
+            1 => (0, col),
             2 => (0, Columns - 1),
-            _ => (_cursorCol, Columns - 1),
+            _ => (col, Columns - 1),
         };
         for (var c = from; c <= to && c < Columns; c++)
             row[c] = BlankCell();
@@ -426,23 +832,36 @@ private void EraseInLine(int mode)
 
     private void EraseInDisplay(int mode)
     {
+        var col = Math.Min(_cursorCol, Columns - 1);
         switch (mode)
         {
             case 1:
                 for (var r = 0; r < _cursorRow; r++) ClearRow(r);
-                for (var c = 0; c <= _cursorCol && c < Columns; c++) _screen[_cursorRow][c] = BlankCell();
+                for (var c = 0; c <= col; c++) _screen[_cursorRow][c] = BlankCell();
                 break;
             case 2:
                 for (var r = 0; r < Rows; r++) ClearRow(r);
                 break;
+            case 3:
+                // `clear` sends this after ED 2: forget the history too.
+                if (!IsAlternateScreen)
+                    _scrollback.Clear();
+                break;
             default:
-                for (var c = _cursorCol; c < Columns; c++) _screen[_cursorRow][c] = BlankCell();
+                for (var c = col; c < Columns; c++) _screen[_cursorRow][c] = BlankCell();
                 MarkWrapped(_screen[_cursorRow], false);
                 for (var r = _cursorRow + 1; r < Rows; r++) ClearRow(r);
                 break;
         }
     }
 
+    private void TrimScrollback()
+    {
+        var excess = _scrollback.Count - _scrollbackLimit;
+        if (excess > 0)
+            _scrollback.RemoveRange(0, excess);
+    }
+
     private void ClearRow(int row)
     {
         var r = _screen[row];
@@ -459,24 +878,74 @@ private void MarkWrapped(TerminalCell[] row, bool wrapped)
             _wrapped.Remove(row);
     }
 
-    private void ResetScreen()
+    private void SaveCursor(ref SavedCursor slot)
+    {
+        slot.Row = _cursorRow;
+        slot.Col = _cursorCol;
+        slot.Fg = _fg;
+        slot.Bg = _bg;
+        slot.Attrs = _attrs;
+        slot.OriginMode = _originMode;
+        slot.G0Graphics = _g0Graphics;
+        slot.G1Graphics = _g1Graphics;
+        slot.ShiftOut = _shiftOut;
+    }
+
+    private void RestoreCursor(SavedCursor slot)
+    {
+        _cursorRow = ClampRow(slot.Row);
+        _cursorCol = Math.Clamp(slot.Col, 0, Columns);
+        _fg = slot.Fg;
+        _bg = slot.Bg;
+        _attrs = slot.Attrs;
+        _originMode = slot.OriginMode;
+        _g0Graphics = slot.G0Graphics;
+        _g1Graphics = slot.G1Graphics;
+        _shiftOut = slot.ShiftOut;
+    }
+
+    private void FullReset()
     {
+        if (IsAlternateScreen)
+        {
+            _screen = _mainScreen!;
+            _mainScreen = null;
+        }
+        _scrollTop = 0;
+        _scrollBottom = Rows - 1;
+        _originMode = false;
+        _autoWrap = true;
+        _g0Graphics = _g1Graphics = _shiftOut = false;
+        _saved = default;
+        _mainCursor = default;
+        BracketedPaste = false;
+        CursorVisible = true;
+        ApplicationCursorKeys = false;
+        ResetAttributes();
         for (var r = 0; r < Rows; r++) ClearRow(r);
         _cursorRow = 0;
         _cursorCol = 0;
-        ResetAttributes();
     }
 
     private void ResetAttributes()
     {
-        _fg = TerminalPalette.DefaultForeground;
-        _bg = TerminalPalette.DefaultBackground;
-        _bold = false;
+        _fg = TerminalColor.Default;
+        _bg = TerminalColor.Default;
+        _attrs = TerminalAttributes.None;
     }
 
     // Erased cells keep the active background so colored fills survive a clear.
     private TerminalCell BlankCell() =>
-        new(' ', TerminalPalette.DefaultForeground, _bg, false);
+        new(' ', TerminalColor.Default, _bg, TerminalAttributes.None);
+
+    private TerminalCell[] NewErasedRow()
+    {
+        var row = new TerminalCell[Columns];
+        var blank = BlankCell();
+        for (var c = 0; c < Columns; c++)
+            row[c] = blank;
+        return row;
+    }
 
     private int[] ParseParams()
     {
@@ -486,10 +955,17 @@ private int[] ParseParams()
         var parts = _params.ToString().Split(';');
         var result = new int[parts.Length];
         for (var i = 0; i < parts.Length; i++)
-            result[i] = int.TryParse(parts[i], NumberStyles.Integer, CultureInfo.InvariantCulture, out var v) ? v : 0;
+        {
+            var part = parts[i];
+            var colon = part.IndexOf(':');
+            result[i] = ParseInt(colon >= 0 ? part.Substring(0, colon) : part);
+        }
         return result;
     }
 
+    private static int ParseInt(string s) =>
+        int.TryParse(s, NumberStyles.Integer, CultureInfo.InvariantCulture, out var v) ? v : 0;
+
     private static int Arg(int[] ps, int index, int fallback) =>
         index < ps.Length && ps[index] > 0 ? ps[index] : fallback;
 
diff --git a/src/OpenIPC.Viewer.Core/Ssh/Terminal/TerminalTheme.cs b/src/OpenIPC.Viewer.Core/Ssh/Terminal/TerminalTheme.cs
new file mode 100644
index 0000000..a3bae09
--- /dev/null
+++ b/src/OpenIPC.Viewer.Core/Ssh/Terminal/TerminalTheme.cs
@@ -0,0 +1,136 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+
+namespace OpenIPC.Viewer.Core.Ssh.Terminal;
+
+/// <summary>
+/// The colors a terminal is drawn with: default text and background, the cursor, the selection
+/// highlight and the 16 ANSI colors. Colors are 0xRRGGBB; <see cref="Selection"/> is 0xAARRGGBB
+/// because it is laid over the text. Terminals keep their own palette rather than following the
+/// app theme — the remote picks colors assuming a terminal, not our UI.
+/// </summary>
+public sealed class TerminalTheme
+{
+    public string Id { get; }
+    public uint Foreground { get; }
+    public uint Background { get; }
+    public uint Cursor { get; }
+    public uint Selection { get; }
+    public IReadOnlyList<uint> Ansi { get; }
+
+    private TerminalTheme(string id, string fg, string bg, string cursor, uint selection, string[] ansi)
+    {
+        if (ansi.Length != 16)
+            throw new ArgumentException("A terminal theme needs exactly 16 ANSI colors.", nameof(ansi));
+        Id = id;
+        Foreground = Hex(fg);
+        Background = Hex(bg);
+        Cursor = Hex(cursor);
+        Selection = selection;
+        Ansi = ansi.Select(Hex).ToArray();
+    }
+
+    /// <summary>0xRRGGBB for a cell color; <paramref name="fallback"/> stands in for the default.</summary>
+    public uint Resolve(TerminalColor color, uint fallback)
+    {
+        if (color.IsRgb)
+            return color.Rgb;
+        if (color.IsIndexed)
+            return color.Index < 16 ? Ansi[color.Index] : TerminalPalette.Xterm256(color.Index);
+        return fallback;
+    }
+
+    /// <summary>
+    /// What a cell actually looks like: its colors resolved against this theme, then inverse,
+    /// dim and hidden applied on top.
+    /// </summary>
+    public (uint Foreground, uint Background) ColorsOf(in TerminalCell cell)
+    {
+        var fg = Resolve(cell.Foreground, Foreground);
+        var bg = Resolve(cell.Background, Background);
+        var attrs = cell.Attributes;
+        if ((attrs & TerminalAttributes.Inverse) != 0)
+            (fg, bg) = (bg, fg);
+        if ((attrs & TerminalAttributes.Dim) != 0)
+            fg = Halfway(fg, bg);
+        if ((attrs & TerminalAttributes.Hidden) != 0)
+            fg = bg;
+        return (fg, bg);
+    }
+
+    // Dim text is the foreground pulled halfway to the background — readable on any theme,
+    // light or dark, which a fixed darkening would not be.
+    private static uint Halfway(uint a, uint b)
+    {
+        uint Mix(int shift) => ((((a >> shift) & 0xFF) + ((b >> shift) & 0xFF)) / 2) << shift;
+        return Mix(16) | Mix(8) | Mix(0);
+    }
+
+    private static uint Hex(string hex) =>
+        uint.Parse(hex.TrimStart('#'), NumberStyles.HexNumber, CultureInfo.InvariantCulture);
+
+    public const string DefaultId = "default";
+
+    public static TerminalTheme Default { get; } = new(DefaultId,
+        "#d4d4d4", "#0c0f14", "#d4d4d4", 0x663B8EEA, new[]
+        {
+            "#1e1e1e", "#cd3131", "#0dbc79", "#e5e510", "#2472c8", "#bc3fbc", "#11a8cd", "#cccccc",
+            "#666666", "#f14c4c", "#23d18b", "#f5f543", "#3b8eea", "#d670d6", "#29b8db", "#ffffff",
+        });
+
+    /// <summary>The built-in themes, in the order the settings page lists them.</summary>
+    public static IReadOnlyList<TerminalTheme> BuiltIn { get; } = new[]
+    {
+        Default,
+        new TerminalTheme("gruvbox-dark",
+            "#ebdbb2", "#282828", "#ebdbb2", 0x99665C54, new[]
+            {
+                "#282828", "#cc241d", "#98971a", "#d79921", "#458588", "#b16286", "#689d6a", "#a89984",
+                "#928374", "#fb4934", "#b8bb26", "#fabd2f", "#83a598", "#d3869b", "#8ec07c", "#ebdbb2",
+            }),
+        new TerminalTheme("dracula",
+            "#f8f8f2", "#282a36", "#f8f8f2", 0xCC44475A, new[]
+            {
+                "#21222c", "#ff5555", "#50fa7b", "#f1fa8c", "#bd93f9", "#ff79c6", "#8be9fd", "#f8f8f2",
+                "#6272a4", "#ff6e6e", "#69ff94", "#ffffa5", "#d6acff", "#ff92df", "#a4ffff", "#ffffff",
+            }),
+        new TerminalTheme("solarized-dark",
+            "#839496", "#002b36", "#93a1a1", 0x99586E75, Solarized),
+        new TerminalTheme("solarized-light",
+            "#657b83", "#fdf6e3", "#586e75", 0x6693A1A1, Solarized),
+        new TerminalTheme("phosphor",
+            "#33ff66", "#050a05", "#33ff66", 0x5533FF66, new[]
+            {
+                "#1a2a1a", "#e06c4c", "#33ff66", "#d7ff5f", "#4cb2a0", "#a8d08d", "#66ffcc", "#b8ffc8",
+                "#3d5c3d", "#ff8566", "#66ff8c", "#e8ff8c", "#66d4bf", "#c4e8a8", "#99ffdd", "#e6ffe9",
+            }),
+    };
+
+    // Shared by the dark and light variants, as in the original scheme. Bright black is base01
+    // rather than base03 here: base03 IS the dark background, which made "bright black" text
+    // (comments, `ls` for some file types) disappear.
+    private static string[] Solarized => new[]
+    {
+        "#073642", "#dc322f", "#859900", "#b58900", "#268bd2", "#d33682", "#2aa198", "#eee8d5",
+        "#586e75", "#cb4b16", "#586e75", "#657b83", "#839496", "#6c71c4", "#93a1a1", "#fdf6e3",
+    };
+
+    /// <summary>The built-in theme with this id, or <see cref="Default"/> for an unknown one.</summary>
+    public static TerminalTheme ById(string? id) =>
+        BuiltIn.FirstOrDefault(t => string.Equals(t.Id, id, StringComparison.OrdinalIgnoreCase)) ?? Default;
+}
+
+/// <summary>How the cursor is drawn.</summary>
+public enum TerminalCursorStyle
+{
+    /// <summary>A hollow box; the character under it stays as it is.</summary>
+    Outline,
+    /// <summary>A solid box with the character drawn inverted inside it.</summary>
+    Block,
+    /// <summary>A thin vertical bar at the left edge of the cell.</summary>
+    Bar,
+    /// <summary>A line along the bottom of the cell.</summary>
+    Underline,
+}
diff --git a/tests/OpenIPC.Viewer.Core.Tests/Ssh/TerminalEmulatorTests.cs b/tests/OpenIPC.Viewer.Core.Tests/Ssh/TerminalEmulatorTests.cs
index 839fb95..7ee44ae 100644
--- a/tests/OpenIPC.Viewer.Core.Tests/Ssh/TerminalEmulatorTests.cs
+++ b/tests/OpenIPC.Viewer.Core.Tests/Ssh/TerminalEmulatorTests.cs
@@ -37,10 +37,10 @@ public void Sgr_SetsForegroundColorIndex()
     {
         var t = new TerminalEmulator(20, 5);
         t.Feed("\x1b[31mX");
-        Assert.Equal(1, t.GetRow(0)[0].Foreground); // 31 -> index 1 (red)
+        Assert.Equal(TerminalColor.FromIndex(1), t.GetRow(0)[0].Foreground); // 31 -> index 1 (red)
         // Reset returns to default.
         t.Feed("\x1b[0mY");
-        Assert.Equal(TerminalPalette.DefaultForeground, t.GetRow(0)[1].Foreground);
+        Assert.True(t.GetRow(0)[1].Foreground.IsDefault);
     }
 
     [Fact]
diff --git a/tests/OpenIPC.Viewer.Core.Tests/Ssh/TerminalFullScreenTests.cs b/tests/OpenIPC.Viewer.Core.Tests/Ssh/TerminalFullScreenTests.cs
new file mode 100644
index 0000000..84a41c4
--- /dev/null
+++ b/tests/OpenIPC.Viewer.Core.Tests/Ssh/TerminalFullScreenTests.cs
@@ -0,0 +1,232 @@
+using System.Collections.Generic;
+using System.Linq;
+using OpenIPC.Viewer.Core.Ssh.Terminal;
+using Xunit;
+
+namespace OpenIPC.Viewer.Core.Tests.Ssh;
+
+// What full-screen tools (vi, less, htop, mc) need from the terminal: the alternate screen,
+// scroll regions, line and character insert/delete, cursor-key mode, the line-drawing charset
+// and answers to status queries.
+public sealed class TerminalFullScreenTests
+{
+    private static string RowText(TerminalEmulator t, int row) =>
+        new string(t.GetRow(row).Select(c => c.Char).ToArray()).TrimEnd();
+
+    private static TerminalEmulator Lines(int cols, int rows, params string[] lines)
+    {
+        var t = new TerminalEmulator(cols, rows);
+        t.Feed(string.Join("\r\n", lines));
+        return t;
+    }
+
+    [Fact]
+    public void AlternateScreen_1049_IsBlank_AndRestoresMainScreenAndCursor()
+    {
+        var t = Lines(20, 4, "$ ls", "a b c", "$ vi");
+        Assert.Equal((2, 4), (t.CursorRow, t.CursorColumn));
+
+        t.Feed("\x1b[?1049h");
+        Assert.True(t.IsAlternateScreen);
+        Assert.All(Enumerable.Range(0, 4), r => Assert.Equal("", RowText(t, r)));
+
+        t.Feed("\x1b[1;1Hediting\x1b[3;5H");
+        t.Feed("\x1b[?1049l");
+        Assert.False(t.IsAlternateScreen);
+        Assert.Equal("$ ls", RowText(t, 0));
+        Assert.Equal("$ vi", RowText(t, 2));
+        Assert.Equal((2, 4), (t.CursorRow, t.CursorColumn));
+    }
+
+    [Fact]
+    public void AlternateScreen_HasNoHistory_AndLeavesMainHistoryAlone()
+    {
+        var t = new TerminalEmulator(10, 2);
+        t.Feed("1\r\n2\r\n3\r\n");
+        var history = t.ScrollbackRows;
+        Assert.True(history > 0);
+
+        t.Feed("\x1b[?1049h");
+        Assert.Equal(0, t.ScrollbackRows);
+        for (var i = 0; i < 20; i++)
+            t.Feed("x\r\n");
+        t.Feed("\x1b[?1049l");
+        Assert.Equal(history, t.ScrollbackRows);
+    }
+
+    [Fact]
+    public void AlternateScreen_SurvivesResize_BothScreensFollowTheNewSize()
+    {
+        var t = Lines(20, 6, "one", "two", "three");
+        t.Feed("\x1b[?1049h\x1b[6;1Hbottom");
+        t.Resize(30, 4);
+        Assert.Equal(30, t.GetRow(0).Length);
+        Assert.InRange(t.CursorRow, 0, 3);
+        t.Feed("\x1b[?1049l");
+        Assert.Equal(30, t.GetRow(0).Length);
+        Assert.Equal(4, t.Rows);
+        // The main screen shrank the usual way — from the top — so the last line is still there.
+        Assert.Equal("three", RowText(t, Enumerable.Range(0, 4).Last(r => RowText(t, r).Length > 0)));
+    }
+
+    [Fact]
+    public void ScrollRegion_LineFeedAtBottomScrollsOnlyTheRegion()
+    {
+        var t = Lines(10, 5, "head", "a", "b", "c", "status");
+        t.Feed("\x1b[2;4r");          // rows 2..4
+        t.Feed("\x1b[4;1H\nd");       // line feed at the region's bottom
+        Assert.Equal("head", RowText(t, 0));
+        Assert.Equal("b", RowText(t, 1));
+        Assert.Equal("c", RowText(t, 2));
+        Assert.Equal("d", RowText(t, 3));
+        Assert.Equal("status", RowText(t, 4));
+    }
+
+    [Fact]
+    public void ScrollRegion_InsideItDoesNotFeedHistory()
+    {
+        var t = Lines(10, 4, "a", "b", "c", "d");
+        var before = t.ScrollbackRows;
+        t.Feed("\x1b[2;4r\x1b[4;1H\n\n\n");
+        Assert.Equal(before, t.ScrollbackRows);
+    }
+
+    [Fact]
+    public void ReverseIndex_AtRegionTopScrollsDown()
+    {
+        var t = Lines(10, 4, "a", "b", "c", "d");
+        t.Feed("\x1b[1;1H\x1bMz");
+        Assert.Equal("z", RowText(t, 0));
+        Assert.Equal("a", RowText(t, 1));
+        Assert.Equal("c", RowText(t, 3));
+    }
+
+    [Fact]
+    public void InsertAndDeleteLines_WorkWithinTheRegion()
+    {
+        var t = Lines(10, 5, "0", "1", "2", "3", "4");
+        t.Feed("\x1b[1;4r\x1b[2;1H\x1b[L");
+        Assert.Equal(new[] { "0", "", "1", "2", "4" }, Enumerable.Range(0, 5).Select(r => RowText(t, r)));
+
+        t.Feed("\x1b[2M");
+        Assert.Equal(new[] { "0", "2", "", "", "4" }, Enumerable.Range(0, 5).Select(r => RowText(t, r)));
+    }
+
+    [Fact]
+    public void InsertDeleteEraseChars_EditTheRowInPlace()
+    {
+        var t = Lines(10, 2, "abcdef");
+        t.Feed("\x1b[1;3H\x1b[2@");
+        Assert.Equal("ab  cdef", RowText(t, 0));
+        t.Feed("\x1b[3P");
+        Assert.Equal("abdef", RowText(t, 0));
+        t.Feed("\x1b[1;1H\x1b[2X");
+        Assert.Equal("  def", RowText(t, 0));
+    }
+
+    [Fact]
+    public void ScrollUpDownCommands_MoveTheRegion()
+    {
+        var t = Lines(10, 3, "a", "b", "c");
+        t.Feed("\x1b[S");
+        Assert.Equal(new[] { "b", "c", "" }, Enumerable.Range(0, 3).Select(r => RowText(t, r)));
+        t.Feed("\x1b[2T");
+        Assert.Equal(new[] { "", "", "b" }, Enumerable.Range(0, 3).Select(r => RowText(t, r)));
+    }
+
+    [Fact]
+    public void OriginMode_AddressesRelativeToTheRegion()
+    {
+        var t = new TerminalEmulator(10, 6);
+        t.Feed("\x1b[3;5r\x1b[?6h\x1b[1;1HX\x1b[9;1HY");
+        Assert.Equal("X", RowText(t, 2));
+        Assert.Equal("Y", RowText(t, 4)); // clamped to the region's bottom
+    }
+
+    [Fact]
+    public void CharsetDesignation_DoesNotPrintItsFinalByte_AndDrawsBoxes()
+    {
+        var t = new TerminalEmulator(10, 2);
+        t.Feed("\x1b(0lqk\x1b(Bok");
+        Assert.Equal("┌─┐ok", RowText(t, 0));
+    }
+
+    [Fact]
+    public void ShiftOut_SelectsG1()
+    {
+        var t = new TerminalEmulator(10, 2);
+        t.Feed("\x1b)0x\x0ex\x0fx");
+        Assert.Equal("x│x", RowText(t, 0));
+    }
+
+    [Fact]
+    public void ApplicationCursorKeys_ChangeTheArrowSpelling()
+    {
+        var t = new TerminalEmulator(10, 2);
+        Assert.Equal("\x1b[A", t.CursorKey('A'));
+        t.Feed("\x1b[?1h");
+        Assert.True(t.ApplicationCursorKeys);
+        Assert.Equal("\x1bOA", t.CursorKey('A'));
+        t.Feed("\x1b[?1l");
+        Assert.Equal("\x1b[D", t.CursorKey('D'));
+    }
+
+    [Fact]
+    public void StatusQueries_AreAnswered()
+    {
+        var t = new TerminalEmulator(20, 5);
+        var replies = new List<string>();
+        t.Reply += replies.Add;
+        t.Feed("\x1b[3;7H\x1b[6n\x1b[5n\x1b[c\x1b[>c");
+        Assert.Equal(new[] { "\x1b[3;7R", "\x1b[0n", "\x1b[?1;2c" }, replies);
+    }
+
+    [Fact]
+    public void SaveRestoreCursor_Esc78_KeepsPositionAndRendition()
+    {
+        var t = new TerminalEmulator(20, 5);
+        t.Feed("\x1b[2;3H\x1b[31m\x1b" + "7\x1b[0m\x1b[5;10H\x1b" + "8X");
+        Assert.Equal('X', t.GetRow(1)[2].Char);
+        Assert.Equal(TerminalColor.FromIndex(1), t.GetRow(1)[2].Foreground);
+    }
+
+    [Fact]
+    public void AutoWrapOff_OverwritesTheLastColumn()
+    {
+        var t = new TerminalEmulator(5, 2);
+        t.Feed("\x1b[?7labcdefg");
+        Assert.Equal("abcdg", RowText(t, 0));
+        Assert.Equal("", RowText(t, 1));
+    }
+
+    [Fact]
+    public void Repeat_PrintsTheLastCharacterAgain()
+    {
+        var t = new TerminalEmulator(10, 2);
+        t.Feed("-\x1b[4b|");
+        Assert.Equal("-----|", RowText(t, 0));
+    }
+
+    [Fact]
+    public void EraseScrollback_Ed3ClearsHistory()
+    {
+        var t = new TerminalEmulator(10, 2);
+        t.Feed("1\r\n2\r\n3\r\n4");
+        Assert.True(t.ScrollbackRows > 0);
+        t.Feed("\x1b[3J");
+        Assert.Equal(0, t.ScrollbackRows);
+    }
+
+    [Fact]
+    public void FullReset_LeavesTheAlternateScreenAndModes()
+    {
+        var t = new TerminalEmulator(10, 3);
+        t.Feed("\x1b[?1049h\x1b[?1h\x1b[2;3r\x1b" + "c");
+        Assert.False(t.IsAlternateScreen);
+        Assert.False(t.ApplicationCursorKeys);
+        // A line feed at the bottom scrolls the whole screen; with the old 2..3 region left
+        // behind, row 1 would have stayed put.
+        t.Feed("\x1b[1;1Htop\x1b[3;1H\n");
+        Assert.Equal("", RowText(t, 0));
+    }
+}
diff --git a/tests/OpenIPC.Viewer.Core.Tests/Ssh/TerminalRenditionTests.cs b/tests/OpenIPC.Viewer.Core.Tests/Ssh/TerminalRenditionTests.cs
new file mode 100644
index 0000000..1bcc8cb
--- /dev/null
+++ b/tests/OpenIPC.Viewer.Core.Tests/Ssh/TerminalRenditionTests.cs
@@ -0,0 +1,178 @@
+using System;
+using System.Linq;
+using OpenIPC.Viewer.Core.Ssh.Terminal;
+using Xunit;
+
+namespace OpenIPC.Viewer.Core.Tests.Ssh;
+
+// SGR renditions beyond the 16 basic colors (256-color, truecolor, both parameter spellings),
+// the text attributes, cursor visibility, the scrollback limit, and how a theme turns a cell
+// into the colors that are actually drawn.
+public sealed class TerminalRenditionTests
+{
+    private static TerminalCell Cell(TerminalEmulator t, int col) => t.GetRow(0)[col];
+
+    [Fact]
+    public void Sgr256_KeepsTheFullIndex()
+    {
+        var t = new TerminalEmulator(20, 5);
+        t.Feed("\x1b[38;5;196mA\x1b[48;5;21mB");
+        Assert.Equal(TerminalColor.FromIndex(196), Cell(t, 0).Foreground);
+        Assert.Equal(TerminalColor.FromIndex(21), Cell(t, 1).Background);
+    }
+
+    [Fact]
+    public void SgrTruecolor_SemicolonSpelling()
+    {
+        var t = new TerminalEmulator(20, 5);
+        t.Feed("\x1b[38;2;10;20;30;48;2;200;100;50mX");
+        Assert.Equal(TerminalColor.FromRgb(10, 20, 30), Cell(t, 0).Foreground);
+        Assert.Equal(TerminalColor.FromRgb(200, 100, 50), Cell(t, 0).Background);
+    }
+
+    [Fact]
+    public void SgrTruecolor_ColonSpelling_WithAndWithoutColorSpace()
+    {
+        var t = new TerminalEmulator(20, 5);
+        t.Feed("\x1b[38:2::1:2:3mA\x1b[38:2:4:5:6mB\x1b[38:5:100mC");
+        Assert.Equal(TerminalColor.FromRgb(1, 2, 3), Cell(t, 0).Foreground);
+        Assert.Equal(TerminalColor.FromRgb(4, 5, 6), Cell(t, 1).Foreground);
+        Assert.Equal(TerminalColor.FromIndex(100), Cell(t, 2).Foreground);
+    }
+
+    [Fact]
+    public void SgrColonColor_DoesNotLeakIntoFollowingParameters()
+    {
+        // With ':' folded into ';' the trailing blue component (4) used to read as "underline".
+        var t = new TerminalEmulator(20, 5);
+        t.Feed("\x1b[38:2::1:2:4mX");
+        Assert.Equal(TerminalAttributes.None, Cell(t, 0).Attributes);
+    }
+
+    [Fact]
+    public void SgrTruncatedExtendedColor_LeavesColorAlone()
+    {
+        var t = new TerminalEmulator(20, 5);
+        t.Feed("\x1b[32m\x1b[38;5mX\x1b[48;2;1mY");
+        Assert.Equal(TerminalColor.FromIndex(2), Cell(t, 0).Foreground);
+        Assert.True(Cell(t, 1).Background.IsDefault);
+    }
+
+    [Fact]
+    public void SgrAttributes_SetAndClearIndividually()
+    {
+        var t = new TerminalEmulator(30, 5);
+        t.Feed("\x1b[1;2;3;4;7;8;9mA");
+        Assert.Equal(
+            TerminalAttributes.Bold | TerminalAttributes.Dim | TerminalAttributes.Italic |
+            TerminalAttributes.Underline | TerminalAttributes.Inverse | TerminalAttributes.Hidden |
+            TerminalAttributes.Strikethrough,
+            Cell(t, 0).Attributes);
+
+        t.Feed("\x1b[22;23;24;27;28;29mB");
+        Assert.Equal(TerminalAttributes.None, Cell(t, 1).Attributes);
+
+        t.Feed("\x1b[4m\x1b[4:0mC\x1b[4:3mD");
+        Assert.Equal(TerminalAttributes.None, Cell(t, 2).Attributes);
+        Assert.Equal(TerminalAttributes.Underline, Cell(t, 3).Attributes);
+    }
+
+    [Fact]
+    public void SgrReset_ClearsAttributesAndColors()
+    {
+        var t = new TerminalEmulator(20, 5);
+        t.Feed("\x1b[1;7;31;44mA\x1b[mB");
+        Assert.Equal(TerminalCell.Blank with { Char = 'B' }, Cell(t, 1));
+    }
+
+    [Fact]
+    public void CursorVisibility_FollowsPrivateMode25()
+    {
+        var t = new TerminalEmulator(20, 5);
+        Assert.True(t.CursorVisible);
+        t.Feed("\x1b[?25l");
+        Assert.False(t.CursorVisible);
+        t.Feed("\x1b[?25h");
+        Assert.True(t.CursorVisible);
+        t.Feed("\x1b[?25l\x1b" + "c");
+        Assert.True(t.CursorVisible);
+    }
+
+    [Fact]
+    public void Scrollback_IsCappedAtTheLimit_AndShrinksWithIt()
+    {
+        var t = new TerminalEmulator(10, 2, scrollbackLimit: 150);
+        for (var i = 0; i < 300; i++)
+            t.Feed($"{i}\r\n");
+        Assert.Equal(150, t.ScrollbackRows);
+
+        t.ScrollbackLimit = 120;
+        Assert.Equal(120, t.ScrollbackRows);
+        // The newest rows are the ones kept.
+        Assert.Equal('2', t.GetScrollbackRow(t.ScrollbackRows - 1)[0].Char);
+    }
+
+    [Fact]
+    public void ScrollbackLimit_IsClamped()
+    {
+        Assert.Equal(TerminalEmulator.MinScrollbackLimit, new TerminalEmulator(10, 2, 1).ScrollbackLimit);
+        Assert.Equal(TerminalEmulator.MaxScrollbackLimit, new TerminalEmulator(10, 2, int.MaxValue).ScrollbackLimit);
+    }
+
+    [Theory]
+    [InlineData(16, 0x000000u)]
+    [InlineData(196, 0xFF0000u)]
+    [InlineData(21, 0x0000FFu)]
+    [InlineData(231, 0xFFFFFFu)]
+    [InlineData(232, 0x080808u)]
+    [InlineData(244, 0x808080u)]
+    [InlineData(255, 0xEEEEEEu)]
+    public void Xterm256_MatchesTheStandardPalette(int index, uint rgb) =>
+        Assert.Equal(rgb, TerminalPalette.Xterm256(index));
+
+    [Fact]
+    public void Theme_ResolvesEachKindOfColor()
+    {
+        var theme = TerminalTheme.Default;
+        Assert.Equal(0x123456u, theme.Resolve(TerminalColor.Default, 0x123456));
+        Assert.Equal(theme.Ansi[9], theme.Resolve(TerminalColor.FromIndex(9), 0));
+        Assert.Equal(0xFF0000u, theme.Resolve(TerminalColor.FromIndex(196), 0));
+        Assert.Equal(0x0A141Eu, theme.Resolve(TerminalColor.FromRgb(10, 20, 30), 0));
+    }
+
+    [Fact]
+    public void Theme_InverseSwapsResolvedColors_EvenForDefaults()
+    {
+        var theme = TerminalTheme.Default;
+        var cell = TerminalCell.Blank with { Char = 'x', Attributes = TerminalAttributes.Inverse };
+        Assert.Equal((theme.Background, theme.Foreground), theme.ColorsOf(cell));
+    }
+
+    [Fact]
+    public void Theme_DimBlendsTowardsBackground_HiddenMatchesIt()
+    {
+        var theme = TerminalTheme.Default;
+        var red = TerminalColor.FromRgb(200, 0, 0);
+        var black = TerminalColor.FromRgb(0, 0, 0);
+
+        var dim = new TerminalCell('x', red, black, TerminalAttributes.Dim);
+        Assert.Equal(0x640000u, theme.ColorsOf(dim).Foreground);
+
+        var hidden = new TerminalCell('x', red, black, TerminalAttributes.Hidden);
+        Assert.Equal(0x000000u, theme.ColorsOf(hidden).Foreground);
+    }
+
+    [Fact]
+    public void Themes_AreCompleteAndFoundById()
+    {
+        Assert.All(TerminalTheme.BuiltIn, t => Assert.Equal(16, t.Ansi.Count));
+        Assert.Equal(TerminalTheme.BuiltIn.Count, TerminalTheme.BuiltIn.Select(t => t.Id).Distinct().Count());
+        Assert.Same(TerminalTheme.BuiltIn[2], TerminalTheme.ById(TerminalTheme.BuiltIn[2].Id.ToUpperInvariant()));
+        Assert.Same(TerminalTheme.Default, TerminalTheme.ById("no-such-theme"));
+        Assert.Same(TerminalTheme.Default, TerminalTheme.ById(null));
+    }
+
+    [Fact]
+    public void Xterm256_RejectsThemeIndices() =>
+        Assert.Throws<ArgumentOutOfRangeException>(() => TerminalPalette.Xterm256(15));
+}