Skip to content
Skills Library
Design & UX · Building & coding

typography

/typography

UI typography on Apple platforms — text styles and Dynamic Type, the San Francisco family (Pro/Rounded/Compact/Mono/New York + width axis), optical sizes, tracking vs kerning, leading adjustments, and custom-font scaling. Use when choosing fonts, building type hierarchy, fixing truncation/legibility, or making custom fonts respect Dynamic Type.

Licence
MIT
Last repository change
24.07.2026

Assessment and security

90/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content25 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
4
Deprecation

No signals detected. Repository changed on 24.07.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

UI typography on Apple platforms — text styles and Dynamic Type, the San Francisco family (Pro/Rounded/Compact/Mono/New York + width axis), optical sizes, tracking vs kerning, leading adjustments, and custom-font scaling. Use when choosing fonts, building type hierarchy, fixing truncation/legibility, or making custom fonts respect Dynamic Type.

Original author description

UI typography on Apple platforms — text styles and Dynamic Type, the San Francisco family (Pro/Rounded/Compact/Mono/New York + width axis), optical sizes, tracking vs kerning, leading adjustments, and custom-font scaling. Use when choosing fonts, building type hierarchy, fixing truncation/legibility, or making custom fonts respect Dynamic Type.

How it works

  1. When This Skill Activates
  2. Rule 1: text styles first
  3. Rule 2: let optical sizes and tracking work
  4. The Dynamic Type ladder (WWDC24 10074)
  5. The San Francisco family — pick by job
  6. Custom fonts: what you owe back
  7. Output Format
  8. References
Original SKILL.md headings · 114 lines, 877 words
SKILL.md preview
---
name: typography
description: UI typography on Apple platforms — text styles and Dynamic Type, the San Francisco family (Pro/Rounded/Compact/Mono/New York + width axis), optical sizes, tracking vs kerning, leading adjustments, and custom-font scaling. Use when choosing fonts, building type hierarchy, fixing truncation/legibility, or making custom fonts respect Dynamic Type.
allowed-tools: [Read, Write, Edit, Glob, Grep]
last_verified: 2026-07-16
review_by: 2027-06-22
---

# Typography

Type is most of your UI. The system does the hard parts — optical sizes, tracking tables,
Dynamic Type — *if* you use its APIs. This skill covers when to trust the system, how to build
hierarchy deliberately, and what custom fonts owe you back.

## When This Skill Activates

- Choosing fonts or building a type hierarchy for a screen or app
- Text truncating, cramping, or breaking under larger Dynamic Type sizes
- Adopting a custom/brand font (and keeping accessibility)
- Display typesetting: hero numbers, stats, editorial headlines

## Rule 1: text styles first

Predefined styles (Large Title → Caption 2) are weight + size + leading combos with Dynamic
Type support built in — and different styles scale *differently* (body grows more than
footnote), which manual font sizes can't replicate.

- Build hierarchy from 2–3 text styles + emphasized variants (bold trait — the actual weight
  varies per style: some go medium→semibold, others bold→heavy) before reaching for new fonts.
- Semantic colors + text styles together give dark mode, contrast, and Dynamic Type for free.
- macOS supports text styles (without Dynamic Type); design Mac type at 100% — no iOS-style
  scaling assumptions.

## Rule 2: let optical sizes and tracking work

- San Francisco blends Text→Display designs **continuously between 17 and 28pt** (below: sturdier
  letterforms, looser tracking for legibility; above: tighter, more refined). System font APIs do
  this automatically — hardcoded single-cut fonts don't.
- **Tracking, not kerning**, for letterspacing — tracking is size-specific and lets the OS
  disable clashing features (ligatures). Override system tracking only in exceptional cases.
- Truncation pressure? Use `allowsTightening` (default-tightening-for-truncation) instead of
  manually squeezing — and prefer wrapping to truncating (line limit 0 on labels that matter).
- Line height moves only via leading traits: tight = −2pt, loose = +2pt (±1pt on watchOS); the
  system adds leading automatically for tall scripts (Arabic, Devanagari).

## The Dynamic Type ladder (WWDC24 10074)

12 sizes: 7 default + 5 accessibility (AX1–AX5). `.body` runs 17pt at default up to 53pt
at AX5 — roughly 3× taller, and layouts must expect that. Escalate in order:

1. **Text styles** — `.font(.title)` / `preferredFont(forTextStyle:)` +
   adjusts-for-content-size, line count 0 so text wraps instead of truncating.
2. **`@ScaledMetric`** for the non-text riding alongside (icon frames, spacing); SF
   Symbols scale via `UIImage.SymbolConfiguration(textStyle:)`. Prioritize scaling
   essential content over decoration.
3. **Switch layout axis at accessibility sizes** — branch on
   `dynamicTypeSize.isAccessibilitySize` with `AnyLayout(HStackLayout())` /
   `AnyLayout(VStackLayout())` (UIKit: flip the stack axis on
   `preferredContentSizeCategory.isAccessibilityCategory`); give text the full line
   width and relax `lineLimit`.
