PostScript

History

PostScript's conceptual lineage predates Adobe. Related ideas trace to page and imaging languages developed at Xerox PARC, including the "Press" printer format of the mid-1970s and "JaM" (created in 1978 by Martin Newell and John Gaffney). At Xerox PARC, a group that included John Warnock and Charles Geschke worked on Interpress, a page-description language for controlling laser printers. When Xerox was slow to commercialize Interpress, Warnock and Geschke left to build a product of their own.

Warnock and Geschke founded Adobe Systems in December 1982 (the company was named after Adobe Creek). Working with Doug Brotz, Ed Taft, and Bill Paxton, they developed PostScript — a language conceptually related to Interpress but redesigned. PostScript was Adobe's first product and reached the market in 1984. The earliest surviving source code, released publicly by the Computer History Museum in 2022 with Adobe's permission, is dated to late February 1984 (this is the date of the surviving artifact, not necessarily the first PostScript code ever written).

A pivotal early relationship was with Apple. Steve Jobs engaged Adobe around 1983, and Apple licensed PostScript (accounts cite a royalty advance together with an equity investment, though the exact figures differ between sources). Apple's LaserWriter, announced January 23, 1985 and shipping that year, was the first printer to ship with PostScript. Combined with page-layout software such as Aldus PageMaker and the Macintosh, the LaserWriter is widely credited with launching the desktop-publishing revolution of the mid-1980s.

Subsequent major revisions followed: PostScript Level 2 in 1991 and PostScript 3, announced at the end of 1997 (with products shipping around 1998). The original 1984 release was simply "PostScript"; the "Level 1" designation was applied retroactively once Level 2 existed. Adobe also created Display PostScript (DPS) to use the same imaging model for on-screen rendering, notably on NeXT computers. In the 1990s Adobe developed PDF, which shares PostScript's imaging model, and over the 2000s print workflows increasingly shifted toward PDF-based pipelines.

What problem it solved

Before device-independent page-description languages, output was tightly coupled to specific printer hardware and command sets: fonts, layouts, and graphics often had to be re-authored or re-encoded for each device, and quality was limited by device-specific bitmap fonts and control codes.

PostScript let a single document description drive many different output devices — from an office laser printer to a high-resolution imagesetter — at each device's native resolution. Because everything (text, line art, and images) was expressed in one common mathematical model, content could be scaled, rotated, and positioned freely, and the same file could produce consistent results across different manufacturers' devices. This decoupling of document content from device hardware is what made professional-quality output reproducible and portable.

How it works

A PostScript file is a program written in the PostScript language. The language uses postfix (reverse-Polish) notation and an operand stack: operators consume operands that have been pushed onto the stack. It describes an imaging model in which all marks on the page are built from straight lines and cubic Bézier curves — filled or stroked — plus sampled (raster) images and color. Text is treated as graphics: glyphs are outline descriptions, and Adobe's Type 1 font format uses Bézier outlines together with "hinting," procedures that improve legibility at low resolutions.

An interpreter — the Raster Image Processor, or RIP — executes the program. Because PostScript is a full, dynamically typed, Turing-complete programming language, a file can contain variables, procedures, loops, and conditionals, and can compute content at RIP time. The interpreter maintains a graphics state (current transformation matrix, colors, clipping path, current font, and so on). The final step is rasterization: converting the resolution-independent description into a pixel or dot bitmap at the output device's resolution.

Where it sits in the print/document pipeline

PostScript sits between the authoring application and the physical marking engine. An application, or its print driver, generates a PostScript description of the page. That description is transmitted to a RIP — which may live inside the printer, in a dedicated hardware or software RIP server, or as a software component on a host computer.

The RIP interprets the PostScript, applies device-specific settings such as resolution, halftoning or screening, and color separations, and produces the raster that drives the marking engine (laser printer, imagesetter, platesetter, and the like). In prepress specifically, PostScript historically carried jobs from design applications through to imagesetters and platemaking. To make files more portable and predictable across this pipeline, Adobe defined the Document Structuring Conventions (DSC), a commenting and structuring convention for PostScript files.

Relationship to printers

PostScript is a printer-control and imaging language, and a "PostScript printer" is one containing (or fed by) a PostScript interpreter/RIP. The first such printer was the Apple LaserWriter, announced in 1985.

Many manufacturers licensed PostScript to build compatible devices, which is part of why it became a cross-vendor standard in professional printing. High-end, office, and workgroup laser printers commonly supported PostScript. Over time, low-cost consumer printers — especially inkjets — frequently omitted onboard PostScript in favor of cheaper host-based rendering and simpler proprietary or standardized languages.

Relationship to operating systems

PostScript's imaging model influenced operating-system display technology. Adobe created Display PostScript (DPS) to render on screen using the same model used for print; DPS was used most prominently in NeXTSTEP on NeXT computers.

