fonts

README

go-opentype/fonts

44 legible, permissively-licensed TrueType fonts, one Go subpackage per family, each with its own //go:embed — no downloading, no sourcing a .ttf yourself, and your binary links only the families you import. Coverage spans Latin, Cyrillic and Greek plus seven non-Latin scripts — Arabic and Hebrew (RTL), Devanagari, Thai, Georgian, Armenian and Egyptian Hieroglyphs — for RTL and non-Latin rendering/testing out of the box — plus Noto Sans SC for CJK (Han ideographs, kana and common CJK punctuation). Built for go-opentype/opentype, the pure-Go, stdlib-only TrueType engine, but the raw bytes work with any parser that accepts a .ttf.

Install

go get github.com/go-opentype/fonts

Pure Go, no cgo, no external assets to fetch at build or run time — every family is //go:embedded into its own subpackage.

Quick start

import (
	"github.com/go-opentype/fonts"
	"github.com/go-opentype/fonts/inter"
)

f, err := fonts.Parse(inter.TTF) // *opentype.Font
face := f.NewFace(16)            // 16px face

The lazy-at-compile-time import model

//go:embed is eager per package: any package that embeds a font links that font's bytes into every binary that imports it, whether or not the binary ever uses it. A fonts package that bulk-embedded all 44 families would put all 44 into your binary the moment you imported it for anything at all.

So the root fonts package doesn't do that. Each family lives in its own subpackage — fonts/inter, fonts/roboto, fonts/jetbrainsmono, and so on — with its own //go:embed. Importing fonts/inter links only Inter. Importing ten subpackages links only those ten. This is the same pattern golang.org/x/image/font/gofont uses for Go's own bundled fonts.

The root fonts package holds two things only:

1. Family metadata — name, Kind, license, and import path for every bundled font, returned by All and ByName. No []byte field: enumerating families never links any of them in.

2. MostLegible — the one family embedded directly in the root package, so there's a sensible zero-extra-imports default. Every other family requires importing its own subpackage:

   import (
   	"github.com/go-opentype/fonts"
   	"github.com/go-opentype/fonts/robotomono"
   )
   
   f, err := fonts.Parse(robotomono.TTF)
   

Bundled fonts

Six families are hand-curated (present since v0.1.0); the other thirty-eight were ingested by cmd/genfonts from google/fonts's ofl/ directory. Script is listed for the seven non-Latin families (added in v0.3.0) and for Noto Sans SC, the bundled CJK family (added in v0.4.0); every other family covers Latin, and most also cover Cyrillic and/or Greek.

