AI can propose letterforms, interpolate masters, detect spacing anomalies, and help a type designer explore a large design space. It does not make a generated alphabet into a usable font. A release-quality typeface must encode characters correctly, shape every supported script, remain legible across sizes and devices, respect licensing and cultural context, and survive real text rather than a curated specimen.
The gap is particularly visible in Persian and Arabic typography. A model may draw beautiful isolated glyphs while failing contextual joining, diacritic placement, bidirectional text, Persian-specific characters, or the rhythm of an actual paragraph. The operational goal should therefore be a verified font-production system, not a prompt-to-poster generator.
1. Write a font brief that can be tested
Define the readers, languages, platforms, sizes, and content before training or prompting. “Modern Persian sans” is not a sufficient brief. A team should specify:
- Unicode ranges and exact language coverage;
- text, display, interface, signage, or editorial use;
- minimum and maximum sizes, screen densities, and print conditions;
- required weights, widths, italics or slants, and variable axes;
- numeral sets, punctuation behavior, mathematical symbols, and fallback policy;
- accessibility objectives and the acceptable performance budget for web delivery.
Separate aesthetic intent from functional requirements. Stroke contrast, terminals, proportions, and historical references belong to the design direction; character coverage, joining, mark positioning, and naming are release gates.
2. Build a rights-aware design corpus
Training images, source fonts, manuscripts, and reference specimens need recorded provenance and permitted use. “Found online” is not a license. Store source, creator, date, license terms, geographic and historical context, modifications, and any reserved names.
The SIL Open Font License FAQ explains that modified OFL fonts may require renaming when Reserved Font Names apply and that copyright and license information must be retained. That guidance only governs OFL material; it does not grant permission to train on, trace, or redistribute unrelated commercial or archival typefaces.
Deduplicate near-identical sources and document whose traditions are represented. A corpus dominated by a few digitized styles can make the model present one regional convention as universal. Historical material should be reviewed by people who understand its script, period, and intended use rather than treated as anonymous texture.
3. Generate candidates inside a constrained design system
Use AI where variation is useful: sketching alternate terminals, proposing missing glyphs from approved masters, interpolating rough weights, clustering spacing outliers, or finding inconsistent curves. Keep non-negotiable constraints outside the model:
- baseline, x-height or script-specific vertical zones;
- stem and curve logic;
- overshoot and optical correction;
- joining anchors and mark attachment;
- contour direction, overlap policy, and point economy;
- axis definitions and compatible master topology.
Candidate generation should be reversible. Retain the prompt or model inputs, source masters, model version, random seed where available, and designer edits. The final outline should never be an untraceable binary that cannot be corrected.
The OpenType specification overview distinguishes optional typographic features from capabilities required for correct text display, including Arabic ligatures and mark positioning. A generator can suggest outlines; the production team still has to construct and validate the tables that shaping engines use.
4. Treat Persian and Arabic as shaping systems
Arabic-script characters change form by context, and marks, ligatures, direction, punctuation, and mixed Latin text interact. Test words and sentences, not isolated character grids. Include Persian letters such as پ، چ، ژ and گ; Arabic and Persian forms of yeh and kaf; zero-width joiners and non-joiners; combining marks; Arabic and Persian digits; parentheses; URLs; Latin product names; and poetry or justified prose where relevant.
The Unicode Bidirectional Algorithm defines ordering for mixed-direction text and notes that cursively connected scripts require contextual shaping. It does not design the glyphs or guarantee that a font’s shaping tables are correct. Test with multiple compliant shaping engines and browsers because a font that happens to work in one application can fail elsewhere.
The W3C’s Arabic and Persian Layout Requirements is a draft note, not a final endorsed standard, but it documents concrete issues in direction, contextual shaping, diacritics, line breaking, justification, and kashida. Use it as a test inventory and record the exact document version consulted.
5. Design an evaluation suite beyond visual preference
Evaluation needs machine checks, expert review, and reader studies.
Automated checks should measure:
- required code-point coverage and correct character mapping;
- shaping tests for joining, ligatures, substitutions, marks, and bidirectional runs;
- missing-glyph and fallback frequency in representative corpora;
- outline validity, extreme points, intersections, and hinting or rasterization regressions;
- spacing and kerning outliers by script and size;
- axis interpolation failures and instance consistency;
- file size, page-load impact, and layout shift.
Expert review should examine texture, hierarchy, cultural fit, stroke logic, and optical balance. Reader studies should measure reading errors, speed, comprehension, fatigue, and preference at realistic sizes, while avoiding the claim that preference alone proves legibility.
Hold out words, names, mixed-script strings, and long paragraphs from the design examples used during generation. A font that memorizes a beautiful specimen may collapse on unseen suffixes, repeated teeth, dense diacritics, or narrow mobile columns.
6. Make accessibility part of the design loop
Legibility varies with size, contrast, display quality, visual ability, reading experience, and language. Test common confusions, counters that close at small sizes, marks that disappear, punctuation that becomes ambiguous, and weight changes that erase internal space.
For interfaces, compare task completion and error rate, not only aesthetic ratings. Support zoom and text resizing, preserve sufficient contrast, and ensure fallback fonts do not cause clipped lines or misplaced controls. Variable axes can improve adaptation, but an axis is not automatically accessible; every permitted instance needs safe bounds.
Connect type testing to the broader practices in AI for accessibility and assistive technology. A model should not infer a person’s disability from reading behavior or silently personalize typography in ways that expose sensitive information.
7. Use KPIs that reward a finished font
Good program metrics include:
- percentage of the declared character set covered and correctly shaped;
- pass rate of script-specific regression strings across platforms;
- reader error and completion time at target sizes;
- number of high-severity layout defects per release candidate;
- designer time from candidate to approved glyph, not candidates per minute;
- manual correction rate by generated glyph category;
- provenance completeness for training and source assets;
- webfont bytes and layout performance at the selected subset;
- support tickets attributable to rendering, missing characters, or licensing.
Measure each weight, width, and variable-axis extreme. Averaging across a family can hide a broken bold Persian form or an intermediate instance with self-intersecting outlines.
8. Plan for predictable font-generation failures
Models commonly produce inconsistent stroke logic, impossible interpolation, distorted accents, duplicate contours, over-smoothed historical forms, or Latin assumptions imposed on another script. They can generate a Unicode-looking symbol at the wrong code point or confuse visually similar Arabic and Persian characters.
Other failures are organizational: a prototype ships with incomplete license records; an attractive specimen masks missing punctuation; a generated name conflicts with an existing trademark; a web subset removes characters used by real customers; or a designer accepts a model’s pattern because reviewing thousands of glyphs is exhausting.
Use coverage dashboards, golden shaping strings, contour linting, font diffing, review queues, and release blockers. Do not automatically “repair” a culturally significant form without a qualified designer’s approval.
9. Govern attribution, naming, and release
Maintain a font bill of materials listing source assets, licenses, contributors, tools, models, transformations, and included tables. Record which glyphs were generated, edited, redrawn, or imported. Keep human authorship and approval visible rather than crediting an opaque model as the sole designer.
Have legal review address training rights, redistribution, reserved names, trademarks, and embedded font permissions. Licensing must be checked for the source material, the trained system where applicable, and the released font; these are separate questions.
For Persian-language products, integrate font QA with Persian NLP and localization. Linguists and native readers should review real names, dates, numbers, abbreviations, and mixed-direction interfaces. Translation coverage does not prove typographic coverage.
10. Roll out with specimens, pilots, and rollback
Start with a limited, non-critical specimen site that exposes the full character set, representative prose, UI components, axis controls, and known limitations. Test on major operating systems, browsers, low-resolution displays, print, and exported PDF.
Then pilot in one reversible product surface. Compare the new font with the current family using reading tasks, support feedback, performance, and screenshot regression tests. Keep the previous font stack as an immediate rollback. Do not expand to contracts, healthcare instructions, safety signage, or identity documents until language and accessibility gates pass.
Use the prototyping discipline described in AI product design and prototyping: explore widely, select deliberately, and validate in the installed context. A font file is not finished when the glyph sheet looks coherent; it is finished when real content renders reliably.
11. Release checklist
Before shipping, confirm:
- scope, languages, scripts, platforms, and sizes are explicit;
- every source asset has provenance and compatible rights;
- Unicode mapping, shaping tables, names, and variable axes validate;
- Persian and Arabic strings pass in multiple shaping engines;
- legibility and accessibility were tested with representative readers;
- held-out paragraphs and mixed-direction interfaces render correctly;
- file size, subsetting, fallback, and layout shift meet budgets;
- attribution, license files, reserved names, and trademarks are reviewed;
- versioning, issue reporting, and rollback are operational;
- marketing does not equate generated style with script support or legibility.
AI is valuable as a design instrument and consistency assistant. Typography remains a relationship between language, technology, culture, and readers. That relationship has to be tested in words and interfaces, not inferred from a gallery of synthesized glyphs.
Source notes
Sources checked on 2026-07-30:
- SIL Open Font License FAQ explains modification, redistribution, attribution, and Reserved Font Names for OFL-licensed fonts; it is not a general license for all font data or model training.
- OpenType specification overview describes font data, variation, glyph substitution, and positioning capabilities; a conforming table structure does not by itself establish readability or cultural quality.
- Unicode Standard Annex #9 specifies bidirectional ordering and its relationship to shaping; glyph design and application-specific layout remain outside its full scope.
- W3C Arabic and Persian Layout Requirements catalogues requirements and gaps for Arabic-script Web layout. As of the checked version, it is a Group Draft Note and should be cited as work in progress.