Rel

Rel is a free, open-source desktop database management system created by Dave Voorhis that implements Tutorial D, the relational database language designed by C.J. Date and Hugh Darwen. Where most database systems speak SQL, Rel speaks a language built to be truly relational — faithful to the relational model in a way SQL never fully was. It exists primarily as a teaching and exploration tool: a place to write relational code the way Date and Darwen argued it should be written.

History & Origins

Rel grows directly out of The Third Manifesto (TTM), a body of work by Date and Darwen that began circulating informally around 1994 and was first published officially in ACM SIGMOD Record in 1995. The Manifesto is not a product but a detailed prescription: a set of principles and prohibitions describing what a future relational database language should — and should not — do. Successive book editions (1998, 2000, and the 2006 Databases, Types and the Relational Model) expanded and refined these ideas.

The Manifesto deliberately stops short of defining a complete language, instead specifying a family of conforming languages collectively called D. To make the ideas concrete, Date and Darwen defined Tutorial D, a pedagogical language that satisfies the Manifesto’s requirements. What was missing was a way to actually run it.

That gap is what Dave Voorhis set out to fill. He released the first version of Rel in 2004 as an open-source, Java-based implementation of Tutorial D intended for instructional use. (Some catalog entries list a slightly later date for the project; the first release is most consistently documented as 2004.) Rel gave students, instructors, and TTM enthusiasts a working system in which the abstract rules of the relational model could be typed in, executed, and explored.

Design Philosophy

Rel’s guiding principle is relational fidelity. Tutorial D — and therefore Rel — is designed to honor the relational model as Codd originally conceived it and as Date and Darwen later formalized, rejecting the practical compromises that crept into SQL:

• Relvars, not tables. Tutorial D works with relation-valued variables (relvars) whose values are relations. This treats relations as first-class values — things you can assign, pass, and compute with — rather than as a special-purpose table construct.
• No NULLs. The Manifesto forbids NULLs and the three-valued logic SQL uses to handle them. Rel enforces this, sidestepping a long-standing source of subtle query bugs.
• No duplicate tuples. A relation is a true set of tuples, so duplicate rows are impossible — query results are predictable and well-defined.
• A real type system. Tutorial D is statically and strongly typed, with user-defined types, operators, and a carefully specified model of type inheritance drawn straight from the Manifesto.
• Language, not just queries. Tutorial D is a complete computationally capable language, not merely a query sub-language, blending relational operations with general-purpose programming constructs.

The overarching goal is education and correctness rather than raw performance: Rel aims to show what a database language should look like when the relational model is taken seriously.

Key Features

• Tutorial D language — a direct, executable implementation of the Date & Darwen specification, including relational operators such as JOIN, EXTEND, SUMMARIZE, RENAME, and relational restriction/projection.
• Nested relations — Tutorial D supports relations whose attributes are themselves relations, giving flexibility in modeling and in presenting complex query results.
• User-defined types and operators — values can have rich, user-defined scalar types, with type inheritance as described in the Manifesto.
• Written in Java — Rel runs on any operating system with a Java virtual machine, which made it broadly portable for classroom use across Windows, macOS, and Linux.
• Berkeley DB storage — Rel uses Oracle’s Berkeley DB as its underlying storage engine, while exposing a fully relational data model on top of that key-value foundation.
• DBrowser interface — alongside the textual Tutorial D interface, Rel ships with a graphical client for browsing and querying databases.

A small taste of Tutorial D as run in Rel — defining a relvar and querying it:

VAR Suppliers REAL RELATION {
  SNO CHAR,
  SNAME CHAR,
  CITY CHAR
} KEY { SNO };

INSERT Suppliers RELATION {
  TUPLE { SNO 'S1', SNAME 'Smith', CITY 'London' },
  TUPLE { SNO 'S2', SNAME 'Jones', CITY 'Paris'  }
};

Suppliers WHERE CITY = 'London';

The example shows the hallmarks of the language: a relvar declared with an explicit KEY, relation and tuple values built with the RELATION and TUPLE literals, and a restriction expressed with WHERE.

Evolution

Rel has evolved alongside the Manifesto it implements. As Date and Darwen revised Tutorial D across editions of their books — culminating in the 2006 third edition — Rel tracked those refinements, aiming to remain a faithful, current implementation. Over time the project moved to open development on GitHub under the Apache 2.0 license, with ready-to-run distributions made available through SourceForge as numbered releases — the 3.x series, reaching approximately version 3.016. While the GitHub source repository carries no tagged releases, the SourceForge distributions are versioned, and development requires a modern Java toolchain.

Rel is one of several efforts to implement Manifesto-conforming languages — others include Duro and Dataphor — but it remains among the most accessible and widely cited, precisely because it targets Tutorial D, the language Date and Darwen themselves use for teaching.

Current Relevance

Rel occupies a deliberately niche position. It is not meant to compete with PostgreSQL, Oracle, or any production SQL system; its maintainers describe it as a work in progress best suited to learning true relational concepts, building non-critical databases, and serving as an educational tool. In that role it remains valuable: it is one of the few places where a programmer can write code against a strict, NULL-free, set-based relational model and watch the theory behave exactly as specified.

For anyone studying database theory, comparing SQL against its relational roots, or working through The Third Manifesto, Rel turns a dense specification into something you can actually run.

Why It Matters

Rel matters because it makes an argument executable. The Third Manifesto is, at heart, a critique of SQL and a vision of what relational databases could be if built on firmer logical foundations. Such a vision is easy to dismiss as academic — until you can type it in and run it. By providing a concrete, freely available implementation of Tutorial D, Dave Voorhis gave the relational community a way to test, teach, and defend those ideas in practice. Rel is a reminder that the relational model is richer and more disciplined than the SQL most developers know, and a working invitation to explore what databases might have looked like had the theory been followed more closely.

Sources: Rel — Database of Databases (dbdb.io), DaveVoorhis/Rel on GitHub, Rel — The desktop relational database management system (reldb.org), The Third Manifesto (TTM) — Hugh Darwen & C.J. Date, and Rel and Tutorial D Quickstart (reldb.org).