Hubbry Logo
PostScript fontsPostScript fontsMain
Open search
PostScript fonts
Community hub
PostScript fonts
logo
7 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
PostScript fonts
PostScript fonts
from Wikipedia

PostScript fonts are font files encoded in outline font specifications developed by Adobe Systems for professional digital typesetting. This system uses PostScript file format to encode font information.

"PostScript fonts" may also separately be used to refer to a basic set of fonts included as standards in the PostScript system, such as Times New Roman, Helvetica, and Avant Garde.

History

[edit]

Type 1 and Type 3 fonts, though introduced by Adobe in 1984 as part of the PostScript page description language, did not see widespread use until March 1985 when the first laser printer to use the PostScript language, the Apple LaserWriter, was introduced.

Even then, in 1985, the outline fonts were resident only in the printer, and the screen used bitmap fonts as substitutes for outline fonts.

Although originally part of PostScript, Type 1 fonts used a simplified set of drawing operations compared to ordinary PostScript (programmatic elements such as loops and variables were removed, much like PDF), but Type 1 fonts added "hints" to help low-resolution rendering. Originally, Adobe kept the details of their hinting scheme undisclosed and used a (simple) encryption scheme to protect Type 1 outlines and hints, which still persists today (although the encryption scheme and key has since been published by Adobe). Despite these measures, Adobe's scheme was quickly reverse-engineered by other players in the industry. Adobe nevertheless required anyone working with Type 1 fonts to license their technology.

Type 3 fonts allowed for all the sophistication of the PostScript language, but without the standardized approach to hinting (though some companies such as ATF implemented their own proprietary schemes) or an encryption scheme. Other differences further added to the confusion.

The cost of the licensing was considered very high at this time, and Adobe continued to stonewall on more attractive rates. It was this issue that led Apple to design their own system, TrueType, around 1991. Immediately following the announcement of TrueType, Adobe published ”Adobe type 1 font format”,[1] a detailed specification for the format. Font development tools such as Fontographer added the ability to create Type 1 fonts. The Type 2 format has since been used as one basis for the modern OpenType Format.

Technology

[edit]

By using PostScript (PS) language, the glyphs are described with cubic Bézier curves (as opposed to the quadratic curves of TrueType), and thus a single set of glyphs can be resized through simple mathematical transformations, which can then be sent to a PostScript-ready printer. Because the data of Type 1 is a description of the outline of a glyph and not a raster image (i.e. a bitmap), Type 1 fonts are commonly referred to as "outline fonts," as opposed to bitmap fonts. For users wanting to preview these typefaces on an electronic display, small versions of a font need extra hints and anti-aliasing to look legible and attractive on screen. This often came in the form of an additional bitmap font of the same typeface, optimized for screen display. Otherwise, in order to preview the Type 1 fonts in typesetting applications, the Adobe Type Manager utility was required.

Font type

[edit]

Type 0

[edit]

Type 0 is a "composite" font format – as described in the PostScript Language Reference Manual, 2nd Edition. A composite font is composed of a high-level font that references multiple descendant fonts.

Type 1

[edit]
PostScript Type 1
Filename extension
Type code
Mac:
LWFN  (prn/outline-data/Mac-bitmap).
sfnt (Mac PS1 bitmap) suitcase file.
printer (prn) outline (FOND/bitmap) file.
ffil (display).
FFIL (suitcase/screen).
Win:
binary (.pfb).
Developed byAdobe Systems
Type of formatPostScript outline font
Extended to.otf (OpenType PostScript).
StandardISO 9541

Type 1 (also known as PostScript, PostScript Type 1, PS1, T1 or Adobe Type 1) is the font format for single-byte digital fonts for use with Adobe Type Manager software and with PostScript printers. It can support font hinting.

It was originally a proprietary specification, but Adobe released the specification to third-party font manufacturers provided that all Type 1 fonts adhere to it.

Type 1 fonts are natively supported in macOS, and in Windows 2000 and later via the GDI API.[2] (They are not supported in the Windows GDI+, WPF or DirectWrite APIs.)

Adobe announced on 27 January 2021 that they would end support for Type 1 fonts in Adobe products after January 2023.[3] Support for Type 1 fonts in Adobe Photoshop was discontinued with the release of version 23.0 of the product in October 2021.

Type 2

[edit]

Type 2 is a character string format that offers a compact representation of the character description procedures in an outline font file. The format is designed to be used with the Compact Font Format (CFF). The CFF/Type2 format is the basis for Type 1 OpenType fonts, and is used for embedding fonts in Acrobat 3.0 PDF files (PDF format version 1.2).

Type 3

[edit]

Type 3 font (also known as PostScript Type 3 or PS3, T3 or Adobe Type 3) consists of glyphs defined using the full PostScript language, rather than just a subset. Because of this, a Type 3 font can do some things that Type 1 fonts cannot do, such as specify shading, color, and fill patterns. However, it does not support hinting. Adobe Type Manager did not support Type 3 fonts, and they are not supported as native WYSIWYG fonts on any version of macOS or Windows.

Type 4

[edit]

Type 4 is a format that was used to make fonts for printer font cartridges and for permanent storage on a printer's hard disk. The character descriptions are expressed in the Type 1 format. Adobe does not document this proprietary format.

Type 5

[edit]

Type 5 is similar to the Type 4 format but is used for fonts stored in the ROMs of a PostScript printer. It is also known as CROM font (Compressed ROM font).

Types 9, 10, 11

[edit]

Ghostscript referred them as CID font types 0, 1, and 2 respectively, documented in Adobe supplements. Types 9, 10, and 11 are CID-keyed fonts for storing Types 1, 3, and 42, respectively.

Type 14

[edit]

Type 14, or the Chameleon font format, is used to represent a large number of fonts in a small amount of storage space such as printer ROM. The core set of Chameleon fonts consists of one Master Font, and a set of font descriptors that specify how the Master Font is to be adjusted to give the desired set of character shapes for a specific typeface.

Adobe does not document the Type 14 format. It was introduced with PostScript 3 in 1997, and de-emphasized in later years as storage became cheaper.

Type 32

[edit]

Type 32 is used for downloading bitmap fonts to PostScript interpreters with version number 2016 or greater. The bitmap characters are transferred directly into the interpreter's font cache, thus saving space in the printer's memory.

Type 42

[edit]

The Type 42 font format is a PostScript wrapper around a TrueType font, allowing PostScript-capable printers containing a TrueType rasterizer (which was first implemented in PostScript interpreter version 2010 as an optional feature, later standard) to print TrueType fonts. Support for multibyte CJK TrueType fonts was added in PostScript version 2015. The out-of-sequence choice of the number 42 is said to be a jesting reference to The Hitchhiker's Guide to the Galaxy, where 42 is the Answer to Life, the Universe, and Everything.

Core Font Set

[edit]

In addition to font types, PostScript specifications also defined the Core Font Set, which dictates the minimum number of fonts, and character sets to be supported by each font.

PostScript Level 1

[edit]

The original PostScript defined 13 font styles which form 4 type families:

  • Courier (Regular, Oblique, Bold, Bold Oblique)
  • Helvetica (Regular, Oblique, Bold, Bold Oblique)
  • Times (Roman, Italic, Bold, Bold Italic)
  • Symbol

PostScript Level 2

[edit]

PostScript Level 2 defined 35 font styles which form 10 type families. They include all of the above Level 1 fonts, plus the following:

Many computer operating systems have these fonts installed, while various projects have created clones of them. For instance, the Ghostscript fonts (also known as the URW Base 35 fonts) are open-source clones of all fonts defined in PostScript 2.

PostScript Level 3

[edit]

In PostScript 3, 136 font styles are specified,[4] which include the 35 font styles defined in PostScript 2, core fonts in popular operating systems (namely Windows 95, Windows NT, and Macintosh), selected fonts from Microsoft Office, and the HP 110 font set. New fonts include:

  • Albertus (Light, Roman, Italic)
  • Antique Olive (Roman, Italic, Bold, Compact)
  • Apple Chancery
  • Arial (Regular, Italic, Bold, Bold Italic)
  • Bodoni (Roman, Italic, Bold, Bold Italic, Poster, Poster Compressed)
  • Carta (a dingbat)
  • Chicago
  • Clarendon (Light, Roman, Bold)
  • Cooper Black, Cooper Black Italic
  • Copperplate Gothic (32BC, 33BC)
  • Coronet
  • Eurostile (Medium, Bold, Extended No.2, Bold Extended No.2)
  • Geneva
  • Gill Sans (Light, Light Italic, Book, Book Italic, Bold, Bold Italic, Extra Bold, Condensed, Condensed Bold)
  • Goudy (Oldstyle, Oldstyle Italic, Bold, Bold Italic, Extra Bold)
  • Helvetica (Condensed, Condensed Oblique, Condensed Bold, Condensed Bold Oblique)
  • Hoefler Text (Roman, Italic, Black, Black Italic), Hoefler Ornaments
  • Joanna (Roman/Regular, Italic, Bold, Bold Italic)
  • Letter Gothic (Regular, Slanted, Bold, Bold Slanted)
  • ITC Lubalin Graph (Book, Oblique, Demi, Demi Oblique)
  • ITC Mona Lisa Recut
  • Marigold
  • Monaco
  • New York
  • Optima (Roman, Italic, Bold, Bold Italic)
  • Oxford
  • Stempel Garamond (Roman, Italic, Bold, Bold Italic)
  • Tekton (Regular)
  • Times New Roman (Regular, Italic, Bold, Bold Italic)
  • Univers (45 Light, 45 Light Oblique, 55, 55 Oblique, 65 Bold, 65 Bold Oblique, 57 Condensed, 57 Condensed Oblique, 67 Condensed Bold, 67 Condensed Bold Oblique, 53 Extended, 53 Extended Oblique, 63 Extended Bold, 63 Extended Bold Oblique)
  • Wingdings

