HyperCard

HyperCard was a hypermedia authoring system and programming environment that Apple shipped for the Macintosh from 1987, and it is often described as the first tool to put programming within reach of a mass audience. Its creator, Bill Atkinson, called it a “software erector set.” You built a stack of cards, placed buttons, text fields and pictures on them, and linked them together. Then, if you wanted, you wrote scripts in HyperTalk, an English-like language designed by Dan Winkler, to make those objects respond to clicks, keystrokes and navigation. Because Apple bundled HyperCard with new Macs for several years, teachers, artists, librarians, hobbyists and office workers suddenly had a programming system they could open, inspect and change. Its ideas show up in many later systems: JavaScript’s event handlers, AppleScript’s object references, the first wiki and the early web browser Viola all trace part of their design to HyperCard.

History & Origins

Bill Atkinson and WildCard

Bill Atkinson was one of the most important engineers on Apple’s original Macintosh team. He wrote QuickDraw, the Mac’s graphics engine, and MacPaint. Early on he had also written Rolo, a simple free-form card-file program. In the mid-1980s he began a larger project called WildCard. Contemporary accounts describe it as built around four ideas: buttons to push, text fields to type into, screens (“cards”) holding buttons, fields and graphics, and automatic links that take you from one card to another.

The fourth idea, linking, grew into a full scripting language. Dan Winkler designed HyperTalk, and the product was renamed HyperCard, for trademark reasons according to most histories. The old name survived in HyperCard’s Macintosh creator code, WILD. The release came with a condition. TidBITS credited Atkinson with requiring that a version ship free with every new Mac, and in 1994 Matt Neuburg repeated the story that Atkinson had threatened to give HyperCard away himself if Apple would not bundle it.

Launch: August 1987

Apple announced HyperCard at the Macworld Expo in Boston on 11 August 1987. It shipped free on new Macs, and existing owners could buy it for about $49. The response was immediate. InfoWorld headlined its show report “Hypercard Steals Show At Macworld Exposition.” Danny Goodman’s The Complete HyperCard Handbook, published alongside the software, became a best-seller, and user groups set up HyperCard special-interest groups within months. Because the program was free and every stack’s scripts were open to anyone who had it, a large culture of shared “stackware” grew up quickly through user groups, bulletin boards and online services.

HyperCard 2.0 and the Claris years

After Atkinson moved on, HyperCard engineer Kevin Calhoun led the work on HyperCard 2.0, which Apple announced in mid-1990. TidBITS reported in June 1990 that the release included variable card sizes, multiple windows, multiple fonts and styles in a single field, “hot text” through new clickText, clickLine and clickChunk functions, a modeless script editor, a run-time compiler and debugging tools.

That same year Apple moved HyperCard to Claris, its software subsidiary, effective November 1990. Claris tried to make the product earn money by selling the authoring tools separately. New Macs came with a version set to a restricted user level, while the full documentation and development kit were sold. This upset many longtime users, who had come to think of HyperCard as part of the Mac. Development slowed, and a planned “2.5” with integrated color was reportedly abandoned. Competitors such as SuperCard, which offered color and multiple windows early, began to win serious developers.

A separate team at Apple produced HyperCard IIGS in 1991. This color version for the Apple IIGS was aimed at schools and had roughly the features of Macintosh HyperCard 1.x. Stacks were not binary-compatible, but a translator stack could convert them between the two platforms.

Back at Apple: 2.2, 2.3 and 2.4

HyperCard returned to Apple, and on 13 December 1993 Apple introduced HyperCard 2.2. (Some secondary sources, including William Cook’s AppleScript history, date 2.2 to 1992, but Apple’s PR Newswire release and TidBITS’ February 1994 review both place it at the end of 1993.) Version 2.2 added:

• AppleScript and OSA support. HyperCard could respond to about 150 Apple events. It could be controlled from AppleScript. Any object’s script could even be written in AppleScript or another Open Scripting Architecture language instead of HyperTalk.
• Color Tools, an external command plus a utility stack for coloring buttons, fields and card regions. This worked around the fact that cards themselves were still black and white.
• Save as application, so a stack could be distributed as a double-clickable program without royalties.
• WorldScript support, standard pop-up buttons, button families for radio buttons, and a bundled copy of Motion Works’ ADDmotion II animation tool.

