Font Management in Mac OS X

In 1984, the original Macintosh brought the world a visually integrated computer, and initiated what I've been calling the "Font Decade," where CEOs and homemakers alike learned the difference between Times and Helvetica.

During this time, the acronym WYSIWYG (whizzi-wig) was coined, and "What You See is What You Get" became the battle cry of the print and publishing and graphic design industries. Prior to the Macintosh (which gained the benefits of Xerox research, and added plenty of original design to that), typographers and designers were stuck with marking up type to send (by messenger or post) to a composition house, which produced a galley or repro-proof based on the instructions provided by the designers. The galley was then sent back by messenger to the designer for proofing and correction. Ultimately this process yielded the printed piece for distribution.

Given this time-consuming process, it's no small wonder that the publishing industry jumped head first into the Mac revolution! (We'll leave aside, for now, the various intrigues around the licensing of type designs and that Adobe was thought of as an impudent upstart whose "fonts" were never going to be worthy of being called "Type!")

By 1987, the Mac II came out, and nobody was calling the Macintosh a "toy" anymore. Adobe licensed some of the best type libraries in the world, and engaged in the work of making them available for designers and publishers in the new democratic digital format. Of course, this meant that they were in Adobe's PostScript page description language, and soon after, engineers at Apple developed the TrueType format, based on a different mathematical model, and licensed the technology to Microsoft.

The benefit to both companies was that the rendering engine for TrueType was in the OS, rather than residing on an Adobe licensed CPU in the printer. For quite a few years, the Font Wars waged, until today, we have two firmly established formats, both of which are destined to be absorbed into OpenType, the result of a truce which is non-sectarian as far as the outline format and incorporates plenty of future-oriented options.

Helpful font utilities

Over the years, there have been a number of important utilities developed to help Mac users deal with the proliferation of fonts on their systems. Packages such as Suitcase and Adobe Type Manager provide an interface to manage sets and collections of fonts (ATM also provides a rendering engine for Postscript fonts). Designers depend on these tools to hide the majority of their libraries, which may have hundreds of families and thousands of fonts, while they work on a particular project which will rarely require more than a couple of families, perhaps a dozen or two fonts, to choose from.

The situation today finds designers with a serious quandary. To take advantage of the many benefits of OS X, they must relinquish all of the font-management tools which have matured under the Classic Mac OS.

Although ATM will enable fonts if it's installed when Classic starts up, this is not an acceptable solution. We'll need to see Carbon or, better, Cocoa releases of font-management tools before OS X will be viable for the publishing industry as a whole. Note that the just-released ATM Light 4.6.2 has been tested for compatibility with Mac OS X Classic, unlike previous versions. In addition, both Suitcase and Font Reserve have promised to release OS X-friendly versions of their font management apps this year.

To alias or not to alias?

Of course, the lack of tools is only temporary. Mac OS X has excellent support for advanced typographic features, including OpenType and Unicode, as well as Apple's Advanced Typography (AAT), and promises to be a publishing powerhouse when the toolbox is filled out.

The anti-aliasing is somewhat controversial, but Quartz' built-in renderer guarantees that you will not be faced with either font format breaking into ugly chunks as you scale it up. If you prefer to not have your screen fonts anti-aliased, you can turn off the feature from the Terminal command-line as follows:

sudo defaults write CoreGraphics CGFontDisableAntialiasing YES

Make sure your password is handy because you'll be asked for it.

Where do fonts live in OSX?

According to Apple's Typography Group, fonts can live in a number of places.

~/Library/Fonts/
/Library/Fonts/
/System/Library/Fonts/
/Network/Library/Fonts/
{ClassicStartupVolume}:System Folder:Fonts:

Let's look more closely at this list.

