Fonts by Platform

macOS

macOS has the cleanest desktop font management of any major OS. Font Book ships built-in, handles installation and validation, supports collections, and provides activation controls. macOS natively supports TTF, OTF, TTC (TrueType Collection), and the legacy DFONT format unique to Mac.

Install Locations

Workflow

• Quick install: Double-click the font file → Font Book opens → click "Install Font"
• Bulk install: Drag font files into ~/Library/Fonts via Finder
• Validate before installing: Font Book → File → Validate Fonts catches corrupted files and duplicates
• Activate / deactivate: Right-click in Font Book to disable a font without removing it
• Pro management: Suitcase Fusion or FontExplorer X for activation per-project, font sets, server sync

DFONT and Format Conversion

DFONT (Mac Data Fork Font) is the legacy format that ships with macOS system fonts. It uses TrueType outlines internally, essentially TTF data in a Mac-specific container. For cross-platform projects, convert DFONT to TTF using our DFONT to TTF converter. Conversion is lossless. macOS 10.15+ has been gradually moving toward standard TTF/OTF.

Common Issues

Font won't install: usually a corrupted file or duplicate font name conflict. Run Font Book → File → Validate Fonts. Font appears installed but doesn't show up: restart the app, or use atsutil databases -remove in Terminal to clear the font database cache.

Windows

Windows supports TTF, OTF, TTC (TrueType Collection), and the legacy FON format. Windows 10 and 11 also support variable fonts. The legacy EOT format Microsoft created for Internet Explorer is now obsolete, IE retired in 2022, and modern web work should use WOFF2.

Install Locations

Workflow

• Right-click install: Right-click the font file → "Install" (current user) or "Install for all users" (admin)
• Bulk install: Settings → Personalization → Fonts → drag font files into the page
• Verify install: Settings → Fonts shows everything installed; preview any font by clicking
• ClearType: Run cttune.exe to tune anti-aliasing for your monitor
• Restart the application (or sometimes Windows itself) if fonts don't appear in Word/Photoshop after install

EOT and Format Conversion

EOT was Microsoft's proprietary web font format with DRM. It only ever worked in Internet Explorer, was rejected for W3C standardization in favor of WOFF, and is now obsolete with IE's retirement. Convert EOT files to WOFF2 for modern web use.

Common Issues

Font installed but not in apps: restart application or system. Adobe Creative Cloud and MS Office cache the font list and need full restart. Blurry rendering: enable ClearType, update graphics drivers, check monitor scaling (125%/150% can produce poor rendering on older fonts without proper hinting).

Linux

Linux uses the fontconfig system to manage fonts, with FreeType as the rasterizer. Most modern distributions (Ubuntu, Fedora, Arch) handle fonts identically, drop files into the right directory, run the cache update, done. Linux is also where most command-line font tooling lives (fonttools, FontForge, fc-cache, ttf2eot).

Install Locations

Workflow

# Install for current user
mkdir -p ~/.local/share/fonts
cp my-font.ttf ~/.local/share/fonts/

# Update font cache
fc-cache -fv

# List all installed fonts
fc-list

# Find a specific font family
fc-list : family style | grep -i inter

# Check if a font is available
fc-match "Inter Bold"

Command-Line Font Tools

• FontForge: scriptable font editor for serious modification work, glyph edits, subsetting, format conversion
• fonttools / pyftsubset: Python library and CLI for subsetting, instance generation from variable fonts, OpenType layout debugging
• woff2_compress / woff2_decompress: reference implementation of WOFF2 compression for build pipelines
• fc-cache, fc-list, fc-match: the fontconfig CLI for installation cache management and font discovery

GUI Options

Font Manager (gnome-font-viewer, GNOME Fonts) provides preview and installation through a GUI, similar to macOS Font Book. KDE has its own font management in System Settings. Both work fine for casual users; serious font work happens in the terminal.

Android

Android supports TTF and OTF for native apps. TTC requires Android 9+. Variable fonts work on Android 8+. WOFF and WOFF2 are only for WebView; native UI components don't accept them. The system font is Roboto, free, optimized for screen rendering, zero APK size impact.

Adding Custom Fonts to an App

Place font files in res/font/ within your Android Studio project. Reference them in XML or programmatically:

<!-- res/values/styles.xml -->
<TextView
    android:fontFamily="@font/inter_bold"
    android:text="Hello"/>

<!-- Or programmatically -->
val typeface = ResourcesCompat.getFont(this, R.font.inter_bold)
textView.typeface = typeface

// Compose
Text(
  text = "Hello",
  fontFamily = FontFamily(Font(R.font.inter_bold))
)

Downloadable Fonts

Android 8+ supports Downloadable Fonts via Google Play Services, fonts download on-demand from the Google Fonts catalogue, dramatically reducing APK size. Eliminates the need to bundle fonts in your APK at all for any of the 1,500+ Google Fonts.

Reducing APK Size

• Subset aggressively: use our font subsetter with Latin-only for English-only apps; 70-90% size reduction
• Limit weights: Regular, Medium, Bold cover 95% of UI cases. Light, Black, Italic variants double font footprint each
• Variable fonts: a single Roboto Variable replaces 6+ static weight files
• System fonts free: Roboto family via android:fontFamily="sans-serif" variants adds zero bytes

React Native

For React Native: drop TTF files in your project, configure react-native.config.js with a fonts asset path, and run npx react-native-asset (replaces the deprecated react-native link). Reference fonts by their PostScript name (which may differ from filename).

