Fact-checked by Grok 2 weeks ago

FontForge

FontForge is a application that serves as an outline font editor, enabling users to create, modify, and convert fonts in formats such as (Type 1, Type 3), , , CID-keyed, and . It supports drawing glyph outlines using cubic (Bézier) and quadratic splines, generating bitmaps from outlines, and handling advanced typographic elements like ligatures, , and feature tables. Originally known as PfaEdit, the software was developed primarily by George Williams from 2000 until 2012, after which it transitioned to community maintenance by the FontForge contributors. The tool is cross-platform, available for Windows, macOS, and , and is distributed under a combination of the GNU General Public License version 3 and the BSD license. FontForge's capabilities extend beyond basic editing to include format conversions, automatic accent generation, problem detection in glyphs, and between multiple master fonts, making it a comprehensive resource for type designers and developers. It also provides scripting interfaces in and a custom legacy language to automate font manipulation tasks. As of 2025, FontForge remains actively developed, with the latest stable release dated October 9, 2025, incorporating updates for support and bug fixes while maintaining compatibility with modern font standards. The project encourages community involvement through mailing lists, contributions, and documentation resources, fostering its role in open-source .

Introduction

Overview

FontForge is a and open-source font editor designed for creating, editing, and converting and fonts. It enables users to design fonts supporting extensive character sets, including , through various tools for glyph manipulation such as drawing, spacing, and hinting. The software addresses the needs of type designers by providing capabilities to generate fonts in multiple formats, facilitating across different systems and applications. Developed starting in 2000, FontForge's native is the Spline Font Database (.sfd), an ASCII-based, human-readable text that stores comprehensive font data including outlines, bitmaps, and , allowing for easy editing and . This supports the software's focus on detailed font construction while maintaining accessibility for collaborative development.

Platforms and Licensing

FontForge is available on multiple operating systems, including Windows, macOS, and distributions. Users can compile the software from on these platforms, providing flexibility for and integration with specific system environments. The software is dual-licensed, with the core distributed under the GNU General Public License version 3 (GPLv3) or later, while a large portion, including much of the original work by George Williams, falls under the Revised BSD License. Certain components, such as those integrating libraries like and , use the GNU Lesser General Public License (LGPL), ensuring compatibility for broader use. This licensing structure permits free redistribution in source or binary forms, allows modification and derivation of works, and requires retention of copyright notices and disclaimers, fostering open-source collaboration while protecting against proprietary endorsements without permission. As of October 2025, FontForge supports localization into 12 languages through gettext-based translation files, enabling user interfaces in Bulgarian, , , , , , , , , , , and . Installation options include pre-built binary packages downloadable from the official website and for Windows (.exe installers), macOS (.dmg files requiring OS X 10.15 or later), and . On , users can install via package managers such as apt (for Debian-based systems) or yum/dnf (for RPM-based distributions), though these may provide older versions; portable formats like (official) and (via Flathub) are also available for easier deployment without system-wide installation. Source compilation is supported across all platforms using standard build tools after installing dependencies.

Core Features

User Interface

