The Language That Taught Machines to Print

Every revolution needs its frustrated idealists. At Xerox PARC—the legendary lab that also birthed the graphical user interface and Ethernet—John Warnock and Chuck Geschke had built something remarkable: a language called Interpress that could describe any printed page in pure mathematics. No more sending bitmaps. No more printer-specific formats. One language to rule all output devices.

Xerox, in its infinite corporate wisdom, decided to sit on it. Interpress would remain an internal standard for Xerox hardware only—no licensing, no outside adoption. It was the Xerox PARC story repeating itself: brilliant invention, bureaucratic burial.

So in December 1982, Warnock and Geschke walked out and founded Adobe Systems, named after the creek that ran behind Warnock's home in Los Altos. Their original plan was to build a high-end printing workstation. But a 1983 meeting with Steve Jobs changed everything. Jobs convinced them to abandon hardware entirely and focus on what they knew best: the language. License it as the "brain" for other companies' printers. Let the software be the product.

It was the pivot that launched an industry. Within two years, that language—PostScript—would fundamentally change what was possible with a desktop computer and a laser printer.

Here's what printing looked like in 1984: most offices used daisy wheel printers—motorized typewriters that physically smacked letter-shaped metal slugs onto paper. Want to change fonts? Stop the printer, pop out the plastic wheel, snap in a different one. Graphics? Forget it. A logo required a separate photocopier pass with a physical cut-and-paste overlay.

Professional typesetting was a guild. You needed a $50,000+ phototypesetting machine, a technician trained to operate it, and days of turnaround for even minor changes. Starting a newsletter? Better have deep pockets and a patient disposition.

Then, in 1985, three technologies arrived within months of each other—what industry historians call the "three-legged stool" of desktop publishing:

Apple invested $2.5 million in Adobe for a 19% stake. Jobs insisted on the LaserWriter's staggering price tag—$6,995 in 1985 dollars, over $20,000 today—because he understood something competitors didn't. PostScript's device independence meant an entire office could share one printer over AppleTalk. The cost-per-user dropped dramatically, and the output quality was indistinguishable from professional typesetting.

Overnight, the economics of publishing inverted. A $10,000 setup (Mac plus LaserWriter plus PageMaker) could produce output that rivaled shops charging $55,000 in equipment alone. The guild gates swung open.

PostScript wasn't a file format. It was a Turing-complete, stack-based programming language—closer to Forth than to anything you'd call a "document format" today. Every PostScript file was a program. Your printer didn't just receive data; it executed code.

This sounds like an overengineered disaster, but it was the key insight that made everything else possible. Instead of sending a bitmap—a grid of "dot here, no dot there"—PostScript described pages as mathematical operations. It didn't say "place a black pixel at coordinates (142, 891)." It said: newpath 100 200 moveto 120 280 180 320 200 250 curveto stroke—draw a Bézier curve through these control points and render it.

The implications were profound. Device independence meant a single PostScript file could be printed on a 300-dpi office laser printer for a draft, then sent to a 2,540-dpi Linotronic imagesetter for camera-ready film—identical output at every resolution, because the math scaled perfectly.

Fonts got the same treatment. Adobe's Type 1 fonts weren't just character outlines—they were PostScript programs containing "hints," logic that adjusted letterforms at small sizes so a 9-point serif didn't collapse into an illegible blob on a 300-dpi printer. Fonts became software.

PostScript evolved through three major versions: Level 1 (1984) established the core path-based imaging model. Level 2 (1991) added color management, patterns, and JPEG compression. Level 3 (1997) brought smooth gradient shading and advanced transparency. Each level maintained backward compatibility—a Level 1 file ran perfectly on a Level 3 interpreter. That kind of discipline is rare in computing.

Adobe's PostScript licensing model was extraordinarily profitable—and, depending on your perspective, either brilliantly fair or extortionately monopolistic. Every printer manufacturer that wanted PostScript compatibility paid Adobe a per-unit royalty. This "Adobe tax" added hundreds of dollars to each printer's cost, and Adobe controlled the only certified interpreter.

The backlash came from two directions at once. In 1989, Microsoft and Apple formed an unlikely alliance to break Adobe's grip, developing TrueType (an alternative font format) and TrueImage (a PostScript clone). Hewlett-Packard pushed its own PCL (Printer Command Language) as a faster, cheaper alternative for offices that didn't need PostScript's full graphics power.

But the most consequential response came from the open-source world. In 1988, programmer L. Peter Deutsch created Ghostscript—a free, open-source PostScript interpreter. Ghostscript did for Unix and Linux what Adobe's interpreter did for commercial printers, and it remains a critical piece of the CUPS printing stack that powers printing on macOS and Linux to this day.

The clone wars ultimately benefited everyone. Competition forced Adobe to open up—they eventually published the full Type 1 font specification in 1990—and the ecosystem that grew around PostScript ensured the language outlasted any single company's control over it.

By the early 1990s, PostScript had conquered the printer. But a new problem was emerging: people needed to share documents on screen, across different computers and operating systems, and PostScript was terrible at this.

In 1991, John Warnock wrote an internal memo called "The Camelot Project" that diagnosed the problem with remarkable clarity. He described the "maddening chaos" of trying to share a document between a Mac, a Windows PC, and a Unix workstation. Each platform had different fonts, different screen resolutions, different rendering engines. What looked perfect on your machine was garbage on someone else's.

The solution was PDF—the Portable Document Format—and its design was an exercise in disciplined subtraction. PDF kept PostScript's imaging model: the Bézier curves, the color management, the font embedding, the mathematical page description. But it stripped out the programming. No loops. No variables. No conditional logic. No Turing completeness.

This wasn't a weakness—it was the entire point. Because PDF wasn't a program, you could jump to page 500 without "executing" the first 499 pages. You couldn't embed an infinite loop that would crash a viewer. And the file could be compressed, indexed, and searched in ways that a PostScript program never could. PDF launched in June 1993 and eventually became ISO standard 32000 in 2008. It is, quite literally, PostScript's greatest child.

Open your MacBook. Launch any application. Every pixel you see on screen is rendered by a graphics engine whose lineage runs directly back to PostScript.

When Steve Jobs founded NeXT in 1985, he licensed Display PostScript from Adobe to drive the entire screen—not just the printer. The concept was radical: a "unified imaging model" where the screen and the printer saw exactly the same mathematical description. What you saw was literally what you got. When Apple acquired NeXT in 1997, Display PostScript's DNA evolved into Quartz 2D, the rendering engine that still powers macOS and iOS today.

The fingerprints are everywhere once you know where to look. The d attribute in an SVG <path> element? It uses M (moveto), L (lineto), and C (curveto)—direct descendants of PostScript operators. CSS clip-path and shape-outside? Same mathematical model. The Ghostscript interpreter still processes millions of print jobs daily through the CUPS printing system on every Mac and most Linux machines.

PostScript's deepest legacy, though, isn't technical—it's cultural. Before 1985, publishing was a profession with a capital barrier. After PostScript, it was a capability. Every blog, every indie zine, every self-published book, every Substack newsletter owes something to the language that first proved a page could be described in mathematics and printed by anyone with a computer and a laser printer. The tools changed. The principle hasn't.