View source for Metafont

{{More citations needed|date=November 2024}}

{{short description|Description language used to define rastertype  fonts}}
{{infobox software
| logo                   = METAFONT logo.svg
| logo size              = 220px
| developer              = [[Donald Knuth]]
| latest_release_version = [[e (mathematical constant)|2.71828182]]
| latest_release_date    = {{start date and age|df=yes|2021|1}}
| operating_system       = [[Cross-platform]]
| genre                  = [[Computer language]]
| license                = [[Permissive free software license|Permissive]]
}}
'''Metafont''' is a [[page description language|description language]] used to define [[raster fonts]]. It is also the name of the [[interpreter (computer software)|interpreter]] that executes Metafont code, generating the bitmap fonts that can be embedded into e.g. [[PostScript]]. Metafont was devised by [[Donald Knuth]] as a companion to his [[TeX]] typesetting system.

One of the characteristics of Metafont is that the points defining the shapes of the [[glyph]]s—for example top of a [[Stem (typography)|stem]], or intersection of a stem and crossbar—are defined with geometrical equations; the intent that the three stems of an ‘m’ are equally spaced horizontally might be expressed as <math> x_2-x_1 = x_3-x_2 </math> if points 1, 2, and 3 are at the bottom ends of the three stems, whereas the intent that they all end on the same vertical position would be <math> y_1 = y_2 = y_3 </math>.

Metafont is a [[Macro (computer science)|macro]] language, where operations such as "draw a lower case top of stem serif at point 4" might appear as one macro instruction (with the point as argument) in the program for a letter.  For describing shapes, Metafont has a rich set of [[Bézier cubic|path]] construction operations that mostly relieves the user of having to calculate control points.

Many families of Metafont fonts are set up so that the main source file for a font only defines a small number of design parameters ([[x-height]], em width, slant, vertical stroke width, etc.), then calling a separate source file common for a whole range of fonts to actually draw the individual glyphs; this is the [[Meta (prefix)|meta]] aspect of the system.

==Modes of operation==
Metafont is most often run as a helper to output device (printer, screen) drivers; in those cases, its job is to generate bitmaps for a font for a specific combination of output device (called a ''mode'' in Metafont) and [[Dots per inch|resolution]] (visible in the name of the output file, see below). These bitmaps are typically stored for later reuse, so that Metafont does not have to be run every time a document is displayed, but on the other hand TeX distributions with a Metafont component have typically not included any prebuilt bitmap fonts, since they would be rather large in comparison to the sources from which they could be generated. Since Metafont fonts were traditionally the TeX default from which other font formats were exceptions, an incomplete installation of a non-Metafont font can sometimes result in Metafont being called and emitting a confusing "''somefont''.mf not found" error message.

Equally important, but not as common, is running Metafont to generate a font metric (TFM) file; a TFM file is only generated if the ''fontmaking'' variable is positive. Traditionally TeX distributions have often come with all TFM files pregenerated (since they are pretty small), but someone installing a Metafont font from sources will have to generate its TFM file before TeX can use it.

A third way of operating Metafont is ''proof mode'': if the ''proofing'' variable is positive then the bitmap font file also contains additional information provided via <code>special</code> commands, in particular the positions and names of points the font designer considered important for the design. If using the separate <code>gftodvi</code> utility to generate enlarged images of the font glyphs, this  information from specials is included; point positions are not limited to pixel resolution.

Metafont can also be run interactively, and has commands for displaying on the screen the images it produces. Knuth has said that he uses Metafont as a kind of desk calculator for solving complicated equations, though he now uses MetaPost for mathematical illustrations.
<!-- could say something here about alternatives – e.g. vector versions such as pdftex uses -->

Metafont can render any kind of graphical output, not just glyphs. However, [[MetaPost]] and [[Asymptote (vector graphics language)|Asymptote]] are preferred for mathematical illustrations. Metafont is most commonly invoked without a direct request from the user. [[DVI file format|DVI files]] can only contain references to typefaces, rather than the sets of raster or vector glyphs that other formats like PostScript allow. Consequently, the glyphs in the typefaces need to be accessed whenever a request is made to view, print or convert a DVI file.

