RoboFog

The idea of a programmable font editor goes back to RoboFog, a Python-powered version of FontographerA font editor originally developed by Jim von Ehr’s Altsys, later acquired by Macromedia. The source code was acquired by FontLab in 2005 and upgraded to modern standards. produced by Petr van Blokland in the early 1990s.

Fontographer

Petr had worked on the development of Mac IkarusA Mac version of the font digitizing software Ikarus. Also known as Ikarus M., and had also attempted to create his own font editor – that proved to be a very difficult task. He realized that, instead of writing his own font editor from scratch, he could start from an existing one and make it programmable.

Thanks to work contacts at the Font BureauDigital type foundry based in Boston, United States. Founded by David Berlow and Roger Black in 1989., Petr gained permission to use the old Fontographer codebase as a starting point. With Just van Rossum’s help, he managed to compile Fontographer together with a Python interpreter, and built an API so that the program became scriptable – RoboFog was born.

RoboFog splash screen

RoboFog was very successful within its niche market. It included a small toolkit for creating custom UIs in pure Python. Users had a lot of fun with its features, and used it to build tools which were very useful for their workflows.

Altsys was acquired by Macromedia in 1995, and Fontographer development slowed down after version 4.1. Macromedia was later bought by Adobe. There were important font technology developments around that time, for example Unicode and the new OpenTypeAn extension to the TrueType sfnt font format that allows for either TrueType or Postscript outlines to be used.

OpenType fonts can include layout tables for advanced typographic features, color font formats, and variations. The format is developed jointly by Microsoft and Adobe.
font technology. Fontographer quickly became obsolete, and its user base gradually moved to FontLab.

DrawBot

DrawBot was originally developed by Just van RossumAn independent type designer, graphic designer, software developer and teacher. Original creator of FontTools and DrawBot. as an educational tool for teaching programming to designers, and has grown into a full-fledged platform for automating the creation of all kinds of graphic material.

RoboFab

FontLab was created in the early 1990s by Russian programmer Yuri Yarmola and distributed by the US-based company Pyrus. By the end of the decade, many type designers had moved from Fontographer to FontLab. Yuri was looking for a scripting language for FontLab. After meeting with Just van Rossum in 1997 and seeing a demonstration of RoboFog, he integrated a Python interpreter and added a low-level Python API to FontLab 4.

On top of that basic API, Just van Rossum, Erik van Blokland and Tal Leming developed RoboFab, a pythonicIdiomatic Python. Code that doesn’t just get the syntax right, but also follows the conventions of the Python community and uses the language in the way it is intended to be used. API to FontLab’s native objects. RoboFab was heavily inspired by RoboFog and their APIs were very similar. A simple toolkit for creating UIs in Python, dialogKitA dialog toolkit in Python that worked across different font editing applications. Created by Tal Leming. (deprecated), was also created. All together, this allowed designers to port their old RoboFog scripts to RoboFab.

RoboFab object map

RoboFab also made it possible to write scripts to modify fonts outside of any font editor, using only Python, RoboFab and UFO – for example in Terminal or in a code editor. This ‘non-environment’ became known as NoneLab. There were many limitations though, as several specific tasks – overlap removal, font generation, hinting, etc. – still required a font editor.

The RoboFab package was distributed freely under an open-source license and worked in both Windows and Mac versions of FontLab. It had a pretty website with very complete documentation and a colourful font object map. RoboFab became popular among font makers and helped them create useful tools to get work done. The RoboThonA conference about Type, Tools and Code presented by the TypeMedia department of the KABK (Royal Academy of Art, The Hague). conferences were key to making RoboFab known to a larger group of type designers and font production people.

FontTools / TTX

Another important milestone in the Python font world was Just van Rossum’s FontTools/TTX package, released in 1999 as an open-source project. FontTools is a library to manipulate binary fonts in Python, and TTX is a command-line tool to decompile OpenType fonts into XML and back.

FontTools proved to be extremely useful for mastering and debugging OpenType fonts. Development started to slow down around 2004. In 20XX, while working for Google, Behdad Esfahbod and contributors picked up development, added support for more OpenType tables, fixed many bugs, and added new tools to subset and merge fonts. The project also got a new logo and a much needed documentation in 2020.

UFO

Origins

What would later become UFO started in the mid 2000s when Just and Erik were collaborating on a font project while living in different cities, and needed a way to share glyph data during the project. They were using a version control system for their code, so it was natural to use it for the font data too. They came up with a text-based format to describe glyph data, one glyph per file, structured as XML. This format proved to be very useful, and they teamed up with Tal Leming to develop it further, adding support for meta info and metrics data, and improving the glyph format. A proper format specification was also made, and UFO 1 was published in 2004.

UFO-based workflows

Tal Leming’s UFO Central tool made it possible to import and export UFOs to/from FontLab. What started as a version control format gradually developed into a data exchange format – a way to transfer data back and forth between FontLab and UFO-based font applications like Metrics Machine (more about it below).

