MegaZeux

MegaZeux (usually MZX) is a text-mode game creation system written by Alexis Janson and released for MS-DOS on 4 December 1994, and Robotic is the scripting language that gives its games their behaviour. Both were conceived as an expanded ZZT: where Tim Sweeney’s 1991 game let players script objects in the small ZZT-OOP language, MegaZeux let them script robots in a much larger one, redraw the character set and palette, play MOD music, and run arithmetic on named counters. It was arguably the only one of the many ZZT-inspired systems to find a lasting audience. Released as shareware, then as GPL free software after Janson left in the late 1990s, it has been rewritten twice by its community - once for SDL in 2004, once around SDL 2 in 2017 - and in 2025 was still shipping new versions for Windows, macOS, Linux, the web, and a shelf of consoles from the Nintendo DS to the Sega Dreamcast, as well as, once again, MS-DOS.

The encyclopedia catalogues MegaZeux as dormant, and as a language that is fair: Robotic’s command set has been effectively frozen since the 2.6x series because the world format has almost no room left for new opcodes, and the community that once ran two Day of Zeux competitions a year is much smaller than it was. But the program is not dormant at all. Its official git repository received commits in the week this page was written, and the engine that ran Robotic in 1994 world files can still load them.

History and origins

From ZZT to Zeux

Janson was a well-known ZZT author before she was a language designer. Her ZZT releases include Super Tool Kit (STK), Code Red and Mission:Enigma, and in 1993 she published a shareware DOS side-scroller, Labrynth of Zeux (the title is spelled that way), under her own label, Software Visions. ZZT’s limits were familiar to everyone who used it: a fixed character set, sixteen colours, a handful of counters, and an object language with no arithmetic. MegaZeux was her answer. Version 1.00g went up on AOL on 4 December 1994 for IBM PCs running MS-DOS, and MZXWiki’s summary of what it added is a good summary of the whole design brief: “digital sound and music on compatible hardware, editable character sets, and adjustable board sizes”, plus a robot language, originally called Robo-P, in place of ZZT-OOP.

The shareware package bundled Zeux II: Caverns of Zeux, the sequel to Labrynth of Zeux, and every version from 1.00g to 2.51 shipped with it. As with ZZT, the world editor was included free, so anyone could make and distribute games without registering. (Older documentation and copies of the Wikipedia article credit the author under a former name; the community’s wiki and the official README use Alexis Janson, and so does this page.)

The shareware years, 1995-1996

Janson rewrote the program almost entirely for the 2.x series in 1995, adding EGA palette editing and a much improved language, and kept expanding Robotic through 2.07 (January 1996) and the 2.4x betas: palette commands, copy block, the loopcount counter, and above all counter interpolation, the ability to drop &counter& into almost any argument. Her own game Weirdness (early 1996) demonstrated inventory engines, a 3D maze and a weapon system that nobody had built in MZX before, and the community’s expectations of what a MegaZeux game should be never went back.

MegaZeux 2.50 (24 August 1996) replaced the sound code with the BWSB library, supporting stereo and 16-bit cards, 32 music channels and four sound-effect channels. Its release notes announced, in capitals, that it was “the LAST planned release of MegaZeux”. 2.51 followed on 1 December 1996 as “a quick bug-fix release while working on 3.00”, promising a protected-mode MegaZeux 3.00 with public betas. It never appeared. 2.51 was Janson’s final version; its README already directs users to Matt Williams (MattW) for updates.

The GPL release and the Spider years

Janson left the community, and the existing, incomplete 2.51 source was released under the GNU GPL version 2. The MZXWiki says only that “Janson later released MegaZeux’s existing incomplete source code under the terms of the GNU GPL”; the old Wikipedia article adds that the release followed negotiations between MenTaLguY and MattW as Janson’s successor-in-interest. The exact date is not recorded in the sources located, but it was before 17 January 1999, when Spider 124 released MegaZeux 2.51 s1, the first community build, raising the counter limit from 50 to 1,000 and adding mouse support. 2.51 s2 (October 1999), JZig’s s3 (December 1999) and s3.1, and MadBrain’s s3.2 (April 2001) followed, and the “Spider versions” became the mainline.