Others

[edit]

In PDF, 14 Type 1 fonts are defined as the standard fonts. They include the 13 font styles defined by PostScript Level 1, along with ITC Zapf Dingbats.[5]

However, in recent versions of Adobe Acrobat Reader, Helvetica and Times were internally replaced by Arial and Times New Roman respectively.[6]

Character sets

[edit]

Although PostScript fonts can contain any character set, there are character sets specifically developed by Adobe, which are used by fonts developed by Adobe.

Adobe Western 2

[edit]

It includes a basic character set containing upper and lowercase letters, figures, accented characters, and punctuation. These fonts also contain currency symbols (cent, dollar, euro, florin, pound sterling, yen), standard ligatures (fi, fl), common fractions (1/4, 1/2, 3/4), common mathematics operators, superscript numerals (1,2,3), common delimiters and conjoiners, and other symbols (including daggers, trademark, registered trademark, copyright, paragraph, litre and estimated symbol). Compared to the ISO-Adobe character set, Western 2 also adds 17 additional symbol characters: euro, litre, estimated, omega, pi, partialdiff, delta, product, summation, radical, infinity, integral, approxequal, notequal, lessequal, greaterequal, and lozenge.

Fonts with an Adobe Western 2 character set support most western languages including Afrikaans, Basque, Breton, Catalan, Danish, Dutch, English, Finnish, French, Gaelic, German, Icelandic, Indonesian, Irish, Italian, Norwegian, Portuguese, Sami, Spanish, Swahili and Swedish.

This standard superseded ISO-Adobe as the new minimum character set standard as implemented in OpenType fonts from Adobe.

Adobe CE

[edit]

Fonts with an Adobe CE character set also include the characters necessary to support the following central European languages: Croatian, Czech, Estonian, Hungarian, Latvian, Lithuanian, Polish, Romanian, Serbian (Latin), Slovak, Slovenian and Turkish.

Adobe-GB1

[edit]

This Simplified Chinese character collection provides support for the GB 1988–89, GB 2312–80, GB/T 12345–90, GB 13000.1-93, and GB 18030-2005 character set standards. Supported encodings include ISO-2022, EUC-CN, GBK, UCS-2, UTF-8, UTF-16, UTF-32, and the mixed one, two- and four-byte encoding as published in GB 18030-2005.

Adobe-CNS1

[edit]

This Traditional Chinese character collection provides support for the Big-5 and CNS 11643-1992 character set standards. It also includes support for a number of extensions to Big-5, which contain characters used mainly in the Hong Kong locale. Primary supported Big-5 extensions include HKSCS.[7]

Supported encodings include ISO-2022, EUC-TW, Big Five, UCS-2, UTF-8, UTF-16, and UTF-32.

In Adobe-CNS1-7, 23 additional glyphs were added, with 25 additional mappings for its Unicode CMap resources.[8]

Adobe-Japan1

[edit]

It is a series of character sets developed for Japanese fonts. Adobe's latest, the Adobe-Japan1-6 set covers character sets from JIS X 0208, ISO-2022-JP, Microsoft Windows 3.1 J, JIS X 0213:2004, JIS X 0212-1990, Kyodo News U-PRESS character set.

Adobe-Japan2

[edit]

It was originally as an implementation of JIS X 0212-1990 character set standard and the Macintosh extensions, but with the introduction of Adobe-Japan1 supplement 6 (Adobe-Japan1-6) standard, Adobe-Japan2-0 became obsolete.

Adobe-Korea1

[edit]

This Korean character collection provides support for the KS X 1001:1992 and KS X 1003:1992 character set standards, and their selected corporate variations. Supported encodings include ISO-2022-KR, EUC-KR, Johab, UHC, UCS-2, UTF-8, UTF-16, and UTF-32.

ISO-Adobe

[edit]

Fonts with an ISO-Adobe character set support most western languages including: Afrikaans, Basque, Breton, Catalan, Danish, Dutch, English, Finnish, French, Gaelic, German, Icelandic, Indonesian, Irish, Italian, Norwegian, Portuguese, Sami, Spanish, Swahili and Swedish. This is the standard character set in most PostScript Type 1 fonts from Adobe.

File formats

[edit]

CID

[edit]

The CID-keyed font (also known as CID font, CID-based font, short for Character Identifier font) is a font structure, originally developed for PostScript font formats, designed to address a large number of glyphs. It was developed to support pictographic East Asian character sets, as these comprise many more characters than the Latin, Greek and Cyrillic writing systems.

Adobe developed CID-keyed font formats to solve problems with the OCF/Type 0 format, for addressing complex Asian-language (CJK) encoding and very large character sets. CID-keyed internals can be used with the Type 1 font format for standard CID-keyed fonts, or Type 2 for CID-keyed OpenType fonts. CID-keyed fonts often reference "character collections," static glyph sets defined for different language coverage purposes. Although in principle any font maker may define character collections, Adobe's are the only ones in wide usage. Each character collection has an encoding which maps Character IDs to glyphs. Each member glyph in a character collection is identified by a unique character identifier (CID). Such CIDs are generally supplemental to other encodings or mappings such as Unicode.

Character collections are uniquely named by registry, ordering and supplement, such as "Adobe-Japan1-6." The registry is the developer (such as Adobe). The so-called "ordering" gives the purpose of the collection (for example, "Japan1"). The supplement number (such as 6) indicates incremental additions: for a given language, there may be multiple character collections of increasing size, each a superset of the last, using a higher supplement number. The Adobe-Japan1-0 collection is 8284 glyphs, while Adobe-Japan1-6 is 23,058 glyphs.

CID-keyed fonts may be made without reference to a character collection by using an "identity" encoding, such as Identity-H (for horizontal writing) or Identity-V (for vertical). Such fonts may each have a unique character set, and in such cases the CID number of a glyph is not informative; generally the Unicode encoding is used instead, potentially with supplemental information.

CID-keyed fonts internally have their character sets divided into "rows," with the advantage that each row may have different global hinting parameters applied.

In theory it would be possible to make CID-keyed OpenType versions of western fonts. This would seem desirable for some such fonts because of the hinting advantages. However, according to Adobe, much of the software infrastructure (applications, drivers, operating systems) makes incorrect assumptions about CID-keyed fonts in ways that makes such fonts behave badly in real-world usage.

Adobe ClearScan technology (as from Acrobat 9 Pro) creates custom Type1-CID fonts to match the visual appearance of a scanned document after optical character recognition (OCR). ClearScan does not replace the fonts with system fonts or substitute them by Type1-MM (as in Acrobat 8 and earlier versions), but uses these newly created custom fonts. The custom fonts are embedded in the PDF file (this is mandatory). In Acrobat DC, it is no longer called "ClearScan" but instead "Recognize Text - Editable Text & Images",[9] and it is now possible to edit the text.[10]

Compact Font Format

[edit]

Compact Font Format (also known as CFF font format, Type 2 font format, or CFF/Type 2 font format) is a lossless compaction of the Type 1 format using Type 2 charstrings. It is designed to use less storage space than Type 1 fonts, by using operators with multiple arguments, various predefined default values, more efficient allotment of encoding values and shared subroutines within a FontSet (family of fonts).

The so-called PostScript or Type 1 flavor of OpenType fonts, also called OpenType CFF, contains glyph outlines and hints in a CFF table.

CFF fonts can be embedded in PDF files, starting with PDF version 1.2. It is the usual approach to representing a Type 1 font within PDF.

CID-keyed fonts can be represented within CFF with Type 2 charstrings for CID-keyed OpenType fonts.

A Type 1 font can be losslessly converted into CFF/Type2 format and back.

Multiple Master

[edit]

