Library / SDK
rootfont/rootfont avatar
rootfont/rootfont

Ten weighted factors produce a programming grade, but Programming mode only grades monospaced fonts

The native font manager for designers and programmers on macOS.

2,648 stars228 forksSwiftApache-2.0

At a glance

What is it?
rootfont is a macOS-only Swift font manager whose Programming workspace grades monospaced fonts S/A/B/C/NR across ten weighted factors. This alpha build ships scoring, multi-mode compare, activation and editor config export in one window, and several of its own lists and defaults disagree with each other.
Who is it for?
rootfont suits a Mac user who already builds from source and wants grading, activation and editor snippets in one window, and it does not suit anyone waiting on a stable release: all three tags are alpha or beta, the newest is v0.3.0-alpha from 2026-06-16, and the last push landed 2026-08-16. Before trusting any grade, confirm which weight preset produced it and whether scores.json was rebuilt after your last font change.
Can I use it commercially?
Yes. Apache-2.0 is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository last received commits 91 days ago.
What is it written in?
Mainly Swift, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • rootfont/rootfont2,648 ★ · -7
Star history
Repository2026-10-042026-11-15
rootfont/rootfont2.7k2.6k

-7 Stars in the last 42 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

Programming mode is scoped to monospaced fonts before any score runs

Switching the sidebar from Library to Programming does two things at once: it narrows the catalog to monospaced fonts, and it changes the default sort to programming fit. That filter runs ahead of the scoring pipeline, so the ten factor grades only ever get applied to fonts that already passed a monospaced test. A proportional family with wide coverage and clean hinting never receives a grade through this route, and no documented path scores one outside Programming mode. Three sidebar filters sit alongside the switch: Recommended for code, Avoid for code, and Managed by rootfont. The last one is not a property of the typeface at all. It tracks fonts the app installed itself, which is the thread the activation section picks up.

Ten weighted factors, four presets, and a cache keyed to font files

The Programming suitability score spans ten weighted factors: monospace baseline, glyph disambiguation, ligatures, stylistic flexibility, box drawing, Powerline, Nerd Font, variable font, language coverage, and weight variety. Each result lands on a grade of S/A/B/C/NR, shown as a badge on the grid card with per-factor progress bars and a Why popover explaining the breakdown, and low grades get improvement hints. Weighting is not fixed. Settings ships Default, Terminal Heavy, IDE Heavy, and Minimalist presets plus ten independent sliders, so two people can look at the same file and see different letters. Computed scores persist at `~/Library/Application Support/rootfont/scores.json`, described as invalidated on font file changes. Nothing states what happens to that cache when the weights themselves move.

Compare is four overlays and a delta, and code preview covers twelve languages

Font compare lives in the preview panel and offers side-by-side, overlay with both opacity and visibility controls, glyph zoom, and outline diff. Alongside those visual modes it reports the score delta between a baseline font and a candidate, the top factor deltas, and the difference in language coverage, which turns a subjective pairing into numbers you can argue about. The preview surface toggles between Sample and Code, and Code carries mini syntax highlighting for twelve languages: Swift, TypeScript, JavaScript, Python, Rust, Go, Java, Kotlin, SQL, JSON, Shell, and CSS. Snippet text is picked per language through a SnippetCatalog with Semantic and Native strategies, so the toggle shows an idiomatic fragment instead of filler for that language.

The screenshot block for the current build is an empty paragraph

The section titled Screenshots (v0.3.0-alpha) contains an empty centered paragraph element and nothing else. What follows are two instructions aimed at contributors rather than readers: images follow the `screenshots/v<version>/NN-<slug>.png` convention, and new ones are checked locally with `python3 scripts/optimize-screenshots.py --check` before committing. The screenshots directory is present in the repository tree, alongside logo-rootfont.png and logo-rootfont-300x300.png. The net effect is that the release carrying the entire Programming workspace, the scoring pipeline and multi-mode compare is described in detail and illustrated with nothing at all. The version segment of that path is also written as a placeholder rather than a concrete folder name.

One list names five interface languages, another names eight

The Features list advertises a localized UI in English, Simplified Chinese, Traditional Chinese, Japanese, and Korean. The Localization section a few lines lower names eight codes: `en`, `zh-Hans`, `zh-Hant`, `ja`, `ko`, `fr`, `de`, `es`. French, German and Spanish appear in only one of the two lists. Sample text narrows the gap again: Quick Sample presets ship dedicated Japanese and Korean strings, and nothing equivalent is mentioned for the three European languages. Continuous integration runs `check-l10n.py` on `macos-15` beside `swift build`, `swift test` and `check-version.py`, so some check does compare translation coverage, yet which set of languages it treats as complete is not stated. A related behavior sits in the preview instead of the settings: when the selected font cannot fully render the current preview text, rootfont shows a fallback warning.