4. **Large Content Viewer** — only for bars that legitimately can't grow: a tab bar takes
   under 10% of screen height, and scaled to accessibility sizes it would eat almost a
   quarter (WWDC24 10074). Scaling is always preferred; the viewer is the fallback, not
   the fix.

Test at all 12 sizes (Xcode Previews → Variants → Dynamic Type Variants), not just the
biggest — mid-range accessibility sizes catch different wrap points.

## The San Francisco family — pick by job

| Face | Job |
|---|---|
| SF Pro | The default; UI text everywhere |
| SF Pro Rounded | Friendlier numerals/labels — widgets, health/fitness data |
| SF Compact | watchOS (space-efficient counterpart) |
| SF Mono | Code, tabular alignment |
| New York | Serif — reading experiences, editorial contrast |
| SF Arabic / SF Arabic Rounded | Arabic script with its own optical sizes |

**The width axis** (Condensed / Regular / Compressed / Expanded):

- Default Regular; every non-Regular choice is a legibility decision — check it.
- Condensed: fit more text comfortably (long headlines wrap one line fewer).
- Compressed: display-only density, not body text.
- Expanded: display typesetting AND small secondary labels (wide + loose tracking).
- Width is a **fourth hierarchy lever** beside weight, size, color; all widths share identical
  vertical proportions, so mixing them never misaligns baselines. 2–3 styles are enough —
  pair one width with contrasting weights, one weight with contrasting widths, or oppose both
  for maximum display contrast.

## Custom fonts: what you owe back

System fonts get Dynamic Type free; a brand font makes *you* the type engine:

- Scale with `UIFontMetrics(forTextStyle:).scaledFont(for:)` + adjusts-for-content-size, or
  SwiftUI `Font.custom(_:size:relativeTo:)`; scale layout constants with `@ScaledMetric`.
- Test at the largest accessibility sizes — wrap to multiple lines rather than truncate.
- Verify script coverage for your locales; have a fallback plan for writing systems the brand
  font doesn't cover (the system stacks: `system-ui`, `ui-rounded`, `ui-serif`, `ui-monospace`
  on the web).
- Budget for the maintenance: tracking tables, optical sizing, and weight ramps are things SF
  does that a licensed font usually doesn't.

❌ Anti-patterns: hardcoded point sizes on user-facing text · kerning APIs for tracking jobs ·
custom font without `relativeTo:` (frozen size) · Compressed body text · truncation where
wrapping was possible.

## Output Format

Type review: `Element | Current (font/size/style) | Issue (hierarchy/scaling/legibility) | Fix`
— check Dynamic Type at XXL + AX sizes before signing off; pairs with the contrast rules in
`generators/accessibility-generator`.

## References

- https://developer.apple.com/videos/play/wwdc2020/10175/ (The details of UI typography)
- https://developer.apple.com/videos/play/wwdc2022/110381/ (The expanded San Francisco family)
- https://developer.apple.com/fonts/ (SF + New York downloads)
- https://developer.apple.com/design/human-interface-guidelines/typography
- Related skills: `design/sf-symbols` (symbols align to text styles), `foundation/attributed-string` (rich text mechanics), `generators/accessibility-generator`

Versions

RepositoryScoreLicence
This page · rshankras/claude-code-apple-skills90MIT
dreamlab-ai/agentbox100AGPL-3.0
glebis/claude-skills100MIT
oborchers/fractional-cto100MIT
glebis/humane-agentic-design100MIT
arnavpuri/designskills100MIT
danium/practicaltypography100MIT
Dragoon0x/dragoon-skills100MIT
EthanYoQ/Skill-hub95MIT

Database snapshot: 13.11.2026 · package version 0aa604bb7771 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 90apple-typography-workflow
    Guide Apple platform typography decisions and implementation across SwiftUI Font, UIKit UIFont, AppKit NSFont, San Francisco system fonts, SF Pro, SF Compact, SF Mono, SF Pro Rounded, New York serif design, Dynamic Type, text styles, fontDesign, fontWeight, fontWidth, monospaced…
  • 90apple-design-foundations
    Use when choosing colors, typography, or layout/spacing for an Apple-style interface — semantic & dynamic system colors, Display P3 wide gamut, dark mode, the San Francisco type family, Dynamic Type, the 8-point grid, safe areas, and bento layouts. Part of the apple-design…
  • 91apple-hig-typography
    Use when choosing, reviewing, or adapting Apple-platform text hierarchy, system/custom fonts, Dynamic Type, Bold Text, legibility, or spatial text.
  • 100apple-hig-typography
    Use when designing, reviewing, or implementing typography in Apple-platform apps — SwiftUI text styles, hierarchy, readable sizes, monospaced data, custom fonts, labels, captions, and accessibility.
  • 100accessibility-dynamic-type-specialist
    Audits views for compliance with Apple's Dynamic Type accessibility nutrition label. Checks that text scales with the user's preferred size, fonts use text styles or UIFontMetrics, and layouts adapt for accessibility sizes. Use when the user asks to check Dynamic Type support,…
  • 90typeset
    Improve UI typography by fixing font choices, type scale, hierarchy, weight, and readability so text feels intentional. Use when the user mentions fonts, typography, type scale, readability, text hierarchy, or sizing that feels off.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.