FontForge provides a primarily built using the , with support for multiple platforms including Windows and macOS through wrappers. The interface centers around several interconnected main windows that facilitate font management and glyph editing. These windows allow users to navigate, select, and manipulate font elements interactively, with visual feedback such as color-coded indicators for glyph states. The Font View serves as the primary overview window, displaying all glyphs in the font as a or , typically at sizes ranging from 24 to 96 pixels. Users can select multiple glyphs by dragging or shift-clicking, reorder them via drag-and-drop, and access contextual menus by right-clicking for operations like transformations. Glyph labels show names, values, or encoding details, with red outlines indicating missing glyphs in modes. Navigation includes keyboard arrows for selection, to cycle through glyphs, and typing a to jump to the corresponding glyph. The Outline Glyph View is the main editing window for vector-based spline editing, showing the glyph's outline with points classified as corners (squares), curves (circles), or tangents (triangles). It includes an information line for coordinates and measurements, supporting up to 19 tools for point manipulation, such as the pointer for selection and the pen for adding points. Layers for foreground, background, and guides are managed via a palette, allowing overlay of images or other splines. Drag-and-drop from the Font View inserts glyph references. The Bitmap View mirrors the Outline View's structure but focuses on pixel-level editing for raster glyphs, displaying a grid for setting or clearing bits with tools like the , line, or eyedropper for anti-aliased greyscale. It supports six primary tools, including and , with options for shapes like rectangles or rotations. Free-floating palettes for tools and shades can be docked for efficient access. The Metrics View enables examination and adjustment of glyph spacing and by displaying up to 15 selected s in sequence, with draggable lines for origins (green), advance widths (blue), and bearings. Users add glyphs via drag-and-drop from the Font View or keyboard input (F12), and toggle features like ligatures from a dropdown. Modes for , width, or both allow precise interactions, with vertical metrics available if enabled in font properties. Navigation across views uses consistent menus for file operations (e.g., open, save), element editing (e.g., copy, paste), and view controls. The menu provides zoom in/out (centering on selections), fit-to-view scaling, and panning via a or (with Ctrl for zoom). Drag-and-drop supports transfer between windows, such as from Font View to Metrics View for quick spacing setup. Menus are accessible via underlined accelerators with Ctrl combinations. The , invoked via the fontforge executable, supports batch operations without launching the , processing font files in formats like SFD, , or . Key options include -script to run automation scripts (e.g., opening and generating fonts) or -c for inline commands, enabling non-interactive tasks such as conversions or validations on multiple files. Scripts can be omitted if the file is executable with a shebang containing "fontforge". This mode integrates briefly with or legacy scripting for extended automation. Accessibility is enhanced through extensive shortcuts, with defaults like Ctrl+O for open, Ctrl+C for copy, and for navigation in views. Users customize hotkeys by editing the ~/.FontForge/hotkeys file, assigning modifiers (Ctrl, Alt, Shift) to actions or tools, with support for window-specific bindings (e.g., CharView for editing). Customizable palettes for tools, layers, and shades can be docked or floated, and the adapts to different keyboards via configuration. Three-button support is recommended for precise control.

Editing and Design Tools

FontForge provides robust glyph editing capabilities, allowing users to create and refine individual characters using vector-based outlines. It supports cubic Bézier splines, which are third-order curves commonly used in Type 1 fonts for smooth, editable paths. Quadratic splines, second-degree curves suited for fonts, offer mathematical simplicity but require careful editing to maintain smoothness. Additionally, FontForge integrates clothoid splines via the libspiro library, enabling the creation of curves with constant and slope transitions without control points, which simplifies aesthetically pleasing contours. Users can insert points along paths using specialized tools for curve points (to maintain smoothness), tangent points (for straight-to-curve transitions), and corner points (for sharp angles), ensuring precise control over outline shapes. Path correction is facilitated by dragging control points or endpoints to align with reference images, with options to close open contours by snapping the final point to the starting one. Layer management includes a foreground layer for the primary editable outline, a background layer for importing reference images or traces, and guide layers for consistent metrics like across glyphs. Hinting tools in FontForge ensure high-quality rasterization at small sizes by aligning stems and counters. For PostScript Type 1 fonts, it supports stem hints—horizontal (light green) and vertical (light blue) lines defining stroke widths—and flex hints, which allow dynamic stem adjustments via substitution points for curved sections like serifs. Counter hints manage spaces between stems, either automatically generated or manually defined in horizontal and vertical groups. TrueType fonts utilize instruction-based hinting, where FontForge can automatically generate instructions from -style stem hints, incorporating diagonal stems and Private dictionary data for precise pixel alignment during rendering. Users may edit these instructions directly or add manual diagonal hints. Auto-hinting is available through the AutoHint command, which detects stems, substitution points, and basic counters while discarding prior hints unless manual overrides are applied; this process can be toggled globally via preferences. Advanced design features enhance efficiency and typographic sophistication. References enable glyph reuse by embedding instances of other glyphs as components, such as constructing accented characters from letters and diacritics, which promotes and reduces . Multiple fonts support across axes like weight, width, or optical size, requiring identical counts, point distributions, and orientations across designs—up to 16 for or 27 for Apple-style—to generate intermediate styles seamlessly. For complex layouts, FontForge handles and Apple Advanced Typography (AAT) lookups via the GSUB table for glyph substitutions like ligatures and the GPOS table for positioning adjustments, including pairs, mark-to-base attachments, and connections. Validation tools help maintain font integrity by identifying and resolving common issues. The Element > Find Problems command scans selected glyphs for errors across categories such as non-integral coordinates, open or intersecting paths, missing extrema, and excessive point counts (e.g., over 1,500 for compatibility), with results displayed in tabbed panels for targeted fixes like adding points or correcting directions. Spacing issues, including inconsistent advances or conflicts, are detected alongside overlap problems in composite glyphs. The dedicated Font Validation window performs comprehensive checks against and standards, flagging items like flipped references, invalid substitutions, or coordinate offsets exceeding 32,767 units; it supports batch repairs, such as removing overlaps before saving, and revalidates incrementally as edits occur.

