Why METAFONT didn’t catch on?

TUG2008, Cork, Ireland

Dave Crossland dave@lab6.com

Introduction: Dave is an international public speaker on software freedom and fonts, he runs a small business doing type design, information design and free software consultancy projects, and is a committee member of UKTUG. He’ is currently studying the Masters programme in typeface Design at the University of Reading, and he’s doing a presentation today on “Why Didn’t METAFONT Catch On?”

Dave: Alright, thank you.


I’m assuming a general understanding of what METAFONT is. It was made by Don Knuth as part of the original TeX system a long time ago - 1978 - its one of the earliest digital type design systems, and as we’ve been in the last few hours its capable of dealing with pretty much any system you can throw at it. Its always been freely available, and its remarkably powerful. But its never caught on with professional type designers. I wonder, why that might be?

There’s an old joke that there are three kinds of people, those that can count, and those that can’t. There’s a serious point to that though - that of type. Not as in typography, but as in psychology, personality type. There is a brand of personality type psychology, “Myers-Briggs” that’s pretty famous and perhaps you’ll have heard of before.

That looks at people in terms of how the use tools - if they prefer to use tools in a cooperative way or a competitive way. And a similar aspect of that trait is our approach to decision making, whether we make decisions more logically or emotionally. Other ways people are different in their personality are to do with their use of language, some people prefer to use more abstract language and thinking, while other people prefer to use more concrete language.

Myers-Briggs has some peculiar words for this, Thinking, Feeling, Sensing, Intuiting, and that gives those preferences little one letter labels.

It also takes into account other things, attitudes to socialising, if you feel after a dinner party drained or energised. And also attitudes to time keeping, if you prefer to be more flexible or punctual. Again, there are these jargon words for these preferences, Introverted Extroverted, Perceiving, Judging. And you put these together into a system, which gives 16 personality types.

There’s a book called “Please Understand Me 2” where some psychologists put this together in a cohesive system, and grouped those 16 personality types together in to 4 temperaments. To make those a bit more understandable, they used Greek Gods to personify those temperaments. So they had a class of Dionysian “Guardians”, another set of Apollonian “Artisans,” and Epimethian “Idealists,” and TeXXies, er, Promethean “Rationalists.”

This is a broad theory for how people are different, and perhaps you can’t take it too far, as ultimately people are all pretty much the same - what one man can do, another man can do - but there is definitely a sense that there is a certain set of the population who tend to be more abstract in their language and thinking and more logical.

Software is pretty logical and abstract, and the people who get into software related things tend to be of these personality types, and free software - the free software movement, specifically - has that kind of draw. And TeX programs also tend to have that kind of approach, as does METAFONT.

But type design is probably not very abstract and logical. Its to do with shapes, spaces between shapes. Its visual, or concrete, and its more emotional than logical.

The kind of people who tend to do type design are not the kind of people with backgrounds in software engineering.

So, I want to go into type design from less of a software engineering perspective. Design happens at various scales at the same time, and type design is no different. At the lowest level, the letter, you are dealing with the black shapes of the letter, its obvious what that is, and then there’s a kind of optical trick where you shift your focus to the white shapes in and around the letter. You can imagine a letter being inverted so the black is white and the white is black, to bring this shape out in to focus.

At another level, you have words. In words there is not only the white shapes inside a letter, or around a letter, but the shapes between the letters. Another things at the word scale is managing the black shapes across letters, the things that look similar (although are not exactly the same.)

You can see here a lowercase n and h. These are similar shapes, but if you look between them, you can see there are slight differences. Between all the letters, there are regular aspects, and some of the earlier presentations today talked about archetype shapes used to construct letter forms out of. Managing letters that are similar is a core aspect of type design. There are strong similarities between various kinds of letters. The letter s is perhaps the most different, and Don Knuth wrote an interesting essay about that.

Going up another level, to paragraphs, where you have paragraphs set and you have a different impression of the letters, you get emergent visual effects, and you have to take that into account when designing the other levels. For example, a ligature, you are dealing with the spaces in and around the letters in a precise way, and this effects the way that a paragraph of will look at a subtle level.

That is what typeface are. So what is a font? What is the difference? Its a subtle distinction: A font is a typeface implemented in software. You can have the same typeface implemented in a metal typesetting technology, and in software, and in… potato? Whatever one you print with, the letters will look the same.

Software is programs and data. Fonts are a peculiar kind of software, because they include programs and data in the same thing, whereas there is normally a big separation between them. Examples of font programs are TrueType hints and OpenType features, and font data is the glyph point data and metrics table data - which is pretty much what the typeface design is.

