How to common kerning pairs and their typical values
- Step 1Identify the cap+cap diagonals — `AV`, `VA`, `AW`, `WA`, `AY`, `YA`, `AT`, `TA`, `LV`, `LW`, `LY`, `PA`, `FA` — the largest negative spaces in Latin. Always must-kern, typically -60 to -120 FUnits at upm 1000. If a font misses these, it looks amateur at any display size.
- Step 2Identify the cap+lowercase pairs — After the overhanging caps T, V, W, Y, F, P, r: `Te`, `To`, `Tu`, `Tw`, `Ty`, `Va`, `Ve`, `Vo`, `Wa`, `We`, `Wo`, `Ya`, `Ye`, `Yo`, `Fa`, `Pa`. Must-kern, typically -30 to -90. These are the most frequent in real headline copy.
- Step 3Identify the lowercase pairs — `av`, `aw`, `ay`, `gr`, `oc`, `oe`, `ow`, `va`, `vo`, `ry`, `yo` — moderate kerning, -10 to -40. Invisible below ~24px; visible in large lowercase logotypes and oversized lead-ins.
- Step 4Identify the punctuation pairs — `T.`, `T,`, `Y.`, `Y,`, `V.`, `f'`, `r.`, `r,`, plus brackets/quotes after overhangs. Values vary widely (-20 to -80). Contribute polish more than legibility; missing ones look slightly loose rather than broken.
- Step 5Normalise the reference values to your font's upm — Reference values here assume upm 1000. For a font at upm 2048, multiply by 2.048 to get the comparable raw FUnit value. Better: convert both to em fractions (`value / upm`) and compare those — it removes the scale entirely.
- Step 6Match against your font's audit — Run the [Kerning Pair Auditor](/font-tools/kerning-pair-auditor) at Top-N 500 and search the JSON `sample` strings for each reference pair. Present with a sensible value: good. Absent: either a real gap (kern-table font) or GPOS storage (verify with the features inspector).
Cap+cap and cap+lowercase must-kern pairs
The headline-critical pairs. Typical values are rough Latin norms at upm 1000 — individual fonts vary. Normalise by your font's actual upm before comparing.
| Category | Pairs | Typical value (upm 1000) | Headline criticality |
|---|---|---|---|
| Cap + cap diagonal | AV VA AW WA AY YA | -60 to -120 | Critical — largest visible gap; the classic kerning test |
| Cap + cap mixed | AT TA LV LW LY PA FA | -40 to -90 | Critical in all-caps wordmarks |
| T/V/W/Y + lowercase | Te To Va Ve Wa We Wo Ya Yo | -30 to -90 | Critical — most frequent in real headline copy |
| F/P/r + lowercase/round | Fa Fe Pa ra (context) r. | -20 to -60 | Common; the overhang creates a gap over the next glyph |
Lowercase and punctuation pairs
Subtler pairs. Lowercase kerning is invisible at body size and only matters at large lowercase settings; punctuation kerning is about polish. Values at upm 1000.
| Category | Pairs | Typical value (upm 1000) | When it matters |
|---|---|---|---|
| Lowercase diagonal | av aw ay va vo ya yo | -10 to -40 | Large lowercase logotypes; invisible below ~24px |
| Lowercase round | oc oe ow gr ry | -5 to -25 | Display-size body type; gentle |
| Cap + period/comma | T. T, Y. Y, V. | -40 to -80 | Captions and labels; loose gaps look careless |
| Letter + quote/apostrophe | f' r' letter+' | -20 to -60 | Pull-quotes and large display text |
FUnit-to-em conversion reference
The same em fraction expressed at the two common upm scales. Use this to translate the reference values above onto your font's actual em size.
| Em fraction | Value at upm 1000 | Value at upm 2048 |
|---|---|---|
| -0.02 em (gentle) | -20 | -41 |
| -0.05 em (moderate) | -50 | -102 |
| -0.08 em (strong) | -80 | -164 |
| -0.10 em (very strong, AV-class) | -100 | -205 |
Cookbook
How to use this reference against a real font. The constant caveat: the Kerning Pair Auditor reads the legacy kern table only, so 'pair not found' needs the features inspector to interpret correctly.
Checking AV against a kern-table font
ExampleThe textbook case. The font has a legacy kern table; AV is present with a strong negative value. The audit confirms what the reference predicts.
Reference: AV should be roughly -60 to -120 at upm 1000.
Audit (search sample 'AV'):
{ "sample": "AV", "value": -98, "upm": 1000 }
-98 / 1000 = -0.098 em → solidly in range. Good kerning on
the single most important Latin pair.Normalising a high-upm font to the reference
ExampleA TrueType font at upm 2048 shows a -180 for AV. Raw, that looks huge; normalised, it's right in the reference band.
Audit: { "sample": "AV", "value": -180, "upm": 2048 }
-180 / 2048 = -0.088 em
Reference -0.06 to -0.12 em → in range.
Don't be fooled by the raw -180; it's normal for a 2048-upm
font. The conversion table maps -0.088 em ≈ -180 at upm 2048.Reference pair absent — but the font is GPOS-kerned
ExampleYou search for To and it isn't in the audit. Before concluding the font lacks it, check the features inspector — the font kerns via GPOS, so the legacy-table auditor shows nothing.
Audit: total_kerning_pairs 0 (no 'To' found) Features inspector: 'kern' feature present (GPOS) The font DOES kern To — it's in GPOS, which the legacy-table auditor can't read. The reference still describes the pair; the audit just can't show it. Confirm visually at 64px.
Reference pair genuinely missing
ExampleA kern-table font with no GPOS kerning, and Wa simply isn't in the list. This is a real gap against the reference.
Audit (kern-table font, Top-N 500): 'AV' present, 'To' present, 'Wa' NOT found Features inspector: no 'kern' feature in GPOS This font kerns AV and To but skips Wa — a real omission. At headline size 'Wa' will look loose. Flag it if your copy uses that pair prominently.
Using the conversion table to set a manual override
ExampleIf a font lacks a pair you need, the reference + conversion table tells you roughly how much tracking to apply as a CSS approximation.
Reference: Wa ≈ -0.05 em (moderate).
Your font: upm 1000, no Wa kern.
/* Approximate with targeted tracking on the headline string */
.headline-wa { letter-spacing: -0.05em; }
/* Caveat: letter-spacing applies to EVERY pair in the string,
not just Wa — review the other pairs don't over-tighten. */Edge cases and what actually happens
Every row below was probed against the live API. Some documented requirements (alphabetical axis order, numerical tuple order) are not actually enforced in practice — useful to know if you've been blaming the wrong thing for a 400.
Reference pair not in the audit
Check storage firstAn absent pair means one of two things: the font genuinely lacks it (legacy-table font, no GPOS), or the font kerns it in GPOS (which the auditor doesn't read). Disambiguate with opentype-features-inspector. Don't read 'absent from the legacy-table audit' as 'the font doesn't kern this pair' without that check.
Raw values look wildly different from the reference
Normalise by upmReference values assume upm 1000. A 2048-upm font's values are roughly 2x larger in raw FUnits for the same visual tightness. Always divide the audit's value by its upm (the field is in the JSON) and compare em fractions, not raw numbers. The conversion table maps the common fractions to both scales.
Lowercase pairs missing
Often acceptableMany fonts kern caps thoroughly but skip lowercase-only pairs because they're invisible below ~24px. Missing av/vo/ow is fine for a body-text or caps-headline brand; it only matters for large all-lowercase logotypes. The reference flags lowercase pairs as low-criticality for exactly this reason.
A pair shows as [glyphname] not letters
ExpectedIf a reference pair involves a glyph with no Unicode codepoint (a small cap, a ligature component), the audit's sample shows [glyphname] instead of the letter. Search by the glyph index or the name rather than the character. Default text rendering won't use these glyphs unless an OpenType feature activates them.
Positive value where the reference expects negative
Unusual but validThe reference values are negative (pull together) because that's the norm. A font with a positive value for a normally-negative pair is unusual — possibly a slab serif decision or a font bug. The audit surfaces it; whether it's intentional is a judgement call. Sorting by absolute value means it can rank surprisingly high.
Comparing two fonts' pair counts directly
Misleading across storage typesA kern-table font with 800 pairs vs a GPOS class-based font showing 0 in the auditor is not a fair comparison — the GPOS font may kern more thoroughly, just in a form the auditor can't count. Pair count only compares fairly between fonts using the same storage encoding.
Reference value range is wide
By designRanges like '-30 to -90' are intentionally broad because optimal kerning depends on the letterforms, the optical size, and the foundry's house style. The reference tells you the order of magnitude and the sign; it can't prescribe an exact value. A pair sitting anywhere in the band is reasonable.
CSS letter-spacing as a kerning substitute
Approximation onlyUsing letter-spacing to fake a missing pair applies the same tracking to every pair in the string, not just the one you wanted to tighten. It's a stopgap for a single headline, not a real fix. Authoring the pair in a font editor (Glyphs, FontForge) is the only proper solution — this tool is read-only.
Frequently asked questions
What's the most-kerned pair in Latin?
AV (and its mirror VA) typically gets the largest absolute value — around -60 to -120 at upm 1000, sometimes more in display faces. The diagonal of the A meeting the diagonal of the V creates the biggest open gap in Latin typography, so it needs the strongest correction. It's the classic single-pair test of whether a font is kerned at all.
Why don't the audit's values match this reference?
Almost always a upm scale mismatch. The reference assumes upm 1000; if your font is upm 2048 (common for TrueType), its raw values are roughly twice as large for the same visual tightness. Divide the audit's value by its upm to get an em fraction and compare that against the reference's em-normalised band. The conversion table shows the common fractions at both scales.
Why are none of these pairs in my font's audit?
Because the font stores kerning in GPOS, not the legacy kern table that the auditor reads. Most modern fonts do this. The pairs exist and kern correctly in browsers; the legacy-table auditor just can't see them. Confirm with opentype-features-inspector — a kern feature present means the font kerns these pairs in GPOS.
How many of these pairs should a good font have?
A thoroughly kerned legacy-table font covers all the cap+cap and cap+lowercase pairs (the ~50 must-kerns) plus many of the ~200 optional ones — often hundreds to a couple thousand total. But pair count only applies to kern-table fonts; a GPOS class-based font expresses the same coverage compactly and audits as zero. Judge by whether the must-kern pairs look right at display size.
Are punctuation pairs important?
They contribute polish more than legibility. T., Y,, f', and bracket/quote pairs after overhanging glyphs look slightly loose if un-kerned, but rarely broken. They matter most in captions, labels, and pull-quotes set at display size. Letter pairs (AV, To) are far more important; address those first.
Why do some fonts skip lowercase kerning?
Because it's invisible at body size. Below ~24px, the difference between kerned and un-kerned av or vo blends into general type density, so foundries optimising for body use skip it to save table size. Display fonts almost always kern lowercase too, because at headline sizes those gaps become visible. Missing lowercase kerning is fine unless your brand uses large lowercase logotypes.
How do I convert a reference value to my font's units?
Multiply the upm-1000 reference value by yourUpm / 1000. So -80 at upm 1000 becomes -80 × 2.048 = -164 at upm 2048. Or skip the math and compare em fractions: divide both the reference and the audit value by their respective upm, then compare. The conversion table maps -0.02 through -0.10 em onto both common scales.
Can I use letter-spacing to add a missing pair?
Only as a rough approximation. CSS letter-spacing applies to every gap in the string, not just the one pair you want to tighten, so it over-tightens the others. It's an acceptable stopgap for a single headline where one pair looks bad, but the proper fix is authoring the pair in a font editor. This tool is read-only and can't add kerning.
Is a pair with a positive value a bug?
Not necessarily. Positive kerning (pushing glyphs apart) is rare but legal — some slab serifs and monospaced faces use it deliberately. The reference values are negative because that's the overwhelming norm; a positive value for a normally-negative pair is worth a second look, but it could be an intentional design choice. The audit surfaces it either way.
How do I find a specific pair in the audit output?
Run the Kerning Pair Auditor at Top-N 500 (the max), then search the JSON for the two-character sample string, e.g. "AV" or "To". There's no in-tool search box — the slider is the only control — so you scan the downloaded JSON. If the pair involves a glyph with no codepoint, search by [glyphname] instead.
Does this reference apply to non-Latin scripts?
No — it's Latin-specific. Other scripts have their own critical pairs and usually kern via GPOS class lookups, which the auditor doesn't enumerate at all. For CJK, Arabic, or Indic kerning, neither this reference nor the legacy-table auditor is the right tool; use desktop fontTools on the GPOS table and script-specific typographic guidance.
What tools complement this reference for a full review?
Use the Kerning Pair Auditor to list kern-table pairs, opentype-features-inspector to confirm where kerning lives, glyph-inspector to see individual glyph outlines, and font-metrics-analyzer for vertical metrics. Together they cover spacing comprehensively; the kerning auditor alone only covers the legacy table.
Privacy first
Every JAD Font tool runs entirely in your browser using opentype.js and the wawoff2 WASM Brotli encoder. Your fonts never leave your device — verified by zero outbound network requests during processing.