Scripting and Automation

FontForge provides extensive scripting capabilities through its Python API, allowing users to automate font editing tasks, batch process files, and extend the software programmatically. Introduced in early 2007, the Python interface embeds the Python interpreter and exposes two primary modules: fontforge for core font manipulation and psMat for transformation matrices. This API mirrors the graphical user interface (GUI) actions, enabling scripts to perform operations like opening fonts with fontforge.open(filename) or generating output files via font.generate(output_filename). Scripts can operate in multiple modes to suit different workflows. Within the GUI, users execute Python code directly via the scripting dialog or embedded console. From the command line, FontForge invokes scripts using the -c flag, such as fontforge -c 'from sys import argv; from fontforge import *; Open(&#36;1).Generate(&#36;2)' input.sfd output.ttf for simple batch conversions. Additionally, the fontforge module can be imported into standalone environments, facilitating integration into larger applications or pipelines, as in glyph generation loops that create and populate new fonts programmatically. For instance, a script might iterate over ranges to build composite glyphs: font = New(); for i in range(0x0041, 0x005B): glyph = font.createChar(i); glyph.draw("..."). Command-line invocation supports non-interactive , detailed further in the user interface documentation. Advanced scripting extends to specialized font features and external interoperability. Namelists enable systematic glyph naming, loaded via LoadNamelist(filename) and applied with RenameGlyphs(namelist_name) to standardize names based on conventions like the Adobe Glyph List. Custom lookups are created using functions such as AddLookup(name, type, flags, features) for GSUB/GPOS tables, followed by AddPosSub(subtable_name, glyphs) to define substitutions or positioning rules, allowing precise control over typographic behaviors. The API integrates seamlessly with libraries like FontTools, a pure-Python font manipulation toolkit, enabling hybrid workflows where FontForge handles outline editing while FontTools manages table-level modifications, such as UFO format conversions. Official documentation includes a comprehensive scripting tutorial for the legacy scripting language, covering fundamental programming constructs such as variable assignment (e.g., i=1), control structures like while loops for iterating over arguments (while (i < $argc) ... endloop), and error handling with conditional if statements and Error("message") calls to validate inputs and prevent crashes. This tutorial provides practical examples for legacy scripting. Python scripting, with its own dedicated documentation, offers greater flexibility for complex automation tasks.

Supported Formats

Input Formats

FontForge supports a wide range of input formats for importing fonts, enabling users to load and edit existing typefaces by converting them into its internal Spline Font Database (.sfd) representation. This internal format preserves outline paths, data, metrics, and other font properties during editing workflows. Upon import, FontForge handles various encodings, such as ISO 8859-1 by default, Mac Roman, and , while allowing manual adjustments for compatibility with specific font origins. For complex cases like CID-keyed fonts, which are common in CJK (, , ) typefaces, FontForge supports both horizontal and vertical metrics, including Adobe's and Type 0 structures, though rudimentary handling may require additional configuration for compact encodings.

Vector Formats