Name	Kind	License	Script	Import path
Atkinson Hyperlegible	Sans	OFL-1.1	Latin	github.com/go-opentype/fonts/atkinsonhyperlegible
Inter	Sans	OFL-1.1	Latin	github.com/go-opentype/fonts/inter
Go	Sans	BSD-3-Clause	Latin	github.com/go-opentype/fonts/goregular
Lora	Serif	OFL-1.1	Latin	github.com/go-opentype/fonts/lora
Go Mono	Mono	BSD-3-Clause	Latin	github.com/go-opentype/fonts/gomono
JetBrains Mono	Mono	OFL-1.1	Latin	github.com/go-opentype/fonts/jetbrainsmono
Arimo	Sans	OFL-1.1	Latin	github.com/go-opentype/fonts/arimo
Bitter	Serif	OFL-1.1	Latin	github.com/go-opentype/fonts/bitter
Cabin	Sans	OFL-1.1	Latin	github.com/go-opentype/fonts/cabin
Cousine	Mono	OFL-1.1	Latin	github.com/go-opentype/fonts/cousine
DM Sans	Sans	OFL-1.1	Latin	github.com/go-opentype/fonts/dmsans
Fira Code	Mono	OFL-1.1	Latin	github.com/go-opentype/fonts/firacode
Fira Sans	Sans	OFL-1.1	Latin	github.com/go-opentype/fonts/firasans
IBM Plex Mono	Mono	OFL-1.1	Latin	github.com/go-opentype/fonts/ibmplexmono
IBM Plex Sans	Sans	OFL-1.1	Latin	github.com/go-opentype/fonts/ibmplexsans
Inconsolata	Mono	OFL-1.1	Latin	github.com/go-opentype/fonts/inconsolata
Karla	Sans	OFL-1.1	Latin	github.com/go-opentype/fonts/karla
Lato	Sans	OFL-1.1	Latin	github.com/go-opentype/fonts/lato
Manrope	Sans	OFL-1.1	Latin	github.com/go-opentype/fonts/manrope
Montserrat	Sans	OFL-1.1	Latin	github.com/go-opentype/fonts/montserrat
Mulish	Sans	OFL-1.1	Latin	github.com/go-opentype/fonts/mulish
Noto Sans	Sans	OFL-1.1	Latin/Greek/Cyrillic	github.com/go-opentype/fonts/notosans
Noto Sans Arabic	Sans	OFL-1.1	Arabic (RTL)	github.com/go-opentype/fonts/notosansarabic
Noto Sans Armenian	Sans	OFL-1.1	Armenian	github.com/go-opentype/fonts/notosansarmenian
Noto Sans Devanagari	Sans	OFL-1.1	Devanagari	github.com/go-opentype/fonts/notosansdevanagari
Noto Sans Egyptian Hieroglyphs	Sans	OFL-1.1	Egyptian Hieroglyphs	github.com/go-opentype/fonts/notosansegyptianhieroglyphs
Noto Sans Georgian	Sans	OFL-1.1	Georgian	github.com/go-opentype/fonts/notosansgeorgian
Noto Sans Hebrew	Sans	OFL-1.1	Hebrew (RTL)	github.com/go-opentype/fonts/notosanshebrew
Noto Sans SC	Sans	OFL-1.1	CJK (Han, kana)	github.com/go-opentype/fonts/notosanssc
Noto Sans Thai	Sans	OFL-1.1	Thai	github.com/go-opentype/fonts/notosansthai
Nunito	Sans	OFL-1.1	Latin	github.com/go-opentype/fonts/nunito
Nunito Sans	Sans	OFL-1.1	Latin	github.com/go-opentype/fonts/nunitosans
Open Sans	Sans	OFL-1.1	Latin	github.com/go-opentype/fonts/opensans
PT Sans	Sans	OFL-1.1	Latin	github.com/go-opentype/fonts/ptsans
Playfair Display	Serif	OFL-1.1	Latin	github.com/go-opentype/fonts/playfairdisplay
Poppins	Sans	OFL-1.1	Latin	github.com/go-opentype/fonts/poppins
Roboto	Sans	OFL-1.1	Latin	github.com/go-opentype/fonts/roboto
Roboto Mono	Mono	OFL-1.1	Latin	github.com/go-opentype/fonts/robotomono
Rubik	Sans	OFL-1.1	Latin	github.com/go-opentype/fonts/rubik
Source Code Pro	Mono	OFL-1.1	Latin	github.com/go-opentype/fonts/sourcecodepro
Source Sans 3	Sans	OFL-1.1	Latin	github.com/go-opentype/fonts/sourcesans3
Space Mono	Mono	OFL-1.1	Latin	github.com/go-opentype/fonts/spacemono
Titillium Web	Sans	OFL-1.1	Latin	github.com/go-opentype/fonts/titilliumweb
Work Sans	Sans	OFL-1.1	Latin	github.com/go-opentype/fonts/worksans

Full license texts are bundled verbatim under licenses/, one file per family (SIL Open Font License 1.1 for every OFL-1.1 row, plus GoFonts-LICENSE.txt — BSD-3-Clause, Bigelow & Holmes — shared by Go and Go Mono).

Non-Latin scripts, and CJK coverage

The seven notosans* script families above exist so RTL (Arabic, Hebrew), Indic (Devanagari), Southeast Asian (Thai), Caucasian (Georgian, Armenian) and Ancient Egyptian (Hieroglyphs, a Unicode Plane 1 / SMP script) text can be rendered or tested without sourcing a .ttf yourself.