One thing had not survived: the source of the Robotic editor. This shaped the language for the next decade. New behaviour could be added by giving special meaning to counters and strings - which existing commands could already read and write - but not by adding commands, because the editor that parsed and compiled Robotic could not be changed. Exophase and Akwende, MZXWiki records, “used kludges involving strings and newly added counters … to allow for Robots to handle things they had not been able to handle before”, and that is how sprites, file access and expressions arrived.

The period also saw forks. MadBrain’s Super MegaZeux 100 Alpha introduced SMZX mode, halving horizontal resolution to give each character cell four colours from a 256-colour palette; Akwende’s MZXak added robot IDs; both fed back into the mainline. In March 2002, after a public dispute over Akwende’s failure to release the MZXak source under the GPL, Koji released 2.60 and 2.61 incorporating a subset of MZXak’s additions, and a week later Exophase (Gilead Kutnick) took over with 2.62.

Exophase, SDL and the modern engine

Exophase was head maintainer from March 2002 to December 2006 and, MZXWiki says, “the major player in the porting/writing of MegaZeux for Windows and other modern 32-bit platforms”. 2.65 (4 October 2002) added sprites and subroutines; the 2.6x series as a whole brought strings (introduced in a limited form in 2.62), mathematical expressions, the vlayer (an off-screen scratch board) and MZM board fragments. 2.70 (6 August 2004) was the last DOS release. Three days later, on 9 August 2004, the 2.80 beta appeared: MegaZeux rewritten on SDL over the summer of 2004 “to eliminate DOS-specific limitations”. Counters became 32-bit, the subroutine stack became dynamic, and - although the first 2.80 builds were for 32-bit Windows only - MegaZeux soon ran on Windows, Linux and Mac OS X; the project README dates the multi-platform port to 2005.

Alistair Strachan (ajs) led the releases from 2.81d (December 2006) through 2.83 (2009), a period in which the code was backported from C++ to C so it could run on processors without floating-point units. That opened the console era: GP2X (2.81g, July 2007), PSP (officially supported in 2.81h, December 2007), Kevin Vance’s DsMZX Nintendo DS port (merged in 2.82, June 2008), Mr_Alert’s Wii port and an AmigaOS 4 port (2.82b, December 2008), a first Android port (2.83) and a Pandora port (2.84, June 2012). 2.84c on Christmas Eve 2012 added a counter debugger, and then the project went quiet for four and a half years - long enough that Eevee’s 2016 essay Succeeding MegaZeux could describe it as “finished, in the sense that a novel is finished”.

It was not. MegaZeux 2.90 (29 June 2017) moved to SDL 2, overhauled the world format and renderers, added unbound sprites for pixel-precise positioning, a Robotic debugger, SAVE_COUNTERS/LOAD_COUNTERS, options for packaging standalone games, and a 2 MB bytecode limit. Since then Alice Rowan (Lachesis) has maintained the project through 2.91 (3DS port), 2.92 (Switch and Emscripten/HTML5 ports, joystick overhaul), 2.93 (31 December 2023: MegaZeux 1.x world support, PlayStation Vita, Wii U, Dreamcast and a DJGPP 32-bit MS-DOS port) and the 2.93b-d bug-fix releases, the last on 9 June 2025.

Design philosophy

MegaZeux’s philosophy is ZZT’s, scaled up: you should be able to open the editor, draw a room out of characters, drop in the built-in enemies, keys, doors and gems, and have a game before you write a line of code - and then, when the built-in rules stop being enough, place a robot and script your way out of them. Eevee’s description of the result is the standard one: Robotic “is effectively a form of bytecode assembly, with no manual assembling required.” A robot’s program is a flat list of commands. There are no blocks, no loops, no local variables in the conventional sense and, originally, no functions. Control flow is goto, conditional jumps, and messages sent to labels in other robots.

What makes this workable is that the editor is not a text editor. Each command is entered on its own line through a structured editor that parses it as you type, colours optional prepositions (“to”, “by”, “for”) grey, previews colour arguments visually, and reports errors before the program can run - a major practical improvement on ZZT-OOP, which only failed at run time. The program is compiled to bytecode when saved, and it is that bytecode which the world file stores; the “space for new Robotic commands is limited through the world format, and is nearly full”, which is why the language has not gained commands since the DOS era even though Exophase eventually rewrote the editor from scratch.

