LotusScript

LotusScript is an embedded, object-oriented dialect of BASIC created by Lotus Development Corporation as a common scripting language for its products. Its syntax is close enough to Microsoft’s Visual Basic that a developer who knows one can read the other, but its purpose was never general-purpose programming. LotusScript exists to be hosted: each Lotus application that embedded it - Improv, Lotus Forms, Word Pro, 1-2-3, Approach, Freelance Graphics, and above all Lotus Notes - supplied its own library of classes, and the language served as the glue that let developers drive those objects. In Notes, that meant NotesSession, NotesDatabase, NotesDocument, and their relatives: the object model through which a generation of enterprise developers built workflow and document-management applications.

The language’s public history is usually told from Notes Release 4 in January 1996, and catalogs often date it to 1995, but LotusScript is older than that. It first shipped in Lotus Improv 2.0 for Windows in 1993, appeared in Lotus Forms and Notes ViP around 1994, and reached the SmartSuite applications in their 96 Editions during 1995 before becoming the programming language of Notes. It has survived three corporate owners - Lotus, IBM (from 1995), and HCL Technologies (from 2019) - and still ships, with new classes, in HCL Notes/Domino 14.5 (June 2025). Its status as dormant reflects that the language itself has not changed materially in two decades and that every product it lives in outside Domino has been discontinued.

History & Origins

A scripting language for the whole product line

By the early 1990s, Lotus had a problem shared by every large software company of the period: each of its products had its own macro language. Lotus 1-2-3 had its keystroke-based macro language, Ami Pro (acquired with Samna in 1990) had its own, and Notes had the @function formula language. Microsoft was moving toward a single BASIC for everything - Visual Basic shipped in 1991, and Visual Basic for Applications arrived in Excel in 1993 - and Lotus needed an answer.

That answer was LotusScript, a BASIC-derived language designed to be embedded in any Lotus product, with the syntax and control flow held constant across hosts and only the object classes varying. Its first host was Improv, the multidimensional spreadsheet that Lotus had launched on the NeXT in 1991 and ported to Windows as version 2.0 in 1993 (reportedly shipping in May). Improv for Windows shipped with what Lotus numbered LotusScript Release 1. Release 2 followed, around 1994, in Lotus Forms, an electronic-forms package, and in Notes ViP, a visual application builder for Notes. Version 3.0 shipped in Freelance Graphics, and 3.1 in 1-2-3, Approach, and Word Pro - the SmartSuite 96 generation that appeared during 1995 and through the 97 Editions that followed.

Notes Release 4

The release that mattered was Lotus Notes Release 4 in January 1996. Until then Notes had been programmed entirely in the formula language, a functional expression language borrowed from 1-2-3 that had no loops, no user-defined procedures, and no way to reach outside the current document. Release 4 added LotusScript 3 as a full procedural language with an integrated debugger and a set of Notes classes that exposed sessions, databases, views, documents, items, and rich text - and, on the client side, the user-interface objects. Books such as 60 Minute Guide to LotusScript 3 Programming for Notes 4 (1996) and IBM’s Redbook LotusScript for Visual Basic Programmers pitched the language explicitly at the Visual Basic audience. Release 4.5 in December 1996 renamed the server Domino, added HTTP serving, and introduced Java; LotusScript nevertheless remained the language most Notes developers wrote most of their code in.

Lotus, IBM, HCL

IBM acquired Lotus in 1995, before Notes 4 shipped, and LotusScript spent the next 23 years as an IBM language. IBM retired the Lotus brand in 2013, withdrew SmartSuite from marketing that June with support ending on September 30, 2014, and in December 2018 announced the sale of Notes and Domino to HCL Technologies in a deal that closed in July 2019. HCL has continued to extend the Notes class library - HTTP and JSON classes in Domino 10, language-model classes and a 64-bit session API in 14.5 - without altering the language underneath.

Design Philosophy

Three ideas run through LotusScript’s design.

One language, many hosts. The core language - statements, data types, control flow, classes, error handling - was meant to be identical in every Lotus product. What changed from product to product was the set of built-in classes. A Sub that loops over a list looks the same in Word Pro and in a Notes agent; only the objects it manipulates differ. This is the same division Microsoft drew between VBA and the Office object models, and it made LotusScript skills transferable within the Lotus line.

