Michael,

Metafont can only produce bitmap fonts which is a severe limitation. Nowadays, people usually create outline fonts since they are scalable and usable in different resolutions. There are tools that convert .mf to Type 1 or TrueType but this is done by autotracing which results in rather poor quality.

There is a related product called Metapost, created by John Hobby, which allows parametric creation of PostScript graphics. This was later extended by Boguslaw Jackowski, Piotr Strzelczyk and Janusz Nowacki to MetaType1, an outline-based parametric font creation system. However, just like many other parametric font creation systems (e.g. Font Chameleon, Infinifont, LiveType), it never gained the necessary momentum. With no professional support and no solid user interface, the tools for creating these sorts of fonts were never able to reach a broad user base. Even Multiple Master fonts that had good user interface tools (Fontographer, FontLab) were dropped because handling them turned out to be too complicated and the revenues were too limited.

Developing mature applications is a long and laborous effort. The commercial market is difficult, which is visible with the fact that numerous efforts such as Fontographer, FontStudio , TypeDesigner or RoboFog “died”. The open source community is too weak to develop a good specialty tool of that sort (open source projects work well with mass products such as Mozilla or OpenOffice, with hundreds of engineers working in their spare time or on government/organizational funding).

Today, with the exception of DTL FontMaster and FontForge (which is free), FontLab is the only font creation application that is actively being developed. First version of FontLab was created 12 years ago and in that process, we have learned that a good user interface is crucial to a success.

Font creators are mostly designers, not engineers. They need visual tools. Also, type is often too subtle to rely on parametric creation. While it would be tempting to re-use the exactly same shape of a serif on n, m, i and l, often, subtle changes need to be made for best effect. The more subtle and refined the letterforms get, the less the parametric approach is useful. Donald Knuth’s Computer Modern isn’t a particularly well-designed typeface and frankly, I have never seen a good typeface made with Metafont.

When people make a profession out of creating type, i.e. they make their living on type design, the issue of a tool being free becomes less relevant. Also, tools such as Metafont are only nominally free. There are no licensing costs but there are substantial costs of maintenance, support and learning. The learning curves are steep, the user communities are small and not integrated, there is no professional support. Therefore, if you work with tools such as Metafont, you’re often left on your own. This is a fact often overlooked by those who advertise free or open source software.

There is a good selection of links about parametric font creation at:
http://www.myfonts.com/activity/parametric-fonts/

Regards,
Adam

Many type designers come into type design via the world of Graphic Design, which is more visual than not. Before beginning to draw letters, many of us were already fluent in vector applications like Illustrator and Freehand. Because of this, I personally view something like Metafont as having too steep of a learning curve. Besides, I don’t see what benefit it would bring.

Also, it may be noble that Metafont is a free standard, but I would rather support companies like FontLab, who I also think is noble even though it is a commercial entity.

The same goes for Apple, actually. I haven’t ever had any doubts about shelling out the higher prices necessary for their hardware and software. I feel like I’m getting good value for my investment. I also learned design on Macs in the early 1990s, and can remember a time (even though I was just a teenager) where there was still alot, design-wise, that one couldn’t do as well on a PC. Apple and the modern graphic design industry built each other up. Almost symbiotically, if you will. I have never used TeX, and doen’t know of very many designers who do.

You are certainly welcome to design with Metafont. I’ll bet that you can even get tips and support here on Typophile! But it isn’t the direction that the industry seems to be going in (or has been going in for a decade and a half).

FontLab, especially when used in conjunction with Python scripting, is a rather powerful tool as well. But I don’t have the requisite knowledge necessary to make a comparison between its capabilities and Metafont’s.

Dan makes a good point. FontLab (http://www.fontlab.com or http://www.pyrus.com ) in connection with Python (http://www.pyrus.com/Font-utilities/The-Python-Page/ ) and most prominently RoboFab (http://www.letterror.com/code/robofab/ and http://just.letterror.com/ltrwiki/RoboFab ) provides a convenient blend of visual design and a programatic environment.

Adam

Why does nobody use Metafont? FWIW, I reckon the main reasons are:

• Metafont programming is difficult;
• Metafonts can’t be converted to Type1 or TrueType, so they can only be used with TeX;
• (Related to the above) Metafonts can’t be sensibly embedded in PostScript or PDF files so that they look good on screen.

Actually I tend to regard Metafont as an interesting failed experiment. The original idea, that a family of type could be constructed by essentially mechanical means from a single source, turned out to be much too naive (as the Metafonters discovered when they got Zapf’s drawings for Euler, and saw that the bold glyphs were not simply the regular ones with thicker strokes!)

In Knuth’s original AMS article on typesetting, he appears to imagine that one could discover a precise mathematical description capturing the Platonic essence of each glyph, and that different typefaces could then be instantiated by setting appropriate parameters.

All that said, it would be very interesting to see what an expert tech-savvy type designer could do with the framework. It’s clearly a very bad way to digitise existing designs, but I’m sure something novel and interesting could be made by taking its strengths and limitations into account. Sadly there is no real incentive for such a person to try, until somebody works out a way to convert the result into a font format that could reasonably be offered for sale.

Parametric font design can be HUGE, but only if:
1) It’s based on outlines and not skeletons;
2) It has a decent GUI.

There was once something along these lines called Font Chameleon (for example it let you change the x-height of a design with a simple slider!) but I don’t know what happened to it.

hhp

Please be kind, this is my first posting here.