FontForge can import vector-based outline fonts from several standards, converting splines and paths into its editable .sfd format. Type 1 fonts, in both ASCII (.pfa) and binary (.pfb) variants, are fully supported, including multiple master instances where applicable. Type 3 fonts (.pt3) are also importable, though they may require post-import overlap removal for proper rendering due to their bitmap-inclusive nature. (.ttf) and Collections (.ttc) files are natively handled, extracting glyph outlines, hints, and tables like 'hmtx' for horizontal metrics. fonts (.otf), including those using Compact Font Format (CFF) outlines (.cff or .otf), are imported with support for advanced tables such as 'GSUB' and 'GPOS' for glyph substitution and positioning, essential for CJK vertical typesetting. (SVG) fonts (.svg) can be loaded, with paths converted to FontForge's quadratic or cubic spline representations, though subset limitations apply to complex SVG features. Unified Font Object (.ufo) files, in both UFO 2 and UFO 3 variants, are supported for import, parsing elements like layercontents.plist and guidelines while mapping them to internal layers; UFO 3 extensions, such as anchor tags, are preserved during the process. (.eps) and PDF-embedded fonts are importable for individual glyphs, with PDF requiring manual subset specification.

Bitmap Formats

For raster-based fonts, FontForge imports bitmap glyphs directly into its multi-layer structure, allowing scaling or autotracing to outlines if needed. Bitmap Distribution Format (.bdf) files, standard for , are fully supported, including multiple sizes and encodings. Portable Compiled Format (.pcf) files from X11 are also importable, with LZW-compressed variants handled transparently. Bitmap strikes embedded in (.ttf), (.otf), or collections (.ttc) are extracted and loaded as separate layers. TeX-related formats like Packed Bitmap (.pk) and Generic Font (.gf) are supported, often requiring explicit encoding assignment post-import for accurate glyph mapping. Additional bitmap sources include Palm Database (.pdb), , (.xbm), and images, which can be imported via templates (e.g., uniXXXX.png for slots). Mac NFNT and Windows FON formats are handled on respective platforms.

Other Formats

Beyond core vector and bitmap types, FontForge accommodates specialized and legacy formats for broader compatibility. (.woff) files can be imported indirectly by decompressing to their underlying SFNT (/) structure, though native .woff extension recognition is limited. Portable Font Resource (.pfr) support is not directly available, but conversion tools may enable indirect import. -keyed fonts, prevalent in CJK workflows, are imported as multi-subfont structures, preserving mappings and metrics for both horizontal ('hmtx') and vertical ('vmtx') orientations; Type 0 and Type 3 variants are included, with warnings for potential issues in metrics views. Other inputs include Font Metrics (.afm), Font Metrics (.tfm or .ofm), and Font Feature (.fea) files for and encoding data, which must match the primary font's structure. Macintosh resource files (.dfont, MacBinary) and formats are platform-specific imports, often needing utilities like acorn2sfd for conversion. During all imports, FontForge generates an .sfd file internally, facilitating unified across formats while retaining original encoding and metric integrity where possible.

Output Formats

FontForge supports a range of font export formats, enabling the generation of scalable outlines suitable for various applications. Primary outputs include (.ttf), which uses quadratic Bézier curves for glyph outlines, and (.otf), available in variants with either outlines or Compact Font Format (CFF) outlines based on cubic Bézier curves. formats are also supported, such as Type 1 (including printable ASCII .pfa and binary .pfb variants) for single-master fonts and Type 2 via CFF for more compact representations. Additionally, font format is exportable in two styles: one mimicking Type 1 contours and another using Type 3-like stroke and fill paths. For bitmap fonts, FontForge allows export to (Bitmap Distribution Format), a standard for monochrome bitmaps used in X11 environments, from which PCF (Portable Compiled Format) files can be generated using external tools such as bdftopcf. Multi-resolution bitmap fonts can be generated by specifying multiple pixel sizes or levels (e.g., greymap strikes at resolutions like 12 pixels with 8 levels of gray), embedding these within container formats such as bitmap-only sfnt or Apple dfont. Specialized export options cater to web and legacy needs, including WOFF (Web Open Font Format) and its compressed variant WOFF2, which wrap or data with metadata for efficient web delivery. and PFB remain available as legacy Type 1 formats for printable applications, while multiple-master fonts—allowing interpolation between design axes like weight or width—are exportable in format. During export, FontForge provides generation flags to customize output. Users can select bitmap types (monochrome or anti-aliased), disable hinting for smoother rendering at arbitrary sizes, and set resolutions (e.g., prompting for specific DPI in exports). A "Validate Before Saving" option performs checks on glyph outlines, metrics, and tables to ensure compliance with format specifications prior to . These options apply to the internal spline or representations derived from prior imports.