~/Library/Fonts/
The tilde ("~") represents your home folder. That is, /Home/{your_user_name}/. (I will continue to use the term "folder," rather than "directory," when that's more consistent with Mac usage. I think it's also a more appropriate descriptive image for what the "folder" does! Of course, on the command line, "directory" is the word; I suppose one could argue that in the Finder, we see folders, but at the BSD level, we list directories.)

Fonts stored in ~/Library/Fonts/ will be available to you only when you are logged in using this User Name. Applications that you install in your ~/Applications foldermay put their custom fonts here.

/Library/Fonts/
Fonts stored here will be available to all users of this computer. However, to add fonts to the /Library/Fonts/ folder, you may need to authorize yourself!

/System/Library/Fonts/
This is where system fonts are stored, and users should never need to install anything here.

/Network/Library/Fonts/
If you are connected to a NetInfo server, the network administrator may install fonts which will show up in this network folder.

Note that fonts installed in any of the above locations will not be available in the Classic Environment.

{ClassicStartupVolume}:System Folder:Fonts:
This is an interesting feature! Any fonts you have installed in your Classic System Fonts folder will be available to any user on your machine. This is true whether or not Classic is running! Unfortunately, most of my fonts are managed by Adobe Type Manager, which, while it works fine under Classic, does not make the fonts available to OS X applications. In addition, ATM would be required to properly render any PostScript outline fonts under Classic.

Approaches to font management

One of the main advantages of Adobe Type Manager, et al, is the freedom to leave fonts organized as you like, each family in its own folder. ATM allows you to create a reference to the fonts and tells the System where to find the resource when it's called for.

We can do a similar thing using BSD-level file links, which, unlike the Finder alias, convince the system that the font actually is residing in the appropriate Font folder.

For instance, I've been using the beautiful Linotype Syntax family, a large series of Postscript fonts, redesigned and engineered to take full advantage of ultra high resolution output devices. The family has thirty fonts and includes small caps, old-style numerals, and four weights. I'd prefer to leave the fonts in a single folder and be able to install or remove them at will.

We'll use some file globbing and linking to install links from the original file into the Classic System Fonts folder (making them available system-wide!), and a similar method to remove them. (Note that Apple's .dfonts will not not work with Classic apps, since the Classic OS doesn't know that these are fonts! Come back next time for the scoop on .dfonts, .otf, .ttf, and the rest!)

To link the contents of a folder, we do something like this in Terminal:

# note the single quotes in this line to preserve
# the space (adjust for your Classic startup volume)

setenv ClassicStartUpVol '/Volumes/rasalas/'

# the rest are double quoted to allow for shell
# substitution

setenv MyFonts "Lino*Syn*"
setenv MyFontLib "$ClassicStartUpVol/System Folder/Fonts/"
setenv MyFontSource "$ClassicStartUpVol/Fonts/LSyntax/"

The setenv command adds an environment variable to the user environment. Here, we've defined user variables which are used in the statement below. This is standard programming technique -- isolate the variable data, generalize the command. If you type env the system will list the current environment vars.

Note: The fonts must be on the same volume as the Classic Startup System Folder. I've found that "symbolic links" ("symlinks") don't seem to do the job as well as "hard" file links, which cannot be used across volumes. In addition, some OS X apps can't seem to find the fonts in the Classic font folder. In this case, install them in /Library/Fonts/ or ~/Library/Fonts/ instead.

cd $MyFontSource ; find . -name "$MyFonts" -exec ln $MyFontSource\{\}
$MyFontLib\{\} \; ; cd -

This line has three parts, each command separated by a semi-colon. First, we cd (change directory) to the font source directory. Then the working parts:

The first argument to the find command (look it up with man find) is the directory to search. Since we've changed to the source directory already, I use the single dot, which indicates the current working directory.

The next argument is a series of conditions which are evaluated for each file under the search directory (note that by default, find will search through the entiredirectory tree under the search directory)

