TADS vs Inform - a (vaguely) in-depth comparison
It's fairly well accepted in the rec.[arts|games].int-fiction
community that the two most-used languages are TADS and Inform, with,
as Graham modestly points out, the latter perhaps having a slight
edge. There have been some tentative and informal discussions of the
differences between the two languages, but no one to the best of my
knowledge has done any sort of serious point-by-point comparison of
the similarities, differences, and various features of the two
There is of course the seminal work in this field, the
"Which Authoring System is Better" FAQ, but it focuses more on
general issues in order to cover a wider selection of languages, and
also doesn't give very much coverage to the day-to-day details that
someone programming in the language would face; this text is aimed
more at the nitty-gritty programming issues.
This evalution is divided into two parts, a "current status of the
system" and "things that probably or may or might happen in the
future". Each of those is divided into two sub-parts, comments on the
system from the player's viewpoint and from the programmer's (although
these must of necessity overlap some; I put foreign-language support
into the coding section even though a French-speaking player is
obviously going to be concerned with it also).
When reading this, please remember that at this time, there is only
one compiler for each language, one virtual machine which each
language is compiled, and no cross-machine compilers. Therefore, I
will be using the language and the virtual machine entirely
interchangably, and the interpreters and the virtual machine somewhat
interchangably. Also, some of these responses are muddied by the fact
that TADS/HTML has just come out, a much-improved interface for
standard TADS games which allows various HTML-based innovations
(including sound, graphics, windowing, etc). In general my comments
apply to both standard TADS and TADS/HTML. I've tried to be clear when
I'm speaking about just one or the other. Finally, please note that
I've tried both TADS and Inform, but use TADS almost exclusively. This
should suggest something both about my experience with the two systems
as well as my personal biases; I've tried to be as fair as possible
but advocacy has a way of slipping in sometimes :) If you have any
comments on this page, feel free to mail me. I'm especially looking
for evaluations/descriptions of other languages (ie, Hugo) at this
level of detail.
- Inform games files tend to be smaller, and so are the save files
on the more up-to-date interpreters (ie, most of them).
- The look&feel of Inform games tends to be a little cleaner,
although this is a relative judgement.
- I like TADS' parser more, although again, this is a relative
- Portability of normal interpreters is in
general not an issue except on pocket machines: if you want to
play a game on your Pilot or Newton or something, it has to be
an Inform game. Graphics interpreters are somewhat less ported
for obvious reasons: the TADS/HTML interpreter is only available
on Win95 with a limited no-sound version on WinNT, while
Z-Machine interpreters are available for windows/dos, amiga, and
in limited form on the Mac.
- Inform's manual is more, mm, English (as in the country (which
is not entirely surprising, given the author)). I find the two
manuals approximately equally useful, though. Beyond the user
manual, Inform is better documented.
- TADS can produce bigger game files (ie, there's basically no
upper limit on how large the game can be; Inform games can be
sizable (q.v. Curses or Jigsaw or Erden) but there is an upper
limit which you might well reach).
- TADS lets you do dynamic object creation. Inform makes you
give a maximum number of objects of the class that will be
created (and, I think, actually creates them in the game file,
so they do take up space all the time. I'm not sure about this
- Standard TADS handles foreign languages in a somewhat less
sophisticated manner than Inform does, IMO. You can write a
game in Russian or Latin or Italian in Inform; it'd be much
more difficult or impossible to do the same in TADS.
But as Neil K Guy points out:
"Minor point: HTML-TADS fully supports ISO Latin-1. So you can write
games in most Western European languages. You can't do
double-byte fonts, so no Asian languages that use scripts, no
Arabic, Hebrew, etc. No Cyrillic either. The main problem
here, however, is the currently hardcoded parser. That can
make parsing many languages difficult."
- Some TADS interpreters will let the game call compiled C
code. This feature is rarely useful or usable.
- Inform was developed on an Acorn, a machine which is rare
outside the UK. As such, there are occasional annoyances in the
compiler and language which crop up for people not using Acorns
(ie, most people (but considering the majority of people use
Win95 and code accordingly, they are hardly in a position to
take the moral high ground)).
- Inform's source code is pretty good. TADS' source is horrid
(except for the new HTML parsing stuff, which is nice). This
shouldn't have too much effect unless you want to port it.
- TADS' default library is nice. Inform's default library is
also nice, unless you want to modify it.
- Inform's parser is nice. TADS' parser is also nice, unless you
want to change it, because you can't. There are a limited
number of entry points that let you do some stuff (eg,
customize error messages), but there are some things it just
- The syntax of the two languages are clearly different. This is
the most important difference from the programmer's
perspective, IMO, and will probably decide your preferred
language. I'm fairly biased about it, but IMO TADS is clean
and Inform is messy, and that's all there is to it. TADS feels
like C with objects, with some parser interfaces grafted
on. Inform feels like it was grown in layers. Nevertheless, it
may be easier to learn piecemeal, as there are many convenient
pieces to use (but the counterpoint to that, again IMO, is
that once you know a little TADS you can extrapolate the rest;
each new chunk of Inform is a concept unto itself and not
logically or stylistically related to any other chunk).
- Finally, if you like that sort of thing, there's graphics and
fancy cursor positioning and stuff. You can write a text-based
version of tetris in Inform; you can't do the same in TADS.
With the advent of TADS/HTML, both TADS and Inform can display
graphics and play sounds and make windows. As far as I can
tell, Inform's abilities in this area are superior but not as
well-documented, -defined, or easy to use currently. There's
also the minor issue that Inform games can't be written to use
just some graphics; you have to make a commitment and compile "a
graphics game", although the actual code changes required are
fairly small, I think. TADS games can use graphics with
virtually no change, and you can play the same game with a
graphics or non-graphics supporting interpreter. In fact, TADS
games currently can't even tell if they are being run on a
graphics or non-graphics interpreter, which may cause
problems (but this is going to be changed soon, so soon that I'm
mentioning it here and not in the "future issues"
section). Inform is in the middle of a change of standards;
currently it's not really possible to make graphics that adhere
to the old standards (which are supported by some interpreters),
and no interpreters support the new standards, which are the
only ones that actual games can be made with. (Also, note the
portability issues mentioned above
in the "playing" section)
- Oh, and Inform games compile to the same format that Infocom
games used. Some people like that.
Into the Future
- The source code of TADS is available and will probably be
improved. This will probably result in better portability, though
perhaps still not as good as Inform interpreters, and maybe I'll like
the look and feel more.
- The Inform parser may get changed. No idea. It is certainly at
least theoretically changable.
- It would be possible to add string compression to TADS games
which would reduce their size by a fair amount, and it would be
also possible to reduce the size of their save files (although
TADS' true dynamic creation makes this more difficult).
- Portability of TADS/HTML and graphics-capable Z-machine
interpreters is likely to increase somewhat but will probably be
restricted to the more major platforms (ie, Windows, Macintosh,
Amiga, possibly X-Windows).
- The TADS documentation will almost certainly get better. The
amount of example code for both languages will probably
continue to increase.
- A larger upper limit on Inform games will probably be made
soonish. This may or may not make them large enough to be
effectively always competitive with TADS' size limit.
- Inform is unlikely to ever get true dynamically-allocated
objects, in my opinion. I don't know much about this though.
(It's definitely theoretically possible to support dynamic
creation in the Z-machine, however).
- TADS' base foreign language support may change, though I'm a
little doubtful if this is a top priority due to (as far as
I see) little demand. TADS/HTML will probably become viable for
foreign languages once TADS' parser gets revised.
- TADS' source will probably get much cleaner. Inform source,
like I said, is already pretty good.
- Someone is planning on writing a whole new OOP Inform library.
This will be cool and probably have a large impact on the
language if it gets done.
- The TADS parser will be moving into the game file eventually.
This will presumably make it just as flexible as the Inform parser.
- The syntax of the languages is unlikely to change substantially,
or if it does, will probably exacerbate the style differences,
not erase them.
- TADS' graphics/sound abilities will probably improve
some. Inform's graphics/sound ease of use will almost certainly
improve. You will always be required to compile into a
special graphics game file as opposed to a "generic"
one. Interpreters that support the new Inform graphics&sound formats
should be appearing soon, allowing new-style graphics&sound games to be