TADS 3

TADS 3 (Text Adventure Development System, version 3) is a specialized, object-oriented programming language and runtime created for one purpose: writing parser-based interactive fiction — the genre of text adventures in which players type commands like take lamp or ask sailor about the map and read the world’s responses. Where a general-purpose language would leave an author to build a parser, a world model, and a narrative engine from scratch, TADS 3 supplies all three as a coherent platform: a compiler, a portable virtual machine called T3, and a large library of pre-built world-modeling classes. The language it compiles has a syntax that will look familiar to anyone who has written C++ or Java, but its libraries and idioms are shaped entirely around simulating rooms, objects, characters, and conversation.

TADS 3 was created by Michael J. Roberts, who had authored the original TADS two decades earlier. It represents a complete rewrite of the engine rather than an incremental update, and it is considered — alongside Inform 7 — one of the two most capable systems for authoring serious, literary interactive fiction.

History & Origins

The TADS lineage begins in 1988, when Michael J. Roberts released the first version of the Text Adventure Development System as shareware through his company High Energy Software. At the time, hobbyist authors had few good options for building text adventures; TADS offered a more powerful parser and a cleaner object model than contemporaries such as AGT (the Adventure Game Toolkit).

TADS 2 followed and became the workhorse of the interactive fiction revival of the 1990s. Its syntax was based on C with borrowings from Pascal, and in July 1996 it was released as freeware, which greatly expanded its user base. In 1998, Multimedia TADS added graphics, sound, and hypertext capabilities layered on top of the TADS 2 core.

Even as TADS 2 flourished, Roberts had concluded that the underlying design had reached its limits. Rather than extend it further, he undertook a ground-up rewrite. The copyright on the TADS 3 source code dates from 1998, marking roughly when that effort began. Development was deliberate and lengthy: the first public beta of TADS 3 appeared around September 2004, and to demonstrate the new system Roberts released Return to Ditch Day, a complete game that doubled as an extended, annotated worked example.

The first general (non-beta) release, version 3.0.12, reportedly shipped in September 2006. This is the point at which TADS 3 is usually said to have “arrived” as a finished system. (Note that the year 1996 is sometimes associated with TADS generally — but that date refers to TADS 2 becoming freeware, not to TADS 3, whose public life began in 2004–2006.)

Design Philosophy

The central architectural decision that distinguishes TADS 3 from its predecessors is where the parser lives. In TADS 1 and 2, the virtual machine itself parsed the player’s typed commands before handing structured results to the game. TADS 3 instead ships a general-purpose virtual machine (T3) and moves command parsing into library code written in the TADS 3 language — an approach philosophically similar to Inform. This makes the parser an ordinary, overridable part of the game’s own program rather than an opaque, fixed feature of the engine, giving authors far deeper control over how input is interpreted and how the game responds.

The design goals that flow from this are consistent throughout the system:

• Literary quality of output. TADS 3 invests heavily in generating natural, grammatical English prose — automatic article selection, subject–verb agreement, list formatting (“a lamp, two keys, and a rusty sword”), and message substitution — so that generated text reads like writing rather than templated fragments.
• A rich but overridable world model. The standard library, adv3, models physical concepts in fine detail: containment, supporting surfaces, light and darkness, multiple senses (sight, sound, smell), doors, actors, postures, and travel connections. Authors extend and override these classes rather than reinvent them.
• Author ergonomics. Features like template syntax (which lets an object’s most common properties be declared positionally) and embedded expressions inside strings reduce the boilerplate of describing a large world.

Key Features

TADS 3 introduced a substantial set of modern language features over TADS 2:

• C++/Java-like syntax with classes, methods, and a familiar expression and statement grammar, lowering the barrier for programmers coming from mainstream languages.
• Dynamic objects with automatic garbage collection, allowing games to create and discard objects at runtime efficiently.
• Multiple inheritance with a well-defined method-resolution order, which the library uses extensively to compose behavior (a “lockable, openable door” mixes several classes).
• Structured exception handling (try/catch/finally) for robust error management.
• Native UTF-8 / Unicode strings, enabling non-English and accented text — important for internationalized interactive fiction.
• Anonymous functions and function pointers, supporting a flexible, event-driven style throughout the library.
• The adv3 library, a large, cohesive framework for building the game world, including a complete parser, world model, and message-generation system in TADS 3 code that authors can inspect and modify.

A very small taste of TADS 3 source, defining a room and an object using the library’s template syntax:

1
2
3
4
5
6
7
8

startRoom: Room 'Dusty Study'
    "Bookshelves line every wall of this cramped study. A single
    brass <<one of>>lamp<<or>>lantern<<stopping>> sits on the desk. "
;

+ lamp: Thing 'brass lamp/lantern' 'brass lamp'
    "It is tarnished but still sound. "
;

Evolution

After the 2006 general release, TADS 3 continued to receive maintenance updates from Roberts. The most recent stable release from the original author is version 3.1.3, dating from May 2013, which remains the reference version of the system.

A major evolution came from the community rather than the core engine. In 2013, longtime TADS author Eric Eve released adv3Lite, an alternative to the standard adv3 library. adv3Lite deliberately omits some of adv3’s rarely-used machinery (such as postures and multiple light levels) and drastically simplifies the class hierarchy, while adding conveniences such as scenes and regions, concepts borrowed from Inform 7. For many authors adv3Lite offers a gentler on-ramp to TADS 3 while retaining most of its expressive power.

Because TADS 3 was rewritten to isolate platform-dependent code, its games and tools travel well across operating systems. On Windows, authors typically use Workbench, a dedicated IDE. Cross-platform interpreters keep compiled games playable everywhere: QTads, a multimedia interpreter available under the GPL, runs on Windows, macOS, and Linux, and FrobTADS, a text-only terminal interpreter and compiler port, targets Unix-like systems including macOS. (Platform and licensing details here follow the interpreters’ own published documentation.)

Current Relevance

Interactive fiction remains a small but durable and creatively vibrant niche, and TADS 3 holds a respected place within it. It is generally regarded as offering the most powerful and detailed world simulation of any IF system, which makes it a favored choice for authors of large, mechanically rich games who value simulation depth and fine control over prose. Its principal peer is Inform 7, which trades some of that simulation depth for a natural-language authoring style; many authors choose between the two based on temperament as much as capability.

Development of the original engine has been quiet since the 2013 release, but the ecosystem stays alive through community effort: a working group and volunteer maintainers keep the interpreters, tools, and documentation current, and adv3Lite continues to be actively supported. Compiled games from the mid-2000s still run on today’s machines through modern interpreters — a testament to the portability that motivated the rewrite.

Why It Matters

TADS 3 matters as one of the clearest examples of a domain-specific language taken to full maturity. Rather than being a thin scripting layer, it is a complete, self-consistent programming environment — language, VM, standard library, and IDE — engineered around the peculiar demands of a single art form. Its insistence on high-quality generated prose, its deeply simulated world model, and its decision to expose the parser as ordinary, modifiable code influenced how the interactive fiction community thinks about the trade-off between authoring convenience and simulation power.

For programmers, TADS 3 is also an instructive case study: it shows how far a specialized language can go in shaping general-purpose features — classes, garbage collection, exceptions, Unicode — toward a narrow but demanding problem domain, and how a well-designed virtual machine can keep a body of creative work runnable for decades.