Noto Sans SC (Simplified Chinese) is bundled as the representative CJK family, covering Han ideographs, kana, and common CJK punctuation — github.com/go-opentype/fonts/notosanssc. Its .ttf is ~17 MB, so cmd/genfonts gives it a per-seed size-cap override (seed.MaxTTFBytes) rather than raising the module-wide 2.5 MB cap for every other family; see Generator: cmd/genfonts below.

Noto Sans TC (Traditional Chinese), Noto Sans JP (Japanese) and Noto Sans KR (Korean) are not bundled by default, to keep this module lean: each is another 10-18 MB, and most consumers need at most one CJK script. Adding any of them is a one-line seed plus a regenerate — copy the notosanssc entry in cmd/genfonts/seeds.go, swap in the family's google/fonts slug and TTF filename, set MaxTTFBytes to comfortably clear its shipped size, and run:

GOWORK=off go run ./cmd/genfonts

The google/fonts slugs for the other three CJK scripts are notosanstc, notosansjp and notosanskr (each under ofl/<slug>/, with a NotoSans*[wght].ttf variable-font file analogous to Noto Sans SC's). You can also skip bundling entirely and fetch a .ttf straight from google/fonts into your own package — opentype.Parse accepts it exactly as it accepts every family bundled here.

Atkinson Hyperlegible is the standout pick when legibility itself is the goal: it was designed by the Braille Institute specifically to maximize character distinction for readers with low vision, benefiting every reader in the process. MostLegible() returns it, and it's the only family embedded directly in the root package.

Many families are variable fonts upstream (Inter, Lora, JetBrains Mono, and most of the cmd/genfonts-ingested set); each bundled .ttf is pinned at that family's default master (static instance). go-opentype has no variable-font support, so it always renders that default instance — OpenType Variations axes are not applied. Each affected subpackage's doc comment says so explicitly.

API

type Kind int

const (
	KindSans Kind = iota
	KindSerif
	KindMono
	KindDisplay
)

// Family is metadata only — no font bytes. Fetch bytes via ImportPath.
type Family struct {
	Name       string // e.g. "Inter"
	Kind       Kind
	License    string // SPDX id: "OFL-1.1" or "BSD-3-Clause"
	ImportPath string // e.g. "github.com/go-opentype/fonts/inter"
}

func All() []Family                        // every bundled family's metadata, stable order
func ByName(name string) (Family, bool)     // case-insensitive lookup by Family.Name
func MostLegible() []byte                   // Atkinson Hyperlegible bytes — the one family embedded here
func Parse(ttf []byte) (*opentype.Font, error) // convenience wrapper over opentype.Parse

Every other family's bytes live in its own subpackage as var TTF []byte, e.g. inter.TTF, roboto.TTF, jetbrainsmono.TTF — see the table above for the full list of import paths.

See the full package documentation on pkg.go.dev.

Generator: cmd/genfonts

cmd/genfonts ingests OFL-licensed families from google/fonts and generates a new subpackage for each one that survives validation. It:

1. Reads the curated seed list in cmd/genfonts/seeds.go — family name, google/fonts ofl/<slug> directory, and the chosen .ttf file (a static Regular instance where one exists, otherwise the family's single default-master variable font).
2. Fetches the .ttf and OFL.txt over plain net/http.
3. Validates the .ttf through opentype.Parse and enforces a size cap — 2.5 MB by default (excludes pathological multi-axis variable fonts), overridable per seed via seed.MaxTTFBytes for the rare family that's legitimately larger (Noto Sans SC sets 20 MB to admit its ~17 MB .ttf).
4. Skips and logs (not an error) any family that fails to fetch, fails to parse, has no OFL.txt to bundle, or exceeds the size cap.
5. Writes <slug>/<slug>.ttf, <slug>/<slug>.go (embed + doc comment), <slug>/<slug>_test.go (an opentype.Parse smoke test), a license file under licenses/, and regenerates the top-level generated.go registry from every family that succeeded.

Run it from the module root:

GOWORK=off go run ./cmd/genfonts

The last run ingested 38 of 40 seeded families; Merriweather (its only shipped .ttf is a ~4.6 MB multi-axis variable font, over the default size cap) and Tinos (its google/fonts directory currently ships no OFL.txt) were skipped. Ubuntu is deliberately not seeded at all: it ships under the Ubuntu Font License (UFL), not OFL, outside this generator's scope. Noto Sans TC, JP and KR are also deliberately not seeded — see Non-Latin scripts, and CJK coverage above for how to add one.

See example_test.go for runnable examples of Parse, MostLegible, All and ByName, and go doc github.com/go-opentype/fonts for the full reference.

Part of the go-opentype pure-Go text stack

go-opentype/fonts is the bundled-face layer of a dependency-free text stack:

• opentype — the parsing, GSUB/GPOS shaping and rasterising engine that Parse hands the raw .ttf bytes to.
• bidi — a full Unicode Bidirectional Algorithm (UBA) implementation, for ordering mixed left-to-right/right-to-left text (Arabic, Hebrew) before it is shaped.
• shape — a HarfBuzz-lite complex-script shaper (Arabic, Indic, Hangul, USE, Egyptian hieroglyphs, ...) built on opentype's GSUB/GPOS engine; several of its real-font tests and examples use the non-Latin families bundled here.
• fonts (this repo) — the 44 bundled OFL/BSD font families.

License

The Go source code in this repository (everything outside the bundled .ttf files and licenses/) is BSD-3-Clause — see LICENSE.

The bundled font files keep their own upstream licenses; see the Bundled fonts table above, each subpackage's doc comment, and licenses/ for the full texts, copyright notices, and (for the OFL fonts) their Reserved Font Names.

Documentation

Overview

Package fonts is a registry of legible, permissively-licensed TrueType fonts, laid out one subpackage per family so your binary links only the families you actually import — the same lazy-at-compile-time model as golang.org/x/image/font/gofont.

The root package never bulk-embeds every family: [//go:embed] is eager per package, so a package that embedded all bundled fonts would link every one of them into any binary that imports it, whether or not it uses them. Instead each family lives in its own subpackage with its own //go:embed, and the root package holds only lightweight Family metadata plus a single embedded default.

Call All to enumerate every bundled family's metadata (name, Kind, license, and import path — no bytes), ByName to look one up by name, or MostLegible for the one family embedded directly in this package: the font the Braille Institute designed specifically for maximum legibility, including for low-vision readers. To use any other family, import its subpackage and read its exported TTF variable:

import (
	"github.com/go-opentype/fonts"
	"github.com/go-opentype/fonts/inter"
)

f, err := fonts.Parse(inter.TTF)
face := f.NewFace(16)

Parse is a thin convenience wrapper around opentype.Parse.

Dozens of families are bundled; see the "Bundled fonts" table in README.md for the full list, and cmd/genfonts for the generator that ingests OFL-licensed families from github.com/google/fonts to produce new subpackages.

The Go code in this repository is BSD-3-Clause (see LICENSE). Each bundled font keeps its own upstream license — see the "Bundled fonts" table in README.md, each subpackage's doc comment, and the full texts under licenses/.

Index

• func MostLegible() []byte
• func Parse(ttf []byte) (*opentype.Font, error)
• type Family
  • func All() []Family
  • func ByName(name string) (family Family, ok bool)
• type Kind
  • func (k Kind) String() string

Examples

• All
• ByName
• MostLegible
• Parse

Functions

func MostLegible

func MostLegible() []byte

MostLegible returns Atkinson Hyperlegible, the bundled font with the strongest legibility credentials: it was designed by the Braille Institute specifically to maximize character distinction for readers with low vision, and it benefits every reader in the process. Prefer it whenever legibility, not brand voice, is the deciding factor.

MostLegible is the one family the root fonts package embeds directly — every other family requires importing its own subpackage. This keeps a sensible default usable with zero extra imports, without defeating the per-family lazy-linking model for everyone else.

Example

ExampleMostLegible parses the one family embedded directly in the root package — Atkinson Hyperlegible — with zero extra imports.

package main

import (
	"fmt"

	"github.com/go-opentype/fonts"
)

func main() {
	f, err := fonts.Parse(fonts.MostLegible())
	if err != nil {
		panic(err)
	}
	fmt.Println(f.NumGlyphs())
}

Output:
369

func Parse

func Parse(ttf []byte) (*opentype.Font, error)

Parse decodes ttf (typically a subpackage's TTF variable, or the return value of MostLegible) into a *opentype.Font, ready for NewFace and rendering. It is a thin convenience wrapper around opentype.Parse:

f, err := fonts.Parse(fonts.MostLegible())

Example

ExampleParse shows the per-family lazy-import model: importing a family's own subpackage (here fonts/inter) links only that family's bytes into the binary, and fonts.Parse is a thin wrapper over opentype.Parse for them.

package main

import (
	"fmt"

	"github.com/go-opentype/fonts"
	"github.com/go-opentype/fonts/inter"
)

func main() {
	f, err := fonts.Parse(inter.TTF)
	if err != nil {
		panic(err)
	}

	face := f.NewFace(16)
	fmt.Println("glyphs:", f.NumGlyphs())
	fmt.Println("Measure(Hi):", face.Measure("Hi"))
}

Output:
glyphs: 2933
Measure(Hi): 16

Types

type Family

type Family struct {
	Name       string // display name, e.g. "Atkinson Hyperlegible"
	Kind       Kind
	License    string // SPDX identifier: "OFL-1.1" or "BSD-3-Clause"
	ImportPath string // e.g. "github.com/go-opentype/fonts/inter"
}

Family describes one bundled font by metadata only: its display name, general style, the SPDX identifier of the license it ships under, and the import path of the subpackage that embeds its bytes.

Family deliberately has no []byte field. Enumerating All therefore does not link any font into your binary — only importing a specific subpackage (e.g. "github.com/go-opentype/fonts/inter") does that. This is the "lazy at compile time" model: your binary links exactly the families you import, nothing more.

func All

func All() []Family

All returns every bundled Family, curated families first (in their original order), followed by cmd/genfonts output, in a stable order.

All returns metadata only — no font bytes. To use a family, import its ImportPath and read its exported TTF variable, e.g.:

import "github.com/go-opentype/fonts/inter"
f, err := fonts.Parse(inter.TTF)

Example

ExampleAll enumerates every bundled family's metadata without linking any font bytes: Family has no []byte field, so All is safe to call even if you only ever import one family's subpackage.

package main

import (
	"fmt"

	"github.com/go-opentype/fonts"
)

func main() {
	all := fonts.All()
	fmt.Println("bundled families:", len(all))
	fmt.Println(all[0].Name, all[0].Kind, all[0].License)
}

Output:
bundled families: 44
Atkinson Hyperlegible sans OFL-1.1

func ByName

func ByName(name string) (family Family, ok bool)

ByName looks up a bundled family by its Family.Name, case-insensitively, and returns its metadata. ok is false when no family matches. As with All, this returns metadata only; fetch bytes via the returned Family.ImportPath subpackage.

Example

ExampleByName looks up a bundled family by name, case-insensitively, to discover its ImportPath before importing the subpackage.

package main

import (
	"fmt"

	"github.com/go-opentype/fonts"
)

func main() {
	fam, ok := fonts.ByName("inter")
	fmt.Println(ok, fam.Name, fam.ImportPath)

	_, ok = fonts.ByName("Nonexistent Family")
	fmt.Println(ok)
}

Output:
true Inter github.com/go-opentype/fonts/inter
false

type Kind

type Kind int

Kind classifies a Family by its general letterform style.

const (
	// KindSans is an upright, low-contrast sans-serif.
	KindSans Kind = iota
	// KindSerif is a text serif.
	KindSerif
	// KindMono is a fixed-width (monospace) face.
	KindMono
	// KindDisplay is a face intended for headlines and short text at large
	// sizes, rather than for body copy.
	KindDisplay
)

func (Kind) String

func (k Kind) String() string

String returns the lower-case name of k ("sans", "serif", "mono", "display"), or "unknown" for any other value.