---
name: Superfamily
slug: superfamily
category: typography
status: published
created: 2026-08-21T00:00:00.000Z
modified: 2026-08-21T00:00:00.000Z
definition: A type system whose serif, sans, and sometimes mono members share
  one skeleton, so they pair by construction rather than by taste.
aliases:
  - name: super family
  - name: type system
    source: community
  - name: matched family
tags:
  - fonts
relations:
  contrastWith:
    - font-pairing
    - variable-font
  variantOf: []
  partOf: []
  seeAlso:
    - sans-serif
implementations: []
sources:
  - title: How to Pair Fonts (Pangram Pangram)
    url: https://pangrampangram.com/blogs/journal/how-to-pair-fonts
demo: inline
exhibit: false
useWhen: picking two typefaces that are guaranteed to agree
---

A family is one design in several weights and styles. A superfamily is one design drawn
out into several classes: a serif, a sans, often a monospace, sometimes a slab or a
condensed set, all built on the same skeleton. The same shoulder on the n, the same
[x-height](/x-height), the same widths, the same bowl on the o, with the difference
carried entirely by what happens at the ends of the strokes. That is why the members
agree when you mix them. They are not two typefaces that happen to look good together,
they are one drawing wearing different terminals.

The practical consequence is that a superfamily removes a whole class of decision. Pair
a serif and a sans by eye and you are matching x-heights, widths, contrast and colour
across two designs that were never meant to meet; get it slightly wrong and headings and
body text look like they came from different documents. Take both from one superfamily
and the agreement is structural: swapping a paragraph from the serif to the sans changes
the texture without changing the [measure](/measure), because the letters occupy the same
widths. Interfaces lean on this hardest where a monospace member is needed for code or
numbers beside ordinary prose.

Do not confuse it with a [font stack](/font-stack), which sounds similar and does the
opposite. A stack is a fallback chain: several unrelated faces listed in order of
preference, so that if the first is unavailable the browser reaches for the next, and the
whole point is that the reader may end up in any one of them. A superfamily is a single
design system by one designer, where every member is meant to be used deliberately and
often on the same page. A stack is about what happens when a face is missing; a
superfamily is about what happens when two faces are both present.

Most superfamilies today ship as [variable fonts](/variable-font), so the members share an axis space as
well as a skeleton, and some go further and put the difference between the classes on an
axis of its own. Watch the [optical size](/optical-size) question separately: sharing a
skeleton does not mean sharing a size range, and a superfamily's display cut still needs
its own master. The honest way to compare members is a
[type specimen](/type-specimen) that sets them side by side with the shared metrics
ruled across. The specimen on this page draws its letters as vector paths rather than
setting them in a face, because no superfamily is loaded here and a claim about a shared
skeleton has to be visible as a shared skeleton.