How are typefaces implemented in software? There are really just two approaches that have come out of the last 30 years.

One is the outline or “Fontographer” approach, where each letter is drawn - visually, interactively - and this is a direct translation or facsimile of the analogue shapes of the letters. Its really good for implementing existing type designs. The AMS Euler project is a clear example of this, where they had an existing design to be digitised, and the best way to do that was to trace the outlines. FontForge is a really great font editor that is free software for doing that.

The other approach is the “METAFONT” approach where you have this stroke and pen idea, and the previous session covered how that goes, where each letter is constructed, by writing source code in an algebraic programming language. That’s an unusual kind of programming language, and its not visual, and its not very interactive. Its abstract and logical. Its not a direct translation of what you do on paper, its “digitally native” - the whole thing is created digitally. This is not great at implementing existing type designs, but I think it could be great for developing new type designs - where its not sure what it is, the look you are trying to get.

MetaType1 is based on MetaPost, a modernisation of METAFONT. As we heard yesterday, the developers are continuing to do good work on that. Its also a very abstract and logical approach.

TeXWorks takes a different approach to TeX typesetting; instead of being very abstract and logically minded, its a little more visual and interactive, because the cycle between writing the TeX code and previewing it is quicker. The SyncTeX technology really helps with that. It makes TeX a little more concrete, a little more emotional.

I wonder if METAFONT style type design technology could also be more concrete and emotional. We’re going to need some kind of canvas that looks nice - Cairo - and splines that have smooth curvature, and Raph Levien has developed a spline format, Spiro, that guarantees very smooth curves, and I encourage everyone to look at that. Its integrated with Inkscape recently, and I hope that it will be featured in the next version. FontForge has recently been restructured so that its a regular kind of C library - “libfontforge.” And we’ll need an object model for fonts, and the RoboFab project has really done some great work thinking out the object model of what a font it. I’d also like to see this done with a framework that allows real time collaboration, so several people could sit with their computers and work on the same glyph or font at the same time, as if you were sat around a big bit of paper, scribbling, and there’s a framework from BBC R&D, Kamaelia, that is powerful and seems useful for this. And I’d also like to see distributed version control there too, if it was fast enough that you could record every step in the design process. Like git.

I think font development is very much a piece of software engineering, and I think type design could benefit from aspects of the software engineering approach, even though the ways people do type design tend not to have those aspects - software engineering is much more logical and abstract, and doesn’t seem to be obviously related to type design. But I think there is at least something in there.

I tried to make this quick, so, questions?


Q: The designer is meant to write stuff? You need a font designer, I think. They are artists. They cannot write this only with programs…

A: Right. I think what I’m trying to say is that the METAFONT approach, if it was visualised much faster, could work for them. At the moment, you write the MetaPost or METAFONT sources, and you run a program to compile or generate images. That whole process, its not real time. Whereas say in TeXWorks, in real time you write the TeX document source, and generate the PDF instantly, and there is a very quick cycle between writing the code and seeing the result. I think bringing that approach to MetaPost style graphics would help people who are more artistic to take a more engineering approach.

Q: Since you are a software writer and a type designer, when are you going to release this?

A: LOL Okay, I’m actually not a software developer. I studied fine art, then graphic design, and now typeface design at the University of Reading. But I am also working part time, and am looking to hire someone to write this software. A friend of mine in Portugal, who was presenting similar work he did in Holland, at the Libre Graphics Meeting, a free software conference for Graphic Design that was in Poland recently, so I’m hoping to hire and work with him on producing this software. This is very much a vapour-ware kind of presentation, but, no, I’m serious about doing this. If anyone wants to help, then send me email!

Q: Visualisations of METAFONT have existed for many many years.

A: :-)

Q: METAFONT is good because of its META-ness. I did my Minion Math fonts with MetaType1 and there are 20 or 30 possible variations possible. How do you propose to visualise these variations? I have one font program in MetaType1 and 20 variations to be shown on the screen.

A: Sure. In your preamble you have your variables that you use to calibrate the following METATYPE program that generates one of those 20. But that is sometime into the process, and I’m talking about the beginning of the process where you are designing new shapes, where you don’t know quite what shape it is you are looking for, and you want to tweak those variables and see what different things look like. Doing that in the outline approach is quite laborious, and using the METAFONT approach of the stroke-pen gives you access to other forms quicker, and that’s a better approach. The sophisticated abilities in METAFONT for dealing with large families of type is great, but I’m talking here about type design, the designing of shapes.

