OpenScript

OpenScript is the programming language built into ToolBook, the Windows authoring system that Asymetrix, Paul Allen’s software company, launched in 1990. It let Windows programmers and non-programmers alike attach English-like event handlers to the objects on a page. COMPUTE! summed it up in 1991 as “complete, powerful, and very English-like.”

OpenScript matters because it brought the HyperCard model to the PC just as Windows 3.0 arrived, and because it outlived that moment. Its syntax survived through more than two decades of ToolBook releases, while the product changed from a general Windows programming tool into a specialist for e-learning courseware.

History and Origins

Paul Allen’s second company

Paul Allen co-founded Microsoft in 1975 and left his active role there in 1983 after being diagnosed with Hodgkin’s disease. Asymetrix was his second software company. Its founding date is reported inconsistently: Wikipedia’s article on SumTotal says 1984 in its text, citing the 1998 IPO prospectus, and 1985 in its infobox. A company profile also gives 1984.

The company was based in Bellevue, Washington, and its first product took several years to appear. ToolBook was announced at the New York City Public Library on 21 May 1990, according to the Seattle Times, at $395. The launch was closely tied to Windows 3.0, which Microsoft launched the next day: Microsoft included a sample ToolBook application and a runtime version with every copy. Bill Gates told the paper that ToolBook was “generations beyond HyperCard.”

The sources found do not name the people who designed OpenScript, and they do not date the language separately from the product. A forum comment from 2021 says OpenScript was integrated with ToolBook from its very first release, and an Asymetrix README copyrighted 1990 lists OpenScript alongside ToolBook as a registered trademark and includes tutorials on it. That supports 1990 as the language’s date, though it cannot be separated from the product’s.

A HyperCard for Windows

The obvious comparison at launch was Apple’s HyperCard, which had shipped in 1987. TidBITS reported on ToolBook’s release from a Macintosh perspective the day it was announced. Where HyperCard had stacks and cards, ToolBook had books and pages. Two differences stood out to that reviewer: a Script Recorder that wrote scripts by watching what the user did, and the ability to attach scripts to graphics and text, not only to buttons and fields.

A third-party tool, ConvertIt! from The HyperMedia Group, sold through Heizer Software, was planned to turn HyperCard stacks into ToolBook books. A 1993 FAQ compiled from the ToolBook mailing list rated it “an 80% job” and said it converted scripts well where they could be converted at all. Lines it could not translate came through as comments for the developer to rewrite. There was no reverse path.

Design Philosophy

OpenScript follows the HyperTalk idea that a script should read almost like a sentence. COMPUTE! said in 1992 that its “syntax is close enough to English to be self-commenting,” and gave the example of getting the text of one field and putting it in the text of another.

Three principles run through the language:

1. Scripts belong to objects. Code is not kept in a separate program. It is attached to the button, field, page or book it governs.
2. Everything is a message. COMPUTE! described almost everything on screen as an object, with objects acting on events by running handlers.
3. The programming is optional at first. The Script Recorder, and later the Actions Editor and templates, let authors produce behaviour before learning the language.

The language was object-based in the HyperCard sense. Authors worked with objects, properties, messages and message forwarding. The sources found do not document the user-defined classes or inheritance in the sense of Smalltalk or C++, so “object-oriented” here describes the environment as period reviews used the term.

Key Features

The examples below are taken from period material. The first is from an Asymetrix tutorial book of about 1990, and the others from the 1993 ToolBook FAQ, compiled by Allan Christie from mailing list postings. None has been run for this page, as no copy of ToolBook was available.

Handlers

A handler begins with to handle and the name of a message. This is the first script the Asymetrix tutorial has the reader write, for a Next button:

1
2
3

to handle buttonUp
    go to next page
end buttonUp

The closing name is optional, as other samples end with a bare end. Handlers can take parameters, and functions are written with to get and return:

1
2
3
4
5
6
7
8

to get ElapsedTime ElapsedTimeSecs
    put ElapsedTimeSecs div 3600 into Myhours
    put ElapsedTimeSecs mod 3600 into MyMinSecs
    put MyMinSecs div 60 into MyMins
    put MyMinSecs mod 60 into MySecs
    put Myhours && "hours" && MyMins && "minutes" && MySecs && "seconds" into TimeString
    return TimeString
end ElapsedTime

&& joins text with a space, and the put ... into form is the one familiar from HyperTalk. Statements also accept the set ... to form used for both variables and properties, and -- starts a comment.

Messages and forwarding

Messages travel upward through the book, and a handler chooses whether to let them continue. forward passes the message on, and send raises a new one. This handler, from a FAQ recipe for an auto-running slide show, shows both, along with a system variable, which keeps its value between handlers:

1
2
3
4
5
6
7
8
9

to handle keyDown   -- do the same thing for buttonUp
    system s_mode
    if s_mode = "slideShow"
        set s_mode to "interactive"
        send startInteractive
    else
        forward
    end
end

The FAQ warns authors not to forget to forward messages so that they reach the book level.

Control flow

Besides if, else and while, OpenScript has a counted step loop and a multi-way conditions statement, whose when clauses appear below. This FAQ handler is the kind of utility that lived in a system book, a separate .sbk file of shared scripts:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

to handle rightButtonUp mLoc, isShift, isCtrl
    conditions
        when isShift
            edit the script of this background
        when isCtrl
            if parent of target is "group"
                edit script of parent of target
            else
                edit script of this book
            end if
        when true
            edit the script of target
    end