HyperCard 2.3, released around 1995, was rewritten as native PowerPC code and added 24-bit color painting tools. Apple announced a 2.3.5 bundle at $99 on 11 December 1996. HyperCard 2.4 followed on 27 April 1998, after what TidBITS called “a two year lull.” It added QuickTime 3.0 scripting, QuickTime VR scenes and URL connections through Internet Config. HyperCard 2.4.1, a small fix released in July 1998, was the last version.

HyperCard 3.0 and the end

Because HyperCard was so widely used for multimedia, Apple moved it into the QuickTime group, and Calhoun led an effort to rebuild it on QuickTime’s interactive architecture. In this HyperCard 3.0 design, stacks would become QuickTime movies, with color and the ability to play inside a web browser. Calhoun demonstrated an early version to developers at WWDC in 1996, and TidBITS reported that Apple was aiming to ship it with QuickTime 3.0 in spring 1997. Dan Crow is reported in some histories to have led the work later. It never shipped. The QuickTime team shifted to streaming for QuickTime 4, and around 2000, after Steve Jobs’s return, the HyperCard engineers were reassigned. Apple withdrew HyperCard from sale in March 2004. It was never ported to Mac OS X, although it could run in the Classic environment on PowerPC Macs up to Mac OS X 10.4.

Bill Atkinson died on 5 June 2025, at the age of 74.

Design Philosophy

HyperCard’s slogan, repeated throughout the Mac community, was “programming for the rest of us.” Several design decisions supported it.

• The user interface is the program. There was no separate “design view” and “run view” in the conventional sense, and no separate files for code, layout and data. A stack file held all three. Typing into a field and moving that field were both just changes to the stack, and HyperCard saved every change automatically.
• Gradual disclosure. HyperCard had five user levels (Browsing, Typing, Painting, Authoring and Scripting). A beginner could simply browse a stack. Raising the level unlocked the paint tools, then the button and field tools, and finally the script editor. Many users built useful stacks without writing any code, using the link feature of the button dialog.
• Readable, forgiving code. HyperTalk was designed to read like English, to be case-insensitive and to convert between text and numbers silently. Apple preferred the word “scripting” to “programming,” and HyperTalk programmers were usually called “authors.”
• Open by default. Anyone at the Scripting level could open any stack’s scripts. Learning by taking apart someone else’s stack was the normal way to learn HyperCard.

Key Features

Stacks, backgrounds and cards

A stack is a single file containing a sequence of cards. Each card can share a background, a layer of fields, buttons and graphics common to many cards. Background fields show different text on each card, so a background works as a record layout and each card as a record. This gave HyperCard a simple flat-file database for free. Its built-in find command and sorting made it easy to build address books, catalogs and note systems.

HyperTalk messages and handlers

Programs are made of handlers attached to objects. When something happens, HyperCard sends a message such as mouseUp, openCard or keyDown to the object involved. If that object has no handler for the message, the message passes up the hierarchy: button or field, then card, background, stack, any stacks in use, the Home stack, and finally HyperCard itself. Scripters never have to write a main event loop.

1
2
3
4
5
6

on mouseUp
  -- Script of a button: ask for a name and greet the user
  ask "What is your name?"
  if it is empty then exit mouseUp
  put "Hello, " & it & "!" into card field "Greeting"
end mouseUp

ask shows a dialog box, and it is a special variable holding the result of the last command that sets it. Assignment uses put ... into, reading left to right like an English sentence.

Chunk expressions

HyperTalk’s most distinctive feature is chunk expressions, which treat text as nested containers of characters, words, items and lines:

1
2
3

put the first character of the third word of line 5 of card field "Notes" into theChar
put item 2 of "red,green,blue" into theColor    -- "green"
add 15 to item 1 of pos                          -- edit part of a "100,100" point in place

