Font Version Control: Managing Font Versions with Git

Why Version Control for Fonts?

Font files are software. Like any software, they evolve over time -- new characters are added, kerning is refined, bugs are fixed. Without version control, font projects suffer from the same problems as unversioned code: lost changes, unclear history, and collaboration conflicts.

Google Fonts -- which manages over 1,050 font families -- requires all submissions to be maintained in public Git repositories with automated CI builds. This practice, pioneered by the open-source font community, has become the standard for professional font development. GitHub Actions automates build + FontBakery checks in approximately 2 minutes per build.

Source Formats for Version Control

The key to effective font version control is using text-based source formats that Git can diff meaningfully. Binary formats (TTF, OTF) change completely with every edit, making diffs useless.

Git Repository Setup

A well-structured font repository separates source files from build outputs and includes proper ignore rules.

# Recommended repository structure
my-font-family/
├── sources/
│   ├── MyFont-Regular.ufo/
│   ├── MyFont-Bold.ufo/
│   └── MyFont.designspace
├── fonts/
│   ├── ttf/              # Built TTF files
│   ├── otf/              # Built OTF files
│   └── webfonts/         # Built WOFF2 files
├── scripts/
│   └── build.py          # Font build script
├── .gitignore
├── .gitattributes
├── LICENSE.txt           # OFL or commercial license
├── METADATA.pb           # Google Fonts metadata (if applicable)
└── README.md

.gitignore for Font Projects

# Build outputs (regenerated from sources)
fonts/ttf/
fonts/otf/
fonts/webfonts/

# OS files
.DS_Store
Thumbs.db

# Editor backups
*.bak
*~

# Python build cache
__pycache__/
*.pyc
build/
dist/
*.egg-info/

.gitattributes for Font Projects

# Treat font source files as text for proper diffing
*.ufo/** text
*.glyphs text
*.designspace text
*.fea text

# Binary font files (if tracked) use LFS
*.ttf filter=lfs diff=lfs merge=lfs -text
*.otf filter=lfs diff=lfs merge=lfs -text
*.woff filter=lfs diff=lfs merge=lfs -text
*.woff2 filter=lfs diff=lfs merge=lfs -text

Font Versioning Conventions

OpenType fonts store a version number in the name table (nameID 5) as "Version X.YYY". This is separate from your Git tags but should be kept in sync.

# Using font-v to manage font versions
pip install font-v

# Check current version
font-v report MyFont-Regular.ttf

# Bump version (updates name table + head table)
font-v write --ver=2.100 MyFont-Regular.ttf

# Tag the Git release to match
git tag -a v2.100 -m "Version 2.100: Added Cyrillic support"
git push origin v2.100

Branching & Collaboration Workflows

Solo Font Developer

For individual type designers, a simple trunk-based workflow works well:

• Work on main branch for day-to-day development
• Create feature branches for major additions (e.g., feature/cyrillic-support)
• Tag releases with version numbers (v2.100)
• Commit frequently with descriptive messages

Team Font Development

For multi-designer teams, use a pull request workflow:

• main is always release-ready (protected branch)
• Feature branches for each designer's work (e.g., alice/italic-refinements)
• Pull requests require review from at least one other designer
• CI runs FontBakery checks before merge is allowed
• Release branches for final QA before tagging

CI/CD Font Build Automation

Automate font compilation with CI/CD so every commit produces tested, production-ready font files. This is the standard workflow for Google Fonts and most open-source font projects.

# .github/workflows/build-fonts.yml
name: Build Fonts
on: [push, pull_request]

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Set up Python
        uses: actions/setup-python@v5
        with:
          python-version: '3.11'

      - name: Install dependencies
        run: pip install fontmake fonttools[woff] fontbakery  # FontBakery 1.1.0+

      - name: Build fonts from UFO sources
        run: |
          fontmake -m sources/MyFont.designspace \
            -o ttf --output-dir fonts/ttf/
          fontmake -m sources/MyFont.designspace \
            -o variable --output-dir fonts/variable/

      - name: Generate WOFF2 web fonts
        run: |
          for ttf in fonts/ttf/*.ttf; do
            fonttools ttLib.woff2 compress "$ttf" \
              -o "fonts/webfonts/$(basename ${ttf%.ttf}.woff2)"
          done

      - name: Run FontBakery quality checks
        run: |
          fontbakery check-universal fonts/ttf/*.ttf \
            --checkid !com.google.fonts/check/name/trailing_spaces \
            -l WARN

      - name: Upload build artifacts
        uses: actions/upload-artifact@v4
        with:
          name: font-files
          path: |
            fonts/ttf/
            fonts/variable/
            fonts/webfonts/

Git LFS for Binary Font Files

If you need to track compiled font binaries in Git (for distribution repos or when build automation is not available), use Git Large File Storage (LFS) to avoid bloating your repository.

# Install and set up Git LFS
git lfs install

# Track binary font formats with LFS
git lfs track "*.ttf"
git lfs track "*.otf"
git lfs track "*.woff"
git lfs track "*.woff2"

# Commit the .gitattributes file
git add .gitattributes
git commit -m "Configure Git LFS for binary font files"

# Now add and commit font files as normal
git add fonts/
git commit -m "Add compiled font binaries v2.100"

Best Practices