The other governing idea is the cycle. Every robot runs some number of commands each game cycle, set by the COMMANDS counter (a robot’s own cycle command sets how many cycles it waits between turns), then yields to the next object - a form of cooperative scheduling. A game with a hundred robots is a hundred tiny interleaved programs, each responding to the events the engine sends it.

The Robotic language

Programs, labels and messages

The help file’s first program is the one every language starts with:

1
2

* "HELLO WORLD!"
end

* writes its string to the message line at the bottom of the screen; end stops the robot for good (“leaving the END command out can cause some problems such as text glitches or, worse, the running of any and all code after where you want your Robot to stop!”). Code runs from the top the moment the board is entered, so most robots begin with end and wait to be woken by a message. A label is written : "name", and the engine sends built-in messages to robots when things happen to them. The classic item robot looks like this:

1
2
3
4
5
6

end
: "touch"
* "You found two keys!"
givekey c04
givekey c05
die as an item

The built-in labels form a small event vocabulary: TOUCH (the player pushed against the robot), SHOT, PLAYERSHOT, ENEMYSHOT, NEUTRALSHOT, BOMBED, SPITFIRE, THUD (walked into an obstacle), EDGE (walked off the board), PUSHED, INVINCO, KEY? for any key on the keyboard, KEYENTER, PLAYERHIT, PLAYERHURT, JUSTENTERED, JUSTLOADED, and - since 2.93 - PLAYERDIED. Robots talk to each other with send "Robot" to "label", or send all to broadcast; goto "label" jumps within the same program.

Zap and restore: state without variables

