Metadata-Version: 2.5
Name: whateverfont
Version: 0.1.0
Summary: WhateverFont You Want. An AI agent draws a complete typeface from a plain-English brief and builds real font files.
Project-URL: Homepage, https://fonts.brianzhou.org
Project-URL: Repository, https://github.com/brianlzhou/whateverfont
Project-URL: Documentation, https://github.com/brianlzhou/whateverfont/tree/main/docs
Project-URL: Changelog, https://github.com/brianlzhou/whateverfont/blob/main/CHANGELOG.md
Project-URL: Issues, https://github.com/brianlzhou/whateverfont/issues
Author: Brian Zhou
License: MIT
License-File: LICENSE
Keywords: agents,color fonts,fonts,parametric,type design,typography,variable fonts
Classifier: Development Status :: 3 - Alpha
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Programming Language :: Python :: 3.13
Classifier: Topic :: Multimedia :: Graphics
Classifier: Topic :: Text Processing :: Fonts
Requires-Python: >=3.10
Requires-Dist: fonttools[woff]>=4.50
Requires-Dist: pillow>=10
Requires-Dist: skia-pathops>=0.8
Requires-Dist: uharfbuzz>=0.39
Provides-Extra: dev
Requires-Dist: pytest>=7; extra == 'dev'
Provides-Extra: trace
Requires-Dist: numpy>=1.24; extra == 'trace'
Description-Content-Type: text/markdown

# WhateverFont

**WhateverFont You Want.** Describe a typeface in plain words. An AI agent draws it, checks its own proofs,
and gives you real font files.