Over the years, UFO has also proved to be a good long-term storage format for font sources. Using a human-readable XML format ensures that data is accessible even after editing applications stop working.

UFO updates

As more and more designers and tools started to use UFO, and with several new developments to the OpenType format, it became necessary to update and improve the format. UFO2 was published in 2009 at the RoboThon conference, and Tal Leming was officially appointed editor of the UFO specification. The process continued with UFO3, published 3 years later at RoboThon 2012, and goes on with UFO4 (currently under development).

Open-source libraries

With FontLab + RoboFab established as the central environment for drawing and generating fonts, in the mid 2000s the focus shifted towards developing specialized libraries and stand-alone applications.

Independently or in collaboration, Just, Erik and Tal Leming developed a set of open-source code libraries for building font applications, establishing the foundations on which RoboFont stands until today.

vanilla

The first of these libraries was vanilla, a toolkit for creating native macOS interfaces in pure Python, inspired by the classic W library from RoboFog days. Vanilla provides Python wrappers for all the main macOS UI elements such as windows of different kinds, buttons, sliders, text input fields, list views, tabs, and lot more.

Vanilla made it possible to build native macOS applications entirely in Python, bypassing the need to use Apple’s Interface Builder or Objective-C directly.

defcon

Then came defcon, a set of lightweight, fast, flexible UFO-based objects for use in font editing applications. Different from RoboFab, which was originally created around the scripting API of a particular application (FontLab), defcon was written from scratch with the purpose of building apps – its objects include built-in functionality such as observing notifications and caching data.

defconAppKit

Along with defcon came defconAppKit, a separate library containing reusable UI elements made specifically for font editing applications – things like a glyph cell, a font info sheet, a text preview area, etc.

mutatorMath

Based on Apple’s TrueType GX variable font technology, Erik van Blokland created MutatorMath, a Python library for building complex interpolation systems, and the engine behind his Superpolator app (see below). The MutatorMath code was open-sourced in 2014 thanks to support and funding from Adobe.

ufo2fdk

Another important milestone came in the form of ufo2fdk, a Python bridge between UFO and Adobe’s AFDKOAdobe Font Developer Kit for OpenType. A suite of tools for generating OpenType fonts. written by Tal. ufo2fdk finally made it possible to generate OpenType fonts directly from UFOs in Nonelab.

Other libraries

Other libraries created in this period include fontMath to perform fast font math, extractor to convert binary fonts to UFO, compositor to set text with OpenType layout features, aicbTools to import vector data from Adobe Illustrator, etc.

Standalone apps

On top of these open-source libraries and using the UFO format for data interchange, several stand-alone font editing applications were built.

Area 51

Area 51 was a small application to inspect UFO fonts and test OpenType features. It started out as a small vanilla and defconAppKit demo, but ended up becoming something useful on its own. The app was later converted into the Feature Preview extension.

Metrics Machine

Metrics Machine was created to make the kerning process suck less, and introduced a new, more efficient interface for kerning. It could write kerning into the UFO or export it as OpenType feature code. The app has recently been converted into an extension for RoboFont 3.

Superpolator

Superpolator, released by Erik van Blokland in 2004, was created to make multidimensional font interpolation available for type designers. It allowed them to build large, complex typeface families using an arbitrary number of axes and sources, in a way that was much more flexible than the Multiple Master based interpolation available in FontLab. The underlying math model was released as the open-source library mutatorMath (see above).

With the introduction of OpenType variable fonts in 2016, Superpolator evolved into a separate tool, Skateboard, which is an extension for RoboFont 3.

Prepolator

Prepolator was created to make source fonts compatible for interpolation, making the tedious task of checking contour compatibility visual and quick. It was typically used next to Superpolator. With the release of RoboFont 3, Prepolator was converted into a RoboFont extension.

Kalliculator

Kalliculator was Frederik Berlaen’s first application, developed in 2005 as his graduation project at TypeMediaPost-graduate course in typeface design at the Royal Academy of Art (KABK) in The Hague, Holland.. Kalliculator is an application to model calligraphic contrast around skeletons, with various parameters such pen width and height, rotation, and pressure. Kalliculator was never released commercially, but the techniques learned to build it were used to create other apps later, including RoboFont.

UFOstretch

UFOstretch is an application to interpolate and transform (scale, rotate, skew, translate) glyphs. It is useful for creating variations like small caps, superscript, condensed, oblique, etc.

roundingUFO

roundingUFO is an application to apply contour effects to the corners of glyphs. It can be used to round off corners, but also to create ink traps or light traps automatically.

FontConstructor

FontConstructor is an application to build glyphs intuitively out of modular parts. It was built as an educational tool to explore the relationships between shapes in a typeface.


Last edited on 15/07/2021