Open Sauce Fonts and the awkward question of what a super family is for

Three cuts of the same skeleton, not three unrelated fonts

Open Sauce Fonts is described in the README as a contemporary grotesque superfamily designed by Alfredo Marco Pradil, and the overview calls it a versatile type family optimized for digital interfaces, branding and editorial design.

The superfamily idea is that the family comprises three distinct variants, each with unique optical characteristics while maintaining visual consistency across weights and styles. The table in the README spells out what distinguishes them. Open Sauce Sans is a standard grotesque with ink traps, optimised for UI and display text. Open Sauce One is a clean grotesque without ink traps, neutral and editorial-appropriate. Open Sauce Two is a rounded variant with a soft, approachable aesthetic.

So Sans is the workhorse with ink traps, which is the term for the small tapered cuts in strokes that give a grotesque a technical, machined character, and the README positions it for UI and display. One is the same design with those traps removed, which makes it quieter and easier to read at length, hence editorial-appropriate. Two is the rounded cut, aimed at a soft and approachable feel.

This is the part of the project that matters most in practice, and it is a question the type itself answers better than the naming does. If you are building a product, the same brand across a marketing page and a settings screen wants one family with two cuts, not three font families that have to be coordinated.

Seven weights, two styles, and 42 files

The technical specifications are precise, and one of them is a trap for anyone writing CSS by hand.

There are 7 weights: Light at 300, Regular at 400, Medium at 500, SemiBold at 600, Bold at 700, ExtraBold at 800 and Black at 900. There are 2 styles per weight, upright and italic. The total is stated as 42 font files per format, which works out as 36 unique styles times 2 formats, since the three families share the same weight and style matrix.

The trap is the naming. The weight numbers run from 300 to 900 in the usual order, but the names are unusual: SemiBold is 600, which is the normal convention, but ExtraBold is 800 and Black is 900, which is not, since most systems put Bold at 700 and call 800 ExtraBold and 900 Black, or Black at 900 with nothing at 800. Here there is a separate Bold at 700 and an ExtraBold at 800, and the word Black is taken by 900. The name that a designer expects to be a font weight in a variable font is a family name here.

Coverage is 358 glyphs per font with an extended Latin character set and full punctuation and symbol support, and the OpenType features included are the standard liga for ligatures, kern, smcp for small capitals, onum for oldstyle figures and lnum for lining figures.

Two formats are shipped: OTF as OpenType CFF for desktop publishing and print, and TTF as TrueType for web and digital distribution. That split is a sensible default rather than a curious one, since it is the same reasoning the Nimbus and Liberation families use.

Installing the fonts on each platform

The installation instructions are per platform, and the paths tell you which format the project expects you to use.

On macOS, the options are to double-click the font file and install it, or to copy the OTF files into the user font directory:

