• The KBOX project
Zork on Android using KBOX and Frotz (etc)
Interactive fiction (IF) contines to hold the attention of a small but loyal
group of followers. I suspect that many of this group, myself included,
grew up telling Advent to rub the electric lamp in the 1970s.
The Zork range of games produced by Infocom
was probably the first commercial success in this
area, and these games are still regularly played by enthuiasts;
there is, at the same time,
a movement to promote interactive fiction as a literary endeavour, rather
than purely a form of gaming.
What both the literary and the gaming varieties of interactive fiction
have in common is
that they continue to be largely based on forms of virtual machine architecture
popularised in the 1980s, and designed for text-in, text-out interaction — they are essentially terminal-based.
The Z-machine ('Z-code') platform is probably still the most
popular of the various IF technologies, despite its technical limitations.
All the original Infcom games
used this format, and many modern offerings do also. Glulx is
a more modern virtual machine format, conceptually similar to Z-machine,
with fewer of its more glaring limitations.
TADS is an alternative to Glulx and Z-machine with a rather different
architecture. All three of these environments have in common that,
although they offer some support for graphics, sound, and more modern
forms of user interface, they can be made to work in a text-only
IF has generated relatively little interest among users of
mobile devices. There are (at least) two reasons for this. First, mobile
handsets generally don't have real keyboards, and all mainstream IF games
input. This isn't a problem that is likely to be solved by improving the way
that existing IF games work on mobile devices. There are a few brave attempts
to adapt the IF idiom to the finger-prodding interface of mobile devices, but
most of the impressive IF games — the ones that people
actually want to play — are are not readily adaptable to such an
interface. This situation may change if there is sufficient interest in
doing IF on mobile devices; in the meantime, we are stuck with doing the
best we can with the existing, terminal-based games and the programs that
support them. If we have to
use keyboard input, then the program should, as a minimum,
offer proper line editing
and support external keyboards. The fact that most Android devices do
not provide virtual keyboards with enough keys (cursor, delete, backspace)
to edit properly is no excuse not to provide the facility in the application — 3rd-party virtual keyboards (and, of course, real keyboards) are available
to remedy this lack.
This brings us to the second problem:
the lack of good, stable implementations of
IF virtual machines for Android and similar platforms, with decent
font and keyboard support. This is the case
even for Z-machine, which is well-documented, and of which implementations
exist for just about every other platform and programming language. Typically
Z-machine is the first IF architecture to be ported to a new platform, simply
because it is so well understood.
For Android, the best-known (only?) implementations of a Z-machine platform
for IF are JFrotz, ZMPP, and Twisty. None of these (so far as I can tell)
offer reliable line editing or line history, even with an external
keyboard, or a virtual keyboard that offers editing keys. None correctly
handled games that needed sophisticated screen management, such as
Beyond Zork, with its popup menus and ASCII-art maps (and I'm using the
word 'sophisticated' in 1970s terms here, not pipelined
texture mapping and suchlike). Of the three, only JFrotz allowed any choice of
display fonts, but it's very slow, even on a fast device.
Twisty is relatively stable but has few configuration choices, and
some games rendered incorrectly. ZMPP looks very nice — it was the only
app I could find that supported proper variable-pitch text rendering — but (so far as I can see) it provides no way to get access to game files
other than those from the IF Archive (in-program access to the IF archive
is a nice feature, but this rules out the Infocom games, which are not
really in the public domain). ZMPP also shows advertisements although,
to be fair, they are unobtrusive.
I couldn't find any reasonably stable Android implementations of a
Glulx or TADS environment. There's been some preliminary work, and it's
to work in your mobile Web browser, but none of this is very encouraging.
It's possible that the approach I describe here is currently the
only way to play TADS or Glulx games on Android.
An alternative approach to IF on Android, using
a proper terminal emualtor
One of the main features of IF games is that they are (nearly always)
be able run in a terminal. This makes it very easy to port the IF interpreters
to different platforms, so long as there is a terminal, or terminal
emulator, available. Android does not supply a terminal emulator, or any
of the usual tools that a terminal-based environment would supply.
This means that anybody who wants to implement a
Z-machine (or whatever) for Android has first of all to implement a
this properly is difficult which, I guess, is why most Android
IF apps offer such
limited choices of font, background colour, etc., and why line editing
is such a chore (because it requires a terminal with proper cursor
But there are 3rd-party terminal emulators for Android, which do all this
stuff properly. Jack Palevitch's Android Terminal, for example,
is robust and highly
customizable, and is free and open source. So why not use an
existing terminal as the basis for playing IF games on Android? Terminal
emulators are designed for running applications that run in a console;
typically such applications are for system administration, but a console will
host an interpreter for Z-Machine (or whatever) easily enough.
THe KBOX project
My KBOX project is an
attempt to merge Jack Palevich's terminal app with just enough Linux
to make it relatively straightforward to port existing Linux/Unix
console applications to run on Android. It does this without rooting or
any of the other nasty stuff that people often employ to make their
Android systems more Linux-like. Among the various things that KBOX
provides are the the libraries needed
to do the extensive screen and keyboard control that a decent
IF interpreter implementation
will need. In addition,
KBOX includes a package manager, and packages are available for
Frotz (for Z-machine games), glulxe (for Glulx games), and
frobtads (for TADS2/TADS3 games).
Frotz is essentially the reference implementation of a Z-machine — given the limitations of a pure terminal environment it provides the
most complete implementation
of the Z-machine specification. It does not support graphics or sound,
but none of the other Android Z-machine implementations do either.
Best of all, because Frotz is implemented in highly optimized, compiled
C code, not Dalvik Java, it's very fast. glulxe is the equivalent for
Glulx games; again, it's lightweight and very fast. frobtads is an
interpreter for console-mode TADS games; it's slightly less useful that
Frotz and glulxe because many more TADS games include graphics than
Z-machine or Glulx games do. Nevertheless, at least some TADS games
play reasonably well.
So if you're desperately keen to play Beyond Zork, Ecdysis, or King
of Shreds and Patches on your
Android handset, and none of the available Android apps cut the mustard,
then running a console-mode interpreter under KBOX may be a viable
requires a bit of setting up in the first instance, and familiarity with
the Linux command-line is certainly helpful; but my guess is that anybody
who wants to play IF games is unlikely to be put off by a bit
How to install KBOX terminal, and various IF interpreters
The setup procedure is a bit fiddly, but only has to be done once.
- Download and install the KBOX terminal, using the instructions
Essentially, download the Android app
and install it using any Android file manager (you might have to enable
support for off-Market apps in the Settings app to be able to install
KBOX; KBOX will never be available on the Android Market).
- Download the appropriate interpreter package(s) for the games you want to
using the Web browser on your Android device. Alternatively, download
them some other way and get them onto your device (perhaps using USB).
I'm assuming that you've downloaded using a browser, and the files are
Download directory on your device — adjust the instructions that
follow if you've done something else.
Available interpreters at preset are as follows:
- If you aren't going to be using a hardware keyboard, I would recommend
installing a fully-featured virtual keyboard like Klaus Weidner's
Hacker's Keyboard. This will provide the line editing keys
that most Android keyboards lack. As well as making Frotz work better,
a virtual keyboard with editing keys will make it easier to enter the
installation commands below.
- Start the KBOX terminal using the Android launcher. You'll get a
command prompt (all being well). The first start-up might take some
time, because there is some intialization to do.
- Install the interpreter package(s) using the command prompt, like this:
$ dpkg -i /sdcard/Download/frotz_2.4.3_kbox.deb
$ dpkg -i /sdcard/Download/glulxe_0.5.1_kbox.deb
$ dpkg -i /sdcard/Download/frobtads_1.2.2_kbox.deb
If you have an external SD card, your
directory might be in
a different place. Try, perhaps:
$ dpkg -i /storage/extSdCcard/Download/frotz_2.4.3_kbox.deb
This is where downloads from the Web browser go on my Samsung Galaxy
Tab 2. I appreciate that this step might be a bit fiddly for people
who are not used to working at the Linux command prompt.
Repeat for the glulxe package, if necessary.
- Test Frotz by typing
frotz at the prompt. It won't
run anything, but you should see a usage message. Same for
glulxe and frobtads
Running Frotz, etc
To use Frotz, glulxe, or frobtads, you'll need to copy some game files onto
your device; again, you can do this by downloading them using the
browser, or copying over USB. I'm assuming that the game files are
Download directory although, of course, you can
use any directory you like, so long as you can find it at the command
prompt on the device. To run a game:
$ cd /sdcard/Download
$ frotz somefile.z5
$ glulxe somefile.gblorb
$ frob somefile.gam
Frotz generally can't work out how wide the terminal is (in terms
of characters), so if you're working on a small screen, or with a large
font, you'll need to help it out. Do this by specifying the
width in the
frotz command like this:
$ frotz -w 65 somefile.z5
The screenshot at the top of this article is from a Galaxy Tab 2 in
portrait mode, with 16-point font and 65 character width. The keyboard
is Klaus Weidner's Hacker's Keboard, set to 5-row mode, so
that you get the arrow keys for editing lines and cycling through the
You might need to experiment with this width if you change the font size.
Frotz will work with both landscape and portrait orientation, but it
will get confused if you change from one to another in the middle of a
WIth all the interpreters, if you save a game, then by default the
save file will be written into
the current directory (which was
/sdcard/Download in the
example above). Be aware that the same default filename is used by
a number of different games, so you should probably change it if you
have more than
one game in progress at a time.
Be aware that neither Frotz nor glulxe respond very well to having their
screen size changed at runtime. This will happen if you change the font,
but it can also happen if you rotate the screen, or even allow the
virtual keyboard to pop up and down. It's certainly better to keep the
virtual keyboard up all the time. Of course, it's even better to use an
external keyboard, but that isn't always practicable.
In general, frobtads seems to work the least well of the three interpreters
available — this, I think, is because many games embed images in the text,
and the inability to display these images in a console interferes with
the screen layout.
I'm aware that the approach I've outlined to playing IF on Android is
likely to be of interest primarily to people who have familiarity with
working at the Linux command prompt. Once an interpreter is running
things are straightforward enough, but
getting it to run means fiddling about with files and directories, which
isn't everybody's idea of fun. I'm guessing that people with an interest
in IF are going to be willing to tolerate a bit of typing but, at the
same time, I expect that many of these people will not be familiar
with working at a Linux command prompt.
It would be possible to produce a version of KBOX that has Frotz and
other IF interpreters built
in, so users wouldn't need to install them at the prompt. It would also
be possible to provide some facility to search the Android media storage
locations for compatible game files, so you wouldn't have to type the
filename at a prompt In the longer term, it would even be possible to
provide a Frotz-specific user interface to the terminal, so that all the
file selection stuff was done with common Android dialogs.
Whether it's worthwhile to do any of this, I'm not sure. In the end,
the main limitation to the success of IF on Android is that Android
devices don't usually have keyboards, and
that isn't something that can easily be fixed in software.
Comments welcome, as always.