You'll need: FontCreator (Windows and macOS) and a font whose glyphs are drawn and already well spaced.

Kerning is the polish that makes a typeface look like a typeface. It's the small, pair-by-pair correction that closes the gap in "AV", tucks the "o" under the arm of a "T", and stops "Yo" from drifting apart. This tutorial shows how to add kerning by eye in FontCreator's font editor, how to scale it sanely with class kerning instead of building thousands of individual pairs, how to generate a first pass automatically with Auto Kern, and how to test and ship the result.

One thing first, because it saves more rework than anything else: kerning is the last step, not the first. If your side-bearings aren't even yet, fix the spacing before you touch a single pair — see Glyph Spacing and Optical Metrics. Kerning on top of good spacing is a short list of genuine exceptions; kerning on top of bad spacing is a font-wide patch job you'll have to redo the moment you fix the spacing underneath.

What kerning actually is (and isn't)

These two words get tangled constantly, so pin them down before opening any window.

• Spacing (side-bearings) is per-glyph. Every glyph carries a left and a right side-bearing — the air built into the letter itself, applied everywhere that letter appears.
• Kerning is per-pair. It's an adjustment to the distance between two specific glyphs that look wrong even when their spacing is correct. The classic offenders are diagonal-against-vertical and round-against-round combinations: "AV", "To", "Yo", "Wa", "P.", "r."

A kerning value is just a horizontal shift — a number, usually negative, that pulls the second glyph closer to the first (a positive value pushes them apart, which you'll need far less often). It lives in the font's OpenType layout data, not on the glyphs, and it only fires between the two glyphs you named.

> Note: Side-bearings and kerning are two separate mechanisms. Changing a side-bearing moves a letter everywhere; changing a kerning pair only changes one specific neighbour relationship. If a whole letter looks too tight against everything, that's a spacing problem — don't kern your way out of it.

Adjust pairs by eye in the OpenType Designer

FontCreator edits kerning in the OpenType Designer, the same window that manages all your OpenType layout features. Open it from Font → OpenType Designer…, or click the OpenType Designer button on the toolbar (its hint reads "OpenType designer: edit kerning and OpenType layout features").

Inside, kerning lives in a Kerning (kern) feature with a pair-positioning lookup. Each entry is a first glyph, a second glyph, and a Kerning value — the shift applied between them. You add a pair, type the two glyphs, set the value, and watch the preview close or open the gap.

The honest way to find the right number is to look, not to guess. Build a test string that frames the pair you're tuning (more on strings below), nudge the value, and stop when the white space between the two letters matches the rhythm of the rest of the word. Negative values are the norm — most kerning pulls letters together. Reserve positive values for the rare combinations that genuinely sit too close, like a capital followed by a tall ascender.

> Tip: Kern the worst offenders first. A typeface only needs a few dozen carefully judged pairs to read well — the diagonals (A, V, W, Y, T), the round-to-round joins, and punctuation against tall letters. Chasing every theoretical pair is how you end up with a bloated, inconsistent kerning table.

Class kerning — avoid the pair explosion

Kerning every letter against every other letter individually does not scale. "A" kerns the same way before "V", "W" and "Y"; "T" behaves the same before "a", "c", "e", "o" and the rest of the round lowercase. If you build those as single pairs you'll author hundreds of near-identical values and have to fix each one by hand whenever you change a shape.

Class kerning (also called group kerning) solves this. You define a class — a group of glyphs that kern alike — and write one value between two classes instead of between every pair of members. Set "the diagonal capitals" against "the round lowercase" once, and every member combination inherits it.

In the OpenType Designer this is handled through the Class Manager (the Class Manager action / Edit Class entries on the kerning lookup). You build a left-side class and a right-side class, then enter a single kerning value for the class-against-class relationship; FontCreator stores it compactly and applies it to all the member pairs at once.

The payoff is twofold. Your kerning table stays small and fast (important for web fonts), and editing is sane — change the class value once and every pair it covers updates together. When one specific member is an exception, you can still override it with an individual pair on top of the class value.

> Watch out: Put each glyph in the class that matches how it kerns, not how it looks. A glyph that behaves differently on its left than on its right belongs to different left-side and right-side classes. Mis-filing one member quietly mis-kerns every pair it touches.

Auto Kern — generate a first pass automatically

You don't have to start from an empty table. Auto Kern measures the actual outlines of your glyphs and generates kerning values for you, the same way optical metrics generates side-bearings.

Run it from Tools → Auto Kern…. (There's also an Auto Kern command inside the OpenType Designer's kerning view, with the hint "Generate kerning pair values".) This opens the Automatic Kerning Wizard, a Next/Back wizard that walks you through the settings and shows a live preview before it commits anything.

The wizard's main controls:

• Glyph spacing factor — the global tightness, "usually between 20 and 30". Larger leaves more room between letters; smaller tightens the whole result. The preview line reports which factor it's showing so you can compare.
• Exclude pairs if the absolute XAdvance is less than — a threshold that drops trivially small adjustments so you don't clutter the table with values no reader could ever see.
• Exclude lowercase-uppercase pairs, Exclude lowercase-lowercase pairs, and Exclude digits — skip whole categories that rarely need kerning, keeping the output focused.
• Composite glyphs follow base glyph — accented forms inherit the kerning of the base letter they're built from, so "Á" kerns like "A" without separate pairs.

Step through the wizard, watch the preview, adjust the factor and the exclusions until the sample reads evenly, and apply.

> Tip: Auto Kern is a strong first draft, not a final answer. It's excellent at the bulk of regular pairs and saves hours, but it can over- or under-correct the hardest combinations — exactly the diagonals and round joins your eye is best at judging. Run it, then review.

Review and clean up the generated result

After Auto Kern runs, treat its output as a starting list to audit:

1. Proof the diagonals and round joins by eye. "AV", "Ta", "Yo", "Wo", "P.", "r." — the cases that are hard to compute are the ones to check.
2. Look for over-tight pairs where letters touch or overlap. Auto-generated values occasionally pull shapes into each other; loosen those.
3. Prefer fixing the class, not the pair. If you have class kerning set up, correct the class value so the fix propagates instead of editing dozens of individual members.
4. Delete pairs that add nothing. The wizard's exclude-threshold catches most of these, but a final sweep keeps the table lean.

The goal is the same as spacing: an even band of white marching across a line of text, with no pair drawing attention to itself.

Test with real strings

You can't judge a pair in isolation — kerning only looks right between other letters and inside real words. Type test strings that frame each tricky pair against steady neighbours, then read the rhythm.

• Diagonal-against-vertical: AV, AW, AY, TA, VA, WA, YA — and lowercase follow-ons like Ta, Va, Wo, Yo.
• Round-against-round and round-against-straight: oo, oc, co, nn, no, on.
• Punctuation against tall letters: T., V,, r., f), P, — and quotes around capitals.
• Whole words that mix shapes: WAVE, Yesterday, Toronto, AVATAR, quick brown fox — real text exposes uneven kerning faster than isolated pairs.

Type these in a preview and at a few sizes. Then proof the font outside FontCreator too — install it (or use a test viewer) and read it in an actual application, with kerning switched on, to confirm the layout engine applies your pairs the way you intend. For the full pre-release checklist, see Test & Validate Your Font.

> Note: Some pairs only need kerning in certain contexts, and some scripts need three-glyph (contextual) adjustments rather than simple pairs. If a flat pair value can't satisfy every situation, that's the cue to reach for contextual kerning — see Variable Contextual Kerning – Triplets.

How kerning ships on export

Kerning travels with the font in two possible forms, and FontCreator lets you choose both. In the Font Export Settings dialog there's a Kerning group with:

• Include OpenType 'GPOS' kerning — the modern path. GPOS stores your pairs and class kerning and is what current applications, browsers and operating systems read. Leave this on.
• Include legacy 'KERN' table — the old kern table, for older software that doesn't read GPOS. Both are on by default, which is the safe choice for the widest compatibility.

Class kerning is preserved through GPOS, so the compact table you built stays compact in the exported font. For the complete export walk-through, see Export a Font (Export Fonts Correctly).

> Watch out: If kerning seems to "disappear" after export, check that Include OpenType 'GPOS' kerning was enabled and that the application you're testing in actually applies kerning (some have it off by default). The pairs are in the font; the layout engine has to ask for them.

Troubleshooting

Frequently asked questions

Should I space or kern first? Space first, always. Run optical metrics, get an even rhythm, then kern the handful of pairs that good spacing still can't fix. Kerning is not a substitute for setting side-bearings.

How many kerning pairs does a font need? Far fewer than people expect — a few dozen well-judged pairs (plus class kerning) read better than thousands of individual ones. Quality and consistency beat quantity.

What's the difference between class kerning and pair kerning? Pair kerning sets a value between two specific glyphs. Class kerning sets one value between two groups of glyphs that kern alike, and applies it to every member combination at once. Class kerning keeps the table small and editing manageable; individual pairs can still override a class where needed.

Is Auto Kern's output final? Treat it as a strong first draft. It handles the bulk of regular pairs well; review the diagonals, round joins and punctuation by eye and correct anything that over- or under-shoots.

Do I need both the GPOS and the legacy KERN table? GPOS is what modern software reads and is the one that matters. The legacy kern table only helps very old applications. Both are on by default, which is the safest setting unless you have a reason to drop one.

My pair value won't fix a problem that only happens sometimes — why? Because simple pair kerning is context-free. When a pair needs different treatment depending on what surrounds it, you need contextual (triplet) kerning instead.

What to read next

• Glyph Spacing and Optical Metrics — set even side-bearings first, so kerning stays a short list of exceptions.
• Variable Contextual Kerning – Triplets — for pairs that need different values depending on context.
• Test & Validate Your Font — proof your kerning in real applications before you release.
• Enrich Your Fonts with OpenType Features — the wider toolkit the OpenType Designer manages alongside kerning.