Patens

ES

Back to the foundry

The differentiator

An audit module that teaches as you draw.

Every other browser-based type editor checks a font for errors. Patens checks it against 94 type-design rules — every contour, metric, kern pair, anchor, master, palette, and brief field — and for each finding, hands you plain-English prose that names the rule, explains why it matters, and (for around 30 codes) offers a one-click fix. The audit module is the spine of the editor, not a lint step bolted on at the end.

The teaching prose comes from the type-design tradition — the rules that get internalized through years of mentorship, or from a copy of Detail in Typography, or by watching a master rep a kerning class until everything snaps into place. Patens encodes those rules into a Web Worker that runs continuously alongside the editor, with a single describeAuditCode(code) dictionary feeding five teaching surfaces (edit panel, audit page, release pre-flight, family hub, home page) so the same prose appears wherever an audit finding is shown.

The 94 codes are stable forever — once shipped, a code's ID never gets reused. If a rule turns out to be wrong, it's deprecated (marked severity: 'info' + deprecated: true) rather than recycled. That's the same contract OpenSSF Scorecard, CodeQL, and ESLint use for their check IDs — it makes the codes referenceable from commits, bug reports, tutorials, and downstream tooling without ambiguity.

94 codes across 9 families.

Grouped by what the rule checks. The breakdown:

Full reference with every code's prose: /learn/audit-codes.

Six examples, verbatim.

The teaching prose on this page is the exact text users see when they hover or click into a finding in the editor. No marketing rewrite — the audit-as-teaching promise is that the in-app copy reads like prose, not like a linter dump.

Run it from your terminal.

The same 94-code engine ships as a CLI. Drop it into your CI as a font-design lint step, or batch-audit a directory of project files before a foundry release.

# Audit a single project
npx patens audit my.font.json

# Error-severity only, for CI gates
npx patens audit my.font.json --severity=error

# JSON output for downstream tooling
npx patens audit my.font.json --json | jq '.'

# PR annotations in GitHub Actions
npx patens audit fonts/*.font.json --github

Exit code is 0 when no error-severity issues, 1 when there are, 2 on usage / parse failure. describe any code by name to get the same prose the editor shows: npx patens describe self-intersecting.

The Patens Method.

The audit module isn't a lint step. It's a mentor that catches the things every type designer learns by drawing badly, then better, then well. The teaching prose is the difference between "warning: cap-height exceeds ascender" and "Capital letters will clip when rendered — ascender is the platform-recognised top of the glyph bounding box, caps must fit inside it."

The first sentence is true. The second sentence teaches. Patens optimizes for the second.

This is the difference that justifies opening Patens instead of one of the four other browser-based type editors. Glyphr Studio, Fontra, typlr.app, and FontStruct all check fonts for errors. Patens is the only one designed to teach you why each error matters.

Common questions.

Answers double as FAQPage structured data so AI engines (ChatGPT, Claude, Perplexity, Gemini) can cite individual answers when asked about the audit module.

How many audit codes are there?

Ninety-four, all live and shipping in production today. The full reference is at /learn/audit-codes. The count grows over time but every code already shipped has a stable ID that is never reused; deprecated codes get marked deprecated rather than recycled, on the same convention OpenSSF Scorecard, CodeQL, and ESLint use.

How many codes have a one-click fix?

Around 30 of the 94 (roughly a third). The rest are "designer judgment" findings — they explain the rule and surface the problem, but the right resolution depends on the designer's intent (e.g. an x-height misalignment might be deliberate optical correction or might be a bug). The audit teaches you what to look at; the human decides what to do about it.

Can I add my own audit codes?

Yes. The audit module is in src/lib/font/audit.ts in the open-source repo. Adding a code is a single function that returns AuditIssue[] keyed by glyph/codepoint, plus an entry in describeAuditCode() for the teaching prose. The CONTRIBUTING.md "areas where help is wanted" section lists this as one of the highest-leverage contribution paths.

Is the audit module free? Will it ever be paywalled?

Free, MIT-licensed, and the editor is committed to never being paywalled — see DESIGN_PHILOSOPHY.md in the repo. The optional integrations (cloud share, GitHub OAuth, AI presets) gracefully degrade when unconfigured; the audit module is core, in-browser, and always works.

Does the audit run on every keystroke?

No — it runs in a Web Worker with a debounced trigger after edits stop, so the typing path stays responsive. The worker maintains a monotonic seq guard that ignores stale responses if a newer edit lands while the previous audit pass was still running. The full 94-code pass over a 162-glyph project takes well under 100ms on modern hardware.

How does Patens's audit differ from FontBakery or fontTools's checks?

FontBakery and fontTools (subset, checker, etc.) are great release-time linters — you run them once on the final binary and get a pass/fail report. Patens's audit is integrated continuously into the editor surface itself: every change re-checks, the findings appear in the panel next to the glyph you're working on, and the teaching prose explains the rule in real time. Different tier of the same tradition — Patens is upstream of FontBakery, not a replacement for it.

Can I run the audit on a font file I didn't make in Patens?

Yes via the CLI: `npx patens audit my.font.json`. Patens's portable .font.json format is its native interchange — if you have a font in .otf or .ufo or a Glyphs file, you'd need to convert first (UFO import is supported in the editor; OTF + UFO export is supported). The audit runs against the Project type regardless of how it was created.

See it in action.

The demo project ships with several audit findings already triggered so you can see the panel live without drawing anything.