BASIC syntax, deliberately. Lotus chose BASIC for the same reasons Microsoft did: it was the language most business-application developers and power users already knew, and Visual Basic had just made it respectable. LotusScript’s Dim, Sub, Function, If...Then...Else, For...Next, Do...Loop, Select Case, On Error, and Print are recognizably the Visual Basic of the early 1990s. Contemporary descriptions frequently call it a variant or near-superset of the Visual Basic of the day; the language itself is a separate implementation, but the resemblance was the point.

Object-oriented extensions, not just object access. Unlike VBA of the period, LotusScript let developers define their own classes with Class...End Class, including single inheritance, constructors (Sub New) and destructors (Sub Delete), properties (Property Get/Property Set), and Me as the self reference. Product classes could not be subclassed, but user classes could wrap them. The ForAll statement iterated over any collection or array, and Set x = New ClassName created objects. Combined with events on host objects - Initialize, Terminate, Querysave, Postopen on a Notes form - this gave a small BASIC a fairly complete object model well before Visual Basic gained user-defined classes in version 4.

Key Features

Syntax and types

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

Option Declare   ' require explicit variable declarations

Sub Initialize
    Dim greeting As String
    Dim count As Integer
    greeting = "Hello, World!"
    For count = 1 To 3
        Print greeting & " (" & CStr(count) & ")"
    Next
End Sub

Scalar types are Integer (16-bit), Long (32-bit), Single, Double, Currency, String, and Boolean, plus Variant, which can hold any value including arrays, lists, and object references. Without Option Declare, undeclared variables spring into existence as Variants - a habit inherited from BASIC that most LotusScript style guides forbid. Fixed-size and dynamic arrays (ReDim ... Preserve), user-defined Type records, and a built-in associative List type (Dim names List As String) round out the data structures.

Classes

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

Class Counter
    Private value As Long

    Sub New(start As Long)
        value = start
    End Sub

    Public Sub Increment()
        value = value + 1
    End Sub

    Public Property Get Current As Long
        Current = value
    End Property
End Class

Sub Initialize
    Dim c As New Counter(10)
    c.Increment
    Print c.Current   ' prints 11
End Sub

Classes support Private/Public members, a single base class (Class Child As Parent), Me for the current instance, and deterministic cleanup through Delete. Objects are reference-counted; Delete obj runs the destructor immediately.

The Notes object model

The classes that made LotusScript worth learning are the Notes back-end and front-end libraries. A typical agent that walks a view and updates documents:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

Sub Initialize
    Dim session As New NotesSession
    Dim db As NotesDatabase
    Dim view As NotesView
    Dim doc As NotesDocument

    Set db = session.CurrentDatabase
    Set view = db.GetView("OpenInvoices")
    Set doc = view.GetFirstDocument()

    While Not doc Is Nothing
        If doc.DueDate(0) < Today() Then
            Call doc.ReplaceItemValue("Status", "Overdue")
            Call doc.Save(True, False)
        End If
        Set doc = view.GetNextDocument(doc)
    Wend
End Sub

Document fields are exposed as extended-syntax properties (doc.DueDate(0) reads the first value of the DueDate item), and the same classes are available to scheduled agents on the server, to buttons and form events in the client, and - through NotesUIWorkspace, NotesUIDocument, and NotesUIView - to code that manipulates what the user sees. Because the classes mirror the Notes data model directly, LotusScript code written in 1996 against NotesDocument still runs on Domino 14.5.

Extensibility: LSX, LS:DO, LS2J, and C

LotusScript was designed to be extended in several directions:

• LSX (LotusScript Extensions) are dynamically loaded modules that register new classes with any LotusScript host. The LSX Toolkit let third parties write them in C++, and the UseLSX statement loads them. Lotus’s own LS:DO (LotusScript Data Object) LSX provided ODBC access through ODBCConnection, ODBCQuery, and ODBCResultSet, and the LSX for Lotus Connectors reached DB2, Oracle, and other enterprise systems.
• LS2J (LotusScript to Java), introduced in Notes/Domino 6 in 2002, lets LotusScript create Java objects and call their methods, so the growing Java ecosystem could be reached without leaving the language.
• Declare statements bind external C functions from DLLs or shared libraries, including the Notes C API - a technique documented in Normunds Kalnberzins’s LotusScript to Lotus C API Programming Guide (2003) and widely used for features the classes did not expose.
• OLE Automation support on Windows let LotusScript drive Microsoft Office and other COM servers, and Evaluate runs a formula-language expression from inside script, so the two Notes languages could be mixed.