end rightButtonUp

Reaching into Windows

OpenScript was never confined to its own sandbox. The linkDLL statement declares functions from Windows DLLs with C-style types, after which scripts call them like built-in functions. The FAQ’s slide-show recipe gets its timer that way:

1
2
3
4
5
6
7
8
9

to handle enterBook
    system s_lastTime,s_startTime
    linkDLL "user"
        DWORD  GetTickCount()
    end
    set s_lastTime to GetTickCount()
    set s_startTime to 0
    forward
end

Asymetrix also promoted the language’s Dynamic Data Exchange support in its evaluation material, and the FAQ shows books communicating through commands such as executeRemote and getRemote.

Authoring tools and limits

Scripts were developed inside the product, with a script editor and a debugger. The 1994 releases improved both, according to Tech Monitor. ToolBook separated an author level, for editing, from a reader level, for use. The runtime could be redistributed without royalties, and it did not allow scripts to be set or the user to enter author mode.

OpenScript was interpreted, and speed was the main complaint in COMPUTE!’s 1991 review. The FAQ also reports practical limits from version 1.x experience: about 64K of data per page, including text and scripts, and 32K of text in a field.

How close was it to HyperTalk?

The sources disagree, and no side-by-side comparison was found:

The code above shows a strong family likeness in put ... into, the message handlers and the English-like phrasing. It also shows differences, such as to handle where HyperTalk uses on, and the conditions and step statements. The 80% conversion figure suggests that the two were close but not interchangeable, so “superset” looks too strong.

Evolution

• ToolBook 1.0 (1990): the original Windows 3.0 release, a 16-bit application according to WinWorld.
• ToolBook 1.5 and 1.53 (from 1991): the long-lived first series, with 1.53 still current in May 1993 according to the FAQ. Multimedia ToolBook was based on 1.5, and OpenScript reached MCI through tbkMCI() functions, which needed an explicit link to the TBKMM.SBK system book.
• Version 2.0: Wikipedia says that no 2.0 was released. The 1993 FAQ shows that one was in final beta that May, so the work seems to have been released under a later number or dropped. The sources found do not say which.
• ToolBook 3.0 (1994): Tech Monitor reported visual programming and multimedia editions, along with viewer objects for multi-window applications and an Auto-Script library. Nelson’s 1994 paper shows callMCI() and playSound() as native OpenScript.
• ToolBook II and later (from the mid-1990s): the product moved toward computer-based training and then web delivery. Wikipedia lists versions 4.0 to 6.0 between 1996 and 1998.
• ToolBook 7.0 and 8.0 (1999-2000): DHTML export and the Actions Editor arrived, followed by SCORM and AICC support for learning management systems, according to Wikipedia.
• ToolBook 9.0 to 11.5 (2007-2012): the last releases, under SumTotal.

The move to the web created the problem that shaped OpenScript’s last years. OpenScript ran only in ToolBook’s Native engine, not in DHTML-delivered content. Asymetrix first tried Neuron, a browser plug-in that played ToolBooks over the web. Bob Jensen, a long-time user, was blunt about its limits, calling that delivery “neither efficient nor effective” and comparing the web serving of ToolBooks coded in OpenScript to “pushing 800 lb gorillas through a garden hose.”

The answer was the Actions Editor, whose syntax is nearly identical to OpenScript’s but which has perhaps 80 commands, against over a thousand commands and functions in OpenScript. Actions ran in both the Native engine and the browser, so anything meant for the browser had to use them, leaving OpenScript for the Windows side.

Decline and Current Relevance

Jensen reported in 1999 that Asymetrix would “no longer” feature or upgrade ToolBook programmed in OpenScript. This is one user’s account, and no vendor statement was found. That was clearly not an end to the language, because it was still included in ToolBook II Instructor in 2000 and remained part of ToolBook to the end, according to Wikipedia. It does mark the point at which the vendor’s attention moved elsewhere. Asymetrix became click2learn.com in October 1999, focused on online learning services, and merged with Docent to form SumTotal Systems in 2004.

ToolBook 11.5, from December 2012, was the last version. SumTotal ended all sales and support on 31 December 2021, and Wikipedia adds that it also ended activation on new computers. A 2021 Slashdot submission, written before the cutoff, said only that activations “may” be refused and that there was no format-compatible replacement. Its submitter’s main concern was the courseware still in use. A SumTotal notice, seen only as a search excerpt, pointed customers to a migration programme with dominKnow.

The 2004 rename to SumTotal was not the end of the language commercially: ToolBook with OpenScript stayed on sale for many years after that.

Today there is no vendor, no supported implementation and no open source version. The UK National Archives keeps format records for ToolBook files through its PRONOM registry, for digital preservation, and old versions are preserved at WinWorld. OpenScript should not be confused with Oracle’s unrelated OpenScript testing tool.

Why It Matters

OpenScript shows how a language can be carried by a platform shift. Its appeal in 1990 was simple: the hypermedia style that Macintosh users had enjoyed for three years was now available on Windows, with a runtime in the box with Windows itself. It was an early and well-funded example of a visual, event-driven Windows development environment, and period writers treated it as a tool for programmers and authors alike, a space that Visual Basic was about to enter in 1991.

Its later life is just as instructive. A language tied to a desktop runtime has no easy route to the browser, and OpenScript’s vendor had to build a smaller, compatible subset to get there. The courseware written in it is a preservation problem for the same reason, because it needs a commercial program that can no longer be bought.