![Fonts made with WhateverFont](https://raw.githubusercontent.com/brianlzhou/whateverfont/main/docs/images/gallery.png)

Every font in that picture was made by an agent with this engine, and the gray line above each row is the
request that started it. Every row but the last is drawn from nothing. The last row restyles an existing open font.

WhateverFont is a prototype. Read [what it cannot do yet](#what-it-cannot-do-yet) before you rely on it.

## Why

Good typefaces are licensed, and the default free ones are everywhere. When an agent builds a page or a deck
for you, it reaches for the same five fonts. A typeface is a finite thing, though: a few hundred shapes that
follow a small set of repeated decisions. That is a good fit for an agent, as long as it does not have to
guess raw outline coordinates.

So WhateverFont gives the agent a pen, not a canvas. The agent writes a few numbers ("stems 82 units thick,
thin strokes at 60% of thick ones, ends flared by 34%") and, when a letter needs it, a short recipe that
places the skeleton of that letter. The engine does the parts that need precision: it gives the skeleton
thickness, spaces and kerns the letters, and compiles the files.

## What you get

- **An engine.** Skeleton strokes plus a pen model. One set of letter recipes produces a hairline sans, a bold
  flare serif, a rounded display face or a broad-pen book hand, depending on about 25 parameters.
- **Every weight and slant you want.** A family declares axes. Each named style is drawn exactly, and the
  whole design space also ships as one variable font with sliders.
- **Proofs the agent can see.** `whateverfont look` renders the built font file, shaped with HarfBuzz, so the agent
  sees what a reader will see. `whateverfont probe` reports measurements and problems as JSON.
- **A review board.** One HTML page per project. You type your own text, compare directions, drag the axes,
  pick one, and write notes. The agent reads your feedback and revises.
- **Effects.** A stencil, an engraved line, a block shadow, speed stripes or a hand-cut edge, each in one
  call. An effect is a short function, so an agent can write a new one for a brief that needs it.
- **Color fonts.** Neon glow, brush marks that follow the pen, mosaic, dots, bands, and decorated capitals,
  with palettes you can switch (COLR version 0, which every major browser draws).
- **Monospaced fonts.** Set one number and every glyph fits one cell, with the signs of code drawn for code
  and the box-drawing characters included. Slab serifs make a typewriter.
- **European languages, Greek, Cyrillic and Vietnamese, and the signs people type.** The full set has GF Latin
  Core, the whole Vietnamese alphabet with its horn, hook above, dot below and stacked marks, Pinyin, and
  letters for Azerbaijani, Yoruba, Igbo and Hausa. It has modern Greek with the tonos and the dialytika, and
  Cyrillic for Russian, Ukrainian, Belarusian, Bulgarian, Serbian, Macedonian and Kazakh, drawn with the same
  pen as the Latin letters. It also has 34 currency signs, the Mac Roman math signs, arrows, check marks and
  shapes, superscripts, subscripts and 15 fractions: 800 code points.
- **OpenType features.** `frac` (1/2 becomes a fraction), `sups`, `subs`, `numr`, `dnom`, `ordn`, `zero`
  (a slashed zero), `case` (dashes and brackets for capitals) and `pnum` (proportional figures; the default
  figures are tabular, and a family can turn that around).
- **Picture fonts.** A recipe can draw anything: type a letter, get a bird.
- **Remix.** Round the corners of an existing font, or embolden, slant or narrow it, in one command.
- **Fast, repeatable builds.** A family with six styles and three axes builds in about three seconds on a
  laptop. The same design always gives the same bytes, and nothing is built twice.

## Quick start

With an agent (Claude Code, Codex, Cursor or any agent that can run commands):

```sh
uv tool install whateverfont        # or: pipx install whateverfont
whateverfont skill install          # adds the skill to Claude Code
```

With Node and uv, `npx whateverfont skill install` does both. In Claude Code you can also add the skill as a
plugin: `/plugin marketplace add brianlzhou/whateverfont`, then `/plugin install whateverfont@whateverfont`.
The plugin holds the skill, and the skill tells the agent how to install the command.

Then ask, in a new session:

> Use whateverfont. Make me a font that gives me the feeling of winter break and Christmas holidays in middle school.

The agent writes the brief down, draws three directions, looks at its own proofs, and gives you a review
board in the browser. Say what to change ("chunkier", "the tails on g and y hang too low", "now put snow on
it") until it is right. The font files are in `fonts/NAME/fonts/`. For an agent without skills, say "run
`whateverfont skill show` and follow it".

By hand:

```sh
whateverfont new fonts/quill --preset flare --brief "A calm serif for a long essay. No default web serifs."
whateverfont build fonts/quill        # TTF, WOFF2, a variable font, and board.html
whateverfont look fonts/quill         # prints the path of a proof sheet (PNG)
open fonts/quill/board.html       # compare, adjust, pick
```

A project is a folder with two files. `font.py` is the design:

```python
from whateverfont import Axis, Family
from whateverfont.presets import preset

FAMILY = Family(
    name="Quill",
    base=preset("flare", contrast=0.55, xh=500),
    axes=[
        Axis("wght", "Weight", 300, 400, 800, {300: {"weight": 50}, 800: {"weight": 150}}),
        Axis("slnt", "Slant", -11, 0, 0, {-11: {"slant": 11}}),
    ],
    styles={"Regular": {}, "Italic": {"slnt": -11}, "Bold": {"wght": 700}},
)
```

`BRIEF.md` holds the brief in your words, and the agent's design decisions and your feedback over time.

## Use it with an agent

`whateverfont skill install` copies the skill to `~/.claude/skills/whateverfont`. Add `--project` for the project
you are in, or `--dest DIR` for the skills folder of another agent. `whateverfont skill show` prints it, so any
coding agent can read the same instructions. The skill is one page:
[`skills/whateverfont/SKILL.md`](https://github.com/brianlzhou/whateverfont/blob/main/skills/whateverfont/SKILL.md).

The skill tells the agent to write the brief down, propose three directions, build them, look at the proofs
and fix what it sees, and give you the review board. `whateverfont docs` and `whateverfont examples` give the agent
the reference pages and the sources of every example, so it needs no checkout of this repository.

Four of the examples were made this way by agents that had only the skill and one sentence each: "a font like
Klimt's The Kiss", "like Hokusai's Great Wave", "like Matisse's paper cut-outs", and "a monospaced font for my
terminal". Each agent also reported what tripped it up, and those reports became fixes in the engine.

## Share a font

The [library](https://github.com/brianlzhou/whateverfont/blob/main/library) holds fonts that people made with WhateverFont and gave to everyone. Each one is on
the [library page](https://fonts.brianzhou.org/library/) with the GitHub name of the person who added it.

```sh
gh repo fork brianlzhou/whateverfont --clone && cd whateverfont
whateverfont library add PATH/TO/YOUR/FONT --github YOUR_USERNAME
```

The second command copies your design into `library/`, checks that it builds, and prints the commands that
open the pull request. A pull request holds the design, not font files: the repository builds the fonts
from your source after the merge. The rules are in [library/README.md](https://github.com/brianlzhou/whateverfont/blob/main/library/README.md).

## Commands

| Command | What it does |
|---|---|
| `whateverfont new DIR --preset NAME --brief "..."` | Start a project. `whateverfont presets` lists the starting points, from `grotesk` to `typewriter`. |
| `whateverfont build DIR` | Build every style, the variable font, a stylesheet and the review board. |
| `whateverfont look DIR` | Render a proof sheet. `--text`, `--styles`, `--directions`, `--at wght=650` and `--xray "aeg"` change the view. `--palette` and `--bg` show a color font in another palette, on another ground. |
| `whateverfont probe DIR` | Print measurements and a list of problems as JSON. `--full` adds every glyph. |
| `whateverfont board DIR --serve` | Serve the review board. Feedback is saved to `DIR/feedback.json`. |
| `whateverfont remix FONT.ttf --name "New Name" --round 46 --out DIR` | Restyle an open font. |
| `whateverfont retrace FONT.ttf --name "New Name" --pen PROJECT[:FAMILY] --out DIR` | Redraw an open font in another script (Arabic, Devanagari, Japanese, Simplified or Traditional Chinese, Korean) with a family's pen, and `--effect` if you want one. It keeps the shaping. `--only japanese` (or `chinese`, `traditional`, `korean`) keeps the common characters. Needs `pip install 'whateverfont[trace]'`. See [docs/scripts.md](https://github.com/brianlzhou/whateverfont/blob/main/docs/scripts.md). |
| `whateverfont skill install` | Give your agent the instructions. `show` prints them. |
| `whateverfont docs [NAME]` | List or print the reference pages. |
| `whateverfont examples [NAME]` | List the example projects, or print the folder of one. |
| `whateverfont library add DIR --github NAME` | Prepare a font for the public library, with your credit. `check` runs the checks of a pull request. |

## How it works

1. **Skeleton.** A recipe draws a letter as centerline strokes: `g.stem(...)`, `g.ring(...)`, an arch, a bowl.
2. **Pen.** The engine expands each stroke with an elliptical pen. Thickness depends on direction, so one
   number sets the contrast and another the stress angle. Nodes carry width multipliers, which is how stems
   flare. Ends are cut and optionally rounded.
3. **Spacing.** Each side of a letter says what it is (straight, round, diagonal, open) and gets a sidebearing
   to match. Kerning then measures the white between pairs and corrects the ones sidebearings cannot fix.
4. **Compile.** Static styles have their overlaps removed. The variable font is built from point-compatible
   masters at the axis extremes with fontTools.
5. **Look.** Proofs come from the built files. The agent looks, measures, and edits numbers or recipes.

More detail: [parameters](https://github.com/brianlzhou/whateverfont/blob/main/docs/parameters.md), [writing recipes](https://github.com/brianlzhou/whateverfont/blob/main/docs/recipes.md),
[effects, color, picture and monospaced fonts](https://github.com/brianlzhou/whateverfont/blob/main/docs/effects.md), [the design loop](https://github.com/brianlzhou/whateverfont/blob/main/docs/workflow.md).

## Examples

Each folder in [`examples`](https://github.com/brianlzhou/whateverfont/blob/main/examples) is a complete project with its brief, source, built fonts and board.

| Project | Fonts | What it shows |
|---|---|---|
| [`arroyo`](https://github.com/brianlzhou/whateverfont/blob/main/examples/arroyo) | Arroyo, Arroyo Glyphic, Arroyo Text | A flare serif for long reading, with a sans-to-flare axis. Three directions on one board. |
| [`caliper`](https://github.com/brianlzhou/whateverfont/blob/main/examples/caliper) | Caliper, Gantry | A light condensed flare for titles with a width axis, and a technical sans with a roundness axis. |
| [`tally`](https://github.com/brianlzhou/whateverfont/blob/main/examples/tally) | Tally Mono | A monospaced face for code, in four styles and a variable font. |
| [`platen`](https://github.com/brianlzhou/whateverfont/blob/main/examples/platen) | Platen, Platen Ribbon | A typewriter face with slab serifs, round ends and ball terminals, and a companion typed through an inked ribbon. |
| [`pinout`](https://github.com/brianlzhou/whateverfont/blob/main/examples/pinout) | Pinout | A square monospace for datasheets and terminal manuals, with a slashed zero and hooked `g` and `y`. |
| [`greenbar`](https://github.com/brianlzhou/whateverfont/blob/main/examples/greenbar) | Greenbar, Halation | Dot-matrix print on a strict 9-pin grid, and the same characters glowing on a phosphor screen. |
| [`lastbell`](https://github.com/brianlzhou/whateverfont/blob/main/examples/lastbell) | Last Bell, Last Bell Snow | Chunky marker letters made in four rounds of feedback, and a color font with snow on them. The snow is an effect the project wrote for itself. |
| [`wassail`](https://github.com/brianlzhou/whateverfont/blob/main/examples/wassail) | Wassail, Wassail Initials | A broad-pen book hand, and a color font of illuminated Christmas capitals with three palettes. |
| [`aviary`](https://github.com/brianlzhou/whateverfont/blob/main/examples/aviary) | Aviary Color, Aviary, Aviary Line | A picture font: 26 birds cut from colored paper, built from circles and straight lines. Four palettes, a one-color cut and a coloring book. |
| [`hopstep`](https://github.com/brianlzhou/whateverfont/blob/main/examples/hopstep) | Hopstep, Hopstep Solid, Hopstep Line | A human alphabet: every letter is a person who dances, in a thick line and flat color. One body kit draws all 26 poses. |
| [`neon`](https://github.com/brianlzhou/whateverfont/blob/main/examples/neon) | Neon, Neon Diner, Neon Rod, Neon Glow | One bent glass tube, three ways, and a color font that glows. |
| [`crate`](https://github.com/brianlzhou/whateverfont/blob/main/examples/crate) | Crate Stencil and two more | A stencil for shipping crates, with a bridge through every counter. |
| [`effects`](https://github.com/brianlzhou/whateverfont/blob/main/examples/effects) | Marquee, Turbo, Billboard, Pointille, Meridian | Five display faces, one effect each: inline, stripes, shadow, dots, bands. |
| [`starry`](https://github.com/brianlzhou/whateverfont/blob/main/examples/starry) | Starry, Starry Initials | Brush marks that follow the pen, and capitals set in a turning night sky. |
| [`haystack`](https://github.com/brianlzhou/whateverfont/blob/main/examples/haystack) | Haystack, Haystack Initials | One drawing in four palettes: noon, sunset, snow and dusk. |
| [`gilt`](https://github.com/brianlzhou/whateverfont/blob/main/examples/gilt) | Gilt, Gilt Robe, Gilt Bloom | Gold tiles, spirals and ringed circles. Made by an agent from the skill alone. |
| [`kanagawa`](https://github.com/brianlzhou/whateverfont/blob/main/examples/kanagawa) | Kanagawa and two more | Prussian blue letters with foam on their crests. Made by an agent from the skill alone. |
| [`cutout`](https://github.com/brianlzhou/whateverfont/blob/main/examples/cutout) | Cutout, Cutout Color | Letters cut with scissors from painted paper. Made by an agent from the skill alone. |
| [`cabochon`](https://github.com/brianlzhou/whateverfont/blob/main/examples/cabochon) | Cabochon, Cabochon Rose | Letters cut from polished stone, with a bevel, a highlight and cloudy patches, in six stones. Made by an agent from one picture described in words. |
| [`ombrelle`](https://github.com/brianlzhou/whateverfont/blob/main/examples/ombrelle) | Ombrelle, Ombrelle Initials | Whole dots of pure color with a sunlit side and a violet shadow side, and capitals on a dotted lawn. Made by an agent from the skill alone. |
| [`panework`](https://github.com/brianlzhou/whateverfont/blob/main/examples/panework) | Panework, Panework Boogie | Letters divided by black lines into white, red, yellow and blue rectangles, after the grid paintings of De Stijl. Made by an agent from the skill alone. |
| [`lacentine`](https://github.com/brianlzhou/whateverfont/blob/main/examples/lacentine) | Lacentine, Lacentine Card | A valentine: each letter is cut from card and glued on a paper doily with a scalloped edge and punched hearts. Made by an agent from the skill alone. |
| [`drippelgang`](https://github.com/brianlzhou/whateverfont/blob/main/examples/drippelgang) | Drippelgang, Drippelgang Ink | Halloween letters dipped head first in goo, with drips down the strokes and drops that hang off. Made by an agent from the skill alone. |
| [`leafpile`](https://github.com/brianlzhou/whateverfont/blob/main/examples/leafpile) | Leafpile, Leafpile Plain | Each letter is a heap of fallen maple, oak, birch and ginkgo leaves, cut to a clean outline. Made by an agent from the skill alone. |
| [`pebble`](https://github.com/brianlzhou/whateverfont/blob/main/examples/pebble) | Pebble Sans | A remix: Inter with rounded corners. |
| [`retrace`](https://github.com/brianlzhou/whateverfont/blob/main/examples/retrace) | Last Bell, Last Bell Snow, Neon Glow and Gantry, each in Arabic, Devanagari, Japanese, Simplified Chinese, Traditional Chinese and Korean | Four families redrawn over the centerlines of open fonts, with their pens and effects. The letter shapes come from Kalam, Playpen Sans Arabic, Klee One, LXGW WenKai GB and TC, Gaegu, Noto Sans and Noto Sans CJK. |

The color fonts after paintings take a palette and a kind of mark from the description of the painting.
No image was traced or sampled.

Rebuild them all with `python scripts/build_examples.py`.

The site at [fonts.brianzhou.org](https://fonts.brianzhou.org) sets these fonts live. `python3 scripts/build_site.py` builds it
from `examples/` into `out/site`, and Vercel rebuilds it on every push to `main`.
`python3 scripts/build_site.py --serve 8787` builds it and serves it on your computer.

The library page finds fonts by mood: the search is `site/search.js` on the word vectors in `site/search`, and
it runs in the reader's browser. Votes and views are counted by a small Cloudflare Worker in [`worker/`](https://github.com/brianlzhou/whateverfont/blob/main/worker/README.md).
It keeps the counts in the SQLite storage of one Durable Object, so there is no outside database, and it stores
a salted hash of a visitor's address, never the address. Until the Worker is deployed and `COUNTS` is set in
`scripts/build_site.py`, the site shows no vote buttons and no numbers. `node scripts/try_site.js --seed` serves
the built site with the same code and SQLite in memory, so you can try votes and views on your computer.

The site has a language menu with twelve languages: English, Spanish, French, German, Galician, Breton,
Vietnamese, Simplified Chinese (`zh`), Traditional Chinese as Taiwan writes it (`zh-Hant`), Japanese, Korean,
Arabic and Hindi. English is in the pages, and every other language is one file, `site/i18n/CODE.json`. To add
or correct a translation, copy the keys of [`site/i18n/en.json`](https://github.com/brianlzhou/whateverfont/blob/main/site/i18n/en.json), keep the tags and `{n}` of
each text, and add the language to `LANGS` in `scripts/build_site.py`. The build checks every file. A text with
no translation stays in English. Some keys are words that the page sets in a font: `sample.` (the sample of
each font), `word.` (the wall), `block.` (the footer), `demo.` and `poster.text`. A font shows such a text only
if it has every letter of the translation, so write it with the letters that the font has. It never falls back
to another font. In Japanese, Chinese and Korean, those words keep to the character set of the whole fonts
(kana and JIS level 1, GB 2312 level 1, Big5 level 1, KS X 1001 Hangul), and `tests/test_site.py` checks them.
A code can have a subtag, such as `zh-Hant`. CSS's `:lang(zh)` matches `zh-Hant` too, so the build writes the
rules of `zh` to leave it out: a Traditional page never names or loads a Simplified font, and the reverse.

The large fonts of other scripts (`examples/retrace`) load in two files: a slice with the letters of the page's
own words, and the whole font for a reader who types other words. `python scripts/build_page_slices.py` cuts
the slices again after a translation changes or a font is rebuilt.

## What it cannot do yet

- **It is not a type designer.** The letters are consistent and readable, and the best ones are pleasant.
  A trained eye will find weak shapes, most often in bold weights, in `S`, `a`, `g`, `&` and `@`. Stems
  heavier than about 165 units start to close the counters of `a`, `e`, `6` and `9`.
- **Latin, Greek and Cyrillic, with a kana experiment.** The basic set is GF Latin Core and Vietnamese, plus
  Pinyin and some African letters: Western, Central and Eastern European, Turkish, Baltic, Welsh, Vietnamese,
  Azerbaijani, Yoruba, Igbo and Hausa letters, combining marks that attach to any letter, and the signs
  people type (`€ £ ¥ ₹ ₽ ₺ ₿ © ® ™ § ¶ † ‡ ± ÷ ≈ ≠ ≤ ≥ √ ∞ ∑ ← → ✓ ★ ●`, superscripts, subscripts,
  fractions). It also has modern Greek and the Cyrillic of Russian, Ukrainian, Belarusian, Bulgarian,
  Serbian, Macedonian and Kazakh. Nobody who reads Vietnamese, Chinese, Hausa, Greek or a Cyrillic language
  has reviewed these letters yet. Not yet: the other pan-African letters such as `ɛ ɔ`, old-style figures,
  polytonic Greek, the Bulgarian and Serbian forms of Cyrillic letters, and Cyrillic beyond the large
  languages. `whateverfont.kana` can expand KanjiVG's kana strokes with a family's pen, but nobody
  who reads Japanese has reviewed the result. For Arabic, Devanagari, Japanese, Chinese, Korean and other
  scripts, `whateverfont retrace` redraws an open font with a family's pen: the letter shapes are that
  font's, not new drawings, and nobody who reads those scripts has reviewed the results yet. [The roadmap](https://github.com/brianlzhou/whateverfont/blob/main/docs/roadmap.md) has a plan for each script.
- **Italics are slanted romans.** There are no cursive forms.
- **No bracketed serifs.** Terminals can be plain, flared, round or slab serifs.
- **No hinting.** Text is fine on high-density screens and in print. Small sizes on old Windows displays will
  look soft.
- **Kerning is automatic and plain.** It fixes open pairs such as `AV` and `To`. Nobody tuned it by eye.
- **Color fonts are static and flat.** A color family cannot have axes, and there are no gradients. A
  painted font is large: 500 to 800 KB as WOFF2 for about 95 characters.
- **Effects that cut the outline give static fonts only.** A stencil or an inline family has no variable font.
- **Parallel builds need macOS or Linux.** On Windows a family builds in one process, which is slower.

## Prior art and credits

WhateverFont stands on [fontTools](https://github.com/fonttools/fonttools),
[skia-pathops](https://github.com/fonttools/skia-pathops), [HarfBuzz](https://github.com/harfbuzz/harfbuzz)
and [Pillow](https://github.com/python-pillow/Pillow). The skeleton-and-pen idea is Donald Knuth's Metafont.
[Metapolator](https://github.com/metapolator/metapolator) explored skeleton parameters for interpolation.
[NetsuFont](https://github.com/NetsumaInfo/NetsuFont) is the closest project we found in which an agent draws
glyphs. The agent-facing loop (constrained tools, look, probe, journal) follows
[claude-paint](https://github.com/aliceisjustplaying/claude-paint).

The flare examples are original drawings in a genre that includes Optima, Albertus and ABC Arizona Flare.
They copy no outlines from any font. The coding signs in the monospaced set were first drawn by an agent
that used WhateverFont to make a terminal font. More in [docs/research.md](https://github.com/brianlzhou/whateverfont/blob/main/docs/research.md).

## License

The code is under the [MIT License](https://github.com/brianlzhou/whateverfont/blob/main/LICENSE). The example fonts that WhateverFont drew are under the
[SIL Open Font License 1.1](https://github.com/brianlzhou/whateverfont/blob/main/examples/OFL.txt). Pebble Sans is a modified version of Inter and stays under
Inter's Open Font License, with its copyright notice ([examples/pebble/OFL.txt](https://github.com/brianlzhou/whateverfont/blob/main/examples/pebble/OFL.txt)).
The fonts in `examples/retrace` are modified versions of Kalam, Playpen Sans Arabic, Noto Sans Arabic, Noto
Sans Devanagari, Klee One, LXGW WenKai GB, LXGW WenKai TC, Gaegu and Noto Sans CJK, and stay under their
Open Font License, with their copyright notices ([examples/retrace/OFL.txt](https://github.com/brianlzhou/whateverfont/blob/main/examples/retrace/OFL.txt), and an `OFL.txt` in the
folder of each Japanese, Chinese and Korean font).

Fonts you draw with WhateverFont are yours. Fonts you remix or retrace keep the license of the font you started
from.