Comparison with Visual Basic

Evolution

LotusScript’s development falls into a short period of language change followed by a long period of library growth.

1993-1996: the language takes shape. Releases 1 through 3 moved from Improv to Forms and ViP to the SmartSuite 96 applications and finally to Notes 4, acquiring classes, the debugger, and the LSX architecture along the way. The Notes 4 language - LotusScript 3 - is essentially the language still in use.

1996-2002: the platform grows around it. Java arrived in Notes 4.5, JavaScript and expanded Java in Release 5 (1999), and LS2J in Release 6 (2002). Each Notes release added back-end classes - NotesViewNavigator and NotesOutline in R5; NotesStream and XML parsing and transformation classes in R6 - rather than changing the language. From R6 the language’s version number was, in practice, the Notes version number; IBM’s later LotusScript Language Guide editions were numbered by Notes release rather than by a separate language version.

2007-2013: new tooling, same language. Notes 8 (2007) rebuilt the client on Eclipse, and Domino Designer 8.5.1 (2009) gave LotusScript a modern editor with type-ahead completion, colour coding, and hover documentation. XPages, introduced in 8.5 (2008), pushed Java and server-side JavaScript as the forward-looking way to build Domino web applications, and LotusScript began to be described as the legacy language of the platform - while remaining the language that most existing applications were written in.

2018-present: HCL’s additions. Domino 10 (2018) added NotesHTTPRequest and profiling methods on NotesSession; 10.0.1 added the NotesJSONNavigator family and NotesDominoQuery, making it possible to call REST services, parse JSON, and run Domino Query Language searches natively. Domino 14.5 (2025) added NotesLLMRequest and NotesLLMResponse for the Domino IQ language-model engine and a 64-bit API in NotesSession. None of these touched the syntax; they extend the class library so that thirty-year-old codebases can reach modern services without rewriting.

Current Relevance

LotusScript is, as of 2025, a fully supported language of HCL Notes and Domino 14.5, with an active documentation set, a maintained Eclipse-based editor and debugger in Domino Designer, and new classes in each release. HCL’s system-requirements documentation for Domino 14 lists Windows Server, Linux, and AIX as server platforms, with the Notes client adding Windows and macOS desktops; LotusScript runs wherever the host does. Every organization still running Domino applications - and IBM reportedly claimed well over a hundred million licensed Notes seats in the 2000s - is running LotusScript daily in scheduled agents and form logic.

Outside Domino the language has no life. SmartSuite, its other major host, was withdrawn in 2013 and unsupported after September 2014. There is no open-source implementation, no standalone compiler, no Docker image, and no specification independent of the HCL documentation. The community that once produced Inside LotusScript (1998), Practical LotusScript (1999), the Lotusphere conference sessions, and the OpenNTF LotusScript Gold Collection has largely moved on, and much of its knowledge survives in archived blogs and in Julian Robichaux’s unfinished LotusScript book on nsftools.com. New Domino development is steered toward Java, XPages, the low-code Domino Leap (formerly Domino Volt), and the Domino REST API; LotusScript is the language of applications that already exist.

That is what dormant means here: alive in maintenance, stable in syntax since the mid-1990s, and bound to the lifespan of a single product.

Why It Matters

LotusScript is worth studying for three reasons.

It is the clearest example of the embedded-BASIC strategy outside Microsoft. Between 1993 and 1996 the two largest PC software companies both concluded that a Visual Basic-style language, hosted inside applications and driving their object models, was how business users and departmental developers would program. Microsoft’s version became VBA and won; Lotus’s version became LotusScript and, through Notes, powered a very large share of corporate workflow software for two decades. Understanding one illuminates the other.

It gave a procedural language to a document database years before that was common. Notes was a replicated, schema-free document store with a scripting language, an object model for documents and views, and agents that ran on the server - in 1996. The combination of NotesDocument, ReplaceItemValue, and a While Not doc Is Nothing loop is, in retrospect, a preview of the programming model that document databases and serverless functions would popularize much later.

And it is a case study in longevity through hosting. LotusScript has never had a standard, a community implementation, or a life of its own, yet code written against Notes 4 in 1996 still runs on Domino 14.5 in 2025 and can now call a language model. Its survival owes nothing to the language’s merits as a language and everything to the value of the applications built in it - a reminder that in enterprise computing, the object model outlives the syntax, and both outlive the company that made them.