draw-your-font ships 0.1.0 and plans its kerning pipeline for v2

The manifest reads 0.1.0 and the FAQ plans the next version as v2

The package manifest names version 0.1.0, and the repository publishes no GitHub releases, so 0.1.0 is what an install from npm actually resolves to. The FAQ entry on kerning, ligatures, and letter randomization answers with a single word: v2. It goes on to say the pipeline, which uses fonttools `calt`, is planned, and that the current output is a clean single-variant font. So the missing features are labelled with a version two major steps past the only version that exists, and the list of what you get today is one variant per character with no kerning pairs and no alternates. That matters more than the usual early-stage caveat, because a handwriting font is exactly the kind of asset where pair spacing is the first thing a reader notices. Nothing in the manifest contradicts the claim, and nothing in the manifest delivers it either.

The template charset flag takes two values and the examples use both

The printable template is described as the best quality path, and it is gated behind a flag with two accepted values. The CLI reference describes the `template` command as producing a printable A4 PDF grid with `--charset minimal|spanish`. Both worked examples pass `minimal`, and one of them carries an inline comment offering `spanish` as the alternative:

npx draw-your-font template -o template.pdf --charset minimal   # or: spanish

Nothing else is named anywhere. So for a project whose premise is your own handwriting, the guided path covers two character sets, and everything else goes down the freeform route where you assert the order yourself with `--chars`. The design is coherent, since a grid only works if the layout and the character set agree, but it is a real limit. Photographing five pages of an alphabet the flag will not accept does not produce an error you can read from here; it produces a template you cannot fill in the way the pipeline expects.

Freeform and template are different commands rather than one mode

The two routes into the same font are separate subcommands, not a single command with a switch. The freeform route is `make` with one photo and an explicit `--chars` string, on the understanding that you know the order you wrote in:

npx draw-your-font make photo.jpg --chars "ABCabc" --name "My Hand"

The template route prints the PDF, fills it in, photographs the pages, and calls `make` over several images with `--charset minimal` so the order comes off the grid rather than from you. Between those two sit the commands the examples never use. `segment` finds the letters and produces crops, a numbered contact sheet, and a `blobs.json`. `build` turns labeled crops into a font, taking `--labels`, `--chars`, or `--charset`. So `make` is `segment` and `build` composed in one shot, and `preview` is a separate fifth command that renders any text in the built font. The refinement flags attach to the build step: `--smooth 0..2` for rounder curves, `--weight=-2..2` for thinner or bolder, and `--formats ttf,woff,woff2,css` for the web formats plus a `@font-face` snippet.

Seven runtime dependencies cover the PDF in and the three web formats out

The dependency list maps one to one onto the pipeline stages. `pdfkit` writes the printable A4 grid. `sharp` does the image work on the photograph. `potrace` is the vectorizer, and it is a JavaScript package rather than a system binary, which is what makes the page's claim of zero system dependencies hold: no FontForge, no ImageMagick, and no potrace binary, since the engine is reached through npm. `svgpath` handles path geometry, `svg2ttf` turns vectors into a TrueType file, and `ttf2woff` with `wawoff2` covers the two web formats. That is a complete chain from a JPEG to a WOFF2 with nothing outside the package manager, and the same potrace engine is named as the one inside FontForge and Inkscape, so the drawing output is comparable to what those tools produce. The four development dependencies serve the rest of the repository rather than the library: `esbuild` bundles the demo, `esm-potrace-wasm` and `opentype.js` sit behind the tests, and `wrangler` pairs with `wrangler.jsonc` at the root.

The published tarball ships four paths out of the whole repository

The manifest's files array names four things: `src`, `skills`, `README.md`, and `LICENSE`. Nothing else is published, so an install from npm receives the library, the skill definition, and the two documents, and does not receive `site` with its demo page, `assets`, the `test` directory that the test script runs, or `.claude`. The root tree also holds `site-redirect/` next to `site/` and the `wrangler.jsonc` that configures the worker, so the repository carries three deliverables rather than one: an npm command, a Claude Code skill, and a hosted site with a redirect alongside it. The one script that touches the site is `build:demo`, which bundles `site/demo.src.js` into `site/demo.js` as a minified iife with `node:fs` and `wawoff2` marked external. The entry point declared for the command is `src/cli.js` and the library entry is `src/index.js`, with the engine floor set to Node 18 or newer, which matches the page's claim that it runs wherever that Node runs on macOS, Linux, or Windows.

Shared em-square metrics are the step that decides whether it reads as a font

The pipeline is printed as one line of stages:

photo ──► adaptive threshold ──► blob detection ──► label (Claude / you / template order)
      ──► potrace vectorize ──► shared em-square metrics ──► TTF/WOFF/WOFF2 + preview

The page says the craft is in the metrics step. Every character is assigned a vertical band inside a shared 1000-unit em square covering cap height, x-height, and descender depth, so a lowercase g hangs below the line and a lowercase o stays small. That band assignment is what stops each glyph from sitting wherever its own crop happened to land, and it is the difference the page draws between a font and a ransom note. The same paragraph draws a line around the AI as well: it never draws the letters, it only finds, labels, and judges them. On the skill side, judging means a legibility score plus the two worst letter pairs, and a request like the g looks bad gets back the crop of that letter and either a fix or a request to photograph again.

The no-upload claim sits beside the path that needs a hosted model

The project summary says no uploads, and the skill section says everything runs locally on your machine and your handwriting never leaves it. The CLI section then opens with the phrase no AI at all, which is the part where that sentence is straightforward: seven npm packages, no service, no browser editor, and the whole chain reachable with npx. The skill path is the one that needs Claude Code, where the photo is handed to a model in a terminal by design, and every command in that section is written as something you say to it, starting from handing over the photograph by dragging it into the terminal. The page squares the cost difference with Calligraphr in terms of who runs the compute: their cost is servers and a browser editor, and here your machine does the work while the agent is the editor. On ownership the answer is short and unambiguous, since the font is yours with commercial use included, because it is your handwriting.

Editorial conclusion

Use draw-your-font if you already have a way to photograph a full alphabet cleanly, and if you want a font that only needs to exist rather than one that needs to be designed. The metric pass is the part that makes the result usable, putting every glyph in a band inside a shared 1000-unit em square so descenders descend and lowercase stays small. Verify three things first. The manifest reads 0.1.0 and there are no published releases, so kerning, ligatures, and letter randomization are the v2 pipeline and not what you get today; what you get is a clean single-variant font. The printable template path accepts two charsets, minimal and spanish, so anything else has to go through the freeform route where you supply the order yourself. And the promise that the handwriting never leaves your machine describes the CLI path cleanly, while the skill path by design hands the photo to Claude Code, so decide which route you are on before you assume the privacy sentence covers it.

Frequently asked questions

Official sources

1. danilo-znamerovszkij/draw-your-font on GitHub
2. Issues
3. License: MIT
4. Project website
5. README