• 

  landing_page

• 

  upload_section

About the Project

Inspiration

Handwriting is a unique personal touch in the digital age. A note, a card, or a journal page carries a certain special flair, but that visual identity is hard to carry into the places where we actually share text today. I made Inkform to make handwriting into fonts without making people print a character sheet, create an account, or hand their private writing to a server. I have always been a writer myself (going through many notebooks over the years!), so this project is a nice nod to the way I still primarily create and process information.

What it does

Inkform turns a handwriting photo into a downloadable TrueType font. A user uploads an image, supplies the text that's already visible in that image, previews their style on real words, and downloads the result. The current version focuses on Latin Extended coverage. The preview and export both use the same browser-side Rust font engine, so the experience remains local to the user's browser.

How I built it

I built Inkform as a Rust-first application. After all, I am a Youtuber specializing in Rust programming projects (which you can check out over @Neoravit :) ). The deterministic engine lives in inkform-core, where it validates samples, derives stroke and style signals, extracts bounded centerlines, synthesizes glyph outlines, and assembles a browser-compatible TTF. inkform-wasm exposes that engine to the frontend through WebAssembly. The product shell is a Next.js app designed for Vercel Hobby deployment, with no always-on backend required.

For a transcript-aligned sample, Inkform uses confirmed letters only when their extracted geometry passes continuity and topology checks. It uses those measurements to influence stroke weight, slant, letter width, and spacing. It then falls back to a controlled glyph grammar for characters that cannot safely be reconstructed from a single photo. This lets the result follow the character of the upload while keeping a complete font readable.

Codex and GPT-5.6 were part of the build process from the first design decisions through implementation, browser debugging, test coverage, and polish. I even included a gif stepping through the first through prompts of the project in my intro video, which you can also view here (https://imgur.com/a/niyEg3M). I used Codex to work through the Rust/WASM architecture, trace font-loading failures, write regression tests, and convert visual feedback from real samples into generator changes instead of editing individual font files by hand.

Challenges I ran into

The central challenge is that a freeform photo rarely contains every character needed for a useful font, and connected cursive writing is not reliably separable into isolated glyphs. A system that simply assigns image fragments left-to-right can produce unreadable letters. I built safety checks around transcript alignment and use synthesis when an extracted shape is too ambiguous to replay.

I also encountered the less visible but important work of font engineering. A TTF can look valid in a parser yet fail to load in a browser because of table details or metrics. I fixed the browser-compatible cmap format, verified generated fonts with FreeType tooling and browser loading, and added tests to prevent regressions. On the workflow side, I was new to Codex, so explicit project guardrails in AGENTS.md, a real test suite, and mandatory Clippy checks helped keep the work deliberate as the implementation evolved.

Accomplishments that I'm proud of

I am proud that Inkform is a working, locally processed creative tool rather than a static mockup. It produces a downloadable TTF, previews the generated output in the browser, and adapts visible details such as cursive loops, entry strokes, terminal strokes, width, and spacing from the sample. I am also proud of the engineering discipline behind it: no unsafe Rust, no unwrap in our application logic, typed errors, a shared Rust core, WebAssembly delivery, and regression tests for both glyph construction and font compatibility.

What I learned

I learned that handwriting-to-font generation is not one problem. It is image segmentation, style inference, typography, binary font construction, browser compatibility, and product design at the same time. The best result comes from being honest about uncertainty: preserve uploaded geometry when it is safe, but do not force an unreliable fragment into a letter just because it exists.

I also learned how to collaborate effectively with Codex (this was my first time using it). The most useful pattern was to give it clear engineering constraints, keep durable context in AGENTS.md, inspect real output after each generator change, and turn visual failures into small, testable rules. Codex accelerated implementation, but the product decisions and quality bar stayed intentional.

What's next for Inkform

The next step is to make the style model more robust across a wider variety of photos and handwriting styles, especially when a transcript is not available. I also want to expand script coverage beyond the initial Latin Extended pack. CJK, Japanese, Chinese, and other large writing systems need a different data and synthesis strategy.

Built With

• next.js
• rust
• vercel
• webassembly