===Output files===
Metafont outputs several kinds of files: for a file called NAME.mf, it can output:

* NAME.NNNNgf – File with raster output at resolution NNNN (2602 by default). 
* NAME.tfm – File with [[TeX font metric]] information, which is the information TeX needs. Usually metafont has to be told to generate this file.
* NAME.log – Log file output from processing

After running Metafont, typically one uses the gftopk program to convert the NNNNgf files to pk (packed) format (.NNNNpk). The pk format was primarily introduced to reduce file size (to about half), but expected to also speed up processing since less data would have to be [[input/output]]. The GF and PK formats both employ [[run-length encoding]] of bitmaps, but make different binary encodings of the run-lengths. The PK format also does some preprocessing of the bitmaps (bounding box, eliding repeated rows) and encodes all rows of a character as one long bit-sequence.<ref>{{cite journal |last1=Rokicki |first1=Tomas |title=Packed (PK) Font File Format |journal=TUGboat |date=1985 |volume=6 |issue=3 |pages=115–120 |url=https://www.tug.org/TUGboat/tb06-3/tb13pk.pdf |archive-url=https://web.archive.org/web/20111106100403/http://tug.org/TUGboat/tb06-3/tb13pk.pdf |archive-date=2011-11-06 |url-status=live |access-date=2019-08-09}}</ref>

In the ''TeX Directory Structure'' standard, filenames are limited to 8+3 characters, so GF and PK files would only have extensions <code>.gf</code> and <code>.pk</code>. Files for different resolutions are kept apart by placing them in separate directories, named <code>dpi</code>NNNN, e.g. <code>dpi300/cmr10.pk</code>.

==Language==
The Metafont language is an [[interpreter (computing)|interpreted]] language for programs that are ''essentially [[declarative programming|declarative]] rather than [[imperative programming|imperative]]''.<ref name="METAFONTbook">{{cite book |last1=Knuth |first1=Donald |title=The METAFONTbook |date=1986 |publisher=Addison Wesley |isbn=0-201-13445-4}}</ref>

===Variables and equations===
Variables in Metafont can be of eight different types:
* Numeric: [[fixed-point arithmetic|fixed-point]] signed numbers with an [[machine epsilon|epsilon]] of <math>2^{-16}</math>, capped to be less than 4096 ([[Q (number format)|Q12.16]]). This is the default for variables not declared to be of another type.
* Pair: a pair of numerics, used primarily for representing points in the plane.
* Path: as in [[PostScript]]/[[PDF]]/[[Scalable Vector Graphics|SVG]], a [[parametric curve]] in the plane whose coordinate functions are [[piecewise]] cubic polynomials. As in those other systems, path segments are encoded as [[Bézier curve]]s in terms of knots and control points.
* Transform: an [[affine transformation]] of the plane, equivalent to a "(transformation) matrix" in PostScript/PDF.
* Pen: a convex polygon, representing the shape of a "pen" used for drawing.
* Picture: a [[raster graphics|raster image]] with a signed integer value for each pixel.
* [[Boolean data type|Boolean]]
* String (of 8-bit characters)
[[Metapost]] adds color (a triple of numerics) as a ninth type and has a completely different (non-raster) model for pictures; the latter is the main point of divergence between the two programs. Metafont vardef macros also live in the same namespace as variables and may in some ways be regarded as a ninth type of variable, although macros do not exist as [[first-class citizen|first-class]] values in Metafont.

Unusually, the names of variables are not simple tokens, but sequences of symbolic tokens and numeric indices; the variable name <code>x2r</code> is thus not one [[alphanumeric]] token, but a sequence of the three tokens <code>x</code> (symbolic), <code>2</code> (numeric), and <code>r</code> (symbolic). [[Record (computer science)|Record]] and [[Array data type|array]] types may be simulated through collections of variables that share a common name prefix, an idiom supported by the type declaration system giving all variables whose names which differ only in numeric indices the same type (as expected for arrays) while keeping variables whole name differ in some symbolic token separate (as expected for records).

A very distinctive feature of Metafont is the use of [[equation]]s to define variables. A numeric variable (or component of a pair or transformation variable) may be in the three states ''known'' (set), ''unknown independent'' (not set), and ''unknown dependent'' (not set, but given by a [[Linear function (calculus)|linear expression]] of one or several independents). When Metafont executes an equation statement, it turns one of the independents involved into a dependent and eliminates it from the expressions for all other dependents; when no independents remain in the expression for a dependent variable, that variable becomes known. Solving [[system of linear equations|''linear'' equation systems]] thus is a built-in feature of the Metafont language, and the recommended method of assigning most variables (especially those whose values have geometric significance) is to state equations determining their values. Equation systems frequently mix numeric (scalar) equations with pair (vector) equations.

An exception to the above is the class of ''internal quantity'' variables. These have names consisting of just one symbolic token, are always numeric, and are always known. They have a more direct internal representation than ordinary variables, making it convenient for primitive operations in Metafont (or extensions thereof) to use them implicitly.

===Syntax===
Metafont has numeric and string constant tokens with mainstream syntaxes; strings are delimited by <code>"</code> quotes, numeric constants can have decimals but not an [[scientific notation|exponent part]]. All other tokens are classified as ''symbolic'', and can be redefined arbitrarily; there is no restriction that tokens with certain meanings must have names consisting of certain characters. At runtime, there can additionally be ''capsule'' tokens, which are effectively constant value tokens of arbitrary type; in the source code those appear as symbolic tokens.

Except where characters are involved in numeric or string constants, the extent of the token containing a particular character depends on to which class the character belongs; unlike [[TeX]], Metafont has fixed character classes. The characters <code>,</code>, <code>;</code>, <code>(</code>, and <code>)</code> are "loners" and only form single character tokens. For the character classes <code><=>:|</code>, <code>‘’</code> (single quotes), <code>+-</code>, <code>/*\</code>, <code>!?</code>, <code>#&@$</code>, <code>^~</code>, <code>[</code>, <code>]</code>, <code>{}</code>, and <code>.</code>, as well as the class of underscore together with upper and lower case A–Z, the token consists of the longest consecutive sequence of characters from the same class. Whitespace characters don't contribute tokens. <code>%</code> starts a comment lasting until end of line.

A notable application of these rules is that <code>#</code> is frequently appearing as part of variable names in Metafont code, e.g. <code>em#</code> and <code>pt#</code>.

Delimiters (such as parentheses) do not have built-in meanings, instead there is a command that turns two symbolic tokens into a pair of matching delimiters, but normally Metafont programs use only the ordinary parentheses. Besides to override priorities in expressions, delimiters are also required around certain kinds of macro arguments.

===Graphics===
Curves in Metafont are defined as [[cubic spline]]s, rather than quadratic, for greater versatility at the cost of more complex arithmetic.<ref>{{cite interview|last=Knuth|first=Donald|subject-link=Donald Knuth|interviewer=Advogato|title=Interview: Donald E. Knuth|url=http://www.advogato.org/article/28.html|date=January 25, 2000|access-date=January 13, 2016|quote=...the mathematics is really simple for a quadratic. The corresponding thing for a cubic is six times as complicated...|archive-url=https://web.archive.org/web/20090122043044/http://www.advogato.org/article/28.html|archive-date=January 22, 2009|url-status=dead}}</ref>

Unlike more common outline font formats (such as [[TrueType]] or [[PostScript#Font handling|PostScript Type 1]]), a Metafont font is primarily made up of strokes with finite-width "pens", along with filled regions. Thus, rather than describing the outline of the glyph directly, a Metafont file describes the pen paths. Some simpler Metafont fonts, such as the calligraphic mathematics fonts in the [[Computer Modern]] family, use a single pen stroke with a relatively large pen to define each visual "stroke" of the glyphs. More complex fonts such as the [[Roman type|Roman]] text fonts in the Computer Modern family use a small pen to trace around the outline of the visual "strokes", which are then filled; the result is much like an outline font, but with slightly softened corners defined by the pen shape.

Since the font shapes are defined by equations rather than directly coded numbers, it is possible to treat parameters such as aspect ratio, font slant, stroke width, [[serif]] size, and so forth as input parameters in each glyph definition (which then define not a single font, but a [[Meta (prefix)|meta]]-font). Thus, by changing the value of one of these parameters at one location in the Metafont file, one can produce a consistent change throughout the entire font. Computer Modern Roman illustrates many uses of this feature; a typical TeX installation includes a number of versions of the font in [[pitch (typewriter)|pitches]] from 5 to 17 cpi, with the stroke widths the same in all sizes (rather than increasing as the font is scaled up). In addition, the Computer Modern typewriter and [[sans-serif]] fonts are defined using essentially the same Metafont file as the Roman font, but with different global parameters.

==Use==
While well-known type designers, such as [[Hermann Zapf]], have collaborated with Knuth to create new fonts using Metafont, the system has not been widely adopted by professional type designers. Knuth attributes this to the fact that "asking an artist to become enough of a mathematician to understand how to write a font with 60 parameters is too much."<ref>CSTUG, Charles University, Prague, March 1996, Questions and Answers with Prof. Donald E. Knuth, reproduced in TUGboat '''17 (4)''' (1996), 355–67. Citation is from page 361. Available online at [http://www.tug.org/TUGboat/Articles/tb17-4/tb53knuc.pdf ]''</ref> [[Jonathan Hoefler]] commented that the Metafont system ultimately became "a technology behind zero of your favourite fonts...Knuth's idea that letters start with skeletal forms is flawed."<ref name="skeletal forms">{{cite web |last1=Hoefler |first1=Jonathan |title=Knuth's idea that letters start with skeletal forms is flawed. But his work is important and had lasting impact. |url=https://twitter.com/HoeflerCo/status/655557339987226624 |publisher=Twitter |access-date=18 August 2018}}</ref>{{Better source needed|reason=This is literally just a tweet.|date=September 2022}}

The Metafont system allows fonts to be processed in unusual ways; in 1982, Knuth showed how it could be used to morph fonts, with a [[serif]] font slowly transitioning into a [[sans-serif]] design over the course of a text.<ref name="The Concept of a Meta-Font">{{cite journal|last1=Knuth|first1=Donald|title=The Concept of a Meta-Font|journal=Visible Language|date=1982|volume=16|issue=1|pages=3–27|url=https://s3-us-west-2.amazonaws.com/visiblelanguage/pdf/16.1/the-concept-of-a-meta-font.pdf |archive-url=https://web.archive.org/web/20200707233644/https://s3-us-west-2.amazonaws.com/visiblelanguage/pdf/16.1/the-concept-of-a-meta-font.pdf |archive-date=2020-07-07 }}</ref>

==History==
[[Donald Knuth]] started work on font creation software in 1977, and produced the first version of Metafont in 1979. Due to shortcomings in the original Metafont language, Knuth developed an entirely new Metafont system in 1984, and it is this revised system that is used today; Metafont has a versioning system similar to that of [[TeX]], where the number [[asymptotically]] approaches ''[[e (mathematical constant)|e]]'' with each revision.<ref>{{cite web|url=http://www-cs-faculty.stanford.edu/~uno/abcde.html#bugs|title=Knuth: Computers and Typesetting}}</ref>

==Example==
The following example creates a closed beanlike shape for the character "B" of a font:
<syntaxhighlight lang="matlab">
%file name: beta.mf
%mode_setup;
% Define a beanlike shape for the character B
beginchar("B",11pt#,11pt#,0);
  % Setup coordinates as an equation system
  y1=y2=y3=0;
  y4=y5=y6=h;
  x1=x4=0;
  x2=x5=w;
  x3=x6=2*w;

  % Define pen
  pickup pencircle xscaled 0.2w yscaled 0.04w rotated 45;

  % Draw the character curve
  % z1 is the same as (x1, y1)
  draw z1..z3..z6{z2-z6}..z5..{z4-z2}z4..cycle;
endchar;

end
</syntaxhighlight>
This yields the following glyph:

[[File:metafont-example-output.svg|284px]]

The above example will be processed with a command line such as:<ref name=grandsir>{{cite web|url=http://metafont.tutorial.free.fr/|title=METAFONT Tutorial|author=Christophe Grandsir}}</ref>

<syntaxhighlight lang=bash>
mf '\mode=ljfour; mode_setup; input beta.mf';
gftopk beta.600gf beta.600pk
</syntaxhighlight>

Then it can be used in a LaTeX file such as the following<ref name=grandsir/> (all files should dwell in the same directory, or the TeX system should be informed about them using appropriate methods):
<syntaxhighlight lang="latex">
\documentclass{article}

\newfont{\letterbeta}{beta}
\newcommand{\otherbeta}{{\letterbeta B}}

\begin{document}
Let's try having a strange \otherbeta\ here.
\end{document}
</syntaxhighlight>
The resulting PDF file should look like this:
[[File:Tex mf beta.pdf|187px]]

==Producing PostScript Type 1 fonts==
There are several tools for converting Metafont programs to [[PostScript Type 1]] fonts. Most make use of [[MetaPost]]'s ability to convert a subset of Metafont's language into [[Encapsulated PostScript|EPS]] outlines, which can subsequently be converted to PostScript Type 1 fonts. Generating vector outlines of Metafont pen strokes is nontrivial, as the Metafont model of a glyph is a raster image and the exact outlines of most strokes are not [[Bézier curve]]s.{{NoteTag|Technically, Metafont ''does'' generate vector outlines as an intermediate step of rasterising a stroke, but those intermediate outlines are tailored to the current raster resolution and non-simple as curves, so they are very far from being usable as Type 1 outlines. An effect of the non-simplicity is spurious pixels on the concave side of a stroke that get a value of 2 rather than 1, however the automatic culling of pictures being shipped out as glyphs in a font normally prevents this from showing up in the final bitmap.}}

* The Polish [[JNS team]] developed [[METATYPE1]]<ref>{{cite web|url=http://www.ctan.org/tex-archive/fonts/utilities/metatype1/|title=CTAN: tex-archive/fonts/utilities/metatype1}}</ref> (based on MetaPost) for creating PostScript Type 1 fonts. Its big disadvantage is that no pens may be used which highly reduces the power of Metafont language. Initially, tool has been used by the Polish [[TeX|GUST]] typeface foundry to produce a modernized and extended variant of [[Computer Modern]], called [[Latin Modern]].
* [[mf2pt1]],<ref>{{cite web|url=http://www.ctan.org/tex-archive/support/mf2pt1/|title=CTAN: tex-archive/support/mf2pt1}}</ref> which is also based on Metapost, was developed by Scott Pakin with some contributions from [[Werner Lemberg]]. It also has several limitations detailed in its manual, the most significant one being the restriction that each glyph must be drawn entirely from closed paths. In order to overcome the limitations of mf2pt1, the EPS output by Metapost can be post-processed with [[FontForge]], which is capable of interpreting complex PostScript paths generated by Metapost from Metafont's elliptic pens, and also capable of removing contour overlaps. Since FontForge supports scripting, this post-processing step can also be automated. This approach was used to produce Type 1 outlines for the [[MnSymbol]] mathematical font developed by Achim Blumensath; MnSymbol was designed as a companion to [[Minion (typeface)|Minion Pro]].
* [[MetaFog]]<ref>{{Cite web|url=http://www.tug.org/TUGboat/Articles/tb16-3/tb48kinc.pdf |archive-url=https://web.archive.org/web/20001005030023/http://www.tug.org/TUGboat/Articles/tb16-3/tb48kinc.pdf |archive-date=2000-10-05 |url-status=live|title=R. J. Kinch, "MetaFog: converting Metafont shapes to contours", ''TUGboat'' '''16(3)''', 233–43 (1995)}}</ref> is a proprietary converter that can analytically convert pen strokes, but it requires manual post processing to eliminate degenerate cases, and it is not publicly available. It can process only Metapost output.<ref>K. Píška, 2004</ref>

The common approach to generate Type 1 fonts with pen strokes remains to generate a high-resolution bitmap and then use an [[autotracer]], implemented by packages such as [[mftrace]]<ref>[http://lilypond.org/mftrace/ mftrace] – a small Python program that lets you trace a TeX bitmap font into a PFA or PFB font (A PostScript Type1 Scalable Font) or TTF (TrueType) font. It is licensed under the GNU GPL. Created by Han-Wen Nienhuys. Versions prior to 1.0.5 were called 'pktrace'.</ref> and [[TeXtrace]]<ref>[http://pts.szit.bme.hu/textrace/ TeXtrace] – a collection of scripts for UNIX that convert any TeX font into a Type1 .pfb outline font immediately suitable for use with dvips, pdftex, acroread (and any many other programs). Created by Peter Szabo.</ref>

==See also==
*[[Ikarus (typography software)]]
* [[MetaPost]], a vector drawing language derived from Metafont

==Notes==
{{NoteFoot}}

==References==
{{Reflist}}

===Sources===
* [[Donald Knuth]]: ''Metafont: The Program'', Addison-Wesley 1986. {{ISBN|0-201-13438-1}}
* Donald Knuth: ''The Metafontbook'', Addison-Wesley 1986. {{ISBN|0-201-13444-6}} <!-- not a typo -->. The [http://www.ctan.org/tex-archive/systems/knuth/dist/mf/mfbook.tex source code of the book in TeX] (and a [http://www.ctan.org/tex-archive/systems/knuth/dist/lib/manmac.tex  needed macro]) is available online on [[CTAN]].
* Donald Knuth: The [https://web.archive.org/web/20110927042453/http://www.tex.ac.uk/ctan/systems/knuth/dist/mf/mf.web Metafont source code] is written in the [[WEB]] programming language, and includes very extensive documentation about the algorithms used in Metafont.
* Yannis Haralambous, "Fonts and Encodings", O'Reilly 2007, {{ISBN|0-596-10242-9}}, Appendix F: "METAFONT and its derivatives"
* K. Píška, "Creating Type 1 fonts from Metafont sources: comparison of tools, techniques and results", in ''TeX, XML, and Digital Typography'' (Springer-Verlag, Berlin, 2004), Lect. Notes Comput. Sci., Vol. 3130, pp.&nbsp;240–56. [https://web.archive.org/web/20170721213643/http://www-hep2.fzu.cz/~piska/TUG2004/piskatb2.pdf preprint]
* Hofstadter, Douglas R., [https://web.archive.org/web/20200707233646/https://s3-us-west-2.amazonaws.com/visiblelanguage/pdf/V16N4_1982_E.pdf "Metafont, Metamathematics, and Metaphysics: Comments on Donald Knuth's Article 'The Concept of a Meta-Font'"] ''Visible Language'', Vol. XVI no. 4, pp.&nbsp;309–338 (republished in Hofstadter's book ''Metamagical Themas'', NY: Basic Books, 1985)

==External links==
* [http://metafont.tutorial.free.fr/downloads/mftut.pdf The Metafont Tutorial] (PDF). Christophe Grandsire, 2004.

{{Free and open-source typography}}

[[Category:Free TeX software]]
[[Category:Font formats]]
[[Category:Donald Knuth]]
[[Category:Cross-platform software]]
[[Category:Declarative programming languages]]
[[Category:Computer-related introductions in 1977]]