Pairing Typefaces

Typography Fundamentals

Course 1 ยท Chapter 5 ยท Pairing Typefaces

In Typography Fundamentals 4 you built a hierarchy from one typeface, using size, weight, colour and space to rank the levels. That is a strong foundation, and plenty of excellent pages stop there. But sooner or later you will want a second voice: a headline face with more personality, or a calm body face next to a lively title. Choosing that second typeface is called pairing. It is where beginners most often go wrong, because two fonts that are each lovely can still look dreadful together. This chapter gives you a few simple tests so that you are choosing for reasons and not by luck.

What was run, and what was not
The one Python script in this chapter was run on Windows with Python 3.14.0, using only the standard library. The output shown is exactly what it printed. The x-height numbers in it are rough, illustrative values typed in by hand, not measurements of the real fonts (check). The specimens on the page are live text in fonts that ship with most computers, so they may look slightly different on your system. The CSS snippets were not tested across several browsers.

Why Pairings Work or Clash

Think of two people at a dinner table. If they are almost the same, you wonder why both were invited. If they are completely unrelated, the conversation never starts. The ones who get on are different enough to be interesting and share something underneath. Typefaces behave the same way, and the rule that follows is easy to remember:

  • Clear difference on at least one obvious axis (serif against sans-serif, light against heavy, plain against decorative), so the pairing looks chosen.
  • Quiet similarity on another axis (similar x-height, similar proportions, similar mood or era), so the two look like they belong.

The failure is the middle ground: two typefaces that are nearly alike. A reader cannot tell whether the difference is a design decision or an accident, and the page looks slightly out of tune. Here are the three situations side by side. Same sentence, same sizes; only the face of the heading changes:

Clash: two near-twin serifs

Winter Allotment Notes

Lift the last of the leeks before the ground freezes hard, and cover the bare beds with compost.

Too far apart: a heavy display face with a mono body

Winter Allotment Notes

Lift the last of the leeks before the ground freezes hard, and cover the bare beds with compost.

Works: serif heading, sans body, matched size

Winter Allotment Notes

Lift the last of the leeks before the ground freezes hard, and cover the bare beds with compost.

Notice that the third sample sets the sans-serif body slightly smaller than the others. Verdana is a wide face with a tall x-height, so at the same nominal size it looks bigger than Georgia (Typography Fundamentals 1 introduced x-height). Matching the apparent size of two faces, not their numbers, is half the craft of pairing.

Contrast or Harmony: Two Strategies

There are two honest ways to combine type, and both are valid. Choose one on purpose.

StrategyThe ideaExampleRisk
ContrastTwo different families, each with a clear jobA serif for headings, a sans-serif for bodyMismatched size or mood makes them fight
HarmonyOne family, or a family and its relatives, varied by weight, width and styleOne sans-serif in light, regular and boldCan feel flat if the weights are too close (see Typography Fundamentals 4)

A good way to build a contrast pairing is to change one big thing and keep the rest similar. If the classification differs (serif against sans-serif, from Typography Fundamentals 2), keep the proportions and the era roughly alike. If you want an expressive display face for a headline, let the body face be as plain and neutral as possible.

The roles rule
Give every typeface a job before you choose it: "headings", "body", "code", "captions". If you cannot say what a face is for, it does not belong on the page. A typeface with no job is decoration, and decoration is the first thing to cut.

Superfamilies: Pairing Made Easy

The safest pairing is one the designer already made for you. A superfamily is a set of related typefaces, often a serif, a sans-serif and sometimes a mono or slab, drawn together to share proportions and details, so they pair well by construction. Several well-known sets exist (check): for instance, some open-source families publish a matching serif and sans, and some include a monospace for code. When you are unsure, a superfamily lets you get contrast without having to judge x-heights yourself.

Even a single family gives you a lot of room. As you saw in Typography Fundamentals 2, one family may offer many weights, a condensed and an extended width, and an italic. A page that uses only one family in four or five carefully chosen styles can be both rich and perfectly consistent. Many professional designs never use a second family.

OptionEffortVarietySafety
One family, several stylesLowestModerateAlmost unbreakable
SuperfamilyLowHighHigh: designed to match
Two unrelated familiesHighest: you do the matchingHighDepends on your eye

The Two-Family Limit

A useful starting rule is: no more than two families on one page or in one small design system (check: some designers allow three if one is a mono for code). Each extra family adds visual noise and, on the web, extra files to download (Typography Fundamentals 6 returns to that cost). Two families, each used consistently for its role, plus a few weights and sizes, is enough for nearly everything.

A consistent use matters more than the number. If headings are serif on one page and sans-serif on the next, the site looks like several different sites stitched together, even though only two families are involved.

Worked Examples

Three small pairings, each with a verdict. Read the reasons, not just the looks.

A. A newsletter: Georgia + Verdana

The Tuesday Bake

Warm, readable and friendly. Serif and sans give clear contrast; the matched sizes keep them in step.

B. A tech blog: Verdana + Courier New

Reading Log Files

Body in sans, code samples in mono. Mono has a clear job, so it earns its place.

C. A poster: Impact + Impact

SUMMER FAIR SATURDAY

Gates open at ten, music from noon, raffle at four.

Sample A and B are good: each pairs two different classifications with a clear role for each. Sample C fails for a different reason. It uses one loud face for everything, so there is no hierarchy and the small text is tiring to read; a display face is built for a few big words, not a paragraph. The cure is to keep Impact for the headline and set the details in a quiet sans-serif.

Common mistakes in pairing
Pairing two similar-but-different faces (two serifs, two geometric sans-serifs); mixing three or four families "for variety"; choosing a display face for body text; matching sizes by number instead of by eye; and changing the pairing page by page.

A Crude Pairing Checker