In this example, I'm asking find to select all the files which match the pattern which I've stored in the variable $MyFonts (the $ is required to access the value). Here, that value is Lino*Syn*. If you recall from my previous article, Unix for the Rest of Us, the * in a shell expression is a "globbing" operator that matches any characters in the name. Thus, our pattern will match any file name in the search directory which begins with the characters "Lino" and includes the characters "Syn" somewhere before the end of the name. Note that the search is case-sensitive by default. Note also that spaces are included in the "glob."

In this case, we will match filenames similar to these:

LinotSynHea
LinotSynMedIta.AFM
LinotSynOsFBla
LinotSynOsFBla.AFM
LinotSynOsFBlaIt
LinotypeSyntax Medium
LinotypeSyntax OsF Black

The third part of the find statement is the -exec clause. The string following -exec, up to the next semi-colon, is a command wherein the current filename is inserted at the {} markers. Since the brackets are also shell delimiters, we have to "escape" that context by preceding each bracket with a backslash.

We also precede the semi-colon with a backslash, since it also has meaning to the shell, which is to separate multiple commands on the same line. In this case, I've added just such a semi-colon, and finally the last command, cd -, which returns us to our prior working directory.

So, as the find command selects each filename in order, the exec statement would be built, and then executed by the shell. The commands might look like these, if we were to echo the string before it's executed:

ln /Volumes/rasalas/Fonts/LSyntax/./LinotSynSCReg /Volumes/rasalas/System Folder//Fonts/./LinotSynSCReg
ln /Volumes/rasalas/Fonts/LSyntax/./LinotSynSCReg.AFM /Volumes/rasalas/System Folder//Fonts/./LinotSynSCReg.AFM
ln /Volumes/rasalas/Fonts/LSyntax/./LinotypeSyntax Medium /Volumes/rasalas/System Folder//Fonts/./LinotypeSyntax Medium

The ln command creates a link or reference between the source file (the first argument) and the link named in the second argument.

This is similar in effect, but substantially different in operation, to a Mac Finder alias. (A Finder alias is dynamically updated if you move the source file, for example.)

To the Finder, the link appears to actually bethe file itself. With each "link" to a file, the BSD file system creates a pointer to the actual data on the storage device.

It may be useful to re-login before using the newly installed fonts. However, most of the applications I tried seemed to recognize the fonts after restarting the app. I've successfully used this method in Macromedia Freehand 10, both printing and exporting valid PDF with the fonts embedded. In Classic, Photoshop 6.01 accepts the new fonts as well.

To reverse the installation, we'll reuse the environment variables and simply say:

cd $MyFontLib ; rm "$MyFonts" ; cd -

First, we cd to the font library (not the font source, where the original fonts are!), then use the rm command to remove the links:

Note that the rm command, by default, does not remove files recursively in directories other than the current working directory. However, the $MyFonts environment variable is expanded by the shell, and all of the links are removed from the current directory.

This gives us a primitive but effective method of font management while we're waiting for developers to move ahead with OSX native tools. I hope you've been able to follow the procedure. Obviously there are many ways that we can extend this process to make it more flexible. For instance, you can try creating font sets in folders, and have the process add all the fonts within the set. (The problem comes when you want to remove each of them!)

In my next article, we'll make some "containers," which encapsulate this behavior into double-clickable scripts.

I look forward to your comments and suggestions regarding this technique. I should also offer a disclaimer: YMMV (your mileage may vary) and don't try this with fonts that you don't have backed up somewhere else ;-) There are some inconsistent behaviors that pop up using this method. I'm not really sure why, but occassionally, I would find that Freehand 10 would "forget" where the Type 1 outlines were, and show only chunky, aliased bitmaps. Generally, this was remedied by restarting the application. However, I can't understand why it would work sometimes, and not others. I'd love to hear from anyone with an explanation!

Peter Fraterdeus has been webmastering with Linux since 1993 and became hooked on the Mac after purchasing a 128k model in October 1984.

Return to the Mac DevCenter.

Copyright © 2009 O'Reilly Media, Inc.