diff --git a/AGENTS.md b/AGENTS.md
index a2f33c8..730934a 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -22,8 +22,8 @@ The renderer and test projects target `net8.0` and `net10.0`; both runtimes are
 - `DisplayList` is the backend-agnostic, flat command model. Scoped effects are push/pop pairs (`PushClip`, `PushTransform`, `PushOpacity`, `PushFilter`, ...) that the backend maps to `Save`/`SaveLayer`/`Restore`. `InsertRange` and `MoveRangeToEnd` exist to reorder already-emitted commands.
 - `SkiaRenderBackend` rasterizes the display list and implements `ITextMeasurer`, so layout measures with the very typefaces it paints with.
 - `ITextMeasurer` is the seam between layout and rasterization (line breaking, alignment, table widths). Never reintroduce a font-independent width heuristic - it silently decouples layout from what is drawn.
-- `SkiaTextShaping` is the single font-resolution path for both measuring and painting (and SVG text). Text is drawn glyph by glyph with `canvas.DrawText` - no HarfBuzz shaping (no Arabic joining, ligatures or `font-feature-settings`).
-- `BidiAlgorithm` (UAX #9: levels, `unicode-bidi` embeddings/overrides/isolates, mirroring) and `WebFontDecoder` (WOFF via zlib, WOFF2 via Brotli plus the `glyf`/`loca`/`hmtx` transforms, back to plain sfnt) are self-contained internal helpers.
+- `SkiaTextShaping` is the single font-resolution and shaping path for measuring, painting and SVG text. `ShapeText` splits text into fallback-typeface runs and script runs, shapes each with HarfBuzz (HarfBuzzSharp; one cached `hb_font` per `SKTypeface`, positions in font units scaled by the font size), and painting draws the very same glyphs and positions as `SKTextBlob`s, so measuring and painting cannot disagree. Text reaches it in logical order: `RenderFont.IsRightToLeft` is the bidi run direction, HarfBuzz reverses and mirrors. A right-to-left script is always shaped right to left (strong RTL characters always end up at odd levels), because layout measures words before resolving levels and HarfBuzz shapes Arabic differently when forced left to right. `RenderFont.FontFeatures` carries HarfBuzz feature strings; letter spacing goes after each cluster and turns optional ligatures off. `RenderFont.Language` (from `lang`/`xml:lang`, element semantics, carried in the style map under `lang` and inherited through `RenderTextStyle.Language`) selects `locl` forms; without one the buffer language is fixed (`und`) so results do not depend on the host locale. `RenderFont.ContextBefore`/`ContextAfter` are neighbouring characters shaped elsewhere (`ApplyShapingContext` sets them where IFC text pieces meet across an inline box edge), handed to HarfBuzz as pre/post context so Arabic joins across elements; they are part of the measure cache key. Callers without a layout (SVG text, Canvas 2D `fillText`) use `MeasureParagraph`/`DrawParagraph`, which split a line into bidi runs (`BidiAlgorithm.GetVisualRuns`, shared with the paragraph path) first.
+- `BidiAlgorithm` (UAX #9: levels, `unicode-bidi` embeddings/overrides/isolates; mirroring is left to shaping) and `WebFontDecoder` (WOFF via zlib, WOFF2 via Brotli plus the `glyf`/`loca`/`hmtx` transforms, back to plain sfnt) are self-contained internal helpers.
 - `HtmlRenderOptions` holds viewport and text defaults.
 - `SvgRasterizer` (`Skia/Svg/`) paints SVG by walking the DOM AngleSharp already produced - no second SVG parser. Its PNG output becomes an ordinary `RenderedImage`.
 - `InteractiveHtmlRendererState` / `IDomHarness` back interactive documents (`:hover`, scrolling, focus, a virtual clock for transitions/animations/caret).
@@ -32,12 +32,12 @@ The renderer and test projects target `net8.0` and `net10.0`; both runtimes are
 
 `SkiaTextShaping.CreateTypeface` walks the `font-family` list in order; the first usable entry wins:
 
-1. Generic families (`serif`, `sans-serif`, `monospace`, `cursive`, `fantasy`, `system-ui`, `ui-*`) always map to the bundled fonts in `Resources/Fonts`. This is what keeps snapshots reproducible; `@font-face` cannot take them over.
+1. Generic families (`serif`, `sans-serif`, `monospace`, `cursive`, `fantasy`, `system-ui`, `ui-*`) always map to the bundled DejaVu fonts in `Resources/Fonts`. This is what keeps snapshots reproducible; `@font-face` cannot take them over.
 2. `@font-face` rules (`FontFaceLoader`, carried on `DisplayList.Fonts`). `local()` resolves against installed fonts; `url()` against `data:` URIs, or the network only when the browsing context has an `IDocumentLoader`. WOFF/WOFF2 are decoded to sfnt by `WebFontDecoder` first; SVG and EOT fonts are rejected.
 3. Installed families - host-dependent, never assert them in snapshots.
 4. Bundled sans-serif as the last resort.
 
-A character the resolved typeface has no glyph for falls back per character (`SplitFallbackRuns`, shared by measuring and painting): the next `font-family` entry that has it, then the bundled fonts, then `SKFontManager.MatchCharacter` (host-dependent, so never in snapshots). Text the typeface fully covers stays one run.
+A character the resolved typeface has no glyph for falls back per character (`SplitFallbackRuns`, shared by measuring and painting): the next `font-family` entry that has it, then the bundled fonts (DejaVu, then Noto Sans Devanagari, which is fallback-only and never a generic family; its OFL license ships in the package), then `SKFontManager.MatchCharacter` (host-dependent, so never in snapshots). Text the typeface fully covers stays one run.
 
 Never resolve named families with `SKTypeface.FromFamilyName`: it substitutes the host default for unknown names instead of returning null, swallowing the rest of the fallback list. Availability goes through a case-insensitive index of installed families (Skia's lookup is case-sensitive on Linux only).
 
@@ -47,7 +47,7 @@ Never resolve named families with `SKTypeface.FromFamilyName`: it substitutes th
 
 **Styling comes only from the computed style** (the render tree, cascaded with the UA stylesheet), never from tag names: no "`<b>` is bold", "`h1` is 700", "`<span>` is inline", "`<script>` is hidden". An unset `display` is its initial value, `inline`. Tag names are only legitimate for element semantics that CSS does not express (replaced-element content, form-control values, `<select>` options, `ol`/`li` ordinals). When the UA sheet lacks a rule, file it upstream as a failing test.
 
-Upstream status: everything filed so far is fixed as of 1.2.1; no failing upstream tests are open.
+Upstream status: `font-variant-east-asian` was unparsed; fixed with tests in the sibling AngleSharp.Css checkout (unreleased 1.3.1, not committed there yet). `TextShapingTests.FontVariantEastAsian_SelectsOpenTypeFeatures` is skipped until `AngleSharpCssVersion` can be raised to it.
 
 ## Core Layout Invariants
 
@@ -72,8 +72,8 @@ Only the non-obvious parts; see XML doc remarks in `HtmlRenderer.cs` for detail.
 
 ### Box model, positioning, painting
 - Floats, `inline-block`, relative/absolute/fixed/sticky positioning, z-index ordering (CSS 2.1 Appendix E: a stacking context's own background paints before its negative-z descendants).
-- `position: sticky` (`HtmlRenderer.Sticky.cs`): a sticky box is laid out at its natural position and registered (`LayoutStickyAwareElement`, wrapping every `LayoutElement` call) with the scope of the container laying out its parent; every container (block, flex, grid, table, page) calls `ResolveStickyBoxes` once its content box is known (after its own box-paint `InsertRange`). That shifts the box by `top`/`bottom`/`left`/`right` against the viewport (layout already runs in scrolled coordinates; `top` beats `bottom`, `left` beats `right`), keeps its margin box inside the container's content box, moves its commands to the end of the container's children under a `PushTransform` translation, and re-records its own metrics. Ranges are found again by the identity of their first command; registrations made against a scratch list (trial layouts, multi-column) are ignored, so such sticky boxes stay static. The viewport is the only scrollport. Below-the-fold culling (`maxY`) is skipped while a `bottom`-sticky box follows.
-- Floats: each block formatting context owns a `FloatArea` (placed float margin boxes, absolute coordinates) that is passed down instead of the old offset/bottom pair. Ordinary blocks share their parent's area, so their *box* ignores floats while their lines (`GetBand` per line in the IFC; a bare-text run beside floats goes through the IFC too) wrap around them; boxes that establish a new context (`EstablishesBlockFormattingContext`: floats, positioned boxes, atomics, flex items, `overflow` other than `visible`, `flow-root`, flex/grid/table) get a fresh area, sit beside outer floats as a whole, never collapse margins with children, and grow to contain their own floats. `FloatArea.Place` puts a float as high as possible on its side, never above an earlier float, moving down when it does not fit. Floats and atomics keep their authored margins (no over-constrained margin absorption). `clear: left|right|both` uses `GetClearance`. Not modeled: lines moving down when even their first word does not fit beside a float.
+- `position: sticky` (`HtmlRenderer.Sticky.cs`): a sticky box is laid out at its natural position and registered (`LayoutStickyAwareElement`, wrapping every `LayoutElement` call) with the scope of the container laying out its parent; every container (block, flex, grid, table, page) calls `ResolveStickyBoxes` once its content box is known (after its own box-paint `InsertRange`). That shifts the box by `top`/`bottom`/`left`/`right` against the viewport (layout already runs in scrolled coordinates; `top` beats `bottom`, `left` beats `right`), keeps its margin box inside the container's content box, moves its commands to the end of the container's children under a `PushTransform` translation, and re-records its own metrics. Ranges are found again by the identity of their first command; registrations made against a scratch list (trial layouts, multi-column) are ignored, so such sticky boxes stay static. Inside a writing-mode system the viewport is only known once the system is placed: `ResolveStickyBoxes` moves the range and wraps it in a placeholder `PushTransformCommand` registered with the innermost `LayoutContext.StickyFlows` list, and `ResolveFlowStickyBoxes` (called once the flow transform is known) hands the boxes up to the enclosing system with the composed transform, or sticks them against the viewport mapped into their own coordinates (where their remapped logical insets apply) and replaces the placeholder (`DisplayList.ReplaceCommand`). Trial layouts push an empty list there, so their sticky boxes are never placed. The viewport is the only scrollport. Below-the-fold culling (`maxY`) is skipped while a `bottom`-sticky box follows.
+- Floats: each block formatting context owns a `FloatArea` (placed float margin boxes, absolute coordinates) that is passed down instead of the old offset/bottom pair. Ordinary blocks share their parent's area, so their *box* ignores floats while their lines (`GetBand` per line in the IFC; a bare-text run beside floats goes through the IFC too) wrap around them; boxes that establish a new context (`EstablishesBlockFormattingContext`: floats, positioned boxes, atomics, flex items, `overflow` other than `visible`, `flow-root`, flex/grid/table) get a fresh area, sit beside outer floats as a whole, never collapse margins with children, and grow to contain their own floats. `FloatArea.Place` puts a float as high as possible on its side, never above an earlier float, moving down when it does not fit. Floats and atomics keep their authored margins (no over-constrained margin absorption). `clear: left|right|both` uses `GetClearance`. A line whose first unbreakable unit (`MeasureFirstLineUnit`) does not fit beside the floats moves down to the next float bottom (`NextBottomBelow`) until it fits or the band is the full width; this only runs when floats narrow the band.
 - `min-width`/`max-width` clamp block widths (a clamped width centers with `margin: auto`). Replaced elements without a size use their natural size.
 - On a box, `vertical-align` positions the box in its line only; it is reset for the box's own contents.
 - `visibility: hidden` (and `collapse` outside tables) is a paint concern only: never use AngleSharp.Css's `IsVisible()` for layout (it rejects hidden boxes); use `GeneratesBoxes` (`display: none`). The inherited flag `RenderTextStyle.IsHidden` suppresses text (`DrawStyledText`), inline fragments, markers, form controls, images, column rules and, through `decorationBuffer`, a box's own decorations, while its scopes stay so visible descendants still paint.
@@ -99,20 +99,21 @@ Only the non-obvious parts; see XML doc remarks in `HtmlRenderer.cs` for detail.
 - `aspect-ratio` derives width from a definite height; `object-fit`/`object-position` apply to replaced elements.
 
 ### Text
-Every text feature exists twice - in the paragraph path (whole lines as strings) and in the inline formatting context (pieces) - so change both. `MeasureTextWidth` and `DrawStyledText` are the only measure/paint entry points: they drop soft hyphens, synthesize small caps (lowercase as uppercase at `SmallCapsScale` 0.7, run by run) and paint `text-shadow` first, so every path (cells, markers, form labels) agrees.
+Every text feature exists twice - in the paragraph path (whole lines as strings) and in the inline formatting context (pieces) - so change both. `MeasureTextWidth` and `DrawStyledText` are the only measure/paint entry points: they drop soft hyphens, synthesize small caps (lowercase as uppercase at `SmallCapsScale` 0.7, run by run) and paint `text-shadow` first, so every path (cells, markers, form labels) agrees. Words are measured one by one but painted as runs, so kerning across a space can shift a run by a fraction of a pixel.
+- Font features: `font-feature-settings`, `font-kerning`, `font-variant-ligatures`/`-numeric`/`-east-asian` (all inherited, tracked per property in `FontFeatureProperties`) become `RenderTextStyle.FontFeatures` (`ResolveFontFeatures`, CSS Fonts 4 §7.2 order, `font-feature-settings` last so it wins). `font-variant-east-asian` needs AngleSharp.Css 1.3.1 (see Upstream status).
 - `white-space`: `NormalizeWhitespace(text, mode)` implements the collapse/preserve table for the paragraph path; the IFC applies the same rules per piece (`\n` as forced breaks, `nowrap`/`pre` without soft wraps). Preserved tabs reach the next `tab-size` stop: an exact-width `IsTab` space piece in the IFC (runs split around it), expanded to whole spaces in the paragraph path (`ExpandTabs`).
 - `text-align: justify` widens the line's untrimmed spaces (runs are then painted word by word); the last line and lines ended by a forced break use `text-align-last` (`ResolveLineAlign`), defaulting to start. Bidi-reordered paragraph lines are not justified.
 - `hyphens`: soft hyphens (U+00AD) are break opportunities (`auto` = `manual`, no dictionary); a line broken there shows `-`. The IFC splits words into syllable pieces carrying `HyphenWidth`; `BuildLine` only takes a syllable when its hyphen fits too or the rest of the word fits.
-- `text-overflow: ellipsis` (not inherited; only when overflow clips) and `-webkit-line-clamp`: the paragraph path truncates a single line by rune; the IFC truncates every overflowing line (`TruncateLineWithEllipsis`, by grapheme, keeping box edges) and stops after the clamped line, adding `…` when content remains.
+- `text-overflow: ellipsis` (not inherited; only when overflow clips) and `-webkit-line-clamp`: the paragraph path truncates a single line by glyph cluster; the IFC truncates every overflowing line (`TruncateLineWithEllipsis`, by glyph cluster from `ITextMeasurer.GetClusterBoundaries` - graphemes for measurers that do not implement it - keeping box edges) and stops after the clamped line, adding `…` when content remains. The clamped box pushes a `LineClampScope` (`LayoutContext.LineClampScopes`) around its content: every line of the IFC and the paragraph path inside it, in nested blocks too, uses one up; `LayoutNode` lays out nothing once none is left (so the box ends after the last line), and the last line gets `…` when anything rendered follows it in the box (`HasRenderedContentAfter`). Trial layouts work on a copy of the scope.
 - `word-break: break-all` wraps per character; `overflow-wrap`/`word-wrap: break-word`/`anywhere` split a word only when it cannot fit even an empty line. `keep-all` = `normal`.
 - `text-transform` (inherited; `capitalize` tracks word starts across inline elements) and `word-spacing` (paints word by word, since a text run cannot express it). Runs drop their edge spaces unless decorated.
 - `font-weight: bolder`/`lighter` (the UA rule for `b`, `strong`, `th`, headings) resolve against the inherited weight.
 - `font-stretch` travels as a percentage on `RenderFont`/`DrawTextCommand` and selects an installed or `@font-face` width class; the bundled fonts have one width and nothing is synthesized.
-- Bidi: the IFC builds the line text (atomics as U+FFFC, box edges as `unicode-bidi` controls or U+2060), runs `BidiAlgorithm` and splits pieces into visual fragments (`ReorderLine`); the paragraph path paints reordered lines as visual runs (`GetVisualRuns`). `direction` also resolves `start`/`end`.
+- Bidi: the IFC builds the line text (atomics as U+FFFC, box edges as `unicode-bidi` controls or U+2060), runs `BidiAlgorithm` and splits pieces into visual fragments (`ReorderLine`); the paragraph path paints reordered lines as visual runs (`GetVisualRuns`). Fragments and runs keep their text in logical order and set `RenderTextStyle.IsRightToLeftRun` at odd levels; the IFC only merges pieces of one direction into a run and concatenates right-to-left pieces in reverse (logical) order. Display-list tests therefore see logical text plus `DrawTextCommand.IsRightToLeft`; glyph order and mirroring are tested in `TextShapingTests`. `direction` also resolves `start`/`end`.
 - `text-decoration` (line/color/style), `letter-spacing`, `text-indent` (inherited; an inside list marker's space is the separate, non-inherited `MarkerIndent`), `vertical-align` shifts as fixed font-size fractions.
 
 ### Writing modes
-`HtmlRenderer.WritingModes.cs`. Layout always runs horizontally in the logical coordinates of a *system* (x = inline, y = block). `ResolveWritingModeSystems` walks the render tree once per render and records the system every element's box sits in (`LayoutContext.BoxSystems`, also covering pseudo-elements, which have no parent in the DOM) and the system of its content (`ContentSystems`). A box in a vertical system gets its style map remapped to logical properties when it is built (`RemapStyleMapToLogical`: width↔height, min/max, margin/padding/border sides, insets, corner radii with swapped axes, overflow axes). An element whose writing mode is orthogonal to its box's system (or `<body>`'s content, for the page) is an orthogonal flow: its content is laid out at the origin with `RenderTextStyle.FlowMode` set to its own mode, inline size = its logical height or shrink-to-fit against the viewport, and wrapped in `ResolveOrthogonalFlowTransform` (box system⁻¹ · own mode, translated onto the content box); an auto width is the content's block size, and intrinsic sizing reports that block size (`MeasureOrthogonalBlockSize`). Orthogonal flows always establish a formatting context. Text in a vertical system turns with the system; `MeasureTextWidth`/`DrawStyledText` give upright glyphs (`text-orientation: upright`, or CJK etc. under `mixed`) one em each and counter-rotate them, and `vertical-lr` (a reflection) flips its sideways runs back about their glyph-box centre. Limitations: only orthogonal changes start a system (a `vertical-lr` element inside `vertical-rl` content keeps the outer direction); block containers only (flex/grid/table containers do not become orthogonal flows); backgrounds, gradients and shadows inside vertical content rotate with it; metrics of descendants are recorded in their flow's logical coordinates; sticky boxes inside an orthogonal flow stay static; no `text-combine-upright` and no decorations on upright glyphs.
+`HtmlRenderer.WritingModes.cs`. Layout always runs horizontally in the logical coordinates of a *system* (x = inline, y = block). `ResolveWritingModeSystems` walks the render tree once per render and records the system every element's box sits in (`LayoutContext.BoxSystems`, also covering pseudo-elements, which have no parent in the DOM) and the system of its content (`ContentSystems`). A box in a vertical system gets its style map remapped to logical properties when it is built (`RemapStyleMapToLogical`: width↔height, min/max, margin/padding/border sides, insets, corner radii with swapped axes, overflow axes). An element whose writing mode maps onto other physical axes than its box's system (`StartsWritingModeSystem`; or `<body>`'s content, for the page) starts a system: its content is laid out at the origin with `RenderTextStyle.FlowMode` set to its own mode and wrapped in `ResolveFlowTransform` (box system⁻¹ · own mode, translated onto the content box). An orthogonal flow has inline size = its logical height or shrink-to-fit against the viewport; an auto width is the content's block size, and intrinsic sizing reports that block size (`MeasureOrthogonalBlockSize`). A parallel flow (`vertical-lr` in `vertical-rl` or the reverse) keeps the box's width as inline size and is flipped along the block axis once its height is known. Such flows always establish a formatting context. A flex, grid or table container that starts a system is laid out as a block in the enclosing system (its box: margins, border, padding, background, positioning), whose content is the container laid out again at the origin of its own system (`LayoutContainerInOwnSystem`): its style map is temporarily replaced in `StyleMapCache` by one remapped to its own system, without the box's properties, sized to the flow's inline (and definite block) size, so its main/cross axes or rows/columns follow its own writing mode. Text in a vertical system turns with the system; `MeasureTextWidth`/`DrawStyledText` give upright glyphs (`text-orientation: upright`, or CJK etc. under `mixed`) one em each and counter-rotate them, and `vertical-lr` (a reflection) flips its sideways runs back about their glyph-box centre. Limitations: backgrounds, gradients and shadows inside vertical content rotate with it; metrics of descendants are recorded in their flow's logical coordinates; no `text-combine-upright` and no decorations on upright glyphs.
 
 ### Lists, counters, generated content
 - `display: list-item` uses normal block flow; `PaintListItemMarker` paints shape markers via the `border-radius` machinery and text markers via `DrawText`. Outside markers sit a fixed 6px left of the item's border box, inside the list's `padding-left` (40px from the UA sheet). Inside markers add the separate `MarkerIndent` to the first line.
@@ -122,13 +123,13 @@ Every text feature exists twice - in the paragraph path (whole lines as strings)
 ### Flexbox and Grid
 - Flexbox with grow/shrink/basis/wrap/alignment/order. Only the longhands (`flex-grow`/`-shrink`/`-basis`) are read, never the serialized `flex` shorthand. A definite `flex-basis` is used as-is; content is measured only for `auto` basis and size. `ResolveFlexibleLengths` is the spec's "resolve flexible lengths": hypothetical sizes clamped by min/max, the automatic minimum (`min-width: auto` = min-content, not for scroll containers), shrink weighted by inner base size, and freezing on min/max violations. Item heights (and column items' content size) come from a cached trial layout (`MeasureBorderBoxHeight`, `LayoutContext.MeasuredHeights`).
 - Gaps (`ResolveColumnGap`/`ResolveRowGap`): `column-gap` percentages resolve against the content width, `row-gap` ones against a definite height, else zero.
-- Grid: `GridParser` structural parsing; `fr`, `repeat()` (including auto-fill/auto-fit fill counts), `minmax()`, `grid-template-areas`, `grid-area`, `grid-auto-flow`, `grid-auto-rows`. `CssRepeatValue`/`CssFitContentValue` are internal upstream, so they are matched via `ICssFunctionValue.Name`. Sizing is two-pass: placement is resolved once in pass 1 (and reused, to keep the auto-placement cursor consistent) while `Auto` tracks grow; `fr` space is distributed between passes; without a definite height, `fr` rows get the flex fraction their items need (`ResolveIndefiniteGridFractionTracks`). An authored container height is the height (content overflows). Line names come from `[name]` in the track lists and `area-start`/`area-end` of `grid-template-areas` (`GridLines`); `ParseGridLinePlacement` reads numbers, negative numbers, names (with index) and `span` on either side. Content-sized columns (`auto`, `min-content`, `max-content`, `fit-content()`, `minmax()` with a non-`fr` maximum) are sized by `ResolveIntrinsicGridColumns` from the items' min/max-content contributions (`ComputeOuterIntrinsicWidths`): base size and growth limit per track, spanning items spread their excess, free space grows tracks to their limits and then stretches `auto` tracks unless `justify-content` packs them (track alignment itself - `center`, `space-between`, ... - is not implemented). Auto rows take authored item heights up front and measured content heights between the passes. `justify-self`/`align-self` (falling back to `justify-items`/`align-items`) place an item start/center/end/stretch; a non-stretched item is shrink-to-fit wide or content tall.
+- Grid: `GridParser` structural parsing; `fr`, `repeat()` (including auto-fill/auto-fit fill counts), `minmax()`, `grid-template-areas`, `grid-area`, `grid-auto-flow`, `grid-auto-rows`. `CssRepeatValue`/`CssFitContentValue` are internal upstream, so they are matched via `ICssFunctionValue.Name`. Sizing is two-pass: placement is resolved once in pass 1 (and reused, to keep the auto-placement cursor consistent) while `Auto` tracks grow; `fr` space is distributed between passes; without a definite height, `fr` rows get the flex fraction their items need (`ResolveIndefiniteGridFractionTracks`). An authored container height is the height (content overflows). Line names come from `[name]` in the track lists and `area-start`/`area-end` of `grid-template-areas` (`GridLines`); `ParseGridLinePlacement` reads numbers, negative numbers, names (with index) and `span` on either side. Content-sized columns (`auto`, `min-content`, `max-content`, `fit-content()`, `minmax()` with a non-`fr` maximum) are sized by `ResolveIntrinsicGridColumns` from the items' min/max-content contributions (`ComputeOuterIntrinsicWidths`): base size and growth limit per track, spanning items spread their excess, free space grows tracks to their limits and then stretches `auto` tracks unless `justify-content` packs them. `justify-content`/`align-content` then place the tracks within a definite content box (`ResolveGridContentAlignment`: an offset of the first track plus spacing added to every gap; overflowing tracks shift for `center`/`end` unless `safe`, distributed values fall back to `start`/`center`). Auto rows take authored item heights up front and measured content heights between the passes. `justify-self`/`align-self` (falling back to `justify-items`/`align-items`) place an item start/center/end/stretch; a non-stretched item is shrink-to-fit wide or content tall.
 
 ### Multi-column
-`column-count`/`column-width`/`column-gap` (`normal` = 1em)/`column-rule` on block containers. Content is laid out once at the column width into a scratch list while recording line/block bottoms (`RecordColumnBreakCandidate`) and line tops (`RecordColumnContentStart`); the smallest column height that fits into the column count without splitting a line is chosen, and each column replays the scratch list under a clip plus translate (margins at a break are truncated). An authored height fills columns sequentially. No `column-span`, `break-*` or `column-fill`.
+`column-count`/`column-width`/`column-gap` (`normal` = 1em)/`column-rule` on block containers. Direct children with `column-span: all` split the content into column sets, each balanced on its own, with the spanner laid out full-width between them (spanners deeper in the tree are not recognized). Each set is laid out once at the column width into a scratch list while `ColumnBreakCapture` records block bottoms (`RecordColumnBreakCandidate`), line boxes (`RecordColumnLine`, per paragraph = one `FlushRun`, for `orphans`/`widows`), and per block child `break-before`/`-after`/`-inside` and replaced boxes (`RecordColumnBlockBreaks`, read from the computed style only while a capture is active). `CollectColumnBreaks` classifies the candidates as allowed, avoid (taken only when nothing allowed fits) or forced; the smallest column height that fits into the column count is chosen, and each column replays the scratch list under a clip plus translate (margins at a break are truncated). When no break fits, the block is cut at the column end (or above a line/replaced box that would be cut). With a definite height `column-fill: auto` fills columns sequentially, `balance` (initial) balances within it. `TrialLayout` suspends the capture. Paged media (`@page`) is out of scope but would reuse this.
 
 ### Tables
-`HtmlRenderer.Tables.cs`. Structure comes from computed `display` (header-group rows first, footer-group rows last); only `colspan`/`rowspan`/`span` are attributes. `GetTableStructure` runs once per render (`LayoutContext.TableStructures`) because the collapsing border model rewrites style maps: each grid line takes the widest border meeting there (`hidden` suppresses it), cells and the table keep half of each line as a transparent border for layout, and `PaintCollapsedBorders` paints the lines (solid only) over the cells; a collapsed table has no padding. Column widths: automatic layout (per-column min/max-content, spanning cells spread their excess by max-content, the table shrink-to-fit unless it has a width) or `table-layout: fixed`. Cells go through `LayoutNode` with `forcedBorderBoxWidth`/`forcedBorderBoxHeight` (stretched to their rows) and `contentOffsetY` for `vertical-align`; `baseline` cells share the row's first baseline (`TrialLayout`'s `FirstBaselineY`). Column-group/column/row-group/row backgrounds paint per cell. `visibility: collapse` on rows/columns (and their groups) removes them and their spacing after the column widths are computed; cells living only there are not laid out. `empty-cells: hide` skips an empty cell's box and the part backgrounds behind it (separated model only). Percentage row and cell heights refer to the table's definite height, else count for nothing; cell percentages are moved out of the cell's style map (`TableCellInfo.PercentHeight`) so `LayoutElement` never resolves them against a width. Tables get no transform/opacity/filter scopes. Not implemented: anonymous table objects (stray cells and text are dropped), percentage table heights.
+`HtmlRenderer.Tables.cs`. Structure comes from computed `display` (header-group rows first, footer-group rows last); only `colspan`/`rowspan`/`span` are attributes. Anonymous table objects (CSS 2.1 §17.2.1) are built into the render tree right after `window.Render` (`BuildAnonymousTableBoxes`), so everything downstream (style maps, writing modes, intrinsic sizes, inline collection) sees well-formed tables: an anonymous box is a detached `div` whose computed style is `display` plus the parent's inherited properties (`CanBeInherited`), so the rest is initial; it is its own specified style (no cascade reaches it) and hit testing skips it (`s_anonymousTableBoxes`). Moved children keep their original `Parent`. White space between table parts is dropped; whitespace and `display: none` never start a run. `GetTableStructure` runs once per render (`LayoutContext.TableStructures`) because the collapsing border model rewrites style maps: each grid line takes the widest border meeting there (`hidden` suppresses it), cells and the table keep half of each line as a transparent border for layout, and `PaintCollapsedBorders` paints the lines (solid only) over the cells; a collapsed table has no padding. Column widths: automatic layout (per-column min/max-content, spanning cells spread their excess by max-content, the table shrink-to-fit unless it has a width) or `table-layout: fixed`. Cells go through `LayoutNode` with `forcedBorderBoxWidth`/`forcedBorderBoxHeight` (stretched to their rows) and `contentOffsetY` for `vertical-align`; `baseline` cells share the row's first baseline (`TrialLayout`'s `FirstBaselineY`). Column-group/column/row-group/row backgrounds paint per cell. `visibility: collapse` on rows/columns (and their groups) removes them and their spacing after the column widths are computed; cells living only there are not laid out. `empty-cells: hide` skips an empty cell's box and the part backgrounds behind it (separated model only). A percentage table height resolves against the containing block's definite height (`containingHeight`), else is `auto`. Percentage row and cell heights refer to the table's definite height, else count for nothing; cell percentages are moved out of the cell's style map (`TableCellInfo.PercentHeight`) so `LayoutElement` never resolves them against a width. Tables get no transform/opacity/filter scopes.
 
 ### Form controls
 - A form control's look (border, padding, background, margins, round radio) comes from the UA stylesheet. `ApplyFormControlDefaults` only fills in the element-derived intrinsic size (text fields 150px, checkbox/radio from font size, buttons/selects/file inputs from their label) when `width`/`height` are unset.
@@ -143,12 +144,12 @@ Every text feature exists twice - in the paragraph path (whole lines as strings)
 - `CssTransitionTracker`/`CssAnimationTracker` run on a virtual clock (`IDomHarness.AdvanceTime`). Only `CssValueInterpolation.InterpolatableProperties` (colors, lengths, `opacity`, and the function lists `transform`/`translate`/`rotate`/`scale`/`filter`/`backdrop-filter`) interpolate; `all` means that whitelist. Function lists interpolate by structure (`CssFunctionListInterpolation`: matching functions argument by argument, `none`/shorter lists padded with identity functions, mismatched transforms through 2D matrix decomposition, anything else discretely at 50%). An element's natural `transform` is its authored value (`ReadAuthoredTransform`), never the computed one. Overrides are injected by `ApplyActiveTransitionAndAnimationOverrides` over the whole whitelist (not only existing keys); the animation lookup re-runs the cascade per property, so it only happens for elements whose computed style has an `animation-name`. Transition "from" values must be captured before pseudo-class mutation. Reversals restart with the full duration. Animations start at clock zero; fill-mode/direction/iteration share one effective-time computation; `animation-play-state: paused` is supported.
 
 ### SVG
-`<img src="*.svg">` (sniffed in `TryLoadImageResource`) and inline `<svg>` (rasterized from the live DOM, cached per element). Rasterized at natural size × `OversampleFactor`, not at CSS size. Supports shapes and full path data, percentages, `g`/`a`/`use`/`symbol`/nested `svg`, `text`/`tspan`, `clipPath`, `mask`, gradients, patterns, filters (every primitive, with the filter region and primitive subregions as crop rects, each primitive in its `color-interpolation-filters` space (linearRGB by default, converted with lookup tables since SkiaSharp 2.88 has no gamma color filters) - see `SvgFilterBuilder`), `currentColor`, `preserveAspectRatio`, and an internal `<style>` subset. Inline SVG also takes the page's CSS (`ResolveSvgPageStyle`): the root starts from its computed inherited values (so `color`/`fill`/fonts flow in from the HTML), and each element's own page declarations (`ComputeExplicitStyle`, never `GetDeclarations`, which merges in inherited values that would beat presentation attributes) apply after the SVG-internal rules and before inline `style`. The inline-SVG raster cache is keyed by a fingerprint of the markup and those page styles. An SVG used as an image (`<img src="*.svg">`, CSS `url()`) is an isolated document, so - as in browsers - page CSS never reaches it. `SvgTransformParser` must apply the rightmost function first (`next.PostConcat(result)`) - verify changes there visually.
+`<img src="*.svg">` (sniffed in `TryLoadImageResource`) and inline `<svg>` (rasterized from the live DOM, cached per element). Rasterized at natural size × `OversampleFactor`, not at CSS size. Supports shapes and full path data, percentages, `g`/`a`/`use`/`symbol`/nested `svg`, `text`/`tspan`, `clipPath`, `mask`, gradients, patterns, filters (every primitive, with the filter region and primitive subregions as crop rects, each primitive in its `color-interpolation-filters` space (linearRGB by default, converted with lookup tables since SkiaSharp 2.88 has no gamma color filters) - see `SvgFilterBuilder`), `currentColor`, `preserveAspectRatio`, and an internal `<style>` subset. Inline SVG also takes the page's CSS (`ResolveSvgPageStyle`): the root starts from its computed inherited values (so `color`/`fill`/fonts flow in from the HTML), and each element's own page declarations (`ComputeExplicitStyle`, never `GetDeclarations`, which merges in inherited values that would beat presentation attributes) apply after the SVG-internal rules and before inline `style`. The inline-SVG raster cache is keyed by a fingerprint of the markup and those page styles. An SVG used as an image (`<img src="*.svg">`, CSS `url()`) is an isolated document, so - as in browsers - page CSS never reaches it. Text is shaped like HTML text (`DrawParagraph`) with `direction` as the paragraph direction, which also flips what `text-anchor: start`/`end` and the advance of following `tspan`s mean, and `lang`/`xml:lang` (up into the host page) as the language. `SvgTransformParser` must apply the rightmost function first (`next.PostConcat(result)`) - verify changes there visually.
 
 ## Known Gaps
 
-- Text shaping (HarfBuzz): Arabic joining, ligatures, kerning, `font-feature-settings`, `font-variant-*` beyond caps. Hyphenation dictionaries (`hyphens: auto`). `-webkit-line-clamp` counts lines per inline run, not across nested blocks.
-- Not implemented: 3D transforms, `background-clip: text`, `mask-composite` other than `add`, the table features listed under Tables.
+- Text: hyphenation dictionaries (`hyphens: auto`); synthesized small caps rather than `smcp`; the min/max-content widths of a word split across elements ignore the shaping context; Canvas 2D has no `direction` (its paragraphs are left to right).
+- Not implemented: 3D transforms, `background-clip: text`, `mask-composite` other than `add`, nested `column-span: all` spanners, paged media.
 
 ## Code Conventions
 
@@ -174,10 +175,10 @@ cd src/AngleSharp.Renderer.Benchmarks
 dotnet run -c Release -f net10.0 [-- --job short]
 ```
 
-Record new numbers plus a `History` entry in `BASELINE.md` whenever an optimization lands. Past wins: style-map caching, caching the explicit-declaration style collection, skipping flex/grid container-only reads for non-containers. A typed `ParseLength` fast path gave no measurable gain because AngleSharp.Css's `.CssText` serialization dominates; skipping the string entry entirely is untested and first needs proof that nothing reads those 17 keys as raw strings.
+Record new numbers plus a `History` entry in `BASELINE.md` whenever an optimization lands. Past wins: style-map caching, caching the explicit-declaration style collection, skipping flex/grid container-only reads for non-containers, and the per-thread width cache in `SkiaTextMeasurer` that keeps HarfBuzz shaping from multiplying with nested trial layouts (painting still shapes every run once, about +10% on `RenderToPng`). A typed `ParseLength` fast path gave no measurable gain because AngleSharp.Css's `.CssText` serialization dominates; skipping the string entry entirely is untested and first needs proof that nothing reads those 17 keys as raw strings.
 
 ## Repository Notes
 
 - User-facing docs live under `docs/general/` and `docs/tutorials/`.
 - Add release notes to `CHANGELOG.md`.
-- Linux uses `SkiaSharp.NativeAssets.Linux.NoDependencies`: no fontconfig, but it scans `/usr/share/fonts/`, so named families depend on the runner image. CI deliberately installs no extra fonts.
+- Linux uses `SkiaSharp.NativeAssets.Linux.NoDependencies`: no fontconfig, but it scans `/usr/share/fonts/`, so named families depend on the runner image. CI deliberately installs no extra fonts. HarfBuzzSharp's own package only brings Windows/macOS natives, hence the explicit `HarfBuzzSharp.NativeAssets.Linux`, kept at the version `SkiaSharp.HarfBuzz` depends on.
diff --git a/CHANGELOG.md b/CHANGELOG.md
index f833446..a52c73f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,32 @@
+# 0.9.0
+
+Released on Friday, October 30 2026.
+
+- Fixed `-webkit-line-clamp` counting lines per inline run instead of across the nested blocks of the clamped box (e.g. paragraphs in a clamped card), which now ends after its last line
+- Fixed gaps with font- or viewport-relative units (e.g. Tailwind's `gap-4`, i.e. `gap: 1rem`) being ignored in grid and flex containers
+- Fixed images (and other replaced elements) with `border-radius` not being clipped to its curve (e.g. a `rounded-full` avatar painted square)
+- Fixed `line-height` lengths (e.g. `16px`, or `1rem` as in Tailwind's `text-xs`) being ignored in favor of the inherited (or default) line height
+- Fixed inline-level flex items and non-stretched grid items (e.g. a `<span>`) being as tall as their inline box instead of their line boxes, which let text overflow them at the bottom (e.g. tag pills with padding)
+- Fixed words breaking after a hyphen or slash in a box sized to fit them (e.g. a flex item with the max-content width of `c-sharp`), as the width came out of the box arithmetic a fraction of a pixel short
+- Added grid track alignment: `justify-content` and `align-content` (`start`, `end`, `center`, `space-between`, `space-around`, `space-evenly`, with `safe`) position the tracks of a grid whose tracks do not fill it
+- Added lines moving down past floats: a line whose first word does not fit beside the floats moves down to where one of them ends, until it fits or no float is beside it
+- Added `writing-mode` on flex, grid and table containers: a container whose writing mode differs from its parent's lays out its items along its own axes (e.g. a `vertical-rl` flex container runs its main axis downwards)
+- Added nested writing modes in the same orientation: a `vertical-lr` element in `vertical-rl` content (or the reverse) stacks its blocks in its own direction
+- Added `position: sticky` inside orthogonal flows (e.g. in a `vertical-rl` box), which used to stay static
+- Added anonymous table objects: stray `display: table-cell` boxes (e.g. `<div style="display:table-cell">` used for layout) form a row of an anonymous table, rows outside a table get one, and text or other content directly inside a table or row is wrapped in an anonymous row or cell instead of being dropped
+- Added percentage table heights (e.g. `table { height: 50% }`), resolved against a definite containing block height
+- Added `column-span: all` in multi-column containers: the spanner is laid out across all columns, and the content on each side of it is balanced separately
+- Added text shaping with HarfBuzz (via `SkiaSharp.HarfBuzz`): kerning and ligatures (e.g. `fi`, `fl`), Arabic joining and complex scripts such as Devanagari, measured and painted from the same shaped glyphs, so line breaking, alignment and table widths use the shaped advances
+- Added `font-feature-settings`, `font-kerning`, `font-variant-ligatures` and `font-variant-numeric` (e.g. `font-feature-settings: "liga" 0` turns ligatures off, `tabular-nums` selects tabular figures); a non-zero `letter-spacing` turns optional ligatures off
+- Added Noto Sans Devanagari as a bundled fallback font (its OFL license is included in the package), so Devanagari renders without an installed font
+- Changed right-to-left text in the display list: `DrawTextCommand.Text` is now in logical order with `IsRightToLeft` set, and shaping reverses and mirrors it (it used to be reversed and mirrored by layout)
+- Changed `text-overflow: ellipsis` to cut at glyph clusters (`ITextMeasurer.GetClusterBoundaries`, which defaults to grapheme clusters for custom measurers), so it never splits a ligature or conjunct
+- Improved SVG `text`/`tspan`, which is shaped the same way as HTML text, reordered by the bidi algorithm with `direction` as its paragraph direction (which also decides where `text-anchor: start` and `end` are), and in its `lang`
+- Added `lang` to text shaping, so fonts with language-specific forms use them (e.g. the Marathi forms of Noto Sans Devanagari for `lang="mr"`)
+- Added joining across element boundaries: an Arabic word split by an inline element (e.g. one letter in `<b>`) keeps its joined forms
+- Changed Canvas 2D `fillText` to use the context's `font` (family, size, weight, style) with the same fonts, shaping and bidi reordering as HTML text instead of the host's default typeface
+- Added fragmentation in multi-column containers: `break-before`/`break-after` (`column` forces a new column, `avoid`), `break-inside: avoid`, `orphans`/`widows` (lines of a paragraph are no longer left alone at the top or bottom of a column), `column-fill: auto|balance` with a definite height (balanced by default), and blocks without lines splitting across columns
+
 # 0.8.2
 
 Released on Sunday, October 25 2026.
diff --git a/docs/general/01-Basics.md b/docs/general/01-Basics.md
index 899bda0..df49da9 100644
--- a/docs/general/01-Basics.md
+++ b/docs/general/01-Basics.md
@@ -61,6 +61,10 @@ Inline content is laid out in line boxes, so nested inline elements keep their o
 Generic font families like `serif`, `sans-serif`, and `monospace` always map to fonts bundled with the renderer, so they render the same on every machine.
 Named families resolve only when installed on the host (or declared via `@font-face`), so prefer generic families when you need predictable output in visual tests.
 
+Text is shaped with HarfBuzz, so kerning and ligatures (`fi`, `fl`) apply, Arabic letters join, and complex scripts such as Devanagari form their conjuncts.
+`font-feature-settings`, `font-kerning`, `font-variant-ligatures` and `font-variant-numeric` select the OpenType features of the font; a non-zero `letter-spacing` turns optional ligatures off.
+The bundled fonts cover Latin, Greek, Cyrillic, Hebrew and Arabic (DejaVu) and Devanagari (Noto Sans Devanagari, used only as a fallback); other scripts need an installed font or an `@font-face` that covers them.
+
 ## Visual Testing
 
 The test suite uses PNG snapshots under `verification-assets/`. Missing baselines are created automatically unless strict mode is enabled with `ANGLESHARP_SNAPSHOT_STRICT=1`.
diff --git a/docs/tutorials/03-Questions.md b/docs/tutorials/03-Questions.md
index bb95489..d2b61b9 100644
--- a/docs/tutorials/03-Questions.md
+++ b/docs/tutorials/03-Questions.md
@@ -6,9 +6,13 @@ section: "AngleSharp.Renderer"
 
 ## Why do web-safe fonts look the same on my machine?
 
-The renderer maps generic families such as `serif`, `sans-serif`, and `monospace` to installed local fonts. If your system does not have distinct serif/sans/monospace faces available, Skia may fall back to similar-looking defaults.
+The renderer maps generic families such as `serif`, `sans-serif`, and `monospace` to fonts bundled with it (DejaVu), not to installed fonts, so they look the same on every machine.
 
-For stable results, install a font set with visibly different faces or use explicit family names that are present on the target machine.
+Named families (e.g. `Arial`) resolve only when installed on the host or declared via `@font-face`; otherwise the next entry of the `font-family` list is used.
+
+## Why does my text in another script show boxes?
+
+Characters the resolved font has no glyph for fall back to the next `font-family` entry, then the bundled fonts (Latin, Greek, Cyrillic, Hebrew, Arabic, Devanagari), then whatever the host has installed. For other scripts (e.g. Thai or CJK) declare an `@font-face` or install a font that covers them.
 
 ## Why does a snapshot fail when I add a new baseline?
 
diff --git a/src/AngleSharp.Renderer.Benchmarks/BASELINE.md b/src/AngleSharp.Renderer.Benchmarks/BASELINE.md
index cadc48f..38086fc 100644
--- a/src/AngleSharp.Renderer.Benchmarks/BASELINE.md
+++ b/src/AngleSharp.Renderer.Benchmarks/BASELINE.md
@@ -35,6 +35,10 @@ Against `AngleSharp` 1.8.1, `AngleSharp.Css` 1.1.2 (both via `PackageReference`)
 | **Layout only: `BuildDisplayList`** | **364 ms** | **194.14 MB** |
 | Full pipeline: layout + Skia rasterization + PNG encoding (`RenderToPng`) | 527 ms | 199.41 MB |
 
+> **Note (2026-10-28):** the tables above predate HarfBuzz text shaping and were measured on the
+> Apple M5. The shaping change was measured before/after on a different machine (see the last
+> History entry); re-run these tables on the M5 to refresh them.
+
 **Cumulative improvement over the original, pre-optimization baseline: ~9.5x faster, ~7.5x less
 allocation** on `BuildDisplayList` (net10.0: 2,415 ms / 1,456 MB &rarr; 255 ms / 194 MB). The
 net8.0 mean above carries a wide error margin in this particular short-job run (~285ms on a 364ms
@@ -206,3 +210,37 @@ BenchmarkDotNet refuses to run outside `Release` and warns loudly if it detects
 unoptimized build - always use `-c Release`. Update the tables above (and the date) after a
 meaningful optimization lands, so this file keeps tracking the current baseline rather than one
 frozen the day it was first written.
+
+### 2026-10-28, HarfBuzz text shaping (cost, plus a width cache in `SkiaTextMeasurer`)
+
+Measured on a different machine than the tables above, so only the before/after pair is
+comparable: AMD Ryzen 7 3700X (16 threads), Linux (WSL2), .NET SDK 10.0.100, `short` job.
+"Before" is commit `59b892a` (unshaped `canvas.DrawText`), "shaped" is HarfBuzz shaping in
+`SkiaTextShaping` without any caching, "shaped + cache" adds the per-thread width cache that
+`SkiaTextMeasurer.MeasureWidth` now keeps (keyed by text and `RenderFont`, cleared at 16,384
+entries).
+
+| `BuildDisplayList` | net10.0 Mean | net8.0 Mean | Allocated |
+|---|---:|---:|---:|
+| before | 423 ms | 401 ms | 119.9 MB |
+| shaped | 443 ms | 509 ms | 142.4 MB |
+| shaped + cache | 409 ms | 355 ms | 121.7 MB |
+
+| `RenderToPng` | net10.0 Mean | net8.0 Mean | Allocated |
+|---|---:|---:|---:|
+| before | 2,630 ms | 2,586 ms | 124.7 MB |
+| shaped | 2,923 ms | 2,988 ms | 148.1 MB |
+| shaped + cache | 2,867 ms | 2,963 ms | 127.3 MB |
+
+The short job's error margins are wide on this machine (up to +/-30 ms StdDev for layout), so the
+layout means are best read as "back to parity" with the cache; allocation is deterministic and
+ends up +1.8 MB (+1.5%). Painting keeps a real cost of roughly +9-15% on the full pipeline: every
+painted run is shaped once more when it is drawn (lines are mostly unique, so a paint-side cache
+would rarely hit).
+
+Nested trial layouts: a probe laying out 20 copies of inline-blocks nested 1-5 deep (each with a
+12-word sentence) in a 300px box. The number of `MeasureWidth` calls is identical before and after
+(trial layouts multiply it by ~2-2.5x per level: 1,280 / 4,020 / 9,760 / 21,500 / 41,946), and
+with the width cache the repeated calls cost a dictionary lookup instead of a shaping pass, so the
+time per layout did not grow (before: 17 / 36 / 89 / 160 / 154 ms, after: 19 / 45 / 76 / 133 /
+123 ms for depths 1-5; single runs of 5 layouts, so +/-20%).
diff --git a/src/AngleSharp.Renderer.Docs/package.json b/src/AngleSharp.Renderer.Docs/package.json
index d827f1c..c2b60ee 100644
--- a/src/AngleSharp.Renderer.Docs/package.json
+++ b/src/AngleSharp.Renderer.Docs/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@anglesharp/renderer",
-  "version": "0.8.2",
+  "version": "0.9.0",
   "preview": true,
   "description": "The doclet for the AngleSharp.Renderer documentation.",
   "keywords": [
diff --git a/src/AngleSharp.Renderer.Tests/HtmlRendererTests.cs b/src/AngleSharp.Renderer.Tests/HtmlRendererTests.cs
index 27c9dfb..65fbbd7 100644
--- a/src/AngleSharp.Renderer.Tests/HtmlRendererTests.cs
+++ b/src/AngleSharp.Renderer.Tests/HtmlRendererTests.cs
@@ -5,6 +5,7 @@
 using AngleSharp.Html.Dom;
 using AngleSharp.Io;
 using AngleSharp.Renderer.Rendering;
+using AngleSharp.Renderer.Skia;
 
 using System.Net;
 using System.Threading;
@@ -120,6 +121,37 @@ public async Task BuildDisplayList_ObjectFitCoverFillsTheBoxAndClipsTheOverflow(
         Assert.Single(displayList.Commands.OfType<PopClipCommand>());
     }
 
+    [Fact]
+    public async Task BuildDisplayList_ClipsImagesToTheInnerCurveOfTheirBorderRadius()
+    {
+        // found on me.florian-rappl.de: a rounded-full avatar was painted square
+        var document = await ParseAsync($"""
+            <html><body style="margin:0">
+                <img src="{OnePixelPng}" style="width:40px; height:40px; padding:2px; border:3px solid black; border-radius:9999px;" />
+            </body></html>
+            """);
+
+        var commands = BuildDisplayList(document).Commands.ToList();
+        var imageIndex = commands.FindIndex(command => command is DrawImageCommand);
+        var clip = Assert.IsType<PushClipCommand>(commands[imageIndex - 1]);
+
+        // the radius is clamped to half the 50px border box and shrinks by border and padding
+        Assert.Equal(new RenderRect(5f, 5f, 40f, 40f), clip.Rect);
+        Assert.Equal(20f, clip.Radii.TopLeftX, precision: 2);
+        Assert.Equal(20f, clip.Radii.BottomRightY, precision: 2);
+        Assert.IsType<PopClipCommand>(commands[imageIndex + 1]);
+    }
+
+    [Fact]
+    public async Task BuildDisplayList_DoesNotClipImagesWithoutBorderRadius()
+    {
+        var document = await ParseAsync($"""
+            <html><body><img src="{OnePixelPng}" style="width:40px; height:40px;" /></body></html>
+            """);
+
+        Assert.Empty(BuildDisplayList(document).Commands.OfType<PushClipCommand>());
+    }
+
     [Fact]
     public async Task BuildDisplayList_ObjectFitNoneUsesNaturalSizeCenteredInTheBox()
     {
@@ -1661,6 +1693,104 @@ public async Task BuildDisplayList_AppliesGridGapsToTrackPlacement()
         Assert.Equal(30f, childBackgrounds[3].Rect.Y);
     }
 
+    [Theory]
+    [InlineData("display:grid; grid-template-columns:repeat(2, 20px)", 36f, 26f)]
+    [InlineData("display:flex; flex-wrap:wrap; width:60px", 36f, 26f)]
+    public async Task BuildDisplayList_ResolvesFontRelativeGaps(string container, float secondX, float thirdY)
+    {
+        // found on me.florian-rappl.de: Tailwind's gap-4 (gap:1rem) was ignored
+        var document = await ParseAsync($"""
+            <html><body style="margin:0">
+                <div style="{container}; gap:1rem .5em; font-size:32px">
+                    <div style="width:20px; height:10px; background-color:#ff0000;"></div>
+                    <div style="width:20px; height:10px; background-color:#0000ff;"></div>
+                    <div style="width:20px; height:10px; background-color:#00ff00;"></div>
+                </div>
+            </body></html>
+            """);
+
+        var childBackgrounds = BuildDisplayList(document).Commands
+            .OfType<FillRectCommand>()
+            .Where(command => command.Rect.Width == 20f && command.Rect.Height == 10f)
+            .ToArray();
+
+        // row-gap 1rem = 16px, column-gap .5em = 16px (of the container's 32px)
+        Assert.Equal(3, childBackgrounds.Length);
+        Assert.Equal(secondX, childBackgrounds[1].Rect.X);
+        Assert.Equal(0f, childBackgrounds[1].Rect.Y);
+        Assert.Equal(0f, childBackgrounds[2].Rect.X);
+        Assert.Equal(thirdY, childBackgrounds[2].Rect.Y);
+    }
+
+    [Theory]
+    [InlineData("<div style=\"{0}\">text</div>")]
+    [InlineData("<div style=\"line-height:1.5\"><div style=\"{0}\">text</div></div>")]
+    [InlineData("<div style=\"display:flex\"><span style=\"{0}\">text</span></div>")]
+    [InlineData("<div style=\"display:flex; align-items:center; height:80px\"><span style=\"{0}\">text</span></div>")]
+    [InlineData("<div style=\"display:grid; align-items:center; height:80px\"><span style=\"{0}; justify-self:start\">text</span></div>")]
+    public async Task BuildDisplayList_SizesBoxesByTheirLineHeightLength(string markup)
+    {
+        // found on me.florian-rappl.de: Tailwind's text-xs (12px with line-height:1rem) pills were
+        // as tall as their inline box, so the 16px line box overflowed them at the bottom
+        var box = "font-size:12px; line-height:1.875rem; padding:2px; background-color:#ff0000";
+        var document = await ParseAsync($"<html><body style=\"margin:0\">{string.Format(markup, box)}</body></html>");
+
+        var background = Assert.Single(BuildDisplayList(document).Commands
+            .OfType<FillRectCommand>()
+            .Where(command => command.Color == new RenderColor(255, 0, 0, 255)));
+
+        // a 30px line box plus 2px padding at the top and bottom
+        Assert.Equal(34f, background.Rect.Height, precision: 2);
+    }
+
+    [Theory]
+    [InlineData("start", 0f, 20f, 0f, 10f)]
+    [InlineData("center", 30f, 50f, 20f, 30f)]
+    [InlineData("end", 60f, 80f, 40f, 50f)]
+    [InlineData("space-between", 0f, 80f, 0f, 50f)]
+    [InlineData("space-around", 15f, 65f, 10f, 40f)]
+    [InlineData("space-evenly", 20f, 60f, 13.33f, 36.67f)]
+    [InlineData("safe center", 30f, 50f, 20f, 30f)]
+    public async Task BuildDisplayList_AlignsGridTracksWithinTheContainer(string alignment, float firstX, float secondX, float firstY, float secondY)
+    {
+        // two 20px columns in 100px and two 10px rows in 60px leave 60px and 40px to distribute
+        var document = await ParseAsync($"""
+            <html><body style="margin:0">
+                <div style="display:grid; grid-template-columns:20px 20px; grid-template-rows:10px 10px; width:100px; height:60px; justify-content:{alignment}; align-content:{alignment}">
+                    <div style="background-color:#ff0000"></div><div></div><div></div><div style="background-color:#0000ff"></div>
+                </div>
+            </body></html>
+            """);
+
+        var commands = BuildDisplayList(document).Commands.OfType<FillRectCommand>().ToList();
+        var first = Assert.Single(commands, command => command.Color == new RenderColor(255, 0, 0));
+        var last = Assert.Single(commands, command => command.Color == new RenderColor(0, 0, 255));
+
+        Assert.Equal(firstX, first.Rect.X, precision: 2);
+        Assert.Equal(firstY, first.Rect.Y, precision: 2);
+        Assert.Equal(secondX, last.Rect.X, precision: 2);
+        Assert.Equal(secondY, last.Rect.Y, precision: 2);
+    }
+
+    [Fact]
+    public async Task BuildDisplayList_OverflowingGridTracksFallBackForDistributedAlignment()
+    {
+        // 2 x 80px columns overflow 100px: space-between packs them at the start, center centers them
+        var document = await ParseAsync("""
+            <html><body style="margin:0">
+                <div style="display:grid; grid-template-columns:80px 80px; width:100px; justify-content:space-between"><div style="height:10px; background-color:#ff0000"></div></div>
+                <div style="display:grid; grid-template-columns:80px 80px; width:100px; justify-content:center"><div style="height:10px; background-color:#0000ff"></div></div>
+                <div style="display:grid; grid-template-columns:80px 80px; width:100px; justify-content:safe center"><div style="height:10px; background-color:#00ff00"></div></div>
+            </body></html>
+            """);
+
+        var commands = BuildDisplayList(document).Commands.OfType<FillRectCommand>().ToList();
+
+        Assert.Equal(0f, Assert.Single(commands, command => command.Color == new RenderColor(255, 0, 0)).Rect.X);
+        Assert.Equal(-30f, Assert.Single(commands, command => command.Color == new RenderColor(0, 0, 255)).Rect.X);
+        Assert.Equal(0f, Assert.Single(commands, command => command.Color == new RenderColor(0, 255, 0)).Rect.X);
+    }
+
     [Fact]
     public async Task BuildDisplayList_SizesFractionalTracksProportionally()
     {
@@ -6960,6 +7090,121 @@ public async Task BuildDisplayList_OverlongWordsBreakAfterSlashesAndHyphensButNo
         Assert.Equal(expected + "|" + expected, string.Join("|", lines));
     }
 
+    [Fact]
+    public async Task BuildDisplayList_DoesNotBreakAHyphenatedWordInABoxAHairNarrowerThanIt()
+    {
+        // found on me.florian-rappl.de: the max-content width of a flex item came out of the box
+        // arithmetic a fraction of a pixel short of its text, which then broke as "c-|sharp"
+        var width = new SkiaTextMeasurer().MeasureWidth("c-sharp", new RenderFont("sans-serif", 16f, 400f, false, 0f)) - 0.004f;
+        var document = await ParseAsync($"""
+            <html><body style="margin:0"><div style="width:{width.ToString(System.Globalization.CultureInfo.InvariantCulture)}px; font:16px sans-serif">c-sharp</div></body></html>
+            """);
+
+        var text = Assert.Single(BuildDisplayList(document).Commands.OfType<DrawTextCommand>());
+        Assert.Equal("c-sharp", text.Text);
+    }
+
+    [Fact]
+    public async Task BuildDisplayList_MovesALineBelowAFloatWhenItsFirstWordDoesNotFitBesideIt()
+    {
+        // 50px are left beside the float, too little for the 80px box, which moves below the float
+        var document = await ParseAsync("""
+            <html><body style="margin:0">
+                <div style="width:200px; line-height:20px">
+                    <div style="float:left; width:150px; height:40px; background-color:#ff0000"></div>
+                    <span style="display:inline-block; width:80px; height:20px; background-color:#0000ff"></span>
+                </div>
+            </body></html>
+            """);
+
+        var box = Assert.Single(BuildDisplayList(document).Commands.OfType<FillRectCommand>(), command => command.Color == new RenderColor(0, 0, 255));
+
+        Assert.Equal(0f, box.Rect.X);
+        Assert.True(box.Rect.Y >= 40f, $"Expected the box below the float, got y = {box.Rect.Y}");
+    }
+
+    [Fact]
+    public async Task BuildDisplayList_MovesALineToTheFirstBandBesideFloatsWhereItFits()
+    {
+        // 50px are free beside the first float and 100px beside the second, which is wide enough
+        var document = await ParseAsync("""
+            <html><body style="margin:0">
+                <div style="width:200px; line-height:20px">
+                    <div style="float:left; width:150px; height:30px"></div>
+                    <div style="float:left; clear:left; width:100px; height:30px"></div>
+                    <span style="display:inline-block; width:80px; height:20px; background-color:#0000ff"></span>
+                </div>
+            </body></html>
+            """);
+
+        var box = Assert.Single(BuildDisplayList(document).Commands.OfType<FillRectCommand>(), command => command.Color == new RenderColor(0, 0, 255));
+
+        Assert.Equal(100f, box.Rect.X);
+        Assert.InRange(box.Rect.Y, 30f, 40f);
+    }
+
+    [Fact]
+    public async Task BuildDisplayList_KeepsALineBesideAFloatWhenItsFirstWordFits()
+    {
+        var document = await ParseAsync("""
+            <html><body style="margin:0">
+                <div style="width:200px; line-height:20px">
+                    <div style="float:left; width:150px; height:40px"></div>
+                    <span style="display:inline-block; width:40px; height:20px; background-color:#0000ff"></span>
+                </div>
+            </body></html>
+            """);
+
+        var box = Assert.Single(BuildDisplayList(document).Commands.OfType<FillRectCommand>(), command => command.Color == new RenderColor(0, 0, 255));
+
+        Assert.Equal(150f, box.Rect.X);
+        Assert.InRange(box.Rect.Y, 0f, 10f);
+    }
+
+    [Fact]
+    public async Task BuildDisplayList_LineClampCountsTheLinesOfNestedBlocks()
+    {
+        var document = await ParseAsync("""
+            <html><body style="margin:0">
+                <div style="overflow:hidden; display:-webkit-box; -webkit-box-orient:vertical; -webkit-line-clamp:3; line-height:20px; background-color:#ff0000">
+                    <p style="margin:0">one</p>
+                    <p style="margin:0">two<br>three<br>four</p>
+                    <p style="margin:0">five</p>
+                </div>
+            </body></html>
+            """);
+
+        var displayList = BuildDisplayList(document);
+        var lines = displayList.Commands.OfType<DrawTextCommand>().Select(command => command.Text).ToArray();
+        var box = Assert.Single(displayList.Commands.OfType<FillRectCommand>(), command => command.Color == new RenderColor(255, 0, 0));
+
+        Assert.Equal(["one", "two", "three…"], lines);
+        Assert.Equal(60f, box.Rect.Height);
+    }
+
+    [Fact]
+    public async Task BuildDisplayList_LineClampShowsAnEllipsisWhenALaterBlockIsCut()
+    {
+        var document = await ParseAsync("""
+            <html><body style="margin:0">
+                <div style="overflow:hidden; -webkit-line-clamp:2; line-height:20px">
+                    <p style="margin:0">one</p>
+                    <p style="margin:0">two</p>
+                    <p style="margin:0">three</p>
+                </div>
+                <div style="overflow:hidden; -webkit-line-clamp:2; line-height:20px">
+                    <p style="margin:0">four</p>
+                    <p style="margin:0">five</p>
+                </div>
+            </body></html>
+            """);
+
+        var lines = BuildDisplayList(document).Commands.OfType<DrawTextCommand>().Select(command => command.Text).ToArray();
+
+        // nothing follows "five", so it shows no ellipsis
+        Assert.Equal(["one", "two…", "four", "five"], lines);
+    }
+
     [Fact]
     public async Task BuildDisplayList_OverflowWrapNormalLeavesAnOverlongWordOnOneOverflowingLine()
     {
@@ -8477,6 +8722,124 @@ public async Task BuildDisplayList_ColumnCountSplitsContentIntoBalancedColumns()
         Assert.Equal(2f, rule.Rect.Width);
     }
 
+    [Fact]
+    public async Task BuildDisplayList_ColumnSpanAllSpansTheColumnsAndBalancesEachSideSeparately()
+    {
+        var document = await ParseAsync("""
+            <html><body>
+                <div style="width:300px; column-count:2; column-gap:20px; line-height:20px; background-color:#0000ff">
+                    <p style="margin:0">A</p><p style="margin:0">B</p>
+                    <div style="column-span:all; height:30px; background-color:#ff0000"></div>
+                    <p style="margin:0">C</p><p style="margin:0">D</p><p style="margin:0">E</p><p style="margin:0">F</p>
+                </div>
+            </body></html>
+            """);
+
+        var displayList = BuildDisplayList(document);
+        var clips = displayList.Commands.OfType<PushClipCommand>().Select(clip => clip.Rect).ToList();
+
+        Assert.Equal(new RenderRect(0f, 20f, 300f, 30f), SingleFill(displayList, Red).Rect);
+        Assert.Equal(90f, SingleFill(displayList, Blue).Rect.Height, precision: 2);
+        Assert.Equal(4, clips.Count);
+        Assert.All(clips.Take(2), clip => Assert.Equal((0f, 20f), (clip.Y, clip.Height)));
+        Assert.All(clips.Skip(2), clip => Assert.Equal((50f, 40f), (clip.Y, clip.Height)));
+    }
+
+    [Theory]
+    [InlineData("", -40f)]
+    [InlineData("break-inside:avoid", -20f)]
+    public async Task BuildDisplayList_BreakInsideAvoidKeepsABlockInOneColumn(string breakInside, float secondColumnShift)
+    {
+        var document = await ParseAsync($$"""
+            <html><body>
+                <div style="width:300px; column-count:2; line-height:20px">
+                    <p style="margin:0">A</p>
+                    <div style="{{breakInside}}"><p style="margin:0">B</p><p style="margin:0">C</p></div>
+                </div>
+            </body></html>
+            """);
+
+        var translations = BuildDisplayList(document).Commands.OfType<PushTransformCommand>().Select(t => t.Transform).ToList();
+
+        Assert.Equal(2, translations.Count);
+        Assert.Equal(secondColumnShift, translations[1].F, precision: 2);
+    }
+
+    [Fact]
+    public async Task BuildDisplayList_BreakBeforeColumnStartsANewColumn()
+    {
+        var document = await ParseAsync("""
+            <html><body>
+                <div style="width:300px; column-count:2; line-height:20px">
+                    <p style="margin:0">A</p><p style="margin:0">B</p><p style="margin:0; break-before:column">C</p>
+                </div>
+            </body></html>
+            """);
+
+        var displayList = BuildDisplayList(document);
+        var clips = displayList.Commands.OfType<PushClipCommand>().ToList();
+        var translations = displayList.Commands.OfType<PushTransformCommand>().Select(t => t.Transform).ToList();
+
+        Assert.Equal(40f, clips[0].Rect.Height, precision: 2);
+        Assert.Equal(-40f, translations[1].F, precision: 2);
+    }
+
+    [Theory]
+    [InlineData("", -60f)]
+    [InlineData("orphans:1; widows:3", -40f)]
+    public async Task BuildDisplayList_OrphansAndWidowsChooseTheBreakLine(string lineCounts, float secondColumnShift)
+    {
+        var document = await ParseAsync($$"""
+            <html><body>
+                <div style="width:300px; column-count:2; line-height:20px; {{lineCounts}}">
+                    <p style="margin:0; white-space:pre-line">1
+            2
+            3
+            4
+            5</p>
+                </div>
+            </body></html>
+            """);
+
+        var translations = BuildDisplayList(document).Commands.OfType<PushTransformCommand>().Select(t => t.Transform).ToList();
+
+        Assert.Equal(2, translations.Count);
+        Assert.Equal(secondColumnShift, translations[1].F, precision: 2);
+    }
+
+    [Theory]
+    [InlineData("auto", 1)]
+    [InlineData("balance", 2)]
+    public async Task BuildDisplayList_ColumnFillDecidesHowADefiniteHeightIsFilled(string columnFill, int expectedColumns)
+    {
+        var document = await ParseAsync($$"""
+            <html><body>
+                <div style="width:300px; height:100px; column-count:2; column-fill:{{columnFill}}; line-height:20px">
+                    <p style="margin:0">A</p><p style="margin:0">B</p><p style="margin:0">C</p>
+                </div>
+            </body></html>
+            """);
+
+        Assert.Equal(expectedColumns, BuildDisplayList(document).Commands.OfType<PushClipCommand>().Count());
+    }
+
+    [Fact]
+    public async Task BuildDisplayList_ABlockWithoutLinesSplitsAcrossColumns()
+    {
+        var document = await ParseAsync("""
+            <html><body>
+                <div style="width:300px; column-count:2">
+                    <div style="height:100px; background-color:#ff0000"></div>
+                </div>
+            </body></html>
+            """);
+
+        var clips = BuildDisplayList(document).Commands.OfType<PushClipCommand>().ToList();
+
+        Assert.Equal(2, clips.Count);
+        Assert.All(clips, clip => Assert.Equal(50f, clip.Rect.Height, precision: 2));
+    }
+
     [Fact]
     public async Task BuildDisplayList_ColumnWidthDerivesTheColumnCount()
     {
@@ -9624,8 +9987,10 @@ public async Task BuildDisplayList_HebrewTextIsPaintedInVisualOrder()
 
         var text = Assert.Single(BuildDisplayList(document).Commands.OfType<DrawTextCommand>());
 
-        // The logical "shalom olam" is drawn right-to-left: last letter first, words swapped.
-        Assert.Equal("\u05dd\u05dc\u05d5\u05e2 \u05dd\u05d5\u05dc\u05e9", text.Text);
+        // The logical "shalom olam" is one right-to-left run; shaping draws it last letter first
+        // (see TextShapingTests for the glyph order).
+        Assert.Equal("\u05e9\u05dc\u05d5\u05dd \u05e2\u05d5\u05dc\u05dd", text.Text);
+        Assert.True(text.IsRightToLeft);
     }
 
     [Fact]
@@ -9635,7 +10000,8 @@ public async Task BuildDisplayList_HebrewInsideLeftToRightTextIsReorderedInPlace
 
         var texts = BuildDisplayList(document).Commands.OfType<DrawTextCommand>().ToList();
 
-        Assert.Equal(["abc", "\u05d2\u05d1\u05d0", "def"], texts.Select(t => t.Text.Trim()));
+        Assert.Equal(["abc", "\u05d0\u05d1\u05d2", "def"], texts.Select(t => t.Text.Trim()));
+        Assert.Equal([false, true, false], texts.Select(t => t.IsRightToLeft));
         Assert.True(texts[0].X < texts[1].X && texts[1].X < texts[2].X);
     }
 
@@ -9644,11 +10010,13 @@ public async Task BuildDisplayList_MixedInlineContentIsReorderedAcrossElements()
     {
         var document = await ParseAsync("<html><body><p style=\"direction:rtl\">\u05d0\u05d1 <b>\u05d2\u05d3</b> (1)</p></body></html>");
 
-        var texts = BuildDisplayList(document).Commands.OfType<DrawTextCommand>().OrderBy(t => t.X).Select(t => t.Text.Trim()).ToList();
+        var texts = BuildDisplayList(document).Commands.OfType<DrawTextCommand>().OrderBy(t => t.X).Where(t => t.Text.Trim().Length > 0).ToList();
 
         // Right-to-left from the right edge: "אב", then the bold "גד", then "(1)" - so visually,
-        // left to right, the mirrored "(1)" comes first and "אב" last.
-        Assert.Equal(["(1)", "\u05d3\u05d2", "\u05d1\u05d0"], texts.Where(t => t.Length > 0));
+        // left to right, "(1)" comes first and "אב" last. The brackets are right-to-left runs of
+        // their own (mirrored when shaped), around the left-to-right digit.
+        Assert.Equal([")", "1", "(", "\u05d2\u05d3", "\u05d0\u05d1"], texts.Select(t => t.Text.Trim()));
+        Assert.Equal([true, false, true, true, true], texts.Select(t => t.IsRightToLeft));
     }
 
     [Fact]
@@ -9656,9 +10024,10 @@ public async Task BuildDisplayList_UnicodeBidiOverrideForcesTheElementsDirection
     {
         var document = await ParseAsync("<html><body><p>ab <span style=\"direction:rtl; unicode-bidi:bidi-override\">xyz</span> cd</p></body></html>");
 
-        var texts = BuildDisplayList(document).Commands.OfType<DrawTextCommand>().Select(t => t.Text.Trim()).ToList();
+        var texts = BuildDisplayList(document).Commands.OfType<DrawTextCommand>().ToList();
 
-        Assert.Contains("zyx", texts);
+        // Overridden to right to left, so shaped (and drawn) as "zyx".
+        Assert.Contains(texts, t => t.Text.Trim() == "xyz" && t.IsRightToLeft);
     }
 
     [Fact]
@@ -9668,7 +10037,10 @@ public async Task BuildDisplayList_BracketsAreMirroredInRightToLeftText()
 
         var text = Assert.Single(BuildDisplayList(document).Commands.OfType<DrawTextCommand>());
 
-        Assert.Equal("(\u05d1) \u05d0", text.Text);
+        // One right-to-left run in logical order; shaping mirrors the brackets
+        // (TextShapingTests.RightToLeftRuns_MirrorBrackets).
+        Assert.Equal("\u05d0 (\u05d1)", text.Text);
+        Assert.True(text.IsRightToLeft);
     }
 
     private static readonly RenderColor FormControlAccentColorForTests = new(26, 115, 232);
diff --git a/src/AngleSharp.Renderer.Tests/TableLayoutTests.cs b/src/AngleSharp.Renderer.Tests/TableLayoutTests.cs
index e943724..0809139 100644
--- a/src/AngleSharp.Renderer.Tests/TableLayoutTests.cs
+++ b/src/AngleSharp.Renderer.Tests/TableLayoutTests.cs
@@ -401,6 +401,113 @@ public async Task TableMargins_CollapseWithTheirSiblings()
         Assert.Equal(40f, SingleFill(displayList, Yellow).Rect.Y);
     }
 
+    [Fact]
+    public async Task StrayTableCells_FormOneRowOfAnAnonymousTable()
+    {
+        var displayList = await LayoutAsync("""
+            <div style="display:table-cell; width:20px; height:10px; background-color:#ff0000"></div>
+            <div style="display:table-cell; width:30px; height:15px; background-color:#00ff00"></div>
+            <div style="height:5px; background-color:#0000ff"></div>
+            """);
+
+        // The anonymous table has the initial `border-spacing: 0`; cells stretch to the row.
+        Assert.Equal(new RenderRect(0f, 0f, 20f, 15f), SingleFill(displayList, Red).Rect);
+        Assert.Equal(new RenderRect(20f, 0f, 30f, 15f), SingleFill(displayList, Green).Rect);
+        Assert.Equal(15f, SingleFill(displayList, Blue).Rect.Y);
+    }
+
+    [Fact]
+    public async Task StrayTableRows_AreWrappedInAnAnonymousTableThatInheritsTableProperties()
+    {
+        var displayList = await LayoutAsync("""
+            <div style="border-spacing:5px">
+              <div style="display:table-row"><span style="display:table-cell; width:10px; height:10px; background-color:#ff0000"></span></div>
+              <div style="display:table-row"><span style="display:table-cell; width:10px; height:10px; background-color:#00ff00"></span></div>
+            </div>
+            """);
+
+        Assert.Equal(new RenderRect(5f, 5f, 10f, 10f), SingleFill(displayList, Red).Rect);
+        Assert.Equal(new RenderRect(5f, 20f, 10f, 10f), SingleFill(displayList, Green).Rect);
+    }
+
+    [Fact]
+    public async Task TextDirectlyInsideATable_IsWrappedInAnAnonymousRowAndCell()
+    {
+        var displayList = await LayoutAsync("""
+            <div style="display:table; border-spacing:0">
+              Hello
+              <div style="display:table-row"><div style="display:table-cell">World</div></div>
+            </div>
+            """);
+
+        var hello = SingleText(displayList, "Hello");
+        var world = SingleText(displayList, "World");
+
+        Assert.Equal(hello.X, world.X, precision: 2);
+        Assert.True(world.Y > hello.Y);
+    }
+
+    [Fact]
+    public async Task ContentInsideATableRow_IsWrappedInAnAnonymousCell()
+    {
+        var displayList = await LayoutAsync("""
+            <div style="display:table; border-spacing:0">
+              <div style="display:table-row">
+                <div style="display:table-cell; width:20px; height:10px; background-color:#ff0000"></div>
+                <span>tail</span>
+              </div>
+            </div>
+            """);
+
+        Assert.Equal(20f, SingleText(displayList, "tail").X, precision: 2);
+    }
+
+    [Fact]
+    public async Task WhiteSpaceBetweenStrayCells_DoesNotBreakTheRow()
+    {
+        var displayList = await LayoutAsync("""
+            <div>
+              before
+              <span style="display:table-cell; background-color:#ff0000">a</span>
+              <span style="display:table-cell; background-color:#00ff00">b</span>
+              after
+            </div>
+            """);
+
+        Assert.Equal(SingleFill(displayList, Red).Rect.Y, SingleFill(displayList, Green).Rect.Y);
+        Assert.True(SingleFill(displayList, Green).Rect.X > SingleFill(displayList, Red).Rect.X);
+        Assert.Single(displayList.Commands.OfType<DrawTextCommand>(), text => text.Text.Contains("before"));
+        Assert.Single(displayList.Commands.OfType<DrawTextCommand>(), text => text.Text.Contains("after"));
+    }
+
+    [Fact]
+    public async Task PercentageTableHeight_ResolvesAgainstADefiniteContainingBlockHeight()
+    {
+        var displayList = await LayoutAsync("""
+            <div style="height:200px">
+              <table style="height:50%; border-spacing:0; background-color:#ffff00">
+                <tr><td style="padding:0; width:10px; height:10px"></td></tr>
+              </table>
+            </div>
+            """);
+
+        Assert.Equal(100f, SingleFill(displayList, Yellow).Rect.Height);
+    }
+
+    [Fact]
+    public async Task PercentageTableHeight_IsAutoWithoutADefiniteContainingBlockHeight()
+    {
+        var displayList = await LayoutAsync("""
+            <div>
+              <table style="height:50%; border-spacing:0; background-color:#ffff00">
+                <tr><td style="padding:0; width:10px; height:10px"></td></tr>
+              </table>
+            </div>
+            """);
+
+        Assert.Equal(10f, SingleFill(displayList, Yellow).Rect.Height);
+    }
+
     private static async Task<DisplayList> LayoutAsync(string bodyHtml)
     {
         var context = BrowsingContext.New(Configuration.Default.WithCss());
diff --git a/src/AngleSharp.Renderer.Tests/TextShapingTests.cs b/src/AngleSharp.Renderer.Tests/TextShapingTests.cs
new file mode 100644
index 0000000..e997396
--- /dev/null
+++ b/src/AngleSharp.Renderer.Tests/TextShapingTests.cs
@@ -0,0 +1,365 @@
+namespace AngleSharp.Renderer.Tests;
+
+using AngleSharp;
+using AngleSharp.Css;
+using AngleSharp.Renderer.Rendering;
+using AngleSharp.Renderer.Skia;
+
+using SkiaSharp;
+
+/// <summary>
+/// Text is shaped with HarfBuzz: kerning, ligatures, joining and complex scripts, and the
+/// OpenType features CSS selects. Asserted through the measurer (advances and cluster
+/// boundaries), which is what layout sees, and through rendered pixels where only the glyphs
+/// themselves can tell.
+/// </summary>
+public sealed class TextShapingTests
+{
+    private static readonly RenderFont Sans = new("sans-serif", 32f, 400f, false, 0f);
+
+    private readonly SkiaTextMeasurer _measurer = new();
+
+    [Fact]
+    public void Kerning_TightensPairsAndCanBeTurnedOff()
+    {
+        var kerned = _measurer.MeasureWidth("AV", Sans);
+        var unkerned = _measurer.MeasureWidth("AV", Sans with { FontFeatures = "kern=0" });
+        var separate = _measurer.MeasureWidth("A", Sans) + _measurer.MeasureWidth("V", Sans);
+
+        Assert.True(kerned < unkerned, $"Expected kerning to tighten \"AV\" ({kerned:F2} vs {unkerned:F2}).");
+        Assert.Equal(separate, unkerned, tolerance: 0.01f);
+    }
+
+    [Theory]
+    [InlineData("fi")]
+    [InlineData("fl")]
+    public void StandardLigatures_FormOneCluster(string text)
+    {
+        Assert.Equal([0, 2], _measurer.GetClusterBoundaries(text, Sans));
+    }
+
+    [Theory]
+    [InlineData("liga=0", 0f)]
+    [InlineData(null, 2f)]
+    public void Ligatures_AreOffWithTheFeatureOrUnderLetterSpacing(string? features, float letterSpacing)
+    {
+        var font = Sans with { FontFeatures = features, LetterSpacing = letterSpacing };
+
+        Assert.Equal([0, 1, 2], _measurer.GetClusterBoundaries("fi", font));
+    }
+
+    [Fact]
+    public void Arabic_Joins()
+    {
+        var font = Sans with { IsRightToLeft = true };
+
+        // A zero-width non-joiner keeps the same letters apart, in their isolated forms.
+        var joined = _measurer.MeasureWidth("ببب", font);
+        var isolated = _measurer.MeasureWidth("ب‌ب‌ب", font);
+
+        Assert.True(joined < isolated, $"Expected joined beh to be narrower than isolated beh ({joined:F2} vs {isolated:F2}).");
+    }
+
+    [Fact]
+    public void LamAlef_IsOneLigature()
+    {
+        Assert.Equal([0, 2], _measurer.GetClusterBoundaries("لا", Sans with { IsRightToLeft = true }));
+    }
+
+    [Fact]
+    public void Devanagari_FormsConjuncts()
+    {
+        // "क्ष" (ka, virama, ssa) is one conjunct glyph cluster, narrower than its parts.
+        const string conjunct = "क्ष";
+
+        Assert.Equal([0, 3], _measurer.GetClusterBoundaries(conjunct, Sans));
+        Assert.True(_measurer.MeasureWidth(conjunct, Sans) < _measurer.MeasureWidth("क", Sans) + _measurer.MeasureWidth("ष", Sans));
+    }
+
+    [Fact]
+    public void RightToLeftRuns_ArePaintedInVisualOrder()
+    {
+        // Alef does not join the letter after it, so "اب" is two isolated letters: alef on the
+        // right, beh on the left. Painting them one by one, left to right, must give the same image.
+        var rtl = Sans with { IsRightToLeft = true };
+        var behWidth = _measurer.MeasureWidth("ب", Sans);
+
+        var shaped = Render(list => DrawText(list, "اب", 10f, rtl));
+        var manual = Render(list =>
+        {
+            DrawText(list, "ب", 10f, Sans);
+            DrawText(list, "ا", 10f + behWidth, Sans);
+        });
+
+        Assert.Equal(manual, shaped);
+    }
+
+    [Fact]
+    public void RightToLeftRuns_MirrorBrackets()
+    {
+        var mirrored = Render(list => DrawText(list, "(", 10f, Sans with { IsRightToLeft = true }));
+        var closing = Render(list => DrawText(list, ")", 10f, Sans));
+        var opening = Render(list => DrawText(list, "(", 10f, Sans));
+
+        Assert.Equal(closing, mirrored);
+        Assert.NotEqual(opening, mirrored);
+    }
+
+    [Fact]
+    public void Ligatures_ArePainted()
+    {
+        var ligature = Render(list => DrawText(list, "fi", 10f, Sans));
+        var separate = Render(list => DrawText(list, "fi", 10f, Sans with { FontFeatures = "liga=0" }));
+
+        Assert.NotEqual(separate, ligature);
+    }
+
+    [Theory]
+    [InlineData("font-feature-settings:\"liga\" 0", "liga=0")]
+    [InlineData("font-feature-settings:\"tnum\", \"zero\" on", "tnum=1,zero=1")]
+    [InlineData("font-kerning:none", "kern=0")]
+    [InlineData("font-variant-ligatures:no-common-ligatures", "liga=0,clig=0")]
+    [InlineData("font-variant-numeric:tabular-nums slashed-zero", "tnum,zero")]
+    [InlineData("font-kerning:none; font-feature-settings:\"kern\" 1", "kern=0,kern=1")]
+    public async Task FontProperties_SelectOpenTypeFeatures(string declarations, string expected)
+    {
+        var text = await LayoutSingleTextAsync($"<p style='{declarations}'>Text</p>");
+
+        Assert.Equal(expected, text.FontFeatures);
+    }
+
+    // AngleSharp.Css parses `font-variant-east-asian` from 1.3.1 on (verified against the sibling
+    // checkout); remove the skip once AngleSharpCssVersion is raised to it.
+    [Fact(Skip = "Needs AngleSharp.Css 1.3.1, which parses font-variant-east-asian")]
+    public async Task FontVariantEastAsian_SelectsOpenTypeFeatures()
+    {
+        var text = await LayoutSingleTextAsync("<p style='font-variant-east-asian:jis04 full-width ruby'>Text</p>");
+
+        Assert.Equal("jp04,fwid,ruby", text.FontFeatures);
+    }
+
+    [Fact]
+    public async Task FontFeatures_AreInherited()
+    {
+        var text = await LayoutSingleTextAsync("<div style='font-kerning:none'><p><span>Text</span></p></div>");
+
+        Assert.Equal("kern=0", text.FontFeatures);
+    }
+
+    [Fact]
+    public async Task FontFeatureSettings_Liga0TurnsLigaturesOffInLayout()
+    {
+        var withLigatures = await LayoutSingleTextAsync("<span style='font-size:32px'>ffi</span>");
+        var withoutLigatures = await LayoutSingleTextAsync("<span style='font-size:32px; font-feature-settings:\"liga\" 0'>ffi</span>");
+
+        Assert.Equal([0, 3], _measurer.GetClusterBoundaries("ffi", ToFont(withLigatures)));
+        Assert.Equal([0, 1, 2, 3], _measurer.GetClusterBoundaries("ffi", ToFont(withoutLigatures)));
+    }
+
+    [Fact]
+    public async Task ArabicParagraph_IsOneRightToLeftRunInLogicalOrder()
+    {
+        const string arabic = "مرحبا بالعالم";
+        var text = await LayoutSingleTextAsync($"<p dir='rtl' style='direction:rtl; width:300px'>{arabic}</p>");
+
+        Assert.Equal(arabic, text.Text);
+        Assert.True(text.IsRightToLeft);
+
+        // Right-aligned by its shaped width.
+        Assert.Equal(300f - _measurer.MeasureWidth(arabic, ToFont(text)), text.X, tolerance: 0.5f);
+    }
+
+    [Fact]
+    public async Task Ellipsis_CutsAtClusterBoundaries()
+    {
+        // A measurer that treats "ffi" as one cluster: the cut may fall before it or after it,
+        // never inside.
+        var measurer = new ClusteringMeasurer("ffi");
+        var context = BrowsingContext.New(Configuration.Default.WithCss());
+        var document = await context.OpenAsync(request => request.Content(
+            "<html><body style='margin:0'><p style='width:45px; white-space:nowrap; overflow:hidden; text-overflow:ellipsis'>affix and more</p></body></html>"));
+
+        var text = new HtmlRenderer(new SkiaRenderBackend(), measurer)
+            .BuildDisplayList(document, new DefaultRenderDevice { ViewPortWidth = 400, ViewPortHeight = 100, FontSize = 16f })
+            .Commands.OfType<DrawTextCommand>()
+            .Single();
+
+        Assert.True(text.Text is "a…" or "affi…" or "affix…" or "…", $"Truncated inside a cluster: \"{text.Text}\".");
+    }
+
+    [Theory]
+    [InlineData("\u0932", "mr")]
+    [InlineData("\u091D", "ne")]
+    public void Language_SelectsLocalizedForms(string letter, string language)
+    {
+        // Noto Sans Devanagari has Marathi and Nepali forms of these letters (`locl`).
+        Assert.NotEqual(_measurer.MeasureWidth(letter, Sans with { Language = "hi" }), _measurer.MeasureWidth(letter, Sans with { Language = language }));
+    }
+
+    [Fact]
+    public async Task LangAttribute_IsInheritedByTheText()
+    {
+        var context = BrowsingContext.New(Configuration.Default.WithCss());
+        var document = await context.OpenAsync(request => request.Content(
+            "<html lang='mr'><body style='margin:0'><p>a</p><p lang='ne'><span>b</span></p></body></html>"));
+
+        var texts = new HtmlRenderer()
+            .BuildDisplayList(document, new DefaultRenderDevice { ViewPortWidth = 400, ViewPortHeight = 200, FontSize = 16f })
+            .Commands.OfType<DrawTextCommand>()
+            .ToDictionary(command => command.Text, command => command.Language);
+
+        Assert.Equal("mr", texts["a"]);
+        Assert.Equal("ne", texts["b"]);
+    }
+
+    [Fact]
+    public void ShapingContext_GivesTheContextualForm()
+    {
+        const string beh = "\u0628";
+        var medial = Sans with { IsRightToLeft = true, ContextBefore = beh, ContextAfter = beh };
+
+        Assert.True(_measurer.MeasureWidth(beh, medial) < _measurer.MeasureWidth(beh, Sans with { IsRightToLeft = true }));
+    }
+
+    [Fact]
+    public async Task ArabicWord_JoinsAcrossElementBoundaries()
+    {
+        const string beh = "\u0628";
+        var texts = await LayoutTextsAsync($"<p dir='rtl' style='direction:rtl; width:300px'>{beh}<span style='color:red'>{beh}</span>{beh}</p>");
+
+        Assert.Equal(3, texts.Count);
+
+        var middle = Assert.Single(texts, text => text.Color.R == 255);
+        Assert.Equal(beh, middle.ContextBefore);
+        Assert.Equal(beh, middle.ContextAfter);
+
+        // The three pieces take exactly the width of the joined word, right-aligned.
+        var joined = _measurer.MeasureWidth(beh + beh + beh, Sans with { FontSize = 16f, IsRightToLeft = true });
+        Assert.Equal(300f - joined, texts.Min(text => text.X), tolerance: 0.5f);
+    }
+
+    [Fact]
+    public async Task CanvasFillText_IsShapedAndReordered()
+    {
+        // "אב 12" in a left-to-right paragraph: the digits stay left to right, left of the Hebrew.
+        var reordered = await RenderCanvasAsync(context => context.FillText("\u05d0\u05d1 12", 10f, 40f));
+        var manual = await RenderCanvasAsync(context =>
+        {
+            var font = new RenderFont("sans-serif", 24f, 400f, false, 0f);
+            context.FillText("12 ", 10f, 40f);
+            context.FillText("\u05d0\u05d1", 10f + _measurer.MeasureWidth("12 ", font), 40f);
+        });
+
+        Assert.Equal(manual, reordered);
+
+        var ligature = await RenderCanvasAsync(context => context.FillText("fi", 10f, 40f));
+        var shapedAsHtml = Render(list => list.DrawText("fi", 10f, 40f, RenderColor.Black, 24f, "sans-serif"), 100, 60, transparent: true);
+
+        Assert.Equal(shapedAsHtml, ligature);
+    }
+
+    [Fact]
+    public async Task SvgText_IsReorderedAndAnchoredByItsDirection()
+    {
+        // Right to left, "אב 12" ends at x (its start edge) and reads, from the left: "12", a
+        // space, then the Hebrew. Left to right, "12 אב" has that very visual order, so anchored
+        // at its end it has to cover the same pixels.
+        var rightToLeft = await RasterizeSvgAsync("<text x='150' y='40' direction='rtl'>\u05d0\u05d1 12</text>");
+        var leftToRight = await RasterizeSvgAsync("<text x='150' y='40' text-anchor='end'>12 \u05d0\u05d1</text>");
+        var startingAtX = await RasterizeSvgAsync("<text x='150' y='40'>12 \u05d0\u05d1</text>");
+
+        Assert.Equal(leftToRight, rightToLeft);
+        Assert.NotEqual(startingAtX, rightToLeft);
+        Assert.Contains(rightToLeft, value => value != 0);
+    }
+
+    private static RenderFont ToFont(DrawTextCommand command) =>
+        new(command.FontFamily, command.FontSize, command.FontWeight, command.IsItalic, command.LetterSpacing, null, command.FontStretch, command.IsRightToLeft, command.FontFeatures);
+
+    private static void DrawText(DisplayList list, string text, float x, RenderFont font) =>
+        list.DrawText(text, x, 40f, RenderColor.Black, font.FontSize, font.FontFamily, font.FontWeight, font.IsItalic,
+            letterSpacing: font.LetterSpacing, isRightToLeft: font.IsRightToLeft, fontFeatures: font.FontFeatures);
+
+    private static byte[] Render(Action<DisplayList> draw, int width = 120, int height = 60, bool transparent = false)
+    {
+        var list = new DisplayList();
+
+        if (!transparent)
+        {
+            list.FillRect(new RenderRect(0f, 0f, width, height), RenderColor.White);
+        }
+
+        draw(list);
+
+        var image = new SkiaRenderBackend().RenderToPng(list, new RenderViewport(width, height));
+        using var bitmap = SKBitmap.Decode(image.Data);
+        return bitmap.Bytes;
+    }
+
+    private static async Task<byte[]> RenderCanvasAsync(Action<Canvas2DRenderingContext> draw)
+    {
+        var browsingContext = BrowsingContext.New(Configuration.Default.WithCss());
+        var document = await browsingContext.OpenAsync(request => request.Content("<canvas width='100' height='60'></canvas>"));
+        var context = new Canvas2DRenderingContext((AngleSharp.Html.Dom.IHtmlCanvasElement)document.QuerySelector("canvas")!);
+        context.SetFont("24px sans-serif");
+        draw(context);
+
+        using var bitmap = SKBitmap.Decode(context.ToImage("image/png"));
+        return bitmap.Bytes;
+    }
+
+    private static async Task<byte[]> RasterizeSvgAsync(string content)
+    {
+        var browsingContext = BrowsingContext.New(Configuration.Default.WithCss());
+        var document = await browsingContext.OpenAsync(request => request.Content(
+            $"<html><body style='margin:0'><svg width='200' height='60' font-size='24'>{content}</svg></body></html>"));
+        var image = new HtmlRenderer()
+            .BuildDisplayList(document, new DefaultRenderDevice { ViewPortWidth = 300, ViewPortHeight = 100 })
+            .Commands.OfType<DrawImageCommand>()
+            .Single();
+
+        using var bitmap = SKBitmap.Decode(image.Image.Data);
+        return bitmap.Bytes;
+    }
+
+    private static async Task<List<DrawTextCommand>> LayoutTextsAsync(string bodyHtml)
+    {
+        var context = BrowsingContext.New(Configuration.Default.WithCss());
+        var document = await context.OpenAsync(request => request.Content($"<html><body style='margin:0'>{bodyHtml}</body></html>"));
+
+        return new HtmlRenderer()
+            .BuildDisplayList(document, new DefaultRenderDevice { ViewPortWidth = 400, ViewPortHeight = 200, FontSize = 16f })
+            .Commands.OfType<DrawTextCommand>()
+            .ToList();
+    }
+
+    private static async Task<DrawTextCommand> LayoutSingleTextAsync(string bodyHtml)
+    {
+        var context = BrowsingContext.New(Configuration.Default.WithCss());
+        var document = await context.OpenAsync(request => request.Content($"<html><body style='margin:0'>{bodyHtml}</body></html>"));
+
+        return new HtmlRenderer()
+            .BuildDisplayList(document, new DefaultRenderDevice { ViewPortWidth = 400, ViewPortHeight = 200, FontSize = 16f })
+            .Commands.OfType<DrawTextCommand>()
+            .Single();
+    }
+
+    private sealed class ClusteringMeasurer(string cluster) : ITextMeasurer
+    {
+        public float MeasureWidth(string text, RenderFont font) => text.Length * 8f;
+
+        public IReadOnlyList<int> GetClusterBoundaries(string text, RenderFont font)
+        {
+            var boundaries = new List<int> { 0 };
+            var index = 0;
+
+            while (index < text.Length)
+            {
+                index += text.AsSpan(index).StartsWith(cluster) ? cluster.Length : 1;
+                boundaries.Add(index);
+            }
+
+            return boundaries;
+        }
+    }
+}
diff --git a/src/AngleSharp.Renderer.Tests/VisualConformanceTests.cs b/src/AngleSharp.Renderer.Tests/VisualConformanceTests.cs
index 05912de..76f033f 100644
--- a/src/AngleSharp.Renderer.Tests/VisualConformanceTests.cs
+++ b/src/AngleSharp.Renderer.Tests/VisualConformanceTests.cs
@@ -2794,6 +2794,42 @@ public async Task RenderToPng_RendersMultiColumnLayout()
           maxDifferentPixels: TextRenderingToleranceMaxPixels);
     }
 
+    [Fact]
+    public async Task RenderToPng_RendersShapedText()
+    {
+        var document = await ParseAsync("""
+            <html>
+              <head>
+                <style>
+                  html, body { margin: 0; padding: 0; background-color: white; font-family: sans-serif; font-size: 20px; }
+                  p { margin: 4px 8px; }
+                  .off { font-feature-settings: "liga" 0, "kern" 0; }
+                </style>
+              </head>
+              <body>
+                <p>office flow AVATAR Wolf</p>
+                <p class="off">office flow AVATAR Wolf</p>
+                <p dir="rtl" style="direction: rtl">مرحبا بالعالم (لا)</p>
+                <p>नमस्ते क्षत्रिय</p>
+              </body>
+            </html>
+            """);
+
+        var renderer = new HtmlRenderer();
+        var image = renderer.RenderToPng(document, new DefaultRenderDevice
+        {
+            ViewPortWidth = 300,
+            ViewPortHeight = 150,
+            FontSize = 20f,
+        });
+
+        VisualSnapshotVerifier.VerifyOrCreate(
+          snapshotName: "renders-shaped-text.png",
+          actualPng: image.Data,
+          perChannelTolerance: TextRenderingToleranceChannel,
+          maxDifferentPixels: TextRenderingToleranceMaxPixels);
+    }
+
     [Fact]
     public async Task RenderToPng_RendersBlendModesBackgroundClipAndOutlineOffset()
     {
@@ -3114,6 +3150,178 @@ public async Task RenderToPng_BorderBoxSizingKeepsTheDeclaredWidthInsteadOfAddin
           maxDifferentPixels: 0);
     }
 
+    [Fact]
+    public async Task RenderToPng_AlignsGridTracksWithinTheContainer()
+    {
+        var document = await ParseAsync("""
+            <html>
+              <head><style>html, body { margin: 0; padding: 0; } .grid { display:grid; grid-template-columns:20px 20px; grid-template-rows:20px 20px; gap:4px; width:100px; height:80px; margin-bottom:10px; background-color:rgb(230,230,230); } .grid div { background-color:rgb(0,0,200); }</style></head>
+              <body>
+                <div class="grid" style="justify-content:center; align-content:center"><div></div><div></div><div></div><div></div></div>
+                <div class="grid" style="justify-content:space-between; align-content:end"><div></div><div></div><div></div><div></div></div>
+                <div class="grid" style="justify-content:space-evenly; align-content:space-around"><div></div><div></div><div></div><div></div></div>
+              </body>
+            </html>
+            """);
+
+        var image = new HtmlRenderer().RenderToPng(document, new DefaultRenderDevice { ViewPortWidth = 120, ViewPortHeight = 280 });
+
+        VisualSnapshotVerifier.VerifyOrCreate(
+          snapshotName: "aligns-grid-tracks-within-the-container.png",
+          actualPng: image.Data,
+          perChannelTolerance: 0,
+          maxDifferentPixels: 0);
+    }
+
+    [Fact]
+    public async Task RenderToPng_MovesLinesDownPastFloatsTheyDoNotFitBeside()
+    {
+        // the 80px boxes are the "words": 50px are free beside the first float, 100px beside the second
+        var document = await ParseAsync("""
+            <html>
+              <head><style>html, body { margin: 0; padding: 0; } span { display:inline-block; width:80px; height:20px; vertical-align:top; }</style></head>
+              <body>
+                <div style="width:200px; line-height:20px; font-size:0">
+                  <div style="float:left; width:150px; height:30px; background-color:rgb(255,0,0)"></div>
+                  <div style="float:left; clear:left; width:100px; height:30px; background-color:rgb(255,165,0)"></div>
+                  <span style="background-color:rgb(0,0,200)"></span>
+                  <span style="background-color:rgb(0,180,0)"></span>
+                  <span style="background-color:rgb(150,0,150)"></span>
+                </div>
+              </body>
+            </html>
+            """);
+
+        var image = new HtmlRenderer().RenderToPng(document, new DefaultRenderDevice { ViewPortWidth = 200, ViewPortHeight = 120 });
+
+        VisualSnapshotVerifier.VerifyOrCreate(
+          snapshotName: "moves-lines-down-past-floats-they-do-not-fit-beside.png",
+          actualPng: image.Data,
+          perChannelTolerance: 0,
+          maxDifferentPixels: 0);
+    }
+
+    [Fact]
+    public async Task RenderToPng_LineClampCountsTheLinesOfNestedBlocks()
+    {
+        // transparent text on fixed lines: the paragraphs' backgrounds show which lines are kept
+        var document = await ParseAsync("""
+            <html>
+              <head><style>html, body { margin: 0; padding: 0; } p { margin:0; color:transparent }</style></head>
+              <body>
+                <div style="overflow:hidden; -webkit-line-clamp:3; width:100px; line-height:20px; background-color:rgb(230,230,230)">
+                  <p style="background-color:rgb(255,0,0)">a</p>
+                  <p style="background-color:rgb(0,180,0)">b<br>c<br>d</p>
+                  <p style="background-color:rgb(0,0,200)">e</p>
+                </div>
+              </body>
+            </html>
+            """);
+
+        var image = new HtmlRenderer().RenderToPng(document, new DefaultRenderDevice { ViewPortWidth = 120, ViewPortHeight = 120 });
+
+        VisualSnapshotVerifier.VerifyOrCreate(
+          snapshotName: "line-clamp-counts-the-lines-of-nested-blocks.png",
+          actualPng: image.Data,
+          perChannelTolerance: 0,
+          maxDifferentPixels: 0);
+    }
+
+    [Fact]
+    public async Task RenderToPng_LaysOutFlexGridAndTableContainersInTheirOwnWritingMode()
+    {
+        var document = await ParseAsync("""
+            <html>
+              <head><style>html, body { margin: 0; padding: 0; } td { padding:0; width:20px; height:20px; }</style></head>
+              <body style="display:flex; gap:10px; align-items:flex-start">
+                <div style="display:flex; writing-mode:vertical-rl; gap:5px; height:100px; padding:5px; background-color:rgb(230,230,230)">
+                  <div style="width:20px; height:20px; background-color:rgb(255,0,0)"></div>
+                  <div style="width:30px; height:30px; background-color:rgb(0,180,0)"></div>
+                  <div style="width:20px; height:20px; background-color:rgb(0,0,200)"></div>
+                </div>
+                <div style="display:grid; writing-mode:vertical-rl; grid-template-columns:20px 30px; grid-template-rows:20px 30px; padding:5px; background-color:rgb(230,230,230)">
+                  <div style="background-color:rgb(255,0,0)"></div><div style="background-color:rgb(0,180,0)"></div><div style="background-color:rgb(0,0,200)"></div>
+                </div>
+                <table style="writing-mode:vertical-rl; border-spacing:5px; background-color:rgb(230,230,230)">
+                  <tr><td style="background-color:rgb(255,0,0)"></td><td style="background-color:rgb(0,180,0)"></td></tr>
+                  <tr><td style="background-color:rgb(0,0,200)"></td><td></td></tr>
+                </table>
+              </body>
+            </html>
+            """);
+
+        var image = new HtmlRenderer().RenderToPng(document, new DefaultRenderDevice { ViewPortWidth = 220, ViewPortHeight = 120 });
+
+        VisualSnapshotVerifier.VerifyOrCreate(
+          snapshotName: "lays-out-flex-grid-and-table-containers-in-their-own-writing-mode.png",
+          actualPng: image.Data,
+          perChannelTolerance: 0,
+          maxDifferentPixels: 0);
+    }
+
+    [Fact]
+    public async Task RenderToPng_NestedVerticalLrStacksItsBlocksTheOtherWay()
+    {
+        var document = await ParseAsync("""
+            <html>
+              <head><style>html, body { margin: 0; padding: 0; } i { display:block; width:20px; height:20px; }</style></head>
+              <body>
+                <div style="writing-mode:vertical-rl; width:160px; height:60px; background-color:rgb(230,230,230)">
+                  <i style="background-color:rgb(255,0,0)"></i>
+                  <div style="writing-mode:vertical-lr; background-color:rgb(255,220,150)">
+                    <i style="background-color:rgb(0,180,0)"></i>
+                    <i style="width:30px; background-color:rgb(0,0,200)"></i>
+                  </div>
+                  <i style="background-color:rgb(255,0,0)"></i>
+                </div>
+              </body>
+            </html>
+            """);
+
+        var image = new HtmlRenderer().RenderToPng(document, new DefaultRenderDevice { ViewPortWidth = 160, ViewPortHeight = 60 });
+
+        VisualSnapshotVerifier.VerifyOrCreate(
+          snapshotName: "nested-vertical-lr-stacks-its-blocks-the-other-way.png",
+          actualPng: image.Data,
+          perChannelTolerance: 0,
+          maxDifferentPixels: 0);
+    }
+
+    [Fact]
+    public async Task RenderToPng_StickyBoxInVerticalFlowStaysPinnedWhileScrolledPastIt()
+    {
+        var renderDevice = new DefaultRenderDevice
+        {
+            ViewPortWidth = 100,
+            ViewPortHeight = 100,
+            DeviceWidth = 100,
+            DeviceHeight = 100,
+            FontSize = 16,
+        };
+        var configuration = Configuration.Default.WithCss().WithRenderDevice(renderDevice);
+        var document = await ParseAsync("""
+            <html>
+              <head><style>html, body { margin: 0; padding: 0; }</style></head>
+              <body>
+                <div style="writing-mode:vertical-rl; width:100px; height:400px; background-image:linear-gradient(rgb(255,255,0), rgb(0,180,0))">
+                  <div style="position:sticky; top:10px; width:40px; height:30px; background-color:rgb(0,0,200)"></div>
+                </div>
+              </body>
+            </html>
+            """, configuration);
+
+        document.Context.GetDomHarness();
+        document.DocumentElement.SetScrollTop(150);
+
+        var image = new HtmlRenderer().RenderToPng(document, renderDevice);
+
+        VisualSnapshotVerifier.VerifyOrCreate(
+          snapshotName: "sticky-box-in-vertical-flow-stays-pinned-while-scrolled-past-it.png",
+          actualPng: image.Data,
+          perChannelTolerance: 0,
+          maxDifferentPixels: 0);
+    }
+
     private static async Task<AngleSharp.Dom.IDocument> ParseAsync(string html, IConfiguration? configuration = null)
     {
         var context = BrowsingContext.New(configuration ?? Configuration.Default.WithCss());
diff --git a/src/AngleSharp.Renderer.Tests/WritingModeTests.cs b/src/AngleSharp.Renderer.Tests/WritingModeTests.cs
index 96c3806..36a45b8 100644
--- a/src/AngleSharp.Renderer.Tests/WritingModeTests.cs
+++ b/src/AngleSharp.Renderer.Tests/WritingModeTests.cs
@@ -2,6 +2,7 @@ namespace AngleSharp.Renderer.Tests;
 
 using AngleSharp;
 using AngleSharp.Css;
+using AngleSharp.Dom;
 using AngleSharp.Renderer.Rendering;
 
 /// <summary>
@@ -195,6 +196,159 @@ public async Task VerticalFloat_IsAsWideAsItsLines()
         Assert.Equal(await HorizontalLineHeightAsync(), PhysicalRect(displayList, SingleFill(displayList, Red)).Width, precision: 2);
     }
 
+    [Fact]
+    public async Task VerticalLrInVerticalRl_StacksItsBlocksLeftToRight()
+    {
+        var displayList = await LayoutAsync("""
+            <div style="writing-mode:vertical-rl; width:200px; height:100px">
+                <div style="width:20px; height:20px; background-color:#ff0000"></div>
+                <div style="writing-mode:vertical-lr">
+                    <div style="width:20px; height:20px; background-color:#00ff00"></div>
+                    <div style="width:20px; height:20px; background-color:#0000ff"></div>
+                </div>
+            </div>
+            """);
+
+        // the outer blocks stack from the right; the inner box takes the next 40px and stacks its own from its left
+        Assert.Equal(new RenderRect(180f, 0f, 20f, 20f), PhysicalRect(displayList, SingleFill(displayList, Red)));
+        Assert.Equal(new RenderRect(140f, 0f, 20f, 20f), PhysicalRect(displayList, SingleFill(displayList, Green)));
+        Assert.Equal(new RenderRect(160f, 0f, 20f, 20f), PhysicalRect(displayList, SingleFill(displayList, Blue)));
+    }
+
+    [Fact]
+    public async Task VerticalRlInVerticalLr_StacksItsBlocksRightToLeft()
+    {
+        var displayList = await LayoutAsync("""
+            <div style="writing-mode:vertical-lr; width:200px; height:100px">
+                <div style="width:20px; height:20px; background-color:#ff0000"></div>
+                <div style="writing-mode:vertical-rl; width:60px">
+                    <div style="width:20px; height:20px; background-color:#00ff00"></div>
+                    <div style="width:20px; height:20px; background-color:#0000ff"></div>
+                </div>
+            </div>
+            """);
+
+        Assert.Equal(new RenderRect(0f, 0f, 20f, 20f), PhysicalRect(displayList, SingleFill(displayList, Red)));
+        Assert.Equal(new RenderRect(60f, 0f, 20f, 20f), PhysicalRect(displayList, SingleFill(displayList, Green)));
+        Assert.Equal(new RenderRect(40f, 0f, 20f, 20f), PhysicalRect(displayList, SingleFill(displayList, Blue)));
+    }
+
+    [Fact]
+    public async Task StickyInVerticalFlow_PinsToThePhysicalTopOnceScrolledPastIt()
+    {
+        // `top` is the inline-start inset of a box in vertical-rl content: it sticks along the inline axis
+        var displayList = await LayoutAsync("""
+            <div style="writing-mode:vertical-rl; width:100px; height:600px">
+                <div style="position:sticky; top:10px; width:30px; height:40px; background-color:#00ff00"></div>
+            </div>
+            """, scrollTop: 200);
+
+        Assert.Equal(new RenderRect(70f, 10f, 30f, 40f), PhysicalRect(displayList, SingleFill(displayList, Green)));
+    }
+
+    [Fact]
+    public async Task StickyInVerticalFlow_StaysInsideItsContainingBlock()
+    {
+        var displayList = await LayoutAsync("""
+            <div style="writing-mode:vertical-rl; width:100px; height:300px">
+                <div style="position:sticky; top:10px; width:30px; height:40px; background-color:#00ff00"></div>
+            </div>
+            <div style="height:600px"></div>
+            """, scrollTop: 280);
+
+        // the flow ends 20px below the viewport top, so the box cannot stick further than its end
+        Assert.Equal(new RenderRect(70f, -20f, 30f, 40f), PhysicalRect(displayList, SingleFill(displayList, Green)));
+    }
+
+    [Fact]
+    public async Task StickyInVerticalPage_PinsToThePhysicalTop()
+    {
+        var displayList = await LayoutAsync("""
+            <style>html { writing-mode: vertical-rl }</style>
+            <div style="width:30px; height:900px">
+                <div style="position:sticky; top:10px; width:30px; height:40px; background-color:#00ff00"></div>
+            </div>
+            """, scrollTop: 200);
+
+        Assert.Equal(10f, PhysicalRect(displayList, SingleFill(displayList, Green)).Y, precision: 2);
+    }
+
+    [Fact]
+    public async Task VerticalFlexContainer_RunsItsMainAxisDownwards()
+    {
+        var displayList = await LayoutAsync("""
+            <div style="display:flex; writing-mode:vertical-rl; width:100px; height:200px">
+                <div style="width:30px; height:20px; background-color:#ff0000"></div>
+                <div style="width:30px; height:40px; background-color:#00ff00"></div>
+            </div>
+            """);
+
+        // the main axis is the container's inline axis (down), the cross axis its block axis (leftwards)
+        Assert.Equal(new RenderRect(70f, 0f, 30f, 20f), PhysicalRect(displayList, SingleFill(displayList, Red)));
+        Assert.Equal(new RenderRect(70f, 20f, 30f, 40f), PhysicalRect(displayList, SingleFill(displayList, Green)));
+    }
+
+    [Fact]
+    public async Task VerticalGridContainer_PlacesColumnsDownwardsAndRowsLeftwards()
+    {
+        var displayList = await LayoutAsync("""
+            <div style="display:grid; writing-mode:vertical-rl; grid-template-columns:20px 30px; grid-template-rows:40px; width:100px; height:200px">
+                <div style="background-color:#ff0000"></div>
+                <div style="background-color:#00ff00"></div>
+            </div>
+            """);
+
+        // columns run along the inline axis (down), rows along the block axis (from the right)
+        Assert.Equal(new RenderRect(60f, 0f, 40f, 20f), PhysicalRect(displayList, SingleFill(displayList, Red)));
+        Assert.Equal(new RenderRect(60f, 20f, 40f, 30f), PhysicalRect(displayList, SingleFill(displayList, Green)));
+    }
+
+    [Fact]
+    public async Task VerticalGridContainer_IsAsWideAsItsRowsAsAFlexItem()
+    {
+        var displayList = await LayoutAsync("""
+            <div style="display:flex">
+                <div style="display:grid; writing-mode:vertical-rl; grid-template-columns:20px 30px; grid-template-rows:40px 25px; background-color:#ff0000"></div>
+            </div>
+            """);
+
+        // its width is the block size of its rows, its height the inline size of its columns
+        Assert.Equal(new RenderRect(0f, 0f, 65f, 50f), PhysicalRect(displayList, SingleFill(displayList, Red)));
+    }
+
+    [Fact]
+    public async Task VerticalTable_PutsRowsSideBySideFromTheRight()
+    {
+        var displayList = await LayoutAsync("""
+            <table style="writing-mode:vertical-rl; border-spacing:0">
+                <tr><td style="padding:0; width:30px; height:20px; background-color:#ff0000"></td><td style="padding:0; width:30px; height:40px; background-color:#00ff00"></td></tr>
+                <tr><td style="padding:0; width:10px; height:20px; background-color:#0000ff"></td><td style="padding:0"></td></tr>
+            </table>
+            """);
+
+        // rows are columns from the right, the cells of a row go down
+        Assert.Equal(new RenderRect(10f, 0f, 30f, 20f), PhysicalRect(displayList, SingleFill(displayList, Red)));
+        Assert.Equal(new RenderRect(10f, 20f, 30f, 40f), PhysicalRect(displayList, SingleFill(displayList, Green)));
+        Assert.Equal(new RenderRect(0f, 0f, 10f, 20f), PhysicalRect(displayList, SingleFill(displayList, Blue)));
+    }
+
+    [Fact]
+    public async Task HorizontalFlexContainerInVerticalContent_RunsItsMainAxisToTheRight()
+    {
+        var displayList = await LayoutAsync("""
+            <div style="writing-mode:vertical-rl; width:200px; height:100px">
+                <div style="display:flex; writing-mode:horizontal-tb; width:100px; height:30px">
+                    <div style="width:20px; background-color:#ff0000"></div>
+                    <div style="width:40px; background-color:#00ff00"></div>
+                </div>
+            </div>
+            """);
+
+        // the horizontal box is the first block of the vertical content (at its right), its items run rightwards
+        Assert.Equal(new RenderRect(100f, 0f, 20f, 30f), PhysicalRect(displayList, SingleFill(displayList, Red)));
+        Assert.Equal(new RenderRect(120f, 0f, 40f, 30f), PhysicalRect(displayList, SingleFill(displayList, Green)));
+    }
+
     /// <summary>The height of one line of the same text laid out horizontally.</summary>
     private static async Task<float> HorizontalLineHeightAsync()
     {
@@ -202,17 +356,24 @@ private static async Task<float> HorizontalLineHeightAsync()
         return MathF.Round(SingleFill(displayList, Red).Rect.Height, 2);
     }
 
-    private static async Task<DisplayList> LayoutAsync(string bodyHtml)
+    private static async Task<DisplayList> LayoutAsync(string bodyHtml, double scrollTop = 0)
     {
-        var context = BrowsingContext.New(Configuration.Default.WithCss());
-        var document = await context.OpenAsync(request => request.Content($"<html><body style=\"margin:0\">{bodyHtml}</body></html>"));
-
-        return new HtmlRenderer().BuildDisplayList(document, new DefaultRenderDevice
+        var renderDevice = new DefaultRenderDevice
         {
             ViewPortWidth = 400,
             ViewPortHeight = 300,
             FontSize = 16f,
-        });
+        };
+        var context = BrowsingContext.New(Configuration.Default.WithCss().WithRenderDevice(renderDevice));
+        var document = await context.OpenAsync(request => request.Content($"<html><body style=\"margin:0\">{bodyHtml}</body></html>"));
+
+        if (scrollTop > 0)
+        {
+            context.GetDomHarness();
+            document.DocumentElement.SetScrollTop(scrollTop);
+        }
+
+        return new HtmlRenderer().BuildDisplayList(document, renderDevice);
     }
 
     /// <summary>The composition of every transform open around <paramref name="target"/>.</summary>
diff --git a/src/AngleSharp.Renderer.Tests/rendered-cases/test01-box-model.png b/src/AngleSharp.Renderer.Tests/rendered-cases/test01-box-model.png
index f0d4d09..7b2c249 100644
Binary files a/src/AngleSharp.Renderer.Tests/rendered-cases/test01-box-model.png and b/src/AngleSharp.Renderer.Tests/rendered-cases/test01-box-model.png differ
diff --git a/src/AngleSharp.Renderer.Tests/rendered-cases/test02-typography-inline.png b/src/AngleSharp.Renderer.Tests/rendered-cases/test02-typography-inline.png
index be8cbcb..c3209e3 100644
Binary files a/src/AngleSharp.Renderer.Tests/rendered-cases/test02-typography-inline.png and b/src/AngleSharp.Renderer.Tests/rendered-cases/test02-typography-inline.png differ
diff --git a/src/AngleSharp.Renderer.Tests/rendered-cases/test03-flexbox.png b/src/AngleSharp.Renderer.Tests/rendered-cases/test03-flexbox.png
index e183657..e17c37f 100644
Binary files a/src/AngleSharp.Renderer.Tests/rendered-cases/test03-flexbox.png and b/src/AngleSharp.Renderer.Tests/rendered-cases/test03-flexbox.png differ
diff --git a/src/AngleSharp.Renderer.Tests/rendered-cases/test05-positioning-stacking.png b/src/AngleSharp.Renderer.Tests/rendered-cases/test05-positioning-stacking.png
index 67d1dd4..9f81b74 100644
Binary files a/src/AngleSharp.Renderer.Tests/rendered-cases/test05-positioning-stacking.png and b/src/AngleSharp.Renderer.Tests/rendered-cases/test05-positioning-stacking.png differ
diff --git a/src/AngleSharp.Renderer.Tests/rendered-cases/test06-overflow-visuals.png b/src/AngleSharp.Renderer.Tests/rendered-cases/test06-overflow-visuals.png
index 79e8067..e1b0d04 100644
Binary files a/src/AngleSharp.Renderer.Tests/rendered-cases/test06-overflow-visuals.png and b/src/AngleSharp.Renderer.Tests/rendered-cases/test06-overflow-visuals.png differ
diff --git a/src/AngleSharp.Renderer.Tests/rendered-cases/test07-replaced-elements.png b/src/AngleSharp.Renderer.Tests/rendered-cases/test07-replaced-elements.png
index 7309f92..4860f92 100644
Binary files a/src/AngleSharp.Renderer.Tests/rendered-cases/test07-replaced-elements.png and b/src/AngleSharp.Renderer.Tests/rendered-cases/test07-replaced-elements.png differ
diff --git a/src/AngleSharp.Renderer.Tests/rendered-cases/test08-torture.png b/src/AngleSharp.Renderer.Tests/rendered-cases/test08-torture.png
index dc2d44b..0c63b4c 100644
Binary files a/src/AngleSharp.Renderer.Tests/rendered-cases/test08-torture.png and b/src/AngleSharp.Renderer.Tests/rendered-cases/test08-torture.png differ
diff --git a/src/AngleSharp.Renderer.Tests/rendered-cases/test09-writing-modes.png b/src/AngleSharp.Renderer.Tests/rendered-cases/test09-writing-modes.png
index 2615061..159ba89 100644
Binary files a/src/AngleSharp.Renderer.Tests/rendered-cases/test09-writing-modes.png and b/src/AngleSharp.Renderer.Tests/rendered-cases/test09-writing-modes.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/aligned-wrapped-text-with-line-height.linux.png b/src/AngleSharp.Renderer.Tests/verification-assets/aligned-wrapped-text-with-line-height.linux.png
index a1ce136..44171dd 100644
Binary files a/src/AngleSharp.Renderer.Tests/verification-assets/aligned-wrapped-text-with-line-height.linux.png and b/src/AngleSharp.Renderer.Tests/verification-assets/aligned-wrapped-text-with-line-height.linux.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/aligned-wrapped-text-with-line-height.macos.png b/src/AngleSharp.Renderer.Tests/verification-assets/aligned-wrapped-text-with-line-height.macos.png
index 7260775..fffe9cb 100644
Binary files a/src/AngleSharp.Renderer.Tests/verification-assets/aligned-wrapped-text-with-line-height.macos.png and b/src/AngleSharp.Renderer.Tests/verification-assets/aligned-wrapped-text-with-line-height.macos.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/aligned-wrapped-text-with-line-height.windows.png b/src/AngleSharp.Renderer.Tests/verification-assets/aligned-wrapped-text-with-line-height.windows.png
index eafe938..6a9c18b 100644
Binary files a/src/AngleSharp.Renderer.Tests/verification-assets/aligned-wrapped-text-with-line-height.windows.png and b/src/AngleSharp.Renderer.Tests/verification-assets/aligned-wrapped-text-with-line-height.windows.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/aligns-grid-tracks-within-the-container.linux.png b/src/AngleSharp.Renderer.Tests/verification-assets/aligns-grid-tracks-within-the-container.linux.png
new file mode 100644
index 0000000..0a24cdd
Binary files /dev/null and b/src/AngleSharp.Renderer.Tests/verification-assets/aligns-grid-tracks-within-the-container.linux.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/aligns-grid-tracks-within-the-container.macos.png b/src/AngleSharp.Renderer.Tests/verification-assets/aligns-grid-tracks-within-the-container.macos.png
new file mode 100644
index 0000000..0a24cdd
Binary files /dev/null and b/src/AngleSharp.Renderer.Tests/verification-assets/aligns-grid-tracks-within-the-container.macos.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/aligns-grid-tracks-within-the-container.windows.png b/src/AngleSharp.Renderer.Tests/verification-assets/aligns-grid-tracks-within-the-container.windows.png
new file mode 100644
index 0000000..0a24cdd
Binary files /dev/null and b/src/AngleSharp.Renderer.Tests/verification-assets/aligns-grid-tracks-within-the-container.windows.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/compares-list-style-position-inside-and-outside.linux.png b/src/AngleSharp.Renderer.Tests/verification-assets/compares-list-style-position-inside-and-outside.linux.png
index 34b1d68..d51a005 100644
Binary files a/src/AngleSharp.Renderer.Tests/verification-assets/compares-list-style-position-inside-and-outside.linux.png and b/src/AngleSharp.Renderer.Tests/verification-assets/compares-list-style-position-inside-and-outside.linux.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/compares-list-style-position-inside-and-outside.macos.png b/src/AngleSharp.Renderer.Tests/verification-assets/compares-list-style-position-inside-and-outside.macos.png
index c937e52..10bd65d 100644
Binary files a/src/AngleSharp.Renderer.Tests/verification-assets/compares-list-style-position-inside-and-outside.macos.png and b/src/AngleSharp.Renderer.Tests/verification-assets/compares-list-style-position-inside-and-outside.macos.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/compares-list-style-position-inside-and-outside.windows.png b/src/AngleSharp.Renderer.Tests/verification-assets/compares-list-style-position-inside-and-outside.windows.png
index eef9b1d..6fa0509 100644
Binary files a/src/AngleSharp.Renderer.Tests/verification-assets/compares-list-style-position-inside-and-outside.windows.png and b/src/AngleSharp.Renderer.Tests/verification-assets/compares-list-style-position-inside-and-outside.windows.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/lays-out-flex-grid-and-table-containers-in-their-own-writing-mode.linux.png b/src/AngleSharp.Renderer.Tests/verification-assets/lays-out-flex-grid-and-table-containers-in-their-own-writing-mode.linux.png
new file mode 100644
index 0000000..0b5e117
Binary files /dev/null and b/src/AngleSharp.Renderer.Tests/verification-assets/lays-out-flex-grid-and-table-containers-in-their-own-writing-mode.linux.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/lays-out-flex-grid-and-table-containers-in-their-own-writing-mode.macos.png b/src/AngleSharp.Renderer.Tests/verification-assets/lays-out-flex-grid-and-table-containers-in-their-own-writing-mode.macos.png
new file mode 100644
index 0000000..0b5e117
Binary files /dev/null and b/src/AngleSharp.Renderer.Tests/verification-assets/lays-out-flex-grid-and-table-containers-in-their-own-writing-mode.macos.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/lays-out-flex-grid-and-table-containers-in-their-own-writing-mode.windows.png b/src/AngleSharp.Renderer.Tests/verification-assets/lays-out-flex-grid-and-table-containers-in-their-own-writing-mode.windows.png
new file mode 100644
index 0000000..0b5e117
Binary files /dev/null and b/src/AngleSharp.Renderer.Tests/verification-assets/lays-out-flex-grid-and-table-containers-in-their-own-writing-mode.windows.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/line-clamp-counts-the-lines-of-nested-blocks.linux.png b/src/AngleSharp.Renderer.Tests/verification-assets/line-clamp-counts-the-lines-of-nested-blocks.linux.png
new file mode 100644
index 0000000..cef0f05
Binary files /dev/null and b/src/AngleSharp.Renderer.Tests/verification-assets/line-clamp-counts-the-lines-of-nested-blocks.linux.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/line-clamp-counts-the-lines-of-nested-blocks.macos.png b/src/AngleSharp.Renderer.Tests/verification-assets/line-clamp-counts-the-lines-of-nested-blocks.macos.png
new file mode 100644
index 0000000..cef0f05
Binary files /dev/null and b/src/AngleSharp.Renderer.Tests/verification-assets/line-clamp-counts-the-lines-of-nested-blocks.macos.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/line-clamp-counts-the-lines-of-nested-blocks.windows.png b/src/AngleSharp.Renderer.Tests/verification-assets/line-clamp-counts-the-lines-of-nested-blocks.windows.png
new file mode 100644
index 0000000..cef0f05
Binary files /dev/null and b/src/AngleSharp.Renderer.Tests/verification-assets/line-clamp-counts-the-lines-of-nested-blocks.windows.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/mixed-text-sizes-styles-decorations.linux.png b/src/AngleSharp.Renderer.Tests/verification-assets/mixed-text-sizes-styles-decorations.linux.png
index 5d98e4f..fca5356 100644
Binary files a/src/AngleSharp.Renderer.Tests/verification-assets/mixed-text-sizes-styles-decorations.linux.png and b/src/AngleSharp.Renderer.Tests/verification-assets/mixed-text-sizes-styles-decorations.linux.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/mixed-text-sizes-styles-decorations.macos.png b/src/AngleSharp.Renderer.Tests/verification-assets/mixed-text-sizes-styles-decorations.macos.png
index cd619bb..ed773f3 100644
Binary files a/src/AngleSharp.Renderer.Tests/verification-assets/mixed-text-sizes-styles-decorations.macos.png and b/src/AngleSharp.Renderer.Tests/verification-assets/mixed-text-sizes-styles-decorations.macos.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/mixed-text-sizes-styles-decorations.windows.png b/src/AngleSharp.Renderer.Tests/verification-assets/mixed-text-sizes-styles-decorations.windows.png
index 4a8137b..2a0c2df 100644
Binary files a/src/AngleSharp.Renderer.Tests/verification-assets/mixed-text-sizes-styles-decorations.windows.png and b/src/AngleSharp.Renderer.Tests/verification-assets/mixed-text-sizes-styles-decorations.windows.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/moves-lines-down-past-floats-they-do-not-fit-beside.linux.png b/src/AngleSharp.Renderer.Tests/verification-assets/moves-lines-down-past-floats-they-do-not-fit-beside.linux.png
new file mode 100644
index 0000000..fe224d6
Binary files /dev/null and b/src/AngleSharp.Renderer.Tests/verification-assets/moves-lines-down-past-floats-they-do-not-fit-beside.linux.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/moves-lines-down-past-floats-they-do-not-fit-beside.macos.png b/src/AngleSharp.Renderer.Tests/verification-assets/moves-lines-down-past-floats-they-do-not-fit-beside.macos.png
new file mode 100644
index 0000000..fe224d6
Binary files /dev/null and b/src/AngleSharp.Renderer.Tests/verification-assets/moves-lines-down-past-floats-they-do-not-fit-beside.macos.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/moves-lines-down-past-floats-they-do-not-fit-beside.windows.png b/src/AngleSharp.Renderer.Tests/verification-assets/moves-lines-down-past-floats-they-do-not-fit-beside.windows.png
new file mode 100644
index 0000000..fe224d6
Binary files /dev/null and b/src/AngleSharp.Renderer.Tests/verification-assets/moves-lines-down-past-floats-they-do-not-fit-beside.windows.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/nested-vertical-lr-stacks-its-blocks-the-other-way.linux.png b/src/AngleSharp.Renderer.Tests/verification-assets/nested-vertical-lr-stacks-its-blocks-the-other-way.linux.png
new file mode 100644
index 0000000..369809e
Binary files /dev/null and b/src/AngleSharp.Renderer.Tests/verification-assets/nested-vertical-lr-stacks-its-blocks-the-other-way.linux.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/nested-vertical-lr-stacks-its-blocks-the-other-way.macos.png b/src/AngleSharp.Renderer.Tests/verification-assets/nested-vertical-lr-stacks-its-blocks-the-other-way.macos.png
new file mode 100644
index 0000000..369809e
Binary files /dev/null and b/src/AngleSharp.Renderer.Tests/verification-assets/nested-vertical-lr-stacks-its-blocks-the-other-way.macos.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/nested-vertical-lr-stacks-its-blocks-the-other-way.windows.png b/src/AngleSharp.Renderer.Tests/verification-assets/nested-vertical-lr-stacks-its-blocks-the-other-way.windows.png
new file mode 100644
index 0000000..369809e
Binary files /dev/null and b/src/AngleSharp.Renderer.Tests/verification-assets/nested-vertical-lr-stacks-its-blocks-the-other-way.windows.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/renders-before-and-after-generated-content.linux.png b/src/AngleSharp.Renderer.Tests/verification-assets/renders-before-and-after-generated-content.linux.png
index 7b4bf8b..3b0a67f 100644
Binary files a/src/AngleSharp.Renderer.Tests/verification-assets/renders-before-and-after-generated-content.linux.png and b/src/AngleSharp.Renderer.Tests/verification-assets/renders-before-and-after-generated-content.linux.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/renders-before-and-after-generated-content.macos.png b/src/AngleSharp.Renderer.Tests/verification-assets/renders-before-and-after-generated-content.macos.png
index dc407da..1bb8842 100644
Binary files a/src/AngleSharp.Renderer.Tests/verification-assets/renders-before-and-after-generated-content.macos.png and b/src/AngleSharp.Renderer.Tests/verification-assets/renders-before-and-after-generated-content.macos.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/renders-before-and-after-generated-content.windows.png b/src/AngleSharp.Renderer.Tests/verification-assets/renders-before-and-after-generated-content.windows.png
index f594df8..a39e176 100644
Binary files a/src/AngleSharp.Renderer.Tests/verification-assets/renders-before-and-after-generated-content.windows.png and b/src/AngleSharp.Renderer.Tests/verification-assets/renders-before-and-after-generated-content.windows.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/renders-inline-formatting-context.linux.png b/src/AngleSharp.Renderer.Tests/verification-assets/renders-inline-formatting-context.linux.png
index cfd6b04..2545569 100644
Binary files a/src/AngleSharp.Renderer.Tests/verification-assets/renders-inline-formatting-context.linux.png and b/src/AngleSharp.Renderer.Tests/verification-assets/renders-inline-formatting-context.linux.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/renders-inline-formatting-context.macos.png b/src/AngleSharp.Renderer.Tests/verification-assets/renders-inline-formatting-context.macos.png
index abbaf8a..79ef9fc 100644
Binary files a/src/AngleSharp.Renderer.Tests/verification-assets/renders-inline-formatting-context.macos.png and b/src/AngleSharp.Renderer.Tests/verification-assets/renders-inline-formatting-context.macos.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/renders-inline-formatting-context.windows.png b/src/AngleSharp.Renderer.Tests/verification-assets/renders-inline-formatting-context.windows.png
index fb8bcfa..0f927ef 100644
Binary files a/src/AngleSharp.Renderer.Tests/verification-assets/renders-inline-formatting-context.windows.png and b/src/AngleSharp.Renderer.Tests/verification-assets/renders-inline-formatting-context.windows.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/renders-justification-hyphens-small-caps-and-ellipsis.linux.png b/src/AngleSharp.Renderer.Tests/verification-assets/renders-justification-hyphens-small-caps-and-ellipsis.linux.png
index 40e4981..32044f7 100644
Binary files a/src/AngleSharp.Renderer.Tests/verification-assets/renders-justification-hyphens-small-caps-and-ellipsis.linux.png and b/src/AngleSharp.Renderer.Tests/verification-assets/renders-justification-hyphens-small-caps-and-ellipsis.linux.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/renders-justification-hyphens-small-caps-and-ellipsis.macos.png b/src/AngleSharp.Renderer.Tests/verification-assets/renders-justification-hyphens-small-caps-and-ellipsis.macos.png
index d42abf5..da86e2a 100644
Binary files a/src/AngleSharp.Renderer.Tests/verification-assets/renders-justification-hyphens-small-caps-and-ellipsis.macos.png and b/src/AngleSharp.Renderer.Tests/verification-assets/renders-justification-hyphens-small-caps-and-ellipsis.macos.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/renders-justification-hyphens-small-caps-and-ellipsis.windows.png b/src/AngleSharp.Renderer.Tests/verification-assets/renders-justification-hyphens-small-caps-and-ellipsis.windows.png
index 65a3ffe..768551c 100644
Binary files a/src/AngleSharp.Renderer.Tests/verification-assets/renders-justification-hyphens-small-caps-and-ellipsis.windows.png and b/src/AngleSharp.Renderer.Tests/verification-assets/renders-justification-hyphens-small-caps-and-ellipsis.windows.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/renders-left-and-right-floats.linux.png b/src/AngleSharp.Renderer.Tests/verification-assets/renders-left-and-right-floats.linux.png
index 7f3ee75..bb32cbc 100644
Binary files a/src/AngleSharp.Renderer.Tests/verification-assets/renders-left-and-right-floats.linux.png and b/src/AngleSharp.Renderer.Tests/verification-assets/renders-left-and-right-floats.linux.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/renders-left-and-right-floats.macos.png b/src/AngleSharp.Renderer.Tests/verification-assets/renders-left-and-right-floats.macos.png
index 17b59e3..0769ef8 100644
Binary files a/src/AngleSharp.Renderer.Tests/verification-assets/renders-left-and-right-floats.macos.png and b/src/AngleSharp.Renderer.Tests/verification-assets/renders-left-and-right-floats.macos.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/renders-left-and-right-floats.windows.png b/src/AngleSharp.Renderer.Tests/verification-assets/renders-left-and-right-floats.windows.png
index 7479ff7..7ad0059 100644
Binary files a/src/AngleSharp.Renderer.Tests/verification-assets/renders-left-and-right-floats.windows.png and b/src/AngleSharp.Renderer.Tests/verification-assets/renders-left-and-right-floats.windows.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/renders-multi-column-layout.linux.png b/src/AngleSharp.Renderer.Tests/verification-assets/renders-multi-column-layout.linux.png
index 38d763a..54ccf13 100644
Binary files a/src/AngleSharp.Renderer.Tests/verification-assets/renders-multi-column-layout.linux.png and b/src/AngleSharp.Renderer.Tests/verification-assets/renders-multi-column-layout.linux.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/renders-multi-column-layout.macos.png b/src/AngleSharp.Renderer.Tests/verification-assets/renders-multi-column-layout.macos.png
index 37db5f1..5afa48f 100644
Binary files a/src/AngleSharp.Renderer.Tests/verification-assets/renders-multi-column-layout.macos.png and b/src/AngleSharp.Renderer.Tests/verification-assets/renders-multi-column-layout.macos.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/renders-multi-column-layout.windows.png b/src/AngleSharp.Renderer.Tests/verification-assets/renders-multi-column-layout.windows.png
index a7ea38a..61b97e9 100644
Binary files a/src/AngleSharp.Renderer.Tests/verification-assets/renders-multi-column-layout.windows.png and b/src/AngleSharp.Renderer.Tests/verification-assets/renders-multi-column-layout.windows.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/renders-nested-list-with-independent-numbering.linux.png b/src/AngleSharp.Renderer.Tests/verification-assets/renders-nested-list-with-independent-numbering.linux.png
index 97e889f..097d77c 100644
Binary files a/src/AngleSharp.Renderer.Tests/verification-assets/renders-nested-list-with-independent-numbering.linux.png and b/src/AngleSharp.Renderer.Tests/verification-assets/renders-nested-list-with-independent-numbering.linux.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/renders-nested-list-with-independent-numbering.macos.png b/src/AngleSharp.Renderer.Tests/verification-assets/renders-nested-list-with-independent-numbering.macos.png
index 4f46927..62c06ba 100644
Binary files a/src/AngleSharp.Renderer.Tests/verification-assets/renders-nested-list-with-independent-numbering.macos.png and b/src/AngleSharp.Renderer.Tests/verification-assets/renders-nested-list-with-independent-numbering.macos.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/renders-nested-list-with-independent-numbering.windows.png b/src/AngleSharp.Renderer.Tests/verification-assets/renders-nested-list-with-independent-numbering.windows.png
index 187e128..c032748 100644
Binary files a/src/AngleSharp.Renderer.Tests/verification-assets/renders-nested-list-with-independent-numbering.windows.png and b/src/AngleSharp.Renderer.Tests/verification-assets/renders-nested-list-with-independent-numbering.windows.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/renders-ordered-list-with-decimal-markers.linux.png b/src/AngleSharp.Renderer.Tests/verification-assets/renders-ordered-list-with-decimal-markers.linux.png
index e8799d0..15ba24d 100644
Binary files a/src/AngleSharp.Renderer.Tests/verification-assets/renders-ordered-list-with-decimal-markers.linux.png and b/src/AngleSharp.Renderer.Tests/verification-assets/renders-ordered-list-with-decimal-markers.linux.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/renders-ordered-list-with-decimal-markers.macos.png b/src/AngleSharp.Renderer.Tests/verification-assets/renders-ordered-list-with-decimal-markers.macos.png
index 520b0d0..5dd26a8 100644
Binary files a/src/AngleSharp.Renderer.Tests/verification-assets/renders-ordered-list-with-decimal-markers.macos.png and b/src/AngleSharp.Renderer.Tests/verification-assets/renders-ordered-list-with-decimal-markers.macos.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/renders-ordered-list-with-decimal-markers.windows.png b/src/AngleSharp.Renderer.Tests/verification-assets/renders-ordered-list-with-decimal-markers.windows.png
index dca11e9..c942776 100644
Binary files a/src/AngleSharp.Renderer.Tests/verification-assets/renders-ordered-list-with-decimal-markers.windows.png and b/src/AngleSharp.Renderer.Tests/verification-assets/renders-ordered-list-with-decimal-markers.windows.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/renders-shaped-text.linux.png b/src/AngleSharp.Renderer.Tests/verification-assets/renders-shaped-text.linux.png
new file mode 100644
index 0000000..d05b951
Binary files /dev/null and b/src/AngleSharp.Renderer.Tests/verification-assets/renders-shaped-text.linux.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/renders-shaped-text.macos.png b/src/AngleSharp.Renderer.Tests/verification-assets/renders-shaped-text.macos.png
new file mode 100644
index 0000000..431b769
Binary files /dev/null and b/src/AngleSharp.Renderer.Tests/verification-assets/renders-shaped-text.macos.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/renders-shaped-text.windows.png b/src/AngleSharp.Renderer.Tests/verification-assets/renders-shaped-text.windows.png
new file mode 100644
index 0000000..9aba3e2
Binary files /dev/null and b/src/AngleSharp.Renderer.Tests/verification-assets/renders-shaped-text.windows.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/renders-square-and-circle-list-style-types.linux.png b/src/AngleSharp.Renderer.Tests/verification-assets/renders-square-and-circle-list-style-types.linux.png
index 0628e9e..b701e5b 100644
Binary files a/src/AngleSharp.Renderer.Tests/verification-assets/renders-square-and-circle-list-style-types.linux.png and b/src/AngleSharp.Renderer.Tests/verification-assets/renders-square-and-circle-list-style-types.linux.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/renders-square-and-circle-list-style-types.macos.png b/src/AngleSharp.Renderer.Tests/verification-assets/renders-square-and-circle-list-style-types.macos.png
index 7c69245..407269c 100644
Binary files a/src/AngleSharp.Renderer.Tests/verification-assets/renders-square-and-circle-list-style-types.macos.png and b/src/AngleSharp.Renderer.Tests/verification-assets/renders-square-and-circle-list-style-types.macos.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/renders-square-and-circle-list-style-types.windows.png b/src/AngleSharp.Renderer.Tests/verification-assets/renders-square-and-circle-list-style-types.windows.png
index 4b2891a..ee08e0f 100644
Binary files a/src/AngleSharp.Renderer.Tests/verification-assets/renders-square-and-circle-list-style-types.windows.png and b/src/AngleSharp.Renderer.Tests/verification-assets/renders-square-and-circle-list-style-types.windows.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/renders-table-cell-borders-and-widths.linux.png b/src/AngleSharp.Renderer.Tests/verification-assets/renders-table-cell-borders-and-widths.linux.png
index 073f801..210062b 100644
Binary files a/src/AngleSharp.Renderer.Tests/verification-assets/renders-table-cell-borders-and-widths.linux.png and b/src/AngleSharp.Renderer.Tests/verification-assets/renders-table-cell-borders-and-widths.linux.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/renders-table-cell-borders-and-widths.macos.png b/src/AngleSharp.Renderer.Tests/verification-assets/renders-table-cell-borders-and-widths.macos.png
index ba259b6..243f3a7 100644
Binary files a/src/AngleSharp.Renderer.Tests/verification-assets/renders-table-cell-borders-and-widths.macos.png and b/src/AngleSharp.Renderer.Tests/verification-assets/renders-table-cell-borders-and-widths.macos.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/renders-table-cell-borders-and-widths.windows.png b/src/AngleSharp.Renderer.Tests/verification-assets/renders-table-cell-borders-and-widths.windows.png
index bbe93ac..23cab66 100644
Binary files a/src/AngleSharp.Renderer.Tests/verification-assets/renders-table-cell-borders-and-widths.windows.png and b/src/AngleSharp.Renderer.Tests/verification-assets/renders-table-cell-borders-and-widths.windows.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/renders-table-with-colspan-and-rowspan.linux.png b/src/AngleSharp.Renderer.Tests/verification-assets/renders-table-with-colspan-and-rowspan.linux.png
index d0002fc..0e5722a 100644
Binary files a/src/AngleSharp.Renderer.Tests/verification-assets/renders-table-with-colspan-and-rowspan.linux.png and b/src/AngleSharp.Renderer.Tests/verification-assets/renders-table-with-colspan-and-rowspan.linux.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/renders-table-with-colspan-and-rowspan.macos.png b/src/AngleSharp.Renderer.Tests/verification-assets/renders-table-with-colspan-and-rowspan.macos.png
index 551ad4d..66d028f 100644
Binary files a/src/AngleSharp.Renderer.Tests/verification-assets/renders-table-with-colspan-and-rowspan.macos.png and b/src/AngleSharp.Renderer.Tests/verification-assets/renders-table-with-colspan-and-rowspan.macos.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/renders-table-with-colspan-and-rowspan.windows.png b/src/AngleSharp.Renderer.Tests/verification-assets/renders-table-with-colspan-and-rowspan.windows.png
index 98ef09f..da64cd0 100644
Binary files a/src/AngleSharp.Renderer.Tests/verification-assets/renders-table-with-colspan-and-rowspan.windows.png and b/src/AngleSharp.Renderer.Tests/verification-assets/renders-table-with-colspan-and-rowspan.windows.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/renders-unordered-list-with-disc-bullets.linux.png b/src/AngleSharp.Renderer.Tests/verification-assets/renders-unordered-list-with-disc-bullets.linux.png
index 3266e44..e329281 100644
Binary files a/src/AngleSharp.Renderer.Tests/verification-assets/renders-unordered-list-with-disc-bullets.linux.png and b/src/AngleSharp.Renderer.Tests/verification-assets/renders-unordered-list-with-disc-bullets.linux.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/renders-unordered-list-with-disc-bullets.macos.png b/src/AngleSharp.Renderer.Tests/verification-assets/renders-unordered-list-with-disc-bullets.macos.png
index 800285f..84f2793 100644
Binary files a/src/AngleSharp.Renderer.Tests/verification-assets/renders-unordered-list-with-disc-bullets.macos.png and b/src/AngleSharp.Renderer.Tests/verification-assets/renders-unordered-list-with-disc-bullets.macos.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/renders-unordered-list-with-disc-bullets.windows.png b/src/AngleSharp.Renderer.Tests/verification-assets/renders-unordered-list-with-disc-bullets.windows.png
index d1a8441..00a3e05 100644
Binary files a/src/AngleSharp.Renderer.Tests/verification-assets/renders-unordered-list-with-disc-bullets.windows.png and b/src/AngleSharp.Renderer.Tests/verification-assets/renders-unordered-list-with-disc-bullets.windows.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/sticky-box-in-vertical-flow-stays-pinned-while-scrolled-past-it.linux.png b/src/AngleSharp.Renderer.Tests/verification-assets/sticky-box-in-vertical-flow-stays-pinned-while-scrolled-past-it.linux.png
new file mode 100644
index 0000000..ce5b11d
Binary files /dev/null and b/src/AngleSharp.Renderer.Tests/verification-assets/sticky-box-in-vertical-flow-stays-pinned-while-scrolled-past-it.linux.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/sticky-box-in-vertical-flow-stays-pinned-while-scrolled-past-it.macos.png b/src/AngleSharp.Renderer.Tests/verification-assets/sticky-box-in-vertical-flow-stays-pinned-while-scrolled-past-it.macos.png
new file mode 100644
index 0000000..86c9361
Binary files /dev/null and b/src/AngleSharp.Renderer.Tests/verification-assets/sticky-box-in-vertical-flow-stays-pinned-while-scrolled-past-it.macos.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/sticky-box-in-vertical-flow-stays-pinned-while-scrolled-past-it.windows.png b/src/AngleSharp.Renderer.Tests/verification-assets/sticky-box-in-vertical-flow-stays-pinned-while-scrolled-past-it.windows.png
new file mode 100644
index 0000000..ce5b11d
Binary files /dev/null and b/src/AngleSharp.Renderer.Tests/verification-assets/sticky-box-in-vertical-flow-stays-pinned-while-scrolled-past-it.windows.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/text-indent-and-vertical-align.linux.png b/src/AngleSharp.Renderer.Tests/verification-assets/text-indent-and-vertical-align.linux.png
index 35aaf89..6b0765e 100644
Binary files a/src/AngleSharp.Renderer.Tests/verification-assets/text-indent-and-vertical-align.linux.png and b/src/AngleSharp.Renderer.Tests/verification-assets/text-indent-and-vertical-align.linux.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/text-indent-and-vertical-align.macos.png b/src/AngleSharp.Renderer.Tests/verification-assets/text-indent-and-vertical-align.macos.png
index 8888b69..5728ac5 100644
Binary files a/src/AngleSharp.Renderer.Tests/verification-assets/text-indent-and-vertical-align.macos.png and b/src/AngleSharp.Renderer.Tests/verification-assets/text-indent-and-vertical-align.macos.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/text-indent-and-vertical-align.windows.png b/src/AngleSharp.Renderer.Tests/verification-assets/text-indent-and-vertical-align.windows.png
index 3c63381..ad50bbc 100644
Binary files a/src/AngleSharp.Renderer.Tests/verification-assets/text-indent-and-vertical-align.windows.png and b/src/AngleSharp.Renderer.Tests/verification-assets/text-indent-and-vertical-align.windows.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/truncates-and-breaks-overflowing-text.linux.png b/src/AngleSharp.Renderer.Tests/verification-assets/truncates-and-breaks-overflowing-text.linux.png
index ee64ce8..f579426 100644
Binary files a/src/AngleSharp.Renderer.Tests/verification-assets/truncates-and-breaks-overflowing-text.linux.png and b/src/AngleSharp.Renderer.Tests/verification-assets/truncates-and-breaks-overflowing-text.linux.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/truncates-and-breaks-overflowing-text.macos.png b/src/AngleSharp.Renderer.Tests/verification-assets/truncates-and-breaks-overflowing-text.macos.png
index 9cddcda..565ab67 100644
Binary files a/src/AngleSharp.Renderer.Tests/verification-assets/truncates-and-breaks-overflowing-text.macos.png and b/src/AngleSharp.Renderer.Tests/verification-assets/truncates-and-breaks-overflowing-text.macos.png differ
diff --git a/src/AngleSharp.Renderer.Tests/verification-assets/truncates-and-breaks-overflowing-text.windows.png b/src/AngleSharp.Renderer.Tests/verification-assets/truncates-and-breaks-overflowing-text.windows.png
index b7ed3f1..e5a7da4 100644
Binary files a/src/AngleSharp.Renderer.Tests/verification-assets/truncates-and-breaks-overflowing-text.windows.png and b/src/AngleSharp.Renderer.Tests/verification-assets/truncates-and-breaks-overflowing-text.windows.png differ
diff --git a/src/AngleSharp.Renderer/AngleSharp.Renderer.csproj b/src/AngleSharp.Renderer/AngleSharp.Renderer.csproj
index ef2c718..62dcadb 100644
--- a/src/AngleSharp.Renderer/AngleSharp.Renderer.csproj
+++ b/src/AngleSharp.Renderer/AngleSharp.Renderer.csproj
@@ -33,10 +33,13 @@
     <PackageReference Include="AngleSharp.Css" Version="[$(AngleSharpCssVersion),2.0.0)" />
     <PackageReference Include="SkiaSharp" Version="2.88.9" />
     <PackageReference Include="SkiaSharp.NativeAssets.Linux.NoDependencies" Version="2.88.9" />
+    <PackageReference Include="SkiaSharp.HarfBuzz" Version="2.88.9" />
+    <PackageReference Include="HarfBuzzSharp.NativeAssets.Linux" Version="7.3.0.3" />
   </ItemGroup>
 
   <ItemGroup>
     <EmbeddedResource Include="Resources/Fonts/*.ttf" />
+    <None Include="Resources/Fonts/*-OFL.txt" Pack="true" PackagePath="licenses/" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/src/AngleSharp.Renderer/BidiAlgorithm.cs b/src/AngleSharp.Renderer/BidiAlgorithm.cs
index 491bfd0..a78ba2b 100644
--- a/src/AngleSharp.Renderer/BidiAlgorithm.cs
+++ b/src/AngleSharp.Renderer/BidiAlgorithm.cs
@@ -6,7 +6,8 @@ namespace AngleSharp.Renderer;
 /// <summary>
 /// The Unicode Bidirectional Algorithm (UAX #9) for one line of text: explicit embeddings,
 /// overrides and isolates (rules X1-X10), the weak, neutral and implicit rules (W1-W7, N1-N2,
-/// I1-I2), trailing whitespace (L1), reordering (L2) and mirroring (L4).
+/// I1-I2), trailing whitespace (L1) and reordering (L2). Mirroring (L4) is left to shaping,
+/// which mirrors the glyphs of right-to-left runs.
 /// </summary>
 /// <remarks>
 /// .NET exposes no Bidi_Class data, so <see cref="GetClass"/> derives it from script ranges and
@@ -210,27 +211,37 @@ public static int[] GetVisualOrder(byte[] levels)
         return order;
     }
 
-    /// <summary>The mirrored glyph of a Bidi_Mirrored character in right-to-left text (L4).</summary>
-    public static char Mirror(char value) => value switch
+    /// <summary>
+    /// One line of text as runs in visual order: each run is a maximal stretch at one embedding
+    /// level, in logical order and without formatting characters; shaping reverses and mirrors
+    /// the right-to-left ones.
+    /// </summary>
+    public static List<(string Text, bool IsRightToLeft)> GetVisualRuns(string line, bool isRightToLeft)
     {
-        '(' => ')',
-        ')' => '(',
-        '[' => ']',
-        ']' => '[',
-        '{' => '}',
-        '}' => '{',
-        '<' => '>',
-        '>' => '<',
-        '«' => '»',
-        '»' => '«',
-        '‹' => '›',
-        '›' => '‹',
-        '≤' => '≥',
-        '≥' => '≤',
-        '⟨' => '⟩',
-        '⟩' => '⟨',
-        _ => value,
-    };
+        var levels = GetLevels(line, isRightToLeft);
+        var order = GetVisualOrder(levels);
+        var runs = new List<(string Text, bool IsRightToLeft)>();
+        var position = 0;
+
+        while (position < order.Length)
+        {
+            var level = levels[order[position]];
+            var end = position;
+
+            while (end + 1 < order.Length && levels[order[end + 1]] == level && Math.Abs(order[end + 1] - order[end]) == 1)
+            {
+                end++;
+            }
+
+            var first = Math.Min(order[position], order[end]);
+            var last = Math.Max(order[position], order[end]);
+            var run = new string(line.AsSpan(first, last - first + 1).ToArray().Where(static c => !IsFormattingCharacter(c)).ToArray());
+            runs.Add((run, (level & 1) == 1));
+            position = end + 1;
+        }
+
+        return runs;
+    }
 
     /// <summary>
     /// Whether a character is an explicit formatting character or the placeholder, none of
diff --git a/src/AngleSharp.Renderer/HtmlRenderer.Columns.cs b/src/AngleSharp.Renderer/HtmlRenderer.Columns.cs
index 9f3c344..d169538 100644
--- a/src/AngleSharp.Renderer/HtmlRenderer.Columns.cs
+++ b/src/AngleSharp.Renderer/HtmlRenderer.Columns.cs
@@ -9,12 +9,14 @@ namespace AngleSharp.Renderer;
 
 /// <summary>
 /// Multi-column layout (<c>column-count</c>, <c>column-width</c>, <c>column-gap</c>,
-/// <c>column-rule</c>).
+/// <c>column-rule</c>, <c>column-span</c>, <c>column-fill</c>) and its fragmentation
+/// (<c>break-before</c>/<c>-after</c>/<c>-inside</c>, <c>orphans</c>, <c>widows</c>).
 /// </summary>
 /// <remarks>
-/// The content is laid out once, as a single column of the used column width, into a scratch
-/// display list. Every line box and block bottom produced on the way is a candidate break point;
-/// the column height is the smallest one that fits the content into the column count without
+/// Each column set (the content between <c>column-span: all</c> children) is laid out once, as a
+/// single column of the used column width, into a scratch display list. Every line box and block
+/// bottom produced on the way is a candidate break point, refined by the break properties; the
+/// column height is the smallest one that fits the content into the column count without
 /// breaking a line. Each column then replays the scratch list, translated into place and clipped
 /// to its own slice, so no layout code needs to know about fragmentation.
 /// </remarks>
@@ -23,26 +25,163 @@ public sealed partial class HtmlRenderer
     private static readonly AsyncLocal<ColumnBreakCapture?> s_columnBreakCapture = new();
 
     /// <summary>
-    /// Where content may be split into columns: <see cref="Ends"/> are the bottoms of line boxes
-    /// and blocks (a column may end there), <see cref="Starts"/> the tops of line boxes (the next
-    /// column starts at the first one below the break, so margins at a break are truncated).
+    /// What a multi-column container may break at: <see cref="Ends"/> are the bottoms of line
+    /// boxes and blocks (a column may end there), <see cref="Starts"/> the tops of line boxes (the
+    /// next column starts at the first one below the break, so margins at a break are truncated).
+    /// The other lists refine those candidates: <c>break-before</c>/<c>break-after</c> between
+    /// blocks, <c>break-inside: avoid</c> ranges, the lines of each paragraph (for
+    /// <c>orphans</c>/<c>widows</c>), and the ranges no column may cut through (line boxes and
+    /// replaced blocks).
     /// </summary>
     private sealed class ColumnBreakCapture
     {
         public List<float> Ends { get; } = [];
 
         public List<float> Starts { get; } = [];
+
+        public List<(float Y, ColumnBreakKind Kind)> Between { get; } = [];
+
+        public List<(float Top, float Bottom)> AvoidInside { get; } = [];
+
+        public List<(float Top, float Bottom)> Monolithic { get; } = [];
+
+        public List<(float Bottom, int Paragraph)> Lines { get; } = [];
+
+        public List<(int Orphans, int Widows)> Paragraphs { get; } = [];
+
+        public int CurrentParagraph { get; set; } = -1;
     }
 
+    private enum ColumnBreakKind
+    {
+        Allowed,
+        Avoid,
+        Forced,
+    }
+
+    private readonly record struct ColumnBreak(float Offset, ColumnBreakKind Kind);
+
     /// <summary>
     /// Notes the bottom of a line box or block, where a multi-column container may end a column.
     /// </summary>
     private static void RecordColumnBreakCandidate(float y) => s_columnBreakCapture.Value?.Ends.Add(y);
 
     /// <summary>
-    /// Notes the top of a line box, where a multi-column container may start a column.
+    /// Notes a line box: a column may start at its top and end at its bottom, but never cut it.
+    /// </summary>
+    private static void RecordColumnLine(float top, float bottom)
+    {
+        if (s_columnBreakCapture.Value is not { } capture)
+        {
+            return;
+        }
+
+        capture.Starts.Add(top);
+        capture.Ends.Add(bottom);
+        capture.Monolithic.Add((top, bottom));
+        capture.Lines.Add((bottom, capture.CurrentParagraph));
+    }
+
+    /// <summary>
+    /// Starts a paragraph (a run of lines of one block container) whose breaks follow the
+    /// container's <c>orphans</c>/<c>widows</c>; returns the paragraph to restore afterwards.
     /// </summary>
-    private static void RecordColumnContentStart(float y) => s_columnBreakCapture.Value?.Starts.Add(y);
+    private static int BeginColumnParagraph(IRenderNode firstChild)
+    {
+        if (s_columnBreakCapture.Value is not { } capture)
+        {
+            return -1;
+        }
+
+        var previous = capture.CurrentParagraph;
+        var container = firstChild switch
+        {
+            ElementRenderNode element => element.Parent,
+            TextRenderNode text => text.Parent as ElementRenderNode,
+            _ => null,
+        };
+
+        capture.Paragraphs.Add((ReadLineCount(container, "orphans"), ReadLineCount(container, "widows")));
+        capture.CurrentParagraph = capture.Paragraphs.Count - 1;
+        return previous;
+
+        static int ReadLineCount(ElementRenderNode? node, string propertyName) =>
+            node is not null &&
+            int.TryParse(node.ComputedStyle.GetPropertyValue(propertyName)?.Trim(), NumberStyles.Integer, CultureInfo.InvariantCulture, out var count) &&
+            count > 0
+                ? count
+                : 2;
+    }
+
+    private static void EndColumnParagraph(int previous)
+    {
+        if (s_columnBreakCapture.Value is { } capture)
+        {
+            capture.CurrentParagraph = previous;
+        }
+    }
+
+    /// <summary>
+    /// Notes the fragmentation properties of a block laid out from <paramref name="top"/> (its
+    /// margin edge, which is where the previous block ended) to <paramref name="bottom"/>.
+    /// </summary>
+    private static void RecordColumnBlockBreaks(IRenderNode child, float top, float bottom)
+    {
+        if (s_columnBreakCapture.Value is not { } capture || child is not ElementRenderNode element)
+        {
+            return;
+        }
+
+        var style = element.ComputedStyle;
+
+        if (ParseBreakBetween(style.GetPropertyValue("break-before")) is { } before)
+        {
+            capture.Between.Add((top, before));
+        }
+
+        if (ParseBreakBetween(style.GetPropertyValue("break-after")) is { } after)
+        {
+            capture.Between.Add((bottom, after));
+        }
+
+        if (style.GetPropertyValue("break-inside")?.Trim().ToLowerInvariant() is "avoid" or "avoid-column")
+        {
+            capture.AvoidInside.Add((top, bottom));
+        }
+
+        if (IsReplacedElement(element.Ref))
+        {
+            capture.Monolithic.Add((top, bottom));
+        }
+    }
+
+    /// <summary>
+    /// <c>break-before</c>/<c>break-after</c> as they apply inside a multi-column container: every
+    /// forced break value (page breaks included, as there are no pages) starts a new column.
+    /// </summary>
+    private static ColumnBreakKind? ParseBreakBetween(string? value) => value?.Trim().ToLowerInvariant() switch
+    {
+        "column" or "page" or "always" or "left" or "right" or "recto" or "verso" => ColumnBreakKind.Forced,
+        "avoid" or "avoid-column" => ColumnBreakKind.Avoid,
+        _ => null,
+    };
+
+    /// <summary>
+    /// <c>column-span: all</c> on an in-flow child; floats and absolutely positioned boxes never
+    /// span.
+    /// </summary>
+    private static bool IsColumnSpanner(IRenderNode node, LayoutContext context)
+    {
+        if (node is not ElementRenderNode element || !GeneratesBoxes(element) ||
+            !string.Equals(element.ComputedStyle.GetPropertyValue("column-span")?.Trim(), "all", StringComparison.OrdinalIgnoreCase))
+        {
+            return false;
+        }
+
+        var styleMap = GetOrCreateStyleMap(context, element.Ref, element.ComputedStyle);
+        return styleMap.GetValueOrDefault("float")?.Trim().ToLowerInvariant() is null or "" or "none" &&
+               styleMap.GetValueOrDefault("position")?.Trim().ToLowerInvariant() is not ("absolute" or "fixed");
+    }
 
     private readonly record struct ColumnLayout(int Count, float Width, float Gap);
 
@@ -101,8 +240,9 @@ private static bool TryResolveColumnLayout(Dictionary<string, string> styleMap,
     }
 
     /// <summary>
-    /// Lays out a multi-column container's children into balanced columns and returns the height
-    /// of the columns.
+    /// Lays out a multi-column container's children into columns and returns the height of its
+    /// content. Every <c>column-span: all</c> child ends a column set: the content before it is
+    /// balanced on its own, and the spanner is laid out across all columns below it.
     /// </summary>
     private static float LayoutMultiColumnChildren(
         IReadOnlyList<IRenderNode> children,
@@ -120,11 +260,109 @@ private static float LayoutMultiColumnChildren(
         float positionedContainingWidth,
         float positionedContainingHeight)
     {
+        var cursorY = contentY;
+        var set = new List<IRenderNode>();
+        var fullWidth = (columns.Count * columns.Width) + ((columns.Count - 1) * columns.Gap);
+
+        foreach (var child in children)
+        {
+            if (!IsColumnSpanner(child, context))
+            {
+                set.Add(child);
+                continue;
+            }
+
+            // Column sets followed by a spanner are always balanced.
+            cursorY += LayoutColumnSet(set, columns, styleMap, contentX, cursorY, float.NaN, float.NaN, specifiedContentHeight, ref textIndentConsumed, textStyle, context, displayList, positionedContainingX, positionedContainingY, positionedContainingWidth, positionedContainingHeight);
+            set = [];
+
+            var previousMarginBottom = 0f;
+            var suppressTopMargin = false;
+
+            LayoutNode(
+                child,
+                contentX,
+                contentY,
+                fullWidth,
+                ref cursorY,
+                ref previousMarginBottom,
+                ref suppressTopMargin,
+                new FloatArea(),
+                ref textIndentConsumed,
+                textStyle,
+                context,
+                displayList,
+                float.MaxValue,
+                containingHeight: specifiedContentHeight,
+                positionedContainingX: positionedContainingX,
+                positionedContainingY: positionedContainingY,
+                positionedContainingWidth: positionedContainingWidth,
+                positionedContainingHeight: positionedContainingHeight);
+
+            cursorY += previousMarginBottom;
+        }
+
+        // With a definite height the last set takes what is left of it: `column-fill: auto` fills
+        // its columns one after another, `balance` (the initial value) balances them within it.
+        // Columns that do not fit overflow to the side.
+        var remainingHeight = float.IsNaN(specifiedContentHeight) ? float.NaN : Math.Max(1f, specifiedContentHeight - (cursorY - contentY));
+        var fillsSequentially = !float.IsNaN(remainingHeight) &&
+                                string.Equals(styleMap.GetValueOrDefault("column-fill")?.Trim(), "auto", StringComparison.OrdinalIgnoreCase);
+
+        cursorY += LayoutColumnSet(
+            set,
+            columns,
+            styleMap,
+            contentX,
+            cursorY,
+            fillsSequentially ? remainingHeight : float.NaN,
+            fillsSequentially ? float.NaN : remainingHeight,
+            specifiedContentHeight,
+            ref textIndentConsumed,
+            textStyle,
+            context,
+            displayList,
+            positionedContainingX,
+            positionedContainingY,
+            positionedContainingWidth,
+            positionedContainingHeight);
+
+        return float.IsNaN(specifiedContentHeight) ? cursorY - contentY : specifiedContentHeight;
+    }
+
+    /// <summary>
+    /// Lays out one column set at <paramref name="top"/> and returns its height. Columns are
+    /// <paramref name="fillHeight"/> tall and filled one after another when that is given, else
+    /// balanced (never taller than <paramref name="maxHeight"/>, when given).
+    /// </summary>
+    private static float LayoutColumnSet(
+        IReadOnlyList<IRenderNode> children,
+        ColumnLayout columns,
+        Dictionary<string, string> styleMap,
+        float contentX,
+        float top,
+        float fillHeight,
+        float maxHeight,
+        float containingHeight,
+        ref bool textIndentConsumed,
+        RenderTextStyle textStyle,
+        LayoutContext context,
+        DisplayList displayList,
+        float positionedContainingX,
+        float positionedContainingY,
+        float positionedContainingWidth,
+        float positionedContainingHeight)
+    {
+        if (children.Count == 0)
+        {
+            return 0f;
+        }
+
         var scratch = new DisplayList { Fonts = context.Fonts };
         var capture = new ColumnBreakCapture();
         var previousCapture = s_columnBreakCapture.Value;
         s_columnBreakCapture.Value = capture;
-        var cursorY = contentY;
+        var cursorY = top;
 
         try
         {
@@ -135,7 +373,7 @@ private static float LayoutMultiColumnChildren(
             LayoutFlowChildren(
                 children,
                 contentX,
-                contentY,
+                top,
                 columns.Width,
                 ref cursorY,
                 ref previousBlockMarginBottom,
@@ -146,7 +384,7 @@ private static float LayoutMultiColumnChildren(
                 context,
                 scratch,
                 float.MaxValue,
-                specifiedContentHeight,
+                containingHeight,
                 positionedContainingX,
                 positionedContainingY,
                 positionedContainingWidth,
@@ -158,28 +396,34 @@ private static float LayoutMultiColumnChildren(
             s_columnBreakCapture.Value = previousCapture;
         }
 
-        var totalHeight = Math.Max(0f, cursorY - contentY);
-        var candidates = capture.Ends
-            .Select(y => y - contentY)
-            .Where(offset => offset > 0.5f && offset < totalHeight - 0.5f)
-            .Append(totalHeight)
-            .Distinct()
-            .OrderBy(offset => offset)
-            .ToList();
+        var totalHeight = Math.Max(0f, cursorY - top);
+        var breaks = CollectColumnBreaks(capture, top, totalHeight);
         var starts = capture.Starts
-            .Select(y => y - contentY)
+            .Select(y => y - top)
             .Distinct()
             .OrderBy(offset => offset)
             .ToList();
+        var monolithic = capture.Monolithic.Select(range => (range.Top - top, range.Bottom - top)).ToList();
+
+        List<(float Start, float End)> segments;
+        float columnHeight;
+
+        if (!float.IsNaN(fillHeight))
+        {
+            segments = FillColumns(breaks, starts, monolithic, totalHeight, fillHeight, out _);
+            columnHeight = fillHeight;
+        }
+        else
+        {
+            segments = BalanceColumns(breaks, starts, monolithic, totalHeight, columns.Count);
+            columnHeight = segments.Max(segment => segment.End - segment.Start);
 
-        // A container with an authored height fills its columns one after another (extra columns
-        // overflow to the side); otherwise the column height is balanced.
-        var segments = float.IsNaN(specifiedContentHeight)
-            ? BalanceColumns(candidates, starts, totalHeight, columns.Count)
-            : FillColumns(candidates, starts, totalHeight, Math.Max(1f, specifiedContentHeight), out _);
-        var columnHeight = float.IsNaN(specifiedContentHeight)
-            ? segments.Max(segment => segment.End - segment.Start)
-            : specifiedContentHeight;
+            if (!float.IsNaN(maxHeight) && columnHeight > maxHeight + 0.01f)
+            {
+                segments = FillColumns(breaks, starts, monolithic, totalHeight, maxHeight, out _);
+                columnHeight = maxHeight;
+            }
+        }
 
         for (var index = 0; index < segments.Count; index++)
         {
@@ -187,7 +431,7 @@ private static float LayoutMultiColumnChildren(
             var columnX = contentX + (index * (columns.Width + columns.Gap));
 
             // Content that overflows a column horizontally may spill into half of the gap.
-            var clip = new RenderRect(columnX - (columns.Gap / 2f), contentY, columns.Width + columns.Gap, end - start);
+            var clip = new RenderRect(columnX - (columns.Gap / 2f), top, columns.Width + columns.Gap, end - start);
             displayList.PushClip(clip, RenderCornerRadii.Zero);
             displayList.PushTransform(RenderTransform2D.Translate(columnX - contentX, -start));
             displayList.InsertRange(displayList.Commands.Count, scratch.Commands);
@@ -195,15 +439,106 @@ private static float LayoutMultiColumnChildren(
             displayList.PopClip();
         }
 
-        PaintColumnRules(styleMap, segments.Count, columns, contentX, contentY, columnHeight, textStyle.IsHidden ? new DisplayList() : displayList);
+        PaintColumnRules(styleMap, segments.Count, columns, contentX, top, columnHeight, textStyle.IsHidden ? new DisplayList() : displayList);
         return columnHeight;
     }
 
+    /// <summary>
+    /// The places a column set may break at, as offsets from its top, in order and ending with
+    /// its total height. Forced breaks (<c>break-before</c>/<c>break-after</c>) always break;
+    /// breaks to avoid (<c>break-*: avoid</c>, inside a <c>break-inside: avoid</c> block, or
+    /// leaving fewer lines of a paragraph than <c>orphans</c> before or <c>widows</c> after them)
+    /// are only taken when no other break fits.
+    /// </summary>
+    private static List<ColumnBreak> CollectColumnBreaks(ColumnBreakCapture capture, float top, float totalHeight)
+    {
+        var entries = new List<(float Offset, ColumnBreakKind Kind, bool IsCandidate)>();
+
+        bool InRange(float offset) => offset > 0.5f && offset < totalHeight - 0.5f;
+
+        foreach (var end in capture.Ends)
+        {
+            if (InRange(end - top))
+            {
+                entries.Add((end - top, ColumnBreakKind.Allowed, true));
+            }
+        }
+
+        // A forced break is a break even where nothing else ends (inside a parent's padding).
+        foreach (var (y, kind) in capture.Between)
+        {
+            if (InRange(y - top))
+            {
+                entries.Add((y - top, kind, kind == ColumnBreakKind.Forced));
+            }
+        }
+
+        foreach (var paragraph in capture.Lines.Where(line => line.Paragraph >= 0).GroupBy(line => line.Paragraph))
+        {
+            var lines = paragraph.ToList();
+            var (orphans, widows) = capture.Paragraphs[paragraph.Key];
+
+            for (var index = 0; index < lines.Count - 1; index++)
+            {
+                var before = index + 1;
+                var after = lines.Count - before;
+
+                if (before < orphans || after < widows)
+                {
+                    entries.Add((lines[index].Bottom - top, ColumnBreakKind.Avoid, false));
+                }
+            }
+        }
+
+        var breaks = new List<ColumnBreak>();
+
+        foreach (var group in GroupNearby(entries.OrderBy(entry => entry.Offset).ToList()))
+        {
+            if (!group.Any(entry => entry.IsCandidate))
+            {
+                continue;
+            }
+
+            var offset = group[0].Offset;
+            var kind = group.Any(entry => entry.Kind == ColumnBreakKind.Forced)
+                ? ColumnBreakKind.Forced
+                : group.Any(entry => entry.Kind == ColumnBreakKind.Avoid) ||
+                  capture.AvoidInside.Any(range => offset > range.Top - top + 0.5f && offset < range.Bottom - top - 0.5f)
+                    ? ColumnBreakKind.Avoid
+                    : ColumnBreakKind.Allowed;
+            breaks.Add(new ColumnBreak(offset, kind));
+        }
+
+        breaks.Add(new ColumnBreak(totalHeight, ColumnBreakKind.Allowed));
+        return breaks;
+
+        static IEnumerable<List<(float Offset, ColumnBreakKind Kind, bool IsCandidate)>> GroupNearby(List<(float Offset, ColumnBreakKind Kind, bool IsCandidate)> sorted)
+        {
+            var group = new List<(float Offset, ColumnBreakKind Kind, bool IsCandidate)>();
+
+            foreach (var entry in sorted)
+            {
+                if (group.Count > 0 && entry.Offset - group[0].Offset > 0.01f)
+                {
+                    yield return group;
+                    group = [];
+                }
+
+                group.Add(entry);
+            }
+
+            if (group.Count > 0)
+            {
+                yield return group;
+            }
+        }
+    }
+
     /// <summary>
     /// Finds the smallest column height that fits the content into <paramref name="columnCount"/>
-    /// columns, breaking only at <paramref name="candidates"/>.
+    /// columns, breaking only at <paramref name="breaks"/> (or, failing those, inside a block).
     /// </summary>
-    private static List<(float Start, float End)> BalanceColumns(List<float> candidates, List<float> starts, float totalHeight, int columnCount)
+    private static List<(float Start, float End)> BalanceColumns(List<ColumnBreak> breaks, List<float> starts, List<(float Top, float Bottom)> monolithic, float totalHeight, int columnCount)
     {
         if (totalHeight <= 0f)
         {
@@ -213,10 +548,10 @@ private static float LayoutMultiColumnChildren(
         var height = totalHeight / columnCount;
 
         // Each round grows the height by the smallest amount that lets some column take one more
-        // piece, so this ends after at most as many rounds as there are candidates.
-        for (var round = 0; round <= candidates.Count; round++)
+        // piece, so this ends after at most as many rounds as there are breaks.
+        for (var round = 0; round <= breaks.Count; round++)
         {
-            var segments = FillColumns(candidates, starts, totalHeight, height, out var smallestIncrease);
+            var segments = FillColumns(breaks, starts, monolithic, totalHeight, height, out var smallestIncrease);
 
             if (segments.Count <= columnCount || float.IsInfinity(smallestIncrease))
             {
@@ -226,14 +561,14 @@ private static float LayoutMultiColumnChildren(
             height += Math.Max(0.5f, smallestIncrease);
         }
 
-        return FillColumns(candidates, starts, totalHeight, totalHeight, out _);
+        return FillColumns(breaks, starts, monolithic, totalHeight, totalHeight, out _);
     }
 
     /// <summary>
     /// Fills columns of <paramref name="height"/> greedily. <paramref name="smallestIncrease"/> is
     /// how much taller the columns would need to be for any of them to take one more piece.
     /// </summary>
-    private static List<(float Start, float End)> FillColumns(List<float> candidates, List<float> starts, float totalHeight, float height, out float smallestIncrease)
+    private static List<(float Start, float End)> FillColumns(List<ColumnBreak> breaks, List<float> starts, List<(float Top, float Bottom)> monolithic, float totalHeight, float height, out float smallestIncrease)
     {
         var segments = new List<(float Start, float End)>();
         smallestIncrease = float.PositiveInfinity;
@@ -243,30 +578,65 @@ private static float LayoutMultiColumnChildren(
         {
             var limit = start + height + 0.01f;
             var end = start;
+            var avoidedEnd = start;
             var next = float.NaN;
 
-            foreach (var candidate in candidates)
+            foreach (var candidate in breaks)
             {
-                if (candidate <= start + 0.01f)
+                if (candidate.Offset <= start + 0.01f)
                 {
                     continue;
                 }
 
-                if (candidate <= limit)
+                if (candidate.Offset > limit)
                 {
-                    end = candidate;
+                    next = candidate.Offset;
+                    break;
                 }
-                else
+
+                if (candidate.Kind == ColumnBreakKind.Avoid)
+                {
+                    avoidedEnd = candidate.Offset;
+                    continue;
+                }
+
+                end = candidate.Offset;
+
+                if (candidate.Kind == ColumnBreakKind.Forced)
                 {
-                    next = candidate;
+                    next = float.NaN;
                     break;
                 }
             }
 
-            if (end <= start)
+            var cutInsideBlock = false;
+
+            if (end <= start && avoidedEnd > start)
+            {
+                end = avoidedEnd;
+            }
+            else if (end <= start)
             {
-                // A single piece taller than the column still has to go somewhere.
-                end = float.IsNaN(next) ? totalHeight : next;
+                // Nothing fits: a block is split at the column's end, or above the line or
+                // replaced box that would be cut there. A piece that cannot be split overflows.
+                var cut = start + height;
+                var blocker = monolithic.Where(range => range.Top < cut - 0.01f && range.Bottom > cut + 0.01f).Select(range => range.Top).DefaultIfEmpty(float.NaN).Min();
+
+                if (!float.IsNaN(blocker))
+                {
+                    cut = blocker;
+                }
+
+                if (cut > start + 0.5f && cut < totalHeight - 0.01f)
+                {
+                    end = cut;
+                    cutInsideBlock = true;
+                }
+                else
+                {
+                    end = float.IsNaN(next) ? totalHeight : next;
+                }
+
                 next = float.NaN;
             }
 
@@ -277,11 +647,17 @@ private static float LayoutMultiColumnChildren(
 
             segments.Add((start, end));
 
-            // The next column starts with the next line box, skipping the space (margins) between.
+            // The next column starts with the next line box, skipping the space (margins) between;
+            // the rest of a split block continues right at the cut.
             start = end;
 
             foreach (var candidateStart in starts)
             {
+                if (cutInsideBlock)
+                {
+                    break;
+                }
+
                 if (candidateStart >= end - 0.01f)
                 {
                     start = Math.Min(Math.Max(end, candidateStart), totalHeight);
diff --git a/src/AngleSharp.Renderer/HtmlRenderer.Inline.cs b/src/AngleSharp.Renderer/HtmlRenderer.Inline.cs
index e54e9ce..f57a484 100644
--- a/src/AngleSharp.Renderer/HtmlRenderer.Inline.cs
+++ b/src/AngleSharp.Renderer/HtmlRenderer.Inline.cs
@@ -58,6 +58,8 @@ void FlushRun(ref float cursorY, ref float previousBlockMarginBottom, ref bool s
                 return;
             }
 
+            var outerColumnParagraph = BeginColumnParagraph(run[0]);
+
             if (run.All(static node => node is TextRenderNode) && !floats.HasFloatsBelow(cursorY))
             {
                 // A run of bare text keeps the dedicated paragraph path, which also implements
@@ -91,6 +93,7 @@ void FlushRun(ref float cursorY, ref float previousBlockMarginBottom, ref bool s
                     paintOrder);
             }
 
+            EndColumnParagraph(outerColumnParagraph);
             run.Clear();
             runHasInlineContent = false;
         }
@@ -124,6 +127,7 @@ void FlushRun(ref float cursorY, ref float previousBlockMarginBottom, ref bool s
 
             var blockTextIndentConsumed = false;
             var childRangeStart = displayList.Commands.Count;
+            var childTop = cursorY;
 
             LayoutNode(
                 node: child,
@@ -146,6 +150,7 @@ void FlushRun(ref float cursorY, ref float previousBlockMarginBottom, ref bool s
                 positionedContainingHeight: positionedContainingHeight);
 
             RecordColumnBreakCandidate(cursorY);
+            RecordColumnBlockBreaks(child, childTop, cursorY);
 
             if (IsNegativeZIndexChild(child, context) && !IsStickyElement(child, context))
             {
@@ -353,11 +358,11 @@ private sealed class InlinePiece
         /// <summary>A preserved tab: a space piece whose width reaches the next tab stop.</summary>
         public bool IsTab { get; init; }
 
-        public InlinePiece WithText(string text, float width) => new()
+        public InlinePiece WithText(string text, float width, RenderTextStyle? style = null) => new()
         {
             Kind = Kind,
             Text = text,
-            Style = Style,
+            Style = style ?? Style,
             StyleId = StyleId,
             Width = width,
             BreakAfter = BreakAfter,
@@ -746,6 +751,8 @@ private static void LayoutInlineFormattingContext(
             return;
         }
 
+        ApplyShapingContext(pieces, context);
+
         var lineStartIndex = 0;
         var emittedAnyLine = false;
         var lineTop = cursorY;
@@ -759,6 +766,21 @@ private static void LayoutInlineFormattingContext(
             var indent = !textIndentConsumed ? textStyle.TextIndent + textStyle.MarkerIndent : 0f;
             var available = Math.Max(0f, lineAvailable - indent);
 
+            // A line whose first unbreakable unit does not fit beside the floats moves down to
+            // where one of them ends, until it fits or no float is left beside it (CSS 2.1 §9.5).
+            if (lineAvailable < contentWidth && pieces[lineStartIndex].Kind != InlinePieceKind.BlockInInline)
+            {
+                var firstUnitWidth = MeasureFirstLineUnit(pieces, lineStartIndex);
+
+                while (firstUnitWidth > available + 0.01f && lineAvailable < contentWidth && floats.NextBottomBelow(lineTop) is var nextBottom && !float.IsNaN(nextBottom))
+                {
+                    lineTop = nextBottom;
+                    (lineLeft, lineRight) = floats.GetBand(lineTop, textStyle.FontSize * textStyle.LineHeightMultiplier, contentX, contentX + contentWidth);
+                    lineAvailable = Math.Max(0f, lineRight - lineLeft);
+                    available = Math.Max(0f, lineAvailable - indent);
+                }
+            }
+
             // A block-level box nested in inline content gets a line of its own.
             if (pieces[lineStartIndex].Kind == InlinePieceKind.BlockInInline)
             {
@@ -817,8 +839,11 @@ private static void LayoutInlineFormattingContext(
             // `-webkit-line-clamp` ends the content after its last line, which shows an ellipsis
             // when anything was cut; `text-overflow: ellipsis` truncates every overflowing line.
             var isLastLine = forcedBreak || !HasContentBeforeNextBlock(pieces, lineStartIndex);
-            var clamped = hasLineBox && textStyle.LineClamp > 0 && lineCount + 1 >= textStyle.LineClamp &&
-                          pieces.Skip(lineStartIndex).Any(static piece => !piece.Trimmed && (piece.CountsAsContent || piece.Kind == InlinePieceKind.BlockInInline));
+            var lineClamp = context.LineClampScopes.TryPeek(out var scope) ? scope : null;
+            var isClampLine = lineClamp is not null ? lineClamp.Remaining == 1 : textStyle.LineClamp > 0 && lineCount + 1 >= textStyle.LineClamp;
+            var clamped = hasLineBox && isClampLine &&
+                          (pieces.Skip(lineStartIndex).Any(static piece => !piece.Trimmed && (piece.CountsAsContent || piece.Kind == InlinePieceKind.BlockInInline)) ||
+                           lineClamp is not null && nodes.Count > 0 && HasRenderedContentAfter(lineClamp.Root, nodes[^1].Ref));
 
             if (clamped || (hasLineBox && textStyle.TextOverflow == TextOverflowMode.Ellipsis && MeasureLinePieces(linePieces) > available + 0.01f))
             {
@@ -855,7 +880,12 @@ private static void LayoutInlineFormattingContext(
             textIndentConsumed = true;
             lineCount++;
 
-            if (lineTop > maxY || clamped)
+            if (lineClamp is not null)
+            {
+                lineClamp.Remaining--;
+            }
+
+            if (lineTop > maxY || clamped || lineClamp is { Remaining: <= 0 })
             {
                 break;
             }
@@ -900,6 +930,41 @@ private static void LayoutInlineFormattingContext(
     /// its last piece. A line always takes at least one breakable unit, so an overlong unit
     /// overflows instead of looping forever.
     /// </summary>
+    /// <summary>
+    /// The width of the unbreakable unit a line starting at <paramref name="start"/> begins with,
+    /// i.e. what has to fit beside the floats, without changing the pieces as BuildLine does.
+    /// </summary>
+    private static float MeasureFirstLineUnit(List<InlinePiece> pieces, int start)
+    {
+        var index = start;
+
+        while (index < pieces.Count && pieces[index].Kind == InlinePieceKind.Space && pieces[index].Collapsible)
+        {
+            index++;
+        }
+
+        var width = 0f;
+
+        for (; index < pieces.Count; index++)
+        {
+            var piece = pieces[index];
+
+            if (piece.Kind is InlinePieceKind.ForcedBreak or InlinePieceKind.BlockInInline or InlinePieceKind.Space)
+            {
+                break;
+            }
+
+            width += piece.Width;
+
+            if (piece.BreakAfter)
+            {
+                break;
+            }
+        }
+
+        return width;
+    }
+
     private static int BuildLine(List<InlinePiece> pieces, int start, float available, LayoutContext context, out bool forcedBreak)
     {
         forcedBreak = false;
@@ -1268,17 +1333,11 @@ private static void TruncateLineWithEllipsis(List<InlinePiece> linePieces, float
     }
 
     /// <summary>
-    /// The longest grapheme-cluster prefix of <paramref name="text"/> that fits into <paramref name="width"/>.
+    /// The longest cluster prefix of <paramref name="text"/> that fits into <paramref name="width"/>.
     /// </summary>
     private static string FitTextPrefix(LayoutContext context, string text, float width, RenderTextStyle style)
     {
-        var boundaries = new List<int>();
-        var enumerator = StringInfo.GetTextElementEnumerator(text);
-
-        while (enumerator.MoveNext())
-        {
-            boundaries.Add(enumerator.ElementIndex + ((string)enumerator.Current).Length);
-        }
+        var boundaries = GetClusterEnds(context, text, style);
 
         var low = 0;
         var high = boundaries.Count;
@@ -1433,8 +1492,7 @@ private static float EmitLine(
 
         var lineHeight = Math.Max(maxAbove + maxBelow, edgeAlignedHeight);
         var baselineY = lineTop + maxAbove;
-        RecordColumnContentStart(lineTop);
-        RecordColumnBreakCandidate(lineTop + lineHeight);
+        RecordColumnLine(lineTop, lineTop + lineHeight);
 
         PaintInlineBoxFragments(linePieces, baselineY, displayList);
 
@@ -1455,6 +1513,7 @@ private static float EmitLine(
                 while (runEnd < visualOrder.Count &&
                        visualOrder[runEnd].Kind is InlinePieceKind.Text or InlinePieceKind.Space &&
                        visualOrder[runEnd].StyleId == piece.StyleId &&
+                       visualOrder[runEnd].Style.IsRightToLeftRun == piece.Style.IsRightToLeftRun &&
                        ReferenceEquals(visualOrder[runEnd].Box, piece.Box) &&
                        !(splitAtSpaces && (visualOrder[runEnd].Kind == InlinePieceKind.Space || visualOrder[runEnd - 1].Kind == InlinePieceKind.Space)) &&
                        !visualOrder[runEnd].IsTab && !visualOrder[runEnd - 1].IsTab)
@@ -1480,11 +1539,12 @@ visualOrder[runEnd].Kind is InlinePieceKind.Text or InlinePieceKind.Space &&
                     }
                 }
 
+                // A right-to-left run is shaped from its logical text: its pieces in reverse.
                 var run = new StringBuilder();
 
                 for (var runIndex = first; runIndex <= last; runIndex++)
                 {
-                    run.Append(visualOrder[runIndex].Text);
+                    run.Append(visualOrder[piece.Style.IsRightToLeftRun ? first + last - runIndex : runIndex].Text);
                 }
 
                 var text = run.ToString();
@@ -1494,7 +1554,17 @@ visualOrder[runEnd].Kind is InlinePieceKind.Text or InlinePieceKind.Space &&
                 {
                     var runX = visualOrder[first].X;
                     var textBaseline = baselineY + piece.Style.VerticalAlignOffset;
-                    DrawStyledText(context, displayList, text, runX, textBaseline, piece.Style);
+
+                    // shaped with the context of its logically first and last pieces
+                    var logicalFirst = visualOrder[piece.Style.IsRightToLeftRun ? last : first];
+                    var logicalLast = visualOrder[piece.Style.IsRightToLeftRun ? first : last];
+                    var runStyle = piece.Style with
+                    {
+                        ShapingContextBefore = logicalFirst.Style.ShapingContextBefore,
+                        ShapingContextAfter = logicalLast.Style.ShapingContextAfter,
+                    };
+
+                    DrawStyledText(context, displayList, text, runX, textBaseline, runStyle);
                 }
 
                 index = runEnd;
@@ -1660,21 +1730,20 @@ private static List<InlinePiece> ReorderLine(List<InlinePiece> linePieces, bool
                 var last = Math.Max(order[position], order[end]) - pieceStarts[owner];
                 var fragment = piece.Text.Substring(first, last - first + 1);
 
-                if ((level & 1) == 1)
-                {
-                    fragment = ReverseForDisplay(fragment);
-                }
+                // A right-to-left fragment stays in logical order; shaping reverses and mirrors it.
+                var fragmentIsRightToLeft = (level & 1) == 1;
 
-                if (first == 0 && last == piece.Text.Length - 1 && (level & 1) == 0)
+                if (first == 0 && last == piece.Text.Length - 1 && fragmentIsRightToLeft == piece.Style.IsRightToLeftRun)
                 {
                     result.Add(piece);
                 }
                 else
                 {
+                    var style = piece.Style with { IsRightToLeftRun = fragmentIsRightToLeft };
                     var width = piece.Kind == InlinePieceKind.Space && fragment.Length == piece.Text.Length
                         ? piece.Width
-                        : MeasureTextWidth(context, fragment, piece.Style) + (piece.Kind == InlinePieceKind.Space ? piece.Style.WordSpacing * fragment.Length : 0f);
-                    result.Add(piece.WithText(fragment, width));
+                        : MeasureTextWidth(context, fragment, style) + (piece.Kind == InlinePieceKind.Space ? style.WordSpacing * fragment.Length : 0f);
+                    result.Add(piece.WithText(fragment, width, style));
                 }
             }
             else if (position == end || !result.Contains(piece))
@@ -1690,28 +1759,62 @@ private static List<InlinePiece> ReorderLine(List<InlinePiece> linePieces, bool
     }
 
     /// <summary>
-    /// Right-to-left text in visual order: reversed by grapheme cluster (so combining marks and
-    /// surrogate pairs stay intact) and mirrored.
+    /// Gives every text piece that touches another one across an inline box edge (no space or
+    /// anything else between them, e.g. <c>ab&lt;b&gt;cd&lt;/b&gt;</c>) a few characters of its
+    /// neighbours as shaping context, so contextual forms such as Arabic joining continue across
+    /// the element boundary, and measures it again with that context.
     /// </summary>
-    private static string ReverseForDisplay(string text)
+    private static void ApplyShapingContext(List<InlinePiece> pieces, LayoutContext context)
     {
-        var elements = new List<string>();
-        var enumerator = System.Globalization.StringInfo.GetTextElementEnumerator(text);
+        // HarfBuzz looks at no more than a handful of characters of context
+        const int ContextLength = 8;
+        var before = new string?[pieces.Count];
+        var after = new string?[pieces.Count];
+        var previous = -1;
+        var any = false;
 
-        while (enumerator.MoveNext())
+        for (var index = 0; index < pieces.Count; index++)
         {
-            elements.Add(enumerator.GetTextElement());
-        }
+            var piece = pieces[index];
 
-        var builder = new StringBuilder(text.Length);
+            if (piece.Kind is InlinePieceKind.BoxStart or InlinePieceKind.BoxEnd)
+            {
+                continue;
+            }
 
-        for (var index = elements.Count - 1; index >= 0; index--)
+            if (piece.Kind != InlinePieceKind.Text || piece.Text.Length == 0)
+            {
+                previous = -1;
+                continue;
+            }
+
+            if (previous >= 0 && !ReferenceEquals(pieces[previous].Box, piece.Box))
+            {
+                var previousText = pieces[previous].Text;
+                before[index] = previousText[Math.Max(0, previousText.Length - ContextLength)..];
+                after[previous] = piece.Text[..Math.Min(piece.Text.Length, ContextLength)];
+                any = true;
+            }
+
+            previous = index;
+        }
+
+        if (!any)
         {
-            var element = elements[index];
-            builder.Append(element.Length == 1 ? BidiAlgorithm.Mirror(element[0]) : element);
+            return;
         }
 
-        return builder.ToString();
+        for (var index = 0; index < pieces.Count; index++)
+        {
+            if (before[index] is null && after[index] is null)
+            {
+                continue;
+            }
+
+            var piece = pieces[index];
+            var style = piece.Style with { ShapingContextBefore = before[index], ShapingContextAfter = after[index] };
+            pieces[index] = piece.WithText(piece.Text, MeasureTextWidth(context, piece.Text, style), style);
+        }
     }
 
     /// <summary>
@@ -1908,7 +2011,9 @@ private static AtomicInlineMeasurement MeasureAtomicInline(ElementRenderNode ele
     /// <summary>
     /// Lays out <paramref name="element"/> at the origin into a throwaway display list, capturing
     /// its own border box and the last text baseline painted inside it. Layout metrics recorded
-    /// during the trial never reach a real <see cref="CaptureLayoutMetrics"/> capture.
+    /// during the trial never reach a real <see cref="CaptureLayoutMetrics"/> capture. A flex or
+    /// grid item is blockified and lays out its contents as a block of its own (e.g. a
+    /// <c>&lt;span&gt;</c> item gets the height of its line boxes, not of its inline box).
     /// </summary>
     private static (ElementLayoutMetrics? Metrics, float? LastBaselineY, float? FirstBaselineY) TrialLayout(
         ElementRenderNode element,
@@ -1916,12 +2021,28 @@ private static (ElementLayoutMetrics? Metrics, float? LastBaselineY, float? Firs
         RenderTextStyle inheritedStyle,
         LayoutContext context,
         float forcedBorderBoxWidth,
-        bool isAtomicInline)
+        bool isAtomicInline,
+        bool isFlexOrGridItem = false)
     {
         var capture = new LayoutCapture();
         var previous = s_layoutCapture.Value;
         s_layoutCapture.Value = capture;
 
+        // a trial is laid out elsewhere, so its lines are no column break candidates
+        var previousColumnBreaks = s_columnBreakCapture.Value;
+        s_columnBreakCapture.Value = null;
+
+        // a trial must not use up the lines of a clamped box it is measured in
+        var lineClamp = context.LineClampScopes.TryPeek(out var scope) ? scope : null;
+
+        if (lineClamp is not null)
+        {
+            context.LineClampScopes.Push(lineClamp.Clone());
+        }
+
+        // the sticky boxes of a trial are never placed
+        context.StickyFlows.Push([]);
+
         try
         {
             var cursorY = 0f;
@@ -1945,7 +2066,8 @@ private static (ElementLayoutMetrics? Metrics, float? LastBaselineY, float? Firs
                 displayList: new DisplayList { Fonts = context.Fonts },
                 maxY: float.MaxValue,
                 forcedBorderBoxWidth: forcedBorderBoxWidth,
-                isAtomicInline: isAtomicInline);
+                isAtomicInline: isAtomicInline,
+                isFlexItem: isFlexOrGridItem);
 
             var snapshot = capture.Snapshot();
             return (snapshot.TryGetValue(element.Ref, out var metrics) ? metrics : null, capture.LastBaselineY, capture.FirstBaselineY);
@@ -1953,6 +2075,14 @@ private static (ElementLayoutMetrics? Metrics, float? LastBaselineY, float? Firs
         finally
         {
             s_layoutCapture.Value = previous;
+            s_columnBreakCapture.Value = previousColumnBreaks;
+
+            context.StickyFlows.Pop();
+
+            if (lineClamp is not null)
+            {
+                context.LineClampScopes.Pop();
+            }
         }
     }
 
@@ -2039,6 +2169,17 @@ private static bool TryResolveReplacedContentWidth(ElementRenderNode element, Di
         return true;
     }
 
+    /// <summary>
+    /// An auto content height within <c>min-height</c> and <c>max-height</c>, as LayoutElement
+    /// clamps it once the content is laid out.
+    /// </summary>
+    private static float ClampToMinMaxHeight(Dictionary<string, string> styleMap, float contentHeight, float heightReference, float verticalExtras)
+    {
+        contentHeight = Math.Max(contentHeight, ResolveAuthoredDimension(styleMap, "min-height", heightReference, 0f, verticalExtras));
+        var maxHeight = ResolveAuthoredDimension(styleMap, "max-height", heightReference, float.NaN, verticalExtras);
+        return float.IsNaN(maxHeight) ? contentHeight : Math.Min(contentHeight, maxHeight);
+    }
+
     private static float ClampToMinMaxWidth(Dictionary<string, string> styleMap, float contentWidth, float containingWidth, float horizontalExtras)
     {
         var maxWidth = ResolveAuthoredDimension(styleMap, "max-width", containingWidth, float.NaN, horizontalExtras);
diff --git a/src/AngleSharp.Renderer/HtmlRenderer.Sticky.cs b/src/AngleSharp.Renderer/HtmlRenderer.Sticky.cs
index de811cc..f882000 100644
--- a/src/AngleSharp.Renderer/HtmlRenderer.Sticky.cs
+++ b/src/AngleSharp.Renderer/HtmlRenderer.Sticky.cs
@@ -1,5 +1,7 @@
 namespace AngleSharp.Renderer;
 
+using System.Linq;
+
 using AngleSharp.Css.RenderTree;
 using AngleSharp.Dom;
 using AngleSharp.Renderer.Rendering;
@@ -35,6 +37,18 @@ private sealed record StickyBox(
         Dictionary<string, string> Style,
         ElementLayoutMetrics Metrics);
 
+    /// <summary>
+    /// A sticky box inside a writing-mode system, whose offset waits until the system is placed:
+    /// its commands are already wrapped in <paramref name="Placeholder"/>, and
+    /// <paramref name="ToOuter"/> maps its coordinates to those of the systems placed so far.
+    /// </summary>
+    private sealed record DeferredStickyBox(
+        DisplayList DisplayList,
+        PushTransformCommand Placeholder,
+        StickyBox Sticky,
+        RenderRect ContainingBlock,
+        RenderTransform2D ToOuter);
+
     /// <summary>Catches the metrics a sticky element records for itself while it is laid out.</summary>
     private sealed class StickyProbe(IElement element)
     {
@@ -161,11 +175,22 @@ private static void ResolveStickyBoxes(DisplayList displayList, List<StickyBox>
             }
 
             var count = Math.Min(sticky.Count, commands.Count - start);
-            var (offsetX, offsetY) = ComputeStickyOffset(sticky, containingBlock, context);
 
             // A sticky box is positioned, so it paints over the in-flow content after it.
             displayList.MoveRangeToEnd(start, count);
 
+            // Inside a writing-mode system the viewport is only known once the system is placed.
+            if (context.StickyFlows.TryPeek(out var flow))
+            {
+                var placeholder = new PushTransformCommand(RenderTransform2D.Identity);
+                displayList.InsertRange(displayList.Commands.Count - count, [placeholder]);
+                displayList.PopTransform();
+                flow.Add(new DeferredStickyBox(displayList, placeholder, sticky, containingBlock, RenderTransform2D.Identity));
+                continue;
+            }
+
+            var (offsetX, offsetY) = ComputeStickyOffset(sticky, containingBlock, GetStickyViewport(context));
+
             if (offsetX == 0f && offsetY == 0f)
             {
                 continue;
@@ -173,39 +198,104 @@ private static void ResolveStickyBoxes(DisplayList displayList, List<StickyBox>
 
             displayList.InsertRange(displayList.Commands.Count - count, [new PushTransformCommand(RenderTransform2D.Translate(offsetX, offsetY))]);
             displayList.PopTransform();
+            RecordStickyMetrics(sticky, offsetX, offsetY);
+        }
+    }
+
+    /// <summary>
+    /// Places the sticky boxes of a writing-mode system once the transform from its coordinates
+    /// to the enclosing ones is known: inside another system they wait for that one, else they
+    /// stick against the viewport as seen in their own coordinates, where their (logical)
+    /// insets apply.
+    /// </summary>
+    private static void ResolveFlowStickyBoxes(List<DeferredStickyBox> stickyBoxes, RenderTransform2D toOuter, LayoutContext context)
+    {
+        if (stickyBoxes.Count == 0)
+        {
+            return;
+        }
 
-            var metrics = sticky.Metrics;
-            RecordLayoutMetrics(
-                sticky.Element,
-                metrics.BorderBoxX + offsetX,
-                metrics.BorderBoxY + offsetY,
-                metrics.BorderBoxWidth,
-                metrics.BorderBoxHeight,
-                metrics.BorderLeft,
-                metrics.BorderRight,
-                metrics.BorderTop,
-                metrics.BorderBottom,
-                metrics.PaddingLeft,
-                metrics.PaddingRight,
-                metrics.PaddingTop,
-                metrics.PaddingBottom);
+        if (context.StickyFlows.TryPeek(out var outerFlow))
+        {
+            outerFlow.AddRange(stickyBoxes.Select(deferred => deferred with { ToOuter = RenderTransform2D.Multiply(toOuter, deferred.ToOuter) }));
+            return;
+        }
+
+        var viewport = GetStickyViewport(context);
+
+        foreach (var deferred in stickyBoxes)
+        {
+            var toPage = RenderTransform2D.Multiply(toOuter, deferred.ToOuter);
+            var localViewport = MapRect(Invert(toPage), viewport);
+            var (offsetX, offsetY) = ComputeStickyOffset(deferred.Sticky, deferred.ContainingBlock, localViewport);
+
+            if ((offsetX != 0f || offsetY != 0f) &&
+                deferred.DisplayList.ReplaceCommand(deferred.Placeholder, new PushTransformCommand(RenderTransform2D.Translate(offsetX, offsetY))))
+            {
+                RecordStickyMetrics(deferred.Sticky, offsetX, offsetY);
+            }
+        }
+
+        static RenderTransform2D Invert(RenderTransform2D m)
+        {
+            var determinant = (m.A * m.D) - (m.B * m.C);
+            return new RenderTransform2D(
+                m.D / determinant,
+                -m.B / determinant,
+                -m.C / determinant,
+                m.A / determinant,
+                ((m.C * m.F) - (m.D * m.E)) / determinant,
+                ((m.B * m.E) - (m.A * m.F)) / determinant);
+        }
+
+        static RenderRect MapRect(RenderTransform2D m, RenderRect rect)
+        {
+            var corners = new[] { (rect.X, rect.Y), (rect.X + rect.Width, rect.Y), (rect.X, rect.Y + rect.Height), (rect.X + rect.Width, rect.Y + rect.Height) }
+                .Select(corner => ((m.A * corner.Item1) + (m.C * corner.Item2) + m.E, (m.B * corner.Item1) + (m.D * corner.Item2) + m.F))
+                .ToArray();
+            var left = corners.Min(corner => corner.Item1);
+            var top = corners.Min(corner => corner.Item2);
+            return new RenderRect(left, top, corners.Max(corner => corner.Item1) - left, corners.Max(corner => corner.Item2) - top);
         }
     }
 
+    /// <summary>The viewport sticky boxes stay inside, in page coordinates.</summary>
+    private static RenderRect GetStickyViewport(LayoutContext context) =>
+        new(context.Padding, context.Padding, context.Width - (2f * context.Padding), context.Height - (2f * context.Padding));
+
+    private static void RecordStickyMetrics(StickyBox sticky, float offsetX, float offsetY)
+    {
+        var metrics = sticky.Metrics;
+        RecordLayoutMetrics(
+            sticky.Element,
+            metrics.BorderBoxX + offsetX,
+            metrics.BorderBoxY + offsetY,
+            metrics.BorderBoxWidth,
+            metrics.BorderBoxHeight,
+            metrics.BorderLeft,
+            metrics.BorderRight,
+            metrics.BorderTop,
+            metrics.BorderBottom,
+            metrics.PaddingLeft,
+            metrics.PaddingRight,
+            metrics.PaddingTop,
+            metrics.PaddingBottom);
+    }
+
     /// <summary>
     /// How far a sticky box moves from its natural position: far enough to stay
     /// <c>top</c>/<c>bottom</c>/<c>left</c>/<c>right</c> inside the viewport (<c>top</c> wins over
     /// <c>bottom</c>, <c>left</c> over <c>right</c>), but never so far that its margin box leaves
     /// the containing block.
     /// </summary>
-    private static (float X, float Y) ComputeStickyOffset(StickyBox sticky, RenderRect containingBlock, LayoutContext context)
+    private static (float X, float Y) ComputeStickyOffset(StickyBox sticky, RenderRect containingBlock, RenderRect viewport)
     {
         var style = sticky.Style;
         var box = sticky.Metrics;
-        var viewportLeft = context.Padding;
-        var viewportTop = context.Padding;
-        var viewportRight = context.Width - context.Padding;
-        var viewportBottom = context.Height - context.Padding;
+        var viewportLeft = viewport.X;
+        var viewportTop = viewport.Y;
+        var viewportRight = viewport.X + viewport.Width;
+        var viewportBottom = viewport.Y + viewport.Height;
         var viewportWidth = viewportRight - viewportLeft;
         var viewportHeight = viewportBottom - viewportTop;
 
diff --git a/src/AngleSharp.Renderer/HtmlRenderer.Tables.cs b/src/AngleSharp.Renderer/HtmlRenderer.Tables.cs
index b373ee3..f0bf610 100644
--- a/src/AngleSharp.Renderer/HtmlRenderer.Tables.cs
+++ b/src/AngleSharp.Renderer/HtmlRenderer.Tables.cs
@@ -2,8 +2,10 @@ namespace AngleSharp.Renderer;
 
 using System.Globalization;
 using System.Linq;
+using System.Runtime.CompilerServices;
 
 using AngleSharp.Css.Dom;
+using AngleSharp.Css.Parser;
 using AngleSharp.Css.RenderTree;
 using AngleSharp.Dom;
 using AngleSharp.Renderer.Rendering;
@@ -86,6 +88,187 @@ private sealed class TableStructure
         public required bool CollapseBorders { get; init; }
     }
 
+    /// <summary>
+    /// The detached elements standing in for anonymous table boxes, so hit testing can skip them.
+    /// </summary>
+    private static readonly ConditionalWeakTable<IElement, object> s_anonymousTableBoxes = new();
+
+    private static bool IsAnonymousTableBox(IElement element) => s_anonymousTableBoxes.TryGetValue(element, out _);
+
+    private static string GetTableRole(IRenderNode node) =>
+        node is ElementRenderNode element ? element.ComputedStyle.GetDisplay()?.Trim().ToLowerInvariant() ?? string.Empty : string.Empty;
+
+    private static bool IsRowGroupRole(string role) => role is "table-row-group" or "table-header-group" or "table-footer-group";
+
+    /// <summary>The children a table box takes as they are (CSS 2.1 §17.2.1, "proper table child").</summary>
+    private static bool IsProperTableChildRole(string role) =>
+        role is "table-row" or "table-caption" or "table-column" or "table-column-group" || IsRowGroupRole(role);
+
+    /// <summary>
+    /// Nodes that never generate a box of their own: collapsible white space and
+    /// <c>display: none</c> elements. They neither start nor break a run of table parts.
+    /// </summary>
+    private static bool IsTableNeutral(IRenderNode node) => node switch
+    {
+        TextRenderNode text => NormalizeWhitespace(text.Ref.Data).Length == 0,
+        ElementRenderNode => !GeneratesBoxes(node),
+        _ => false,
+    };
+
+    /// <summary>
+    /// Generates the anonymous table objects of CSS 2.1 §17.2.1 in the render tree, so that the
+    /// table layout only ever sees well-formed tables: content of a table or row group that is
+    /// not a row is wrapped in an anonymous row, content of a row that is not a cell in an
+    /// anonymous cell, consecutive cells outside a row in an anonymous row, and consecutive rows,
+    /// row groups, captions and columns outside a table in an anonymous table. White space between
+    /// table parts is dropped. An anonymous box is a detached element whose computed style holds
+    /// its <c>display</c> plus the inherited properties of its parent, so everything else is its
+    /// initial value. Runs once per render, before anything reads the tree; a second pass would
+    /// find nothing left to wrap.
+    /// </summary>
+    private static void BuildAnonymousTableBoxes(IRenderNode node)
+    {
+        if (node is ElementRenderNode element && element.Children is List<IRenderNode> children &&
+            element.Ref is not IPseudoElement && GeneratesBoxes(element) && !IsReplacedElement(element.Ref))
+        {
+            var role = GetTableRole(element);
+
+            switch (role)
+            {
+                case "table" or "inline-table":
+                    WrapMissingChildren(element, children, child => !IsProperTableChildRole(GetTableRole(child)), "table-row");
+                    break;
+                case "table-row-group" or "table-header-group" or "table-footer-group":
+                    WrapMissingChildren(element, children, child => GetTableRole(child) != "table-row", "table-row");
+                    break;
+                case "table-row":
+                    WrapMissingChildren(element, children, child => GetTableRole(child) != "table-cell", "table-cell");
+                    break;
+                case "table-column" or "table-column-group":
+                    break;
+                default:
+                    WrapMissingParents(element, children, child => GetTableRole(child) == "table-cell", "table-row");
+                    WrapMissingParents(element, children, child => IsProperTableChildRole(GetTableRole(child)), role is "inline" ? "inline-table" : "table");
+                    break;
+            }
+        }
+
+        foreach (var child in node.Children)
+        {
+            BuildAnonymousTableBoxes(child);
+        }
+    }
+
+    /// <summary>
+    /// Wraps every run of children matching <paramref name="isMisplaced"/> into an anonymous box.
+    /// A run that would generate nothing (white space, <c>display: none</c>) is not wrapped and
+    /// its white space is dropped.
+    /// </summary>
+    private static void WrapMissingChildren(ElementRenderNode parent, List<IRenderNode> children, Func<IRenderNode, bool> isMisplaced, string display)
+    {
+        var result = new List<IRenderNode>(children.Count);
+        var run = new List<IRenderNode>();
+
+        void Flush()
+        {
+            if (run.All(IsTableNeutral))
+            {
+                result.AddRange(run.Where(node => node is not TextRenderNode));
+            }
+            else
+            {
+                result.Add(CreateAnonymousTableBox(parent, display, run));
+            }
+
+            run = [];
+        }
+
+        foreach (var child in children)
+        {
+            if (isMisplaced(child))
+            {
+                run.Add(child);
+                continue;
+            }
+
+            Flush();
+            result.Add(child);
+        }
+
+        Flush();
+        children.Clear();
+        children.AddRange(result);
+    }
+
+    /// <summary>
+    /// Wraps every run of consecutive children matching <paramref name="isOrphan"/> into an
+    /// anonymous box. White space and <c>display: none</c> elements between them belong to the run
+    /// (the white space is dropped); those before the first and after the last stay outside.
+    /// </summary>
+    private static void WrapMissingParents(ElementRenderNode parent, List<IRenderNode> children, Func<IRenderNode, bool> isOrphan, string display)
+    {
+        if (!children.Any(isOrphan))
+        {
+            return;
+        }
+
+        var result = new List<IRenderNode>(children.Count);
+        var index = 0;
+
+        while (index < children.Count)
+        {
+            if (!isOrphan(children[index]))
+            {
+                result.Add(children[index++]);
+                continue;
+            }
+
+            var run = new List<IRenderNode>();
+            var end = index;
+
+            for (var next = index; next < children.Count && (isOrphan(children[next]) || IsTableNeutral(children[next])); next++)
+            {
+                if (isOrphan(children[next]))
+                {
+                    end = next;
+                }
+            }
+
+            for (var member = index; member <= end; member++)
+            {
+                if (children[member] is not TextRenderNode)
+                {
+                    run.Add(children[member]);
+                }
+            }
+
+            result.Add(CreateAnonymousTableBox(parent, display, run));
+            index = end + 1;
+        }
+
+        children.Clear();
+        children.AddRange(result);
+    }
+
+    private static ElementRenderNode CreateAnonymousTableBox(ElementRenderNode parent, string display, List<IRenderNode> children)
+    {
+        var document = parent.Ref.Owner!;
+        var element = document.CreateElement("div");
+        var style = new CssParser(new CssParserOptions(), document.Context).ParseDeclaration(string.Empty)!;
+
+        foreach (var property in parent.ComputedStyle)
+        {
+            if (property.CanBeInherited && !string.IsNullOrEmpty(property.Value))
+            {
+                style.SetProperty(property.Name, property.Value);
+            }
+        }
+
+        style.SetProperty("display", display);
+        s_anonymousTableBoxes.AddOrUpdate(element, display);
+        return new ElementRenderNode(element, parent, children, style, style);
+    }
+
     private static bool HasDisplay(ElementRenderNode node, string display) =>
         string.Equals(node.ComputedStyle.GetDisplay()?.Trim(), display, StringComparison.OrdinalIgnoreCase);
 
@@ -740,7 +923,8 @@ private static void LayoutTable(
         float positionedContainingY,
         float positionedContainingWidth,
         float positionedContainingHeight,
-        float forcedBorderBoxWidth)
+        float forcedBorderBoxWidth,
+        float containingHeight = float.NaN)
     {
         var structure = GetTableStructure(tableNode, context);
         var styleMap = GetOrCreateStyleMap(context, tableNode.Ref, tableNode.ComputedStyle);
@@ -910,11 +1094,10 @@ float SpanWidth(TableCellInfo cell)
         var cellHeights = new float[cellCount];
         var cellBaselines = new float[cellCount];
 
-        // Percentage row and cell heights refer to the table's height, and count for nothing
-        // while that is not definite.
-        var definiteTableHeight = styleMap.TryGetValue("height", out var tableHeight) && TryParsePercentage(tableHeight, out _)
-            ? float.NaN
-            : ResolveAuthoredDimension(styleMap, "height", flowWidth, float.NaN, verticalExtras);
+        // A percentage table height refers to the containing block's height (and is `auto` while
+        // that is not definite); percentage row and cell heights refer to the table's height, and
+        // count for nothing while that is not definite.
+        var definiteTableHeight = ResolveAuthoredDimension(styleMap, "height", containingHeight, float.NaN, verticalExtras);
         var percentageHeightBase = float.IsNaN(definiteTableHeight) ? 0f : definiteTableHeight;
 
         for (var row = 0; row < rowCount; row++)
diff --git a/src/AngleSharp.Renderer/HtmlRenderer.Text.cs b/src/AngleSharp.Renderer/HtmlRenderer.Text.cs
index cf9fa2d..c08b423 100644
--- a/src/AngleSharp.Renderer/HtmlRenderer.Text.cs
+++ b/src/AngleSharp.Renderer/HtmlRenderer.Text.cs
@@ -246,6 +246,115 @@ private static float ParseFontStretch(Dictionary<string, string> styleMap, float
         return runs;
     }
 
+    /// <summary>
+    /// The inherited properties that select OpenType features, each as authored (or inherited).
+    /// </summary>
+    private readonly record struct FontFeatureProperties(string? Settings, string? Kerning, string? Ligatures, string? Numeric, string? EastAsian);
+
+    private static FontFeatureProperties ParseFontFeatureProperties(Dictionary<string, string> styleMap, FontFeatureProperties inherited)
+    {
+        return new FontFeatureProperties(
+            Read("font-feature-settings", inherited.Settings),
+            Read("font-kerning", inherited.Kerning),
+            Read("font-variant-ligatures", inherited.Ligatures),
+            Read("font-variant-numeric", inherited.Numeric),
+            Read("font-variant-east-asian", inherited.EastAsian));
+
+        string? Read(string propertyName, string? inheritedValue) =>
+            styleMap.TryGetValue(propertyName, out var value) && !string.IsNullOrWhiteSpace(value) ? value.Trim() : inheritedValue;
+    }
+
+    private static readonly IReadOnlyDictionary<string, string> s_featureKeywords = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
+    {
+        ["none"] = "liga=0,clig=0,dlig=0,hlig=0,calt=0",
+        ["common-ligatures"] = "liga,clig",
+        ["no-common-ligatures"] = "liga=0,clig=0",
+        ["discretionary-ligatures"] = "dlig",
+        ["no-discretionary-ligatures"] = "dlig=0",
+        ["historical-ligatures"] = "hlig",
+        ["no-historical-ligatures"] = "hlig=0",
+        ["contextual"] = "calt",
+        ["no-contextual"] = "calt=0",
+        ["lining-nums"] = "lnum",
+        ["oldstyle-nums"] = "onum",
+        ["proportional-nums"] = "pnum",
+        ["tabular-nums"] = "tnum",
+        ["diagonal-fractions"] = "frac",
+        ["stacked-fractions"] = "afrc",
+        ["ordinal"] = "ordn",
+        ["slashed-zero"] = "zero",
+        ["jis78"] = "jp78",
+        ["jis83"] = "jp83",
+        ["jis90"] = "jp90",
+        ["jis04"] = "jp04",
+        ["simplified"] = "smpl",
+        ["traditional"] = "trad",
+        ["full-width"] = "fwid",
+        ["proportional-width"] = "pwid",
+        ["ruby"] = "ruby",
+    };
+
+    /// <summary>
+    /// The OpenType features (HarfBuzz syntax, comma separated) the font properties select, in
+    /// the order of CSS Fonts 4 §7.2, so later ones win: <c>font-kerning</c>, the
+    /// <c>font-variant-*</c> keywords, then <c>font-feature-settings</c>. <see langword="null"/>
+    /// when everything is at its default.
+    /// </summary>
+    private static string? ResolveFontFeatures(FontFeatureProperties properties)
+    {
+        var features = new List<string>();
+
+        switch (properties.Kerning?.Trim().ToLowerInvariant())
+        {
+            case "none":
+                features.Add("kern=0");
+                break;
+            case "normal":
+                features.Add("kern=1");
+                break;
+        }
+
+        foreach (var value in new[] { properties.Ligatures, properties.Numeric, properties.EastAsian })
+        {
+            foreach (var keyword in (value ?? string.Empty).Split(' ', StringSplitOptions.RemoveEmptyEntries))
+            {
+                if (s_featureKeywords.TryGetValue(keyword, out var mapped))
+                {
+                    features.Add(mapped);
+                }
+            }
+        }
+
+        if (properties.Settings is { } settings && !string.Equals(settings.Trim(), "normal", StringComparison.OrdinalIgnoreCase))
+        {
+            foreach (var entry in settings.Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries))
+            {
+                var parts = entry.Split(' ', StringSplitOptions.RemoveEmptyEntries);
+                var tag = parts[0].Trim('"', '\'');
+
+                if (tag.Length != 4)
+                {
+                    continue;
+                }
+
+                var setting = parts.Length < 2 ? "1" : parts[1].ToLowerInvariant() switch
+                {
+                    "on" => "1",
+                    "off" => "0",
+                    var number when int.TryParse(number, NumberStyles.Integer, CultureInfo.InvariantCulture, out var parsed) && parsed >= 0 => parsed.ToString(CultureInfo.InvariantCulture),
+                    _ => null,
+                };
+
+                if (setting is not null)
+                {
+                    features.Add($"{tag}={setting}");
+                }
+            }
+        }
+
+        return features.Count == 0 ? null : string.Join(',', features);
+    }
+
     private static RenderTextStyle WithSmallCapsSize(RenderTextStyle style) =>
         style with { FontSize = style.FontSize * SmallCapsScale, VariantCaps = FontVariantCapsMode.Normal };
 
@@ -326,6 +435,11 @@ private static void DrawPlainText(DisplayList displayList, string text, float x,
             style.DecorationColor,
             style.DecorationStyle,
             style.LetterSpacing,
-            style.FontStretch);
+            style.FontStretch,
+            style.IsRightToLeftRun,
+            style.FontFeatures,
+            style.Language,
+            style.ShapingContextBefore,
+            style.ShapingContextAfter);
     }
 }
diff --git a/src/AngleSharp.Renderer/HtmlRenderer.WritingModes.cs b/src/AngleSharp.Renderer/HtmlRenderer.WritingModes.cs
index 6b1cd2c..820f2af 100644
--- a/src/AngleSharp.Renderer/HtmlRenderer.WritingModes.cs
+++ b/src/AngleSharp.Renderer/HtmlRenderer.WritingModes.cs
@@ -12,10 +12,11 @@ namespace AngleSharp.Renderer;
 /// </summary>
 /// <remarks>
 /// Layout always runs horizontally, in the logical coordinates of a <em>system</em>: x along the
-/// inline axis, y along the block axis. An element whose writing mode is orthogonal to the system
-/// its box sits in (a vertical element in horizontal content, or the reverse) starts a new system:
+/// inline axis, y along the block axis. An element whose writing mode runs along other axes than
+/// the system its box sits in (orthogonally, as a vertical element in horizontal content, or with
+/// the block direction reversed, as <c>vertical-lr</c> in <c>vertical-rl</c>) starts a new system:
 /// its content is laid out horizontally at the origin and its commands are wrapped in the
-/// transform that maps that system onto its content box (<see cref="ResolveOrthogonalFlowTransform"/>).
+/// transform that maps that system onto its content box (<see cref="ResolveFlowTransform"/>).
 /// The physical properties of every element whose box sits in a vertical system (width/height,
 /// margin/padding/border sides, insets, corners) are remapped to the logical ones when its style
 /// map is built. Text in a vertical system is drawn sideways by the system's rotation; upright
@@ -42,6 +43,14 @@ private enum TextOrientationKind
 
     private static bool IsVerticalMode(WritingModeKind mode) => mode != WritingModeKind.HorizontalTb;
 
+    /// <summary>
+    /// Whether content in <paramref name="mode"/> needs a system of its own inside
+    /// <paramref name="system"/>: its axes run differently, either orthogonally or (e.g.
+    /// <c>vertical-lr</c> in <c>vertical-rl</c>) with the block direction reversed.
+    /// </summary>
+    private static bool StartsWritingModeSystem(WritingModeKind mode, WritingModeKind system) =>
+        LogicalToPhysical(mode) != LogicalToPhysical(system);
+
     private static WritingModeKind ParseWritingMode(string? value, WritingModeKind inherited) =>
         value?.Trim().ToLowerInvariant() switch
         {
@@ -87,7 +96,7 @@ private static void ResolveWritingModeSystems(IRenderNode node, WritingModeKind
         if (node is ElementRenderNode element)
         {
             var ownMode = ParseWritingMode(element.ComputedStyle.GetPropertyValue("writing-mode"), WritingModeKind.HorizontalTb);
-            contentSystem = IsVerticalMode(ownMode) != IsVerticalMode(boxSystem) ? ownMode : boxSystem;
+            contentSystem = StartsWritingModeSystem(ownMode, boxSystem) ? ownMode : boxSystem;
 
             if (IsVerticalMode(boxSystem))
             {
@@ -110,10 +119,9 @@ private static void ResolveWritingModeSystems(IRenderNode node, WritingModeKind
     private static WritingModeKind GetContentSystem(IElement element, LayoutContext context) =>
         context.ContentSystems.TryGetValue(element, out var system) ? system : WritingModeKind.HorizontalTb;
 
-    /// <summary>Whether an element's content runs orthogonally to the system its box sits in.</summary>
-    private static bool IsOrthogonalFlow(IElement element, LayoutContext context) =>
-        IsVerticalMode(GetContentSystem(element, context)) !=
-        IsVerticalMode(context.BoxSystems.TryGetValue(element, out var boxSystem) ? boxSystem : WritingModeKind.HorizontalTb);
+    /// <summary>Whether an element's content is laid out in another system than its box.</summary>
+    private static bool StartsWritingModeSystem(IElement element, LayoutContext context) =>
+        StartsWritingModeSystem(GetContentSystem(element, context), context.BoxSystems.TryGetValue(element, out var boxSystem) ? boxSystem : WritingModeKind.HorizontalTb);
 
     /// <summary>
     /// The inline size of an orthogonal flow: the box's (logical) height when it has one, else
@@ -137,21 +145,118 @@ private static float ResolveOrthogonalInlineSize(ElementRenderNode node, Diction
     }
 
     /// <summary>
-    /// Lays out the content of an orthogonal flow at the origin of its own system, as a block
-    /// formatting context of the given inline size, and returns its block size.
+    /// Lays out the content of a system at its origin, as a block formatting context of the
+    /// given inline size, and returns its block size. Its sticky boxes are only placed once the
+    /// system is (see <see cref="ResolveFlowStickyBoxes"/>).
     /// </summary>
-    private static float LayoutOrthogonalFlowContent(IReadOnlyList<IRenderNode> children, RenderTextStyle flowStyle, float inlineSize, LayoutContext context, DisplayList displayList)
+    private static float LayoutOrthogonalFlowContent(IReadOnlyList<IRenderNode> children, RenderTextStyle flowStyle, float inlineSize, LayoutContext context, DisplayList displayList, out List<DeferredStickyBox> stickyBoxes)
     {
         var cursorY = 0f;
         var previousMarginBottom = 0f;
         var suppressTopMargin = false;
         var textIndentConsumed = false;
         var floats = new FloatArea();
+        stickyBoxes = [];
+        context.StickyFlows.Push(stickyBoxes);
+        context.StickyScopes.Push([]);
+
+        try
+        {
+            LayoutFlowChildren(children, 0f, 0f, inlineSize, ref cursorY, ref previousMarginBottom, ref suppressTopMargin, floats, ref textIndentConsumed, flowStyle, context, displayList, float.MaxValue, float.NaN, 0f, 0f, inlineSize, float.NaN, []);
 
-        LayoutFlowChildren(children, 0f, 0f, inlineSize, ref cursorY, ref previousMarginBottom, ref suppressTopMargin, floats, ref textIndentConsumed, flowStyle, context, displayList, float.MaxValue, float.NaN, 0f, 0f, inlineSize, float.NaN, []);
+            var blockSize = cursorY + previousMarginBottom;
+            blockSize = float.IsNaN(floats.Bottom) ? blockSize : Math.Max(blockSize, floats.Bottom);
+            ResolveStickyBoxes(displayList, context.StickyScopes.Peek(), new RenderRect(0f, 0f, inlineSize, blockSize), context);
+            return blockSize;
+        }
+        finally
+        {
+            context.StickyScopes.Pop();
+            context.StickyFlows.Pop();
+        }
+    }
+
+    private static bool IsItemContainer(Dictionary<string, string> styleMap) =>
+        IsFlexContainer(styleMap) || IsGridContainer(styleMap) ||
+        GetDisplay(styleMap) is "table" or "inline-table";
+
+    /// <summary>
+    /// The content of a flex, grid or table container in a system of its own: the container is
+    /// laid out again at the origin of that system, as a bare container of the given inline size
+    /// (and block size, when definite), so its items follow its own axes; its box (margins,
+    /// border, padding, background, positioning) is the block laid out in the enclosing system.
+    /// Returns the block size of the content.
+    /// </summary>
+    private static float LayoutContainerInOwnSystem(ElementRenderNode node, RenderTextStyle flowStyle, float inlineSize, float blockSize, LayoutContext context, DisplayList displayList, out List<DeferredStickyBox> stickyBoxes)
+    {
+        var element = node.Ref;
+        var map = CreateStyleMap(node.ComputedStyle, element, context);
+
+        if (IsVerticalMode(flowStyle.FlowMode))
+        {
+            RemapStyleMapToLogical(map, flowStyle.FlowMode);
+        }
+
+        foreach (var property in map.Keys.Where(IsBoxProperty).ToList())
+        {
+            map.Remove(property);
+            (map as StyleMap)?.ClearRawLength(property);
+        }
+
+        map["width"] = FormattableString.Invariant($"{inlineSize}px");
+
+        if (!float.IsNaN(blockSize))
+        {
+            map["height"] = FormattableString.Invariant($"{blockSize}px");
+        }
+
+        var hadMap = context.StyleMapCache.Remove(element, out var boxMap);
+        context.StyleMapCache[element] = map;
+        stickyBoxes = [];
+        context.StickyFlows.Push(stickyBoxes);
+        context.StickyScopes.Push([]);
+
+        try
+        {
+            var cursorY = 0f;
+            var previousMarginBottom = 0f;
+            var suppressTopMargin = false;
+            var textIndentConsumed = false;
+
+            LayoutNode(node, 0f, 0f, inlineSize, ref cursorY, ref previousMarginBottom, ref suppressTopMargin, new FloatArea(), ref textIndentConsumed, flowStyle, context, displayList, float.MaxValue);
+
+            ResolveStickyBoxes(displayList, context.StickyScopes.Peek(), new RenderRect(0f, 0f, inlineSize, cursorY), context);
+            return cursorY;
+        }
+        finally
+        {
+            context.StickyScopes.Pop();
+            context.StickyFlows.Pop();
+
+            if (hadMap)
+            {
+                context.StyleMapCache[element] = boxMap!;
+            }
+            else
+            {
+                context.StyleMapCache.Remove(element);
+            }
+        }
 
-        var blockSize = cursorY + previousMarginBottom;
-        return float.IsNaN(floats.Bottom) ? blockSize : Math.Max(blockSize, floats.Bottom);
+        // what the box in the enclosing system already does
+        static bool IsBoxProperty(string property) =>
+            property.StartsWith("margin", StringComparison.Ordinal) ||
+            property.StartsWith("padding", StringComparison.Ordinal) ||
+            (property.StartsWith("border", StringComparison.Ordinal) && property is not ("border-collapse" or "border-spacing")) ||
+            property.StartsWith("background", StringComparison.Ordinal) ||
+            property.StartsWith("outline", StringComparison.Ordinal) ||
+            property.StartsWith("mask", StringComparison.Ordinal) ||
+            property.StartsWith("min-", StringComparison.Ordinal) ||
+            property.StartsWith("max-", StringComparison.Ordinal) ||
+            property.StartsWith("overflow", StringComparison.Ordinal) ||
+            property is "height" or "box-shadow" or "box-sizing" or "position" or "top" or "right" or "bottom" or "left" or "inset" or
+                "float" or "clear" or "transform" or "translate" or "rotate" or "scale" or "opacity" or "filter" or "backdrop-filter" or
+                "z-index" or "clip-path" or "mix-blend-mode" or "aspect-ratio" or "-webkit-line-clamp" or "visibility";
     }
 
     /// <summary>
@@ -170,7 +275,10 @@ private static float MeasureOrthogonalBlockSize(ElementRenderNode element, Dicti
 
         try
         {
-            return LayoutOrthogonalFlowContent(OrderChildrenForPainting(element.Children, context).ToList(), flowStyle, inlineSize, context, new DisplayList { Fonts = context.Fonts });
+            var scratch = new DisplayList { Fonts = context.Fonts };
+            return IsItemContainer(styleMap)
+                ? LayoutContainerInOwnSystem(element, flowStyle, inlineSize, float.NaN, context, scratch, out _)
+                : LayoutOrthogonalFlowContent(OrderChildrenForPainting(element.Children, context).ToList(), flowStyle, inlineSize, context, scratch, out _);
         }
         finally
         {
@@ -239,11 +347,13 @@ private static void RemapStyleMapToLogical(Dictionary<string, string> map, Writi
     }
 
     /// <summary>
-    /// The transform that places the content of an orthogonal flow, laid out horizontally at the
-    /// origin with the given inline size, into its content box (given in the logical coordinates
-    /// of the system its box sits in): its inline axis runs along that system's block axis.
+    /// The transform that places the content of a system, laid out horizontally at the origin
+    /// with the given inline and block size, into its content box (given in the logical
+    /// coordinates of the system its box sits in): for an orthogonal flow its inline axis runs
+    /// along that system's block axis, for a parallel one (<c>vertical-lr</c> in
+    /// <c>vertical-rl</c>) its block axis runs the other way.
     /// </summary>
-    private static RenderTransform2D ResolveOrthogonalFlowTransform(WritingModeKind mode, WritingModeKind boxSystem, float contentX, float contentY, float contentWidth, float contentHeight)
+    private static RenderTransform2D ResolveFlowTransform(WritingModeKind mode, WritingModeKind boxSystem, float contentX, float contentY, float inlineSize, float blockSize)
     {
         var own = LogicalToPhysical(mode);
         var outer = LogicalToPhysical(boxSystem);
@@ -254,9 +364,8 @@ private static RenderTransform2D ResolveOrthogonalFlowTransform(WritingModeKind
         var c = (outer.A * own.C) + (outer.B * own.D);
         var d = (outer.C * own.C) + (outer.D * own.D);
 
-        // The content's inline size is the box's height, its block size the box's width; the
-        // corner the logical origin lands on is wherever the mapped box starts.
-        var corners = new[] { (0f, 0f), (contentHeight, 0f), (0f, contentWidth), (contentHeight, contentWidth) }
+        // The corner the logical origin lands on is wherever the mapped box starts.
+        var corners = new[] { (0f, 0f), (inlineSize, 0f), (0f, blockSize), (inlineSize, blockSize) }
             .Select(corner => ((a * corner.Item1) + (c * corner.Item2), (b * corner.Item1) + (d * corner.Item2)))
             .ToArray();
         var minX = corners.Min(corner => corner.Item1);
diff --git a/src/AngleSharp.Renderer/HtmlRenderer.cs b/src/AngleSharp.Renderer/HtmlRenderer.cs
index 7864d3f..428e938 100644
--- a/src/AngleSharp.Renderer/HtmlRenderer.cs
+++ b/src/AngleSharp.Renderer/HtmlRenderer.cs
@@ -125,12 +125,29 @@ private readonly record struct LayoutContext(
         Dictionary<(IElement Element, float Width), float> MeasuredHeights,
         Dictionary<IElement, WritingModeKind> BoxSystems,
         Dictionary<IElement, WritingModeKind> ContentSystems,
-        Dictionary<IElement, ICssStyleDeclaration> SpecifiedStyles)
+        Dictionary<IElement, ICssStyleDeclaration> SpecifiedStyles,
+        Stack<LineClampScope> LineClampScopes,
+        Stack<List<DeferredStickyBox>> StickyFlows)
     {
         // only needed for what the render tree does not hold (e.g. ::placeholder), so it is built on demand
         public IStyleCollection? StyleCollection => LazyStyleCollection.Value;
     }
 
+    /// <summary>
+    /// The lines a box with `-webkit-line-clamp` has left for its content. Every line laid out
+    /// inside it counts, in nested blocks too; once none is left, the rest of its content is not
+    /// laid out (so the box ends after the last line), and that line shows an ellipsis when
+    /// anything follows it.
+    /// </summary>
+    private sealed class LineClampScope(IElement root, int remaining)
+    {
+        public IElement Root { get; } = root;
+
+        public int Remaining { get; set; } = remaining;
+
+        public LineClampScope Clone() => new(Root, Remaining);
+    }
+
     private sealed class LayoutCapture
     {
         private readonly Dictionary<IElement, ElementLayoutMetrics> _metricsByElement = new(ReferenceEqualityComparer.Instance);
@@ -182,6 +199,12 @@ private static IReadOnlyDictionary<IElement, ElementLayoutMetrics> AddHitTestLay
 
         foreach (var (element, elementMetrics) in metrics)
         {
+            // Anonymous table boxes are not part of the document, so they are never hit.
+            if (IsAnonymousTableBox(element))
+            {
+                continue;
+            }
+
             result[element] = context.StyleMapCache.TryGetValue(element, out var styleMap)
                 ? elementMetrics with { Layer = ResolveHitTestLayer(element, styleMap, context) }
                 : elementMetrics;
@@ -305,7 +328,7 @@ private static LayoutContext CreateLayoutContext(IDocument document, IRenderDevi
             defaultFontFamily = styleMap.TryGetValue("font-family", out var family) && !string.IsNullOrWhiteSpace(family)
                 ? family.Trim('\'', '"', ' ')
                 : defaultFontFamily;
-            defaultLineHeight = ParseLineHeight(styleMap, defaultLineHeight);
+            defaultLineHeight = ParseLineHeight(styleMap, defaultFontSize, defaultLineHeight);
             defaultTextColor = ParseColor(styleMap.TryGetValue("color", out var colorValue) ? colorValue : null, defaultTextColor);
         }
 
@@ -360,7 +383,11 @@ private static LayoutContext CreateLayoutContext(IDocument document, IRenderDevi
             BoxSystems: new Dictionary<IElement, WritingModeKind>(ReferenceEqualityComparer.Instance),
             ContentSystems: new Dictionary<IElement, WritingModeKind>(ReferenceEqualityComparer.Instance),
             // The cascaded declarations of the render tree's elements (see GetExplicitDeclarations).
-            SpecifiedStyles: new Dictionary<IElement, ICssStyleDeclaration>(ReferenceEqualityComparer.Instance));
+            SpecifiedStyles: new Dictionary<IElement, ICssStyleDeclaration>(ReferenceEqualityComparer.Instance),
+            // The `-webkit-line-clamp` boxes being laid out, innermost on top (see LineClampScope).
+            LineClampScopes: new Stack<LineClampScope>(),
+            // The sticky boxes of the writing-mode systems being laid out (see ResolveFlowStickyBoxes).
+            StickyFlows: new Stack<List<DeferredStickyBox>>());
     }
 
     /// <summary>
@@ -478,6 +505,7 @@ private static DisplayList BuildDisplayListCore(IDocument document, RenderViewpo
         PrepareDocumentForRendering(document);
 
         var renderTree = window.Render(renderDevice);
+        BuildAnonymousTableBoxes(renderTree);
         CollectSpecifiedStyles(renderTree, context);
         ResolveWritingModeSystems(renderTree, WritingModeKind.HorizontalTb, context);
 
@@ -542,10 +570,11 @@ private static DisplayList BuildDisplayListCore(IDocument document, RenderViewpo
             var pageStyle = textStyle with { WritingMode = pageSystem, FlowMode = pageSystem };
             var inlineSize = Math.Max(0f, viewport.Height - (2f * context.Padding));
             var flowStart = displayList.Commands.Count;
-            LayoutOrthogonalFlowContent(OrderChildrenForPainting(root.Children, context).ToList(), pageStyle, inlineSize, context, displayList);
-            displayList.InsertRange(flowStart, [new PushTransformCommand(ResolveOrthogonalFlowTransform(pageSystem, WritingModeKind.HorizontalTb, contentX, contentY, contentWidth, inlineSize))]);
+            LayoutOrthogonalFlowContent(OrderChildrenForPainting(root.Children, context).ToList(), pageStyle, inlineSize, context, displayList, out var pageStickyBoxes);
+            var pageTransform = ResolveFlowTransform(pageSystem, WritingModeKind.HorizontalTb, contentX, contentY, inlineSize, contentWidth);
+            displayList.InsertRange(flowStart, [new PushTransformCommand(pageTransform)]);
             displayList.PopTransform();
-            context.StickyScopes.Peek().Clear();
+            ResolveFlowStickyBoxes(pageStickyBoxes, pageTransform, context);
         }
         else
         {
@@ -701,6 +730,12 @@ private static void LayoutNode(
         float contentOffsetY = 0f,
         bool mainAxisMarginsPlaced = false)
     {
+        // nothing after the last line of a clamped box is laid out
+        if (context.LineClampScopes.TryPeek(out var lineClamp) && lineClamp.Remaining <= 0)
+        {
+            return;
+        }
+
         switch (node)
         {
             case TextRenderNode textNode:
@@ -764,10 +799,17 @@ private static void LayoutElement(
 
         var display = GetDisplay(styleMap);
 
-        if (string.Equals(display, "table", StringComparison.OrdinalIgnoreCase) ||
-            string.Equals(display, "inline-table", StringComparison.OrdinalIgnoreCase))
+        // A flex, grid or table container in a writing-mode system of its own is laid out as a
+        // block, whose content is the container laid out again in that system (see
+        // LayoutContainerInOwnSystem).
+        var startsSystem = formControlKind == FormControlKind.None && !IsReplacedElement(element) &&
+                           StartsWritingModeSystem(ParseWritingMode(styleMap.GetValueOrDefault("writing-mode"), inheritedTextStyle.WritingMode), inheritedTextStyle.FlowMode);
+
+        if (!startsSystem &&
+            (string.Equals(display, "table", StringComparison.OrdinalIgnoreCase) ||
+             string.Equals(display, "inline-table", StringComparison.OrdinalIgnoreCase)))
         {
-            LayoutTable(node, containingX, containingWidth, ref cursorY, ref previousBlockMarginBottom, ref suppressNextBlockTopMargin, floats, inheritedTextStyle, context, displayList, maxY, positionedContainingX, positionedContainingY, positionedContainingWidth, positionedContainingHeight, forcedBorderBoxWidth);
+            LayoutTable(node, containingX, containingWidth, ref cursorY, ref previousBlockMarginBottom, ref suppressNextBlockTopMargin, floats, inheritedTextStyle, context, displayList, maxY, positionedContainingX, positionedContainingY, positionedContainingWidth, positionedContainingHeight, forcedBorderBoxWidth, containingHeight);
             return;
         }
 
@@ -825,9 +867,9 @@ private static void LayoutElement(
         var floatSide = GetFloat(styleMap);
         var isFloat = floatSide is "left" or "right";
         var isOutOfFlow = IsOutOfFlowPositioned(styleMap);
-        // An orthogonal flow (see HtmlRenderer.WritingModes.cs) is always a formatting context of its own.
+        // A writing-mode system of its own (see HtmlRenderer.WritingModes.cs) is always a formatting context of its own.
         var establishesContext = EstablishesBlockFormattingContext(styleMap, isFloat, isOutOfFlow, isAtomicInline, isFlexItem) ||
-                                 IsVerticalMode(currentTextStyle.WritingMode) != IsVerticalMode(inheritedTextStyle.FlowMode);
+                                 StartsWritingModeSystem(currentTextStyle.WritingMode, inheritedTextStyle.FlowMode);
 
         // `clear` moves a box below the floats on the side(s) it must not sit next to.
         var clearance = isOutOfFlow ? float.NaN : floats.GetClearance(GetClear(styleMap));
@@ -1245,7 +1287,7 @@ formControlKind is FormControlKind.Select or FormControlKind.Button ||
         // a control painting its own label (or selected option) has no children to lay out as items
         var layoutsItems = formControlKind is not (FormControlKind.Select or FormControlKind.Button);
 
-        if (layoutsItems && IsFlexContainer(styleMap))
+        if (layoutsItems && !startsSystem && IsFlexContainer(styleMap))
         {
             LayoutFlexContainer(
                 node,
@@ -1281,7 +1323,7 @@ formControlKind is FormControlKind.Select or FormControlKind.Button ||
             return;
         }
 
-        if (layoutsItems && IsGridContainer(styleMap))
+        if (layoutsItems && !startsSystem && IsGridContainer(styleMap))
         {
             LayoutGridContainer(
                 node,
@@ -1317,6 +1359,15 @@ formControlKind is FormControlKind.Select or FormControlKind.Button ||
         var isOrthogonalFlow = IsVerticalMode(currentTextStyle.WritingMode) != IsVerticalMode(inheritedTextStyle.FlowMode) &&
                                formControlKind == FormControlKind.None &&
                                !IsReplacedElement(element);
+        var isParallelFlow = !isOrthogonalFlow &&
+                             StartsWritingModeSystem(currentTextStyle.WritingMode, inheritedTextStyle.FlowMode) &&
+                             formControlKind == FormControlKind.None &&
+                             !IsReplacedElement(element);
+
+        if (currentTextStyle.LineClamp > 0)
+        {
+            context.LineClampScopes.Push(new LineClampScope(element, currentTextStyle.LineClamp));
+        }
 
         if (isOrthogonalFlow)
         {
@@ -1326,20 +1377,42 @@ formControlKind is FormControlKind.Select or FormControlKind.Button ||
             var flowStyle = currentTextStyle with { FlowMode = currentTextStyle.WritingMode };
             var inlineSize = ResolveOrthogonalInlineSize(node, styleMap, flowStyle, resolvedContentHeight, heightReference, verticalBorderAndPadding, context);
             var flowStart = displayList.Commands.Count;
-            var blockSize = LayoutOrthogonalFlowContent(orderedChildren, flowStyle, inlineSize, context, displayList);
+            var blockSize = IsItemContainer(styleMap)
+                ? LayoutContainerInOwnSystem(node, flowStyle, inlineSize, specifiedContentWidth, context, displayList, out var flowStickyBoxes)
+                : LayoutOrthogonalFlowContent(orderedChildren, flowStyle, inlineSize, context, displayList, out flowStickyBoxes);
 
             if (float.IsNaN(specifiedContentWidth) && float.IsNaN(forcedBorderBoxWidth))
             {
                 contentWidth = ClampToMinMaxWidth(styleMap, blockSize, flowContainingWidth, horizontalBorderAndPadding);
             }
 
-            displayList.InsertRange(flowStart, [new PushTransformCommand(ResolveOrthogonalFlowTransform(currentTextStyle.WritingMode, inheritedTextStyle.FlowMode, contentX, contentY + contentOffsetY, contentWidth, inlineSize))]);
+            var flowTransform = ResolveFlowTransform(currentTextStyle.WritingMode, inheritedTextStyle.FlowMode, contentX, contentY + contentOffsetY, inlineSize, contentWidth);
+            displayList.InsertRange(flowStart, [new PushTransformCommand(flowTransform)]);
             displayList.PopTransform();
+            ResolveFlowStickyBoxes(flowStickyBoxes, flowTransform, context);
             resolvedContentHeight = inlineSize;
             childCursorY = contentY + inlineSize;
-
-            // Sticky boxes in there were registered in the flow's own coordinates.
-            context.StickyScopes.Peek().Clear();
+        }
+        else if (isParallelFlow)
+        {
+            // A parallel flow (e.g. vertical-lr content in a vertical-rl box): the same inline
+            // axis, but its blocks stack the other way, so it is laid out on its own and flipped
+            // into the content box once its block size is known.
+            var flowStyle = currentTextStyle with { FlowMode = currentTextStyle.WritingMode };
+            var flowStart = displayList.Commands.Count;
+            var blockSize = IsItemContainer(styleMap)
+                ? LayoutContainerInOwnSystem(node, flowStyle, contentWidth, resolvedContentHeight, context, displayList, out var flowStickyBoxes)
+                : LayoutOrthogonalFlowContent(orderedChildren, flowStyle, contentWidth, context, displayList, out flowStickyBoxes);
+            var flowHeight = float.IsNaN(resolvedContentHeight)
+                ? ClampToMinMaxHeight(styleMap, blockSize, heightReference, verticalBorderAndPadding)
+                : resolvedContentHeight;
+
+            var flowTransform = ResolveFlowTransform(currentTextStyle.WritingMode, inheritedTextStyle.FlowMode, contentX, contentY + contentOffsetY, contentWidth, flowHeight);
+            displayList.InsertRange(flowStart, [new PushTransformCommand(flowTransform)]);
+            displayList.PopTransform();
+            ResolveFlowStickyBoxes(flowStickyBoxes, flowTransform, context);
+            resolvedContentHeight = flowHeight;
+            childCursorY = contentY + flowHeight;
         }
         else if (TryResolveColumnLayout(styleMap, contentWidth, currentTextStyle.FontSize, out var columnLayout))
         {
@@ -1384,6 +1457,11 @@ formControlKind is FormControlKind.Select or FormControlKind.Button ||
                 negativeZIndexRanges);
         }
 
+        if (currentTextStyle.LineClamp > 0)
+        {
+            context.LineClampScopes.Pop();
+        }
+
         // A box with its own formatting context grows to contain the floats inside it.
         if (establishesContext && !float.IsNaN(childFloats.Bottom))
         {
@@ -1486,6 +1564,13 @@ formControlKind is FormControlKind.Select or FormControlKind.Button ||
 
         if (TryResolveReplacedElementImage(node, styleMap, flowContainingWidth, borderBoxX + borderLeft + paddingLeft, borderBoxY + borderTop + paddingTop, out var image, out var imageRect, out var objectFitClipRect))
         {
+            var roundedContentClip = GetRoundedContentClip(box.BorderRadius, borderBoxX, borderBoxY, borderBoxWidth, borderBoxHeight, new EdgeSizes(borderTop, borderRight, borderBottom, borderLeft), new EdgeSizes(paddingTop, paddingRight, paddingBottom, paddingLeft));
+
+            if (roundedContentClip is { } contentClip)
+            {
+                displayList.PushClip(contentClip.Rect, contentClip.Radii);
+            }
+
             if (objectFitClipRect is { } objectFitClip)
             {
                 displayList.PushClip(objectFitClip, RenderCornerRadii.Zero);
@@ -1497,6 +1582,11 @@ formControlKind is FormControlKind.Select or FormControlKind.Button ||
             {
                 displayList.PopClip();
             }
+
+            if (roundedContentClip is not null)
+            {
+                displayList.PopClip();
+            }
         }
 
         if (clipsOverflow)
@@ -2270,6 +2360,13 @@ float EstimateCrossSize(FlexItemLayoutInfo item, float mainSize)
 
         if (TryResolveReplacedElementImage(node, styleMap, containingWidth, borderBoxX + borderLeft + paddingLeft, borderBoxY + borderTop + paddingTop, out var image, out var imageRect, out var objectFitClipRect))
         {
+            var roundedContentClip = GetRoundedContentClip(box.BorderRadius, borderBoxX, borderBoxY, borderBoxWidth, borderBoxHeight, new EdgeSizes(borderTop, borderRight, borderBottom, borderLeft), new EdgeSizes(paddingTop, paddingRight, paddingBottom, paddingLeft));
+
+            if (roundedContentClip is { } contentClip)
+            {
+                displayList.PushClip(contentClip.Rect, contentClip.Radii);
+            }
+
             if (objectFitClipRect is { } objectFitClip)
             {
                 displayList.PushClip(objectFitClip, RenderCornerRadii.Zero);
@@ -2281,6 +2378,11 @@ float EstimateCrossSize(FlexItemLayoutInfo item, float mainSize)
             {
                 displayList.PopClip();
             }
+
+            if (roundedContentClip is not null)
+            {
+                displayList.PopClip();
+            }
         }
 
         if (clipsOverflow)
@@ -2304,7 +2406,7 @@ void LayoutOutOfFlowChildren(float usedContentHeight)
 
                 if (isRowDirection && alignItems is "center" or "flex-end")
                 {
-                    var freeSpace = Math.Max(0f, usedContentHeight - MeasureBorderBoxHeight(child, containingWidth, inheritedTextStyle, context));
+                    var freeSpace = Math.Max(0f, usedContentHeight - MeasureBorderBoxHeight(child, containingWidth, inheritedTextStyle, context, isFlexItem: false));
                     childCursorY += alignItems == "center" ? freeSpace / 2f : freeSpace;
                 }
 
@@ -2728,6 +2830,8 @@ void MarkPlaced(GridPlacement column, GridPlacement row)
 
         var columnSizes = columns.Select(t => t.Pixels).ToList();
         var rowSizes = rows.Select(t => t.Pixels).ToList();
+        var columnAlignment = ResolveGridContentAlignment(justifyContent, columnSizes, resolvedColumnGap, containingWidth);
+        var rowAlignment = ResolveGridContentAlignment(styleMap.GetValueOrDefault("align-content")?.Trim().ToLowerInvariant(), rowSizes, resolvedRowGap, containerHeight);
 
         // Pass 2: lay out every item for real, against the now-fully-resolved track sizes.
         foreach (var child in gridItems)
@@ -2747,10 +2851,10 @@ void MarkPlaced(GridPlacement column, GridPlacement row)
 
             var contentX = borderBoxX + borderLeft + paddingLeft;
             var contentY = borderBoxY + borderTop + paddingTop;
-            var cellX = contentX + GetGridTrackOffset(columnSizes, effectivePlacementColumn.LineIndex, resolvedColumnGap);
-            var cellY = contentY + GetGridTrackOffset(rowSizes, effectivePlacementRow.LineIndex, resolvedRowGap);
-            var cellWidth = GetGridTrackSpanSize(columnSizes, effectivePlacementColumn.LineIndex, effectivePlacementColumn.Span, resolvedColumnGap, containingWidth);
-            var cellHeight = GetGridTrackSpanSize(rowSizes, effectivePlacementRow.LineIndex, effectivePlacementRow.Span, resolvedRowGap, containingWidth);
+            var cellX = contentX + columnAlignment.Offset + GetGridTrackOffset(columnSizes, effectivePlacementColumn.LineIndex, resolvedColumnGap + columnAlignment.Spacing);
+            var cellY = contentY + rowAlignment.Offset + GetGridTrackOffset(rowSizes, effectivePlacementRow.LineIndex, resolvedRowGap + rowAlignment.Spacing);
+            var cellWidth = GetGridTrackSpanSize(columnSizes, effectivePlacementColumn.LineIndex, effectivePlacementColumn.Span, resolvedColumnGap + columnAlignment.Spacing, containingWidth);
+            var cellHeight = GetGridTrackSpanSize(rowSizes, effectivePlacementRow.LineIndex, effectivePlacementRow.Span, resolvedRowGap + rowAlignment.Spacing, containingWidth);
             var childStyleMap = GetOrCreateStyleMap(context, elementChild.Ref, elementChild.ComputedStyle);
             var childBox = ResolveBoxStyle(childStyleMap, elementChild.Ref);
             var childHorizontalExtras = childBox.BorderWidth.Left + childBox.BorderWidth.Right + childBox.Padding.Left + childBox.Padding.Right;
@@ -2776,7 +2880,7 @@ void MarkPlaced(GridPlacement column, GridPlacement row)
 
             if (float.IsNaN(childContentHeight) && alignSelf != GridSelfAlignment.Stretch)
             {
-                var measured = TrialLayout(elementChild, childBorderBoxWidth, inheritedTextStyle, context, childBorderBoxWidth, isAtomicInline: false).Metrics?.BorderBoxHeight ?? 0f;
+                var measured = TrialLayout(elementChild, childBorderBoxWidth, inheritedTextStyle, context, childBorderBoxWidth, isAtomicInline: false, isFlexOrGridItem: true).Metrics?.BorderBoxHeight ?? 0f;
                 childContentHeight = Math.Max(0f, measured - childVerticalExtras);
                 resolvedChildContentHeight = childContentHeight;
             }
@@ -2922,6 +3026,55 @@ void MarkPlaced(GridPlacement column, GridPlacement row)
         suppressNextBlockTopMargin = false;
     }
 
+    /// <summary>
+    /// Where `justify-content`/`align-content` put the grid tracks within the content box when
+    /// they do not fill it (CSS Box Alignment 3 §5.1): the offset of the first track and the
+    /// spacing added to every gap. `normal`/`stretch` already grew the `auto` tracks instead.
+    /// Without a definite size there is no free space. Overflowing tracks still shift for `center`
+    /// and `end` (unless `safe`), while distributed alignment falls back to `start` or `center`.
+    /// </summary>
+    private static (float Offset, float Spacing) ResolveGridContentAlignment(string? value, IReadOnlyList<float> tracks, float gap, float available)
+    {
+        if (string.IsNullOrEmpty(value) || tracks.Count == 0 || float.IsNaN(available))
+        {
+            return (0f, 0f);
+        }
+
+        var isSafe = value.StartsWith("safe ", StringComparison.Ordinal);
+
+        if (isSafe || value.StartsWith("unsafe ", StringComparison.Ordinal))
+        {
+            value = value[(value.IndexOf(' ') + 1)..].Trim();
+        }
+
+        var freeSpace = available - tracks.Sum() - gap * (tracks.Count - 1);
+
+        if (freeSpace < 0f)
+        {
+            if (isSafe)
+            {
+                return (0f, 0f);
+            }
+
+            value = value switch
+            {
+                "space-between" => "start",
+                "space-around" or "space-evenly" => "center",
+                _ => value,
+            };
+        }
+
+        return value switch
+        {
+            "center" => (freeSpace / 2f, 0f),
+            "end" or "flex-end" or "right" => (freeSpace, 0f),
+            "space-between" when tracks.Count > 1 => (0f, freeSpace / (tracks.Count - 1)),
+            "space-around" => (freeSpace / tracks.Count / 2f, freeSpace / tracks.Count),
+            "space-evenly" => (freeSpace / (tracks.Count + 1), freeSpace / (tracks.Count + 1)),
+            _ => (0f, 0f),
+        };
+    }
+
     private static float GetGridTrackOffset(IReadOnlyList<float> tracks, int index, float gap)
     {
         if (index <= 0)
@@ -3296,6 +3449,31 @@ private static float ResolveGridTrackLength(ICssValue value, float relativeTo)
         return float.IsNaN(pixels) ? 0f : Math.Max(0f, pixels);
     }
 
+    /// <summary>
+    /// The content of a replaced element (e.g. an image) is clipped to the inner curve of its
+    /// `border-radius` at the content edge; null when that curve has no rounded corner left.
+    /// </summary>
+    private static (RenderRect Rect, RenderCornerRadii Radii)? GetRoundedContentClip(RenderCornerRadii borderRadius, float x, float y, float width, float height, EdgeSizes border, EdgeSizes padding)
+    {
+        var radii = borderRadius.ClampToBox(width, height).Inset(
+            border.Top + padding.Top,
+            border.Right + padding.Right,
+            border.Bottom + padding.Bottom,
+            border.Left + padding.Left);
+
+        if (radii.IsZero)
+        {
+            return null;
+        }
+
+        var rect = new RenderRect(
+            x + border.Left + padding.Left,
+            y + border.Top + padding.Top,
+            Math.Max(0f, width - border.Left - border.Right - padding.Left - padding.Right),
+            Math.Max(0f, height - border.Top - border.Bottom - padding.Top - padding.Bottom));
+        return (rect, radii);
+    }
+
     private static float? ParseGridGap(Dictionary<string, string> styleMap, string propertyName, float relativeTo, int tokenIndex)
     {
         if (!styleMap.TryGetValue(propertyName, out var rawValue) || string.IsNullOrWhiteSpace(rawValue))
@@ -3911,7 +4089,7 @@ private static void LayoutTextNode(
         suppressNextBlockTopMargin = false;
 
         var (bandLeft, bandRight) = floats.GetBand(cursorY, textStyle.FontSize * textStyle.LineHeightMultiplier, containingX, containingX + containingWidth);
-        LayoutWrappedText(text, bandLeft, bandRight - bandLeft, ref cursorY, textStyle, context, displayList, maxY, textIndentConsumed ? 0f : textStyle.TextIndent + textStyle.MarkerIndent);
+        LayoutWrappedText(text, bandLeft, bandRight - bandLeft, ref cursorY, textStyle, context, displayList, maxY, textIndentConsumed ? 0f : textStyle.TextIndent + textStyle.MarkerIndent, textNode);
         textIndentConsumed = true;
     }
 
@@ -3924,7 +4102,8 @@ private static void LayoutWrappedText(
         LayoutContext context,
         DisplayList displayList,
         float maxY,
-        float firstLineIndent)
+        float firstLineIndent,
+        INode? source = null)
     {
         var lineHeight = textStyle.FontSize * textStyle.LineHeightMultiplier;
         var forcedBreakLines = new HashSet<int>();
@@ -3937,7 +4116,22 @@ private static void LayoutWrappedText(
         // browser's `-webkit-line-clamp` removes them from the box's own content height too.
         var isClampedLastLine = false;
 
-        if (textStyle.LineClamp > 0 && lines.Count > textStyle.LineClamp)
+        if (context.LineClampScopes.TryPeek(out var lineClamp))
+        {
+            // the lines left in the clamped box, which may continue after this text
+            if (lines.Count > lineClamp.Remaining)
+            {
+                lines = [.. lines.Take(lineClamp.Remaining)];
+                isClampedLastLine = true;
+            }
+            else if (lines.Count == lineClamp.Remaining && lines.Count > 0 && source is not null)
+            {
+                isClampedLastLine = HasRenderedContentAfter(lineClamp.Root, source);
+            }
+
+            lineClamp.Remaining -= lines.Count;
+        }
+        else if (textStyle.LineClamp > 0 && lines.Count > textStyle.LineClamp)
         {
             lines = [.. lines.Take(textStyle.LineClamp)];
             isClampedLastLine = true;
@@ -3946,9 +4140,8 @@ private static void LayoutWrappedText(
         for (var index = 0; index < lines.Count; index++)
         {
             var line = lines[index];
-            RecordColumnContentStart(cursorY);
+            RecordColumnLine(cursorY, cursorY + lineHeight);
             cursorY += lineHeight;
-            RecordColumnBreakCandidate(cursorY);
 
             if (cursorY > maxY)
             {
@@ -3997,14 +4190,16 @@ private static void LayoutWrappedText(
             {
                 var runX = lineX;
 
-                foreach (var run in GetVisualRuns(line, textStyle.Direction == TextDirection.Rtl))
+                foreach (var (run, isRightToLeft) in BidiAlgorithm.GetVisualRuns(line, textStyle.Direction == TextDirection.Rtl))
                 {
+                    var runStyle = textStyle with { IsRightToLeftRun = isRightToLeft };
+
                     if (!string.IsNullOrWhiteSpace(run))
                     {
-                        DrawStyledText(context, displayList, run, runX, baselineY, textStyle);
+                        DrawStyledText(context, displayList, run, runX, baselineY, runStyle);
                     }
 
-                    runX += MeasureTextWidth(context, run, textStyle) + (CountSpaces(run) * textStyle.WordSpacing);
+                    runX += MeasureTextWidth(context, run, runStyle) + (CountSpaces(run) * textStyle.WordSpacing);
                 }
 
                 continue;
@@ -4049,37 +4244,6 @@ private static int CountSpaces(string text)
         return count;
     }
 
-    /// <summary>
-    /// One line of text as runs in visual order (UAX #9): each run is a maximal stretch at one
-    /// embedding level, right-to-left runs already reversed and mirrored.
-    /// </summary>
-    private static List<string> GetVisualRuns(string line, bool isRightToLeft)
-    {
-        var levels = BidiAlgorithm.GetLevels(line, isRightToLeft);
-        var order = BidiAlgorithm.GetVisualOrder(levels);
-        var runs = new List<string>();
-        var position = 0;
-
-        while (position < order.Length)
-        {
-            var level = levels[order[position]];
-            var end = position;
-
-            while (end + 1 < order.Length && levels[order[end + 1]] == level && Math.Abs(order[end + 1] - order[end]) == 1)
-            {
-                end++;
-            }
-
-            var first = Math.Min(order[position], order[end]);
-            var last = Math.Max(order[position], order[end]);
-            var run = new string(line.AsSpan(first, last - first + 1).ToArray().Where(static c => !BidiAlgorithm.IsFormattingCharacter(c)).ToArray());
-            runs.Add((level & 1) == 1 ? ReverseForDisplay(run) : run);
-            position = end + 1;
-        }
-
-        return runs;
-    }
-
     /// <summary>
     /// Splits <paramref name="text"/> into display lines, honoring <c>white-space</c>'s two layout-
     /// relevant effects <see cref="NormalizeWhitespace(string, WhiteSpaceMode)"/> itself cannot: an
@@ -4516,13 +4680,13 @@ private static float MeasureFlexItemTextHeight(string text, float width, RenderT
     /// The border-box height of an element laid out at the given border-box width, by a trial
     /// layout, cached for the render (nested flex containers would otherwise multiply them).
     /// </summary>
-    private static float MeasureBorderBoxHeight(ElementRenderNode element, float borderBoxWidth, RenderTextStyle inheritedTextStyle, LayoutContext context)
+    private static float MeasureBorderBoxHeight(ElementRenderNode element, float borderBoxWidth, RenderTextStyle inheritedTextStyle, LayoutContext context, bool isFlexItem = true)
     {
         var key = (element.Ref, borderBoxWidth);
 
         if (!context.MeasuredHeights.TryGetValue(key, out var height))
         {
-            height = TrialLayout(element, borderBoxWidth, inheritedTextStyle, context, borderBoxWidth, isAtomicInline: false).Metrics?.BorderBoxHeight ?? 0f;
+            height = TrialLayout(element, borderBoxWidth, inheritedTextStyle, context, borderBoxWidth, isAtomicInline: false, isFlexOrGridItem: isFlexItem).Metrics?.BorderBoxHeight ?? 0f;
             context.MeasuredHeights[key] = height;
         }
 
@@ -4584,7 +4748,7 @@ private static RenderTextStyle ResolveTextStyle(Dictionary<string, string> style
             ? family.Trim('\'', '"', ' ')
             : inherited.FontFamily;
 
-        var lineHeight = ParseLineHeight(styleMap, inherited.LineHeightMultiplier);
+        var lineHeight = ParseLineHeight(styleMap, fontSize, inherited.LineHeightMultiplier);
         var color = ParseColor(styleMap.TryGetValue("color", out var colorValue) ? colorValue : null, inherited.Color);
         var fontWeight = ParseFontWeight(styleMap, inherited.FontWeight);
         var isItalic = ParseFontStyle(styleMap, inherited.IsItalic);
@@ -4609,13 +4773,19 @@ private static RenderTextStyle ResolveTextStyle(Dictionary<string, string> style
         var tabSize = ParseTabSize(styleMap, fontSize, inherited.TabSize, inherited.TabSizeIsLength, out var tabSizeIsLength);
         var variantCaps = ParseFontVariantCaps(styleMap, inherited.VariantCaps);
         var fontStretch = ParseFontStretch(styleMap, inherited.FontStretch);
+        var featureProperties = ParseFontFeatureProperties(styleMap, inherited.FeatureProperties);
+        var fontFeatures = featureProperties == inherited.FeatureProperties ? inherited.FontFeatures : ResolveFontFeatures(featureProperties);
+        var language = styleMap.TryGetValue("lang", out var languageValue) && !string.IsNullOrWhiteSpace(languageValue) ? languageValue.Trim() : inherited.Language;
 
         return new RenderTextStyle(fontSize, color, fontFamily, lineHeight, fontWeight, isItalic, underline, strikeThrough, decorationColor, decorationStyle, textAlign, letterSpacing, textIndent, verticalAlignOffset, textShadows, whiteSpace, wordBreak, overflowWrap, textOverflow, lineClamp, direction, textTransform, wordSpacing, textAlignLast, hyphens, tabSize, tabSizeIsLength, variantCaps, fontStretch,
             IsHidden: ResolveIsHidden(styleMap, inherited.IsHidden),
             WritingMode: ParseWritingMode(styleMap.GetValueOrDefault("writing-mode"), inherited.WritingMode),
             TextOrientation: ParseTextOrientation(styleMap.GetValueOrDefault("text-orientation"), inherited.TextOrientation),
             // The system text is laid out in only changes at an orthogonal flow (LayoutElement).
-            FlowMode: inherited.FlowMode);
+            FlowMode: inherited.FlowMode,
+            FeatureProperties: featureProperties,
+            FontFeatures: fontFeatures,
+            Language: language);
     }
 
     /// <summary>
@@ -4922,7 +5092,11 @@ private static (bool Underline, bool StrikeThrough) ParseTextDecoration(Dictiona
         return (underline, strikeThrough);
     }
 
-    private static float ParseLineHeight(Dictionary<string, string> styleMap, float defaultValue)
+    /// <summary>
+    /// The line height as a multiple of <paramref name="fontSize"/>. A length (the computed value
+    /// of e.g. `line-height: 1rem` or `150%`) is absolute, so it becomes the ratio to the font size.
+    /// </summary>
+    private static float ParseLineHeight(Dictionary<string, string> styleMap, float fontSize, float defaultValue)
     {
         if (!styleMap.TryGetValue("line-height", out var value) || string.IsNullOrWhiteSpace(value))
         {
@@ -4942,6 +5116,11 @@ private static float ParseLineHeight(Dictionary<string, string> styleMap, float
             return unitless;
         }
 
+        if (fontSize > 0f && TryParsePixelValue(normalized, out var pixels))
+        {
+            return pixels / fontSize;
+        }
+
         return defaultValue;
     }
 
@@ -5208,6 +5387,21 @@ private static ICssStyleDeclaration ComputeStyle(IStyleCollection styleCollectio
             ? computed
             : styleCollection.ComputeDeclarations(element);
 
+    /// <summary>
+    /// Gaps are only parsed as px or %, so an authored gap takes the computed value, which has
+    /// font- and viewport-relative units (e.g. gap: 1rem) resolved but keeps percentages.
+    /// </summary>
+    private static string? ResolveGapValue(ICssStyleDeclaration computedStyle, string propertyName, string? explicitValue)
+    {
+        if (string.IsNullOrWhiteSpace(explicitValue))
+        {
+            return explicitValue;
+        }
+
+        var computedValue = computedStyle.GetPropertyValue(propertyName);
+        return string.IsNullOrWhiteSpace(computedValue) ? explicitValue : computedValue;
+    }
+
     private static string ReadExplicitOrComputed(ICssStyleDeclaration explicitDeclarations, ICssStyleDeclaration computedStyle, string propertyName)
     {
         var explicitValue = explicitDeclarations.GetPropertyValue(propertyName);
@@ -5444,11 +5638,11 @@ private static Dictionary<string, string> CreateStyleMap(ICssStyleDeclaration st
         if (isGridContainer || isFlexContainer)
         {
             var explicitColumnGap = explicitDeclarations is not null ? ReadExplicitOrComputed(explicitDeclarations, style, "column-gap") : ResolveExplicitPropertyValue(element, style, "column-gap");
-            AddIfPresent(map, "column-gap", string.IsNullOrWhiteSpace(explicitColumnGap) ? ParseStyleAttributeValue(inlineStyle, "column-gap") : explicitColumnGap);
+            AddIfPresent(map, "column-gap", ResolveGapValue(style, "column-gap", string.IsNullOrWhiteSpace(explicitColumnGap) ? ParseStyleAttributeValue(inlineStyle, "column-gap") : explicitColumnGap));
             var explicitRowGap = explicitDeclarations is not null ? ReadExplicitOrComputed(explicitDeclarations, style, "row-gap") : ResolveExplicitPropertyValue(element, style, "row-gap");
-            AddIfPresent(map, "row-gap", string.IsNullOrWhiteSpace(explicitRowGap) ? ParseStyleAttributeValue(inlineStyle, "row-gap") : explicitRowGap);
+            AddIfPresent(map, "row-gap", ResolveGapValue(style, "row-gap", string.IsNullOrWhiteSpace(explicitRowGap) ? ParseStyleAttributeValue(inlineStyle, "row-gap") : explicitRowGap));
             var explicitGap = explicitDeclarations is not null ? ReadExplicitOrComputed(explicitDeclarations, style, "gap") : ResolveExplicitPropertyValue(element, style, "gap");
-            AddIfPresent(map, "gap", string.IsNullOrWhiteSpace(explicitGap) ? ParseStyleAttributeValue(inlineStyle, "gap") : explicitGap);
+            AddIfPresent(map, "gap", ResolveGapValue(style, "gap", string.IsNullOrWhiteSpace(explicitGap) ? ParseStyleAttributeValue(inlineStyle, "gap") : explicitGap));
         }
 
         var explicitGridColumn = explicitDeclarations is not null ? ReadExplicitOrComputed(explicitDeclarations, style, "grid-column") : ResolveExplicitPropertyValue(element, style, "grid-column");
@@ -5525,6 +5719,7 @@ private static Dictionary<string, string> CreateStyleMap(ICssStyleDeclaration st
             AddIfPresent(map, "column-rule-width", style.GetPropertyValue("column-rule-width"));
             AddIfPresent(map, "column-rule-style", style.GetPropertyValue("column-rule-style"));
             AddIfPresent(map, "column-rule-color", style.GetPropertyValue("column-rule-color"));
+            AddIfPresent(map, "column-fill", style.GetPropertyValue("column-fill"));
 
             if (!isGridContainer && !isFlexContainer)
             {
@@ -5581,6 +5776,16 @@ private static Dictionary<string, string> CreateStyleMap(ICssStyleDeclaration st
         AddIfPresent(map, "hyphens", style.GetPropertyValue("hyphens"));
         AddIfPresent(map, "tab-size", style.GetPropertyValue("tab-size"));
         AddIfPresent(map, "font-variant-caps", style.GetPropertyValue("font-variant-caps"));
+        AddIfPresent(map, "font-feature-settings", style.GetPropertyValue("font-feature-settings"));
+        AddIfPresent(map, "font-kerning", style.GetPropertyValue("font-kerning"));
+        AddIfPresent(map, "font-variant-ligatures", style.GetPropertyValue("font-variant-ligatures"));
+        AddIfPresent(map, "font-variant-numeric", style.GetPropertyValue("font-variant-numeric"));
+        AddIfPresent(map, "font-variant-east-asian", style.GetPropertyValue("font-variant-east-asian"));
+
+        // The element's language (`lang`, element semantics rather than CSS) rides along so that
+        // ResolveTextStyle inherits it like a property; shaping uses it. A pseudo-element reads its
+        // host's attribute, which is the language it inherits anyway.
+        AddIfPresent(map, "lang", element?.GetAttribute("lang") ?? element?.GetAttribute("xml:lang"));
         AddIfPresent(map, "font-stretch", style.GetPropertyValue("font-stretch"));
         AddIfPresent(map, "text-transform", style.GetPropertyValue("text-transform"));
         AddIfPresent(map, "line-height", style.GetLineHeight());
@@ -5888,7 +6093,7 @@ private static bool TryGetFirstCollapsibleChildTopMargin(ElementRenderNode node,
             if (childBox.BorderWidth.Top <= 0f &&
                 ParseLength(childStyle, "padding-top", containingWidth, childBox.Padding.Top, allowAuto: false) <= 0f &&
                 !EstablishesBlockFormattingContext(childStyle, isFloat, isOutOfFlow, isAtomicInline: false, isFlexItem: false) &&
-                !IsOrthogonalFlow(childElement.Ref, context) &&
+                !StartsWritingModeSystem(childElement.Ref, context) &&
                 TryGetFirstCollapsibleChildTopMargin(childElement, containingWidth, context, out var grandchildMarginTop))
             {
                 marginTop = CollapseMargins(marginTop, grandchildMarginTop);
@@ -6487,6 +6692,34 @@ private static void PaintOutline(DisplayList displayList, Dictionary<string, str
     /// pseudo-element whose `content` is a single `url()`. A pseudo-element proxies its host's tag
     /// name and attributes, so it is only ever judged by its generated content.
     /// </summary>
+    /// <summary>
+    /// Whether anything rendered follows <paramref name="node"/> (and its descendants) inside
+    /// <paramref name="root"/>: text other than white space, or a replaced element.
+    /// </summary>
+    private static bool HasRenderedContentAfter(IElement root, INode node)
+    {
+        for (var current = node; current is not null && current != root; current = current.Parent)
+        {
+            for (var sibling = current.NextSibling; sibling is not null; sibling = sibling.NextSibling)
+            {
+                if (HasRenderedContent(sibling))
+                {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+
+        static bool HasRenderedContent(INode node) => node switch
+        {
+            IText text => !string.IsNullOrWhiteSpace(text.Data),
+            IElement element => !string.Equals(element.ComputeCurrentStyle().GetDisplay()?.Trim(), "none", StringComparison.OrdinalIgnoreCase) &&
+                                (IsReplacedElement(element) || element.ChildNodes.Any(HasRenderedContent)),
+            _ => false,
+        };
+    }
+
     private static bool IsReplacedElement(IElement element) => element is IPseudoElement
         ? s_generatedContentImages.TryGetValue(element, out _)
         : string.Equals(element.LocalName, "img", StringComparison.OrdinalIgnoreCase) ||
@@ -8743,7 +8976,7 @@ private static void PaintTextShadows(DisplayList displayList, IReadOnlyList<Rend
         for (var i = shadows.Count - 1; i >= 0; i--)
         {
             var shadow = shadows[i];
-            displayList.DrawTextShadow(text, x + shadow.OffsetX, y + shadow.OffsetY, shadow.Color, textStyle.FontSize, textStyle.FontFamily, textStyle.FontWeight, textStyle.IsItalic, shadow.BlurRadius, textStyle.LetterSpacing, textStyle.FontStretch);
+            displayList.DrawTextShadow(text, x + shadow.OffsetX, y + shadow.OffsetY, shadow.Color, textStyle.FontSize, textStyle.FontFamily, textStyle.FontWeight, textStyle.IsItalic, shadow.BlurRadius, textStyle.LetterSpacing, textStyle.FontStretch, textStyle.IsRightToLeftRun, textStyle.FontFeatures, textStyle.Language, textStyle.ShapingContextBefore, textStyle.ShapingContextAfter);
         }
     }
 
@@ -11355,6 +11588,10 @@ private static RenderColor ParseHexColor(string color, RenderColor fallback)
     /// </summary>
     private static IReadOnlyList<string> WrapText(LayoutContext context, string text, float maxWidth, RenderTextStyle textStyle)
     {
+        // a width taken from measured text (e.g. a max-content flex item) can come out of the box
+        // arithmetic slightly smaller than the text, which must still fit (as in the inline layout)
+        maxWidth += 0.01f;
+
         if (textStyle.WordBreak == WordBreakMode.BreakAll)
         {
             return WrapTextCharacterWise(context, StripSoftHyphens(text), maxWidth, textStyle);
@@ -11617,11 +11854,11 @@ private static IReadOnlyList<string> WrapTextCharacterWise(LayoutContext context
     private const string EllipsisCharacter = "…";
 
     /// <summary>
-    /// Truncates <paramref name="text"/> to the longest prefix (by rune, not raw UTF-16 char, so a
-    /// truncation point never lands inside a surrogate pair) whose width plus the ellipsis
+    /// Truncates <paramref name="text"/> to the longest prefix (by glyph cluster, so a truncation
+    /// point never lands inside a surrogate pair, a ligature or a conjunct) whose width plus the ellipsis
     /// character's own width still fits within <paramref name="maxWidth"/>, then appends it - the
     /// approach every real browser's own `text-overflow: ellipsis` uses (truncate, do not scale or
-    /// reflow). Binary search over rune count, not a linear scan, since <see cref="MeasureTextWidth"/>
+    /// reflow). Binary search over the clusters, not a linear scan, since <see cref="MeasureTextWidth"/>
     /// goes through the backend's own font shaping and this runs on already-overflowing text on the
     /// hot layout path.
     /// </summary>
@@ -11634,14 +11871,14 @@ private static string TruncateWithEllipsis(LayoutContext context, string text, f
             return EllipsisCharacter;
         }
 
-        var runes = text.EnumerateRunes().ToArray();
+        var clusterEnds = GetClusterEnds(context, text, textStyle);
         var low = 0;
-        var high = runes.Length;
+        var high = clusterEnds.Count;
 
         while (low < high)
         {
             var mid = (low + high + 1) / 2;
-            var prefixWidth = MeasureTextWidth(context, string.Concat(runes.Take(mid).Select(r => r.ToString())), textStyle);
+            var prefixWidth = MeasureTextWidth(context, text[..clusterEnds[mid - 1]], textStyle);
 
             if (prefixWidth + ellipsisWidth <= maxWidth)
             {
@@ -11653,9 +11890,16 @@ private static string TruncateWithEllipsis(LayoutContext context, string text, f
             }
         }
 
-        return string.Concat(runes.Take(low).Select(r => r.ToString())) + EllipsisCharacter;
+        return (low == 0 ? string.Empty : text[..clusterEnds[low - 1]]) + EllipsisCharacter;
     }
 
+    /// <summary>
+    /// The ends of the glyph clusters of <paramref name="text"/> (ascending, the last one is its
+    /// length): where it may be cut, e.g. before an ellipsis.
+    /// </summary>
+    private static List<int> GetClusterEnds(LayoutContext context, string text, RenderTextStyle textStyle) =>
+        [.. context.TextMeasurer.GetClusterBoundaries(text, ToRenderFont(textStyle, context.Fonts)).Where(boundary => boundary > 0)];
+
     private static RenderFont ToRenderFont(RenderTextStyle textStyle, FontFaceSet fonts) => new(
         textStyle.FontFamily,
         textStyle.FontSize,
@@ -11663,7 +11907,12 @@ private static string TruncateWithEllipsis(LayoutContext context, string text, f
         textStyle.IsItalic,
         textStyle.LetterSpacing,
         fonts,
-        textStyle.FontStretch);
+        textStyle.FontStretch,
+        textStyle.IsRightToLeftRun,
+        textStyle.FontFeatures,
+        textStyle.Language,
+        textStyle.ShapingContextBefore,
+        textStyle.ShapingContextAfter);
 
     /// <summary>
     /// Measures text the way <see cref="DrawStyledText"/> paints it: soft hyphens are invisible
@@ -11837,7 +12086,13 @@ private readonly record struct RenderTextStyle(
         bool IsHidden = false,
         WritingModeKind WritingMode = WritingModeKind.HorizontalTb,
         TextOrientationKind TextOrientation = TextOrientationKind.Mixed,
-        WritingModeKind FlowMode = WritingModeKind.HorizontalTb);
+        WritingModeKind FlowMode = WritingModeKind.HorizontalTb,
+        bool IsRightToLeftRun = false,
+        FontFeatureProperties FeatureProperties = default,
+        string? FontFeatures = null,
+        string? Language = null,
+        string? ShapingContextBefore = null,
+        string? ShapingContextAfter = null);
 
     private enum TextAlign
     {
diff --git a/src/AngleSharp.Renderer/Rendering/Canvas2DRenderingContext.cs b/src/AngleSharp.Renderer/Rendering/Canvas2DRenderingContext.cs
index 57cc976..2d5d5b7 100644
--- a/src/AngleSharp.Renderer/Rendering/Canvas2DRenderingContext.cs
+++ b/src/AngleSharp.Renderer/Rendering/Canvas2DRenderingContext.cs
@@ -237,10 +237,65 @@ public void FillText(string? text, float x, float y)
             return;
         }
 
-        using var paint = CreatePaint(_fillColor, SKPaintStyle.Fill);
-        using var typeface = SKTypeface.Default;
-        using var font = new SKFont(typeface, ParseFontSize(_font));
-        _canvas.DrawText(text, x + _translateX, y + _translateY, font, paint);
+        // Shaped and resolved like HTML text: the font list falls back per character, and
+        // right-to-left runs are reordered within the left-to-right paragraph.
+        var font = ParseFont(_font) with { Language = ResolveLanguage(Host) };
+        using var paint = Skia.SkiaTextShaping.CreateTextPaint(font);
+        paint.Color = _fillColor;
+        Skia.SkiaTextShaping.DrawParagraph(_canvas, paint, text, x + _translateX, y + _translateY, font, isRightToLeft: false);
+    }
+
+    /// <summary>
+    /// The CSS <c>font</c> shorthand of the context (<c>[italic] [bold|weight] size family</c>);
+    /// the generic family when none is given.
+    /// </summary>
+    private static Rendering.RenderFont ParseFont(string font)
+    {
+        var tokens = font.Split(' ', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
+        var isItalic = false;
+        var weight = 400f;
+        var size = 10f;
+        var familyStart = tokens.Length;
+
+        for (var index = 0; index < tokens.Length; index++)
+        {
+            var token = tokens[index].ToLowerInvariant();
+
+            if (token is "italic" or "oblique")
+            {
+                isItalic = true;
+            }
+            else if (token is "bold" or "bolder")
+            {
+                weight = 700f;
+            }
+            else if (float.TryParse(token, System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out var numericWeight))
+            {
+                weight = numericWeight;
+            }
+            else if (token.EndsWith("px", StringComparison.Ordinal))
+            {
+                size = ParseFontSize(token);
+                familyStart = index + 1;
+                break;
+            }
+        }
+
+        var family = familyStart < tokens.Length ? string.Join(' ', tokens[familyStart..]) : "sans-serif";
+        return new Rendering.RenderFont(family, size, weight, isItalic, 0f);
+    }
+
+    private static string? ResolveLanguage(IHtmlCanvasElement host)
+    {
+        for (AngleSharp.Dom.IElement? element = host; element is not null; element = element.ParentElement)
+        {
+            if (element.GetAttribute("lang") is { } language && !string.IsNullOrWhiteSpace(language))
+            {
+                return language.Trim();
+            }
+        }
+
+        return null;
     }
 
     /// <summary>
diff --git a/src/AngleSharp.Renderer/Rendering/DisplayList.cs b/src/AngleSharp.Renderer/Rendering/DisplayList.cs
index 12b8eb4..9c43091 100644
--- a/src/AngleSharp.Renderer/Rendering/DisplayList.cs
+++ b/src/AngleSharp.Renderer/Rendering/DisplayList.cs
@@ -44,6 +44,27 @@ public void InsertRange(int index, IEnumerable<RenderCommand> commands)
         _commands.InsertRange(index, commands);
     }
 
+    /// <summary>
+    /// Replaces a command (found by identity, as records compare by value) with another one,
+    /// e.g. a placeholder transform whose value is only known after later layout.
+    /// </summary>
+    /// <param name="command">The command to replace.</param>
+    /// <param name="replacement">The command taking its place.</param>
+    /// <returns>Whether the command was found.</returns>
+    internal bool ReplaceCommand(RenderCommand command, RenderCommand replacement)
+    {
+        for (var index = 0; index < _commands.Count; index++)
+        {
+            if (ReferenceEquals(_commands[index], command))
+            {
+                _commands[index] = replacement;
+                return true;
+            }
+        }
+
+        return false;
+    }
+
     /// <summary>
     /// Moves a contiguous range of already-appended commands to the current end of the list,
     /// preserving their own relative order. Used for a stuck `position: sticky` element painted as
@@ -275,12 +296,17 @@ public void DrawText(
         RenderColor? decorationColor = null,
         RenderTextDecorationStyle decorationStyle = RenderTextDecorationStyle.Solid,
         float letterSpacing = 0f,
-        float fontStretch = 100f)
+        float fontStretch = 100f,
+        bool isRightToLeft = false,
+        string? fontFeatures = null,
+        string? language = null,
+        string? contextBefore = null,
+        string? contextAfter = null)
     {
         ArgumentException.ThrowIfNullOrWhiteSpace(text);
         ArgumentException.ThrowIfNullOrWhiteSpace(fontFamily);
 
-        Add(new DrawTextCommand(text, x, y, color, fontSize, fontFamily, fontWeight, isItalic, underline, strikeThrough, decorationColor ?? color, decorationStyle, letterSpacing, fontStretch));
+        Add(new DrawTextCommand(text, x, y, color, fontSize, fontFamily, fontWeight, isItalic, underline, strikeThrough, decorationColor ?? color, decorationStyle, letterSpacing, fontStretch, isRightToLeft, fontFeatures, language, contextBefore, contextAfter));
     }
 
     /// <summary>
@@ -297,12 +323,17 @@ public void DrawTextShadow(
         bool isItalic,
         float blurRadius,
         float letterSpacing,
-        float fontStretch = 100f)
+        float fontStretch = 100f,
+        bool isRightToLeft = false,
+        string? fontFeatures = null,
+        string? language = null,
+        string? contextBefore = null,
+        string? contextAfter = null)
     {
         ArgumentException.ThrowIfNullOrWhiteSpace(text);
         ArgumentException.ThrowIfNullOrWhiteSpace(fontFamily);
 
-        Add(new DrawTextShadowCommand(text, x, y, color, fontSize, fontFamily, fontWeight, isItalic, blurRadius, letterSpacing, fontStretch));
+        Add(new DrawTextShadowCommand(text, x, y, color, fontSize, fontFamily, fontWeight, isItalic, blurRadius, letterSpacing, fontStretch, isRightToLeft, fontFeatures, language, contextBefore, contextAfter));
     }
 }
 
@@ -431,7 +462,9 @@ public sealed record PushBlendModeCommand(RenderBlendMode Mode) : RenderCommand;
 public sealed record PopBlendModeCommand : RenderCommand;
 
 /// <summary>
-/// Draws a single line of text at a baseline position.
+/// Draws a single line of text at a baseline position. The text is shaped (see
+/// <see cref="RenderFont"/> for <c>IsRightToLeft</c> and <c>FontFeatures</c>) exactly as it was
+/// measured during layout.
 /// </summary>
 public sealed record DrawTextCommand(
     string Text,
@@ -447,7 +480,12 @@ public sealed record DrawTextCommand(
     RenderColor DecorationColor,
     RenderTextDecorationStyle DecorationStyle,
     float LetterSpacing,
-    float FontStretch = 100f) : RenderCommand
+    float FontStretch = 100f,
+    bool IsRightToLeft = false,
+    string? FontFeatures = null,
+    string? Language = null,
+    string? ContextBefore = null,
+    string? ContextAfter = null) : RenderCommand
 {
     /// <summary>
     /// Indicates whether the command should be rendered with a bold typeface.
@@ -471,7 +509,12 @@ public sealed record DrawTextShadowCommand(
     bool IsItalic,
     float BlurRadius,
     float LetterSpacing,
-    float FontStretch = 100f) : RenderCommand
+    float FontStretch = 100f,
+    bool IsRightToLeft = false,
+    string? FontFeatures = null,
+    string? Language = null,
+    string? ContextBefore = null,
+    string? ContextAfter = null) : RenderCommand
 {
     /// <summary>
     /// Indicates whether the command should be rendered with a bold typeface.
diff --git a/src/AngleSharp.Renderer/Rendering/ITextMeasurer.cs b/src/AngleSharp.Renderer/Rendering/ITextMeasurer.cs
index d08c43a..bfc9a8d 100644
--- a/src/AngleSharp.Renderer/Rendering/ITextMeasurer.cs
+++ b/src/AngleSharp.Renderer/Rendering/ITextMeasurer.cs
@@ -16,4 +16,25 @@ public interface ITextMeasurer
     /// <param name="font">The font the text is rendered with.</param>
     /// <returns>The advance width in pixels.</returns>
     float MeasureWidth(string text, RenderFont font);
+
+    /// <summary>
+    /// The offsets at which the text may be cut without breaking a glyph cluster (e.g. to
+    /// truncate it with an ellipsis): ascending UTF-16 offsets, starting with 0 and ending with
+    /// the length of the text. The default treats every grapheme cluster as one.
+    /// </summary>
+    /// <param name="text">The text to split.</param>
+    /// <param name="font">The font the text is rendered with.</param>
+    /// <returns>The cluster boundaries.</returns>
+    IReadOnlyList<int> GetClusterBoundaries(string text, RenderFont font)
+    {
+        var boundaries = new List<int> { 0 };
+        var enumerator = System.Globalization.StringInfo.GetTextElementEnumerator(text);
+
+        while (enumerator.MoveNext())
+        {
+            boundaries.Add(enumerator.ElementIndex + ((string)enumerator.Current).Length);
+        }
+
+        return boundaries;
+    }
 }
diff --git a/src/AngleSharp.Renderer/Rendering/RenderCornerRadii.cs b/src/AngleSharp.Renderer/Rendering/RenderCornerRadii.cs
index 3d0aab6..4d71591 100644
--- a/src/AngleSharp.Renderer/Rendering/RenderCornerRadii.cs
+++ b/src/AngleSharp.Renderer/Rendering/RenderCornerRadii.cs
@@ -62,6 +62,18 @@ public RenderCornerRadii ClampToBox(float width, float height)
             BottomLeftX * scale, BottomLeftY * scale);
     }
 
+    /// <summary>
+    /// The radii of the inner curve of a box whose edges are inset by the given widths, e.g. the
+    /// padding or content edge of a border box with these radii. Each radius shrinks by the width
+    /// of its adjacent edge and turns square once that width exceeds it
+    /// (https://www.w3.org/TR/css-backgrounds-3/#corner-shaping).
+    /// </summary>
+    public RenderCornerRadii Inset(float top, float right, float bottom, float left) => new(
+        Math.Max(0f, TopLeftX - left), Math.Max(0f, TopLeftY - top),
+        Math.Max(0f, TopRightX - right), Math.Max(0f, TopRightY - top),
+        Math.Max(0f, BottomRightX - right), Math.Max(0f, BottomRightY - bottom),
+        Math.Max(0f, BottomLeftX - left), Math.Max(0f, BottomLeftY - bottom));
+
     private static float SafeRatio(float available, float requested) =>
         requested > 0f ? available / requested : float.MaxValue;
 }
diff --git a/src/AngleSharp.Renderer/Rendering/RenderFont.cs b/src/AngleSharp.Renderer/Rendering/RenderFont.cs
index 4852101..0239a7d 100644
--- a/src/AngleSharp.Renderer/Rendering/RenderFont.cs
+++ b/src/AngleSharp.Renderer/Rendering/RenderFont.cs
@@ -10,6 +10,25 @@ namespace AngleSharp.Renderer.Rendering;
 /// <param name="LetterSpacing">The additional spacing between characters in pixels.</param>
 /// <param name="Faces">The <c>@font-face</c> declarations in scope, if any.</param>
 /// <param name="FontStretch">The CSS <c>font-stretch</c> as a percentage (100 = normal).</param>
+/// <param name="IsRightToLeft">
+/// Whether the text is a right-to-left run (an odd bidi embedding level). The text is still in
+/// logical order; shaping puts the glyphs in visual order and mirrors them.
+/// </param>
+/// <param name="FontFeatures">
+/// The OpenType features to shape with, in HarfBuzz syntax separated by commas (e.g.
+/// <c>liga=0,tnum</c>), from <c>font-feature-settings</c>, <c>font-kerning</c> and
+/// <c>font-variant-*</c>; <see langword="null"/> for the font's defaults.
+/// </param>
+/// <param name="Language">
+/// The BCP 47 language of the text (from <c>lang</c>), which selects language-specific glyph
+/// forms when shaping; <see langword="null"/> when unknown.
+/// </param>
+/// <param name="ContextBefore">
+/// Text that logically precedes this text but is shaped elsewhere (across an inline element
+/// boundary), so contextual forms such as Arabic joining continue across it. It is not measured
+/// or painted.
+/// </param>
+/// <param name="ContextAfter">Text that logically follows this text but is shaped elsewhere.</param>
 public readonly record struct RenderFont(
     string FontFamily,
     float FontSize,
@@ -17,4 +36,9 @@ public readonly record struct RenderFont(
     bool IsItalic,
     float LetterSpacing,
     FontFaceSet? Faces = null,
-    float FontStretch = 100f);
+    float FontStretch = 100f,
+    bool IsRightToLeft = false,
+    string? FontFeatures = null,
+    string? Language = null,
+    string? ContextBefore = null,
+    string? ContextAfter = null);
diff --git a/src/AngleSharp.Renderer/Resources/Fonts/NotoSansDevanagari-OFL.txt b/src/AngleSharp.Renderer/Resources/Fonts/NotoSansDevanagari-OFL.txt
new file mode 100644
index 0000000..cd2cc5c
--- /dev/null
+++ b/src/AngleSharp.Renderer/Resources/Fonts/NotoSansDevanagari-OFL.txt
@@ -0,0 +1,93 @@
+Copyright 2022 The Noto Project Authors (https://github.com/notofonts/devanagari)
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+https://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.
diff --git a/src/AngleSharp.Renderer/Resources/Fonts/NotoSansDevanagari-Regular.ttf b/src/AngleSharp.Renderer/Resources/Fonts/NotoSansDevanagari-Regular.ttf
new file mode 100644
index 0000000..0bf16ff
Binary files /dev/null and b/src/AngleSharp.Renderer/Resources/Fonts/NotoSansDevanagari-Regular.ttf differ
diff --git a/src/AngleSharp.Renderer/Skia/SkiaRenderBackend.cs b/src/AngleSharp.Renderer/Skia/SkiaRenderBackend.cs
index 661d3b2..622f3ab 100644
--- a/src/AngleSharp.Renderer/Skia/SkiaRenderBackend.cs
+++ b/src/AngleSharp.Renderer/Skia/SkiaRenderBackend.cs
@@ -19,6 +19,9 @@ public sealed partial class SkiaRenderBackend : IRenderBackend, ITextMeasurer
     /// <inheritdoc />
     public float MeasureWidth(string text, RenderFont font) => _textMeasurer.MeasureWidth(text, font);
 
+    /// <inheritdoc />
+    public IReadOnlyList<int> GetClusterBoundaries(string text, RenderFont font) => _textMeasurer.GetClusterBoundaries(text, font);
+
     /// <inheritdoc />
     public RenderedImage RenderToPng(DisplayList displayList, RenderViewport viewport)
     {
@@ -1010,7 +1013,12 @@ private static void DrawText(SKCanvas canvas, DrawTextCommand command, FontFaceS
             command.IsItalic,
             command.LetterSpacing,
             fonts,
-            command.FontStretch);
+            command.FontStretch,
+            command.IsRightToLeft,
+            command.FontFeatures,
+            command.Language,
+            command.ContextBefore,
+            command.ContextAfter);
 
         using var paint = SkiaTextShaping.CreateTextPaint(font);
         paint.Color = ToSkColor(command.Color);
@@ -1052,7 +1060,12 @@ private static void DrawTextShadow(SKCanvas canvas, DrawTextShadowCommand comman
             command.IsItalic,
             command.LetterSpacing,
             fonts,
-            command.FontStretch);
+            command.FontStretch,
+            command.IsRightToLeft,
+            command.FontFeatures,
+            command.Language,
+            command.ContextBefore,
+            command.ContextAfter);
 
         using var paint = SkiaTextShaping.CreateTextPaint(font);
         paint.Color = ToSkColor(command.Color);
diff --git a/src/AngleSharp.Renderer/Skia/SkiaTextMeasurer.cs b/src/AngleSharp.Renderer/Skia/SkiaTextMeasurer.cs
index 60b8703..03b60ef 100644
--- a/src/AngleSharp.Renderer/Skia/SkiaTextMeasurer.cs
+++ b/src/AngleSharp.Renderer/Skia/SkiaTextMeasurer.cs
@@ -19,6 +19,14 @@ public sealed class SkiaTextMeasurer : ITextMeasurer
     [ThreadStatic]
     private static Dictionary<RenderFont, SKPaint>? t_paints;
 
+    // Shaping a word is far costlier than looking it up, and layout measures the same words over
+    // and over (every trial layout of an inline-block measures its content again). A width only
+    // depends on the text and the font, so it is cached per thread, cleared when it gets large.
+    private const int MaxCachedWidths = 16384;
+
+    [ThreadStatic]
+    private static Dictionary<(string Text, RenderFont Font), float>? t_widths;
+
     /// <inheritdoc />
     public float MeasureWidth(string text, RenderFont font)
     {
@@ -27,9 +35,27 @@ public float MeasureWidth(string text, RenderFont font)
             return 0f;
         }
 
-        return SkiaTextShaping.MeasureTextWidth(GetPaint(font), text, font.LetterSpacing, font);
+        var widths = t_widths ??= [];
+
+        if (widths.TryGetValue((text, font), out var width))
+        {
+            return width;
+        }
+
+        if (widths.Count >= MaxCachedWidths)
+        {
+            widths.Clear();
+        }
+
+        width = SkiaTextShaping.MeasureTextWidth(GetPaint(font), text, font.LetterSpacing, font);
+        widths[(text, font)] = width;
+        return width;
     }
 
+    /// <inheritdoc />
+    public IReadOnlyList<int> GetClusterBoundaries(string text, RenderFont font) =>
+        string.IsNullOrEmpty(text) ? [0] : SkiaTextShaping.GetClusterBoundaries(GetPaint(font), text, font);
+
     private static SKPaint GetPaint(RenderFont font)
     {
         var paints = t_paints ??= [];
diff --git a/src/AngleSharp.Renderer/Skia/SkiaTextShaping.cs b/src/AngleSharp.Renderer/Skia/SkiaTextShaping.cs
index f4724c9..f0829ee 100644
--- a/src/AngleSharp.Renderer/Skia/SkiaTextShaping.cs
+++ b/src/AngleSharp.Renderer/Skia/SkiaTextShaping.cs
@@ -9,14 +9,15 @@ namespace AngleSharp.Renderer.Skia;
 using AngleSharp.Renderer.Rendering;
 
 using SkiaSharp;
+using SkiaSharp.HarfBuzz;
 
 /// <summary>
 /// Shared text configuration for the Skia backend.
 /// </summary>
 /// <remarks>
-/// Measuring and painting have to resolve the same typeface and apply the same paint settings,
-/// otherwise layout is computed against a font that never reaches the canvas. Both paths go
-/// through this type so they cannot drift apart.
+/// Measuring and painting have to resolve the same typeface, apply the same paint settings and
+/// shape the same way, otherwise layout is computed against glyphs that never reach the canvas.
+/// Both paths go through this type (<see cref="ShapeText"/>) so they cannot drift apart.
 /// </remarks>
 internal static class SkiaTextShaping
 {
@@ -305,32 +306,46 @@ private static SKPaint CreateFallbackPaint(SKPaint paint, SKTypeface typeface, R
         var fallbackPaint = paint.Clone();
         fallbackPaint.Typeface = typeface;
         fallbackPaint.TextSkewX = font.IsItalic && typeface.FontSlant == SKFontStyleSlant.Upright ? -0.25f : 0f;
-        ApplySyntheticBold(fallbackPaint, font, typeface);
+
+        // a stroke paint (SVG `stroke`) outlines the glyphs and has to stay one
+        if (paint.Style != SKPaintStyle.Stroke)
+        {
+            ApplySyntheticBold(fallbackPaint, font, typeface);
+        }
+
         return fallbackPaint;
     }
 
     /// <summary>
-    /// Draws text the way <see cref="MeasureTextWidth"/> measures it: per fallback run, and
-    /// character by character when letter spacing is in play.
+    /// Draws text exactly as <see cref="MeasureTextWidth"/> measures it: shaped with HarfBuzz
+    /// (see <see cref="ShapeText"/>) and painted as positioned glyphs, one text blob per run.
     /// </summary>
     public static void DrawText(SKCanvas canvas, SKPaint paint, string text, float x, float y, float letterSpacing, RenderFont? font = null)
     {
-        if (SplitFallbackRuns(paint, text, font) is not { } runs)
-        {
-            DrawSingleTypefaceText(canvas, paint, text, x, y, letterSpacing);
-            return;
-        }
-
-        var cursorX = x;
+        var shaped = ShapeText(paint, text, letterSpacing, font);
 
-        foreach (var (runText, typeface) in runs)
+        foreach (var run in shaped.Runs)
         {
-            var runPaint = ReferenceEquals(typeface, paint.Typeface) ? paint : CreateFallbackPaint(paint, typeface, font!.Value);
+            if (run.Glyphs.Length == 0)
+            {
+                continue;
+            }
+
+            var runPaint = ReferenceEquals(run.Typeface, paint.Typeface) || font is null ? paint : CreateFallbackPaint(paint, run.Typeface, font.Value);
 
             try
             {
-                DrawSingleTypefaceText(canvas, runPaint, runText, cursorX, y, letterSpacing);
-                cursorX += MeasureSingleTypefaceText(runPaint, runText, letterSpacing) + (letterSpacing > 0f ? letterSpacing : 0f);
+                using var skFont = runPaint.ToFont();
+                using var builder = new SKTextBlobBuilder();
+                var buffer = builder.AllocatePositionedRun(skFont, run.Glyphs.Length);
+                buffer.SetGlyphs(run.Glyphs);
+                buffer.SetPositions(run.Positions);
+                using var blob = builder.Build();
+
+                if (blob is not null)
+                {
+                    canvas.DrawText(blob, x, y, runPaint);
+                }
             }
             finally
             {
@@ -342,24 +357,6 @@ public static void DrawText(SKCanvas canvas, SKPaint paint, string text, float x
         }
     }
 
-    private static void DrawSingleTypefaceText(SKCanvas canvas, SKPaint paint, string text, float x, float y, float letterSpacing)
-    {
-        if (letterSpacing <= 0f)
-        {
-            canvas.DrawText(text, x, y, paint);
-            return;
-        }
-
-        var cursorX = x;
-
-        foreach (var character in text)
-        {
-            var glyph = character.ToString();
-            canvas.DrawText(glyph, cursorX, y, paint);
-            cursorX += paint.MeasureText(glyph) + letterSpacing;
-        }
-    }
-
     /// <summary>
     /// Walks the sources of a face in declaration order and returns the first usable one.
     /// </summary>
@@ -462,53 +459,278 @@ private static IReadOnlyDictionary<string, string> CreateSystemFontFamilyIndex()
     }
 
     /// <summary>
-    /// Measures the advance width, mirroring how the backend lays glyphs out when letter
-    /// spacing is in play.
+    /// Measures a line of text that no layout has split into bidi runs (SVG text, Canvas 2D), as
+    /// <see cref="DrawParagraph"/> paints it.
     /// </summary>
-    public static float MeasureTextWidth(SKPaint paint, string text, float letterSpacing, RenderFont? font = null)
+    public static float MeasureParagraph(SKPaint paint, string text, RenderFont font, bool isRightToLeft)
     {
-        if (SplitFallbackRuns(paint, text, font) is not { } runs)
+        if (!BidiAlgorithm.RequiresReordering(text, isRightToLeft))
         {
-            return MeasureSingleTypefaceText(paint, text, letterSpacing);
+            return MeasureTextWidth(paint, text, font.LetterSpacing, font with { IsRightToLeft = false });
         }
 
         var width = 0f;
 
-        foreach (var (runText, typeface) in runs)
+        foreach (var (run, runIsRightToLeft) in BidiAlgorithm.GetVisualRuns(text, isRightToLeft))
+        {
+            width += MeasureTextWidth(paint, run, font.LetterSpacing, font with { IsRightToLeft = runIsRightToLeft });
+        }
+
+        return width;
+    }
+
+    /// <summary>
+    /// Draws a line of text that no layout has split into bidi runs: its runs in visual order
+    /// (UAX #9, with <paramref name="isRightToLeft"/> as the paragraph direction), left to right
+    /// from <paramref name="x"/>, each shaped in its own direction.
+    /// </summary>
+    public static void DrawParagraph(SKCanvas canvas, SKPaint paint, string text, float x, float y, RenderFont font, bool isRightToLeft)
+    {
+        if (!BidiAlgorithm.RequiresReordering(text, isRightToLeft))
+        {
+            DrawText(canvas, paint, text, x, y, font.LetterSpacing, font with { IsRightToLeft = false });
+            return;
+        }
+
+        foreach (var (run, runIsRightToLeft) in BidiAlgorithm.GetVisualRuns(text, isRightToLeft))
         {
-            if (ReferenceEquals(typeface, paint.Typeface))
+            var runFont = font with { IsRightToLeft = runIsRightToLeft };
+            DrawText(canvas, paint, run, x, y, font.LetterSpacing, runFont);
+            x += MeasureTextWidth(paint, run, font.LetterSpacing, runFont);
+        }
+    }
+
+    /// <summary>
+    /// Measures the advance width of <paramref name="text"/> as <see cref="DrawText"/> paints it.
+    /// </summary>
+    public static float MeasureTextWidth(SKPaint paint, string text, float letterSpacing, RenderFont? font = null) =>
+        ShapeText(paint, text, letterSpacing, font).Width;
+
+    /// <summary>
+    /// The boundaries (UTF-16 offsets, ascending, starting with 0) of the clusters HarfBuzz forms
+    /// for <paramref name="text"/>: the units text may be cut into without breaking a glyph.
+    /// </summary>
+    public static IReadOnlyList<int> GetClusterBoundaries(SKPaint paint, string text, RenderFont? font = null)
+    {
+        var boundaries = new SortedSet<int> { 0 };
+
+        foreach (var run in ShapeText(paint, text, font?.LetterSpacing ?? 0f, font).Runs)
+        {
+            foreach (var cluster in run.Clusters)
             {
-                width += MeasureSingleTypefaceText(paint, runText, letterSpacing);
+                boundaries.Add((int)cluster);
             }
-            else
+        }
+
+        boundaries.Add(text.Length);
+        return [.. boundaries];
+    }
+
+    /// <summary>
+    /// The glyphs of one typeface, positioned relative to the origin of the whole text, in
+    /// visual order.
+    /// </summary>
+    private sealed record GlyphRun(SKTypeface Typeface, ushort[] Glyphs, SKPoint[] Positions, uint[] Clusters);
+
+    private sealed record ShapedText(List<GlyphRun> Runs, float Width);
+
+    /// <summary>
+    /// Shapes text with HarfBuzz: split into runs of one typeface (<see cref="SplitFallbackRuns"/>)
+    /// and one script, each shaped in the run direction of <paramref name="font"/> (or its
+    /// script's, for right-to-left scripts) with the font's OpenType features, the whole text as context. Runs are placed
+    /// in visual order, so the first logical run is the rightmost one in right-to-left text.
+    /// Letter spacing goes after every cluster but the last and turns optional ligatures off.
+    /// </summary>
+    private static ShapedText ShapeText(SKPaint paint, string text, float letterSpacing, RenderFont? font)
+    {
+        var runs = new List<GlyphRun>();
+
+        if (string.IsNullOrEmpty(text) || paint.Typeface is not { } primary)
+        {
+            return new ShapedText(runs, 0f);
+        }
+
+        var isRightToLeft = font?.IsRightToLeft ?? false;
+        var features = ResolveFeatures(letterSpacing, font?.FontFeatures);
+        var segments = new List<(int Start, int Length, SKTypeface Typeface, HarfBuzzSharp.Script Script)>();
+        var offset = 0;
+
+        // Context from across an element boundary is handed to HarfBuzz around the text, so
+        // joining continues across it without being shaped (or measured) here.
+        var contextBefore = font?.ContextBefore ?? string.Empty;
+        var shapedText = contextBefore.Length == 0 && string.IsNullOrEmpty(font?.ContextAfter) ? text : contextBefore + text + font?.ContextAfter;
+
+        foreach (var (runText, typeface) in SplitFallbackRuns(paint, text, font) ?? [(text, primary)])
+        {
+            foreach (var (start, length, script) in SplitScripts(text, offset, runText.Length))
             {
-                using var runPaint = CreateFallbackPaint(paint, typeface, font!.Value);
-                width += MeasureSingleTypefaceText(runPaint, runText, letterSpacing);
+                segments.Add((start, length, typeface, script));
             }
 
-            width += letterSpacing > 0f ? letterSpacing : 0f;
+            offset += runText.Length;
         }
 
-        return letterSpacing > 0f ? width - letterSpacing : width;
+        if (isRightToLeft)
+        {
+            segments.Reverse();
+        }
+
+        var penX = 0f;
+        var spacingCount = 0;
+
+        foreach (var (start, length, typeface, script) in segments)
+        {
+            var hbFont = GetHarfBuzzFont(typeface);
+            var scale = paint.TextSize / hbFont.UnitsPerEm;
+
+            // Strong right-to-left characters always resolve to an odd bidi level (UAX #9 I1/I2),
+            // so a right-to-left script is shaped right to left even where the caller has not
+            // resolved the levels yet (layout measures words before reordering lines, SVG text
+            // never does): HarfBuzz shapes e.g. Arabic differently when forced left to right.
+            // Everything else (neutrals, or Latin under an override) takes the run direction.
+            using var buffer = new HarfBuzzSharp.Buffer();
+            buffer.AddUtf16(shapedText, contextBefore.Length + start, length);
+            buffer.Direction = isRightToLeft || script.HorizontalDirection == HarfBuzzSharp.Direction.RightToLeft
+                ? HarfBuzzSharp.Direction.RightToLeft
+                : HarfBuzzSharp.Direction.LeftToRight;
+            buffer.Language = GetLanguage(font?.Language);
+            buffer.GuessSegmentProperties();
+            hbFont.Font.Shape(buffer, features);
+
+            var infos = buffer.GetGlyphInfoSpan();
+            var positions = buffer.GetGlyphPositionSpan();
+            var glyphs = new ushort[infos.Length];
+            var points = new SKPoint[infos.Length];
+            var clusters = new uint[infos.Length];
+
+            for (var index = 0; index < infos.Length; index++)
+            {
+                glyphs[index] = (ushort)infos[index].Codepoint;
+                clusters[index] = infos[index].Cluster - (uint)contextBefore.Length;
+                points[index] = new SKPoint(penX + (positions[index].XOffset * scale), -positions[index].YOffset * scale);
+                penX += positions[index].XAdvance * scale;
+
+                // spacing follows the last glyph of every cluster
+                if (letterSpacing != 0f && (index + 1 == infos.Length || infos[index + 1].Cluster != infos[index].Cluster))
+                {
+                    penX += letterSpacing;
+                    spacingCount++;
+                }
+            }
+
+            runs.Add(new GlyphRun(typeface, glyphs, points, clusters));
+        }
+
+        // no spacing after the last cluster
+        return new ShapedText(runs, spacingCount > 0 ? penX - letterSpacing : penX);
     }
 
-    private static float MeasureSingleTypefaceText(SKPaint paint, string text, float letterSpacing)
+    // Without a `lang` the language is fixed rather than HarfBuzz's default (the host locale), so
+    // results do not depend on the machine.
+    private static readonly HarfBuzzSharp.Language DefaultLanguage = new("und");
+
+    private static readonly ConcurrentDictionary<string, HarfBuzzSharp.Language> Languages = new(StringComparer.OrdinalIgnoreCase);
+
+    private static HarfBuzzSharp.Language GetLanguage(string? language) =>
+        string.IsNullOrWhiteSpace(language) ? DefaultLanguage : Languages.GetOrAdd(language, static tag => new HarfBuzzSharp.Language(tag));
+
+    private static readonly HarfBuzzSharp.Feature[] NoLigatures = ParseFeatures("liga=0,clig=0,dlig=0,hlig=0");
+
+    /// <summary>
+    /// The features to shape with: optional ligatures off under letter spacing (CSS Text 3
+    /// §8.2), then those of the font's <c>font-variant-*</c>/<c>font-kerning</c>/
+    /// <c>font-feature-settings</c>, which come later and so take precedence.
+    /// </summary>
+    private static HarfBuzzSharp.Feature[] ResolveFeatures(float letterSpacing, string? fontFeatures)
     {
-        if (letterSpacing <= 0f)
+        var declared = string.IsNullOrEmpty(fontFeatures) ? [] : ParsedFeatures.GetOrAdd(fontFeatures, ParseFeatures);
+        return letterSpacing != 0f ? [.. NoLigatures, .. declared] : declared;
+    }
+
+    private static readonly ConcurrentDictionary<string, HarfBuzzSharp.Feature[]> ParsedFeatures = new(StringComparer.Ordinal);
+
+    private static HarfBuzzSharp.Feature[] ParseFeatures(string features)
+    {
+        var parsed = new List<HarfBuzzSharp.Feature>();
+
+        foreach (var entry in features.Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries))
         {
-            return paint.MeasureText(text);
+            if (HarfBuzzSharp.Feature.TryParse(entry, out var feature))
+            {
+                parsed.Add(feature);
+            }
         }
 
-        var width = 0f;
+        return [.. parsed];
+    }
+
+    /// <summary>
+    /// Splits a range of <paramref name="text"/> into runs of one script, as HarfBuzz shapes one
+    /// script at a time. Characters of no particular script (spaces, punctuation, digits,
+    /// combining marks) stay with the run they are in, or join the first run when they lead.
+    /// </summary>
+    private static List<(int Start, int Length, HarfBuzzSharp.Script Script)> SplitScripts(string text, int start, int length)
+    {
+        var result = new List<(int Start, int Length, HarfBuzzSharp.Script Script)>();
+        var runStart = start;
+        var runScript = HarfBuzzSharp.Script.Invalid;
+        var end = start + length;
+        var index = start;
 
-        foreach (var character in text)
+        while (index < end)
         {
-            width += paint.MeasureText(character.ToString()) + letterSpacing;
+            var codepoint = char.IsSurrogatePair(text, index) ? char.ConvertToUtf32(text, index) : text[index];
+            var script = HarfBuzzSharp.UnicodeFunctions.Default.GetScript((uint)codepoint);
+
+            if (script != HarfBuzzSharp.Script.Common && script != HarfBuzzSharp.Script.Inherited && script != HarfBuzzSharp.Script.Unknown)
+            {
+                if (runScript != HarfBuzzSharp.Script.Invalid && script != runScript)
+                {
+                    result.Add((runStart, index - runStart, runScript));
+                    runStart = index;
+                }
+
+                runScript = script;
+            }
+
+            index += codepoint > 0xFFFF ? 2 : 1;
         }
 
-        return width > 0f ? width - letterSpacing : 0f;
+        result.Add((runStart, end - runStart, runScript));
+        return result;
+    }
+
+    /// <summary>A HarfBuzz font for a typeface, kept with the blob and face behind it.</summary>
+    private sealed class HarfBuzzFont(HarfBuzzSharp.Blob blob, HarfBuzzSharp.Face face, HarfBuzzSharp.Font font, int unitsPerEm)
+    {
+        public HarfBuzzSharp.Blob Blob { get; } = blob;
+
+        public HarfBuzzSharp.Face Face { get; } = face;
+
+        public HarfBuzzSharp.Font Font { get; } = font;
+
+        public int UnitsPerEm { get; } = unitsPerEm;
     }
 
+    // Typefaces are themselves cached for the life of the process (bundled, installed and
+    // @font-face ones alike), so their HarfBuzz fonts are too. Shaping with a font is thread safe.
+    private static readonly ConcurrentDictionary<SKTypeface, HarfBuzzFont> HarfBuzzFonts = new(ReferenceEqualityComparer.Instance);
+
+    private static HarfBuzzFont GetHarfBuzzFont(SKTypeface typeface) =>
+        HarfBuzzFonts.GetOrAdd(typeface, static typeface =>
+        {
+            // the blob takes over the stream (it may point straight into its memory)
+            var blob = typeface.OpenStream(out var index).ToHarfBuzzBlob();
+            var face = new HarfBuzzSharp.Face(blob, index);
+            var unitsPerEm = Math.Max(1, face.UnitsPerEm);
+            var font = new HarfBuzzSharp.Font(face);
+
+            // positions in font units, scaled to the font size by the caller
+            font.SetScale(unitsPerEm, unitsPerEm);
+            font.SetFunctionsOpenType();
+            return new HarfBuzzFont(blob, face, font, unitsPerEm);
+        });
+
     private static IReadOnlyDictionary<string, BundledFontFamily> CreateBundledFonts()
     {
         var sansRegular = LoadBundledTypeface("DejaVuSans.ttf");
@@ -517,12 +739,17 @@ private static IReadOnlyDictionary<string, BundledFontFamily> CreateBundledFonts
         var serifBold = LoadBundledTypeface("DejaVuSerif-Bold.ttf");
         var monoRegular = LoadBundledTypeface("DejaVuSansMono.ttf");
         var monoBold = LoadBundledTypeface("DejaVuSansMono-Bold.ttf");
+        var devanagari = LoadBundledTypeface("NotoSansDevanagari-Regular.ttf");
 
         return new Dictionary<string, BundledFontFamily>(StringComparer.OrdinalIgnoreCase)
         {
             ["sans-serif"] = new BundledFontFamily(sansRegular, sansBold),
             ["serif"] = new BundledFontFamily(serifRegular, serifBold),
             ["monospace"] = new BundledFontFamily(monoRegular, monoBold),
+
+            // Only a fallback for the scripts the DejaVu fonts lack, never a generic family; its
+            // bold is synthesized.
+            ["devanagari"] = new BundledFontFamily(devanagari, devanagari),
         };
     }
 
diff --git a/src/AngleSharp.Renderer/Skia/Svg/SvgElementRenderer.cs b/src/AngleSharp.Renderer/Skia/Svg/SvgElementRenderer.cs
index 4387de4..76e9711 100644
--- a/src/AngleSharp.Renderer/Skia/Svg/SvgElementRenderer.cs
+++ b/src/AngleSharp.Renderer/Skia/Svg/SvgElementRenderer.cs
@@ -1,6 +1,7 @@
 namespace AngleSharp.Renderer.Skia.Svg;
 
 using AngleSharp.Dom;
+using AngleSharp.Renderer.Rendering;
 
 using SkiaSharp;
 
@@ -480,16 +481,20 @@ private static void DrawTextRun(SKCanvas canvas, string text, SvgPaintState stat
             TextSize = state.FontSize,
         };
 
-        var width = measurePaint.MeasureText(text);
+        // Shaped like HTML text (kerning, ligatures, joining scripts, font fallback), in visual
+        // order with `direction` as the paragraph direction.
+        var font = new RenderFont(state.FontFamily, state.FontSize, state.FontWeight, state.IsItalic, 0f, Language: state.Language);
+        var width = SkiaTextShaping.MeasureParagraph(measurePaint, text, font, state.IsRightToLeft);
         var ascent = -measurePaint.FontMetrics.Ascent;
         var descent = measurePaint.FontMetrics.Descent;
         var bounds = new SKRect(cursorX, y - ascent, cursorX + width, y + descent);
 
+        // `start` and `end` follow the direction: right-to-left text starts at its right edge
         var anchorOffset = state.TextAnchor switch
         {
             SvgTextAnchor.Middle => -width / 2f,
-            SvgTextAnchor.End => -width,
-            _ => 0f,
+            SvgTextAnchor.End => state.IsRightToLeft ? 0f : -width,
+            _ => state.IsRightToLeft ? -width : 0f,
         };
 
         var drawX = cursorX + anchorOffset;
@@ -500,7 +505,7 @@ private static void DrawTextRun(SKCanvas canvas, string text, SvgPaintState stat
         {
             fillPaint.Typeface = measurePaint.Typeface;
             fillPaint.TextSize = state.FontSize;
-            canvas.DrawText(text, drawX, y, fillPaint);
+            SkiaTextShaping.DrawParagraph(canvas, fillPaint, text, drawX, y, font, state.IsRightToLeft);
         }
 
         using var strokePaint = state.CreateStrokePaint(bounds, context, viewport);
@@ -509,10 +514,10 @@ private static void DrawTextRun(SKCanvas canvas, string text, SvgPaintState stat
         {
             strokePaint.Typeface = measurePaint.Typeface;
             strokePaint.TextSize = state.FontSize;
-            canvas.DrawText(text, drawX, y, strokePaint);
+            SkiaTextShaping.DrawParagraph(canvas, strokePaint, text, drawX, y, font, state.IsRightToLeft);
         }
 
-        cursorX += width;
+        cursorX += state.IsRightToLeft ? -width : width;
     }
 
     private static string NormalizeWhitespace(string text)
diff --git a/src/AngleSharp.Renderer/Skia/Svg/SvgPaintState.cs b/src/AngleSharp.Renderer/Skia/Svg/SvgPaintState.cs
index 212fa09..caad07f 100644
--- a/src/AngleSharp.Renderer/Skia/Svg/SvgPaintState.cs
+++ b/src/AngleSharp.Renderer/Skia/Svg/SvgPaintState.cs
@@ -73,7 +73,9 @@ internal readonly record struct SvgPaintState(
     float FontWeight,
     bool IsItalic,
     SvgTextAnchor TextAnchor,
-    SKColor CurrentColor)
+    SKColor CurrentColor,
+    bool IsRightToLeft = false,
+    string? Language = null)
 {
     public static SvgPaintState Initial { get; } = new(
         Fill: SvgPaintValue.FromColor(SKColors.Black),
@@ -96,7 +98,32 @@ internal readonly record struct SvgPaintState(
     /// SVG-internal &lt;style&gt; rules, then an inline `style` attribute.
     /// </summary>
     public SvgPaintState Resolve(IElement element, SvgRenderContext context, SvgViewport viewport) =>
-        ResolveDeclarations(ReadDeclarations(element, context), viewport);
+        ResolveDeclarations(ReadDeclarations(element, context), viewport) with { Language = ResolveLanguage(element, Language) };
+
+    /// <summary>
+    /// The language of the element's text (shaping takes it into account): its own <c>lang</c>
+    /// or <c>xml:lang</c>, else the inherited one, else that of the nearest ancestor that has one,
+    /// which reaches into the host page for an inline SVG.
+    /// </summary>
+    private static string? ResolveLanguage(IElement element, string? inherited)
+    {
+        for (var current = element; current is not null; current = current.ParentElement)
+        {
+            var language = current.GetAttribute("lang") ?? current.GetAttribute("xml:lang");
+
+            if (!string.IsNullOrWhiteSpace(language))
+            {
+                return language.Trim();
+            }
+
+            if (inherited is not null)
+            {
+                return inherited;
+            }
+        }
+
+        return null;
+    }
 
     /// <summary>
     /// Layers <paramref name="declarations"/> (property name to value) over this inherited state -
@@ -195,7 +222,12 @@ public SvgPaintState ResolveDeclarations(IReadOnlyDictionary<string, string> dec
             };
         }
 
-        return new SvgPaintState(fill, fillOpacity, stroke, strokeOpacity, strokeWidth, opacity, fillRule, fontFamily, fontSize, fontWeight, isItalic, textAnchor, currentColor);
+        // `direction` sets the paragraph direction of text (and what `start`/`end` anchors mean)
+        var isRightToLeft = TryGetDeclaration(declarations, "direction", out var directionValue)
+            ? string.Equals(directionValue.Trim(), "rtl", StringComparison.OrdinalIgnoreCase)
+            : IsRightToLeft;
+
+        return new SvgPaintState(fill, fillOpacity, stroke, strokeOpacity, strokeWidth, opacity, fillRule, fontFamily, fontSize, fontWeight, isItalic, textAnchor, currentColor, isRightToLeft, Language);
     }
 
     public SKPaint? CreateFillPaint(SKRect bounds, SvgRenderContext context, SvgViewport viewport) =>
@@ -330,7 +362,7 @@ private static bool TryParseOpacity(string value, out float opacity)
     public static readonly string[] PresentationProperties =
     [
         "fill", "stroke", "fill-opacity", "stroke-opacity", "stroke-width", "opacity", "fill-rule",
-        "font-family", "font-size", "font-weight", "font-style", "text-anchor", "color",
+        "font-family", "font-size", "font-weight", "font-style", "text-anchor", "color", "direction",
     ];
 
     private static Dictionary<string, string> ReadDeclarations(IElement element, SvgRenderContext context)
diff --git a/src/Directory.Build.props b/src/Directory.Build.props
index 0c22afa..81a3c0d 100644
--- a/src/Directory.Build.props
+++ b/src/Directory.Build.props
@@ -2,7 +2,7 @@
   <PropertyGroup>
     <Description>Adds rendering functionality to the core AngleSharp library.</Description>
     <Product>AngleSharp.Renderer</Product>
-    <Version>0.8.2</Version>
+    <Version>0.9.0</Version>
     <Nullable>enable</Nullable>
     <LangVersion>latest</LangVersion>
     <SignAssembly>true</SignAssembly>