You cannot automate taste, but you can automate a sanity check on the two things this chapter keeps repeating: are the classes different, and are the x-heights close? This script holds a few made-up x-height values (as fractions of the em, rough and for illustration only (check)) and gives each pair a verdict.

"""Pairing check: do two typefaces differ enough to look deliberate? py pair.py """ # name: (class, x-height as a fraction of the em, weight of the regular style) FACES = { "Georgia": ("serif", 0.48, 400), "Times New Roman": ("serif", 0.45, 400), "Verdana": ("sans-serif", 0.55, 400), "Arial": ("sans-serif", 0.52, 400), "Courier New": ("monospace", 0.42, 400), "Rockwell": ("slab", 0.48, 400), } PAIRS = [("Georgia", "Verdana"), ("Georgia", "Times New Roman"), ("Arial", "Verdana"), ("Times New Roman", "Courier New"), ("Rockwell", "Georgia")] print(f"{'pair':<34}{'classes':<24}{'x-height gap':>13} verdict") for a, b in PAIRS: ca, xa, _ = FACES[a] cb, xb, _ = FACES[b] gap = abs(xa - xb) if ca == cb and gap < 0.05: verdict = "clash: near twins, looks like a mistake" elif ca == cb: verdict = "weak: same class, mismatched size" elif gap > 0.08: verdict = "contrast, but fix the sizes to match" else: verdict = "good: clear contrast, similar size" print(f"{a + ' + ' + b:<34}{ca + '/' + cb:<24}{gap:>13.2f} {verdict}")
pair classes x-height gap verdict Georgia + Verdana serif/sans-serif 0.07 good: clear contrast, similar size Georgia + Times New Roman serif/serif 0.03 clash: near twins, looks like a mistake Arial + Verdana sans-serif/sans-serif 0.03 clash: near twins, looks like a mistake Times New Roman + Courier New serif/monospace 0.03 good: clear contrast, similar size Rockwell + Georgia slab/serif 0.00 good: clear contrast, similar size

The script agrees with your eye on the first three rows: serif with sans is fine, and two near-identical serifs or two near-identical sans-serifs clash. It is also wrong in an instructive way. It calls Rockwell with Georgia "good" simply because the classes differ, yet a slab and a bookish serif are both warm, sturdy and fairly close in feel, so many designers would find that pairing too similar. A script that only knows classes and x-heights cannot see mood, and that is why the final check is always your own eye on real text.

Putting a Pairing into CSS

The pairing belongs in two custom properties, one per role, so that the whole site follows from two lines and a change of mind costs you two lines (the same idea as the size scale in Typography Fundamentals 4). Always add a generic fallback at the end of each stack.

:root { /* Two roles, two families, each with a generic fallback */ --font-heading: Georgia, "Times New Roman", serif; --font-body: Verdana, Geneva, sans-serif; --font-code: "Courier New", monospace; } body { font-family: var(--font-body); font-size: 0.9375rem; line-height: 1.6; } h1, h2, h3 { font-family: var(--font-heading); font-weight: 700; } code, pre { font-family: var(--font-code); font-size: 0.9em; }

Two details are worth noting. The body is set slightly below 1rem because Verdana looks large; that is the apparent-size matching from earlier, done in code. And the code, pre rule sets 0.9em because monospace faces tend to look larger than the text around them (check).

Idea in this chapterAn idea you may already know
Contrast with shared groundA colour scheme: a bold accent colour works because the rest is neutral
Roles for typefacesVariable names in code: each has one clear purpose
SuperfamilyA component library: parts built together fit together
Two-family limitKeeping a project's dependencies down: each extra one has a cost

Hands-On Exercises

Three exercises: a written design task that picks and defends a pairing, a code task that extends the checker, and a CSS task that builds a pairing into a page. Each has a solution file that opens in a new tab.

Exercise 1

A small independent bookshop wants a new look for its website, with three pieces of text: the shop name, the book descriptions and the opening-hours notice. On paper, choose a type plan using no more than two families (you may use well-known system fonts such as Georgia, Verdana, Arial, Courier New or Times New Roman). Give each family a role, say whether you chose contrast or harmony and why, state one thing the two faces have in common, and name one pairing you rejected and the specific reason it would clash.

๐Ÿ“„ View solution
Exercise 2

Extend the pairing checker so that each face also has a mood tag (for example "formal", "friendly", "technical", "loud") and a role list (for example "heading", "body", "code"). Add two new rules: warn when two faces have the same mood and the same class, and warn when a face is used for a role it is not suited to (such as a loud display face for body text). Add at least two new faces, run it on at least six pairs and print a summary line at the end that says how many pairs passed without a warning.

๐Ÿ“„ View solution
Exercise 3

Write a stylesheet for a short recipe page that sets up a pairing with custom properties for a heading family, a body family and a code or quantities family. Give each a generic fallback, adjust the body size so that its apparent size matches the heading face, and style a small label (such as "Serves 4") in the heading family in small capitals with tracking. Add a comment on each rule saying which role the family plays, and a final comment explaining how you would change the whole page to a different pairing by editing only two lines.

๐Ÿ“„ View solution

Chapter 5 Quick Reference

  • A pairing needs clear difference plus quiet similarity; the failure is two faces that are nearly alike
  • Two strategies: contrast (two families with clear jobs) or harmony (one family, varied by weight, width and style)
  • Roles first: give each typeface a job (heading, body, code) before choosing it
  • Superfamilies are designed to match; one family in several styles is almost unbreakable
  • Two-family limit as a starting rule (check); be consistent about which family does which job
  • Match apparent size, not the font-size number: wide, tall-x-height faces need a smaller size
  • In CSS: store each family in a custom property, with a generic fallback; a pairing then changes in two lines
  • Display faces are for a few big words, not for paragraphs