Development History

Origins and Early Development

FontForge was originally developed by George Williams as PfaEdit, with its first release on November 7, 2000, hosted on a server provided by Dan Kenan. Williams created the software to address deficiencies in existing open-source tools for editing PostScript fonts, particularly Type 1 formats, at a time when commercial options like Fontographer lacked support for emerging standards such as OpenType and Unicode. His motivations stemmed from practical needs encountered during his professional background in software development; in the early 1990s, while working at NaviSoft—a startup later acquired by AOL—on an HTML editor similar to Microsoft FrontPage, Williams required robust Unicode font support to handle accented characters and Type 0 PostScript composites, which existing tools could not adequately provide. This experience, combined with his earlier interests in calligraphy and font design dating back to the 1980s when he used Fontographer for personal projects, drove him to develop PfaEdit as a retirement endeavor after achieving financial independence from the AOL acquisition in the late 1990s. Early development focused on expanding format compatibility to meet the demands of web and multilingual . The initial version supported Type 1 fonts in format, with rapid additions in 2001 including PFB, , bitmap, CID-keyed, and Type 2 formats, alongside basic capabilities introduced in April of that year. By March 2004, the project was renamed FontForge at the suggestion of a user, reflecting its broader scope beyond editing. Further milestones included integration of a debugger in March 2003 for rasterization testing, support for fonts following the EuroTeX 2003 conference, and multi-master font handling added in February 2004. features were progressively enhanced through the mid-2000s, with significant updates by 2005 enabling more comprehensive layout table support. In 2011, the project transitioned to for , with the migrating to in September 2012, marking a shift toward more collaborative hosting while still under Williams' primary stewardship; the full migration of the and occurred in September 2012. Williams handled nearly all development single-handedly until his retirement in , contributing core systems that defined FontForge's technical foundation. His innovations included advanced spline handling, such as improved editing for quadratic splines between January and February 2006, which enhanced curve precision for outline-based fonts. Additionally, he developed hinting mechanisms, notably the auto-hinter enhancements in July 2008, refined with input from collaborators Nowakowski and Alexej Kryukov, to automate instruction generation for better on-screen rendering at small sizes. These contributions established FontForge as a versatile tool for font designers seeking free alternatives to .

Community Maintenance and Recent Advances

Following George Williams' retirement in 2012, development of FontForge shifted to a community-driven model, with maintenance coordinated through the project's GitHub repository involving numerous contributors. A parallel community initiative emerged as SortsMill Tools, a fork derived from the original FontForge codebase, emphasizing improved reliability, code reuse, and font editing enhancements. This transition ensured the software's continued evolution beyond its founder's involvement. Key advancements in recent years include the implementation of full support for the Unified Font Object (UFO) format in the 2014 stable release (version 20141005), led by developer Frank Trampe to enable better interoperability with other font design tools. Python scripting integration was further refined around 2015, allowing seamless embedding of FontForge functionality within environments for automation and custom workflows. The most recent stable release, dated October 9, 2025, incorporates ongoing refinements such as updated support and build improvements. FontForge remains under active development, with bug fixes, feature requests, and enhancements tracked via issues and the legacy tracker. Security maintenance is prioritized, exemplified by a 2025 advisory addressing a (CVE-2025-50949) in version 20230101. The fosters collaboration through dedicated mailing lists, including fontforge-users for general inquiries and fontforge-devel for technical discussions and patches. Contributions are welcomed in the form of code pull requests on and financial donations to sustain development efforts.

Notable Applications

Fonts Created with FontForge

