Dylania — type specimen

Type specimen · concept mockup no. 1 initialcapacity · type studio

A calm monospace for terminals and prose. Dylania keeps the proven skeleton of JetBrains Mono — the tall x-height, the 600-unit advance, the flat-cut terminals — and re-skins it with fuller bowls, quiet disambiguation, and a true italic. No ligatures, by design.

fig. 01 — skeleton & metrics

The inherited frame

Every glyph sits in a fixed 600/1000 advance (dashed verticals). Cap height 730, x-height 530 — tall enough that lowercase carries at terminal sizes — with generous descenders and vertical metrics that bake in comfortable line spacing, since terminals ignore your line-height. Vertical metrics, per 1000 em: ascent 734 · descent 222 · line pitch 1200 — a built-in 1.2 em rhythm (2048 UPM in production).

fig. 02 — control characters

Where the new skin shows

The differentiation from JetBrains Mono lives in the curves: fuller, rounder bowls on a e g o s where JetBrains flattens toward rectangles, a single-story g with an open tail, and stroke endings cut flat to the grid. Calm, not characterless.

fig. 03 — disambiguation

Quietly unambiguous

dotted zero / cap O

serifed one / flagged l / cap I

the classic lineup

mirror set

rn vs m

vv vs w

cl vs d

l collisions

hex & id confusables

round-form digits

; , . : ' "

punctuation, up close

A centered dot in the zero, a flat base serif on the one, a flagged and tailed l, crossbarred I — and the second row stress-tests the classic misreads: the m's arches are visibly narrower than two n's, w is one angular gesture where vv is two rounded valleys, the flagged l keeps cl from fusing into d, and ll / lI / l1 stay countable because flag, crossbar, and base serif never repeat. Every ambiguity resolved without a single mark that would read as noise in running prose — the slashed zero stays home (a ss01 stylistic set offers it for those with the muscle memory).

fig. 04 — terminal

Grid discipline

$ dylania --info

┌─ dylania 0.1.0 ────────┐
│ glyphs     364         │
│ upm        2048        │
│ ligatures  none        │
└────────────────────────┘

$ dylania --joins

┌─┬─┐
├─┼─┤
└─┴─┘

$ echo "il1 O0 {x != 0}"

il1 O0 {x != 0}

Box-drawing glyphs are a v1 requirement, drawn to connect seamlessly across lines; block elements, the full box-drawing set, and powerline symbols are all drawn. Punctuation is slightly oversized — in a TUI, punctuation is structure, not decoration.

fig. 05 — code

The day job

// measure ink, not the cell

const gap = (cell, glyph) => {
  const [l, r] = glyph.ink;
  return cell - (r - l);
};
const xs = rows.filter(Boolean).map((v, i) => ({...v, i}));
type Deep = Map<string, Set<Map<Cell, u32>>>;

// notes: italics keep the roman advance

<li>{xs.map((r) => (<Cell {...r} />))}</li>

# dotted zero, tailed l, f-strings

def is_ambiguous(ch):
    return ch in "0Oo1lI|"
df = df.loc[df['col'] == f"{v:.2f}"]

// rust: turbofish, lifetimes

let xs = Vec::<u32>::new();
impl<'a> Iter<'a> { type Item = Option<T>; }

Operators stay literal — => is an equals and a greater-than, spaced to read as one gesture. Brackets and braces are drawn full-height and slightly oversized, comments carry the same rhythm as code, generics and JSX close-outs stay countable at depth, and 0Oo1lI| stays unambiguous mid-identifier.

fig. 06 — the pixel test

Small sizes, real pixels

const [l, r] = glyph.ink; // il1 O0

const [l, r] = glyph.ink; // il1 O0

const [l, r] = glyph.ink; // il1 O0

const [l, r] = glyph.ink; // il1 O0

const [l, r] = glyph.ink; // il1 O0

mean     std      min     max
0.125    47.50    6.983   1024.8
892.44   3.1416   0.001   57.09

The same line from 34 px down to 11 px, then a decimal table exercising the full digit set. The dotted zero, flagged l, and serifed 1 hold shape at reading sizes; the production build ships TrueType autohinting proofed at 11–16 px so low-DPI panels keep this behavior.

fig. 07 — prose & the true italic

A second voice that keeps the grid

dylania is a monospace family in
four styles. it reads calmly in
long documentation, aligns tables
in readmes, and stays honest in
terminals. no ligatures: each
glyph stands alone, unfused.

notes read in a second voice:
same advance, gentler angle.

roman

true italic · 9° · same advance

The italic is redrawn, not slanted: single-story a, descending tailed f, gentle entry strokes at a 9° angle — cursive enough to be a real voice for emphasis and comments, but every glyph holds the exact roman advance, so italic text never breaks the column grid.

fig. 08 — weights

Four styles for v1, six by v1.1

light · 300 · v1.1

regular · 400

italic · 400

medium · 500 · v1.1

bold · 700

bold italic · 700

Regular, Italic, Bold, Bold Italic — the four styles terminals actually map — plus Light and Medium in v1.1 for dimmed panes and comment styling (shown here as monoline previews; production weights are interpolated masters).

fig. 09 — operators & delimiters

No ligatures, by design

:: != !== -> => >= ===
() [] {} <> | / ' "

Every operator renders as its literal characters — a stated feature, not a missing one. The effort goes into composed spacing instead: => and != should look balanced without being fused. Delimiters occupy four distinct silhouettes — curve, square, curly, angle — so nesting scans at a glance.

fig. 10 — the brief, condensed

Design notes

personality: Calm and neutral. Differentiation through refinement — curve quality, spacing, detail — never flair.
skeleton: JetBrains Mono proportions: 600/1000 advance, x-height ≈ 0.53 em, open counters and apertures.
terminals: Strokes end in flat horizontal and vertical cuts, aligned to the pixel grid.
rendering: Monoline mockup today; the production build ships TrueType autohinting proofed at 11–16 px on low-DPI panels before release.
habitat: Terminal and TUI first, docs and mixed prose second. Structure stays terminal-strict; the warmth lives in the curves and the italic.
coverage v1: ASCII, Latin-1, full box drawing and block elements, powerline symbols.

note — the compiled fonts carry the production drawing rules: ~10% stroke contrast (horizontals run lighter) and automatic junction tapering at every bowl-to-stem joint. The inline samples on this page are simplified monoline previews; download the fonts to see the drawn letterforms.