TOM

Tom is what happens when a group of rewriting researchers stop trying to make people come to their language and go to everybody else’s instead. Built at LORIA in Nancy from around 2000 and developed at Inria for the better part of two decades, Tom takes the machinery of term rewriting — algebraic signatures, pattern matching modulo equational theories, rewrite rules, traversal strategies — and grafts it onto Java. A .t file is a Java file with extra constructs in it; the tom command expands those constructs into ordinary Java and hands the result to javac. Nothing is interpreted and no foreign engine takes over at run time, though generated code does link against Tom’s own runtime library (tom-runtime-full.jar, on the CLASSPATH); and in principle an ordinary Java program is already a valid Tom program, since the compiler expands only the constructs it recognises and passes the rest through untouched.

The name is an acronym, and a slightly apologetic one. The project’s own about page explains it: “In its first version, Tom was just supposed to add pattern matching facilities to a programming language. The considered pattern matching feature was supposed to discriminate over a single subject. This is why Tom is called Tom: To One Matching.”

Dating the language

Language lists give 2000, and the project’s own copyright line supports it: the LICENCE file in the source tree reads “Copyright (c) 2000-2015, Universite de Lorraine, Inria”. But nothing dated 2000 survives in the code. The oldest record in the tree is the ChangeLog, and it opens on 25 January 2001 with a single line — “Setup of TOM under automake” — followed on 6 February by the first JavaCC parser and on 14 February 2001 by an entry that reads, in full, “src/jtom/Tom.java: first bootstrap”. The first publication, “A Pattern Matching Compiler” by Pierre-Étienne Moreau, Christophe Ringeissen and Marian Vittek, was presented at the first LDTA workshop in Genova in April 2001.

Version numbers arrive late and start low. The ChangeLog dates version 0.6 to 29 October 2002 (it introduces the backquote notation), version 0.7 to 19 November 2002 (“bootstrap with ApiGen”), and 1.0beta to 21 November 2002. The safest reading is that 2000 is when the design work began, 2001 when there was a working compiler, and 2002 when it started being versioned for other people.

Where it came from: the ELAN lesson

Tom’s ancestry is explicit. The Protheo group at LORIA had spent the 1990s building ELAN, a rewriting language with non-deterministic strategies and a compiler for associative-commutative rewriting that was, along with Maude, among the most serious implementations of its kind. The Tom about page states the lineage directly: Tom’s “design follows our research on rule based languages, and our experiences on the efficient compilation of ELAN”.

What the group took from ELAN was less a technique than a disappointment. The RTA 2007 system description sets it out plainly: implementing a good term data structure is hard, marshalling data in and out of a rewriting engine is often the bottleneck, built-in integers and doubles are awkward, mutable structures like arrays are essential and missing — “but one of the most important things we learned is that even if efficiency is important to make our technology credible, integration capabilities are even more important to make our research widely used both in academic and industrial projects.”

The alternative to piling libraries, threads, GUIs and native interfaces onto a research language was to stop competing with Java. The group called the resulting idea a formal island: a fragment of formally-defined, rule-based code embedded in an ordinary program, connected to the surrounding data by a formal anchor — a mapping that explains how an existing concrete data structure is to be read as an algebraic term. The idea is related to Wadler’s views, and its practical effect is that Tom can rewrite data structures it did not create, without converting them first.

What the language adds

The whole language is a handful of constructs. The canonical example from the project’s guided tour defines a signature and matches on it:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

import matching.logic.types.*;

public class Matching {

  %gom {                                // algebraic signature
    module Logic
      imports int String
      abstract syntax

      Proposition = P(t:Term)
                  | Q(t:Term)
                  | implies(p1:Proposition, p2:Proposition)

      Term = nat(i:int)
           | var(name:String)
           | plus(t1:Term, t2:Term)
  }

  public static String prettyProposition(Proposition p) {
    %match(p) {                          // pattern matching over terms
      P(t)           -> { return "P(" + prettyTerm(`t) + ")"; }
      Q(t)           -> { return "Q(" + prettyTerm(`t) + ")"; }
      implies(p1,p2) -> { return "(" + prettyProposition(`p1)
                                 + " => " + prettyProposition(`p2) + ")"; }
    }
    return "";                           // javac does not know this is unreachable
  }