Lists and coordinates are simply comma-separated strings, and chunk expressions read and write their parts directly. When Apple designed AppleScript, its first specification extended HyperTalk’s chunk expressions into AppleScript’s object specifiers, according to William Cook’s history of the language.

Natural references to objects

Objects can be addressed by name, number, ID or position, with shortcuts the interpreter fills in from context:

1
2
3
4
5
6
7
8

repeat with i = 1 to the number of card fields
  hide card field i
end repeat

send "mouseUp" to card button "OK" of card "Settings"
go to next card
visual effect dissolve
go to card "Index"

Functions and dynamic evaluation

Authors can define functions and message handlers of their own, and the do command runs any text as HyperTalk. This made it easy to build interactive consoles inside a stack:

1
2
3
4
5
6
7

function replaceStr pattern, newStr, inStr
  repeat while pattern is in inStr
    put offset(pattern, inStr) into pos
    put newStr into character pos to (pos + the length of pattern) - 1 of inStr
  end repeat
  return inStr
end replaceStr

Externals: XCMDs and XFCNs

HyperTalk could be extended with external commands (XCMDs) and external functions (XFCNs). These were compiled code resources, usually written in Pascal or C, stored inside a stack’s resource fork and called just like built-in commands. They were an early form of the plug-in idea. Because externals travelled inside the stack, no separate installation was needed. A large third-party market grew up around them, covering color, extra windows, serial-port and hardware control, database access and networking.

Evolution at a Glance

Legacy and Influence

On the web

HyperCard ran on single machines and its links stayed inside local stacks. Even so, it influenced the web. Pei-Yuan Wei, a student at UC Berkeley with only X terminals and no Mac, studied the HyperCard manual and reimplemented its ideas for X Windows as Viola. ViolaWWW, built on Viola, became one of the first graphical web browsers and an early browser to support scripting and style sheets. HyperCard’s pointing-finger browse cursor is often credited as the origin of the familiar hyperlink cursor of web browsers. Atkinson later said that if he had thought about networked stacks instead of local ones, HyperCard could have become the first web browser.

On programming languages

• JavaScript. The JavaScript history by Allen Wirfs-Brock and Brendan Eich (HOPL IV, 2020) says HyperCard inspired Eich to use events in the original Netscape 2 DOM. The onclick-style handler attributes are commonly seen as echoing HyperTalk’s on mouseUp, though the paper credits only the concept of events.
• AppleScript. Its first specification generalized HyperTalk chunk expressions into object specifiers, and HyperCard 2.2 was one of the first applications to let AppleScript replace or work alongside its native scripts.
• The xTalk family. SuperCard’s SuperTalk, MetaCard, and their descendant LiveCode kept HyperTalk’s syntax and model. LiveCode has offered a route for importing HyperCard stacks, although how well it works depends on the stack and the LiveCode version. Macromedia Director’s Lingo is widely described as following HyperTalk’s English-like style.

On the wiki

Ward Cunningham, who invented the wiki, has traced it to a HyperCard stack of interlinked cards about people, projects and patterns that he kept in the late 1980s. In 1995 he rebuilt that structure on the web as WikiWikiWeb, adding one change: anyone could edit it.

Preservation

HyperCard stacks are hard to run today. They depend on the classic Mac OS, on resource forks and often on 68k-only externals. The Internet Archive’s emulated stack collection, launched on 11 August 2017 for the 30th anniversary, lets people open a large collection of stacks in a web browser. LiveCode and modern hobbyist systems in the HyperCard style, such as Decker, are the main ways of building new stacks in a similar way.

Why It Matters

HyperCard made the idea of a programmable personal computer real for people who would never have called themselves programmers. It combined a drawing program, a form designer, a database and a scripting language in one free application, and its scripts were open for anyone to read. A generation of Mac users learned to program by opening someone else’s stack and changing it. Several commercial successes, Myst above all, started as HyperCard stacks. Its ideas then moved into the web, JavaScript and AppleScript. HyperCard itself is long discontinued, but much of what it did is now a normal part of computing.