Notes from the Kamaelia talk at BBC Mashed

These are rough notes from a public event, and any errors or stupidity should be attributed to me and my poor note taking; I hope these notes are useful despite their obvious flaws, and everything should be double checked :)

Kamaelia is an awesome framework and doesn’t get anywhere near enough recognition, and I have enormous respect for the project lead Michael Sparks although we disagree on a couple of things :-)

Kamaelia at Mashed, 2008-06-21 12:20

[20 mins late :( ]



This is a pyGame window that visualises the program! You can see the program is made is discrete individual chunks.


This has a simple pipeline, like a UNIX pipe, which links together these boxes - like hardware and mashups. Whats inside a box?

It has a ConsoleReader() that takes input and pushes it to an outbox. The original concept is network servers, and things are non-blocking there, so they are here too. Note that python “yeild” is not the same as Ruby’s.

So how do you write a component?


This is a Webcam exmaple: It uses pyGame for display, and starts with getting a display, getting a camera, taking images, and finally displays them. its simple and fun :)

But not massively reusable. Its just a mirroring thing, right? So then we make it a threaded component; you can see the changes from a standard python object class to a ThreadedComponent one in this file, and we separate out flipping the display; thats a global thing that we want to reuse. (You can only have one display in pyGame because its a limitation of SDL.)

To turn this component into something you can re-use, you need to have it spit the output out, instead of keeping it internally. This makes the code a lot simpler, so you just have something that captures the image and puts it into an outbox.

Now that it is a component, you can use the inbox of any other component to process that outbox; a diplayer, a video encoder - anything. So you make a displayer component, that is simplified too, although maybe won’t play nice with other concurrent components, so could be improved.

“Here’s one I made earlier.” A metaphor for components is someone in an office who needs to know something: they go and ask someone. This code goes and finds who is displaying things, and uses their outbox. This is a complex example, since it looks for other components in the system globally, and then asks them to do something.

Axon is like the Linux kernel, its the very low level stuff, and then Kamaelia is the bulk of the components itself, like GNU, that completes the system and makes it easy to do things.


This is a TCP server instead of a GUI display. The CookBook on the wiki has great examples; the SimpleBittorrentExample page was written by non-BBC people, and its great. You can use all the components in the same system if you want.


This is a silly exmaple, with just 2 components. What happens if you bolt a webserver onto it? Well its easy, you can have a webpage to upload images and add them to the bouncing caracel - that becomes straightforward to do with Kamaelia.

So that is how you build systems and wire them together.

Kamaelia Macro

This records and transcodes what is broadcast over DTT, for future viewing. Timeshifting is perfectly legal, you just can’t redistribute the data legally. So you can build you own home ‘redux’ system easily using the Macro example. It also has a method for ‘Finding Programme Junctions’ and transcoding to any format, using a ‘pipe through’ to mencoder. If anyone can build a redux this weekend, that would be awesome; you could make it controlled via IRC easily with our IRC component, loads of fun stuff.

Kamaelia Grey

This is an email greylisting server, and this is what Michael uses personally at home, and it works very well. Greylisting works with 3 pieces of information: who they send it to, who they claim to be, and what IP they are using. If any one of them hasn’t been seen before, it asks for a SMTP resend, and most spam doesn’t resend, and if it gets a resend, it accepts it. This has eradicated Michael’s spam!

The core is GreyListServer, with a TCPserver inbox which is a Selector. Someone connects, Selector tells the TCPServer, and that opens a new GreyListServer instance. It you have a large number of connections at once, the Selector handles that with ease. The 3 main components of the greylisting core are GreylistServer, ConnectedSocketAdapter and GreyListingPolicy. These 3 things create a factory for handle new connections.

New Release

There is a new release of Kamaelia today, anyone can contribute to the Ideas page on the wiki, please do. Someone making a homebased redux system for recording everything is possible: 1Tb harddisks are now only £70 and you only need a cheap laptop worth of processing power…

Q: Repository format?

A: We use SVN. We allow people to make branches with their names, and have a ‘Sketches’ tree. The 3DFolding one is in the MH/OpenGL dir. There is a handwriting recognition component which works pretty well (StrokeRecognition.py) and a speech generation component too! And you can join these together as they are just components. GP2X with the stylus input, you could make a ‘speak and spell’ easily enough: It could say “Spell the word Cat” and then recognise the hand writing. [Someone actually made this at Mashed!]

Q: License?

