Chapter 7: Scripting for production


XX In the production phase of a font it all comes together: moving stuff around, naming, interpolations, quality control, generating, database work, it pays to invest some time (or money) in some really good scripts. Each foundry and designer has their own preferred ways of doing things. It's impossible to describe one production process and please everyone. So instead we're going to look at some of the things you probably have to do anyway. You will have to match and adapt for your own methods.

Production scripts can save a lot of time. But be careful: it is costly to make mistakes with your production sources. Make sure to test production scripts first on duplicate data, preferably in a different folder. Doing something "quickly" to a massive kerning table only to discover it was your only copy, and the action was wrong — will not save you any time. Like carpentry: measure twice, cut once.

Batch processing

Here are some examples of applying changes to several fonts at once using AllFonts(). Keep in mind that this applies to all fonts you have open in FontLab. So make sure to close any fonts that you don't want treated this way before running the script.

# robothon 2009
# set font info in all fonts

from import AllFonts
for font in AllFonts(): = "MyFamily" = 700 = -300

➔ Download this.

Obviously you can extend these to do lots more.

# robothon 2009
# get info attributes for all fonts
# and dump them to a text file

from import AllFonts
from robofab.interface.all.dialogs import PutFile

text = []

for font in AllFonts():

text = '\n'.join(text)
path = PutFile('Save file as:')
if path:
    file = open(path, 'w')
➔ Download this.

This is a more complex script. It iterates through all open fonts, collects some data in each and finally asks for a place to save all the data in a text file.

# robothon 2009
# batch save as

import os
from import AllFonts
from robofab.interface.all.dialogs import GetFolder

path = GetFolder()
if path:
    for font in AllFonts():
        fileName = os.path.basename(font.path)
        newPath = os.path.join(path, fileName)

➔ Download this.

This asks for a folder, then proceeds to save all open fonts in this folder.

# robothon 2009
# batch interpolate

import os
from import SelectFont, NewFont

# ask for two masters to interpolate:
font1 = SelectFont("Select font 1")
font2 = SelectFont("Select font 2")
# these are the interpolation factors:
values = [.3, .6]

for value in values:
    # make a new font
    destination = NewFont()
    # do the interpolation
    destination.interpolate(value, font1, font2, doProgress=True)
    # make a new path + filename for the new font to be saved at:
    dir = os.path.dirname(font1.path)
    fileName = "Demo_%d.vfb" % (1000 * value)
    # save at this path and close the font, fileName))

➔ Download this.

Here you can pick two fonts from the open fonts. The script will create a new, third font, and make interpolations with the interpolation factors in the values = [.3, .6] list. The interpolated font is then saved in the same folder as the first master.

This touches on a slippery problem which can cause a lot of confusion. Robofab can only tell FontLab fonts apart from their path attribute, the place where each font is saved. A newly created font has not been saved yet, so it has no path. The effect is that when you have more than one new, unsaved font open, Robofab can't tell them apart (for a couple of reasons) and will continue to work with the first one. It will look like nothing is happening when you run a script. The way around this is to make sure you save each font you created with a script before creating another one. This is safer anyway.

Here are some useful bits for batch processing fonts which are not open, but in a file. This script is a way to make python collect all files of a particular kind in a folder or folders within that folder. You can use the walker function outside of this script too, it's a useful thing to know.

# robothon 2009
# ask for a folder
# find (nested) fontlab files in the folder
# open the fonts
# Demonstrates: recursive function,, dialog, os module

import os.path
from robofab.interface.all.dialogs import GetFolder
from import OpenFont

# this function looks for fontlab files in a folder
def walk(someFolder, extension):
    extension = extension.lower()
    files = []
    # the os module has tools to deal with
    # the operating system. This returns a list of names
    # of stuff in the folder you feed it:
    names = os.listdir(someFolder)
    for n in names:
            p = os.path.join(someFolder, n)
            # if this new thing is a folder itself,
            # call this function again, but now with the
            # new path to check that as well. This is
            # called recursion.
            if os.path.isdir(p):
                # add the results of the other folder
                # to the list
                files += walk(p, extension)
            # is it a file with the extension we want?
            # add it then!
            if n.lower().find(extension) <> -1:
    return files

yourFolder = GetFolder("Search a folder:")
if yourFolder is not None:
    fontPaths = walk(yourFolder, ".vfb")
    for path in fontPaths:
➔ Download this.

Moving stuff around

