Markdown Test Pattern

Broadcast engineers had test patterns. This is ours: every markdown element the theme styles, on one page, so you can see how the phosphor palette handles real content before committing to it.

Headings#

The heading scale is deliberately shallow - terminals didn't do six weights of type, and neither does this.

Third level#

Fourth level#

Fifth level#

Text formatting#

Body copy is bold, italic, both at once, struck through, and inline code. Links inside a paragraph are underlined like classic hypertext; external ones open in a new tab. Keyboard shortcuts read naturally as code: Ctrl + C.

Footnotes work too¹, including multiple references².

Images#

Images get a partial-grayscale phosphor treatment so photographs sit naturally against the terminal background. Hover to ease the filter back:

Images are lazy-loaded automatically by the theme's render hook.

Blockquotes#

The terminal is the most efficient interface ever devised for talking to a computer, and every generation rediscovers this about ten years later.

Nested quotes work as well:

Including this one, two levels deep.

Lists#

Unordered lists use a > prompt marker:

• Phosphor persistence
• Horizontal scan lines
  • Nested items indent cleanly
  • And keep their markers
• Beam brightness falloff at the edges

Ordered lists keep their numerals:

1. Power on, wait for the CRT to warm
2. Watch the raster stabilize
3. Log in

Task lists render with checkboxes:

• Historically accurate phosphor colors
• Pure-CSS effects, zero JavaScript
• Actual 15 kHz flyback whine

Tables#

Tables scroll horizontally on narrow screens rather than breaking the layout.

Code#

Inline const answer = 42 sits in the text. Fenced blocks get line numbers and class-based highlighting (requires noClasses = false):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

// Server renders the terminal session over a websocket.
func handleSession(w http.ResponseWriter, r *http.Request) error {
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        return fmt.Errorf("upgrade: %w", err)
    }
    defer conn.Close()

    for {
        if err := pump(conn); err != nil {
            return err
        }
    }
}

Different languages, same monochrome treatment:

1
2
3
4
5

SELECT terminal, phosphor, COUNT(*) AS units
FROM   installations
WHERE  year BETWEEN 1983 AND 1987
GROUP  BY terminal, phosphor
ORDER  BY units DESC;

1
2
3
4
5

/* Set syntax.colored = true for a multi-color palette instead */
.crt-scanlines {
  background: linear-gradient(to bottom, transparent 50%, rgb(0 0 0 / 40%) 50%);
  background-size: 100% 3px;
}

With line numbers enabled (as in this demo), an over-long line scrolls horizontally inside the block, so the numbers stay aligned with their code:

1

$ dmesg | grep -i tty && echo "this line is deliberately long enough to demonstrate how the theme handles overflow inside a fenced code block on narrow viewports"

Horizontal rules#

Rules render as a terminal divider:

Definition-style content#

Term lists fall back to standard markup:

Phosphor persistence

How long the coating keeps glowing after the beam moves on. Long persistence reduces flicker but smears motion.

Refresh rate

How often the beam repaints the screen - 60 Hz on most DEC terminals.

That's the whole pattern. If everything above reads cleanly in your chosen scheme, the theme is configured correctly.