A: Mozilla trilicense: MPL1.1, LGPL2.1, GPL2. Boils down to, change our stuff, share it, write your stuff, don’t have to share. Mozilla was chosen because of an explicit patent grant, in case the BBC went to patent some of these stuff. And it protects recipients of the code too.

Q: Whats the relation between redux, pandora, macro?

A: Pandora was made by some brothers; they were commissioned to make Macro for the BBC. Tom Loosemore then wanted to replace the backend; he heard Radio had a system for transcoding everything from radio for podcasts. So that needed a lot more efficiency for video. Redux was a different thing at the same time, that doesn’t transcode. But this was great for us so we could focus on the opimisation of things, such as zero copy transfer between components. So now implementing redux takes a day!

12:50 end

GNU Hackers Meeting 2008 Notes

These are rough notes from a public event, and any errors or stupidity should be attributed to me and my poor note taking; I didn’t get much sleep last night since my talk at the event was at 09:30 this morning, and I was just traveling in France to research my thesis and had to catch up on email and stuff, so the notes are less thorough than I’d’ve liked. But videos of the talks are available at http://www.river-valley.tv and some photos at http://www.espontaneas.com/album/h/buscar/gnuhm2008 so not to worry too much about that, you can watch them yourselves :-)

It was a great meeting with a lot of smart and interesting free software hackers, and I’m sad I missed the first day because I was in France.

Distributed Version Control

Ian Jackson


Distributed VC makes it easy to deal with things when people disagree with you. We are all sometimes wrong and it helps when the discussion about who is right and wrong isn’t interfered with.

Git is very popular; rcs, svr, &c, tla, are all basically dead in 5 years. CVS/SVN are still going, and the DVCS that aren’t git are not all that popular.

Git: Very different to the others; most people here have used it, it is very popular.

Bzr: Bazaar is a marketing term, a totally different system to bzr. Baz was a fork of TLA (formerly Arch) and Bzr is a totally new VCS with all new code. Its similar to Mercurial Darcs and Monotone.

rsync is a strange kind of version control - and you will need to 2nd

Q: Git is fine; moved from CVS to Git

A: A lot of people who tried that got stuck, git was linus’ ideas and it doesn’t resemble CVS. Eg, you are using git and want to commit, “git commit -a” and “git diff” before you do that check-in, but that might not show everything. If you edit a file and you want to throw them away and replace with the repo version, you use “git checkout”. That’s okay if you want to learn the quirks, but if you want to sell someone a version control system, they don’t want to learn.

Fortunately, all the rest do have a user interface that is roughly the same. But all 4 have some killer disadvantage.

bzr is very slow on huge projects; its great for a tiny little project of your own and your friends. bzr won’t blow up if you type strange commands at it.

hg is slowish, and the way it handles tags strangely.

not used the others enough.

Q: darcs v1 documentation had ‘exponential corner cases’ but v2 was fixed them. great UI though.

Q: Monotone also quite slow

So they are all playing some kind of catchup game.

So these Big 5 are all in a good usable state, more or less (big projects need git…)

We like getting our patches upstream, and upstream have an important gatekeeper role, but DVCS can mitigate the bottleneck problems there…

You have more downstream effort in most projects, Linux kernel has most effort up, and its strange requirements have an effect on Git.

Bzr has a bunch of propaganda about merging instead of emailing patches like git; that works well with DVCS. You can maintain two main trees and constantly merge from one to the other.

You can use bzr for a small project, and in 5 years time, there will be a wrapper for Git so you can easily switch up if you become big enough. If you are a big project, you should pick git.

A chief selling point of Git is that if you disagree with someone using another VCS tool, you can mirror their repo into your git.

Distributed means branches are cheap; non-distributed VCS don’t track what has been merged, and its very tedious to make a new branch. When branching is really easy, you make them all the time - make a branch, mess some stuff up, an urgent bug fix comes in, switch to the main branch and fix it, switch back to the messy branch, carry on. With CVS you can get very big merges and its a real pain. You do it once a month, because its such a big job. But with DVCS you do it daily.

No need for in-tree change logs with DVCS, an in-tree list would be a feature list.

Ian wants to write a wrapper called VCS that means they all have the same interface.

All the Big 5 are stable enough for real work, although they are in active development.


All use commits that are hash based, and hash collision with tags is unlikely.

gitk is a GTK git repo viewer.


Sylvian B


Game programming system under the GPL

FreeDink is a game, the old isometric style of Zelda. You start off as a pig farmer, and you learn how to fight, and increase your skill points.

