What I learned is that there are roughly six weeks of FontForge scripting between "the model can generate a few beautiful characters" and "a single OTF file opens correctly in Word."
That's not a complaint—it was my actual progress bar before I built MoFont. Back then I assumed the hard part was teaching an AI to write like me. It turned out the real time sink was something else entirely: taking six thousand-plus pretty glyph images and assembling them into one font file that the operating system recognizes, that Word opens, and that doesn't crash on some random character.
So in this post I want to break the whole thing apart: what steps actually turn handwriting into a font, which road is right for you, and the traps that "you only learn by hitting them yourself."
The bottom line first: there are two roads
Making a font from handwriting comes down to two paths. The only difference is which part you carry yourself.
Road one: fully manual (the hardcore route). This splits into two branches. The old-school way: you prepare a character chart covering the common characters, hand-write every cell, then use a tool like FontForge to trace outlines, set the glyph box, and define widths—one character at a time. Covering the 6,500 common Chinese characters means writing 6,500 cells and then processing 6,500 outlines. The slightly smarter way: you hand-write only a few hundred characters as samples, train a generative model yourself to fill in the rest, then script the generated output into a font file.
Road two: the assisted route (MoFont). You're only responsible for writing. Training, generation, vectorization, assembly, and spacing fixes are all automated.
I've walked both. Below I'll cover each, and along the way I'll point out exactly where most people on road one give up.
The hardcore route: why most people quit halfway
If you just want a logo or a shop sign with a handful of characters, hand-tracing is viable—arguably more controllable. But the moment you want a complete font—one you can type with, where every character exists—the problem changes character entirely.
Common Chinese starts at 6,500 characters. That is not a "write a bit longer" quantity. When I hit character #800 myself, my hand had already started to drift—the first hundred were neat, and the longer I wrote the sloppier they got, so the resulting font fought with its own style. That's the first trap: handwriting consistency. You are not a printer. Your horizontal stroke at character #50 and character #5000 are not the same thing.
Even if you survive the writing, the real bone to chew is in the back half. Every glyph image has to become a glyph: trace the outline (pixels to vector curves), define the glyph box, set side bearings, set advance width, and handle hinting (so the character isn't a blur at small sizes). You can batch all of this with FontForge's scripting interface, but "can batch it" and "do it correctly" are separated by an ocean of detail.
The trap that stuck me longest: when you importOutlines, the Y axis is flipped. A bitmap's origin is top-left with Y pointing down; a font's coordinate system has its origin at the baseline with Y pointing up. Ignore this and every imported glyph comes in upside down—and the error message will never tell you "because your axes are inverted." I spent the better part of a day staring at an upside-down screen of glyphs before it clicked.
There's a whole pile of cousins to this one: how big to set the em square, where to put the baseline, inconsistent advance widths that make text jitter wide-then-narrow, self-intersecting outlines that render some characters as solid black blocks. None of them is individually hard. Stacked together, they're six weeks. That's why most people, after writing a few hundred characters and generating a gorgeous single-glyph preview, get stuck at "how do I turn this into a usable OTF" and quit.
The underlying rules themselves are public—Microsoft's OpenType specification lays it all out. The problem was never missing docs. The problem is the docs assume you already understand font engineering.
The assisted route: how MoFont actually flows
Building MoFont was essentially me sealing those six weeks into a pipeline, so you only keep the one thing you already know how to do—write.
Five concrete steps:
1. Print A4 grid paper
Download the sample sheets from MoFont and print them on A4. Each sheet is a set of squared cells with the characters you'll copy printed in. Don't use paper so thin the ink bleeds through; ordinary printer paper is fine.
2. Write 30–50 characters with the same pen
This step sets the floor for your font's quality. A few rules of thumb:
- Use the same pen the whole way. Ballpoint, gel pen, or brush all work—but don't swap mid-stream. Change the pen and the model learns "two fonts" blended together.
- Write to the edges, fill the cell. Don't shrink into a tiny clump in the center; the model needs to see your characters' real size and center of gravity.
- Write naturally, not too carefully. This is counterintuitive: many people start out determined to "write beautifully" and end up with a handwriting that isn't theirs at all. The model is here to learn your hand, not a calligraphy textbook. Relax and write the way you write every day—that's what makes the result look like you.
- Even lighting. The photo step will thank you.
30–50 characters is the comfortable amount to cover enough style samples.
3. Photograph and upload each sheet
Shoot straight-on with your phone, no tilted light, no hand shadow over the characters. Upload them into MoFont one by one; the system auto-segments the cells, aligns them, and recognizes each character. You do zero alignment work here—I used to write segmentation scripts for this by hand; now it does it itself.
4. Model trains for about three to four hours
Once uploaded, the model starts learning your style. This runs in the background for roughly three to four hours—go do something else. The "what happens under the hood" section below explains what it's actually computing.
5. Get back an OTF + TTF covering 6,500 common characters
When training finishes, you download an OTF and a TTF covering the 6,500 common characters. Don't agonize over the format difference: Mac and Windows install either fine; design apps occasionally prefer one, so you get both.
What happens under the hood (a quick demystifying)
Skip this section if you don't want the technical detail—but I think understanding the mechanism makes you write better samples.
Style learning. From your 30–50 characters, the model doesn't memorize "copy each character." It abstracts your style—your stroke weight, your entry-and-exit habits, how tight or loose your structures are. In research this is called few-shot / one-shot font generation; the FontDiffuser paper, for instance, uses a diffusion model to extrapolate an entire font library from a single reference character. That's why you don't have to write all 6,500—a few dozen representative characters are enough for it to infer the rest.
Generating all glyphs. Having learned the style, the model draws all 6,500 characters one by one in that style, outputting glyph images (bitmaps).
Vectorization. A font can't be bitmaps—they blur when scaled up. So each glyph image is traced into vector outlines (Bézier curves), staying crisp at any size.
Assembly into OTF/TTF. The last step, and the one that ground on me hardest back then: drop 6,500 vector outlines into the right places in a font file, set advance widths, side bearings, and baseline, add hinting, and write the naming tables so the system recognizes it. The importOutlines Y-flip, self-intersections, and uneven widths I mentioned earlier all get handled automatically right here.
In one sentence: the model handles "looks like you," font engineering handles "actually works." MoFont does both halves and hands you the result.
How to use the finished font
Once the file's in hand, it's an ordinary font—used exactly like any commercial font you've ever bought.
Install. On Mac, double-click the OTF/TTF and click Install in Font Book—see Apple's official Font Book guide. On Windows, right-click the font file and choose Install, or drag it into the Fonts folder—see Microsoft's add-a-font guide.
Use. After installing, restart Word / Pages / PowerPoint and you'll find it in the font list (under whatever name you set in MoFont). Design apps like Photoshop, Figma, and Procreate work the same way. From then on, typing is your handwriting.
License and price. MoFont is buy-once—make it once, get the file, no subscription, no monthly charge. Exported fonts have no watermark, and if you need commercial use there's a plan with a commercial license—prices are on the pricing page.
In the end, "turn handwriting into a font" sounds like magic, but pull it apart and it's two things: teach a machine to write like you, then engineer the result into a font file that actually passes muster. The first part has gotten steadily better as AI improved. The second part—those six weeks of grunt work—was never something you should have had to carry.
You just write, with the same hand that makes typos and draws horizontals that aren't quite level. Leave the rest to the pipeline.
— Iris Gu
