MetaCard

MetaCard was a commercial, HyperCard-compatible development environment, first sold in June 1992. It came from MetaCard Corporation of Boulder, Colorado, and was written by Scott Raney. MetaCard brought Apple’s stack-and-card model to Unix workstations running the X Window System, and later to Windows and the Macintosh. Its scripting language, MetaTalk, was a superset of HyperCard’s HyperTalk. MetaCard was sold as a product for only about eleven years, but it matters more than that suggests: its engine was bought by Runtime Revolution in 2003 and became the engine of Revolution and then LiveCode. The xTalk language family survived into the 21st century because of it.

History & Origins

HyperCard for the workstation

By the end of the 1980s HyperCard (1987) had shown that people who were not professional programmers could build working software from cards, buttons, fields and short English-like scripts. That only applied on the Macintosh, though. On Unix workstations, building a graphical interface still meant C, Xlib, Motif widget resources and callbacks.

MetaCard Corporation’s reviewer’s guide says the company was formed in 1990 to build easy-to-learn multimedia and application development tools for Unix workstations, and to make them compatible with HyperCard. Version 1.0 was released in June 1992, and the company FAQ dates the start of development to 1990 as well. When the engine was sold in 2003, Raney said MetaCard had been in development for more than twelve years, which also points back to 1990–91. The 1992 date therefore marks the first commercial release, not the start of work.

The environment was built in itself from the start. MetaCard’s reviewer’s guide notes that the 1.0 development environment was written as MetaCard stacks, and that every later release was built the same way. The tool palettes, property inspectors, menus and dialogs were all stacks that a user could open and change.

The Unix years (1992–1996)

Early reviews were favourable. MetaCard’s product literature says UNIXWorld magazine named it one of the 10 Best Products of 1992, and that it was a finalist in SCO’s Product of the Year contest in 1993. It also quotes SunWorld calling MetaCard a “must-have UNIX utility” once users had learned it.

Scott Raney’s 14 February 1994 announcement of MetaCard 1.3 shows what the product had become by then:

• it could import and run HyperCard 1.2.5 and 2.1 stacks directly from their binary files, converting icons, cursors and sounds, and it supported recompiled XCMDs through a compatible API
• it added vector graphics, functions for starting and managing external processes, FLI/FLC animation playback and EPS import
• it ran on 13 Unix/X11 platforms: SPARC (SunOS and Solaris 2.x), Sun 3, DECstation and DEC Alpha, HP 9000/300 and 700, SCO Open Desktop, 88open, SGI IRIS, UnixWare, Linux and IBM RS/6000. A DESQview/X engine was also offered for MS-DOS
• a single-user licence cost $495, site licences ran from $1,800 for 5 users to $15,000 for 250, and the platform engines could be redistributed free of charge

The vendor distributed a free “save-disabled” copy by anonymous FTP, which let people try the full environment without being able to save their work.

MetaCard 1.4 followed. Linux Journal’s New Products column for February 1995 listed it with QuickTime, AVI and FLI/FLC playback, HyperCard 2.2 stack import and a special $195 price for Linux. A Sun Solutions catalogue entry from 1997 describes MetaCard as a hypermedia and rapid application development environment for X11/Unix workstations. It lists Motif-compliant interfaces, 24-bit colour, a Display PostScript object, the ability to run any Unix program and collect its output, and calls to C functions through an external procedure mechanism.

Rewrite and the jump to Windows and Mac (1996–1998)

MetaCard 2.0 was a large internal rewrite. The reviewer’s guide says it replaced the language execution system and added custom properties. It also moved operating-system-specific code into separate modules so that the engine would be easier to port. SCO World magazine named 2.0 one of its Hot Products of 1996.

The new structure was used straight away:

IEEE Computer Graphics and Applications chose MetaCard 2.1 as one of its Top 10 Software Products of 1997, according to MetaCard’s literature.

