GlyphSprout: A Handwriting Font Workshop with Per-Glyph Editing

Handwriting font tools usually give you two choices: pay for software to build a full typeface, or give up entirely. GlyphSprout takes a narrow path—it serves projects that only need a small set of personal characters, turning scanned handwriting pages into font subsets that can be inspected and adjusted glyph by glyph.

Starting from a single A4 handwritten page

The workflow begins with an A4 template. Each page holds 35 cells, and a project can cover up to 512 supported BMP characters across 15 pages. The input is a flat, evenly lit PNG or JPEG scan.

The steps aren't complicated, but each one leaves room for human confirmation: specify the page number, verify the visible ID, manually place four registration corner points. GlyphSprout then produces a corrected preview, and only after you confirm the page is correct does it hand off to a background worker.

The benefit of this design is that poor scan quality gets caught before tracing begins—you don't have to wait until the font is generated to discover the whole page was skewed.

BMP character set: BMP (Basic Multilingual Plane) is the first plane of Unicode, covering code points U+0000–U+FFFF, a total of 65,536 character positions. It encompasses the vast majority of modern writing systems, including Latin, Greek, Cyrillic, most CJK unified ideographs, and common symbols and punctuation. Characters outside the BMP (such as some emoji, rare Han characters, and historical scripts) live in supplementary planes and must be represented using surrogate pairs, which are poorly supported in some font-processing tools. GlyphSprout being limited to the BMP means it cannot handle characters beyond that plane, but for common personal use cases like signatures, seals, and logos, the BMP is more than enough. This is also the precondition that lets the tool stay simple and reliable at a scale of 15 pages and 512 characters.

Tracing isn't a black box: thresholds, speck removal, per-glyph fine-tuning

The tracing stage applies thresholding to each cell and removes small connected specks. Black ink is tracked as independent contours, so counters and detached dots and strokes are preserved within the glyph.

Parameter tuning is per-character. Threshold, speck filtering, cropping, scaling, offset, and spacing can all be adjusted separately, with the source cell always displayed alongside the contours for reference. If the scanned input itself is unsuitable, you can also draw or erase directly.

This differs clearly from most automatic vectorization pipelines: the tool doesn't decide for you that "it looks close enough"—it lays every tradeoff out in front of you.

Connected components and speck filtering: When scanning handwritten pages, paper texture, dust, and scanner noise all form isolated black blobs after binarization. GlyphSprout uses connected-component analysis to identify these specks: if a black pixel region is disconnected from the main strokes and its area falls below a set threshold, it's treated as noise and removed. Genuine strokes, detached dots (like the three dots of the "氵" radical), and components connected to the main body are preserved. This process directly determines the completeness of the glyph outline—set the filter threshold too high and it eats your dots; set it too low and it keeps the noise. That's why the tool makes it a per-character adjustable parameter rather than a global one-size-fits-all setting.

Live type specimen and export formats

The live type specimen loads the generated font file itself, not a simulated rendering. Completed projects can be exported as TTF or WOFF2.

If some selected characters aren't finished yet, you must explicitly choose the clearly labeled "completed subset" export option. This limitation seems annoying, but in practice it prevents half-finished characters from slipping into a finished font.

The difference between TTF and WOFF2: TTF (TrueType Font) is the universal font format for desktop systems—installable directly on Windows, macOS, and Linux, and the primary format recognized by tools like LibreOffice and Fontconfig. WOFF2 (Web Open Font Format 2) is a compressed font format designed specifically for the web, supporting Brotli compression, typically 30%+ smaller than TTF in file size, natively supported by all modern browsers, but generally not installable by double-clicking into an operating system. GlyphSprout offers both exports, meaning the same typeface can be installed into the system for local documents and embedded into web pages via CSS @font-face. Which to choose depends on the final use case, not on tool limitations.

A reproducible verification case

Paper Bloom is the first access example, containing 6 real letter crops from the public-domain NIST SD19 form f1002_33. The generated TTF is only 3,284 bytes.

The author checked the font family and character mapping with Fontconfig, used it in LibreOffice, and confirmed PDF text and embedded fonts via Poppler. It should be noted that this size applies only to these 6 letters; the Han and kana samples shown in the article are synthetic geometric shapes, not real handwriting.

This approach of including a verification chain is far more credible than simply claiming "it works."

Data storage and the boundaries of offline use

Project data stays in browser storage. IndexedDB holds the current and previous recovery snapshots, and a warning appears when another tab tries to write.

Even so, the author still recommends downloading the project JSON—browser storage can be cleared, and this isn't a theoretical risk. Offline use only begins after the full app cache report is ready.

From an engineering perspective, this is an honest tradeoff: it doesn't pretend browser storage equals a backup, nor does it make offline capability sound smoother than it actually is.

IndexedDB and the persistence of browser storage: IndexedDB is a transactional NoSQL database provided by browsers, capable of storing structured data and large binary objects, with capacity typically far exceeding localStorage. But unlike disk files, its lifecycle is managed by the browser: clearing cache, exiting private mode, storage-pressure eviction, and users manually clearing site data can all cause IndexedDB contents to be lost. GlyphSprout uses the current snapshot plus the previous recovery snapshot to reduce the risk of accidental operations, but it still can't fight browser cleanup policies. This is exactly why the author repeatedly emphasizes exporting the project JSON—a JSON file that lands on the user's own filesystem is a truly controllable backup.

Who it's for

GlyphSprout doesn't aim to replace full font editors like FontForge or Glyphs. It's aimed at scenarios that need a small batch of personal characters—signatures, seal characters, specific logo characters, or simply wanting to turn handwriting into a small font that can be installed into the system.

The project is open source, with source code and configuration instructions available on GitHub, and you can try the workshop directly in your browser. The feedback the author most wants right now focuses on two stages: scan page confirmation and per-glyph review.

If you've built a handwriting font, you probably know these two steps are the most patience-draining and the most error-prone. Giving feedback on these two areas is more valuable than a vague "it works well."

One-line Summary

GlyphSprout turns scanned A4 handwriting pages into font subsets with per-glyph parameter tuning, focused on small personal character sets.

Paragraph Summary

GlyphSprout is an open-source handwriting font tool for small personal character needs. Its workflow starts from A4 template scans, with 35 cells per page, supporting up to 512 BMP characters across 15 pages. It breaks tracing into per-character adjustable parameters—threshold, speck filtering, cropping, scaling, offset, and spacing—and allows drawing or erasing, avoiding the black-box feel of automatic vectorization tools. Fonts can be exported as TTF or WOFF2, the live specimen loads the generated font file directly, and unfinished characters require explicitly exporting the completed subset. The verification case Paper Bloom uses 6 public-domain NIST SD19 letters, producing a TTF of only 3,284 bytes, cross-verified with Fontconfig, LibreOffice, and Poppler. Project data lives in browser IndexedDB, and the author recommends downloading the project JSON as a backup.