FontForge has been instrumental in the development of several prominent open-source fonts, enabling designers to create comprehensive glyph sets and advanced typographic features without . One notable example is Sans Guilt, a reinterpretation of Eric Gill's typeface released under the (OFL). Developed by the Open Source Publishing (OSP) collective during a 2011 workshop at the Royal College of Art, Sans Guilt features three variants—MB (based on rasterized Monotype Gill Sans), DB (drawn from early sketches), and LB (derived from lead type)—each crafted using FontForge alongside tools like and for tracing and editing outlines. The DejaVu font family, an extension of Bitstream Vera fonts aimed at broad Unicode coverage, also relies on FontForge for its ongoing expansions and maintenance. The project provides source files in FontForge's SFD (Spline Font Database) format, allowing contributors to add glyphs for Cyrillic, Greek, and other scripts while preserving the original aesthetic. This format facilitates collaborative editing of complex character sets, supporting over 2,000 glyphs per font in versions like DejaVu Sans and Serif, which include mathematical symbols and historical scripts. Similarly, Cantarell, which served as the default sans-serif typeface for the GNOME desktop environment and Fedora project from 2009 until early 2025, was designed exclusively with open-source tools, primarily FontForge. Created by Dave Crossland and Jakub Steiner starting in 2009, Cantarell emphasizes on-screen readability with humanist proportions optimized for mobile and web interfaces. In GNOME 48 (released in 2025), it was replaced by Adwaita Sans as the default UI font, with Fedora adopting this change in subsequent releases. FontForge enabled the implementation of multiple weights (, Bold, Oblique, Thin) and italic styles, incorporating features such as and ligatures for enhanced legibility across Latin scripts. In these projects, FontForge's capabilities for handling intricate glyph designs proved essential for achieving full Unicode compliance, particularly in DejaVu's expansions to cover underrepresented languages and scripts. The software's built-in support for TrueType hinting allowed precise rasterization at small sizes, crucial for Cantarell's UI applications, while its scripting and feature tables facilitated the addition of OpenType substitutions and positioning in Sans Guilt's variants. These technical affordances democratized access to professional-grade font engineering in open-source typography. FontForge's role extends to broader open-source , powering the creation and refinement of numerous fonts listed in repositories like the Open Font Library. By providing free tools for interpolation, bitmap generation, and format conversion, it has fostered a vibrant where volunteers expand font families for global linguistic diversity.

Integrations and Use Cases

FontForge integrates with other font-related tools through its , which provides programmatic access to its core functionality for embedding in custom workflows or applications. The , importable as fontforge, enables operations such as opening, editing, and generating fonts directly within scripts, making it suitable for automation in tools like RoboFont where it has been invoked for manipulation and format conversions. Additionally, while FontTools serves as a complementary for font manipulation, FontForge's can be combined with it in pipelines, such as creating fallback fonts by generating base s in FontForge and subsetting via FontTools. The tool's command-line interface further supports integration into build pipelines, particularly for web font production, where scripts automate format conversions like SFD to WOFF or TTF for efficient deployment. For instance, commands such as fontforge -c 'Open(&#36;1); Generate(&#36;2)' input.sfd output.woff allow batch generation of web-optimized fonts without interactive use, streamlining processes in continuous integration environments. In publishing workflows, FontForge facilitates font conversions, such as transforming glyphs into or formats, enabling designers to integrate vector-based illustrations into professional for print or digital media. Automated scripts enhance this by processing files in bulk, converting them to outline fonts while preserving scalability for high-quality output. For icon font creation, it supports batch importing sequences of icons as glyphs, assigning points, and exporting unified font files, which is common in design for scalable symbol sets. As an educational resource, FontForge is employed in type design courses to teach font , glyph editing, and generation, with tutorials guiding beginners through creating custom typefaces from vector sources. Professionally, FontForge contributes to large-scale projects like Google Fonts by converting its native SFD format to UFO via tools such as sfd2ufo, integrating into build chains with Fontmake for open font production. For complex fonts like CJK, scripting addresses limitations in handling thousands of glyphs, such as automated import via CID maps and memory management, though 512 MB RAM is recommended minimum for stability during edits. In open-source communities, FontForge is actively packaged in distributions like Fedora, supporting font packaging guidelines for outline and bitmap formats in collaborative initiatives.