The move to the Mac turned the product around. The reviewer’s guide says that by the 2.5 era the installed base was mostly Unix, then Windows, then Mac, but new sales came mostly from Mac OS, then Windows, then Unix. Mac users looking for a successor to HyperCard had become MetaCard’s main source of new customers.

Cross Worlds, Revolution, and the sale (1997–2003)

In Edinburgh, Kevin Miller’s company Cross Worlds Computing built commercial software on MetaCard, including a touch-typing tutor for Windows. It also wrote its own development environment for the MetaCard engine and called it Revolution. The company later took the name Runtime Revolution. Revolution 1.0 shipped in 2001, running on MetaCard’s engine under licence; the language as used in Revolution became known as Transcript.

On 8 July 2003 Runtime Revolution announced that it had acquired the MetaCard engine technology from MetaCard Corporation. In the announcement, Raney said that selling the technology would let it reach markets that MetaCard could not. Messages on the user mailing lists the same week say Raney would go on working on the engine inside Runtime Revolution. The MetaCard name stopped being used for new engine releases, which came out from then on as Revolution.

The original MetaCard IDE did not go into Revolution. metacard.com says the MC IDE stacks (mctools.mc, mchelp.mc, mchome.mc) were made available as open source, maintained by a working group through the MC_IDE Yahoo group. They required the Revolution engine, which stayed under Runtime Revolution’s licence.

Design Philosophy

MetaCard’s literature repeats a few main ideas:

• HyperCard compatibility first. MetaTalk is a superset of HyperTalk and is also compatible with SuperCard’s SuperTalk. Most of SuperCard’s extensions to HyperCard were added in versions 1.0 to 1.4, including a compatible “graphic” object. Existing stacks were meant to load without preprocessing.
• One stack, every platform. A stack file runs unchanged on every supported engine, with no recompiling. The engines could be redistributed free of royalties. The licensed part was the Home stack that unlocked development.
• The tool built in itself. Because the IDE was made of ordinary stacks, users could change any menu, palette or dialog, and the same skills built both the tools and the applications.
• A very high level language instead of a 3GL. The company described MetaTalk as having the features common to C, C++ and Java with a much simpler syntax. It argued that fewer lines of code meant faster development and cheaper maintenance, and that interface building needed none of the widget-resource and callback knowledge Motif required.

Key Features

The object model

A MetaCard application is a stack of cards. Each card holds objects such as buttons, fields, scrollbars, images, graphics and players. As in HyperCard, every object can hold a script, and events such as mouseUp, openCard or keyDown pass up a message path from the object to its card, its stack and finally the engine. A handler can deal with a message where it is or let it travel further.

The MetaTalk language

MetaTalk has the English-like syntax of HyperTalk. A short handler in a button script, written in the syntax shared by the xTalk family, looks like this:

on mouseUp
  put "Hello, World!" into field "Output"
end mouseUp

The reviewer’s guide lists what MetaTalk added on top of HyperTalk:

• associative arrays, indexed by strings
• regular-expression pattern matching, which the company compared to Perl’s
• call-by-reference parameters
• delayed-event scheduling, so that a message can be sent to an object at a later time
• binary data handling, including NUL bytes
• built-in HTTP support
• custom properties on every object type. These persist with the stack and can run scripts when they are read or set

A call-by-reference parameter is marked with @, and delayed messages use send … in. Both kept the same form in Revolution and LiveCode:

on swapValues @pFirst, @pSecond
  local tTemp
  put pFirst into tTemp
  put pSecond into pFirst
  put tTemp into pSecond
end swapValues

on openCard
  send "updateClock" to me in 1 second
end openCard

These snippets are illustrations in the shared xTalk syntax. They have not been tested against a historical MetaCard engine.

Execution model