iOS

iOS supports TTF, OTF, and TTC. Variable fonts work on iOS 12+. The system font is SF Pro (San Francisco), beautifully designed, free, supports Dynamic Type for accessibility, and adds zero bytes to your app. For most apps, system fonts are the right answer.

Adding Custom Fonts to an App

1. Drag font files (.ttf or .otf) into your Xcode project
2. Ensure the font is added to your target's Copy Bundle Resources in Build Phases
3. Open Info.plist and add the font filenames under UIAppFonts
4. Reference the font by its PostScript name (often differs from the filename)

// Swift / UIKit
let label = UILabel()
label.font = UIFont(name: "Inter-Bold", size: 16)

// SwiftUI
Text("Hello")
    .font(.custom("Inter-Bold", size: 16))

// Debug, list available font family names
for family in UIFont.familyNames {
    print(family)
    for name in UIFont.fontNames(forFamilyName: family) {
        print("  \(name)")
    }
}

Common Issues

Font not appearing: most common cause is using filename instead of PostScript name. Run the debug snippet above. Second most common: not added to Copy Bundle Resources. Third: missing from UIAppFonts in Info.plist.

App Store Licensing

Apple's App Review occasionally rejects apps with improperly licensed fonts. Document your licenses, store proof of purchase, and have it ready if questioned. Open-source fonts (OFL, Apache 2.0) are unambiguously safe, see our open source font licenses guide.

Reducing App Size

• SF Pro for any system-feeling UI, free and supports Dynamic Type natively
• Subset aggressively for English-only apps
• Variable fonts to replace 6-12 static weights
• Custom fonts need manual Dynamic Type support, use UIFontMetrics.default.scaledFont(for:)

Chromebook

Chrome OS is the most font-restricted of the major platforms. There's no built-in system font installer, you can't just drop a TTF file somewhere and have apps pick it up. Chrome OS ships with a sensible default set (Roboto, Noto Sans/Serif covering most languages, monospace fonts), and uses font substitution for common "web-safe" fonts (Arial, Times New Roman, Verdana).

Web Fonts

Web fonts work normally on Chromebooks, Chrome browser renders WOFF2, WOFF, TTF, and OTF via @font-face identically to any other platform. Google Fonts work without any special setup. For web development, Chromebook is functionally identical to any other Chrome environment.

Custom Fonts via Linux (Crostini)

If you have Linux (Crostini) enabled on your Chromebook, you can install fonts inside the Linux container, same workflow as standard Linux. These fonts are available in Linux applications running through Crostini (LibreOffice, GIMP, Inkscape, command-line tools) but are not exposed to Chrome OS itself or to Android apps running on the Chromebook.

# In Crostini terminal
mkdir -p ~/.local/share/fonts
cp my-font.ttf ~/.local/share/fonts/
fc-cache -fv

# Now usable in Linux apps only

Google Docs and Workspace

Google Docs has its own font picker via the "More fonts" option, which exposes hundreds of Google Fonts directly. You cannot add custom fonts outside the Google Fonts library to Google Docs on Chromebook, this is the cleanest workflow for typography work on Chrome OS without dropping into Linux.

Cross-Platform Projects

When the same fonts need to render consistently across macOS, Windows, Linux, iOS, Android, and the web, the answer is rarely "one format for everything." Each platform has its own optimal format and rendering pipeline.

Format Choice by Context

Cross-Platform Rendering Differences

Even with identical fonts, rendering varies between platforms because each uses a different rasterizer:

• macOS Core Text: generally bolder appearance, smooth anti-aliasing, accurate to designer intent
• Windows DirectWrite: ClearType subpixel rendering, sharper but historically more aggressive sub-pixel positioning
• Linux FreeType: historically the "most accurate" outline rendering, depends on hinting strategy configured
• Android: Roboto-tuned subpixel rendering, optimized for mid-DPI mobile displays
• iOS: Core Text variant, optimized for high-DPI Retina displays

These differences mean a font that looks great on Mac may appear thin on Windows or over-aliased on Linux. Always test on actual devices before locking brand fonts into a multi-platform product.

CSS System Font Stacks

For native-feeling cross-platform typography on the web, system font stacks let each OS render in its own native UI font:

/* Modern system UI font stack */
font-family:
  -apple-system,           /* iOS / macOS Safari */
  BlinkMacSystemFont,      /* macOS Chrome */
  "Segoe UI",              /* Windows */
  Roboto,                  /* Android */
  Oxygen-Sans,             /* KDE Linux */
  Ubuntu,                  /* Ubuntu */
  Cantarell,               /* GNOME */
  "Helvetica Neue",        /* macOS legacy */
  sans-serif;              /* fallback */

/* Or just use system-ui (modern browsers) */
font-family: system-ui, sans-serif;

Universal Format Compatibility

TTF is the most universally compatible format. It works natively on Windows, macOS, Linux, iOS, Android, ChromeOS (via Linux), and most legacy systems. OTF works almost as well, with slightly newer support requirements on some older systems. For web specifically, WOFF2 is the standard. There's no font format that's optimal everywhere, choose the right one per context.

No Font is Truly Universal

Even "web-safe" fonts like Arial, Georgia, and Verdana are not truly universal. They exist on most systems but with slight version differences and metrics variations. For guaranteed visual consistency across platforms, embed your fonts (apps), self-host your fonts (web), or use system stacks (when native-feeling typography is acceptable).