Install writes into ~/Library/Fonts/rootfont, and startup reconcile is undefined

Three font states are offered. Session activate registers the font for the running login session and leaves nothing behind. User-scope install copies the file into `~/Library/Fonts/rootfont/`, a subfolder of the user's own font directory rather than a system location, so no administrator rights are implied. Uninstall and a startup reconcile complete the set. What reconcile actually does is not written down: it runs at launch, it acts on the state of a folder the user can also edit by hand, and no rule is given for the case where files were removed or replaced outside the app. There is also no note about what happens to applications already holding the font open, or whether uninstall removes the directory it created.

The editor config button copies text, while the bundle embeds version, build and SHA

Six editors get a one-click configuration copy: VS Code, Cursor, Alacritty, Kitty, Warp, and Zed. The action is a copy to the clipboard. No file path is written, no settings key is named, and no configuration file is identified, so what actually lands in your terminal setup after a paste is left unspecified. Preview header actions are more concrete: copy PostScript name, open in Font Book, open the managed fonts folder. Packaging is deterministic instead:

bash
bash scripts/build-app.sh

That produces `.build/app/rootfont.app` with the version, build number and git short SHA embedded in `Info.plist`, which is why a bug report asks for the value behind About, Copy Version, plus an About, Copy System Info dump, `swift --version` and `xcode-select -p`.

swift test needs Xcode components, and the repair path asks for sudo

rootfont is a macOS-only SwiftPM project. macOS 14+, Xcode 15+ and Swift 6.0+ are the stated requirements, with 6.2 recommended because newer toolchains apply stricter concurrency checks. Building on Linux, or with Command Line Tools alone, is called out as unsupported. The toolchain has to be the full Xcode install, and the check is explicit about what the wrong answer looks like:

bash
xcode-select -p
# Expected: /Applications/Xcode.app/Contents/Developer

# If you see /Library/Developer/CommandLineTools instead:
sudo xcode-select -s /Applications/Xcode.app/Contents/Developer

`swift test` then needs XCTest from Xcode. A missing component surfaces as `no such module 'XCTest'`, and the stated repair is to switch the toolchain as above and open Xcode once so component installation finishes. The suite is about 80 tests across 16 suites, and CI runs it on `macos-15`. `bash scripts/install-git-hooks.sh` is optional and only runs those localization and version metadata checks on commit when matching files are staged.

Editorial conclusion

rootfont suits a Mac user who already builds from source and wants grading, activation and editor snippets in one window, and it does not suit anyone waiting on a stable release: all three tags are alpha or beta, the newest is v0.3.0-alpha from 2026-06-16, and the last push landed 2026-08-16. Before trusting any grade, confirm which weight preset produced it and whether scores.json was rebuilt after your last font change. Before installing into ~/Library/Fonts/rootfont, decide how you will undo it, since startup reconcile is left undefined and uninstall does not say whether it removes the folder it made.

Frequently asked questions

Can rootfont be built on Linux or with only the Command Line Tools?

No. It is described as a macOS-only SwiftPM project requiring macOS 14+, Xcode 15+ and Swift 6.0+, and building or testing on Linux or with Command Line Tools alone is stated as unsupported. Use the Xcode toolchain so swift test can find XCTest.

How does rootfont decide a font's programming grade?

It scores ten weighted factors, from monospace baseline through glyph disambiguation, ligatures, box drawing, Powerline, Nerd Font, variable font, language coverage and weight variety, then maps the total to S/A/B/C/NR. Weighting ships as Default, Terminal Heavy, IDE Heavy and Minimalist presets plus ten sliders.

Where does rootfont keep its cached scores and its installed fonts?

Scores persist at ~/Library/Application Support/rootfont/scores.json and are described as invalidated on font file changes. User-scope installs go to ~/Library/Fonts/rootfont/, with an uninstall action and a startup reconcile step.

Which languages does the rootfont interface ship in?

Two different lists appear. The Localization section names en, zh-Hans, zh-Hant, ja, ko, fr, de and es, while the Features list names only English, Simplified Chinese, Traditional Chinese, Japanese and Korean. Quick Sample presets carry dedicated Japanese and Korean text only.

Does rootfont write configuration into my editor when I use the one-click export?

The export is a copy action for VS Code, Cursor, Alacritty, Kitty, Warp and Zed. No configuration file path and no settings key are identified, so what ends up applied after you paste is not specified here.

Official sources

  1. License: Apache-2.0
  2. Project website
  3. README
  4. Releases
  5. rootfont/rootfont on GitHub
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/rootfont-rootfont.svg)](https://hysenlabs.com/projects/rootfont-rootfont)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/rootfont-rootfont.svg)](https://hysenlabs.com/projects/rootfont-rootfont)

Was this useful?