Font Migration: How to Move Fonts Between Computers and Operating Systems

Moving Fonts Between Operating Systems

Font files themselves are largely portable. What is not portable is the container format some fonts ship in, the way each system renders outlines, and the licence that permits the installation. Work through those three before you copy anything.

Which Formats Survive the Crossing

Anything in the bottom half of that table needs converting before it will install on the other side. Our online font converter handles the common cases in the browser, and the Type 1 migration section of the legacy formats guide covers the PostScript families in detail, including what happens to kerning data on the way out.

Why the Same Font Looks Different After the Move

The two systems render outlines differently, and the difference is not a bug on either side. Windows uses DirectWrite and ClearType, which lean on the TrueType hinting instructions inside a font to snap stems onto the pixel grid. macOS uses Core Text, which renders the outline more or less faithfully and largely ignores hinting. The practical consequences run in both directions.

Planning Any Font Migration

The same five steps apply whichever direction you are moving. The platform sections below give the specific commands for each one.

Migrating Fonts on macOS

macOS keeps fonts in four places, and only two of them are yours to move. Getting this distinction right is the difference between a clean migration and a Mac that boots to placeholder boxes in the menu bar.

Where macOS Stores Fonts

Inventory and Back Up

# Count and list what is installed for this user
find ~/Library/Fonts -type f \( -name "*.ttf" -o -name "*.otf" -o -name "*.ttc" \) | wc -l
du -sh ~/Library/Fonts

# Flag anything that will not survive a move to Windows
find ~/Library/Fonts -type f \( -name "*.dfont" -o -name "*.pfb" -o -name "*.ttc" \)

# Back up fonts and Font Book organization together
BACKUP_DIR=~/Desktop/Font_Backup_$(date +%Y%m%d)
mkdir -p "$BACKUP_DIR"
cp -R ~/Library/Fonts "$BACKUP_DIR/User_Fonts"
cp -R ~/Library/FontCollections "$BACKUP_DIR/FontCollections"
cp ~/Library/Preferences/com.apple.FontBook.plist "$BACKUP_DIR/"

Before transferring, open Font Book, select all fonts with Cmd+A, and run File then Validate Fonts. Fix or remove anything reported under Serious Problems. Minor problems are usually safe to carry across. Migrating a corrupt font simply moves the problem to a machine where it is harder to diagnose.

Choose a Transfer Method

# On the old Mac
cp -R ~/Library/Fonts /Volumes/ExternalDrive/Font_Migration/
cp -R ~/Library/FontCollections /Volumes/ExternalDrive/Font_Migration/

# On the new Mac, with Font Book and design apps closed
cp -R /Volumes/ExternalDrive/Font_Migration/Fonts/* ~/Library/Fonts/
cp -R /Volumes/ExternalDrive/Font_Migration/FontCollections/* ~/Library/FontCollections/

# Rebuild the font database, then restart
sudo atsutil databases -remove

Clean Up in Font Book

Once the files are in place, open Font Book and do three things. Run Edit then Look for Duplicates, and resolve them, preferring the copy in ~/Library/Fonts over older versions elsewhere. Re-run File then Validate Fonts on the new machine, since a transfer can truncate files. Then disable fonts you do not need: application launch times and font menus both suffer past roughly 200 active families, and disabled fonts stay installed and can be re-enabled at any time.

Troubleshooting on macOS

Migrating Fonts on Windows

Windows differs from macOS in one way that matters more than any other: a font file sitting in the Fonts folder is not installed until it also has a registry entry. Copying files alone produces the classic symptom of a font that is visibly present on disk and invisible in every application.

Where Windows Stores Fonts

Inventory with PowerShell

# List every registered system font
$fonts = Get-ItemProperty 'HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Fonts'
$fonts.PSObject.Properties | Where-Object { $_.Name -notmatch '^PS' } |
  Select-Object @{N='FontName';E={$_.Name}}, @{N='FileName';E={$_.Value}} |
  Sort-Object FontName | Format-Table -AutoSize

# Flag legacy Type 1 files that need converting before migration
Get-ChildItem "C:\Windows\Fonts" -Include *.pfm,*.pfb -Recurse -ErrorAction SilentlyContinue |
  ForEach-Object { Write-Host "Type 1 font found: $($_.Name)" -ForegroundColor Yellow }

# Export a full inventory for the record
Get-ChildItem "C:\Windows\Fonts" |
  Select-Object Name, Extension, @{N='SizeKB';E={[math]::Round($_.Length/1KB,1)}}, LastWriteTime |
  Export-Csv -Path "font-inventory.csv" -NoTypeInformation

# Include per-user fonts (Windows 10 1809 and later)
$userFontPath = "$env:LOCALAPPDATA\Microsoft\Windows\Fonts"
if (Test-Path $userFontPath) { Get-ChildItem $userFontPath | Format-Table Name, Extension }

Export the registry keys as well as the files. The CSV tells you what you had, and the registry export tells you how it was registered, which is what you will compare against if fonts go missing on the new machine.

Install on the New Machine

For a handful of fonts, select them in Explorer, right-click, and choose Install for all users, which writes both the file and the registry entry. For a bulk migration, copy the files and register them in one pass. The script below is also the basis of the Group Policy startup script further down.

$FontSource = "D:\Font_Migration"
$FontDest   = "C:\Windows\Fonts"
$RegPath    = "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Fonts"

Get-ChildItem $FontSource -Include *.ttf,*.otf -Recurse | ForEach-Object {
    $destPath = Join-Path $FontDest $_.Name
    if (-not (Test-Path $destPath)) {
        Copy-Item $_.FullName $destPath -Force
        $fontName = [System.IO.Path]::GetFileNameWithoutExtension($_.Name)
        New-ItemProperty -Path $RegPath -Name "$fontName (TrueType)" -Value $_.Name -Force
        Write-Host "Installed: $($_.Name)"
    }
}

ClearType and Hinting

If any of these fonts are headed for a website, hinting is the step that decides whether Windows users see sharp text or mush. ClearType aligns glyph outlines to the pixel grid using the hinting instructions in the font, so an unhinted font that looked perfect on a Mac can render badly in Chrome and Edge on Windows.

# Install the toolchain (Python 3.8+ from python.org or the Microsoft Store)
pip install fonttools[woff] brotli ttfautohint-py

# Hint first, then convert. The order matters.
ttfautohint ^
  --stem-width-mode=qqq ^
  --increase-x-height=14 ^
  --hinting-range-min=8 ^
  --hinting-range-max=50 ^
  input.ttf input-hinted.ttf

python -m fontTools.ttLib -o output.woff2 input-hinted.ttf

# Note: ^ is line continuation in CMD. Use a backtick in PowerShell.

WSL runs the same Linux font tooling if you would rather follow instructions written for macOS or Linux. If you do not want a local toolchain at all, the webfont generator produces WOFF2 files and the matching @font-face CSS in the browser.

Deploying Across an Organization

For a fleet rather than a single machine, there are two supported routes. A Group Policy computer startup script running the install script above, pointed at a network share, covers domain-joined estates. For cloud-managed devices, package the fonts and an install script as a Win32 app with the IntuneWinAppUtil tool, upload it to Microsoft Intune, set a detection rule that checks for a known font file in C:\Windows\Fonts, and assign it to device groups. Broader fleet policy, including licence tracking at that scale, is covered in the enterprise font management guide.

Troubleshooting on Windows

Post-Migration Checklist

Work through this on the destination machine before you close the migration out. Most of the failures that surface weeks later would have been caught by items four and five.