  public static String prettyTerm(Term t) {
    %match(t) {
      nat(i)      -> { return Integer.toString(`i); }
      var(x)      -> { return `x; }
      plus(t1,t2) -> { return prettyTerm(`t1) + " + " + prettyTerm(`t2); }
    }
    return "";
  }

  public static void main(String[] args) {
    // backquote builds terms; maximal sharing makes equality a pointer test
    Proposition p = `implies(P(plus(nat(1),nat(2))), Q(var("x")));
    System.out.println(prettyProposition(p));
  }
}

The moving parts:

Two properties follow from Gom’s term representation, inherited from CWI’s ATerm and ApiGen work: terms are maximally shared — the property inherited from CWI’s ATerm library, under which no two structurally equal subterms are ever separately allocated, so that testing structural equality is a pointer comparison rather than a traversal — and lists can be normalised with respect to equational axioms — associativity, associativity with neutral element, and (from 2.8) associativity-commutativity — so that matching happens modulo those theories rather than syntactically.

Evolution

The backend story is messier than the release notes suggest. Java was always the supported target; the source tree also carries generators for C, C#, Caml, Python and - from the final release of 2013, according to NEWS - Ada, of varying completeness, and the manual is candid that the model-transformation constructs of the last release work “only [for] Java and EMF”. The installation guide in doc/ gives the requirement as a development kit “version 1.5 or newer”, and reports that Tom “has been used successfully on many platforms, including GNU/Linux distributions (Debian, Gentoo, Mandrake, Ubuntu), MacOS X, FreeBSD, NetBSD, Windows XP, Windows Vista and Windows 7” — a list of platforms the project says it was used on rather than a supported-platform matrix.

The decline

Tom did not fail; it stopped. Version 2.10 shipped on 21 March 2013 and no release followed. The ChangeLog runs on to August 2013, the master branch to December 2017, a v3 branch to August 2019, and build.xml still names an unreleased 3.0-dev. Then the infrastructure went: Inria took gforge.inria.fr off-line at the end of 2020, and with it every download link, the Windows installer, the bug tracker and the git URLs printed all over the project’s pages. The site at tom.loria.fr is still served, but what is served is a static HTTrack copy of it made on 1 March 2023, complete with dead links to the forge. Tom does not appear ever to have been published to Maven Central — nothing is served under the obvious group IDs — so there is no package-manager fallback either.

What survives is the source. A mirror of the repository was created on GitHub in February 2016 and is complete back to the CVS-to-Subversion import of 8 January 2003, with the pre-2003 history preserved in the ChangeLog. And in May 2026, over three days, Pierre-Étienne Moreau pushed 63 commits to a branch called tom-go: the ATerm library, the parser, the Gom backend and the compiler phases ported to Go, with the commit messages tracking parity against the Java implementation test by test. It is branch work, unreleased and unannounced, and it would be wrong to call it a revival — but it is the only movement in the project since 2019, and it is by the person who started it.

Why it matters

Tom is the most fully worked-out answer to a question the programming-language research community keeps running into: what do you do when your ideas are good and nobody will switch languages to get them? The formal-island approach — put the formal fragment inside the industrial language, connect it to existing data through a mapping rather than a conversion, compile it away to nothing — let a rewriting group ship pattern matching, equational matching, rewrite rules and strategy combinators into Java projects the best part of two decades before Java itself got pattern matching, and let those projects keep their own data structures while doing it.

It is also a good specimen of how such a project actually ends. There was no fork, no schism, no successor language: there was a research group whose people finished their theses and moved on, a series of releases that got steadily better and steadily more specialised, one clearly documented industrial engagement, and finally a hosting service being decommissioned. The compiler is four fifths written in itself, which is the sincerest thing a language designer can say about a design; the tarballs it was distributed in are gone; and the whole of it now fits in a git clone.

Running Tom today

There is no Docker image and no official download. What is available:

• The source. git clone https://github.com/rewriting/tom.git gives the full history, the Ant build (./build.sh), the manual under doc/, and the examples and regression tests. Building it requires a JDK and bootstrapping through the checked-in stable compiler; the tree was last built against Java 8 and would need care on a modern JDK.
• The documentation. The reference manual, guided tour and FAQ are in the repository as Markdown under doc/, and the 2.7-era manual PDF is deposited in Inria’s HAL archive.
• The web site, tom.loria.fr, as a frozen 2023 mirror: news log, applications, licensing, and the Emacs, Vim and Notepad++ syntax files, which are among the few links on it that still resolve.

The licence remains the one the project settled on in 2005: GPL v2 for the compiler, BSD for the runtime library and the predefined mappings, precisely so that anything Tom generates can be redistributed under whatever licence its author prefers.