Multiple master fonts (or MM fonts) are an extension to Adobe Systems' Type 1 PostScript fonts. Multiple master fonts contain one or more "masters" — that is, original font styles, e.g. a light, a regular and a bold version — and enable a user to interpolate these font styles along a continuous range of "axes." While Multiple Master fonts are not common in end user fonts anymore, they still play an important role when developing complex font families.

OpenType

[edit]

PostScript glyph data can be embedded in OpenType font files, but OpenType fonts are not limited to using PostScript outlines. PostScript outlines in OpenType fonts are encoded in the Type2 Compact Font Format (CFF).

OpenType conversion

[edit]

When Adobe converted PostScript Type 1 and Type 1 multiple master fonts to OpenType CFF format, they were made based on the last Type 1/MM versions from the Adobe Type Library fonts. In addition to file format change, there are other changes:

  • All alphabetic fonts had 17 additional characters included: the euro (some had already gotten this in Type 1), litre, estimated, and the 14 Mac "symbol substitution" characters. Symbol substitution was a scheme used on macOS to deal with the fact that the standard "ISO-Adobe" character set omitted certain characters which were part of the MacRoman character set. When one of these 14 characters was typed in a Type 1 font with standard encoding, both ATM and the printer driver would get a generic glyph in the Times style from the Symbol font. In the OpenType conversion, these characters were built into every font, getting some degree of font-specific treatment (weight and width).
  • Fonts that had unkerned accented characters had additional kerning to deal with accented characters.
  • Font families that included separate Type 1 expert fonts or Cyrillic fonts have these glyphs built into the "base font" in their OpenType counterparts.
  • Multiple master fonts were converted to individual OpenType fonts; each font consisting of a former Multiple Master instance.

For many Adobe Originals fonts, particularly those designed by Robert Slimbach, Adobe did some degree of redesign along with the conversion to OpenType.

The typeface Helvetica Narrow was not converted to OpenType, because the Type 1 original was a mathematically squished version of Helvetica, rather than an actually designed condensed typeface. This was originally done to conserve ROM space in PostScript printers.[11]

As a result of the above changes, Adobe no longer guarantees metric compatibility between Type 1 and OpenType fonts. However, Adobe claims the change is minimal for Adobe (not Adobe Originals) fonts, if:

  • Text is written in English
  • The formatted text contains only non-accented characters
  • Only characters that were present in the old fonts are used, without the former Symbol substitution characters
  • Applications are used which base line spacing solely on point size or leading, and not on the bounding box of the font

Original Composite Font

[edit]

Original Composite Font format (which uses a Type 0 file structure) was Adobe's first effort to implement a format for fonts with large character sets, debuted with PostScript level 2.

Adobe then developed the CID-keyed font file format which was designed to offer better performance and a more flexible architecture for addressing the complex Asian-language encoding and character set issues. Adobe does not document or support OCF font format.

OCF font metrics are described in Adobe Composite Font Metrics file.

Adobe Font Metrics, Adobe Composite Font Metrics, Adobe Multiple Font Metrics

[edit]

Adobe Font Metrics (AFM), Adobe Composite Font Metrics (ACFM), Adobe Multiple Font Metrics (AMFM) files contain general font information and font metrics information for the font program. These files are generally used directly only in Unix environments.

An AFM file provides both global metrics for a font program and the metrics of each individual character.

The metrics of a multiple master font are described by one AMFM file, which specifies the control data and global font information, plus one AFM file for each of the master designs in the font.

An ACFM file provides information about the structure of a composite font. Specifically, the global metrics of the composite font program and the global metrics of each of its immediately descendent font programs. ACFM file does not associate with a base font, but act as the top-level structure of a composite font. The character metrics of individual characters in the composite font are described completely by one of more associated AFM files.

The formats are sufficiently similar that a compliant parser can parse AFM, ACFM, and AMFM files.

Printer Font ASCII

[edit]

Printer Font ASCII (PFA) is a pure ASCII version of a Type 1 font program, containing in particular a font's glyph data. It is pure PostScript code without any sort of wrapper, and can be copied in full into a PS file to define the font to the PS interpreter. PFA is the preferred format for Type 1 fonts used in UNIX environments, and usually carries a ".PFA" file name extension.

Though these files syntactically can contain arbitrary PostScript code, they usually follow a rather rigid formula in order to allow readers that are less than full PostScript interpreters to process them (for example to subset the font). The first section of the file is called the clear text portion, and begins constructing those data structures that define the font in the PostScript interpreter; the information here are things Adobe in the 1980s were comfortable having public, and much of it would be present also in the companion AFM file. The last two operators in the clear text portion are currentfile eexec (encrypted exec), which instructs the interpreter to switch to reading the current file as an encrypted stream of instructions. The following encrypted portion is again PostScript code for finishing constructing the font data structures—a lot of it consists of charstrings, which is rather a kind of bytecode, but at the font definition stage those are merely data stored in the font—even if that code is encrypted (which produces arbitrary byte values) and then hex-encoded to ensure the overall ASCII nature of the file. The data structures created here are marked noaccess to make them inaccessible for subsequent PostScript code. The final action in the encrypted portion is to switch back to reading the file normally, but since eexec would read ahead a bit it was impossible to know at exactly which character normal processing would resume. Therefore, PFA files end with a trailer of 512 zeroes followed by a cleartomark operator that throws away any operands that might have ended up on the stack as a result of interpreting those zeroes starting from a random position.

Printer Font Binary

[edit]

Printer Font Binary (PFB) is a binary PostScript font format created by Adobe Systems, usually carrying ".PFB" file name extension. It contains a font's glyph data.

The PFB format is a lightweight wrapper to allow more compact storage of the data in a PFA file. The file consists of a number of blocks, each of which is marked as ASCII or binary. To recreate the corresponding PFA file, one takes the ASCII blocks verbatim and hex-encodes the binary blocks. The binary blocks are those which make up the encrypted portion of the font program.

LaserWriter Font

[edit]

LaserWriter Font (LWFN) is a binary PostScript font format used on Classic Mac OS, conceptually similar to the Printer Font Binary format but using the macOS resource fork data structure rather than a custom wrapper for the font data. It contains the glyph data for one font.

LWFN is the file type code for this kind of file. It would not carry any extension, and the file name would be an abbreviation of the PostScript name of the font, according to a 5+3+3+... formula: the name is read as being in CamelCase and split into subwords, up to 5 letters are kept from the first subword, and up to 3 letters of any subsequent subword. Palatino-BoldItalic would thus be found in the file PalatBolIta.

Printer Font Metric

[edit]

Printer Font Metric (PFM) is a binary version of AFM, usually carrying ".PFM" file name extension. It contains font metric information.

The PFM format is documented in the Windows 3.1 "Printers and Fonts Kit" help file (PFK31WH.HLP). Some details are also covered in the Windows 3.1 "Device Drivers Adaptation Guide" help file (DDAG31WH.HLP). Both of those documents are part of the Windows 3.1 Device Development Kit (DDK), which is still available (October 2008) to MSDN subscribers.

.INF

[edit]

.inf (INFormation) files contain application-specific information in plain ASCII text, such as font menu names for Windows and DOS-based applications. When a font is installed in Windows, the ATM Installer software takes the AFM and the INF file as input and generates the required PFM file at installation time. The AFM and INF files are not installed in the user's system.

.MMM

[edit]

.MMM files are used for the metric data needed by multiple master fonts for the Windows environment.

.OFM

[edit]

.OFM is the extension used by OS/2 for its version of binary font metrics file, starting from version 2.1.

Support for Microsoft Windows

[edit]

Windows 95, Windows 98, Windows NT 4 and Windows Me do not support Type 1 fonts natively. Adobe Type Manager is needed in order to use these fonts on these operating systems. Windows 2000, Windows XP and Windows Vista support Type 1 fonts natively through GDI calls. The Windows Presentation Foundation introduced in Windows Vista, which is also available for Windows XP however drops support for Type 1 fonts, in favor of Type 2 fonts.

For Microsoft Windows platforms that natively support PostScript, only binary PostScript and OpenType file formats are supported.

Windows Presentation Foundation (formerly codenamed Avalon) in Windows Vista supports rasterizing OpenType CFF/Type 2 fonts, whereas Type 1 fonts will still be supported in GDI, but not in GDI+.

PostScript font utilities

[edit]

The t1utils font utility package by I. Lee Hetherington and Eddie Kohler provides tools for decoding Type 1 fonts into a human-readable, and editable format (t1disasm), reassembling them back into fonts (t1asm), for converting between the ASCII and binary formats (t1ascii and t1binary), and for converting from Macintosh PostScript format to Adobe PostScript font format (unpost).

See also

[edit]

References