On other platforms, PostScript is typically handled through printing subsystems and drivers rather than serving as the native screen-imaging model. On Unix and Linux, the CUPS printing system and interpreters such as Ghostscript (a PostScript/PDF interpreter) are commonly used to process PostScript. Windows and macOS support PostScript printing via drivers and print pipelines, though modern systems increasingly use PDF-centric spooling.

Relationship to PDF / PostScript / drivers

PDF (Portable Document Format), developed by Adobe in the 1990s, shares PostScript's imaging model, and the two are largely mutually convertible for their graphics and text content. The key difference is that PostScript is a general-purpose programming language — with variables, control flow, and RIP-time computation — whereas PDF is a fixed, page-oriented document format that deliberately omits general programmability. That omission makes PDF more predictable, page-random-access, and easier to view and archive.

EPS (Encapsulated PostScript) is a constrained PostScript form used to embed a single graphic in other documents. On the driver side, print drivers or applications emit PostScript — often following Adobe's Document Structuring Conventions (DSC) — for a RIP to interpret. Over time, print workflows have shifted toward PDF as the interchange format (for example, Adobe's PDF Print Engine initiative in the 2000s), with PDF increasingly replacing PostScript as the file that moves through the pipeline.

Modern use

PostScript remains in use in professional and high-end printing and prepress, and interpreters such as Ghostscript keep it usable across platforms for viewing, conversion, and printing. However, its role has narrowed: PDF has become the dominant document interchange format and increasingly the native print-pipeline format, and many consumer printers never included PostScript.

PostScript's imaging model persists indirectly through PDF, which is derived from it. The Type 1 font format built for PostScript has also been largely superseded — Adobe stopped developing Type 1 fonts and ended support for them across its applications after January 2023 — with OpenType (co-developed by Adobe and Microsoft) serving as the common successor.

Advantages

• Device independence: one description drives many devices, each at its native resolution.
• Unified imaging model: text, vector art, and images are described in one mathematical framework, so content can be scaled, rotated, and transformed without loss.
• Cross-vendor standardization through licensing, with publicly available language specifications.
• Full programmability: a page can be computed at RIP time, enabling flexible, data-driven output.
• High-quality typography via outline fonts with hinting.

Limitations

• Programmability adds complexity and potential unpredictability: a job's output can depend on interpreter state and execution, and files are not random-access by page.
• Interpreting and rasterizing complex PostScript can be computationally heavy, historically requiring capable RIPs.
• No built-in page-independence or the fixed, self-contained predictability that PDF later provided; PostScript also lacks native features PDF added over time, such as transparency in later PDF versions.
• Onboard PostScript interpreters added cost, contributing to its absence on many low-end printers.
• As a general language, poorly structured PostScript can be fragile across interpreters, which is why conventions like DSC were needed to make files more portable.

Related standards and protocols

• Interpress (Xerox) — the page-description language predecessor from which PostScript conceptually descended.
• PCL (Printer Command Language) — an alternative printer-language ecosystem.
• PDF — Adobe's fixed-layout document format, which shares PostScript's imaging model.
• EPS (Encapsulated PostScript) — a single-graphic subset used for embedding.
• Document Structuring Conventions (DSC) — a commenting and structuring convention for portable PostScript files.
• Type 1 fonts / OpenType — the PostScript outline font format and its later successor.
• Print subsystems and interpreters — such as CUPS and Ghostscript — used to process PostScript.

Timeline

1. mid-1970s

   Xerox PARC develops the "Press" printer format.

2. 1978

   "JaM" language created at Xerox PARC by Martin Newell and John Gaffney.

3. late 1970s–early 1980s

   Interpress developed at Xerox PARC (contributors include Warnock and Geschke); Xerox is slow to commercialize it.

4. December 1982

   John Warnock and Charles Geschke found Adobe Systems.

5. 1983 (era)

   Steve Jobs / Apple engages Adobe; Apple licenses PostScript.

6. February 1984 (era)

   Date of the earliest surviving PostScript source code, later released publicly by the Computer History Museum in 2022.

7. 1984

   PostScript first brought to market (later retroactively called Level 1); Adobe's first product.

8. January 23, 1985

   Apple LaserWriter announced; the first printer to ship with PostScript, catalyzing desktop publishing.

9. late 1980s

   Display PostScript created; used on NeXT computers.

10. 1991

    PostScript Level 2 introduced (in-RIP separations, image decompression such as JPEG/CCITT, composite fonts, forms and caching).

11. 1990s

    Adobe develops PDF, sharing PostScript's imaging model.

12. 1997

    PostScript 3 announced (products shipping around 1998); improved color handling and new filters.

13. 2000s

    Print workflows shift toward PDF-based pipelines (for example, Adobe PDF Print Engine); onboard PostScript becomes uncommon on low-end printers.

14. 2022

    Computer History Museum publicly releases early PostScript source code, with Adobe's permission.