DFArc2 is a game manager, and there are many games made by users. There is a map editor.

History: There was the Dink project in 03/04, was portable but buggy, and then Dink v1.08 2006-now that’s windows (woe) only and has backwards compatibility problems. GNU FreeDink forked from original Dink, was X11 like but now GPL. The first port was not well documented, the new project has a good task list and docs: Compiler, 2D graphics (stretching, full screen), Fonts, Sound (sample rate conversion for slowing/speeding up sounds)

Progressive migration; continuous testing so nothing was broken for too long. MinGW allowed a switch from MS VC++6 to GCC. SDL is a simple DirectMedia Layer, portable but not equivalent to DirectX, so needed to reproduce

Fonts, was hard to get things pixel-same, using FreeType to draw direct on screen and using the Liberation fonts for their metrics compatibility.

For portability, MinGW can be used as a cross compiler to create .exe from GNU/Linux. This meant there was no need for cross platform tool chains, and autotools, git and wxGlade were fine with cross compiling but they are available but trickier on Woe normally.

xdg-utils was used to make the DMOD files, which are really .tar.bz2 files, recognised as DMODs instead of by file-roller.

Q: I just compiled freedink, but it came with no DMODs?

A: In the docs directory, you can find data.txt, that explains.

GNU Epsilon


Luca Saiu positron@gnu.org

Learned ML, Lisp, Haskell; in 2001 did a toy implementation, in 2002/3 it became more ambitious and I reimplemented it all, making me a better functional programmer; and submitted it to GNU and it was accepted. In 2007 I moved to France, did the 4th implementation and 3rd garbage collection.

I spoke to many people here and everyone seems to know Lisp ;)

Why don’t more people do functional programming? It looks and is different; its reputedly inefficient although not always true.

The language should be layered; a core language that is layered, untyped (so unsafe), and without continuations, lambdas, side-effects, the only conditional being case, and user definable primitives.

The middle language is translated into the core language; its a middle layer of abstraction still not user-facing. Its more lisp like with first class procedures and continuations, side effects, and programs are written as s-expressions.

Top language default will reflect my own tastes but the developer can override all my preferences or do something totally new.

Q: Alan Kay’s “Reinvention of Programming” has a layered language similar to this; he wants a complete graphic OS in 10,000 lines of code. Is epsilon useful for system programming?

A: Lisp and OCAML are useful for system programming. … I want to get the design just right before I recommend it for that kind of use though.



Juan Pedro Bolivar Puente

A winning project in a Spanish students’ free software projects competition.

Its an audio synthesiser. Its an electronic device to make sounds, specifically sounds for music. The concept is modular, interactive, collaborative.

Modular: Breaking sounds into modules that are used to build a soundscape.

Interactive: It has dynamic patching, where modules are connected automatically depending on their relative position and kind of signal. Multi-tactile interfaces give more control over more kinds of input at once.

Collaborative: But there are still too many parameters to be controlled by one person. This can be a single physical interface for several people, or a network to connect several small interfaces.

The reaction to multi-tactile interfaces is “reactable is so cool, I want one” but the free software approach is to Do It Yourself. But the table, camera and projector are expensive; the prototypes are written in Pure Data which is fine for that but not extensible or scalable.

Implementation: We have generators, they generate source sounds, like basic waves (sinus, square, triangle, sawtooth, etc) and noise (white, pink) and samples (where you can change the pitch, run backwards, time stretch, etc)

PsychoSynth3D screenshot

30,000 lines of C++, 7,000 change a month, GPLv3 throughout, the Reactable staff are interested in the project and rewriting in C++ also.

We have got mac/windows music making guys think about free software. There are really good free software audio programs but they have the UNIX philosophy where configurations are used to pipe things together - but this has a more integrated approach, so now people who wanted to buy the Reactable now install psychosynth.

Future: A lot of feedback in a short time.

A lot of people want a port to proprietary platforms, but this is not a priority for me. But its free software! :)

Q: Can you save the scene graph state or even record the whole thing like a Quake demo?

A: Its a planned feature to add soon

Q: How does the network stuff work?

A: We only transmit the events with Open Sound Control low latency protocol, the samples have to be on the clients beforehand.

Q: Have you tried with people not in the same room?

A: The current implementation wont work well over the net, but on a LAN it works great

Its Not The Gates, Its The Bars

Richard Stallman got published by BBC News, writing about Bill Gates’ final retirement from Microsoft. Sadly the BBC continues to require proprietary software to access its services.