[edit]
[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia
from Grokipedia
PostScript fonts are a class of digital outline fonts developed by Adobe Systems, primarily in the Type 1 format, for integration with the page to deliver scalable, high-resolution in and digital applications. Introduced in 1984, these vector-based fonts use mathematical outlines—often defined by Bézier curves—to represent glyphs, allowing them to scale without loss of quality across different devices and resolutions. A key innovation was the inclusion of , which adjusts outlines at low resolutions to ensure crisp rendering on raster output devices like laser printers. The development of fonts stemmed from Adobe's creation of the language itself, founded by and in 1982 as a device-independent programming language for describing page elements, including text, graphics, and images. Evolving from earlier systems like Xerox's JaM and Interpress, PostScript treated fonts geometrically, enabling precise control over type rendering and paving the way for in the 1980s. By licensing popular typefaces and embedding font technology in printers, Adobe established PostScript as an industry standard, powering millions of devices and transforming professional from manual to digital workflows. While PostScript fonts revolutionized printing with their precision and portability, they have largely been superseded by more versatile formats like , which Adobe began promoting in 1996 to address limitations such as smaller glyph support and compatibility issues with modern software. Adobe announced the end of support for creating and editing Type 1 fonts in its applications by 2023, citing incompatibilities with contemporary browsers, operating systems, and the need for broader coverage. Despite this phase-out, the legacy of PostScript fonts endures in the evolution of technologies like PDF, which derives from principles and remains ubiquitous for document interchange.

History

Origins and Development

PostScript fonts originated from the pioneering work of and , who co-founded Systems in December 1982 after leaving Xerox's Palo Alto Research Center (PARC), where they had developed precursor technologies like page description language and early outline font systems. These efforts culminated in the creation of as a comprehensive , with its font architecture designed to support scalable, vector-based integrated directly into the language for high-quality printing. The fonts were invented specifically to enable device-independent rendering, allowing consistent typographic output across varying resolutions without reliance on fixed representations. The development drew significant influence from PARC's innovative graphical systems, including the workstation's early experiments with outline fonts and the broader push for device-independent to overcome the limitations of bitmap-based displays and printers prevalent in the late . Warnock and Geschke's prior projects at PARC, such as , emphasized mathematical descriptions of character shapes using curves, which directly informed PostScript's approach to scalable fonts that could adapt to different output devices like laser printers. This foundation addressed the era's need for professional-grade in computing, moving beyond pixelated bitmaps to enable smooth, resolution-independent text. PostScript 1.0, incorporating these font innovations, was released in 1984, marking Adobe's strategic decision to keep the underlying font format proprietary as a while making it licensable to hardware manufacturers for broad adoption. The first major commercial deployment occurred in 1985 with Apple's Macintosh computer and the printer, which bundled and its scalable fonts, revolutionizing by supplanting alternatives with high-fidelity, adjustable type that supported professional layouts at 300 dpi. This partnership, initiated through ' investment in Adobe, propelled fonts into widespread use, establishing them as a cornerstone of digital .

Evolution Across PostScript Versions

PostScript Level 1, released in , introduced Type 1 fonts as a scalable outline format designed for high-quality digital , featuring compact charstring encoding to minimize and declarative hinting mechanisms to ensure precise rendering on low-resolution devices by aligning stems and preserving character proportions. These fonts represented a significant advancement over earlier bitmap-based approaches, enabling device-independent scaling and supporting the Type Library's initial distribution for workflows. With the advent of PostScript Level 2 in 1990, font capabilities expanded to include support for color imaging, allowing fonts to integrate with composite color models like CMYK, and the introduction of Type 0 composite fonts, which enabled the creation of virtual fonts by combining multiple component fonts for efficient handling of complex scripts and ligatures. Improved data compression techniques, such as LZW for font resources, further reduced storage requirements while maintaining compatibility with Level 1 interpreters. These enhancements facilitated broader adoption in color printing environments and laid groundwork for multilingual font support through CID-keyed structures. PostScript Level 3, introduced in 1997, built on prior versions by enhancing integration with the Portable Document Format (PDF), enabling seamless distillation of PostScript files into PDFs with embedded fonts and device-independent color spaces like DeviceN for specialized printing. It expanded the core font set to 136 fonts, incorporating extensions for the Central European and Cyrillic character sets, and introduced features precursor to , such as advanced glyph substitution tables in CIDFonts for better handling of diacritics and variant forms. These updates improved rasterization efficiency and color accuracy, particularly for high-end RIPs in professional printing. In the post-2000 era, Adobe shifted emphasis toward fonts starting in 1996, converting many legacy Type 1 outlines to the CFF format for enhanced cross-platform compatibility and larger capacities, while preserving with interpreters through dual-format support. This transition was influenced by the late-1980s "font wars," where Apple's development of as a royalty-free alternative to Adobe's licensed Type 1 fonts sparked competition, ultimately leading to collaborative standards like to unify formats. Although fonts faced in favor of PDF workflows for document portability, they remained integral to high-end printing systems; in the 2010s, updates via CIDFont extensions provided limited support for legacy environments, accommodating broader character repertoires without full native integration. The core font sets evolved across levels, with Level 1 offering 35 base fonts, expanding significantly in subsequent versions to support diverse linguistic needs.

Technical Foundations

Font Architecture

PostScript fonts are structured as dictionaries within the language, enabling device-independent representation of scalable . The core of this architecture is the , which encapsulates all essential font data, including the FontName for identification, FontType to specify the format (such as 1 for Type 1 fonts), FontMatrix for scaling transformations, Encoding array for character-to-glyph mapping, CharStrings dictionary for glyph outlines, and Private dictionary for internal data. This dictionary-based organization allows fonts to be loaded and manipulated via operators like findfont and makefont, ensuring portability across PostScript interpreters. Glyph outlines in PostScript fonts are defined in the CharStrings , where each entry maps a name to a procedure composed of cubic Bézier curves. These curves are constructed using operators such as rcurveto (relative curve to) or curveto (absolute curve to), which specify control points in a unitless character space, typically scaled by a factor of 1000 for precision. The Encoding vector, an array of up to 256 elements, maps character codes (0–255) to these names, facilitating standard or custom character sets like StandardEncoding. Font metrics, including ascent (maximum height above baseline) and descent (maximum depth below baseline), are stored in entries like FontBBox (defining the overall bounding box as [llx lly urx ury]) or FontInfo , alongside sidebearing widths via commands like hsbw (horizontal sidebearing width). Scalability is inherent to this vector-based design, where glyph outlines are mathematical paths that can be transformed without quality loss. Points on a are scaled via the FontMatrix, commonly [0.001 0 0 0.001 0 0] for a 1000-unit em square, applied through operators like scalefont; for a uniform scale factor s, a transformed point is computed as (x', y') = (x × s, y × s), maintaining resolution independence across devices. To optimize storage in complex fonts, subroutine sharing employs the Subrs array in the Private dictionary, allowing CharStrings to call reusable segments via callsubr, reducing redundancy by up to nested depths of 10. The Private dictionary further supports vendor-specific data, such as keys for CharStrings or alignment zones, isolated from the Font Dictionary to preserve compatibility. Unlike bitmap fonts, which rely on fixed-resolution pixel grids prone to aliasing at varying sizes, PostScript fonts use these parametric outlines for infinite scalability, generating crisp output at any resolution through path filling and stroking. This architecture, exemplified in Type 1 fonts, underpins the device's output independence central to PostScript.

Rendering and Hinting Mechanisms

The rendering of PostScript fonts involves a that begins with the interpretation of code to define paths, followed by rasterization through scan conversion to produce pixel-based output on raster devices. During interpretation, character codes are mapped to descriptions via font dictionaries, employing operators such as moveto, lineto, and curveto to construct paths, which are then transformed by the current or font matrix. Rasterization converts these paths into device-space s using painting operators like fill and stroke, with scan conversion ensuring consistent thickness and preventing distortion due to pixel grid alignment. In Type 1 fonts, a dedicated hinting system optimizes this process at low resolutions by embedding instructions within charstrings to adjust glyph outlines for pixel grid fitting. These hints align stems—vertical or horizontal stroke elements—to the pixel grid; for instance, the stem3 instruction, implemented as { hstem3 } for horizontal stems or { vstem3 } for vertical ones, positions three equally spaced zones, such as in symbols like the equivalence sign or lowercase "m", without overlapping prior hstem or vstem hints. Blue zones, defined in the font's BlueValues array (up to seven pairs of y-coordinates, starting with the baseline and ensuring at least three units separation), enforce consistent alignment for features like cap height and x-height across glyphs, while optional OtherBlues handle additional zones such as descenders. For curves, flex hints enable smooth rendering of shallow segments, such as serifs, by treating two connected Bézier curves as a flexible unit that may simplify to a straight line at small sizes, constrained by parameters like BlueShift (typically the maximum flex height plus one); counter hints, often via hstem3 or vstem3, maintain uniform spacing in enclosed areas. Type 3 fonts differ markedly in rendering, as they permit arbitrary operators within the BuildGlyph or BuildChar procedures, allowing custom path construction and effects but introducing greater complexity and lacking the structured hinting of Type 1 fonts, which results in less optimized low-resolution output. In Level 2 and higher implementations, performance for large fonts is enhanced through optimizations like banding, which processes output in horizontal strips to manage memory efficiently and reduce errors, alongside techniques that support up to 1016 gray levels for smoother rasterization. Caching of rendered glyphs further mitigates repeated computation demands in these environments.

Font Types

Simple Fonts (Type 1 and Type 3)

Simple fonts in represent the foundational single-glyph font types, limited to 8-bit encodings that support up to 256 characters per font. These include Type 1 and Type 3 formats, which enable scalable outline definitions but differ in their implementation and flexibility. Type 1 fonts provide a standardized, compact structure optimized for professional , while Type 3 fonts offer programmable freedom for custom designs at the expense of built-in optimizations. Type 1 fonts, developed by as the standard outline font format, consist of a clear-text ASCII portion containing the font (including entries like FontName, FontBBox, and Encoding) and an encrypted binary portion that includes the Private and CharStrings. The CharStrings define outlines using a compact, encoded syntax resembling path operators, such as moveto, lineto, and curveto, with all CharStrings encrypted using a specific (starting key 4330) to protect designs. For example, a simplified unencrypted CharString for the 'A' might sequence as: hsbw 0 0 500 0 rmoveto 100 0 lineto 150 700 lineto 200 0 lineto closepath endchar, where hsbw sets horizontal metrics, rmoveto positions the start, and the path operators draw the outline before endchar terminates the definition. Hinting in Type 1 fonts employs standard hints like hstem and vstem to align stems to grids, and flex hints via subroutines (OtherSubrs 0-3) for smooth curve rendering at low resolutions. Type 3 fonts, in contrast, are user-defined and allow arbitrary procedures to construct glyphs, typically via the BuildChar procedure in LanguageLevel 1 or BuildGlyph in LanguageLevel 2, integrated into the font dictionary. These procedures can invoke any operators, including path drawing, clipping, or even imagemask for bitmap-like effects, while remaining scalable through the FontMatrix and current (CTM). Unlike Type 1, Type 3 fonts lack built-in hinting mechanisms, requiring designers to implement manual alignments within the procedures for consistent rendering across sizes. This format supports creative applications, such as textured or procedural glyphs, but demands careful management of the graphics state to avoid issues with save/restore operations. Encoding in simple fonts uses an 8-bit array mapping code points (0-255) to glyph names or indices, with common vectors like StandardEncoding (an Adobe extension of ASCII covering Western European characters) or ISOLatin1Encoding (aligned with ISO 8859-1 for Latin-1 supplement). Type 1 fonts often default to StandardEncoding, while both types permit re-encoding for custom needs, though limited to 256 glyphs total—leaving one slot (.notdef) for undefined characters. The seac operator, specific to Type 1, facilitates accented characters by combining a base glyph (e.g., 'e') with an accent component (e.g., acute), adjusting positions via width adjustments and the accent's left-side bearing, as defined in the CharStrings. A key limitation of Type 1 fonts is the strict 255 usable glyphs (excluding .notdef), necessitating multiple fonts or re-encoding for larger sets, alongside a cap of 1500 path elements per CharString to prevent excessive complexity. Type 3 fonts, while more flexible, inherit the 256-glyph encoding constraint and face challenges like no color support in cached glyphs, potential memory overhead from procedural execution, and incompatibility with global VM contexts. Historically, Type 1 fonts dominated early (DTP) from the mid-1980s, powering scalable in tools like and enabling high-quality output on PostScript printers. Type 3 fonts found niche use in custom effects, such as decorative textures or mathematical symbols, leveraging PostScript's full expressiveness before more structured formats prevailed.

Composite Fonts (Type 0 and Type 42)

Composite fonts in PostScript enable the aggregation of multiple subfonts to manage complex character sets efficiently, particularly for scripts requiring thousands of glyphs, such as those in . Unlike simple fonts, which handle individual glyph definitions, composite fonts use a hierarchical structure where a parent font dictionary references descendant fonts, allowing for modular organization and shared resources like metrics and hinting data. This design supports multi-byte encodings and character mapping via CMaps, facilitating international text rendering without embedding all glyphs in a single font dictionary. Type 0 fonts represent the primary composite format in , defined with a FontType entry of 0 in the font dictionary. They consist of a high-level parent dictionary that includes a DescendantFonts array (also known as FDepVector), which lists subordinate font dictionaries such as CIDFonts or other Type 0 fonts, enabling up to five levels of nesting for scalability. The parent font also specifies an Encoding entry, typically a CMap stream that maps input character codes to Character Identifiers (CIDs), which are then resolved to indices in the descendant fonts. An optional CIDToGIDMap entry or stream provides a direct mapping from CIDs to indices (GIDs) in TrueType-based CIDFonts, defaulting to an identity mapping if omitted to optimize selection. Introduced in Language Level 2, Type 0 fonts were specifically developed to handle large character collections in CJK (Chinese, Japanese, Korean) writing systems, where traditional simple fonts would be inefficient due to the sheer volume of glyphs—often exceeding 10,000 per font family. Within Type 0 fonts, composition rules leverage shared resources across descendants to maintain consistency. The FDArray (Font Descriptor Array) in associated CIDFonts is an of dictionaries that define like FontMatrix for scaling, FontName, and Private data for glyph subsets, metrics, and hinting instructions, ensuring uniform rendering behavior despite the modular structure. For instance, a Type 0 font might combine a Roman subfont (e.g., for Latin characters) with a Greek subfont (e.g., for polytonic accents and breathings) by assigning distinct CID ranges in the CMap, allowing seamless support for mixed-script text like classical without duplicating shared metrics. This approach reduces file size and improves interpreter performance by loading only relevant subfonts as needed. Type 42 fonts serve as a specialized composite variant, acting as a wrapper for fonts to enable their use in PostScript interpreters equipped with TrueType rasterizers, first supported in PostScript version 2010. The structure includes a FontType of 42, an identity FontMatrix, an sfnts array of strings embedding the TrueType sfnt tables (such as cmap for character mapping, loca and glyf for outlines), and a CharStrings mapping glyph names to indices for PostScript compatibility. Rendering proceeds by using the embedded TrueType tables: character codes are mapped via cmap, then resolved to outlines for rasterization, preserving the original TrueType quality without conversion to Type 1 outlines. An optional unique identifier (XUID) allows glyph bitmaps to be cached across jobs for efficiency. Type 42 fonts support subsetting and incremental downloading, making them suitable for large CJK TrueType collections, and function as a bridge between TrueType ecosystems (common in Windows and web applications) and PostScript printing environments, avoiding the need for full font conversion. Introduced in PostScript Language Level 2 alongside Type 0, they extend composite capabilities to non-PostScript outline formats while maintaining the hierarchical and modular advantages for complex scripts.

Specialized and Legacy Types (Type 2, 4, 5, 9-11, 14, 32)

Type 2 fonts represented an early implementation of encrypted outline fonts in the language, predating the standardized Type 1 format and utilizing a basic scheme for protecting font data during distribution. This approach was intended to safeguard glyph outlines but was abandoned due to vulnerabilities in the encryption method, which allowed unauthorized decryption and rendering the format obsolete by the late 1980s. Types 4 and 5 fonts were developed for low-resolution output devices, such as early printers with limited processing power, where Type 4 provided a pure representation of glyphs stored as pixel-aligned rasters for efficient rendering on font cartridges or ROM. Type 5 is similar to Type 4 but compressed for storage in the ROMs of printers, also known as a CROM (Compressed ROM) font. For scaling in these types, was employed to map pixels directly without , preserving sharpness at low pixels-per-inch resolutions typical of 300 PPI devices. These formats saw limited adoption beyond specialized hardware and were phased out in the as outline-based fonts gained prevalence for higher-quality rendering. Types 9, 10, and 11 are CID-keyed fonts that store Type 1, Type 3, and Type 42 glyphs, respectively, in a format compatible with the Macintosh operating system, integrating compatibility with Macintosh-specific . They emerged as proprietary extensions primarily for Apple Macintosh systems, facilitating seamless character mapping for Macintosh Roman and sets in cross-platform workflows, but their platform-specific design restricted broader use and led to deprecation following the shift to in the early . Type 14, known as the format, was introduced in Level 3 to enable dynamic font substitution within printer ROMs, employing a compact master font dictionary paired with variant descriptors to generate multiple styles from a single base without duplicating outlines. This memory-efficient approach supported 112 Latin-based core fonts but was confined to embedded printer applications, with no support in host-based rendering software like . Its specialized role contributed to its legacy status post-1990s. Type 32 fonts act as a wrapper for fonts using the Compact Font Format (CFF), allowing post-2000 embedding of CFF-based outlines in PDF files and streams while maintaining compatibility with legacy interpreters. Unlike earlier bitmap types, Type 32 supports scalable vector data derived from Type 2 charstrings, but explicitly excludes support for it in PDF generation to favor native formats. Although most specialized font types were phased out after the 1990s in favor of and , Type 32 persists for transitional PDF workflows involving converted CFF content.

Core Font Set

PostScript Level 1 Core Fonts

The PostScript Level 1 core fonts comprise a set of 35 base fonts standardized by in 1985 for embedding in printer ROMs, ensuring reliable text rendering across compatible devices without the need for external font downloads. These fonts form the foundational library for interpreters, focusing on Western European characters using the StandardEncoding scheme. Designed primarily as outline fonts (Type 1 format), they leverage cubic Bézier curves for scalable vector descriptions, allowing high-quality output at various resolutions. The set includes variations across 10 primary families, providing regular, bold, italic/oblique, and specialized styles to support diverse typographic needs in and printing. Key families and their variants are as follows:
FamilyVariantsNotes
ITC Avant Garde GothicBook, BookOblique, Demi, DemiObliqueCondensed geometric sans-serif; example of variants with adjusted widths for compact layouts.
ITC BookmanDemi, DemiItalic, Light, LightItalicSerif with high contrast; supports standard kerning pairs for improved readability.
CourierRegular, Oblique, Bold, BoldObliqueMonospaced typewriter-style; based on IBM's 1955 Selectric design for code and fixed-width text.
HelveticaRegular, Oblique, Bold, BoldOblique, Narrow, NarrowOblique, NarrowBold, NarrowBoldObliqueSans-serif; originates from Linotype's 1957 design by Max Miedinger, licensed by Adobe for PostScript.
New Century SchoolbookRoman, Italic, Bold, BoldItalicSerif with open counters; suited for body text.
PalatinoRoman, Italic, Bold, BoldItalicHumanist serif; elegant for headlines and books.
TimesRoman, Italic, Bold, BoldItalicSerif; adapted from Monotype's 1932 design for The Times newspaper, emphasizing legibility.
SymbolRegularMathematical and Greek symbols; non-text encoding.
Zapf ChanceryMediumItalicCalligraphic script for decorative use.
Zapf DingbatsRegularPictorial symbols and ornaments.
This totals 35 fonts, with the first seven families providing 32 outline variations and the last three adding specialized symbol sets. All fonts employ a uniform 1000-unit EM square for consistent scaling, where character coordinates are defined relative to this square via a default FontMatrix of [0.001 0 0 0.001 0 0]. Metrics include predefined character widths (e.g., 600 units for many em-widths in ) and pairs stored in Adobe Font Metrics (AFM) files, enabling precise spacing adjustments during rendering. Early PostScript Level 1 implementations also incorporated bitmap variants of the core 13 fonts (Times, , Courier families, and ) for optimized low-resolution output, such as on 75-dpi screens, where hand-tuned bitmaps improved at sizes like 10-12 points. The primary purpose of this core set was to guarantee portable, device-independent limited to Western scripts, facilitating immediate printing consistency in 1980s workflows. Later PostScript levels expanded this foundation with additional fonts for broader character support.

PostScript Level 2 and 3 Core Fonts

PostScript Level 2, introduced in 1990, expanded the core font set beyond the original 13 fonts of Level 1 to a standardized collection of 35 base fonts, primarily Type 1 outline fonts, to enhance compatibility and typographic versatility in printing environments. This expansion included nine additional outline font families, such as ITC Avant Garde Gothic (with Book, Book Oblique, Demi, and Demi Oblique variants), ITC Bookman (Light, Light Italic, Demi, Demi Italic), (Roman, Italic, Bold, Bold Italic), and New Century Schoolbook (Roman, Italic, Bold, Bold Italic), alongside variants of existing families like Narrow and the inclusion of and . These additions supported improved rendering for diverse document types, with font metrics incorporating features like optical scaling for better legibility across sizes. Level 2 also introduced composite font support via Type 0 fonts, enabling more efficient handling of complex character sets. Building on this foundation, PostScript Level 3, released in 1997, further broadened the core font set to 136 fonts, incorporating over 100 new additions to accommodate emerging platforms like /NT, Macintosh systems, , and the HP 110 font collection. Key new families included Albertus (Light, Roman, Italic), (Roman, Italic, Bold, Compact), Apple Chancery, (Regular, Italic, Bold, Bold Italic), Bookman expansions, variants, and symbol sets like Microsoft Wingdings and Apple Ornaments, with Dingbats receiving significant extensions for decorative elements. These fonts were provided in formats such as Type 1, (via Type 42), and the new format for 112 ROM-resident fonts, alongside the Compact Font Format (CFF) which reduced storage by 50-60% and facilitated embedding in documents like those produced by 3.0. Level 3 enhancements emphasized international compatibility, particularly through composite font support for the Central European (CE) character set, which added 253 characters, enabling coverage of languages like Baltic, Turkish, Czech, Hungarian, and Polish for a total of 315 glyphs. Licensing terms for these core fonts permitted embedding in files and PDFs, promoting widespread adoption while maintaining Adobe's control over distribution. Although Level 3 introduced capabilities for color separations in printing, the core font set focused on outline and bitmap glyphs rather than native color fonts. By Level 3, the cumulative core set, including variants, reached up to 136 base fonts, providing a robust foundation for professional .

Supplementary and Third-Party Fonts

In addition to Adobe's official core font sets, URW++ Design and Development Incorporated provided a collection of 35 high-quality Type 1 fonts as metric-compatible alternatives to the standard base 35 fonts, enabling broader compatibility in open-source environments. These URW++ fonts, such as Nimbus Roman No. 9 L, which closely mirrors the design and metrics of , were developed in the 1980s and integrated into systems like for free distribution. The base 14 subset of these URW++ fonts, including equivalents for , , and Times-Roman, became essential for PDF compliance, serving as drop-in replacements in Level 1 implementations without requiring proprietary licensing. Monotype and Linotype, major type foundries, extended the PostScript ecosystem through licensed contributions of their extensive font libraries, converting classic designs into Type 1 formats for digital typesetting. For instance, , originally designed by and released by Monotype in 1928, was adapted as a PostScript font family in the late 1980s, offering humanist styles with multiple weights and italics for professional printing and display applications. Linotype's involvement, particularly after its merger with Monotype in 2006, included PostScript versions of families like Frutiger and , which provided high-fidelity outline rendering on PostScript devices and were widely licensed for use in applications. Custom PostScript fonts, particularly Type 3 variants, allowed users and third-party developers to create specialized typefaces for unique purposes, bypassing the encryption and hinting of Type 1 fonts. Type 3 fonts, defined using 's general operators, were often employed for bitmap-based or procedurally generated glyphs in technical illustrations, maps, or experimental designs where precise control over rendering was needed. Third-party foundries like Font Bureau produced bespoke PostScript font sets, such as custom sans-serifs and display types for branding, emphasizing scalable outlines tailored to client specifications in the pre-OpenType era. In the 2020s, open-source fonts have gained prominence through distributions like , which bundles URW++ alternatives and supports the creation of custom Type 1 and Type 3 fonts for archival and rendering needs. These fonts ensure compatibility with standards for long-term document preservation, as 's interpreter handles Type 1 outlines in conformance with ISO 19005 specifications. PostScript font licensing has evolved from Adobe's proprietary model in the and —characterized by high fees and restricted distribution—to partial open standards following industry shifts post-2010. Adobe's 2021 announcement to end Type 1 support by January 2023 accelerated the transition to , an open specification co-developed with , allowing foundries to release -compatible outlines under more permissive licenses while phasing out encrypted Type 1 formats. This change, driven by competition and standardization efforts, has encouraged third-party vendors to offer convertible assets, reducing barriers for legacy integration.

Character Sets and Encodings

Standard Roman and Western Encodings

PostScript fonts employ several standard encodings to map character codes to glyphs for Roman and Western European scripts, ensuring compatibility with Latin-based text in documents and . These encodings are defined as 8-bit arrays in the language, typically supporting up to 256 positions, though the number of defined glyphs varies. They prioritize ASCII fundamentals extended with diacritics, symbols, and typographic elements suitable for Western languages, excluding complex scripts like CJK. The StandardEncoding serves as the foundational mapping for Type 1 fonts, accommodating 240 characters that include the full ASCII set (codes 0-127) plus extensions for basic Western symbols and spacing. For instance, code 0xA0 is assigned to the , while positions 0-31 and 127 are often reserved for control characters or mapped to the glyph. This encoding is built into the interpreter's system dictionary and acts as the default for Latin-text fonts, enabling straightforward rendering of English and simple European text without accents. ISOLatin1Encoding extends compatibility with international standards by aligning with ISO/IEC 8859-1, supporting 256 characters that incorporate Western European accented letters and symbols. It builds on StandardEncoding by reassigning positions 160-255 to include glyphs like é (0xE9), ü (0xFC), and À (0xC0), facilitating text in languages such as French, German, and Spanish. This encoding is also predefined in the PostScript system dictionary, allowing fonts to switch via the Encoding key for broader Western coverage without altering the core Roman base. AdobeStandardEncoding, a PostScript-specific variant, enhances typographic precision with dedicated slots for expert glyphs, including ligatures such as fi and fl, as well as old-style figures and fractions. It maintains the 256-position structure but prioritizes professional elements over some ISO mappings, making it ideal for Adobe's Type 1 font library where aesthetic details like swashes or superiors are needed. This encoding is referenced in font dictionaries to access supplementary Roman variants beyond basic ASCII. For PostScript Level 2 and higher implementations, Western 2 Encoding—also known as WinAnsiEncoding—adapts to code page conventions, supporting 256 glyphs with adjustments for environments. It diverges from ISO 8859-1 in positions like 0x91-0x94, which map to curly single and double quotes instead of control codes, and includes the symbol (0x80) for modern Western text. This ensures seamless integration with Windows applications while preserving Roman and Western European character support.
EncodingCharacter PositionsKey Features and ExamplesPrimary Use Case
StandardEncoding256 (240 defined)ASCII + (0xA0); .notdef for controlsBase for Type 1 Latin fonts
ISOLatin1Encoding256Accented chars: (0xE9), (0xFC)ISO 8859-1 Western European text
AdobeStandardEncoding256Expert glyphs: fi ligature, old-style figuresTypographic PostScript fonts
WinAnsiEncoding256Curly quotes (0x91-0x94), (0x80)Windows-compatible Western text
These encodings collectively cover Roman alphabets and Western diacritics up to 256 glyphs per font, focusing exclusively on single-byte Latin scripts.

International and CJK Encodings

introduced support for international character sets beyond the standard Roman encodings through multi-byte schemes, particularly for complex scripts in and , enabling global in documents and . These encodings leverage composite fonts (Type 0) with CID-keyed structures to handle large glyph sets efficiently, where character codes are mapped to unique Character Identifiers (CIDs) via CMap resources. For Central and Eastern European languages, Adobe CE encoding extends the ISO Adobe (Latin-1) set to include characters necessary for languages such as Croatian, Czech, Estonian, Hungarian, Polish, Romanian, Slovak, and Slovenian, aligning with ISO 8859-2 standards. Introduced in PostScript Level 2, this single-byte encoding adds diacritics and special letters like ć, ł, and ň, supporting up to 256 characters while maintaining compatibility with Western scripts. In , developed dedicated CID-keyed collections for Chinese, Japanese, and Korean (CJK) scripts, which require thousands of glyphs due to logographic systems. Adobe-GB1, based on the GB 2312-80 standard for Simplified Chinese, encompasses 7,717 glyphs in its initial collection (GB1-0), including 6,763 hanzi and associated punctuation, encoded via double-byte sequences in EUC-CN or GBK formats for Type 0 fonts. For Traditional Chinese, Adobe-CNS1 draws from the encoding and CNS 11643 Planes 1 and 2, providing 13,053 glyphs in CID form within the CNS1-0 collection, covering traditional hanzi, , and Taiwanese extensions to support horizontal and vertical writing modes in composite fonts. Adobe-Japan1 and Adobe-Japan2 address Japanese typography, rooted in Shift-JIS encoding, with Japan1 including over 6,000 from and extensions, totaling 8,284 glyphs in its initial version (Japan1-0) for hiragana, , and vertical typesetting. Japan2 supplements this by adding vertical variants and JIS X 0212 characters, enabling efficient CID mapping for composite PostScript fonts in publishing workflows. The Adobe-Korea1 collection supports Korean text per KSC 5601, featuring 2,350 precomposed alongside 488 and compatibility characters, structured as 9,333 CIDs (CIDs 0–9,332) in Korea1-0 for double-byte EUC-KR encoding in CID-keyed Type 0 fonts. Central to these international encodings is the CID-keyed structure in composite fonts, where CIDs serve as 16-bit indices (up to glyphs) for glyph access, extensible to 32-bit in advanced CMaps for larger collections; this allows a single font resource to reference multiple subfonts via an FMapType 9, optimizing storage and rendering for multi-script documents.

File Formats and Storage

Binary and ASCII Font Files

PostScript Type 1 fonts are stored in two primary file formats: Printer Font Binary (PFB) and Printer Font ASCII (PFA), which serve as wrappers for the underlying font program data. The PFB format encapsulates the font data in a compact binary structure, consisting of three segments each preceded by a 6-byte header. The header begins with the byte value 128 (0x80 in ), followed by a segment type identifier (1 for ASCII text, 2 for , or 3 for the end marker), and then a 4-byte length field indicating the size of the subsequent data, with the most significant byte last. Typically, the first segment (type 1) contains the initial ASCII header of the font program, including comments and the font dictionary up to the eexec command; the second segment (type 2) holds the binary encrypted portion with outlines; and the third segment (type 3) is a trailer of 512 zero bytes to mark completion. This segmentation allows for efficient storage and transmission, particularly when must be converted to for 7-bit channels, as the interpreter handles decryption of the eexec-encrypted sections using a key of 55665 followed by charstring-specific encryption with key 4330. In contrast, the PFA format represents the entire font program as a single ASCII text file, with binary encrypted sections encoded in hexadecimal pairs to ensure compatibility with text editors and 7-bit data channels. It lacks the explicit segment headers of PFB, instead relying on PostScript syntax within the font dictionary, such as /FontName and length indicators like /Length1 for the encrypted portion before the eexec command. The structure follows the standard Type 1 font program organization: an initial header with font metadata and encoding vector, the Private dictionary containing hinting parameters, the CharStrings dictionary defining glyph outlines as encrypted procedures, and an encoding array mapping characters to glyphs. Whitespace is permitted in PFA except in the first eight characters after encryption start, facilitating readability while the interpreter decodes the hex to binary during execution. PFB files, commonly using the .pfb extension, are preferred for applications on Windows and classic Macintosh systems due to their compactness, enabling easier embedding in documents and reduced storage needs. PFA files, with the .pfa extension, are used where ASCII compatibility is essential, such as in direct program inclusion via commands like (fontname.pfa) run. The binary nature of PFB typically halves the file size compared to PFA, as encoding doubles the space required for the same data. These formats often pair with supplementary metrics files for full font implementation, as detailed in related specifications.

Metrics and Descriptor Files

In PostScript fonts, metrics and descriptor files serve as auxiliary components that supply essential data for text spacing, positioning, and layout, independent of the glyph outline definitions. These files enable applications and printers to compute character widths, kerning adjustments, and bounding boxes without loading the full font program, facilitating efficient rendering and installation across platforms like Windows and OS/2. By separating metrics from outlines, they support faster processing during typesetting and device-specific adaptations, such as varying widths for different resolutions. The Adobe Font Metrics (AFM) file is an ASCII-text format that encapsulates global and per-character metrics for Type 1 and multiple master PostScript fonts. It begins with header keywords defining the font name, version, and encoding scheme, followed by global metrics like the FontBBox array, which specifies the font's overall bounding rectangle in units of 1/1000 em (e.g., /FontBBox [-168 -218 1000 898] for Times-Roman, indicating left, bottom, right, and top coordinates). Character metrics sections provide widths (WX keyword) and individual bounding boxes (B keyword) for each glyph, such as C 65 ; WX 722 ; B 15 0 706 674 for the 'A' glyph, ensuring precise horizontal spacing. Kerning pairs are detailed in a dedicated section with adjustments like KPX A V -135, reducing space between 'A' and 'V' by 135 units to improve visual balance. AFM files typically range from 15 KB for Roman fonts to larger sizes for complex sets, and they are generated from font design tools for use in PostScript interpreters. For composite fonts like Type 0, the Composite Font Metrics (ACFM) file extends the AFM format to describe hierarchical structures involving multiple descendant fonts. It includes global metrics similar to AFM but adds a Descendents keyword (e.g., 256 for CJK support) and sections listing subfont mappings, such as StartDescendent with FontName and FontBBox for each component (e.g., Ryumin-Light-H for horizontal Japanese text). This enables proper layout of international character sets by referencing metrics from base fonts without full outlines. ACFM files are around 35 KB and are crucial for multibyte encodings in Level 2 and later. The Printer Font Metrics (PFM) file provides a binary equivalent of AFM tailored for Windows environments, incorporating device-specific adjustments for Type 1 fonts. It stores widths, , and spacing in a compact structure derived from the Windows Kit (DDK), allowing printers to scale metrics for output resolutions. For instance, PFM files accompany .PFB outline files and include vendor-specific overrides, such as adjusted character advances for laser printers. This format ensures compatibility with Windows GDI for screen display and printing, often generated from AFM sources using utilities like AfmToPfm. Multiple Master Metrics (MMM) files support in multiple master PostScript fonts by defining parameters for design axes like , width, and optical size. These binary files, typically with .MMM extension on Windows, normalized coordinates (0 to 1) across up to four axes between 2–16 master designs, enabling instance generation via linear blending (e.g., interpolating from light to bold masters). They include axis-specific like non-linear mappings for optical adjustments, ensuring smooth transitions without shape distortions, and are referenced during font instantiation in interpreters. MMM files are integral to Type 1 extensions, allowing dynamic style variations while maintaining metric consistency. Windows setup files like .INF and .OFM further aid font installation and metrics handling. .INF files contain descriptive metadata, such as font family names and installation instructions, often bundled with .PFB and .PFM for automated registry entries via the Fonts control panel. For example, an .INF might specify pairs like AV -50 for integration into Windows font management. .OFM files, used in environments (with Windows compatibility via cross-platform tools), provide binary metrics compiled from AFM, including device widths and embedding flags for printing. These descriptors streamline deployment by separating installation logic from core metrics. Overall, these metrics and descriptor files optimize font performance by decoupling layout data from paths, reducing load times and enabling platform-specific optimizations like faster screen previews on Windows systems.

Compact and Composite Formats (CFF, CID, Multiple Master)

The Compact Font Format (CFF) is a binary format designed for efficiently representing Type 1 or CID-keyed fonts, enabling the storage of multiple fonts in a single FontSet unit through shared data structures and defaults. It employs Type 2 CharStrings for outlines, which use a more compact encoding than Type 1 CharStrings, and relies on indexed strings via a String INDEX for referencing standard and custom strings (SIDs ranging from 0 to 64999), minimizing redundancy. The format's structure includes a Header, Name INDEX, Top DICT INDEX, Global Subrs INDEX, and per-font elements like Private DICT and CharStrings INDEX, supporting embedding of code for extensibility in printer environments. CID-Keyed Fonts extend PostScript's composite capabilities specifically for large character sets, such as those in Chinese, Japanese, and Korean (CJK) languages, by mapping character codes to Character Identifiers (CIDs) through CMap files and organizing glyphs in a CIDFont file. Each CIDFont includes a Font Descriptor defining the character collection (e.g., Adobe-GB1-0) and Subrs for shared procedures, including hints like Counter Control for precise rendering. Variants include CIDFontType 0 for base fonts with direct outlines, CIDFontType 1 compatible with Type 1 formats, and CIDFontType 2 for rearranged composites referencing multiple underlying font types, allowing flexible assembly of complex repertoires while reducing memory usage compared to earlier formats. Multiple Master (MM) fonts build on Type 1 by enabling across up to four design axes—such as , width, or optical —between 2 to 16 master designs to generate intermediate instances on demand. For instance, a axis might span from light (e.g., coordinate 200) to black (e.g., 800), with the Blend operator performing linear or non-linear blending to compute outlines, ensuring consistent design integrity without "kinks" in interpolated forms. MM fonts are stored as extended Type 1 files, with design coordinates normalized to a 1–9999 range, and support dynamic instance creation via tools like Font Creator, though file sizes grow with master count and complexity. Prior to CID-Keyed Fonts, PostScript's original composite format used Type 0 fonts as high-level virtual fonts that manually referenced multiple descendant fonts (e.g., Type 1 or Type 3) via Encoding and descendant arrays, facilitating early support for mixed-language or extended character sets without built-in CID mapping. These Type 0 structures allowed nested composites but lacked the efficiency and scalability of later systems, often requiring explicit subfont links in code. In fonts with outlines, CFF data is encapsulated in the CFF table, mapping the binary FontSet to the sfnt wrapper while preserving Type 2 CharStrings and indexed structures for definitions, thus converting traditional formats into a cross-platform container. This integration adds -specific metadata, such as the 'name' table for font naming, without altering the core outline data. CFF achieves principal space savings over Type 1 formats through its binary representation, subroutine sharing via Subrs, and indexed encoding, which reduce file sizes by eliminating textual redundancy and enabling across fonts in a set.

Integration and Support

Microsoft Windows Compatibility

In early Windows versions prior to , Type Manager () functioned as a software renderer for Type 1 fonts, generating high-quality screen bitmaps from PostScript outlines to enable scalable display on systems lacking native support. integrated with the Windows (GDI) to intercept and scale font calls, ensuring smooth rendering without jagged edges on low-resolution screens. Starting with , Type 1 fonts gained direct installation support through pairs of .PFB files (containing binary outline data) and .PFM files (providing printer font metrics), which were placed in the system's Fonts folder via the Control Panel for system-wide availability. However, Microsoft's strategic preference for fonts—developed jointly with Apple to avoid royalties on formats—promoted hybrid environments where fonts were used alongside for printing while handled primary on-screen tasks. From onward, GDI+ introduced native rendering for fonts using outlines in Compact Font Format (CFF), improving scalability and cross-application consistency without requiring external tools like ATM. For printing, applications often fell back to dedicated drivers, such as Adobe's printer drivers, to convert GDI calls into commands for accurate output on -compatible devices. PostScript fonts in Windows environments have faced challenges from hinting differences, as PostScript Type 1 fonts offer limited instruction-based hinting compared to TrueType's grid-fitting, leading to discrepancies between on-screen rasterization (optimized for pixel grids via GDI or GDI+) and vector-based print output, where high-resolution rendering ignores screen-specific adjustments. Additionally, Unicode character mapping relies on the cmap table in OpenType-wrapped PostScript fonts, ensuring proper glyph substitution for international text in Windows applications. In the 2020s, legacy PostScript Type 1 fonts remain functional in through backward compatibility modes, though deprecated their support in August 2024, with planned removal in future updates to align with Adobe's 2023 end-of-support announcement. Modern integration persists via DirectWrite, Windows' text rendering API since Vista, which fully supports CFF-based PostScript fonts for high-quality, subpixel-anti-aliased display in applications.

Cross-Platform Utilities and Tools

The Font Development Kit for (AFDKO) provides a suite of command-line tools for developing and validating -based fonts, particularly for converting Type 1 and CID-keyed fonts into /CFF formats compatible across platforms. Key utilities include tx, which translates Type 1 font programs into Compact Font Format (CFF) data while preserving hinting instructions, and stemhint, which analyzes and adjusts stem widths for consistent rendering at small sizes. For CID fonts, tools like makeotf assemble multiple-master or CID-keyed structures into single files, enabling cross-platform deployment without proprietary dependencies. The kit's FontValidator component scans -derived files for structural errors, such as invalid glyph outlines or encoding mismatches, ensuring compatibility on Windows, macOS, and systems. Commercial font editors like and Glyphs offer integrated environments for designing and exporting PostScript-compatible fonts across macOS and Windows. 8 supports direct editing of PostScript outlines using cubic Bézier curves, with export options for Type 1 fonts or conversion to PS via its TransType utility, which handles legacy PostScript files by embedding them into modern formats while optimizing for cross-platform rendering. Glyphs 3, primarily for macOS but with export tools usable on other systems, allows creation of fonts with PostScript outlines and selective hinting export, generating /CFF files that maintain PostScript precision for vector-based applications like PDF generation. Both editors facilitate management of font metrics, such as and ligatures, ensuring seamless integration in multi-platform workflows without OS-specific adjustments. Open-source tools extend accessibility for PostScript font handling on , macOS, and Windows. Ghostscript serves as a robust interpreter for PostScript language files, including font subsets, and its ps2pdf utility converts PostScript documents with embedded Type 1 fonts into PDF format, preserving outline quality and enabling platform-agnostic distribution. The t1utils package provides essential conversion functions for Type 1 fonts, with t1asm assembling human-readable font programs (from disassembled PFA/PFB files) into binary or ASCII formats, allowing developers to modify and rebuild PostScript fonts for cross-system compatibility. Complementing these, is a free editor that imports, edits, and exports PostScript Type 1 and CID fonts, supporting operations like interpolation and hinting adjustments to produce files usable in diverse environments, from web embedding to print production. For font organization and validation, dedicated managers like FontAgent streamline workflows involving PostScript assets. FontAgent scans and catalogs Type 1 PostScript fonts alongside variants, offering activation controls, duplicate detection, and metadata viewing to prevent conflicts in cross-platform libraries. Adobe's AFDKO tools, including its , can be integrated into pipelines to batch-check PostScript-derived files for compliance with standards like those in , ensuring reliability across operating systems without manual intervention. RoboFont, a scripting-focused editor for macOS, enhances PostScript hinting through Python-extensible parameters that adjust stem snapping and alignment zones, supporting exports to OpenType PS for consistent low-resolution rendering in multi-platform applications.

References

Add your contribution
Related Hubs
User Avatar
No comments yet.