PostScript

PostScript is a stack-based, Turing-complete page description language created by Adobe Systems and first released in 1984. Rather than storing a page as a fixed grid of pixels, a PostScript document is a program: a sequence of instructions that, when executed by an interpreter, draws text, lines, curves, and images at whatever resolution the output device supports. This simple but radical idea — that a printed page is the result of running code — turned printers into small computers and made high-quality, device-independent output available to anyone with a desktop machine.

For most of its life PostScript has been invisible to the people who depend on it. It hums inside laser printers, imagesetters, and print servers, quietly translating the layouts produced by design software into precise marks on paper or film. Yet it is a genuine programming language, complete with variables, control flow, procedures, and data structures, and it remains a foundational piece of the modern world of documents and printing.

History and Origins

PostScript’s lineage runs through Xerox PARC, the legendary research center where so much of modern computing took shape. There, John Warnock worked on Interpress, a page description language intended to drive Xerox’s laser printers, building on earlier experimental work including a system called JaM (for “John and Martin,” after John Gaffney and Martin Newell), which had been developed at Xerox PARC in the late 1970s. Frustrated that Xerox was slow to commercialize these ideas, Warnock and his colleague Charles “Chuck” Geschke left to found Adobe Systems in December 1982.

Adobe’s original business plan involved building complete printing systems, but the founders soon recognized that the real value lay in the language itself. Working with Doug Brotz, Ed Taft, and Bill Paxton, they designed PostScript as a cleaner, more general successor to Interpress and released it in 1984.

The decisive moment came in 1985. Apple’s Steve Jobs saw the potential of pairing PostScript with Apple’s new laser printer hardware, and the Apple LaserWriter shipped that March with a PostScript interpreter built in. Together with the Macintosh and Aldus PageMaker, the LaserWriter created the first practical desktop publishing system — one in which what you designed on screen could be printed faithfully at high resolution. PostScript was the technical glue that made this possible, and Adobe’s licensing of interpreters to printer manufacturers became the engine of the company’s early growth.

Design Philosophy

At its heart, PostScript embodies a single elegant principle: a page is a program. Instead of a static description of where ink goes, a PostScript file is executable code that computes the page. This makes it inherently device-independent — the same program renders crisply on a 300-dpi office printer or a 2,400-dpi imagesetter, because the interpreter resolves the geometry against whatever hardware it is running on.

The language itself is stack-based and uses reverse Polish (postfix) notation, a design clearly influenced by Forth. Operands are pushed onto an operand stack, and operators consume them and push results back. To add two numbers and print the result, you write:

1

2 3 add =

Here 2 and 3 are pushed onto the stack, add pops them and pushes 5, and = pops and reports the value. Drawing follows the same pattern — coordinates and parameters precede the operator that uses them:

1
2
3
4
5

%!PS
/Helvetica findfont 24 scalefont setfont
72 720 moveto
(Hello, World!) show
showpage

This small program selects a 24-point Helvetica font, moves to a point on the page, paints a string, and emits the page. The structure reveals PostScript’s other inheritances: dictionaries and arrays as first-class data structures recall Lisp, while its overall sensibility owes something to Mesa and to Interpress before it.

Key Features

• Imaging model: A consistent, mathematically defined model of paths, fills, strokes, clipping, and coordinate transforms that produces resolution-independent vector graphics.
• Scalable type: PostScript fonts — most famously the Type 1 format — describe glyphs as outlines with hinting information that keeps them legible at small sizes and low resolutions.
• Turing-complete programming: Full procedures, conditionals, loops, recursion, and arithmetic mean a PostScript file can compute its content rather than merely list it.
• Dictionaries and dynamic typing: Names and values live in dictionaries arranged in a stack of scopes; values carry their types at runtime.
• Encapsulated PostScript (EPS): A disciplined subset, introduced in 1987, that lets a single graphic be embedded cleanly inside other documents.

Evolution

PostScript advanced through three major generations. The original Level 1 (1984) established the language and imaging model. Level 2, released in 1991, brought meaningful performance gains, in-RIP color separation, data compression and image decompression, better memory management, and composite fonts for large character sets. PostScript 3 — announced in 1996 and shipping in products from 1997 — dropped the “Level” naming, improved color and shading, and added direct handling of PDF and many image formats. PostScript 3 remains the most recent major version.

Two offshoots extended PostScript’s reach. Display PostScript (1988) applied the same imaging model to interactive screens, most notably as the graphics foundation of the NeXT computer. More consequentially, in 1993 Adobe introduced the Portable Document Format (PDF) — a fixed, non-programmable descendant that kept PostScript’s imaging model and font technology but replaced the full programming language with a static, more predictable file structure. Over the following decades PDF largely displaced PostScript for distributing documents, while PostScript persisted where it was strongest: driving the actual printing hardware.

Current Relevance

Although it is rarely written by hand, PostScript is far from a museum piece. It remains a working standard in professional printing and prepress, where RIPs interpret PostScript (and PDF) to drive high-end output devices. The open-source Ghostscript interpreter renders and converts PostScript across an enormous range of software, and underpins much of the printing stack on Unix and Linux systems. Scientific and technical tools — among them gnuplot, TeX via dvips, and many plotting libraries — have produced Encapsulated PostScript figures for decades, and the format endures in academic publishing.

The long sunset of the original Type 1 font format — Adobe ended support for authoring with Type 1 fonts in its applications in January 2023 in favor of OpenType — marks the gradual retirement of PostScript’s earliest font technology. But the imaging model that Type 1 helped popularize lives on in OpenType, PDF, and beyond.

Why It Matters

PostScript is one of the most quietly influential languages ever created. By reframing a printed page as the output of a program, it decoupled the description of a document from the device that renders it — an abstraction so successful that it became invisible. It made desktop publishing possible, built Adobe into a major company, and seeded the technologies that followed: its imaging model and fonts flow directly into PDF, the format in which much of the world now reads. As a piece of language design, PostScript is also a rare example of a concatenative, stack-based language reaching mass deployment, a living demonstration that the ideas behind Forth could power something used by hundreds of millions of people who never knew its name.