The moving, merging and splitting of fonts. The first example moves selected glyphs in the same font and renames them. Note that if you remove the line f.removeGlyph( the same script effectively copies the glyphs. Also new in this script: it iterates through the whole font and checks for each glyph if the g.selected attribute is 1 or 0. If it is 0, the glyph is not selected in the font window. If it is 1, is is selected. It then proceeds to create a new glyph name, and calls f.insertGlyph() method which takes a glyph as parameter. The optional parameter as is to be able to insert the glyph under a different name. If you don't pass a parameter for as, the font will insert the glyph under its own name. The glyph can come from the same font, or a different font, or be an orphan glyph.

# rename the selected glyphs
# in the current font to <glyphname>.sc

from import CurrentFont
f = CurrentFont()

for g in f:
    if g.selected == 0:
    newName =".sc"
    print "moving",, "to", newName
    # note: as of robofab svn version 200, the "as" argument in insertGlyph has changed to "name"
    f.insertGlyph(g, name=newName)
moving A to
moving C to
moving B to

Generating font binaries

# robothon 2009
# batch generate

from import AllFonts

for font in AllFonts():
➔ Download this.

This will generate CFF flavored OpenType fonts for all open files.

# robothon 2009
# a more robust batch generator that only has one font open at the time.

from robofab.interface.all.dialogs import GetFolder
from import RFont, OpenFont
import os

def collectSources(root):
    files = []
    ext = ['.vfb']
    names = os.listdir(root)
    for n in names:
        if os.path.splitext(n)[1] in ext:
            files.append(os.path.join(root, n))
    return files

# A little function for making folders. we'll need it later.
def makeFolder(path):
    #if the path doesn't exist, make it!
    if not os.path.exists(path):

def makeDestination(root):
    macPath = os.path.join(root, 'FabFonts', 'ForMac')
    return macPath

def generateOne(f, dstDir):
    print "generating %s"

f = GetFolder()

if f is not None:
    paths = collectSources(f)
    dstDir = makeDestination(f)

    for f in paths:
        font = None
        print f
            font = OpenFont(f)
            generateOne(font, dstDir)

            if font is not None:

    print 'done'

➔ Download this.

The script above generates fonts too, but is a bit more robust. FontLab sometimes crashes when it has to generate a long list of fonts and they're all open at the same time. This script asks you for a folder of .vfb sources (which in itself can be a useful ingredient for your own scripts). Then it will open them one by one and generate the fonts in the flavor indicated in the line f.generate('mactype1', dstDir). A list of types and their names can be found in the robofab documentation how-to page on generating fonts. This script also creates a new folder to store the generated fonts in, sorted by type.


Here's an script, quite complex, for combining two fonts into one. Maybe not for the newbie, but if you're into it try to figure out how it works. It uses a couple of new concepts, like Sets and DigestPens. If it is too complicated: don't worry.

# robothon 2009
# merge two fonts

from import SelectFont, NewFont
from robofab.pens.digestPen import DigestPointPen
from sets import Set

font1 = SelectFont("Select base font")
font2 = SelectFont("Select alternate font")

font1Names = Set(font1.keys())
font2Names = Set(font2.keys())

commonNames = font1Names & font2Names
uncommonNames = font2Names - font1Names

for glyphName in commonNames:
    glyph1 = font1[glyphName]
    pointPen = DigestPointPen()
    digest1 = pointPen.getDigest()
    glyph2 = font2[glyphName]
    pointPen = DigestPointPen()
    digest2 = pointPen.getDigest()
    if digest1 != digest2:
        print '> alt >', glyphName
        # note: as of robofab svn version 200, the "as" argument in insertGlyph has changed to "name"
        glyph3 = font1.insertGlyph(glyph2, name=glyphName+'.alt')
        glyph3.mark = 1

for glyphName in uncommonNames:
    print '>', glyphName
    glyph = font1.insertGlyph(font2[glyphName])
    glyph.mark = 60
➔ Download this.

Dealing with Robofab limitations

A handful of FontLab's own glyph and font methods are not supported in RoboFab. The reasons for this vary, some of them are very FontLab specific (for instance fl.productnumber or fl.username), but most of the missing stuff was just not needed very often — the following examples show how to get access to all functionality and attributes in the FontLab layer.

FontLab layer

To get to the FontLab layer, Robofab's Font and Glyph objects have a naked() method which returns the FontLab object. Note that you can still use the Robofab functionality like CurrentFont, CurrentGlyph, pens etc. The FontLab layer is documented here. Maybe you remember the naked() method from the cookie cutter example.

# show the objects from the fontlab layer
from import CurrentFont
f = CurrentFont()
print f.naked()

print g.naked()
<Font: 'MyFont'>
<Glyph: 'A', 0 nodes, parent: 'MyFont'>

Other things you need to dig deeper for. Note that some of these objects appear to be broken.

Step by Step