I have used MetaFont for around a year now, and there are a few misconceptions. Indeed, MetaFont is a programming language (which is, BTW, well-documented in the MetaFontBook by Knuth) and there are relatively few fonts for it. However, with the use of other utilites include a lovely little utility called MFtrace and FontForge, it is possible to create a complete family as any FontForge format (TTF, OTF, PFA, etc.). For further information on tracing of MetaFonts, look at the Lilypond project ( lilypond.org ).

If anyone is interested, I can post some of my MetaFont work (it’s not great, but it might give an idea).

Adam, I just now noticed that you mentioned autotracing. It is worth a look at Lilypond to judge its quality yourself.

-ray_theray

Metafont was mind-blowingly advanced when it was first developed (most people forget how much of a debt digital typography today owes to MF and TeX), but the real problem is that it has gotten hardly a whit of new development since John Hobby graduated and moved on. The lack of any sort of GUI is an absolute killer, and the lack of good export to widely used outline formats also hurts deeply.

Both problems could be addressed, but haven’t. I consider autotracing of bitmaps to be a bandaid rather than a practical solution for working type designers. A proper conversion requires the ability to compute offset curves and boolean operations in cubic Bezier space, which is pretty much rocket science (as it happens, you also need both of these operations to emulate Benton optical scaling, so it’s likely I’ll write and release code, at least for the primitives).

I haven’t done enough actual work in Metafont or FontLab (with its Python scripting hooks), but I have read the relevant documentation for both, and suspect that the latter has in fact come close to replicating what Metafont had almost twenty years ago. Of course, this time around there’s a decent UI and a viable support community, which is, as Adam points out, much more important than pure technical achievement.

Metafont and FontForge may be “only nominally free” in the sense of money changing hands, but freedom in the sense of free software is a different beast altogether. One of the main advantages is that, for all its weaknesses and the difficulty of climbing a learning curve, it won’t die just because its creators go out of business. Of course, without a viable community around the software, that’s more of a theoretical than a practical advantage, sigh.

I can definitely agree with that. MF does indeed lack new development (with perhaps the exception of Omega, which itself only has slightly more interest). As a programming curiousity which appeals to those who can “procedurally” produce fonts (like CMR or Lilypond), MF is useful.

I will also add, as an amateur font enthusiast, many people in this community will have a greater insight into good and bad font design (including things like autotracing) than I. I appreciate your very objective and well-defended arguments. Perhaps I might even snag a look at some modern font utilities ;-)

Jacob,

for anybody interested in creating parametric fonts using the MetaFont paradigm, I recommend looking at MetaType1. It is a package developed by Boguslaw Jackowski, Piotr Strzelczyk and Janusz Nowacki, with some recent support from Johannes Kuester. It is based on MetaPost by John Hobby. MetaPost uses a similar concept as MetaFont, but its output is PostScript code (real outlines), not bitmaps. MetaType1 turns this arbitraty PostScript code into Type 1 code, also allowing adding hints and other font-only related information.

MetaType1 was presented on several TeX conferences:
http://www.ntg.nl/maps/pdf/26_15.pdf (paper)
http://www.ntg.nl/eurotex/JackowskiMT.pdf (slides)

The big difference between MetaPost+MetaType1 and MetaFont+MFtrace is that using MetaPost+MetaType1, you don’t do autotracing but work on actual high-quality outlines all the time. MetaType1 has been used to create or extens several fonts, most of them available free of charge from: http://www.gust.org.pl/fonty/

You can get MetaType1 from http://www.typoma.com/en/projects.html

Regards,
Adam Twardoch

coming too late, but I have to say something about. The reason why MF has not taken off is explaned by Knuth himself: "asking an artist to become enough of a mathematician to understand how to write a font with 60 parameters is too much.".
MF is a totally different, not visual, approach to font creation. And nowadays the visual approach, the WYSIWYG is mostly preferred.
There are some misconception I would like to correct.
MF output is bitmap. Exactly in the same way all scalable vector graphics is bitmap once "produced" and displayed or printed. But usually you don't see the process and the file describing the font is considered the "final" resource. The Metafont source(s) for a well designed font should be considered the same way and so Metafont source(s) is the "final" resource and the font is scalable (provided it is well programmed).
If you don't know the resolution of the target device where your text will be displayed, you have to distribute the MF files - altogether with the document that is going to use that font and metrics tfm files.
So a correct setup and software combination can produce high quality "texts" for any device at any resolution (don't forget the files original TeX produce are called ".dvi" that is DeVice Independet: the only device dependent part is the font itself!).
The problem is that for sure such a system is not good for desktop displays, nor for web. It could be good for typography, having well designed fonts (and as said it is hard to design fonts this way, harder than using a graphical approach), but there are other "problems", for example it is surely faster to "convert" a ttf glyph into bitmap to display (there could be even some sort of hardware aid!) than generating the whole "metafont" bitmap fonts at the needed resolution.

Another note: most of you when you say "parametric" seem to think about font parameters you can change programmatically. Indeed, the whole design of your font can be parametric, helping you to give consistency to a family and also to obtain rther different fonts from the very same source.

Speaking of Lilypond, they’re now in a process of switching from autotracing to direct conversion from MetaFont sources to PostScript Type 1 with a tool called MF2PT1. It’s a Perl piece of code that uses MetaPost for PostScript output plus Type 1 Utilities and FontForge for font assembly and some post-processing. The overall idea is similar to MetaType1, but as far as I can tell the restrictions are less severe.