ObjectScript

ObjectScript (historically Caché ObjectScript) is the native programming language of the InterSystems data platforms — first Caché, and now InterSystems IRIS. It is, at its core, a functional superset of the ANSI-standard MUMPS language: any valid MUMPS routine runs unchanged, but layered on top is a full object system, embedded SQL, a macro preprocessor, and modern C-style control flow. ObjectScript is rarely discussed in language-popularity surveys, yet it quietly underpins a remarkable amount of critical infrastructure — most visibly the electronic health records of a large fraction of the world’s hospital patients.

ObjectScript is unusual among programming languages in that the language and the database are inseparable. Its persistent globals — sparse, multidimensional, B-tree-backed arrays — are simultaneously a data structure in the language and the on-disk storage of the database. There is no object-relational mapping layer to cross; the data model is the language.

History & Origins

ObjectScript’s roots reach back to MUMPS (Massachusetts General Hospital Utility Multi-Programming System, also called M), developed at Massachusetts General Hospital in the late 1960s for managing patient and laboratory data. MUMPS pioneered a model in which a built-in, hierarchical, schema-light database was woven directly into the programming language.

InterSystems, founded in 1978 by Phillip T. (Terry) Ragon, spent its first two decades as a MUMPS-technology company. Through a series of acquisitions — DTM from DataTree (1993), DSM from Digital Equipment Corporation (1995), and MSM from Micronetics (1998) — it consolidated the fragmented M-implementation market and became the dominant vendor in the space.

In 1997, InterSystems brought these threads together in Caché, a new product whose native language, Caché ObjectScript, extended MUMPS into the object-oriented era. The goal was pragmatic: preserve the proven performance and the enormous installed base of MUMPS applications (especially in healthcare and finance), while giving developers objects, SQL, and web capabilities that the bare MUMPS standard lacked. Crucially, backward compatibility was absolute — Caché could run legacy ANSI MUMPS routines without modification.

Design Philosophy

ObjectScript is shaped by a single unifying idea: the database and the language are one system. Three principles follow from it.

• Persistence is native, not bolted on. A global (a variable name prefixed with ^) is automatically stored on disk and shared across processes and sessions; an ordinary local variable lives only in the current process. The same subscript syntax addresses both. This means a developer can build a persistent, indexed data structure with nothing more than assignment statements.
• Backward compatibility is sacred. Because so many mission-critical systems were written in MUMPS, every generation of the language has remained a strict superset of what came before. New, friendlier syntax was added alongside the terse MUMPS originals rather than replacing them.
• Pragmatism over purity. ObjectScript freely mixes paradigms — terse procedural MUMPS commands, an object class system, and embedded SQL — within a single method, choosing whatever expresses the task most directly.

Key Features

• Multidimensional globals. Sparse, B-tree-backed arrays addressed by arbitrary subscripts (numbers or strings), persisted transparently to disk. They serve as the universal storage substrate beneath objects, SQL tables, and raw data alike.
• An object system. Classes (.cls) with single and multiple inheritance, properties, methods, parameters, and relationships. Persistent classes are automatically projected as both objects and SQL tables over the same underlying global storage.
• Embedded SQL. SQL statements can be written inline inside ObjectScript methods (&sql(...)), and the same data is reachable through objects, SQL, and direct global access simultaneously — a model InterSystems calls multi-model or “Common Data Plane.”
• A macro preprocessor. Lines beginning with # define macros, include files, and conditional compilation, expanded before the code is compiled.
• Dual syntax styles. Classic MUMPS allows abbreviated commands and significant whitespace (s x=1 for SET x=1); modern ObjectScript adds C-like braces (if {...} else {...}, for {...}) and relaxed formatting for readability.
• A rich function library. Built-in functions — many inherited from MUMPS, conventionally prefixed with $ (e.g. $PIECE, $ORDER, $LISTBUILD) — provide string parsing, list manipulation, and ordered traversal of globals.

A small taste of the dual nature of the language:

/// A persistent class is also a SQL table.
Class Demo.Person Extends %Persistent
{
    Property Name As %String;
    Property Age As %Integer;

    ClassMethod Greet(name As %String) As %String
    {
        // Modern brace syntax alongside classic $ functions
        Set greeting = "Hello, " _ name _ "!"
        Write greeting, !
        Return greeting
    }
}

// Globals: assignment is persistence
Set ^Patient(12345,"name") = "Ada Lovelace"
Set ^Patient(12345,"dob")  = "1815-12-10"
Write ^Patient(12345,"name")   // -> Ada Lovelace

The _ operator above is string concatenation, and the trailing ! in a Write is a newline — both inherited directly from MUMPS.

Evolution

ObjectScript evolved by accretion rather than reinvention. The original Caché releases in the late 1990s introduced the object layer and embedded SQL over the MUMPS foundation. Over the following two decades, InterSystems layered additional platforms on the same engine — Ensemble (2003) for integration and messaging, and HealthShare (2006) for health informatics — each using ObjectScript as its implementation language.

The largest shift came with the IRIS Data Platform, announced in 2017 and generally available from 2018. IRIS unified the database, interoperability, and analytics capabilities that had previously been split across Caché and Ensemble, and embraced containers and cloud-native deployment. Importantly for developers, IRIS kept ObjectScript intact: code and globals migrated from Caché with strong continuity, preserving the decades-long backward-compatibility promise even across the product transition.

Tooling modernized too. Where development was once done largely inside InterSystems’ own Studio environment, recent years brought first-class support for Visual Studio Code through the InterSystems ObjectScript extension, along with server-side source control and Git-based workflows.

Current Relevance

ObjectScript is a textbook example of a “boring but essential” technology: invisible to most working programmers, indispensable to the institutions that depend on it. According to DB-Engines rankings, Caché held the title of the most popular object-oriented DBMS continuously from roughly 2013 until it was surpassed in that category by InterSystems IRIS around 2023 — a handover within the InterSystems family rather than a defeat by an outside competitor.

Its center of gravity remains healthcare. Because Epic Systems and the U.S. Department of Veterans Affairs’ VistA are built on this lineage, ObjectScript and its MUMPS core sit beneath the medical records of an enormous number of patients. Beyond healthcare, the platform appears in financial services, logistics, and large-scale scientific data processing such as the European Space Agency’s Gaia star-mapping mission.

InterSystems remains a substantial, privately held company — surpassing $1 billion in annual revenue in 2023 — and continues active development of IRIS and ObjectScript, including ongoing work to position the platform for analytics and AI/vector workloads.

Why It Matters

ObjectScript is a bridge across nearly six decades of computing. It carries the MUMPS philosophy — that a database and its programming language should be a single, seamless thing — out of the 1960s and into modern object-oriented, SQL-enabled, containerized systems, without ever breaking the code written along the way. Few languages have sustained such uncompromising backward compatibility for so long while remaining commercially central.

Its lesson is twofold. Technically, it shows how far the schema-light, multidimensional global model can scale when it is the foundation of a language rather than an afterthought. Institutionally, it is a reminder that the software running the most consequential systems in the world — the records of who is sick, who is owed money, where the stars are — is often written in languages the wider industry has barely heard of. ObjectScript matters not because it is fashionable, but because so much depends on it.