MetaCard 2.0’s rewritten execution system was described by the vendor as a “virtual compiler”, with performance it called comparable to byte-code interpreted languages such as Perl and Java. The reviewer’s guide claims it was at least 5 times faster than HyperCard and SuperCard, and up to 30 times faster than JavaScript and Unix shell interpreters. The company FAQ makes a similar claim against ksh and Tcl. These are vendor claims: the published material does not say which scripts were timed, on what hardware or against which versions, so treat them as marketing rather than benchmark results. metacard.com also hosted benchmark pages, and Fourth World’s free MetaBench tool let developers compare the speed of different MetaTalk constructs themselves.

Platform integration

On Unix, MetaCard could run any Unix program and collect its output, and call C functions through an external mechanism. That made it a common choice for graphical front ends to command-line tools. The engine itself was reportedly written in C++, the language of the LiveCode engine code that descends from it.

Evolution

MetaCard went through three stages:

1. 1992–1996: a Unix/X11 product. It was sold as a HyperCard-compatible GUI builder and hypermedia tool for workstations, eventually across more than a dozen Unix variants.
2. 1996–2003: a cross-platform product. The 2.0 rewrite made the engine portable, and Windows (1997) and Mac (1998) engines followed. Late releases added Mac OS X, Unicode and modern debugging.
3. 2003 onward: an engine under another name. The technology continued as the Revolution engine, which was renamed LiveCode in 2010. The LiveCode engine was released under the GPL in 2013 as LiveCode Community, which brought the codebase that started at MetaCard into open source. LiveCode Ltd. ended the open-source Community edition in 2021.

Current Relevance

MetaCard itself is discontinued. No vendor sells it, and the last release was 2.5 in 2003. Archived builds of the late 2.x engines are still kept by community members, and forum posts on openxtalk.org describe running the Windows build under 32-bit Wine and the classic Mac build in emulators. These are community reports, not supported configurations.

The language lives on in its descendants. MetaTalk’s syntax, message path and stack format carry on in LiveCode Script, and in community forks of the open-source LiveCode code such as OpenXTalk. Forum discussions show some long-time developers still opening the MC IDE stacks with newer engines.

Why It Matters

• It took HyperCard off the Mac. In 1992 MetaCard offered Unix programmers HyperCard’s model of direct-manipulation interface building and scripting in English-like code. At the time the usual alternatives were Motif and C, or scripting toolkits such as Tcl/Tk and dtksh, all three of which O’Reilly’s The X Resource (Issue 11, Summer 1994) compared with MetaCard, according to the MetaCard FAQ.
• It kept the xTalk family alive. HyperCard development slowed in the late 1990s, and MetaCard was one of the few actively developed engines that could still open HyperCard stacks and run their scripts.
• Its code still runs today. Through Revolution and LiveCode, MetaCard’s engine has stayed in development for more than three decades. Developers in the community describe it as one engine codebase developed continuously from 1992 to the present, apart from later forks.

Sources and Verification Notes

• Year: 1992 comes from MetaCard Corporation’s own statements: commercial release in June 1992 (FAQ and reviewer’s guide), with development from 1990. The UNIXWorld “10 Best Products of 1992” listing supports a 1992 release.
• Version dates: 1.3 (14 Feb 1994) comes from Raney’s Usenet announcement. 1.4 comes from Linux Journal (Feb 1995). 2.1, 2.1.1 and 2.5 come from the reviewer’s guide. 2.2 and 2.3 come from MacTech-hosted press releases (August 1998 and January 2000). 2.5 (April 2003) and the acquisition (8 July 2003) come from press releases and same-week mailing-list posts. The release dates of 1.1, 1.2, 1.4 (beyond the magazine listing), 2.0 and 2.4 were not found and are not stated.
• Platform count: Linux Journal’s April 1994 New Products column says 1.3 ran on 14 platforms; this matches Raney’s 13 Unix/X11 platforms plus the DESQview/X engine.
• Awards are taken from MetaCard Corporation’s product literature and were not checked against the original magazine issues.
• Notable uses other than the Fermilab paper come from MetaCard Corporation’s application gallery, which is the vendor’s own list.