Welcome to RoboFont

RoboFont is a UFO-based font editor for Mac OS X.

RoboFont provides a simple-to-use environment to draw and modify typefaces in. It has the following main design features:

  • Is written from scratch in Python with scalability in mind.
  • Has full scripting access to objects and the application interface.
  • Can be used as a platform to build additional tools on.
  • Does not preform any ‘auto-magic’.
  • Does not overload the user with a multitude of options.
  • Uses the UFO format as it's native file format.

The operating philosophy behind RoboFont is:

The tools you choose influence your creative process.

Because of this, RoboFont provides many opportunities for the user to tailor the application to their design process. It is strict about not preforming ‘auto-magic’ on one’s font files, ‘auto-’ anything is avoided if possible. This means that it does not do and does not have some features of other font editing applications. Because the application is extensible, if a user finds a need in their design process for a feature that isn’t part of RoboFont, it can be added. This allows the user the control to design the application to their design process.

However, the core of RoboFont is a full featured drawing editor, containing all the basic tools a typeface designer needs for drawing and modifying a design.

RoboFont design principles


A typeface designer (who does not want to do any scripting and has no means of letting someone else do that work), has to deal with the available user interface, tool set, feature set, and the list of bugs in the typeface design applications they use. This makes the designer a victim to the development of applications that are often merely production tools and not intended for design iterations. Not being (partly) the designer of your own tools puts a designer in a vulnerable position.

Specialized tools

Spreading functions over different tools reduces the need to buy them all at the same time, or pay for the development of a function you don’t require. Or you can do better yourself and write your own custom tool for a function. Functions can be added over time as they become available and technology changes.

Decentralized development also means that a group of people can work on the functions that they really do need and are extremely capable of making and maintaining.

The role of RoboFont

The idea behind RoboFont is to provide a sturdy framework where everyone can add their own functionalities with Python, rather than a program with hundreds of (often little needed) functions.

Constructing an open structure for RoboFont allows any developer to add new technologies to the overall functionality, without the need for the main developer(s) to put it on top of their list. It also allows competition between ideas and technologies, as any developer’s idea of how something should work can be part of RoboFont.

This is very different from having one application that can only do most of the things on a average level. It also means that upgrading a single function implies upgrading the entire application, which often is not attractive to a developer. This can result in a lag between the introduction of a new technology/upgraded function and the ability to use that technology/upgraded function. Lastly, one is locked into the developer’s idea of how a function should work, rather than being able to choose how the function should work for you.

No previous knowledge

An application shouldn’t design for a designer, as it is just a tool. Pencils do not illustrate, printing presses do not layout, and a typeface design application shouldn’t make autonomous decisions. The typeface designer should make the decisions and have the power to design their fonts.

Think of RoboFont as a second desktop for your typeface design work. Like your physical desk, it can be customized for different kinds of design work. For example, your settings can be very different if you are designing a headline typeface or working on a revival. RoboFont allows you to change and optimize your editor settings from project to project.

Full scripting support

RoboFont is programmed in Python from the ground up. The entire application is object oriented, allowing any user to dive into the deep functionality of RoboFont and overwrite/redefine/add functions —even at the core of the program— simply by inheriting the existing classes. This way there is a total melding between scripting and coding of the main application.

A platform for building custom tools and extensions

RoboFont is a rich environment for developing one’s own custom tools. The extensibility of it’s object model allows a designer to build whatever they can think of on the base of RoboFont. If a designer isn’t inclined to write additional tools for the RoboFont environment, one can see a near-term future for the sharing or sale of scripts and extension to RoboFont.

Working with UFOs

What is UFO?

UFO stands for Unified Font Object. It is a cross-platform, cross-application, human readable, future proof format for storing font data. The format is developed by Erik van Blokland, Tal Leming, and Just van Rossum. Because it is application neutral, several typeface design and font production applications use it natively; these are referred to as ‘UFO Tools’. UFO is a simple specification, one can rely on the ability to read/write the font data into the future, whatever the application landscape will look like then.

Advantages of UFO

  • An open and documented format
  • UFO is XML: standards-based, future proof, easy to read and write
  • Each glyph is stored separately – easy to access and track versions
  • One can import/export UFO’s from FontLab, Glyphs, and FontForge

Possible disadvantage:

  • Larger files (XML is verbose)

Converting font sources to UFO format

If you are switching to RoboFont from other applications, the first thing you’ll need to do is convert your font files to UFO.

From FontLab

The easiest way to export UFOs from FontLab (version 4 or version 5) is by using Tal Leming’s UFOCentral python script. If you don’t have RoboFab installed, do so first. Install the linked script into your user/Library/Application Support/FontLab/Studio 5/Macros folder. After doing so, restart FontLab if it was running, and go to the macros panel. You should see ‘UFOCentral’ as an option now. With a VFB(s) open, run the script, selecting the Export checkbox. Be sure to select the ‘Format 2’ option (it is the default). The script will then export your VFB(s).

From Glyphs

Go to File ⇢ Export. Select UFO as the export option.

From FontForge

Select the UFO option from File ⇢ Save As.

UFO Tools

Besides RoboFont, there are several other tools for working with UFO files, all doing different things. As of October 19th, 2011 here is a list:

  • MetricsMachine: Tool for kerning
  • Area51: Tool to inspect UFOs, generate fonts, and test features
  • Prepolator: Tool to check fonts for interpolation compatibility
  • Superpolator: Tool to Superpolate fonts
  • RoundingUFO: Tool to round the corners (and more) of glyphs
  • UFOStretch: Tool to transform, translate and interpolate a specific set of glyphs.

Technical specifications

RoboFont requires OSX version 10.6+. It is fully compatible with OSX 10.7+ (Lion) and 10.8+ (Mountain Lion).

RoboFont embeds the AdobeFDK version 2.5 change number 58732, but allows the user to use their own installed version of the AdobeFDK if desired. (see Preferences

What RoboFont can do:

  • drawing
  • editing
  • mastering font info
  • spacing
  • basic kerning
  • general PostScript hint settings
  • PostScript autohinting
  • TrueType autohinting if ttfautohint is installed on your system
  • OpenType feature code editing

What RoboFont cannot currently do:

  • PostScript hint editing
  • TrueType instructions editing
  • font mastering
These features can be done with an extension or a script, they are not part of the core application.