# Option 1: Double-click font file → Install Font
# Option 2: Copy to ~/Library/Fonts/
cp fonts/otf/*.otf ~/Library/Fonts/

On Linux, a user installation copies to the local font directory and refreshes the cache:

# User installation
cp fonts/otf/*.otf ~/.local/share/fonts/
fc-cache -f -v

The system-wide version needs sudo and writes into the system font directory:

# System-wide installation (requires sudo)
sudo cp fonts/otf/*.otf /usr/share/fonts/
sudo fc-cache -f -v

On Windows the README gives you the file manager route, right-click and install, or copying to the Windows fonts directory.

One thing to notice: every platform example uses the OTF files. For web use you want the TTF, which is what the CSS example points at, and the README does not give a separate install recipe for those. That is a small gap, and it is the kind of detail that sends people to a separate web font hosting step.

Web usage means writing one @font-face per style

The web usage section shows what using the family on the web actually requires, and it is a direct consequence of the static-file decision.

Each style gets its own @font-face rule, with the family name, the file URL, the format, the weight and the style:

@font-face {
  font-family: 'Open Sauce Sans';
  src: url('fonts/ttf/OpenSauceSans-Regular.ttf') format('truetype');
  font-weight: 400;
  font-style: normal;
}

And the italic counterpart is declared separately, with the same weight and font-style: italic, pointing at OpenSauceSans-Italic.ttf.

With seven weights and two styles across three families, that is 42 declarations if you want the whole range available in the browser. There is no variable font and no unicode-range subsetting shown, so a real deployment ends up serving a curated subset of weights per family and family, and the designer has to decide which.

The naming in the file path is worth noting too, because it encodes the two-axis scheme: OpenSauceSans is the variant, Regular is the weight, and Italic is the style, all concatenated without separators. The font-family property in CSS is the variant name alone, so the weight and style in the declaration select the file.

Rebuilding from Glyphs sources with fontmake

The build from source is short, and it depends on the Glyphs application format.

The font sources are stored in Glyphs format in the Source directory, one .glyphs file per family, and the rebuild is driven by fontmake with glyphsLib:

# Install dependencies
pip install fontmake glyphsLib

# Build static TTF fonts
fontmake -o ttf -i "Source/Open Sauce One.glyphs"

# Build static OTF fonts
fontmake -o otf -i "Source/Open Sauce One.glyphs"

The two build commands differ only in the output format flag, and the example shows one family, with the other two following the same pattern. The -i flag points at the input source file rather than a directory, which is worth noting because the Source directory contains all three families and you want one at a time.

Quality assurance is automated, and this is the part that makes the project credible as something to depend on. The project uses FontBakery for automated quality checks, and the GitHub Actions workflow runs on every push and pull request. Locally the same checks run with:

# Run FontBakery locally
pip install fontbakery
fontbakery check-universal fonts/ttf/*.ttf

The check-universal profile is the broad one, and contributors are asked to ensure any contributions pass FontBakery checks before submitting. For a font family, that is the equivalent of a test suite, and it is rare to see it wired into CI at the repository level.

One caveat on the tooling: fontmake with glyphsLib handles the compilation, but the README does not describe any additional interpolation, subsetting or web font optimisation step, so the artifacts in fonts/ are what the two commands above produce.

Licensing, version history and what the repository does not say

Open Sauce Fonts are released under the SIL Open Font License version 1.1, and the README summarises the terms: free for personal and commercial use, no attribution required though appreciated, and modifications permitted with restrictions. Individual OFL.txt files in the repository root carry the complete terms for each family.

The repository listing shows the tree the README describes, with Source holding the three .glyphs files, fonts split into otf and ttf subdirectories, an Images directory for specimen images, and a generate_specimen.py script plus a specimen.html at the root, which is how the specimen images in the README are produced.

The version history is thin. The current version is listed as v1.478, marked as the initial release, with 3 families times 7 weights times 2 styles in OTF and TTF formats. There are no GitHub releases, so v1.478 is a number in the README rather than a tag you can pin.

The repository is not archived, and the last push was on 2026-05-11. The project description says the fonts are going to be actively developed, improved and tested, and the repository's own description also says it is optimised for better viewing of small text on screen and print, having been developed for Creative Sauce's internal type system. That last point explains the design brief: Open Sauce is a working typeface that was made public, not a specimen project.

What the README does not cover is the gap between a family being a superfamily and being usable as one. There is no documentation of the x-height, the vertical metrics, or how the three variants align on a shared baseline, which are the details that determine whether a three-variant family can be mixed in one layout. For a type family, that omission matters more than it would for a component library.

Editorial conclusion

Open Sauce Fonts is a good fit for a designer who wants a coherent grotesque across a UI product, a brand and a long-form editorial piece, because the three variants share a skeleton and the ink-trap version gives you a display cut without changing the text cut. It is a poor fit if your workflow needs glyphs outside the extended Latin set, since coverage stops at 358 glyphs per font, and a poor fit if you expect a variable font, because the family ships as 42 static files. Before adopting, check the weight naming in the CSS you write, because the family name carries the variant and the weight carries the style, and confirm that the 358-glyph set covers the languages your product serves, since the README documents no fallback strategy beyond that count.

Frequently asked questions

Official sources

1. Issues
2. marcologous/Open-Sauce-Fonts on GitHub
3. README