OADL

OADL is a dynamically typed, interpreted, object-oriented language written by Ross Cunniff. Its name now stands for Object/Array Data Language. Cunniff’s reference manual says it was “designed for convenient implementation of applications with large numbers of pre-initialized objects (for example, a text adventure)”. OADL started in 1997 as the successor to ADL, the Adventure Definition Language that Cunniff co-designed a decade earlier. It grew into a language that mixes C-style syntax, class-based objects with multiple inheritance, and a large set of array operations modelled on APL.

OADL is obscure. It has no numbered public release, and the manual itself says “the OADL source itself has not been published”. What is public is unusually thorough: a full reference manual, man pages for every tool and intrinsic, a test suite of more than 200 programs, and complete adventure games written in the language.

History & Origins

From DDL to ADL

OADL comes from a line of text-adventure languages:

ADL was a superset of DDL. FOLDOC describes it as “semi-object-oriented” with a Lisp-like syntax, and lists Unix, MS-DOS, Amiga and Acorn Archimedes versions. It points to Usenet’s comp.sources.games and Fred Fish’s Amiga disk 91 as early distribution channels. The Interactive Fiction Archive holds a copy of the portable C source dated March 1993, together with two sample games, Aardvark’s Museum and mpu, plus a 1993 Amiga build and a 1996 MS-DOS build by other contributors.

OADL (1997)

The earliest dated OADL artefact is a version of the “99 Bottles of Beer” song, which is still in the OADL test suite. Its header reads:

The beer song, written in OADL, (Object Attribute Definition Language), the designated heir to ADL (Adventure Definition Language). Ross Cunniff, 1997

So in 1997 the “O” and “A” stood for Object Attribute. At some later, undocumented point the name became Object/Array Data Language, which reflects how central multi-dimensional arrays had become. The MIT licence text in the manual still reads “Copyright (c) 1997 Ross Cunniff”.

Cunniff has called ADL a hobby project. An undated NVIDIA blog author page describes him as an NVIDIA engineering manager responsible for Windows drivers for GeForce GPUs, and lists “Adventure Definition Language” among his “past hobby computer projects”. OADL appears to have been the same kind of personal project, developed over a long period rather than as a product.

Design Philosophy

The manual names three intended uses, and all of them assume OADL is embedded inside a game:

• an Adventure Definition Language for text adventures
• a way “to define object actions in a first-person shooter game”
• a general-purpose programming language

Three design choices follow from that.

1. Objects are declared, not just constructed. A program can declare named, pre-initialized instances at global scope, with their properties set in place. The world of a text adventure (rooms, items, actors) is written down as data.
2. Arrays are first-class values. The manual says arrays “can participate in arithmetic operations as easily as scalars can”. Many array methods “were inspired by the programming language APL”, but OADL gives them English names (reduce, reshape, rotate, outer) instead of APL glyphs.
3. Interactive use comes first. OADL has a built-in “desk calculator” mode, a read-eval-print loop. Most of the manual’s examples are written to be typed straight into it.

Key Features

C-like syntax with procedures and classes

The manual assumes “some familiarity with C, C++, and object-oriented programming”. The syntax looks like it, with proc in place of a return type. A bare string expression as a statement is printed:

1
2
3
4

proc main()
{
    "Hello, world!\n";
}

Classes declare public properties (shared names that any object can respond to), private variables and constants, and methods. Named objects can be declared with their initial property values. This excerpt comes from the 1997 beer song:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

class beerWall;
public describe, takeOneDown, numBeers, beerProc;

/* Here is our wall o' beer (oops - #17 is bear whiz instead) */
beerWall wall {
    numBeers = 99
    beerProc = proc(n) {
        return (n == 17) ? "bear whiz" : "beer";
    }
}

Multiple inheritance is written by listing the parents. The manual’s example is an adventure object that is both a light source and a key:

1
2
3

class litObjClass { public const lit = 1; }
class keyObjClass { public const unlocks = 1; }
class litKeyClass(litObjClass,keyObjClass) {}

APL-inspired arrays

OADL has generic arrays and lists, plus packed, homogeneous array types from PackBool and PackByte up to PackDouble and PackWideChar. Bracket syntax creates packed arrays, and indexing starts at 0. The examples below are from the manual, run in calculator mode:

1
2
3
4
5

    a = [3,3,3].iterate()
    a[0,1]
3 4 5
    [1:10].reduce(`+)
55

The backquoted `+ passes an operator as a value. The reduce documentation compares it with APL’s +/ and says that, like APL, reduction runs right to left. That is why [1:5].reduce(`-) gives 3.

Other language features

• Operator overloading, including an operator {} “completion” method that runs after an object’s initial properties are set
• Dictionaries, namespaces (namespace, using namespace) and dynamic classes created at run time with new Class(...)
• Exceptions with try / catch / throw. Any value can be thrown, and divide-by-zero raises oadl::RangeCheck
• forall, switch, match (regular-expression cases) and with statements, plus foreach expressions that build arrays
• UTF-8 source and wide strings, with a WideChar type for 21-bit Unicode characters
• Garbage collection, plus protect() and readonly() for immutable values

Toolchain

The man pages describe a complete set of command-line tools:

OADL programs can be linked statically or dynamically, and C code can be called through external procedures. The manual’s example of building an external library gives build commands for Linux .so, Windows .dll and macOS .dylib files. Because no OADL binaries have been released, that is the only platform information available, and it should not be read as a list of supported platforms.

A tagged value representation

The implementation notes describe how values are stored. In a 32-bit build, every OADL value fits in a 32-bit word. A Float keeps 31 bits of value and is marked by a least-significant bit of 0. An Int keeps 30 bits and is marked by the low bits 01. Every other type uses the low bits 11, a 6-bit type ID and a 24-bit value or ID. In a 64-bit build, Double and Long get the inline encodings instead, and IDs grow to 32 bits. Small scalars therefore need no heap allocation, and larger values go through IDs into a garbage-collected pool.

Evolution

There are no dated public releases, so OADL’s evolution can only be read from its own files:

• 1997: OADL exists as “Object Attribute Definition Language”, the planned successor to ADL.
• Later (undated): it is renamed Object/Array Data Language, and the array subsystem grows into an APL-like toolkit (reduce, accum, outer, inner, encode/decode, laminate, ravel, reshape, rotate and others).
• 2023: the adventure demos built on the libadv/stdadv libraries carry a 2023 copyright.
• 2025: the external-procedure example in the manual carries a 2025 copyright.
• 2026: the hosted manual and test pages were last modified in March 2026.

The test suite shows how broad the language has become. It has files for packed arrays, half-precision floats (fp16tables.oad), UTF-8 edge cases, lambdas, memoisation, a trie and linear algebra.

Current Relevance

OADL has no community, no package manager, and no source or binary distribution, so from the outside it looks historical. In practice it is a long-running personal language that its author still updates, and it is documented publicly while the implementation stays private. Anyone curious can read the whole design online, but nobody outside can currently run it.

Why It Matters

OADL is a rare case of a 1980s adventure-authoring language continuing into the present in a modernised form. The Aardvark’s Museum and MPU sources moved from DDL to ADL to OADL, so the same game worlds have been rewritten across about four decades of language design. The language is also an unusual combination: a scripting language for game objects that includes a serious APL-style array system. Few hobby languages document themselves this thoroughly, and OADL’s reference manual, man pages and test suite make its design readable even though nobody outside can run it.