Robotic’s most idiosyncratic feature is that a program may contain the same label several times, and a message always goes to the first un-zapped copy. zap "shot" 1 disables the first : "shot" label; restore "shot" 1 re-enables it. A robot that should react differently the second time it is touched therefore needs no counter at all - it writes two : "touch" sections and zaps the first when it has run. This encodes a robot’s state in its own code, which is compact, very ZZT-like (ZZT-OOP has the same #zap/#restore pair) and, as Eevee notes, hard to debug, because the state is invisible.

Counters, interpolation and strings

Variables are counters: named integers, global unless they are one of the per-robot locals local (or local1) to local32, which another robot can reach as r3.local. Counters were 16-bit until the SDL port and are 32-bit since. set "score" to 100, inc "score" by 5, dec, multiply, divide and modulo do arithmetic; if "score" > 99 then "win" branches. A couple of hundred built-in counters expose the engine: playerx, playery, thisx, thisy, ammo, health, key_pressed, mousex, date_weekday, and so on.

The feature Janson added that made everything else possible is interpolation: &counter& inside any string argument is replaced by the counter’s value, so * "Score: &score&" prints the score and set "local" to "&r2.local&" reads another robot’s variable. Strings proper, written with a $ prefix, arrived in 2.62 and are manipulated through the same commands: set "$name" to "Vince", inc "$name" by " the dwarf" to append, $name.length, $name+5 for an offset, $name#5 to truncate, and the special sources INPUT, FREAD and FWRITE for keyboard and file I/O. Comments are a command too: . "like this", and a comment beginning with @ renames the robot.

Expressions and subroutines

Because no new commands could be added, arithmetic expressions were bolted onto strings: any argument written as a parenthesised string is evaluated at run time, with single quotes around counter names. Operators run strictly left to right with no precedence, and comparisons yield 0 or 1, which invites the branch-free idioms the MZXWiki shows, such as set "y" to "(('x'>0*42)+('x'<=0*27))". Subroutines, added in 2.65, are labels beginning with #; goto "#name" pushes a return address and goto "#return" pops it. Rosetta Code’s Robotic FizzBuzz uses most of this:

 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

set "local1" to 1
: "loop"
wait for 10
if "('local1' % 15)" = 0 then "fizzbuzz"
if "('local1' % 3)" = 0 then "fizz"
if "('local1' % 5)" = 0 then "buzz"
* "&local1&"
: "inc"
inc "local1" by 1
if "local1" <= 100 then "loop"
goto "done"

: "fizzbuzz"
* "FizzBuzz"
goto "inc"

: "fizz"
* "Fizz"
goto "inc"

: "buzz"
* "Buzz"
goto "inc"

: "done"
end

Movement, the board and sprites

The rest of the command set is about the world: go NORTH for 3, walk WEST, move, shoot, put, change, copy block, color, char, mod "file.mod", sam for sound effects, teleport, open, lockself. Directions include SEEK (toward the player), FLOW, RANDNB and the relative REL PLAYER/REL COUNTERS prefixes. Sprites (2.65) are addressed entirely through SPRn_X, SPRn_Y, SPRn_WIDTH, SPRn_CLIST and similar counters, with collision detection and, since 2.90, unbound pixel positioning; the SMZX modes, the vlayer, MZM fragments and partial character sets are similarly reached through counters and strings rather than syntax. It is an odd shape for a language, but it is what allowed a 1990s DOS format to keep gaining capabilities for thirty years.

What MegaZeux games are like

Because the engine draws in text mode with a redefinable 8x14 character set, MegaZeux games look like ANSI art in motion, and the palette and SMZX tricks let ambitious authors push that a long way. The community’s own catalogue runs from the bundled Caverns of Zeux and the rest of the Zeux series through Weirdness (1996), Bernard the Bard (1998), the Day of Zeux entries, and 2000s titles the Museum of ZZT has revisited such as Pandora, Demon Earth and Call of Caethrath, to 2010s work like Thanatos Insignia (2012) and a steady stream of itch.io releases. Genres include side-scrollers, RPG battle systems, roguelikes, a port of ZZT’s own Town of ZZT that its author says was authorised by Tim Sweeney, and reportedly even first-person shooters written entirely in Robotic.

Community

Two institutions held the community together. Day of Zeux, invented by Kvance in 1998, gave teams of up to three people 24 hours to make a game to an assigned theme; from around 2001 Terryn’s Dualstream variant assigned one abstract and one concrete theme, and the contest ran roughly twice a year until Winter 2014. DigitalMZX, founded in 1999 as The Untitled MegaZeux Page, became the community’s home after the earlier mWorld site declined in late 2000, and remains the archive, forum, bug tracker and wiki host; a Discord server and the GitHub repository complete the modern picture.

Current relevance

MegaZeux 2.93d is packaged for Windows (32- and 64-bit), macOS (including a legacy PowerPC build), Debian, Ubuntu, Fedora and Raspberry Pi, as a Flatpak, for Android, as an HTML5 build, and for the Nintendo DS, 3DS, Wii, Wii U and Switch, PlayStation Portable and Vita, and Sega Dreamcast; a 32-bit DOS build exists alongside the old 2.70. The official README lists “Windows, Linux, macOS, BSD, Haiku, HTML5, and MS-DOS, as well as numerous console ports” as supported. Alpine Linux, the AUR and Homebrew track the latest release. The project has around 150 GitHub stars, which is small, but the repository is active and its maintainer is still adding Sound Blaster and LPT-DAC drivers to the DOS port in August 2026.

For a would-be Robotic programmer today the entry point is the same as in 1994: open the editor, place a robot, press Enter twice, and type. The help file - the same F1 help now published online - still opens its tutorial with * "HELLO WORLD!".

Why it matters

MegaZeux is a case study in how a hobbyist language survives. Robotic was never elegant: it is a label-and-goto language whose type system is “integers, and later strings”, whose expression syntax was smuggled in through string literals, and whose command set has been frozen by its file format since the mid-2000s. Yet it taught a generation of teenagers in the 1990s and 2000s to think in events, messages, state machines and cooperative scheduling, in an environment where the reward for learning was a game their friends could play. Some of its alumni went on to other well-known hobbyist projects - Exophase’s Game Boy Advance emulator for the PSP and GP2X is the most famous example.

It is also one of the very few 1990s shareware creative tools whose code was freed early enough, and whose community was stubborn enough, to keep the original file format alive uninterrupted: since 2.93 even a world made in MegaZeux 1.x in 1995 can (experimentally) be loaded in the current engine on a Nintendo Switch. That continuity, more than any feature of the language, is MegaZeux’s contribution to computing history.