diff --git a/docs/changelog.txt b/docs/changelog.txt
index 99f9f98ce..7453eac36 100644
--- a/docs/changelog.txt
+++ b/docs/changelog.txt
@@ -28,6 +28,9 @@ USERS
 + Protected worlds are now decrypted to RAM or a temporary file
   when 'auto_decrypt_worlds' is enabled and the original file is
   left unmodified. This setting is now enabled by default.
++ Added experimental support for loading MZX 1.x worlds. Support
+  is not fully implemented yet, but all currently known 1.x
+  worlds are playable.
 + When loading a layer MZM to the board in the editor, instead
   of always loading the MZM as CustomBlocks the conversion type
   can now be selected from CustomBlock, CustomFloor, and Text.
@@ -105,6 +108,7 @@ USERS
   where a corrupt board/robot is found. Due to old world format
   limitations, robots after a corrupt robot can not be scanned.
 + checkres now supports scanning protected worlds.
++ Added experimental checkres support for MZX 1.x worlds.
 + Fixed a standalone mode crash on exit that occurred when using
   Alt+F4 or the window close button.
 + Fixed another bug that would cause string searching in the
diff --git a/docs/fileform.html b/docs/fileform.html
index 30b744d53..147ed1af6 100644
--- a/docs/fileform.html
+++ b/docs/fileform.html
@@ -2,7 +2,7 @@
 <!--
   MegaZeux File Format Reference
 
-  Copyright (C) 2020 Lachesis - https://github.com/AliceLR/megazeux/
+  Copyright (C) 2020-2023 Lachesis - https://github.com/AliceLR/megazeux/
 
   Permission to use, copy, modify, and distribute this document for any
   purpose with or without fee is hereby granted, provided that the above
@@ -316,9 +316,19 @@ <h2>Contents</h2>
         <li><a href="#worldheader">World Format Header and Magic</a></li>
         <li><a href="#saveheader">Save Format Header and Magic</a></li>
       </ol>
+      <li><a href="#world100">World and Save Format (1.00)</a></li>
+      <ol type="i">
+        <li><a href="#global100">Global Data</a></li>
+        <li><a href="#boardlist100">Board Names, Sizes, and Offsets</a></li>
+        <li><a href="#board100">Boards and Board RLE Planes</a></li>
+        <li><a href="#boardparams100">Board Parameters</a></li>
+        <li><a href="#boardobjs100">Board Objects</a></li>
+        <li><a href="#robot100">Robots</a></li>
+        <li><a href="#scroll100">Scrolls</a></li>
+        <li><a href="#sensor100">Sensors</a></li>
+      </ol>
       <li><a href="#world200">World and Save Format (2.00 through 2.84X)</a></li>
       <ol type="i">
-        <li><a href="#encryption200">Encryption</a></li>
         <li><a href="#global200">Global Data</a></li>
         <ol type="a">
           <li><a href="#global200world1">World Block 1</a></li>
@@ -557,8 +567,9 @@ <h2>World and Save Format (all versions)</h2>
       <h3>World Format Header and Magic</h3>
       <p>
         Most world files begin with a 29-byte header. The only exceptions are
-        encrypted worlds from MegaZeux versions prior to 2.6 (see <a href="#encryption200">Encryption</a>)
-        and rearchived MegaZeux 2.90 worlds (see <a href="#world290">the 2.90+ world format</a>).
+        locked worlds from MegaZeux 1.xx, encrypted worlds from MegaZeux 2.00
+        through 2.6, and rearchived MegaZeux 2.90 worlds
+        (see <a href="#world290">the 2.90+ world format</a>).
       </p>
 
       <div class="markdown">
@@ -569,6 +580,27 @@ <h3>World Format Header and Magic</h3>
 | 26   | s3   | Magic
       </div>
 
+      <h4>MegaZeux 1.xx locked world header:</h4>
+      <div class="markdown">
+        | Pos. | Size | Description |
+        |------|------|-------------|
+        | 0    | s25  | World title
+        | 25   | b    | Protection method (always between 1 and 3)
+        | 26   | b    | Length of password (0 to 15)
+        | 27   | s15  | Password (encrypted) <a href="#worldheadernote4">(4)</a>
+        | 42   | s3   | Magic (not encrypted)
+      </div>
+
+      <h4>MegaZeux 2.00 through 2.6 encrypted world header:</h4>
+      <div class="markdown">
+        | Pos. | Size | Description |
+        |------|------|-------------|
+        | 0    | s25  | World title
+        | 25   | b    | Protection method (always between 1 and 3)
+        | 26   | s15  | Password (encrypted) <a href="#worldheadernote4">(4)</a>
+        | 41   | s3   | Magic (not encrypted)
+      </div>
+
       <p>
         The following magic values are valid:
       </p>
@@ -580,7 +612,7 @@ <h3>World Format Header and Magic</h3>
 | `MZ2`       | 2.00 through 2.51
 | `MZA`       | 2.51s1
 | `M\x02\x09` | 2.51s2 through 2.61 (including MZXAk, SMZX 1.00a)
-| `M\x02\x11` | Used for decrypted worlds by newer MZX versions.<br>Likely derived from misreading 2.51s2 magic <code>M\002\011</code> (octal) as hex.
+| `M\x02\x11` | Used for decrypted worlds by some port MZX versions.<br>Likely derived from misreading 2.51s2 magic <code>M\002\011</code> (octal) as hex.
 | `M\x02\x32` | 2.62 and 2.62b (from octal <code>M\002\062</code>)
 | `M\x02\x41` | 2.65 (from decimal <code>65</code>)
 | `M\x02\x44` | 2.68 (from decimal <code>68</code>) <a href="#worldheadernote3">(3)</a>
@@ -596,6 +628,7 @@ <h3>World Format Header and Magic</h3>
 | `M\x02\x5A` | 2.90X
 | `M\x02\x5B` | 2.91X
 | `M\x02\x5C` | 2.92X
+| `M\x02\x5D` | 2.93X
       </div>
 
       <p>
@@ -605,6 +638,32 @@ <h3>World Format Header and Magic</h3>
         and <code>0x0208</code> for 1.00, 2.00, and 2.51s1 worlds (respectively).
       </p>
 
+      <p>
+        In all world files with a password, the password can be decrypted with
+        the following algorithm:
+      </p>
+
+      <code class="example">
+/**
+ * This code is copied from the MZX source code, which is GPL 2+ licensed.
+ */
+char magic_code[16] = "\xE6\x52\xEB\xF2\x6D\x4D\x4A\xB7\x87\xB2\x92\x88\xDE\x91\x24";
+
+for(i = 0; i &lt; 15; i++)
+{
+  password[i] ^= magic_code[i];
+  password[i] -= 0x12 - protection_method;
+  password[i] ^= 0x8D;
+}
+      </code>
+
+      <p>
+        In MegaZeux 2.00 through 2.6 encrypted worlds,
+        the rest of the MZX file is XORed with a byte calculated from the
+        password. The bundled MegaZeux utility "checkres" can output the
+        unencrypted password and XOR value when given the -v option, if needed.
+      </p>
+
       <h4>Notes:</h4>
       <ol>
         <li id="worldheadernote1">
@@ -619,6 +678,12 @@ <h4>Notes:</h4>
           (as they are versioned for MZX 2.65). Resaving these worlds in a
           newer version (such as MZX 2.69) usually fixes this issue.
         </li>
+        <li id="worldheadernote4">
+          The password field is null terminated if it is 14 or fewer characters
+          long. If the password is 15 characters long, it is NOT null terminated,
+          and the null terminator must be added by the decryption algorithm.
+        </li>
+      </ol>
       </ol>
     </section>
 
@@ -637,9 +702,18 @@ <h3>Save Format Header and Magic</h3>
 | 7    | b    | Current board number
       </div>
 
+      <h4>Format prior to MegaZeux 2.82</h4>
+      <div class="markdown">
+| Pos. | Size | Description |
+|------|------|-------------|
+| 0    | s5   | Magic
+| 5    | b    | Current board number
+      </div>
+
       <div class="markdown">
 | Magic         | File Format Version |
 |---------------|---------------------|
+| `MZSAV`       | 1.00
 | `MZSV2`       | 2.00 through 2.51
 | `MZXSA`       | 2.51s1
 | `MZS\x02\x09` | 2.51s2 through 2.61 (including MZXAk, SMZX 1.00a)
@@ -658,6 +732,7 @@ <h3>Save Format Header and Magic</h3>
 | `MZS\x02\x5A` | 2.90X
 | `MZS\x02\x5B` | 2.91X
 | `MZS\x02\x5C` | 2.92X
+| `MZS\x02\x5D` | 2.93X
       </div>
 
       <p>
@@ -670,76 +745,440 @@ <h3>Save Format Header and Magic</h3>
         the world version derived from the world magic when the world was
         initially loaded. Notably, this value is saved as a <i>little endian</i>
         word (whereas it is represented as a <i>big endian</i> word in the world
-        magic string).
+        magic string). In versions where this field is not present, the world
+        version should be treated as the same as the file format version.
       </p>
     </section>
   </section>
 
   <hr>
 
-  <section id="world200" class="main">
-    <h2>World and Save Format (2.00 through 2.84X)</h2>
+  <section id="world100" class="main">
+    <h2>World and Save Format (1.00)</h2>
     <p>
-      MegaZeux 2.00 world (.MZX) and save (.SAV) files share very similar formats,
-      so they are documented together here. This section also tries to note changes
-      in these formats and when they occurred, but save format modifications between
-      versions are somewhat of a mess, so please report any inaccuracies in this
-      document.
+      MegaZeux 1.00 world (.MZX) and save (.SAV) files share very similar formats,
+      so they are documented together here. This format is sufficiently different
+      enough from the 2.00 format that it has been given its own section.
     </p>
 
-    <section id="encryption200" class="inner">
-      <h3>Encryption</h3>
+    <section id="global100" class="inner">
+      <h3>Global Data</h3>
+      <p>
+        World data immediately follows the header.
+      </p>
+
+      <h4 id="global100world1">World Block 1</h4>
+      <p>
+        Total block length is 3890 bytes.
+      </p>
+      <div class="markdown">
+| Pos.  | Size     | Description |
+|-------|----------|-------------|
+| 0     | b * 3584 | Character set (see <a href="#chr">Character Sets</a>)
+| 3584  | b * 128  | ID Chars block 1 (thing chars) <a href="#global100note1">(1)</a>
+| 3712  | b * 178  | ID Chars block 2 (animations and colors) <a href="#global100note2">(2)</a>
+      </div>
+      <h5>Notes</h5>
+      <ol>
+        <li id="global100note1">
+          Worlds in this format do not contain ID chars block 3 (damages),
+          so the 1.x default damages should be substituted for these instead.
+          Likewise, goop (ID 34) didn't exist in 1.x, so char 176 should should
+          be patched in for its character.
+        </li>
+        <li id="global100note2">
+          This is the first 178 bytes of the 2.00 ID chars block 2. The missing
+          values are bullet chars (306-317), player chars (318-321), player
+          color (322), missile color (323), and bullet colors (324-326).
+          Equivalents to these values are stored separately later in the file.
+        </li>
+      </ol>
+
+      <h4 id="global100save1">Save Block 1 (.SAV only)</h4>
+      <p>
+        This block is present in save files only. Total block length is 16.
+      </p>
+      <div class="markdown">
+| Pos.  | Size  | Description |
+|-------|-------|-------------|
+| 0     | b * 16| Keys
+      </div>
+
+      <h4 id="global100world2">World Block 2</h4>
+      <p>
+        Total block length is 72.
+      </p>
+      <div class="markdown">
+| Pos.  | Size     | Description |
+|-------|----------|-------------|
+| 0     | s15 * 4  | Status counter names (null terminated)
+| 60    | b * 4    | Bullet chars
+| 64    | b        | Player char
+| 65    | b        | Saved player X position
+| 66    | b        | Saved player Y position
+| 67    | b        | Saved player board number
+| 68    | b        | Viewport edge color
+| 69    | b        | Player color
+| 70    | b        | Bullet color
+| 71    | b        | Missile color
+      </div>
+
+      <h4 id="global100save2">Save Block 2 (.SAV only)</h4>
+      <p>
+        This block is present in save files only. Total block length is 9.
+      </p>
+      <div class="markdown">
+| Pos.  | Size  | Description |
+|-------|-------|-------------|
+| 0     | b     | Scroll base color
+| 1     | b     | Scroll corner color
+| 2     | b     | Scroll pointer color
+| 3     | b     | Scroll title color
+| 4     | b     | Scroll arrow color
+| 5     | d     | Score
+      </div>
+
+      <h4 id="global100world3">World Block 3</h4>
+      <p>
+        Total block length is 18.
+      </p>
+      <div class="markdown">
+| Pos.  | Size     | Description |
+|-------|----------|-------------|
+| 0     | b        | First board number
+| 1     | b        | Endgame board number (>=128: no endgame board)
+| 2     | b        | Death board number (>=129: same position, 128: restart board)
+| 3     | b        | Endgame board teleport X
+| 4     | b        | Endgame board teleport Y
+| 5     | b        | Death board teleport X
+| 6     | b        | Death board teleport Y
+| 7     | ws       | Starting lives
+| 9     | ws       | Lives limit
+| 11    | ws       | Starting health
+| 13    | ws       | Health limit
+| 15    | b        | Enemies' bullets hurt other enemies
+| 16    | b        | Game over SFX enabled (1) or disabled (0)
+| 17    | b        | Unused
+      </div>
+
+      <h4 id="global100counters">Counters List (.SAV only)</h4>
+      <p>
+        This block is only present in save files and has an variable length.
+        The counters list begins with the number of counters.
+      </p>
+      <div class="markdown">
+| Pos. | Size    | Description |
+|------|---------|-------------|
+| 0    | b       | Number of counters = N
+      </div>
+      <p>
+        A list of <code>N</code> counters follows, each in the following format:
+      </p>
+      <div class="markdown">
+| Pos. | Size | Description |
+|------|------|-------------|
+| 0    | s15  | Counter name (null terminated)
+| 15   | w    | Counter value (unsigned)
+      </div>
+    </section>
+
+    <section id="boardlist100" class="inner">
+      <h3>Board Names, Sizes, and Offsets</h3>
+
+      <p>
+        Following the board count byte is the board names list and the board sizes and
+        offsets table.
+      </p>
+
+      <p>
+        For each board:
+      </p>
+
+      <div class="markdown">
+| Pos. | Size | Description |
+|------|------|-------------|
+| 0    | s25  | Board names (null terminated)
+      </div>
+
+      <p>
+        For each board:
+      </p>
+
+      <div class="markdown">
+| Pos. | Size | Description |
+|------|------|-------------|
+| 0    | d    | Size of board data within the file
+| 4    | d    | Offset of board data within the file
+      </div>
+
+      <p>
+        Typically, board data immediately follows these tables.
+      </p>
+    </section>
+
+    <section id="board100" class="inner">
+      <h3>Boards and Board RLE Planes</h3>
+      <p>
+        MegaZeux 1.xx does not support overlays or board modes; these should be
+        treated as disabled and 100x100, respectively. Boards begin immediately
+        with the board RLE plane data. Board contents are compressed with run
+        length encoding, which is different from its MegaZeux 2.xx counterpart.
+        Each board always has exactly 6 planes in the following order:
+      </p>
+
+      <div class="markdown">
+| name              | description |
+|-------------------|-------------|
+| level_id          | Board thing IDs
+| level_color       | Board thing colors
+| level_param       | Board thing parameters
+| level_under_id    | Board thing IDs for floors beneath non-floor things
+| level_under_color | Board thing colors for floors beneath non-floor things
+| level_under_param | Board thing parameters for floors beneath non-floor things
+      </div>
+
       <p>
-        Encrypted worlds (from versions that supported them) begin with a
-        44-byte header similar to the regular header:
+        Each compressed plane starts with the following fields:
       </p>
 
       <div class="markdown">
 | Pos. | Size | Description |
 |------|------|-------------|
-| 0    | s25  | World title
-| 25   | b    | Protection method (always non-zero)
-| 26   | s15  | Password (encrypted) <a href="#encryption200note1">(1)</a>
-| 41   | s3   | Magic (not encrypted)
+| 0    | b    | Width <a href="#board100note1">(1)</a>
+| 1    | b    | Height
       </div>
 
       <p>
-        The password can be decrypted with the following algorithm:
+        The RLE data follows after, and consists entirely of pairs of run
+        lengths and byte values. The RLE plane can be decompressed with the
+        following algorithm:
       </p>
 
       <code class="example">
 /**
- * This code is copied from the MZX source code, which is GPL 2+ licensed.
+ * This code fragment is a simplified version of the RLE unpacking code from
+ * MegaZeux's source code, and is therefore GPL 2+ licensed.
  */
-char magic_code[16] = "\xE6\x52\xEB\xF2\x6D\x4D\x4A\xB7\x87\xB2\x92\x88\xDE\x91\x24";
 
-for(i = 0; i < 15; i++)
+int size = width * height;
+int i = 0;
+while(i &lt; size)
 {
-  password[i] ^= magic_code[i];
-  password[i] -= 0x12 - protection_method;
-  password[i] ^= 0x8D;
+  runsize = *(stream++);
+  current_char = *(stream++);
+
+  if(runsize &gt; size - i)
+    runsize = size - i; // MegaZeux emits an error if this occurs.
+
+  for(int j = 0; j &lt; runsize; j++)
+    plane[i++] = current_char;
 }
       </code>
 
       <p>
-        The rest of the MZX file follows XORed with a byte calculated from the
-        password. In practice, this byte can be determined by using the character
-        set starting at the 44th byte of the encrypted world, the ID chars space
-        damage value at the 3955th byte of the encrypted world (which is almost
-        always 0 unencrypted) or by using recognizable colors in the palette
-        (offsets 4197 through 4244).
+        The RLE stream ends when <code>(board width * board height)</code>
+        bytes have been expanded from the stream, and the next compressed plane
+        or the board parameters block immediately follows.
+      </p>
+
+      <h5>Notes</h5>
+      <ol>
+        <li id="board100note1">
+          There MAY be an extra run of length 0 padding between any two planes;
+          if the width byte read is 0, skip the following byte and read the
+          width and height from the next two bytes. (It's not clear why old
+          versions of MegaZeux emit these runs, but this is exactly how VER1TO2
+          handles these. I have never seen this in practice. -Lachesis)
+        </li>
+      </ol>
+    </section>
+
+    <section id="boardparams100" class="inner">
+      <h3>Board Parameters</h3>
+      <p>
+        The board parameters block follows the board RLE planes.
       </p>
 
+      <div class="markdown">
+| Pos. | Size | Description |
+|------|------|-------------|
+| 0    | s13  | Mod playing (null terminated)
+| 13   | b    | Viewport X
+| 14   | b    | Viewport Y
+| 15   | b    | Viewport width
+| 16   | b    | Viewport height
+| 17   | b    | Can shoot?
+| 18   | b    | Can bomb?
+| 19   | b    | Fire burns brown?
+| 20   | b    | Fire burns space?
+| 21   | b    | Fire burns fakes?
+| 22   | b    | Fire burns trees?
+| 23   | b    | Explosions leave (0: space, 1: ash, 2: fire)
+| 24   | b    | Save mode (0: enabled, 1: disabled, 2: sensor only)
+| 25   | b    | Forest to floor?
+| 26   | b    | Collect bombs?
+| 27   | b    | Fire burns forever?
+| 28   | b    | Board # to north
+| 29   | b    | Board # to south
+| 30   | b    | Board # to east
+| 31   | b    | Board # to west
+| 32   | b    | Restart if zapped?
+| 33   | w    | Time limit
+| 35   | b    | Last key pressed
+| 36   | ws   | Input (numeric value)
+| 38   | b    | Inputsize
+| 39   | b    | Volume
+| 40   | b    | Player locked NS?
+| 41   | b    | Player locked EW?
+| 42   | b    | Player attack locked?
+| 43   | s81  | Input (string value) (null terminated)
+| 124  | b    | Blind duration <a href="#boardparams100note1">(1)</a>
+| 125  | b    | Firewalker duration
+| 126  | b    | Unused
+| 127  | b    | Freeze time duration
+| 128  | b    | Slow time duration
+| 129  | b    | Unused
+| 130  | b    | Unused
+| 131  | b    | Unused
+| 132  | b    | Wind duration
+| 133  | b    | Last player direction
+| 134  | s81  | Bottom message (null terminated)
+| 215  | b    | Bottom message timer
+| 216  | b    | Lazerwall timer
+| 217  | b    | Bottom message row
+| 218  | b    | Bottom message column (-1: center) <a href="#boardparams100note2">(2)</a>
+| 219  | bs   | Scroll relative X offset
+| 220  | bs   | Scroll relative Y offset
+      </div>
+
+      <h5>Notes</h5>
+      <ol>
+        <li id="boardparams100note1">
+          All 5 status durations are board variables in MegaZeux 1.x. This
+          can be observed most easily in the "Flame Cavern" board of Caverns.
+        </li>
+        <li id="boardparams100note2">
+          The default behavior is centered, but 1.x world files contain 0 here by
+          default. A value of 0 needs to be corrected to -1 when loading worlds.
+        </li>
+      </ol>
+    </section>
+
+    <section id="boardobjs100" class="inner">
+      <h3>Board Objects</h3>
+      <p>
+        Following the board parameters are the robot, scroll, and sensor lists.
+        Each list is stored as a single byte <code>N</code> indicating the
+        number of robots, scrolls, or sensors on the board (0 to 255), followed
+        by <code>N</code> stored objects of that type. Each object in its
+        respective list immediately follows the prior, and the next list starts
+        immediately following the last object in the previous list. The board
+        data ends after all three lists and their objects have been read.
+      </p>
+      <p>
+        The board robots/scrolls/sensors in the list count from ID 1 upward, as
+        ID 0 is the global robot and is invalid for scrolls and sensors. Since
+        objects in the file are sequential, robot/scroll/sensor IDs may have to
+        be reassigned when saving worlds or saves in these versions to optimize
+        out gaps in the list.
+      </p>
+    </section>
+
+    <section id="robot100" class="inner">
+      <h3>Robots</h3>
+      <p>
+        Each robot is 37 bytes plus the length of the robot program long.
+      </p>
+
+      <div class="markdown">
+| Pos. | Size | Default | Description |
+|------|------|---------|-------------|
+| 0    | d    |         | Program length in bytes. FILEFORM.TXT claims signed...
+| 4    | d    |         | unused <a href="#robot100note1">(1)</a>
+| 8    | s15  |         | Robot name (null-terminated)
+| 23   | b    | 2       | Robot char
+| 24   | d    | 1       | Current position in program
+| 28   | b    | 0       | Position within current line (for <code>WAIT</code>/<code>GO</code>/etc)
+| 29   | b    | 1       | Robot cycle
+| 30   | b    | 0       | Cycle counter
+| 31   | b    | 1       | Bullet type (0: player, 1: neutral, 2: enemy)
+| 32   | b    | 0       | Locked status (0: unlocked, 1: locked)
+| 33   | b    | 0       | Can lavawalk (0: no, 1: yes)
+| 34   | b    | 0       | Walk direction (0: idle)
+| 35   | b    | 0       | Last touch direction
+| 36   | b    | 0       | Last shot direction
+| 37   | s... |         | Robot program
+      </div>
+
       <h4>Notes</h4>
       <ol>
-        <li id="encryption200note1">
-          The password field is null terminated if it is 14 or fewer characters
-          long. If the password is 15 characters long, it is NOT null terminated,
-          and the null terminator must be added by the decryption algorithm.
+        <li id="robot100note1">
+          DOS MZX versions wrote robot, scroll, and sensor structs directly to
+          world or save files. The unused 4-byte field at offset 4 probably
+          corresponds to the program memory pointer in these versions, if
+          MegaZeux 2.x is any indication. Scrolls likewise have an unused 4
+          byte field.
         </li>
       </ol>
     </section>
 
+    <section id="scroll100" class="inner">
+      <h3>Scrolls</h3>
+      <p>
+        Each scroll block is 10 bytes plus the length of the scroll text long.
+      </p>
+
+      <div class="markdown">
+| Pos. | Size | Description |
+|------|------|-------------|
+| 0    | w    | Number of lines
+| 2    | d    | unused
+| 6    | d    | Scroll text length in bytes
+| 10   | s... | Scroll text <a href="#scroll100note1">(1)</a>
+      </div>
+
+      <h4>Notes</h4>
+      <ol>
+        <li id="scroll100note1">
+          Scrolls in MegaZeux 1.x have a unique form of color coding that is
+          not available in versions after. If the first character of a line is
+          '!', the byte immediately following it will be used to apply the
+          palette corresponding to that byte to the entire line. For example,
+          if a line begins with <code>33 8e</code> hex, the line will use
+          color 8 as the background color and color 14 as the foreground color.
+          Unlike 2.x scrolls, the scroll text does not begin with <code>01</code>.
+        </li>
+      </ol>
+    </section>
+
+    <section id="sensor100" class="inner">
+      <h3>Sensors</h3>
+      <p>
+        Each sensor block is 31 bytes long.
+      </p>
+
+      <div class="markdown">
+| Pos. | Size | Description |
+|------|------|-------------|
+| 0    | s15  | Sensor name (null-terminated)
+| 15   | b    | Sensor char
+| 16   | s15  | Robot to message (null-terminated)
+      </div>
+    </section>
+  </section>
+
+  <hr>
+
+  <section id="world200" class="main">
+    <h2>World and Save Format (2.00 through 2.84X)</h2>
+    <p>
+      MegaZeux 2.00 world (.MZX) and save (.SAV) files share very similar formats,
+      so they are documented together here. This section also tries to note changes
+      in these formats and when they occurred, but save format modifications between
+      versions are somewhat of a mess, so please report any inaccuracies in this
+      document.
+    </p>
+
     <section id="global200" class="inner">
       <h3>Global Data</h3>
       <p>
@@ -758,8 +1197,8 @@ <h4 id="global200world1">World Block 1</h4>
 | 0     | b * 3584 | Character set (see <a href="#chr">Character Sets</a>)
 | 3584  | b * 128  | ID Chars block 1 (thing chars)
 | 3712  | b * 195  | ID Chars block 2 (animations and colors)
-| 3907  | b        | ID Chars missile color
-| 3908  | b * 3    | ID Chars bullet colors
+| 3907  | b        | ID Chars missile color (block 2 no. 323)
+| 3908  | b * 3    | ID Chars bullet colors (block 2 no. 324 through 326)
 | 3911  | b * 128  | ID Chars block 3 (damage)
 | 4039  | s15 * 6  | Status counter names (null terminated)
       </div>
@@ -773,11 +1212,11 @@ <h4 id="global200save1">Save Block 1 (.SAV only)</h4>
 | Pos.  | Size  | Description |
 |-------|-------|-------------|
 | 0     | b * 16| Keys
-| 16    | b     | Blind timer
-| 17    | b     | Firewalker timer
-| 18    | b     | Freeze time timer
-| 19    | b     | Slow time timer
-| 20    | b     | Wind timer
+| 16    | b     | Blind duration
+| 17    | b     | Firewalker duration
+| 18    | b     | Freeze time duration
+| 19    | b     | Slow time duration
+| 20    | b     | Wind duration
 | 21    | w * 8 | Saved player X positions
 | 37    | w * 8 | Saved player Y positions
 | 53    | b * 8 | Saved player board numbers <a href="#global200save1note3">(3)</a>
@@ -1402,8 +1841,9 @@ <h3>Board RLE Planes</h3>
  * MegaZeux's source code, and is therefore GPL 2+ licensed.
  */
 
+int size = width * height;
 int i = 0;
-while(i < width * height)
+while(i &lt; size)
 {
   current_char = *(stream++);
   if(!(current_char & 0x80))
@@ -1415,7 +1855,10 @@ <h3>Board RLE Planes</h3>
     int runsize = current_char & 0x7F;
     current_char = *(stream++);
 
-    for(int j = 0; j < runsize; j++)
+    if(runsize &gt; size - i)
+      runsize = size - i; // MegaZeux emits an error if this occurs.
+
+    for(int j = 0; j &lt; runsize; j++)
       plane[i++] = current_char;
   }
 }
@@ -2031,11 +2474,11 @@ <h3>World Properties</h3>
 | `0x804B` | Player restart Y                     | int(w)                  | Save-only
 | `0x804C` | Player color                         | int(b)                  | Save-only
 | `0x804D` | Keys                                 | array(b * 16)           | Save-only
-| `0x8050` | Blind timer                          | int(b)                  | Save-only
-| `0x8051` | Firewalker timer                     | int(b)                  | Save-only
-| `0x8052` | Freeze time timer                    | int(b)                  | Save-only
-| `0x8053` | Slow time timer                      | int(b)                  | Save-only
-| `0x8054` | Wind timer                           | int(b)                  | Save-only
+| `0x8050` | Blind duration                       | int(d)                  | Save-only
+| `0x8051` | Firewalker duration                  | int(d)                  | Save-only
+| `0x8052` | Freeze time duration                 | int(d)                  | Save-only
+| `0x8053` | Slow time duration                   | int(d)                  | Save-only
+| `0x8054` | Wind duration                        | int(d)                  | Save-only
 | `0x8058` | Scroll base color                    | int(b)                  | Save-only
 | `0x8059` | Scroll corner color                  | int(b)                  | Save-only
 | `0x805A` | Scroll pointer color                 | int(b)                  | Save-only
@@ -2296,13 +2739,20 @@ <h3>Board Properties</h3>
 | `0x0114` | Volume                 | int(b)  | Save-only
 | `0x0115` | Volume increment       | int(b)  | Save-only
 | `0x0116` | Volume target          | int(b)  | Save-only
+| `0x0117` | Blind duration         | int(b)  | Save-only, 1.x only
+| `0x0118` | Firewalker duration    | int(b)  | Save-only, 1.x only
+| `0x0119` | Freeze time duration   | int(b)  | Save-only, 1.x only
+| `0x011a` | Slow time duration     | int(b)  | Save-only, 1.x only
+| `0x011b` | Wind duration          | int(b)  | Save-only, 1.x only
       </div>
       <ol>
         <li id="board290note1">
           Properties marked "strict" must be present and in the order specified
           in the table for the board data to be considered valid. If the board
           properties file is invalid, the entire board contents will be dummied
-          out.
+          out. Properties marked "save-only" are saved to save files only, but will
+          be respected if loaded from a world file. Properties marked "1.x only"
+          are saved/loaded only if the world compatibility version is 1.x.
         </li>
         <li id="board290note2">
           Board name maximum length is currently 24 characters; extra data
@@ -2361,7 +2811,9 @@ <h3>Robot Properties</h3>
       <ol>
         <li id="robot290note1">
           Properties marked "strict" must be present and in the order specified
-          in the table for the robot data to be considered valid.
+          in the table for the robot data to be considered valid. Properties
+          marked "save-only" are saved to save files only, but will be respected
+          if loaded from a world file.
         </li>
         <li id="robot290note2">
           Robot name maximum length is currently 14 characters; extra data
@@ -2423,13 +2875,26 @@ <h2>Board File (.MZB)</h2>
 | 1    | s3   | Magic (<code>MB2</code> for 2.00 through 2.51s1, same as <a href="#worldheader">world magic</a> after)
     </div>
 
+    <section id="mzb100" class="inner">
+      <h3>Board Files for MegaZeux 1.x</h3>
+      <p>
+        A MegaZeux 1.x board file contains the raw data for a single board in
+        the world format (including robots, scrolls, and sensors as-needed).
+        These board files actually do NOT contain the above header; they begin
+        exactly at the first RLE plane. See the <a href="#board100">world format
+        documentation for boards</a> for more info. A 25-byte null terminated
+        board name follows the board data.
+      </p>
+    </section>
+
     <section id="mzb200" class="inner">
       <h3>Board Files for 2.00 through 2.84X</h3>
       <p>
         The header is immediately followed by the raw data for a single board
         in the world format (including robots, scrolls, and sensors as-needed).
         See the <a href="#board200">world format documentation for boards</a>
-        for more info.
+        for more info. A 25-byte null terminated board name follows the board
+        data.
       </p>
     </section>
 
@@ -2703,7 +3168,7 @@ <h2>Robotic Bytecode (.BC)</h2>
     <h2>License</h2>
     <section class="inner">
       <p>
-        Copyright &copy; 2020 Lachesis &mdash;
+        Copyright &copy; 2020-2023 Lachesis &mdash;
         <a href="https://github.com/AliceLR/megazeux/">
           https://github.com/AliceLR/megazeux/
         </a>
diff --git a/src/board.c b/src/board.c
index 65b0638d6..4d7bb43c2 100644
--- a/src/board.c
+++ b/src/board.c
@@ -36,7 +36,7 @@
 
 
 static int save_board_info(struct board *cur_board, struct zip_archive *zp,
- int savegame, int file_version, const char *name)
+ int savegame, int file_version, int world_version, const char *name)
 {
   const char *tmp;
   char *buffer;
@@ -116,6 +116,16 @@ static int save_board_info(struct board *cur_board, struct zip_archive *zp,
     save_prop_c(BPROP_VOLUME, cur_board->volume, &mf);
     save_prop_c(BPROP_VOLUME_INC, cur_board->volume_inc, &mf);
     save_prop_c(BPROP_VOLUME_TARGET, cur_board->volume_target, &mf);
+
+    // Don't bother saving these compatibility fields unless they're needed.
+    if(file_version >= V293 && world_version < V200)
+    {
+      save_prop_c(BPROP_BLIND_DUR, cur_board->blind_dur_v1, &mf);
+      save_prop_c(BPROP_FIREWALKER_DUR, cur_board->firewalker_dur_v1, &mf);
+      save_prop_c(BPROP_FREEZE_TIME_DUR, cur_board->freeze_time_dur_v1, &mf);
+      save_prop_c(BPROP_SLOW_TIME_DUR, cur_board->slow_time_dur_v1, &mf);
+      save_prop_c(BPROP_WIND_DUR, cur_board->wind_dur_v1, &mf);
+    }
   }
 
   save_prop_eof(&mf);
@@ -138,7 +148,7 @@ int save_board(struct world *mzx_world, struct board *cur_board,
 
   sprintf(name, "b%2.2X", (unsigned char)board_id);
 
-  if(save_board_info(cur_board, zp, savegame, file_version, name))
+  if(save_board_info(cur_board, zp, savegame, file_version, mzx_world->version, name))
     goto err;
 
   sprintf(name+3, "bid");
@@ -295,6 +305,11 @@ static void default_board(struct board *cur_board)
   cur_board->b_mesg_timer = 0;
   cur_board->b_mesg_row = 24;
   cur_board->b_mesg_col = -1;
+  cur_board->blind_dur_v1 = 0;
+  cur_board->firewalker_dur_v1 = 0;
+  cur_board->freeze_time_dur_v1 = 0;
+  cur_board->slow_time_dur_v1 = 0;
+  cur_board->wind_dur_v1 = 0;
 
 #if defined(DEBUG) || defined(CONFIG_EXTRAM)
   cur_board->is_extram = false;
@@ -680,6 +695,31 @@ static int load_board_info(struct board *cur_board, struct zip_archive *zp,
         cur_board->volume_target = load_prop_int_u(&prop, 0, 255);
         break;
 
+      case BPROP_BLIND_DUR:
+        if(*file_version >= V293)
+          cur_board->blind_dur_v1 = load_prop_int_u(&prop, 0, 255);
+        break;
+
+      case BPROP_FIREWALKER_DUR:
+        if(*file_version >= V293)
+          cur_board->firewalker_dur_v1 = load_prop_int_u(&prop, 0, 255);
+        break;
+
+      case BPROP_FREEZE_TIME_DUR:
+        if(*file_version >= V293)
+          cur_board->freeze_time_dur_v1 = load_prop_int_u(&prop, 0, 255);
+        break;
+
+      case BPROP_SLOW_TIME_DUR:
+        if(*file_version >= V293)
+          cur_board->slow_time_dur_v1 = load_prop_int_u(&prop, 0, 255);
+        break;
+
+      case BPROP_WIND_DUR:
+        if(*file_version >= V293)
+          cur_board->wind_dur_v1 = load_prop_int_u(&prop, 0, 255);
+        break;
+
       default:
         break;
     }
diff --git a/src/board_struct.h b/src/board_struct.h
index 705cfec33..ee70811a6 100644
--- a/src/board_struct.h
+++ b/src/board_struct.h
@@ -88,6 +88,11 @@ struct board
   char *palette_path;
   size_t charset_path_allocated;
   size_t palette_path_allocated;
+  unsigned char blind_dur_v1;
+  unsigned char firewalker_dur_v1;
+  unsigned char freeze_time_dur_v1;
+  unsigned char slow_time_dur_v1;
+  unsigned char wind_dur_v1;
 
   int num_robots;
   int num_robots_active;
diff --git a/src/editor/board.c b/src/editor/board.c
index 940c0dadf..4673a0e59 100644
--- a/src/editor/board.c
+++ b/src/editor/board.c
@@ -56,6 +56,58 @@ static int board_magic(const char magic_string[4])
   return 0;
 }
 
+static boolean legacy_check_v1_rle(vfile *vf, int board_width, int board_height)
+{
+  int size = board_width * board_height;
+  int w;
+  int h;
+  int i;
+
+  w = vfgetc(vf);
+  h = vfgetc(vf);
+  if(w == 0) // VER1TO2 hack
+  {
+    w = vfgetc(vf);
+    h = vfgetc(vf);
+  }
+  if(w != board_width || h != board_height)
+    return false;
+
+  for(i = 0; i < size;)
+  {
+    int runsize = vfgetc(vf);
+    int current_char = vfgetc(vf);
+    if(current_char < 0 || runsize > size - i)
+      return false;
+
+    i += runsize;
+  }
+  return true;
+}
+
+static boolean legacy_check_v1_board(vfile *vf)
+{
+  int w;
+  int h;
+  int i;
+
+  vrewind(vf);
+
+  w = vfgetc(vf);
+  h = vfgetc(vf);
+  if(w < 1 || w > 100 || h < 1 || h > 100)
+    return false;
+
+  vrewind(vf);
+  for(i = 0; i < 6; i++)
+    if(!legacy_check_v1_rle(vf, w, h))
+      return false;
+
+  // There is at least usable plane data in this file, so allow it to load.
+  vrewind(vf);
+  return true;
+}
+
 void save_board_file(struct world *mzx_world, struct board *cur_board,
  const char *name)
 {
@@ -149,6 +201,10 @@ void replace_current_board(struct world *mzx_world, const char *name)
 
     file_version = board_magic(version_string);
 
+    // 1.x doesn't have a magic string and needs a custom check.
+    if(file_version == 0 && legacy_check_v1_board(vf))
+      file_version = V100;
+
     if(file_version > 0 && file_version <= MZX_LEGACY_FORMAT_VERSION)
     {
       // Legacy board.
diff --git a/src/editor/world.c b/src/editor/world.c
index 522821221..c6dd3a7de 100644
--- a/src/editor/world.c
+++ b/src/editor/world.c
@@ -216,11 +216,27 @@ static boolean append_world_legacy(struct world *mzx_world, vfile *vf,
   unsigned int *board_offsets;
   unsigned int *board_sizes;
 
-  vfseek(vf, 4234, SEEK_SET);
+  // The board list is 100% compatible between 1.x and 2.x, so the only
+  // differences that need to be handled here are the location and custom SFX.
+  if(file_version >= V200)
+  {
+    vfseek(vf, 4234, SEEK_SET);
+  }
+  else
+  {
+    int protection_method = 0;
+
+    vfseek(vf, LEGACY_BOARD_NAME_SIZE, SEEK_SET);
+    protection_method = vfgetc(vf);
+
+    vfseek(vf, 4009, SEEK_SET);
+    if(protection_method)
+      vfseek(vf, 16, SEEK_CUR);
+  }
 
   num_boards = vfgetc(vf);
 
-  if(num_boards == 0)
+  if(num_boards == 0 && file_version >= V200)
   {
     int sfx_size;
     // Sfx skip word size
@@ -235,6 +251,10 @@ static boolean append_world_legacy(struct world *mzx_world, vfile *vf,
     num_boards = vfgetc(vf);
   }
 
+  // Shouldn't happen...
+  if(num_boards < 1)
+    return false;
+
   // Skip the names for now
   board_names_pos = vftell(vf);
   vfseek(vf, num_boards * BOARD_NAME_SIZE, SEEK_CUR);
@@ -245,12 +265,12 @@ static boolean append_world_legacy(struct world *mzx_world, vfile *vf,
   mzx_world->num_boards += num_boards;
   mzx_world->num_boards_allocated += num_boards;
   mzx_world->board_list =
-   crealloc(mzx_world->board_list,
-   sizeof(struct board *) * (old_num_boards + num_boards));
+   (struct board **)crealloc(mzx_world->board_list,
+    sizeof(struct board *) * (old_num_boards + num_boards));
 
   // Read the board offsets/sizes preemptively to reduce the amount of seeking.
-  board_offsets = cmalloc(sizeof(int) * num_boards);
-  board_sizes = cmalloc(sizeof(int) * num_boards);
+  board_offsets = (unsigned int *)cmalloc(sizeof(int) * num_boards);
+  board_sizes = (unsigned int *)cmalloc(sizeof(int) * num_boards);
   for(i = 0; i < num_boards; i++)
   {
     board_sizes[i] = vfgetd(vf);
@@ -297,7 +317,9 @@ static boolean append_world_legacy(struct world *mzx_world, vfile *vf,
       dest = cur_board->board_name;
 
     if(!vfread(dest, BOARD_NAME_SIZE, 1, vf))
-      dest[0] = 0;
+      dest[0] = '\0';
+
+    dest[BOARD_NAME_SIZE - 1] = '\0';
   }
 
   vfclose(vf);
@@ -350,8 +372,8 @@ static boolean append_world_zip(struct world *mzx_world, struct zip_archive *zp,
   mzx_world->num_boards += num_boards;
   mzx_world->num_boards_allocated += num_boards;
   mzx_world->board_list =
-   crealloc(mzx_world->board_list,
-   sizeof(struct board *) * (old_num_boards + num_boards));
+   (struct board **)crealloc(mzx_world->board_list,
+    sizeof(struct board *) * (old_num_boards + num_boards));
 
   for(i = old_num_boards; i < old_num_boards + num_boards; i++)
   {
diff --git a/src/error.c b/src/error.c
index 4b1a7a20a..9b918a253 100644
--- a/src/error.c
+++ b/src/error.c
@@ -309,7 +309,7 @@ int error_message(enum error_code id, int parameter, const char *string)
 
     case E_WORLD_FILE_VERSION_OLD:
       sprintf(error_mesg,
-       "World is from old version (%s); use converter",
+       "Invalid world version (%s)",
        version_string);
       code = 0x0D02;
       break;
diff --git a/src/graphics.c b/src/graphics.c
index d80c1757a..d05035b82 100644
--- a/src/graphics.c
+++ b/src/graphics.c
@@ -417,8 +417,12 @@ void default_palette(void)
 {
   memcpy(graphics.palette, default_pal,
    sizeof(struct rgb_color) * PAL_SIZE);
-  memcpy(graphics.intensity_palette, default_pal,
-   sizeof(struct rgb_color) * PAL_SIZE);
+
+  if(!graphics.fade_status)
+  {
+    memcpy(graphics.intensity_palette, default_pal,
+     sizeof(struct rgb_color) * PAL_SIZE);
+  }
   graphics.palette_dirty = true;
 }
 
diff --git a/src/legacy_board.c b/src/legacy_board.c
index 4443bac63..c5967d2d5 100644
--- a/src/legacy_board.c
+++ b/src/legacy_board.c
@@ -18,6 +18,7 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
+#include <inttypes.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -51,39 +52,94 @@ static int cmp_robots(const void *dest, const void *src)
   return strcasecmp(rdest->robot_name, rsrc->robot_name);
 }
 
-static int load_RLE2_plane(char *plane, vfile *vf, int size)
+/* Due to some 1.x RLE jank the dimensions need special handling. */
+static int load_RLE_dimensions(vfile *vf, int *w, int *h)
+{
+  /* Some streams may have a run of 0 appended, but not all of them?
+   * No known 1.xx worlds actually contain these; this comes from VER1TO2. */
+  int tmp = vfgetc(vf);
+  if(!tmp)
+  {
+    debug("Board plane ending in run of length 0 @ %" PRId64 "\n", vftell(vf) - 1);
+    vfgetc(vf);
+    *w = vfgetc(vf);
+  }
+  else
+    *w = tmp;
+
+  *h = vfgetc(vf);
+  return (*h < 0) ? -1 : 0;
+}
+
+/* Stream position should be after the dimensions. */
+static int load_RLE_plane(struct board *cur_board, char *plane, vfile *vf,
+ int size, boolean check_size)
+{
+  int i, runsize, byte;
+
+  if(check_size)
+  {
+    int w, h;
+    if(load_RLE_dimensions(vf, &w, &h))
+      return -1;
+    if(w != cur_board->board_width || h != cur_board->board_height)
+      return -1;
+  }
+
+  for(i = 0; i < size;)
+  {
+    runsize = vfgetc(vf);
+    byte = vfgetc(vf);
+    if(byte < 0)
+      return -1;
+
+    if(i + runsize > size)
+      return -2;
+
+    memset(plane + i, byte, runsize);
+    i += runsize;
+  }
+  return 0;
+}
+
+static int load_RLE2_plane(struct board *cur_board, char *plane, vfile *vf,
+ int size, boolean check_size)
 {
   int i, runsize;
   int current_char;
 
-  if(size < 0)
-    return -3;
+  if(check_size)
+  {
+    int w = vfgetw(vf);
+    int h = vfgetw(vf);
+    if(h < 0 || w != cur_board->board_width || h != cur_board->board_height)
+      return -1;
+  }
 
-  for(i = 0; i < size; i++)
+  for(i = 0; i < size;)
   {
     current_char = vfgetc(vf);
-    if(current_char == EOF)
-    {
+    if(current_char < 0)
       return -1;
-    }
-    else if(!(current_char & 0x80))
+
+    if(~current_char & 0x80)
     {
       // Regular character
-      plane[i] = current_char;
+      plane[i++] = current_char;
     }
     else
     {
       // A run
       runsize = current_char & 0x7F;
-      if((i + runsize) > size)
+      if(i + runsize > size)
         return -2;
 
       current_char = vfgetc(vf);
-      if(current_char == EOF)
+      if(current_char < 0)
         return -1;
 
       memset(plane + i, current_char, runsize);
-      i += (runsize - 1);
+      i += runsize;
     }
   }
 
@@ -97,6 +153,8 @@ int legacy_load_board_direct(struct world *mzx_world, struct board *cur_board,
   int num_robots, num_scrolls, num_sensors, num_robots_active;
   int overlay_mode, size, board_width, board_height, i;
   int viewport_x, viewport_y, viewport_width, viewport_height;
+  int overlay_width;
+  int overlay_height;
   boolean truncated = false;
 
   struct robot *cur_robot;
@@ -143,93 +201,139 @@ int legacy_load_board_direct(struct world *mzx_world, struct board *cur_board,
   cur_board->palette_path = NULL;
   cur_board->charset_path_allocated = 0;
   cur_board->palette_path_allocated = 0;
+  cur_board->blind_dur_v1 = 0;
+  cur_board->firewalker_dur_v1 = 0;
+  cur_board->freeze_time_dur_v1 = 0;
+  cur_board->slow_time_dur_v1 = 0;
+  cur_board->wind_dur_v1 = 0;
 
 #if defined(DEBUG) || defined(CONFIG_EXTRAM)
   cur_board->is_extram = false;
 #endif
 
-  // board_mode, unused
-  if(vfgetc(vf) == EOF)
+  if(file_version >= V200)
   {
-    error_message(E_WORLD_BOARD_MISSING, board_location, NULL);
-    return VAL_MISSING;
-  }
-
-  overlay_mode = vfgetc(vf);
-
-  if(!overlay_mode)
-  {
-    int overlay_width;
-    int overlay_height;
+    // board_mode, unused
+    if(vfgetc(vf) < 0)
+    {
+      error_message(E_WORLD_BOARD_MISSING, board_location, NULL);
+      return VAL_MISSING;
+    }
 
     overlay_mode = vfgetc(vf);
-    overlay_width = vfgetw(vf);
-    overlay_height = vfgetw(vf);
 
-    size = overlay_width * overlay_height;
+    if(!overlay_mode)
+    {
+      overlay_mode = vfgetc(vf);
+      overlay_width = vfgetw(vf);
+      overlay_height = vfgetw(vf);
+      cur_board->board_width = overlay_width;
+      cur_board->board_height = overlay_height;
 
-    if((size < 1) || (size > MAX_BOARD_SIZE))
-      goto err_invalid;
+      size = overlay_width * overlay_height;
 
-    cur_board->overlay = cmalloc(size);
-    cur_board->overlay_color = cmalloc(size);
+      if(size < 1 || size > MAX_BOARD_SIZE)
+        goto err_invalid;
 
-    if(load_RLE2_plane(cur_board->overlay, vf, size))
-      goto err_freeoverlay;
+      cur_board->overlay = (char *)cmalloc(size);
+      cur_board->overlay_color = (char *)cmalloc(size);
 
-    // Skip sizes
-    if(vfgetd(vf) == EOF ||
-     load_RLE2_plane(cur_board->overlay_color, vf, size))
-      goto err_freeoverlay;
-  }
-  else
-  {
-    overlay_mode = 0;
-    // Undo that last get
-    vfseek(vf, -1, SEEK_CUR);
-  }
+      if(!cur_board->overlay || !cur_board->overlay_color)
+        goto err_freeoverlay;
 
-  cur_board->overlay_mode = overlay_mode;
+      if(load_RLE2_plane(cur_board, cur_board->overlay, vf, size, false))
+        goto err_freeoverlay;
+      if(load_RLE2_plane(cur_board, cur_board->overlay_color, vf, size, true))
+        goto err_freeoverlay;
+    }
+    else
+    {
+      overlay_mode = 0;
+      // Undo that last get
+      vfseek(vf, -1, SEEK_CUR);
+    }
 
-  board_width = vfgetw(vf);
-  board_height = vfgetw(vf);
-  cur_board->board_width = board_width;
-  cur_board->board_height = board_height;
+    cur_board->overlay_mode = overlay_mode;
 
-  size = board_width * board_height;
+    board_width = vfgetw(vf);
+    board_height = vfgetw(vf);
+    cur_board->board_width = board_width;
+    cur_board->board_height = board_height;
 
-  if((size < 1) || (size > MAX_BOARD_SIZE))
-    goto err_freeoverlay;
+    size = board_width * board_height;
 
-  cur_board->level_id = cmalloc(size);
-  cur_board->level_color = cmalloc(size);
-  cur_board->level_param = cmalloc(size);
-  cur_board->level_under_id = cmalloc(size);
-  cur_board->level_under_color = cmalloc(size);
-  cur_board->level_under_param = cmalloc(size);
+    if(size < 1 || size > MAX_BOARD_SIZE)
+      goto err_freeoverlay;
+    if(overlay_mode && (board_width != overlay_width || board_height != overlay_height))
+      goto err_freeoverlay;
 
-  if(load_RLE2_plane(cur_board->level_id, vf, size))
-    goto err_freeboard;
+    cur_board->level_id = (char *)cmalloc(size);
+    cur_board->level_color = (char *)cmalloc(size);
+    cur_board->level_param = (char *)cmalloc(size);
+    cur_board->level_under_id = (char *)cmalloc(size);
+    cur_board->level_under_color = (char *)cmalloc(size);
+    cur_board->level_under_param = (char *)cmalloc(size);
+
+    if(!cur_board->level_id || !cur_board->level_color ||
+     !cur_board->level_param || !cur_board->level_under_id ||
+     !cur_board->level_under_color || !cur_board->level_under_param)
+      goto err_freeboard;
+
+    if(load_RLE2_plane(cur_board, cur_board->level_id, vf, size, false))
+      goto err_freeboard;
+    if(load_RLE2_plane(cur_board, cur_board->level_color, vf, size, true))
+      goto err_freeboard;
+    if(load_RLE2_plane(cur_board, cur_board->level_param, vf, size, true))
+      goto err_freeboard;
+    if(load_RLE2_plane(cur_board, cur_board->level_under_id, vf, size, true))
+      goto err_freeboard;
+    if(load_RLE2_plane(cur_board, cur_board->level_under_color, vf, size, true))
+      goto err_freeboard;
+    if(load_RLE2_plane(cur_board, cur_board->level_under_param, vf, size, true))
+      goto err_freeboard;
+  }
+  else
+  {
+    /* 1.x has no overlay and a different packing format. */
+    overlay_mode = 0;
+    cur_board->overlay_mode = overlay_mode;
 
-  if(vfgetd(vf) == EOF ||
-   load_RLE2_plane(cur_board->level_color, vf, size))
-    goto err_freeboard;
+    if(load_RLE_dimensions(vf, &board_width, &board_height))
+      goto err_invalid;
 
-  if(vfgetd(vf) == EOF ||
-   load_RLE2_plane(cur_board->level_param, vf, size))
-    goto err_freeboard;
+    cur_board->board_width = board_width;
+    cur_board->board_height = board_height;
 
-  if(vfgetd(vf) == EOF ||
-   load_RLE2_plane(cur_board->level_under_id, vf, size))
-    goto err_freeboard;
+    size = board_width * board_height;
 
-  if(vfgetd(vf) == EOF ||
-   load_RLE2_plane(cur_board->level_under_color, vf, size))
-    goto err_freeboard;
+    if(size < 1 || size > MAX_BOARD_SIZE)
+      goto err_invalid;
 
-  if(vfgetd(vf) == EOF ||
-   load_RLE2_plane(cur_board->level_under_param, vf, size))
-    goto err_freeboard;
+    cur_board->level_id = (char *)cmalloc(size);
+    cur_board->level_color = (char *)cmalloc(size);
+    cur_board->level_param = (char *)cmalloc(size);
+    cur_board->level_under_id = (char *)cmalloc(size);
+    cur_board->level_under_color = (char *)cmalloc(size);
+    cur_board->level_under_param = (char *)cmalloc(size);
+
+    if(!cur_board->level_id || !cur_board->level_color ||
+     !cur_board->level_param || !cur_board->level_under_id ||
+     !cur_board->level_under_color || !cur_board->level_under_param)
+      goto err_freeboard;
+
+    if(load_RLE_plane(cur_board, cur_board->level_id, vf, size, false))
+      goto err_freeboard;
+    if(load_RLE_plane(cur_board, cur_board->level_color, vf, size, true))
+      goto err_freeboard;
+    if(load_RLE_plane(cur_board, cur_board->level_param, vf, size, true))
+      goto err_freeboard;
+    if(load_RLE_plane(cur_board, cur_board->level_under_id, vf, size, true))
+      goto err_freeboard;
+    if(load_RLE_plane(cur_board, cur_board->level_under_color, vf, size, true))
+      goto err_freeboard;
+    if(load_RLE_plane(cur_board, cur_board->level_under_param, vf, size, true))
+      goto err_freeboard;
+  }
 
   // Load board parameters
 
@@ -281,9 +385,7 @@ int legacy_load_board_direct(struct world *mzx_world, struct board *cur_board,
   cur_board->fire_burns = vfgetc(vf);
 
   for(i = 0; i < 4; i++)
-  {
     cur_board->board_dir[i] = vfgetc(vf);
-  }
 
   cur_board->restart_if_zapped = vfgetc(vf);
   cur_board->time_limit = vfgetw(vf);
@@ -294,11 +396,33 @@ int legacy_load_board_direct(struct world *mzx_world, struct board *cur_board,
     cur_board->num_input = vfgetw(vf);
     cur_board->input_size = vfgetc(vf);
 
+    if(file_version < V200)
+    {
+      cur_board->volume = vfgetc(vf);
+      cur_board->player_ns_locked = vfgetc(vf);
+      cur_board->player_ew_locked = vfgetc(vf);
+      cur_board->player_attack_locked = vfgetc(vf);
+    }
+
     if(!vfread(input_string, LEGACY_INPUT_STRING_MAX + 1, 1, vf))
       input_string[0] = 0;
     input_string[LEGACY_INPUT_STRING_MAX] = 0;
     board_set_input_string(cur_board, input_string, LEGACY_INPUT_STRING_MAX);
 
+    if(file_version < V200)
+    {
+      // Effects and unused junk in 1.x :(
+      unsigned char tmp[9];
+      memset(tmp, 0, sizeof(tmp));
+      vfread(tmp, 1, 9, vf);
+
+      cur_board->blind_dur_v1 = tmp[0];
+      cur_board->firewalker_dur_v1 = tmp[1];
+      cur_board->freeze_time_dur_v1 = tmp[3];
+      cur_board->slow_time_dur_v1 = tmp[4];
+      cur_board->wind_dur_v1 = tmp[8];
+    }
+
     cur_board->player_last_dir = vfgetc(vf);
 
     if(!vfread(cur_board->bottom_mesg, LEGACY_BOTTOM_MESG_MAX + 1, 1, vf))
@@ -309,10 +433,23 @@ int legacy_load_board_direct(struct world *mzx_world, struct board *cur_board,
     cur_board->lazwall_start = vfgetc(vf);
     cur_board->b_mesg_row = vfgetc(vf);
     cur_board->b_mesg_col = (signed char)vfgetc(vf);
-    cur_board->scroll_x = (signed short)vfgetw(vf);
-    cur_board->scroll_y = (signed short)vfgetw(vf);
-    cur_board->locked_x = (signed short)vfgetw(vf);
-    cur_board->locked_y = (signed short)vfgetw(vf);
+
+    if(file_version >= V200)
+    {
+      cur_board->scroll_x = (signed short)vfgetw(vf);
+      cur_board->scroll_y = (signed short)vfgetw(vf);
+      cur_board->locked_x = (signed short)vfgetw(vf);
+      cur_board->locked_y = (signed short)vfgetw(vf);
+    }
+    else
+    {
+      cur_board->scroll_x = (signed char)vfgetc(vf);
+      cur_board->scroll_y = (signed char)vfgetc(vf);
+
+      // Fix world default centered value for message column...
+      if(!savegame && cur_board->b_mesg_col == 0)
+        cur_board->b_mesg_col = -1;
+    }
   }
   else
 
@@ -353,15 +490,18 @@ int legacy_load_board_direct(struct world *mzx_world, struct board *cur_board,
     cur_board->locked_y = (signed short)vfgetw(vf);
   }
 
-  cur_board->player_ns_locked = vfgetc(vf);
-  cur_board->player_ew_locked = vfgetc(vf);
-  cur_board->player_attack_locked = vfgetc(vf);
-
-  if(file_version < V283 || savegame)
+  if(file_version >= V200)
   {
-    cur_board->volume = vfgetc(vf);
-    cur_board->volume_inc = vfgetc(vf);
-    cur_board->volume_target = vfgetc(vf);
+    cur_board->player_ns_locked = vfgetc(vf);
+    cur_board->player_ew_locked = vfgetc(vf);
+    cur_board->player_attack_locked = vfgetc(vf);
+
+    if(file_version < V283 || savegame)
+    {
+      cur_board->volume = vfgetc(vf);
+      cur_board->volume_inc = vfgetc(vf);
+      cur_board->volume_target = vfgetc(vf);
+    }
   }
 
 
@@ -405,7 +545,6 @@ int legacy_load_board_direct(struct world *mzx_world, struct board *cur_board,
       }
       else
       {
-        // We don't need no null robot
         clear_robot(cur_robot);
         cur_board->robot_list[i] = NULL;
       }
@@ -451,7 +590,7 @@ int legacy_load_board_direct(struct world *mzx_world, struct board *cur_board,
   {
     for(i = 1; i <= num_scrolls; i++)
     {
-      cur_scroll = legacy_load_scroll_allocate(vf);
+      cur_scroll = legacy_load_scroll_allocate(vf, file_version);
       if(cur_scroll->used)
         cur_board->scroll_list[i] = cur_scroll;
       else
@@ -481,7 +620,7 @@ int legacy_load_board_direct(struct world *mzx_world, struct board *cur_board,
   {
     for(i = 1; i <= num_sensors; i++)
     {
-      cur_sensor = legacy_load_sensor_allocate(vf);
+      cur_sensor = legacy_load_sensor_allocate(vf, file_version);
       if(cur_sensor->used)
         cur_board->sensor_list[i] = cur_sensor;
       else
diff --git a/src/legacy_rasm.c b/src/legacy_rasm.c
index 94356f999..aaa75e679 100644
--- a/src/legacy_rasm.c
+++ b/src/legacy_rasm.c
@@ -19,10 +19,10 @@
  */
 
 #include <ctype.h>
+#include <limits.h>
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
-#include <ctype.h>
 
 #include "rasm.h"
 #include "data.h"
@@ -2729,6 +2729,494 @@ void disassemble_program(char *program, int program_length,
 }
 #endif // !CONFIG_DEBYTECODE
 
+enum v1_params
+{
+  V1_NO_PARAM,
+  V1_16,              // unsigned
+  V1_U8,              // unsigned
+  V1_STRING,
+  V1_CHAR,
+  V1_COLOR,           // bit 8 is stored as bit 7 of the next byte(!).
+  V1_COLOR_UNUSED,    // unused in ver1to2, handled in V1_COLOR here.
+  V1_DIRECTION,
+  V1_ITEM,
+  V1_EQUALITY,
+  V1_CONDITION,
+  V1_THING,
+  V1_PARAM,
+  V1_ADD_PARAM,       // param was not present in the original command, use 256.
+  V1_8,               // signed
+
+  V1_SPECIAL_CHAR_EDIT,     // translate 14 type-2 parameters
+  V1_SPECIAL_TOUCHING_DIR,  // convert direction to condition: touching [dir]
+};
+
+static const uint8_t v1_command_translation[256][8] =
+{
+  // cvt=convert to a different command.
+  { ROBOTIC_CMD_END },
+  { ROBOTIC_CMD_DIE },
+  { ROBOTIC_CMD_WAIT,               V1_U8 },
+  { ROBOTIC_CMD_CYCLE,              V1_U8 },
+  { ROBOTIC_CMD_GO,                 V1_DIRECTION, V1_U8 },
+  { ROBOTIC_CMD_WALK,               V1_DIRECTION },
+  { ROBOTIC_CMD_BECOME,             V1_COLOR, V1_THING, V1_PARAM },
+  { ROBOTIC_CMD_CHAR,               V1_CHAR },
+  { ROBOTIC_CMD_COLOR,              V1_COLOR },
+  { ROBOTIC_CMD_GOTOXY,             V1_8, V1_8 },
+  { ROBOTIC_CMD_SET,                V1_STRING, V1_16 },
+  { ROBOTIC_CMD_INC,                V1_STRING, V1_16 },
+  { ROBOTIC_CMD_DEC,                V1_STRING, V1_16 },
+  { ROBOTIC_CMD_SET,                V1_STRING, V1_STRING }, // cvt
+  { ROBOTIC_CMD_INC,                V1_STRING, V1_STRING }, // cvt
+  { ROBOTIC_CMD_DEC,                V1_STRING, V1_STRING }, // cvt
+  { ROBOTIC_CMD_IF,                 V1_STRING, V1_EQUALITY, V1_16, V1_STRING },
+  { ROBOTIC_CMD_IF,                 V1_STRING, V1_EQUALITY, V1_STRING, V1_STRING }, // cvt
+  { ROBOTIC_CMD_IF_CONDITION,       V1_CONDITION, V1_STRING },
+  { ROBOTIC_CMD_IF_NOT_CONDITION,   V1_CONDITION, V1_STRING },
+  { ROBOTIC_CMD_IF_ANY,             V1_COLOR, V1_THING, V1_ADD_PARAM, V1_STRING },
+  { ROBOTIC_CMD_IF_NO,              V1_COLOR, V1_THING, V1_ADD_PARAM, V1_STRING },
+  { ROBOTIC_CMD_IF_THING_DIR,       V1_COLOR, V1_THING, V1_ADD_PARAM, V1_DIRECTION, V1_STRING },
+  { ROBOTIC_CMD_IF_NOT_THING_DIR,   V1_COLOR, V1_THING, V1_ADD_PARAM, V1_DIRECTION, V1_STRING },
+  { ROBOTIC_CMD_IF_THING_XY,        V1_COLOR, V1_THING, V1_ADD_PARAM, V1_8, V1_8, V1_STRING },
+  { ROBOTIC_CMD_IF_AT,              V1_8, V1_8, V1_STRING },
+  { ROBOTIC_CMD_IF_DIR_OF_PLAYER,   V1_DIRECTION, V1_COLOR, V1_THING, V1_ADD_PARAM, V1_STRING },
+  { ROBOTIC_CMD_DOUBLE,             V1_STRING },
+  { ROBOTIC_CMD_HALF,               V1_STRING },
+  { ROBOTIC_CMD_GOTO,               V1_STRING },
+  { ROBOTIC_CMD_SEND,               V1_STRING, V1_STRING },
+  { ROBOTIC_CMD_EXPLODE,            V1_U8 },
+  { ROBOTIC_CMD_PUT_DIR,            V1_COLOR, V1_THING, V1_PARAM, V1_DIRECTION },
+  { ROBOTIC_CMD_GIVE,               V1_16, V1_ITEM },
+  { ROBOTIC_CMD_TAKE,               V1_16, V1_ITEM },
+  { ROBOTIC_CMD_TAKE_OR,            V1_16, V1_ITEM, V1_STRING },
+  { ROBOTIC_CMD_ENDGAME },
+  { ROBOTIC_CMD_ENDLIFE },
+  { ROBOTIC_CMD_MOD,                V1_STRING },
+  { ROBOTIC_CMD_SAM,                V1_16, V1_STRING },
+  { ROBOTIC_CMD_VOLUME,             V1_U8 },
+  { ROBOTIC_CMD_END_MOD },
+  { ROBOTIC_CMD_END_SAM },
+  { ROBOTIC_CMD_PLAY,               V1_STRING },
+  { ROBOTIC_CMD_END_PLAY },
+  { ROBOTIC_CMD_WAIT_THEN_PLAY,     V1_STRING },
+  { ROBOTIC_CMD_WAIT_PLAY },
+  { ROBOTIC_CMD_BLANK_LINE },
+  { ROBOTIC_CMD_SFX,                V1_U8 },
+  { ROBOTIC_CMD_PLAY_IF_SILENT,     V1_STRING },
+  { ROBOTIC_CMD_OPEN,               V1_DIRECTION },
+  { ROBOTIC_CMD_LOCKSELF },
+  { ROBOTIC_CMD_UNLOCKSELF },
+  { ROBOTIC_CMD_SEND_DIR,           V1_DIRECTION, V1_STRING },
+  { ROBOTIC_CMD_ZAP,                V1_STRING, V1_U8 },
+  { ROBOTIC_CMD_RESTORE,            V1_STRING, V1_U8 },
+  { ROBOTIC_CMD_LOCKPLAYER },
+  { ROBOTIC_CMD_UNLOCKPLAYER },
+  { ROBOTIC_CMD_LOCKPLAYER_NS },
+  { ROBOTIC_CMD_LOCKPLAYER_EW },
+  { ROBOTIC_CMD_LOCKPLAYER_ATTACK },
+  { ROBOTIC_CMD_MOVE_PLAYER_DIR,    V1_DIRECTION },
+  { ROBOTIC_CMD_MOVE_PLAYER_DIR_OR, V1_DIRECTION, V1_STRING },
+  { ROBOTIC_CMD_PUT_PLAYER_XY,      V1_8, V1_8, },
+  { ROBOTIC_CMD_IF_CONDITION,       V1_SPECIAL_TOUCHING_DIR, V1_STRING }, // cvt
+  { ROBOTIC_CMD_IF_NOT_CONDITION,   V1_SPECIAL_TOUCHING_DIR, V1_STRING }, // cvt
+  { ROBOTIC_CMD_IF_PLAYER_XY,       V1_8, V1_8, V1_STRING },
+  { ROBOTIC_CMD_PUT_PLAYER_DIR,     V1_DIRECTION },
+  { ROBOTIC_CMD_TRY_DIR,            V1_DIRECTION, V1_STRING },
+  { ROBOTIC_CMD_ROTATECW },
+  { ROBOTIC_CMD_ROTATECCW },
+  { ROBOTIC_CMD_SWITCH,             V1_DIRECTION, V1_DIRECTION },
+  { ROBOTIC_CMD_SHOOT,              V1_DIRECTION },
+  { ROBOTIC_CMD_LAYBOMB,            V1_DIRECTION },
+  { ROBOTIC_CMD_LAYBOMB_HIGH,       V1_DIRECTION },
+  { ROBOTIC_CMD_SHOOTMISSILE,       V1_DIRECTION },
+  { ROBOTIC_CMD_SHOOTSEEKER,        V1_DIRECTION },
+  { ROBOTIC_CMD_SPITFIRE,           V1_DIRECTION },
+  { ROBOTIC_CMD_LAZERWALL,          V1_DIRECTION, V1_U8 },
+  { ROBOTIC_CMD_PUT_XY,             V1_COLOR, V1_THING, V1_PARAM, V1_8, V1_8 },
+  { ROBOTIC_CMD_DIE_ITEM },
+  { ROBOTIC_CMD_SEND_XY,            V1_8, V1_8, V1_STRING },
+  { ROBOTIC_CMD_COPYROBOT_NAMED,    V1_STRING },
+  { ROBOTIC_CMD_COPYROBOT_XY,       V1_8, V1_8 },
+  { ROBOTIC_CMD_COPYROBOT_DIR,      V1_DIRECTION },
+  { ROBOTIC_CMD_DUPLICATE_SELF_DIR, V1_DIRECTION },
+  { ROBOTIC_CMD_DUPLICATE_SELF_XY,  V1_8, V1_8 },
+  { ROBOTIC_CMD_BULLETN,            V1_CHAR },
+  { ROBOTIC_CMD_BULLETS,            V1_CHAR },
+  { ROBOTIC_CMD_BULLETE,            V1_CHAR },
+  { ROBOTIC_CMD_BULLETW,            V1_CHAR },
+  { ROBOTIC_CMD_GIVEKEY,            V1_COLOR },
+  { ROBOTIC_CMD_GIVEKEY_OR,         V1_COLOR, V1_STRING },
+  { ROBOTIC_CMD_TAKEKEY,            V1_COLOR },
+  { ROBOTIC_CMD_TAKEKEY_OR,         V1_COLOR, V1_STRING },
+  { ROBOTIC_CMD_INC_RANDOM,         V1_STRING, V1_16, V1_16 },
+  { ROBOTIC_CMD_DEC_RANDOM,         V1_STRING, V1_16, V1_16 },
+  { ROBOTIC_CMD_SET_RANDOM,         V1_STRING, V1_16, V1_16 },
+  { ROBOTIC_CMD_TRADE,              V1_16, V1_ITEM, V1_16, V1_ITEM, V1_STRING },
+  { ROBOTIC_CMD_SEND_DIR_PLAYER,    V1_DIRECTION, V1_STRING },
+  { ROBOTIC_CMD_PUT_DIR_PLAYER,     V1_COLOR, V1_THING, V1_PARAM, V1_DIRECTION },
+  { ROBOTIC_CMD_SLASH,              V1_STRING },
+  { ROBOTIC_CMD_MESSAGE_LINE,       V1_STRING },
+  { ROBOTIC_CMD_MESSAGE_BOX_LINE,   V1_STRING },
+  { ROBOTIC_CMD_MESSAGE_BOX_OPTION, V1_STRING, V1_STRING },
+  { ROBOTIC_CMD_MESSAGE_BOX_MAYBE_OPTION, V1_STRING, V1_STRING, V1_STRING },
+  { ROBOTIC_CMD_LABEL,              V1_STRING },
+  { ROBOTIC_CMD_COMMENT,            V1_STRING },
+  { ROBOTIC_CMD_ZAPPED_LABEL,       V1_STRING },
+  { ROBOTIC_CMD_TELEPORT,           V1_STRING, V1_8, V1_8 },
+  { ROBOTIC_CMD_SCROLLVIEW,         V1_DIRECTION, V1_U8 },
+  { ROBOTIC_CMD_INPUT,              V1_STRING },
+  { ROBOTIC_CMD_IF_INPUT,           V1_STRING, V1_STRING },
+  { ROBOTIC_CMD_IF_INPUT_NOT,       V1_STRING, V1_STRING },
+  { ROBOTIC_CMD_IF_INPUT_MATCHES,   V1_STRING, V1_STRING },
+  { ROBOTIC_CMD_PLAYER_CHAR,        V1_CHAR },
+  { ROBOTIC_CMD_MESSAGE_BOX_COLOR_LINE, V1_STRING },
+  { ROBOTIC_CMD_MESSAGE_BOX_CENTER_LINE, V1_STRING },
+  { ROBOTIC_CMD_MOVE_ALL,           V1_COLOR, V1_THING, V1_ADD_PARAM, V1_DIRECTION },
+  { ROBOTIC_CMD_COPY,               V1_8, V1_8, V1_8, V1_8 },
+  { ROBOTIC_CMD_SET_EDGE_COLOR,     V1_COLOR },
+  { ROBOTIC_CMD_BOARD,              V1_DIRECTION, V1_STRING },
+  { ROBOTIC_CMD_BOARD_IS_NONE,      V1_DIRECTION },
+  { ROBOTIC_CMD_CHAR_EDIT,          V1_CHAR, V1_SPECIAL_CHAR_EDIT },
+  { ROBOTIC_CMD_BECOME_PUSHABLE },
+  { ROBOTIC_CMD_BECOME_NONPUSHABLE },
+  { ROBOTIC_CMD_BLIND,              V1_U8 },
+  { ROBOTIC_CMD_FIREWALKER,         V1_U8 },
+  { ROBOTIC_CMD_FREEZETIME,         V1_U8 },
+  { ROBOTIC_CMD_SLOWTIME,           V1_U8 },
+  { ROBOTIC_CMD_WIND,               V1_U8 },
+  { ROBOTIC_CMD_AVALANCHE },
+  { ROBOTIC_CMD_COPY_DIR,           V1_DIRECTION, V1_DIRECTION },
+  { ROBOTIC_CMD_BECOME_LAVAWALKER },
+  { ROBOTIC_CMD_BECOME_NONLAVAWALKER },
+  { ROBOTIC_CMD_CHANGE,             V1_COLOR, V1_THING, V1_ADD_PARAM,
+                                    V1_COLOR, V1_THING, V1_PARAM },
+  { ROBOTIC_CMD_PLAYERCOLOR,        V1_COLOR },
+  { ROBOTIC_CMD_BULLETCOLOR,        V1_COLOR },
+  { ROBOTIC_CMD_MISSILECOLOR,       V1_COLOR },
+  { ROBOTIC_CMD_MESSAGE_ROW,        V1_U8 },
+  { ROBOTIC_CMD_REL_SELF },
+  { ROBOTIC_CMD_REL_PLAYER },
+  { ROBOTIC_CMD_REL_COUNTERS },
+  { ROBOTIC_CMD_SET_ID_CHAR,        V1_16, V1_CHAR },
+  { ROBOTIC_CMD_JUMP_MOD_ORDER,     V1_U8 },
+  { ROBOTIC_CMD_ASK,                V1_STRING },
+  { ROBOTIC_CMD_FILLHEALTH },
+  { ROBOTIC_CMD_THICK_ARROW,        V1_DIRECTION, V1_CHAR },
+  { ROBOTIC_CMD_THIN_ARROW,         V1_DIRECTION, V1_CHAR },
+  { ROBOTIC_CMD_SET_MAX_HEALTH,     V1_16 },
+  { ROBOTIC_CMD_SAVE_PLAYER_POSITION },
+  { ROBOTIC_CMD_RESTORE_PLAYER_POSITION },
+  { ROBOTIC_CMD_EXCHANGE_PLAYER_POSITION },
+  { ROBOTIC_CMD_MESSAGE_COLUMN,     V1_U8 },
+  { ROBOTIC_CMD_CENTER_MESSAGE },
+  { ROBOTIC_CMD_CLEAR_MESSAGE },
+  { ROBOTIC_CMD_RESETVIEW },
+  { ROBOTIC_CMD_MOD_SAM,            V1_16, V1_U8 },
+  { ROBOTIC_CMD_VOLUME,             V1_STRING }, // cvt
+  { ROBOTIC_CMD_SCROLLBASE,         V1_COLOR },
+  { ROBOTIC_CMD_SCROLLCORNER,       V1_COLOR },
+  { ROBOTIC_CMD_SCROLLTITLE,        V1_COLOR },
+  { ROBOTIC_CMD_SCROLLPOINTER,      V1_COLOR },
+  { ROBOTIC_CMD_SCROLLARROW,        V1_COLOR },
+  { ROBOTIC_CMD_VIEWPORT,           V1_U8, V1_U8 },
+  { ROBOTIC_CMD_VIEWPORT_WIDTH,     V1_U8, V1_U8 },
+  { ROBOTIC_CMD_MESSAGE_COLUMN,     V1_STRING }, // cvt
+  { ROBOTIC_CMD_MESSAGE_ROW,        V1_STRING }, // cvt
+
+  /* The following future commands aren't supported by MegaZeux 1.x, but
+   * are allowed to make automated testing of 1.x worlds possible. */
+  [ROBOTIC_CMD_SWAP_WORLD] = { ROBOTIC_CMD_SWAP_WORLD, V1_STRING },
+};
+
+boolean legacy_convert_v1_program(char **_dest, int *_dest_len,
+ int *_cur_prog_line, const char *src, int src_len)
+{
+  uint8_t buf[257];
+  size_t dest_len;
+  size_t dest_alloc;
+  int cur_prog_line = *_cur_prog_line;
+  int i;
+  char *dest;
+  char *tmp;
+
+  // Special case- replace very short programs with FF 00.
+  if(src_len <= 2)
+  {
+    dest = (char *)cmalloc(2);
+    if(!dest)
+      return false;
+
+    *_dest = dest;
+    *_dest_len = 2;
+    *_dest[0] = 0xff;
+    *_dest[1] = 0;
+    *_cur_prog_line = 0;
+    return true;
+  }
+
+  // Fix out-of-bounds cur_prog_line.
+  if(cur_prog_line < 0 || cur_prog_line >= src_len)
+  {
+    debug("Robot has out-of-bounds v1 cur_prog_line %d (len: %d)\n",
+     cur_prog_line, src_len);
+    cur_prog_line = 0;
+  }
+
+  dest_alloc = src_len * 2;
+  dest = (char *)cmalloc(dest_alloc);
+  if(!dest)
+    return false;
+
+  dest[0] = 0xff;
+  dest_len = 1;
+
+  for(i = 1; i + 3 < src_len && *src;)
+  {
+    int cmd_off = i;
+    int cmd_len = src[i++];
+    int cmd = src[i++];
+    int next_cmd = i + cmd_len;
+    int len = 1;
+    int j;
+
+    if(next_cmd >= src_len)
+    {
+      trace("invalid 1.x command: length extends past program, truncating\n");
+      break;
+    }
+
+    // Note: invalid commands default to 0 and translate to ROBOTIC_CMD_END.
+    buf[len++] = v1_command_translation[cmd][0];
+
+    for(j = 1; v1_command_translation[cmd][j]; j++)
+    {
+      switch(v1_command_translation[cmd][j])
+      {
+        case V1_16:
+        case V1_CONDITION:
+        {
+          if(i + 2 > src_len || len + 3 > 255)
+            goto err;
+
+          buf[len++] = 0;
+          buf[len++] = src[i++];
+          buf[len++] = src[i++];
+          break;
+        }
+
+        case V1_U8:
+        case V1_CHAR:
+        case V1_DIRECTION:
+        case V1_ITEM:
+        case V1_EQUALITY:
+        {
+          if(i >= src_len || len + 3 > 255)
+            goto err;
+
+          buf[len++] = 0;
+          buf[len++] = src[i++];
+          buf[len++] = 0;
+          break;
+        }
+
+        case V1_STRING:
+        {
+          int start = len;
+          int str_len = 0;
+          // Reserve length byte.
+          len++;
+
+          while(len < 255 && i < src_len && src[i])
+          {
+            if(src[i] == '&')
+            {
+              // Convert & to &&. ver1to2 did this conditionally for (mainly)
+              // text displaying commands, but it really ought to be applied
+              // unconditionally.
+              buf[len++] = '&';
+              str_len++;
+
+              if(len >= 255)
+                goto err;
+            }
+            buf[len++] = src[i++];
+            str_len++;
+          }
+          if(len >= 255 || i >= src_len)
+            goto err;
+
+          buf[start] = str_len + 1;
+          buf[len++] = '\0';
+          i++;
+          break;
+        }
+
+        case V1_COLOR:
+        {
+          if(i >= src_len || len + 3 > 255)
+            goto err;
+
+          buf[len++] = 0;
+          buf[len++] = src[i++];
+
+          if(i + 1 <= src_len && v1_command_translation[cmd][j + 1] == V1_THING)
+            buf[len++] = src[i] >> 7;
+          else
+            buf[len++] = 0;
+          break;
+        }
+
+        case V1_THING:
+        {
+          if(i >= src_len || len + 3 > 255)
+            goto err;
+
+          // Bit 7 is used to store color bit 8 in some cases.
+          buf[len++] = 0;
+          buf[len++] = src[i++] & 0x7f;
+          buf[len++] = 0;
+          break;
+        }
+
+        case V1_PARAM:
+        {
+          int param;
+          if(i >= src_len || len + 3 > 255)
+            goto err;
+
+          // p?? encodes to a value of 0(!), convert to 256.
+          buf[len++] = 0;
+          buf[len++] = param = src[i++];
+          buf[len++] = param ? 0 : 1;
+          break;
+        }
+
+        case V1_ADD_PARAM:
+        {
+          if(len + 3 > 255)
+            goto err;
+
+          buf[len++] = 0;
+          buf[len++] = 0;
+          buf[len++] = (256 >> 8);
+          break;
+        }
+
+        case V1_8:
+        {
+          int16_t param;
+          if(i >= src_len || len + 3 > 255)
+            goto err;
+
+          param = (int8_t)src[i++];
+
+          buf[len++] = 0;
+          buf[len++] = param & 0xff;
+          buf[len++] = param >> 8;
+          break;
+        }
+
+        case V1_SPECIAL_CHAR_EDIT:
+        {
+          // Hack so the parameter type mapping table doesn't need to be huge.
+          int k;
+          for(k = 0; k < 14; k++)
+          {
+            if(i >= src_len || len + 3 > 255)
+              goto err;
+
+            buf[len++] = 0;
+            buf[len++] = src[i++];
+            buf[len++] = 0;
+          }
+          break;
+        }
+
+        case V1_SPECIAL_TOUCHING_DIR:
+        {
+          // Input is the DIR parameter of IF [NOT] PLAYER DIR "label".
+          // This gets converted to IF [NOT] TOUCHING DIR "label".
+          if(i >= src_len || len + 3 > 255)
+            goto err;
+
+          buf[len++] = 0;
+          buf[len++] = TOUCHING;
+          buf[len++] = src[i++];
+          break;
+        }
+
+        default:
+        {
+          warn("unhandled 1.x parameter type! FIXME!!!\n");
+          break;
+        }
+      }
+    }
+
+    if(i >= src_len || i >= next_cmd)
+    {
+      trace("invalid 1.x command: params too long, truncating.\n");
+      break;
+    }
+    // Chronos Stasis 1.01 has some unusual corrupted robots with broken
+    // trailing length bytes. This is safe to quietly fix.
+    if(src[next_cmd - 1] != cmd_len)
+      trace("invalid 1.x command: trailing length != starting length.\n");
+
+    // Convert v1 cur_prog_line to v2 cur_prog_line.
+    // Any value in the middle of a command is junk and should be filtered.
+    if(cur_prog_line > cmd_off && cur_prog_line < next_cmd)
+    {
+      debug("Robot has invalid v1 cur_prog_line %d @ offset %d (len: %d)\n",
+       cur_prog_line, cmd_off, src_len);
+      cur_prog_line = 0;
+    }
+    if(cur_prog_line == cmd_off)
+      cur_prog_line = dest_len;
+
+    i = next_cmd;
+
+    buf[0] = len - 1;
+    buf[len] = len - 1;
+    len++;
+
+    // +1 for program terminating 0.
+    if(dest_len + len + 1 > dest_alloc)
+    {
+      while(dest_len + len + 1 > dest_alloc)
+      {
+        if(dest_alloc > INT_MAX)
+          goto err;
+
+        dest_alloc *= 2;
+      }
+      tmp = (char *)crealloc(dest, dest_alloc);
+      if(!tmp)
+        goto err;
+
+      dest = tmp;
+    }
+    memcpy(dest + dest_len, buf, len);
+    dest_len += len;
+  }
+
+  dest[dest_len++] = '\0';
+
+  tmp = (char *)crealloc(dest, dest_len);
+  if(tmp)
+    dest = tmp;
+
+  *_dest = dest;
+  *_dest_len = dest_len;
+  *_cur_prog_line = cur_prog_line;
+  return true;
+
+err:
+  free(dest);
+  return false;
+}
+
 enum bytecode_fix_status
 {
   BC_NO_ERROR,
@@ -2986,11 +3474,8 @@ boolean validate_legacy_bytecode(char **_bc, int *_program_length,
     status = BC_COULDNT_FIX;
 
   // One iteration should be a single command.
-  while(1)
+  while(status != BC_COULDNT_FIX)
   {
-    if(status == BC_COULDNT_FIX)
-      break;
-
     cur_command_length = bc[i];
     i++;
     if(cur_command_length == 0)
@@ -2998,14 +3483,8 @@ boolean validate_legacy_bytecode(char **_bc, int *_program_length,
 
     cur_command_start = i;
 
-    if((i + cur_command_length) > program_length)
-    {
-      i--;
-      status = validate_legacy_bytecode_attempt_fix(&bc, &program_length, i);
-      continue;
-    }
-
-    if(bc[i + cur_command_length] != cur_command_length)
+    if(i + cur_command_length >= program_length ||
+     bc[i + cur_command_length] != cur_command_length)
     {
       i--;
       status = validate_legacy_bytecode_attempt_fix(&bc, &program_length, i);
diff --git a/src/legacy_rasm.h b/src/legacy_rasm.h
index 61a5cff30..f65f0bce9 100644
--- a/src/legacy_rasm.h
+++ b/src/legacy_rasm.h
@@ -72,6 +72,8 @@ extern const char special_first_char[256];
 // This command will reallocate the program as-needed, but it won't free it.
 boolean validate_legacy_bytecode(char **_bc, int *_program_length,
  int *_cur_prog_line);
+boolean legacy_convert_v1_program(char **_dest, int *_dest_len,
+ int *_cur_prog_line, const char *src, int src_len);
 
 #ifdef CONFIG_DEBYTECODE
 
diff --git a/src/legacy_robot.c b/src/legacy_robot.c
index 7c33fd4ba..479539316 100644
--- a/src/legacy_robot.c
+++ b/src/legacy_robot.c
@@ -19,6 +19,7 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
+#include <limits.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -36,10 +37,109 @@
 #include "io/memfile.h"
 #include "io/vio.h"
 
+static boolean legacy_load_robot_v1(struct world *mzx_world, struct robot *cur_robot,
+ vfile *vf, int savegame, int file_version)
+{
+  int robot_location = vftell(vf);
+  char *program_v1 = NULL;
+  char *program_v2 = NULL;
+  int program_v1_length;
+  int program_v2_length;
+
+  create_blank_robot(cur_robot);
+
+  program_v1_length = vfgetw(vf);
+  vfgetw(vf); // Unused high bytes
+  vfgetd(vf); // Junk
+
+  if(!vfread(cur_robot->robot_name, LEGACY_ROBOT_NAME_SIZE, 1, vf))
+    return false;
+
+  cur_robot->robot_name[LEGACY_ROBOT_NAME_SIZE - 1] = '\0';
+
+  cur_robot->robot_char = vfgetc(vf);
+  cur_robot->cur_prog_line = vfgetw(vf);
+  vfgetw(vf); // Unused high bytes
+  cur_robot->pos_within_line = vfgetc(vf);
+  cur_robot->robot_cycle = vfgetc(vf);
+  cur_robot->cycle_count = vfgetc(vf);
+  cur_robot->bullet_type = vfgetc(vf);
+  cur_robot->is_locked = vfgetc(vf);
+  cur_robot->can_lavawalk = vfgetc(vf);
+  cur_robot->walk_dir = (enum dir)vfgetc(vf);
+  cur_robot->last_touch_dir = (enum dir)vfgetc(vf);
+  cur_robot->last_shot_dir = (enum dir)vfgetc(vf);
+
+  if(!program_v1_length)
+  {
+    create_blank_robot_program(cur_robot);
+    return true;
+  }
+
+  program_v1 = (char *)cmalloc(program_v1_length);
+  if(!vfread(program_v1, program_v1_length, 1, vf))
+  {
+    trace("failed to read v1 program (len %d) @ %d\n", program_v1_length, robot_location);
+    goto err;
+  }
+
+  // Convert v1 program to v2.
+  if(!legacy_convert_v1_program(&program_v2, &program_v2_length,
+   &cur_robot->cur_prog_line, program_v1, program_v1_length))
+  {
+    trace("legacy convert v1 program failed @ %d\n", robot_location);
+    goto err;
+  }
+
+  free(program_v1);
+  program_v1 = NULL;
+
+  if(!validate_legacy_bytecode(&program_v2, &program_v2_length,
+   &cur_robot->cur_prog_line))
+  {
+    trace("validate legacy bytecode failed @ %d\n", robot_location);
+    goto err;
+  }
+
+#ifdef CONFIG_DEBYTECODE
+
+  // TODO: now convert v2 to source. This multi-step conversion
+  // mess should be replaced with a v1 bytecode frontend.
+  cur_robot->program_source =
+   legacy_disassemble_program(program_v2, program_v2_length,
+   &(cur_robot->program_source_length), true, 10);
+
+  if(savegame)
+  {
+    // Translate the legacy current bytecode offset and stack bytecode offsets
+    // into usable new bytecode offsets. This may compile the robot program.
+    translate_robot_bytecode_offsets(mzx_world, cur_robot, file_version);
+  }
+  free(program_v2);
+  program_v2 = NULL;
+
+#else
+
+  cur_robot->program_bytecode = program_v2;
+  cur_robot->program_bytecode_length = program_v2_length;
+  cache_robot_labels(cur_robot);
+
+#endif
+
+  return true;
+
+err:
+  error_message(E_BOARD_ROBOT_CORRUPT, robot_location, NULL);
+  free(program_v1);
+  free(program_v2);
+  cur_robot->used = 0;
+  return false;
+}
+
 struct robot *legacy_load_robot_allocate(struct world *mzx_world, vfile *vf,
  int savegame, int file_version, boolean *truncated)
 {
-  struct robot *cur_robot = cmalloc(sizeof(struct robot));
+  struct robot *cur_robot = (struct robot *)cmalloc(sizeof(struct robot));
 
   cur_robot->stack = NULL;
   cur_robot->label_list = NULL;
@@ -47,6 +147,13 @@ struct robot *legacy_load_robot_allocate(struct world *mzx_world, vfile *vf,
   cur_robot->program_source = NULL;
   cur_robot->num_labels = 0;
 
+  if(file_version < V200)
+  {
+    if(!legacy_load_robot_v1(mzx_world, cur_robot, vf, savegame, file_version))
+      *truncated = true;
+  }
+  else
+
   if(!legacy_load_robot(mzx_world, cur_robot, vf, savegame, file_version))
     *truncated = true;
 
@@ -147,7 +254,7 @@ void legacy_load_robot_from_memory(struct world *mzx_world,
     // Also don't allow stack positions beyond the size of the stack.
     cur_robot->stack_pointer = CLAMP(cur_robot->stack_pointer, 0, stack_size);
 
-    cur_robot->stack = ccalloc(stack_size, sizeof(int));
+    cur_robot->stack = (int *)ccalloc(stack_size, sizeof(int));
     for(i = 0; i < stack_size; i += 2)
     {
       cur_robot->stack[i] = mfgetd(mf);
@@ -182,7 +289,7 @@ void legacy_load_robot_from_memory(struct world *mzx_world,
 
   if((cur_robot->used) || (program_length >= 2))
   {
-    char *program_legacy_bytecode = cmalloc(program_length);
+    char *program_legacy_bytecode = (char *)cmalloc(program_length);
     mfread(program_legacy_bytecode, program_length, 1, mf);
 
     if(!validate_legacy_bytecode(&program_legacy_bytecode, &program_length,
@@ -216,7 +323,7 @@ void legacy_load_robot_from_memory(struct world *mzx_world,
   cur_robot->program_bytecode_length = program_length;
   if(program_length > 0)
   {
-    cur_robot->program_bytecode = cmalloc(program_length);
+    cur_robot->program_bytecode = (char *)cmalloc(program_length);
     mfread(cur_robot->program_bytecode, program_length, 1, mf);
 
     if(!validate_legacy_bytecode(&cur_robot->program_bytecode, &program_length,
@@ -294,13 +401,8 @@ size_t legacy_load_robot_calculate_size(const void *buffer, int savegame,
 
   // First, read the program length (0 bytes in)
   mfopen(buffer, robot_size, &mf);
-  program_length = mfgetd(&mf);
-
-  // Prior to DBC / VERSION_SOURCE the last two bytes are junk
-  #ifdef CONFIG_DEBYTECODE
-  if(version < VERSION_SOURCE)
-  #endif
-    program_length &= 0xFFFF;
+  program_length = mfgetw(&mf);
+  mfgetw(&mf);
 
   // Next, if this is a savegame robot, read the stack size
   if(savegame)
@@ -320,7 +422,7 @@ boolean legacy_load_robot(struct world *mzx_world, struct robot *cur_robot,
 {
   int robot_location = vftell(vf);
   size_t partial_size = legacy_calculate_partial_robot_size(savegame, version);
-  char *buffer = cmalloc(partial_size);
+  char *buffer = (char *)cmalloc(partial_size);
   boolean truncated = true;
   size_t full_size;
 
@@ -354,28 +456,160 @@ boolean legacy_load_robot(struct world *mzx_world, struct robot *cur_robot,
   return !truncated;
 }
 
-static void legacy_load_scroll(struct scroll *cur_scroll, vfile *vf)
+/**
+ * Convert v1 scroll text to scroll text with color code support.
+ *
+ * 1.x uses a bizarre color code hack where lines can start with ![byte].
+ * The entire line will be colored [byte] (including non-text areas) and the
+ * color code will be displayed as two spaces.
+ *
+ * Convert these to Robotic ~@-style color codes, pad their affected lines with
+ * spaces so they display correctly, and escape existing ~@s.
+ */
+static boolean legacy_convert_scroll_v1(struct scroll *cur_scroll)
+{
+  char *old_text = cur_scroll->mesg;
+  char *new_text;
+  size_t old_size = cur_scroll->mesg_size;
+  size_t new_size;
+  size_t new_pos;
+  size_t i;
+
+  new_text = (char *)cmalloc(old_size * 2);
+  new_size = old_size * 2;
+  if(!new_text)
+    goto err;
+
+  new_text[0] = 0x01;
+  new_pos = 1;
+
+  for(i = 1; i < old_size && old_text[i];)
+  {
+    // Start of line.
+    char linebuf[256];
+    int pad = 0;
+    size_t j = 0;
+
+    if(old_text[i] == '!')
+    {
+      // Legacy v1 color code.
+      static const char hex[] = "0123456789abcdef";
+      uint8_t color = old_text[i + 1];
+      if(!color)
+        goto err;
+
+      linebuf[j++] = '~';
+      linebuf[j++] = hex[color & 0xf];
+      linebuf[j++] = '@';
+      linebuf[j++] = hex[color >> 4];
+      linebuf[j++] = ' ';
+      linebuf[j++] = ' ';
+      i += 2;
+      pad = 62;
+    }
+
+    // Direct line copy with escapes for ~ and @.
+    while(old_text[i])
+    {
+      if(j >= sizeof(linebuf) - 3)
+        goto err;
+
+      if(old_text[i] == '\n')
+      {
+        i++;
+        break;
+      }
+
+      if(old_text[i] == '~')
+        linebuf[j++] = '~';
+
+      if(old_text[i] == '@')
+        linebuf[j++] = '@';
+
+      linebuf[j++] = old_text[i++];
+      pad--;
+    }
+    for(; pad > 0; pad--)
+      linebuf[j++] = ' ';
+
+    linebuf[j++] = '\n';
+
+    // Append line (+1 for scroll terminator).
+    if(j + new_pos + 1 > new_size)
+    {
+      char *t;
+      while(j + new_pos + 1 > new_size)
+      {
+        if(new_size > INT_MAX)
+          goto err;
+
+        new_size *= 2;
+      }
+      t = (char *)crealloc(new_text, new_size);
+      if(!t)
+        goto err;
+
+      new_text = t;
+    }
+    memcpy(new_text + new_pos, linebuf, j);
+    new_pos += j;
+  }
+  new_text[new_pos++] = '\0';
+
+  cur_scroll->mesg = (char *)crealloc(new_text, new_pos);
+  cur_scroll->mesg_size = new_pos;
+  if(!cur_scroll->mesg)
+    goto err;
+
+  free(old_text);
+  return true;
+
+err:
+  free(old_text);
+  free(new_text);
+  cur_scroll->mesg = NULL;
+  return false;
+}
+
+static void legacy_load_scroll(struct scroll *cur_scroll, vfile *vf, int file_version)
 {
   int scroll_size;
 
   cur_scroll->mesg = NULL;
   cur_scroll->num_lines = vfgetw(vf);
-  vfgetw(vf); // Skip junk
-  scroll_size = vfgetw(vf);
-  cur_scroll->mesg_size = scroll_size;
-  cur_scroll->used = vfgetc(vf);
 
-  if(scroll_size < 0)
+  if(file_version >= V200)
+  {
+    vfgetw(vf); // Skip junk
+    scroll_size = vfgetw(vf);
+    cur_scroll->used = vfgetc(vf);
+  }
+  else
+  {
+    vfgetd(vf); // Skip junk
+    scroll_size = vfgetd(vf);
+    cur_scroll->used = 1;
+  }
+
+  if(scroll_size < 0 || scroll_size > 65535)
     goto scroll_err;
 
-  cur_scroll->mesg = cmalloc(scroll_size);
+  cur_scroll->mesg_size = scroll_size;
+  cur_scroll->mesg = (char *)cmalloc(scroll_size);
   if(!vfread(cur_scroll->mesg, scroll_size, 1, vf))
     goto scroll_err;
 
   if(scroll_size < 3)
     goto scroll_err;
 
-  cur_scroll->mesg[scroll_size - 1] = '\0';
+  if(file_version < V200)
+  {
+    if(!legacy_convert_scroll_v1(cur_scroll))
+      goto scroll_err;
+  }
+  else
+    cur_scroll->mesg[scroll_size - 1] = '\0';
+
   return;
 
 scroll_err:
@@ -385,18 +619,18 @@ static void legacy_load_scroll(struct scroll *cur_scroll, vfile *vf)
   cur_scroll->used = 1;
 
   free(cur_scroll->mesg);
-  cur_scroll->mesg = cmalloc(3);
+  cur_scroll->mesg = (char *)cmalloc(3);
   strcpy(cur_scroll->mesg, "\x01\x0A");
 }
 
-struct scroll *legacy_load_scroll_allocate(vfile *vf)
+struct scroll *legacy_load_scroll_allocate(vfile *vf, int file_version)
 {
-  struct scroll *cur_scroll = cmalloc(sizeof(struct scroll));
-  legacy_load_scroll(cur_scroll, vf);
+  struct scroll *cur_scroll = (struct scroll *)cmalloc(sizeof(struct scroll));
+  legacy_load_scroll(cur_scroll, vf, file_version);
   return cur_scroll;
 }
 
-static void legacy_load_sensor(struct sensor *cur_sensor, vfile *vf)
+static void legacy_load_sensor(struct sensor *cur_sensor, vfile *vf, int file_version)
 {
   if(!vfread(cur_sensor->sensor_name, LEGACY_ROBOT_NAME_SIZE, 1, vf))
     goto sensor_err;
@@ -408,7 +642,11 @@ static void legacy_load_sensor(struct sensor *cur_sensor, vfile *vf)
 
   cur_sensor->sensor_name[LEGACY_ROBOT_NAME_SIZE - 1] = '\0';
   cur_sensor->robot_to_mesg[LEGACY_ROBOT_NAME_SIZE - 1] = '\0';
-  cur_sensor->used = vfgetc(vf);
+
+  if(file_version >= V200)
+    cur_sensor->used = vfgetc(vf);
+  else
+    cur_sensor->used = 1;
 
   return;
 
@@ -420,9 +658,9 @@ static void legacy_load_sensor(struct sensor *cur_sensor, vfile *vf)
   cur_sensor->used = 1;
 }
 
-struct sensor *legacy_load_sensor_allocate(vfile *vf)
+struct sensor *legacy_load_sensor_allocate(vfile *vf, int file_version)
 {
-  struct sensor *cur_sensor = cmalloc(sizeof(struct sensor));
-  legacy_load_sensor(cur_sensor, vf);
+  struct sensor *cur_sensor = (struct sensor *)cmalloc(sizeof(struct sensor));
+  legacy_load_sensor(cur_sensor, vf, file_version);
   return cur_sensor;
 }
diff --git a/src/legacy_robot.h b/src/legacy_robot.h
index 3dbf6871f..b574ba14c 100644
--- a/src/legacy_robot.h
+++ b/src/legacy_robot.h
@@ -44,9 +44,9 @@ size_t legacy_load_robot_calculate_size(const void *buffer, int savegame,
 boolean legacy_load_robot(struct world *mzx_world, struct robot *cur_robot,
  vfile *vf, int savegame, int version);
 
-struct scroll *legacy_load_scroll_allocate(vfile *vf);
+struct scroll *legacy_load_scroll_allocate(vfile *vf, int file_version);
 
-struct sensor *legacy_load_sensor_allocate(vfile *vf);
+struct sensor *legacy_load_sensor_allocate(vfile *vf, int file_version);
 
 __M_END_DECLS
 
diff --git a/src/legacy_world.c b/src/legacy_world.c
index d26a18e2a..04356727c 100644
--- a/src/legacy_world.c
+++ b/src/legacy_world.c
@@ -48,6 +48,7 @@
 #include "audio/sfx.h"
 
 #define WORLD_GLOBAL_OFFSET_OFFSET 4230
+#define WORLD_V1_BOARD_NUM_OFFSET 4009
 #define WORLD_BLOCK_1_SIZE 4129
 #define WORLD_BLOCK_2_SIZE 72
 #define DECRYPT_BUFFER_SIZE 8192
@@ -61,33 +62,95 @@ static inline void meter_initial_draw(int curr, int target, const char *title) {
 #endif //!CONFIG_LOADSAVE_METER
 
 static inline boolean legacy_load_counter(struct world *mzx_world,
- vfile *vf, struct counter_list *counter_list, int index)
+ vfile *vf, struct counter_list *counter_list, int index, int file_version)
 {
   char name_buffer[ROBOT_MAX_TR];
-  int value = vfgetd(vf);
-  int name_length = vfgetd(vf);
-
-  name_buffer[0] = 0;
-  if(name_length && !vfread(name_buffer, name_length, 1, vf))
-    return false;
+  int name_length;
+  int value;
 
-  // Stupid legacy hacks
-  if(!strncasecmp(name_buffer, "mzx_speed", name_length))
+  if(file_version >= V281)
   {
-    mzx_world->mzx_speed = value;
-    return false;
-  }
+    value = vfgetd(vf);
+    name_length = vfgetd(vf);
+
+    name_buffer[0] = 0;
+    if(name_length && !vfread(name_buffer, name_length, 1, vf))
+      return false;
 
-  if(!strncasecmp(name_buffer, "_____lock_speed", name_length))
+    if(file_version >= V284)
+    {
+      // Stupid legacy hacks
+      if(!strncasecmp(name_buffer, "mzx_speed", name_length))
+      {
+        mzx_world->mzx_speed = value;
+        return false;
+      }
+
+      if(!strncasecmp(name_buffer, "_____lock_speed", name_length))
+      {
+        mzx_world->lock_speed = value;
+        return false;
+      }
+    }
+  }
+  else
   {
-    mzx_world->lock_speed = value;
-    return false;
+    name_length = vfread(name_buffer, 1, 15, vf);
+    name_buffer[name_length] = '\0';
+
+    if(file_version == V280)
+    {
+      // MegaZeux 2.80 used a hacked DOS counter list with dwords.
+      value = vfgetd(vf);
+    }
+    else
+
+    if(file_version >= V200)
+    {
+      // Counters are signed words in DOS 2.x.
+      value = (signed short)vfgetw(vf);
+    }
+    else
+    {
+      // Counters are unsigned words in 1.x.
+      value = vfgetw(vf);
+    }
   }
 
   load_new_counter(counter_list, index, name_buffer, name_length, value);
   return true;
 }
 
+static void legacy_load_counter_list(struct world *mzx_world, vfile *vf,
+ int file_version, int extra)
+{
+  struct counter_list *counter_list;
+  int num_counters;
+  int i;
+  int j;
+
+  num_counters = vfgetd(vf);
+  counter_list = &(mzx_world->counter_list);
+  counter_list->num_counters = num_counters;
+  counter_list->num_counters_allocated = num_counters + extra;
+  counter_list->counters = ccalloc(num_counters + extra, sizeof(struct counter *));
+
+  for(i = 0, j = 0; i < num_counters; i++)
+  {
+    if(!legacy_load_counter(mzx_world, vf, counter_list, j, file_version))
+    {
+      // Remove 2.84 special counters and counters that failed to load.
+      counter_list->num_counters--;
+      continue;
+    }
+    j++;
+  }
+#ifndef CONFIG_COUNTER_HASH_TABLES
+  // Versions without the hash table require these to be sorted at all times.
+  sort_counter_list(counter_list);
+#endif
+}
+
 static inline void legacy_load_string(vfile *vf,
  struct string_list *string_list, int index)
 {
@@ -108,6 +171,28 @@ static inline void legacy_load_string(vfile *vf,
     return;
 }
 
+static void legacy_load_string_list(struct world *mzx_world, vfile *vf,
+ int file_version)
+{
+  struct string_list *string_list;
+  int num_strings;
+  int i;
+
+  num_strings = vfgetd(vf);
+  string_list = &(mzx_world->string_list);
+  string_list->num_strings = num_strings;
+  string_list->num_strings_allocated = num_strings;
+  string_list->strings = ccalloc(num_strings, sizeof(struct string *));
+
+  for(i = 0; i < num_strings; i++)
+    legacy_load_string(vf, string_list, i);
+
+#ifndef CONFIG_COUNTER_HASH_TABLES
+  // Versions without the hash table require these to be sorted at all times.
+  sort_string_list(string_list);
+#endif
+}
+
 static const char magic_code[16] =
  "\xE6\x52\xEB\xF2\x6D\x4D\x4A\xB7\x87\xB2\x92\x88\xDE\x91\x24";
 
@@ -511,8 +596,9 @@ static enum val_result __validate_legacy_world_file(vfile *vf, boolean savegame)
     else
 
     // This enables 2.84 save loading.
-    // If we ever want to remove this, change this check.
-    //if (v < MZX_VERSION)
+    // This can be expanded to even older save files in the future:
+    // 2.00-2.83 saves require various types of surgery to the load functions.
+    // TODO: 1.xx saves are implemented but this function needs an overhaul.
     if(v < MZX_LEGACY_FORMAT_VERSION)
     {
       error_message(E_SAVE_VERSION_OLD, v, NULL);
@@ -613,7 +699,9 @@ static enum val_result __validate_legacy_world_file(vfile *vf, boolean savegame)
       goto err_invalid;
     }
 
-    /* now we should be at the global robot pointer! */
+    /* Global robot pointer */
+    if(vfgetd(vf) < 0)
+      goto err_invalid;
   }
 
   else /* !savegame */
@@ -651,11 +739,11 @@ static enum val_result __validate_legacy_world_file(vfile *vf, boolean savegame)
         if(v != V100)
           goto err_invalid;
 
-        // Can't actually handle 1.x files right now...
-        error_message(E_WORLD_FILE_VERSION_OLD, v, NULL);
-        return VAL_VERSION;
+        vfseek(vf, -3, SEEK_CUR);
       }
-      return VAL_PROTECTED;
+      /* 2.x encrypts locked worlds. */
+      else
+        return VAL_PROTECTED;
     }
 
     /* TEST 5:  Test the magic */
@@ -669,7 +757,7 @@ static enum val_result __validate_legacy_world_file(vfile *vf, boolean savegame)
     }
     else
 
-    if(v < V200)
+    if(v < V100)
     {
       error_message(E_WORLD_FILE_VERSION_OLD, v, NULL);
       return VAL_VERSION;
@@ -682,32 +770,43 @@ static enum val_result __validate_legacy_world_file(vfile *vf, boolean savegame)
       return VAL_VERSION;
     }
 
-    /* TEST 6:  Attempt to eliminate invalid files by
-     * testing the palette for impossible values.
-     */
-    vfseek(vf, WORLD_GLOBAL_OFFSET_OFFSET - 48, SEEK_SET);
-    for(i = 0; i < 48; i++)
+    if(v >= V200)
     {
-      int val = vfgetc(vf);
-      if((val < 0) || (val > 63))
+      /* TEST 6:  Attempt to eliminate invalid files by
+       * testing the palette for impossible values.
+       */
+      vfseek(vf, WORLD_GLOBAL_OFFSET_OFFSET - 48, SEEK_SET);
+      for(i = 0; i < 48; i++)
+      {
+        int val = vfgetc(vf);
+        if(val < 0 || val > 63)
+          goto err_invalid;
+      }
+
+      /* Global robot pointer */
+      if(vfgetd(vf) < 0)
         goto err_invalid;
     }
+    else
+    {
+      /* 1.x doesn't have a palette or global robot pointer to check. */
+      long offset = WORLD_V1_BOARD_NUM_OFFSET;
+      if(protection_method)
+        offset += MAX_PASSWORD_LENGTH + 1;
 
-    /* now we should be at the global robot pointer! */
+      if(vfseek(vf, offset, SEEK_SET))
+        goto err_invalid;
+    }
   }
 
-  /* TEST 7:  Either branch should be at the global robot pointer now.
+  /* TEST 7:  All branches should be at the board count now.
    * Test for valid SFX structure, if applicable, and board information.
    */
-  if(vfgetd(vf) < 0)
-    goto err_invalid;
-
-  // Do the sfx
   num_boards = vfgetc(vf);
-  if(num_boards == 0)
+  if(num_boards == 0 && v >= V200)
   {
     int sfx_size = vfgetw(vf);
-    int sfx_off = vftell(vf);
+    int sfx_read = 0;
     int cur_sfx_size;
 
     for(i = 0; i < NUM_BUILTIN_SFX; i++)
@@ -718,9 +817,11 @@ static enum val_result __validate_legacy_world_file(vfile *vf, boolean savegame)
 
       if(vfseek(vf, cur_sfx_size, SEEK_CUR))
         break;
+
+      sfx_read += cur_sfx_size + 1;
     }
 
-    if((i != NUM_BUILTIN_SFX) || ((vftell(vf) - sfx_off) != sfx_size))
+    if(i != NUM_BUILTIN_SFX || sfx_read != sfx_size)
       goto err_invalid;
 
     num_boards = vfgetc(vf);
@@ -728,16 +829,14 @@ static enum val_result __validate_legacy_world_file(vfile *vf, boolean savegame)
   if(num_boards <= 0)
     goto err_invalid;
 
-  board_name_offset = vftell(vf);
+  // Read the last board size and pointer to make sure the board table exists.
+  board_name_offset = num_boards * (LEGACY_BOARD_NAME_SIZE + 8) - 8;
 
-  //Make sure board name and pointer data exists
-  if(
-   vfseek(vf, num_boards * LEGACY_BOARD_NAME_SIZE, SEEK_CUR) ||
-   vfseek(vf, num_boards * 8, SEEK_CUR) ||
-   ((vftell(vf) - board_name_offset) != num_boards * (LEGACY_BOARD_NAME_SIZE + 8)))
+  if(vfseek(vf, board_name_offset, SEEK_CUR))
     goto err_invalid;
 
-  //todo: maybe have a complete fail when N number of pointers fail?
+  if(vfgetd(vf) == EOF || vfgetd(vf) == EOF)
+    goto err_invalid;
 
   return VAL_SUCCESS;
 
@@ -813,6 +912,264 @@ vfile *validate_legacy_world_file(struct world *mzx_world,
   return NULL;
 }
 
+/**
+ * Common v1 and v2 board list loader.
+ */
+static void legacy_load_world_boards(struct world *mzx_world, vfile *vf,
+ boolean savegame, int file_version, int num_boards)
+{
+  unsigned int *board_offsets;
+  unsigned int *board_sizes;
+  long board_names_pos;
+  int i;
+
+  int meter_target = 2 + num_boards;
+  int meter_curr = 0;
+
+  meter_update_screen(&meter_curr, meter_target);
+
+  mzx_world->num_boards = num_boards;
+  mzx_world->num_boards_allocated = num_boards;
+  mzx_world->board_list = cmalloc(sizeof(struct board *) * num_boards);
+
+  // Skip the names for now
+  board_names_pos = vftell(vf);
+  vfseek(vf, num_boards * LEGACY_BOARD_NAME_SIZE, SEEK_CUR);
+
+  // Read the board offsets/sizes preemptively to reduce the amount of seeking.
+  board_offsets = cmalloc(sizeof(int) * num_boards);
+  board_sizes = cmalloc(sizeof(int) * num_boards);
+  for(i = 0; i < num_boards; i++)
+  {
+    board_sizes[i] = vfgetd(vf);
+    board_offsets[i] = vfgetd(vf);
+  }
+
+  for(i = 0; i < num_boards; i++)
+  {
+    mzx_world->board_list[i] =
+     legacy_load_board_allocate(mzx_world, vf, board_offsets[i], board_sizes[i],
+      savegame, file_version);
+
+    if(mzx_world->board_list[i])
+    {
+      // Also patch a pointer to the global robot
+      if(mzx_world->board_list[i]->robot_list)
+        (mzx_world->board_list[i])->robot_list[0] = &mzx_world->global_robot;
+
+      // Also optimize out null objects
+      optimize_null_objects(mzx_world->board_list[i]);
+
+      store_board_to_extram(mzx_world->board_list[i]);
+    }
+
+    meter_update_screen(&meter_curr, meter_target);
+  }
+
+  free(board_offsets);
+  free(board_sizes);
+
+  // Go back to where the names are
+  vfseek(vf, board_names_pos, SEEK_SET);
+  for(i = 0; i < num_boards; i++)
+  {
+    char ignore[LEGACY_BOARD_NAME_SIZE];
+    char *board_name = ignore;
+
+    if(mzx_world->board_list[i])
+      board_name = mzx_world->board_list[i]->board_name;
+
+    if(!vfread(board_name, LEGACY_BOARD_NAME_SIZE, 1, vf))
+      board_name[0] = 0;
+
+    board_name[LEGACY_BOARD_NAME_SIZE - 1] = '\0';
+  }
+}
+
+/**
+ * Load a world in the extremely legacy 1.x world format.
+ */
+static void legacy_load_world_v1(struct world *mzx_world, vfile *vf, const char *file,
+ boolean savegame, int file_version, char *name, boolean *faded)
+{
+  static const uint8_t v1_id_dmg[ID_DMG_SIZE] =
+  {
+    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, /* 0x0? */
+    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,100,  0,  0,  0,  0,  0, /* 0x1? */
+    0,  0,  0,  0,  0,  0,  5,  0,  0,  0,  0,  0,  0,  0,  0,  0, /* 0x2? */
+    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 10,  0, 10,  5,  5, /* 0x3? */
+    0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 10, 10,  0, 10, 10, /* 0x4? */
+    10, 0,  0, 10, 10, 10, 10, 10, 10, 10, 10, 10,  0,  0, 10, 10, /* 0x5? */
+  };
+
+  unsigned char *charset_mem;
+  int protection_method;
+  int num_boards;
+  long offset;
+  int score;
+  int i;
+  char buf[4];
+
+  int meter_target = 2, meter_curr = 0;
+
+  mzx_world->version = file_version;
+  mzx_world->current_board_id = 0;
+
+  if(savegame)
+  {
+    vfseek(vf, 5, SEEK_SET);
+    mzx_world->version = file_version;
+    mzx_world->current_board_id = vfgetc(vf);
+  }
+  else
+  {
+    strcpy(mzx_world->name, name);
+
+    vfseek(vf, BOARD_NAME_SIZE, SEEK_SET);
+    protection_method = vfgetc(vf);
+
+    offset = BOARD_NAME_SIZE + 1 + 3;
+    if(protection_method)
+      offset += MAX_PASSWORD_LENGTH + 1;
+    vfseek(vf, offset, SEEK_SET);
+  }
+
+  meter_initial_draw(meter_curr, meter_target, "Loading...");
+
+  charset_mem = cmalloc(CHAR_SIZE * CHARSET_SIZE);
+  if(!vfread(charset_mem, CHAR_SIZE * CHARSET_SIZE, 1, vf))
+  {
+    free(charset_mem);
+    goto err_close;
+  }
+  ec_clear_set();
+  ec_mem_load_set(charset_mem, CHAR_SIZE * CHARSET_SIZE);
+  free(charset_mem);
+
+  // id_chars.
+  memset(id_chars, 0, ID_CHARS_SIZE);
+  memcpy(id_dmg, v1_id_dmg, ID_DMG_SIZE);
+  memset(bullet_color, 0, ID_BULLET_COLOR_SIZE);
+
+  if(!vfread(id_chars, 306, 1, vf))
+    goto err_close;
+  // Goop didn't exist in 1.x.
+  id_chars[GOOP] = 176;
+
+  if(savegame)
+  {
+    if(!vfread(mzx_world->keys, NUM_KEYS, 1, vf))
+      goto err_close;
+  }
+
+  // Status counters.
+  if(vfread((char *)mzx_world->status_counters_shown, COUNTER_NAME_SIZE, 4, vf) != 4)
+    goto err_close;
+
+  for(i = 0; i < 4; i++)
+    mzx_world->status_counters_shown[i][COUNTER_NAME_SIZE - 1] = '\0';
+  for(; i < NUM_STATUS_COUNTERS; i++)
+    mzx_world->status_counters_shown[i][0] = '\0';
+
+  // Junk that was later moved to id_chars.
+  if(!vfread(buf, 4, 1, vf))
+    goto err_close;
+  memcpy(id_chars + bullet_char, buf, 4);
+  memcpy(id_chars + bullet_char + 4, buf, 4);
+  memcpy(id_chars + bullet_char + 8, buf, 4);
+  buf[0] = vfgetc(vf);
+  memset(id_chars + player_char, buf[0], 4);
+
+  // Saved position.
+  memset(mzx_world->pl_saved_x, 0, sizeof(mzx_world->pl_saved_x));
+  memset(mzx_world->pl_saved_y, 0, sizeof(mzx_world->pl_saved_y));
+  memset(mzx_world->pl_saved_board, 0, sizeof(mzx_world->pl_saved_board));
+  mzx_world->pl_saved_x[0] = vfgetc(vf);
+  mzx_world->pl_saved_y[0] = vfgetc(vf);
+  mzx_world->pl_saved_board[0] = vfgetc(vf);
+
+  // Global info.
+  mzx_world->edge_color = vfgetc(vf);
+
+  // More junk that was later moved to id_chars.
+  id_chars[player_color] = vfgetc(vf);
+  i = vfgetc(vf);
+  memset(bullet_color, i, sizeof(bullet_color));
+  missile_color = vfgetc(vf);
+
+  if(savegame)
+  {
+    mzx_world->scroll_base_color = vfgetc(vf);
+    mzx_world->scroll_corner_color = vfgetc(vf);
+    mzx_world->scroll_pointer_color = vfgetc(vf);
+    mzx_world->scroll_title_color = vfgetc(vf);
+    mzx_world->scroll_arrow_color = vfgetc(vf);
+    score = vfgetd(vf);
+  }
+
+  // Global info.
+  mzx_world->first_board = vfgetc(vf);
+  mzx_world->endgame_board = vfgetc(vf);
+  mzx_world->death_board = vfgetc(vf);
+  mzx_world->endgame_x = vfgetc(vf);
+  mzx_world->endgame_y = vfgetc(vf);
+  mzx_world->death_x = vfgetc(vf);
+  mzx_world->death_y = vfgetc(vf);
+  mzx_world->starting_lives = vfgetw(vf);
+  mzx_world->lives_limit = vfgetw(vf);
+  mzx_world->starting_health = vfgetw(vf);
+  mzx_world->health_limit = vfgetw(vf);
+  mzx_world->enemy_hurt_enemy = vfgetc(vf);
+  mzx_world->clear_on_exit = 0;
+  mzx_world->only_from_swap = 0;
+  mzx_world->game_over_sfx = vfgetc(vf);
+  vfgetc(vf); // unused
+
+  // Fix special values for these.
+  if(mzx_world->endgame_board >= 128)
+    mzx_world->endgame_board = NO_ENDGAME_BOARD;
+
+  if(mzx_world->death_board >= 129)
+    mzx_world->death_board = DEATH_SAME_POS;
+  else
+  if(mzx_world->death_board == 128)
+    mzx_world->death_board = NO_DEATH_BOARD;
+
+  if(savegame)
+  {
+    // Counter list.
+    // Allocate 1 extra for the score.
+    legacy_load_counter_list(mzx_world, vf, file_version, 1);
+
+    // Patch in the score.
+    set_counter(mzx_world, "SCORE", score, 0);
+  }
+
+  // No custom palette or global robot in 1.x.
+  *faded = 0;
+  default_palette();
+  create_blank_robot(&mzx_world->global_robot);
+  create_blank_robot_program(&mzx_world->global_robot);
+
+  // Board list is the same as 2.x, though the board structs are different.
+  num_boards = vfgetc(vf);
+  legacy_load_world_boards(mzx_world, vf, savegame, file_version, num_boards);
+
+  meter_restore_screen();
+  vfclose(vf);
+  return;
+
+err_close:
+  // Note that this file had already been successfully validated for length
+  // and opened with no issue before this error occurred, and that the only
+  // way to reach this error is a failed fread before any board/robot data
+  // was loaded. Something seriously went wrong somewhere.
+
+  error_message(E_IO_READ, 0, NULL);
+  meter_restore_screen();
+  vfclose(vf);
+}
+
 /**
  * Load a world or save file from the legacy world format.
  * This will close the provided vfile handle.
@@ -822,16 +1179,19 @@ void legacy_load_world(struct world *mzx_world, vfile *vf, const char *file,
 {
   int i;
   int num_boards;
-  int global_robot_pos, board_names_pos;
+  int global_robot_pos;
   unsigned char *charset_mem;
   unsigned char r, g, b;
-  struct counter_list *counter_list;
-  struct string_list *string_list;
-  unsigned int *board_offsets;
-  unsigned int *board_sizes;
 
   int meter_target = 2, meter_curr = 0;
 
+  if(file_version < V200)
+  {
+    /* Too many differences to properly version here :( */
+    legacy_load_world_v1(mzx_world, vf, file, savegame, file_version, name, faded);
+    return;
+  }
+
   if(savegame)
   {
     vfseek(vf, 5, SEEK_SET);
@@ -850,7 +1210,10 @@ void legacy_load_world(struct world *mzx_world, vfile *vf, const char *file,
 
   charset_mem = cmalloc(CHAR_SIZE * CHARSET_SIZE);
   if(!vfread(charset_mem, CHAR_SIZE * CHARSET_SIZE, 1, vf))
+  {
+    free(charset_mem);
     goto err_close;
+  }
   ec_clear_set();
   ec_mem_load_set(charset_mem, CHAR_SIZE * CHARSET_SIZE);
   free(charset_mem);
@@ -965,9 +1328,7 @@ void legacy_load_world(struct world *mzx_world, vfile *vf, const char *file,
   if(savegame)
   {
     unsigned int vlayer_size;
-    int num_counters, num_strings;
     int screen_mode;
-    int j;
 
     for(i = 0; i < 16; i++)
     {
@@ -983,45 +1344,11 @@ void legacy_load_world(struct world *mzx_world, vfile *vf, const char *file,
     mzx_world->under_player_param = vfgetc(vf);
 
     // Read counters
-    num_counters = vfgetd(vf);
-    counter_list = &(mzx_world->counter_list);
-    counter_list->num_counters = num_counters;
-    counter_list->num_counters_allocated = num_counters;
-    counter_list->counters = ccalloc(num_counters, sizeof(struct counter *));
-
-    for(i = 0, j = 0; i < num_counters; i++)
-    {
-      boolean counter = legacy_load_counter(mzx_world, vf, counter_list, j);
-
-      /* We loaded a special counter, this doesn't need to be
-       * loaded into the regular list.
-       */
-      if(!counter)
-      {
-        counter_list->num_counters--;
-        continue;
-      }
+    legacy_load_counter_list(mzx_world, vf, file_version, 0);
 
-      j++;
-    }
-
-    // Read strings
-    num_strings = vfgetd(vf);
-    string_list = &(mzx_world->string_list);
-    string_list->num_strings = num_strings;
-    string_list->num_strings_allocated = num_strings;
-    string_list->strings = ccalloc(num_strings, sizeof(struct string *));
-
-    for(i = 0; i < num_strings; i++)
-    {
-      legacy_load_string(vf, string_list, i);
-    }
-
-#ifndef CONFIG_COUNTER_HASH_TABLES
-    // Versions without the hash table require these to be sorted at all times
-    sort_counter_list(counter_list);
-    sort_string_list(string_list);
-#endif
+    // Read strings (2.80 and up; DOS handled this differently)
+    if(file_version >= V280)
+      legacy_load_string_list(mzx_world, vf, file_version);
 
     // Sprite data
     for(i = 0; i < MAX_SPRITES; i++)
@@ -1158,49 +1485,7 @@ void legacy_load_world(struct world *mzx_world, vfile *vf, const char *file,
     mzx_world->custom_sfx_on = 0;
   }
 
-  meter_target += num_boards;
-  meter_update_screen(&meter_curr, meter_target);
-
-  mzx_world->num_boards = num_boards;
-  mzx_world->num_boards_allocated = num_boards;
-  mzx_world->board_list = cmalloc(sizeof(struct board *) * num_boards);
-
-  // Skip the names for now
-  board_names_pos = vftell(vf);
-  vfseek(vf, num_boards * LEGACY_BOARD_NAME_SIZE, SEEK_CUR);
-
-  // Read the board offsets/sizes preemptively to reduce the amount of seeking.
-  board_offsets = cmalloc(sizeof(int) * num_boards);
-  board_sizes = cmalloc(sizeof(int) * num_boards);
-  for(i = 0; i < num_boards; i++)
-  {
-    board_sizes[i] = vfgetd(vf);
-    board_offsets[i] = vfgetd(vf);
-  }
-
-  for(i = 0; i < num_boards; i++)
-  {
-    mzx_world->board_list[i] =
-     legacy_load_board_allocate(mzx_world, vf, board_offsets[i], board_sizes[i],
-      savegame, file_version);
-
-    if(mzx_world->board_list[i])
-    {
-      // Also patch a pointer to the global robot
-      if(mzx_world->board_list[i]->robot_list)
-        (mzx_world->board_list[i])->robot_list[0] = &mzx_world->global_robot;
-
-      // Also optimize out null objects
-      optimize_null_objects(mzx_world->board_list[i]);
-
-      store_board_to_extram(mzx_world->board_list[i]);
-    }
-
-    meter_update_screen(&meter_curr, meter_target);
-  }
-
-  free(board_offsets);
-  free(board_sizes);
+  legacy_load_world_boards(mzx_world, vf, savegame, file_version, num_boards);
 
   // Read global robot
   vfseek(vf, global_robot_pos, SEEK_SET); //don't worry if this fails
@@ -1210,23 +1495,6 @@ void legacy_load_world(struct world *mzx_world, vfile *vf, const char *file,
   // Some old worlds have the global_robot marked unused. Always mark it used.
   mzx_world->global_robot.used = 1;
 
-  // Go back to where the names are
-  vfseek(vf, board_names_pos, SEEK_SET);
-  for(i = 0; i < num_boards; i++)
-  {
-    char ignore[LEGACY_BOARD_NAME_SIZE];
-    char *board_name = ignore;
-
-    if(mzx_world->board_list[i])
-      board_name = mzx_world->board_list[i]->board_name;
-
-    if(!vfread(board_name, LEGACY_BOARD_NAME_SIZE, 1, vf))
-      board_name[0] = 0;
-
-    board_name[LEGACY_BOARD_NAME_SIZE - 1] = '\0';
-  }
-
-  meter_update_screen(&meter_curr, meter_target);
   meter_restore_screen();
   vfclose(vf);
   return;
diff --git a/src/utils/checkres.c b/src/utils/checkres.c
index a2c35043d..3f32c8b97 100644
--- a/src/utils/checkres.c
+++ b/src/utils/checkres.c
@@ -127,6 +127,7 @@
 
 #define LEGACY_WORLD_PROTECTED_OFFSET      BOARD_NAME_SIZE
 #define LEGACY_WORLD_GLOBAL_OFFSET_OFFSET  4230
+#define LEGACY_WORLD_BOARD_COUNT_100       4009
 
 #define MAX_PATH_DEPTH 10
 
@@ -175,7 +176,7 @@ enum status
   MALLOC_FAILED,
   PROTECTED_WORLD,
   MAGIC_CHECK_FAILED,
-  MZX_100_NOT_SUPPORTED,
+  BAD_100_PASSWORD,
   DIRENT_FAILED,
   ZIP_FAILED,
   NO_WORLD,
@@ -209,9 +210,9 @@ static const char *decode_status(enum status status)
     case PROTECTED_WORLD:
       return "Protected worlds currently unsupported.";
     case MAGIC_CHECK_FAILED:
-      return "File magic not consistent with 2.00 world or board.";
-    case MZX_100_NOT_SUPPORTED:
-      return "Worlds from MegaZeux 1.xx are not supported by this utility.";
+      return "File magic not consistent with MZX world or board.";
+    case BAD_100_PASSWORD:
+      return "Invalid version 1.x password length.";
     case DIRENT_FAILED:
       return "Failed to read a required directory.";
     case ZIP_FAILED:
@@ -925,7 +926,11 @@ struct base_file
 {
   char file_name[MAX_PATH];
   char relative_path[MAX_PATH];
+  char password[16];
+  int password_length;
+  int protection_method;
   int world_version;
+  int file_version;
 };
 
 struct resource
@@ -1706,7 +1711,7 @@ static enum status parse_sfx(char *sfx_buf, struct base_file *file,
     *start = 0;
     *end = 0;
 
-    trace("SFX (class): %s\n", start + 1);
+    trace("  SFX: %s\n", start + 1);
     add_requirement_sfx(start + 1, file, board_num, robot_num, line_num);
   }
 
@@ -1714,14 +1719,78 @@ static enum status parse_sfx(char *sfx_buf, struct base_file *file,
 }
 
 #define match(s, reqv) ((world_version >= reqv) && \
- (fn_len == sizeof(s)-1) && (!strcasecmp(function_counter, s)))
+ (fn_len == (ssize_t)sizeof(s)-1) && (!strcasecmp(function_counter, s)))
 
 #define match_partial(s, reqv) ((world_version >= reqv) && \
- (fn_len >= sizeof(s)-1) && (!strncasecmp(function_counter, s, sizeof(s)-1)))
+ (fn_len >= (ssize_t)sizeof(s)-1) && (!strncasecmp(function_counter, s, sizeof(s)-1)))
 
 #define TERMINATE(s,slen) \
  do{ if(slen && s[slen - 1] == '\0') slen--; else s[slen]='\0'; }while(0)
 
+/* Get an int16 param (1.x and 2.x). */
+static int param_int(struct memfile *mf, struct base_file *file)
+{
+  if(file->file_version >= V200)
+  {
+    size_t len = mfgetc(mf);
+    if(len != 0)
+    {
+      mfseek(mf, len, SEEK_CUR);
+      return INT_MIN;
+    }
+  }
+  return mfgetw(mf);
+}
+
+/* Get a null-terminated string param (1.x and 2.x). */
+static ssize_t param_string(char *dest, size_t dest_len,
+ struct memfile *mf, struct base_file *file)
+{
+  size_t len;
+
+  if(file->file_version >= V200)
+  {
+    len = mfgetc(mf);
+    if(len == 0)
+    {
+      // Skip int.
+      mfgetw(mf);
+      dest[0] = '\0';
+      return 0;
+    }
+
+    if(!mfread(dest, len, 1, mf))
+      return -1;
+
+    // Don't trust the program's null termination.
+    TERMINATE(dest, len);
+  }
+  else
+  {
+    // Null-terminated string parameter with no prefixed length.
+    unsigned char *pos;
+
+    for(pos = mf->current; pos < mf->end && *pos; pos++);
+    len = pos - mf->current;
+
+    if(pos >= mf->end || len + 1 > dest_len)
+      return -1;
+
+    if(!mfread(dest, len + 1, 1, mf))
+      return -1;
+
+    dest[len] = '\0';
+  }
+  return len;
+}
+
+/* Skip a param (2.x only). */
+static void param_skip(struct memfile *mf, struct base_file *file)
+{
+  int len = mfgetc(mf);
+  mfseek(mf, len ? len : 2, SEEK_CUR);
+}
+
 static enum status parse_legacy_bytecode(struct memfile *mf,
  unsigned int program_size, struct base_file *file, int board_num, int robot_num)
 {
@@ -1732,10 +1801,10 @@ static enum status parse_legacy_bytecode(struct memfile *mf,
   int line_num = 0;
 
   char function_counter[256];
-  size_t fn_len;
+  ssize_t fn_len;
 
   char src[256];
-  size_t src_len;
+  ssize_t src_len;
 
   // skip 0xff marker
   if(mfgetc(mf) != 0xff)
@@ -1765,34 +1834,30 @@ static enum status parse_legacy_bytecode(struct memfile *mf,
     {
       case 10: // ROBOTIC_CMD_SET
       {
-        src_len = mfgetc(mf);
-
-        if(mfread(src, 1, src_len, mf) != src_len)
+        // File-based SET commands were introduced starting in MegaZeux 2.6.
+        if(file->world_version < V260)
         {
-          warnhere("Truncated command\n");
-          return CORRUPT_WORLD;
+          mfseek(mf, command_length - 1, SEEK_CUR);
+          break;
         }
-        // Don't trust null termination from data read in
-        TERMINATE(src, src_len);
 
-        fn_len = mfgetc(mf);
-
-        // Int parameter
-        if(fn_len == 0)
+        // Destination
+        src_len = param_string(src, sizeof(src), mf, file);
+        if(src_len < 0)
         {
-          mfgetw(mf);
-          break;
+          warnhere("Truncated command\n");
+          return CORRUPT_WORLD;
         }
 
-        // String parameter
-        if(mfread(function_counter, 1, fn_len, mf) != fn_len)
+        // Parameter
+        fn_len = param_string(function_counter, sizeof(function_counter), mf, file);
+        if(fn_len < 0)
         {
           warnhere("Truncated command\n");
           return CORRUPT_WORLD;
         }
-        // Don't trust null termination from data read in
-        TERMINATE(function_counter, fn_len);
 
+        // Parameter is integer or empty string?
         if(fn_len == 0)
           break;
 
@@ -1804,7 +1869,7 @@ static enum status parse_legacy_bytecode(struct memfile *mf,
          || match_partial("LOAD_BC", V270)
          || match_partial("LOAD_ROBOT", V270))
         {
-          trace("SET: %s (%s)\n", src, function_counter);
+          trace("  SET: %s (%s)\n", src, function_counter);
           add_requirement_robot(src, file, board_num, robot_num, line_num);
           break;
         }
@@ -1817,7 +1882,7 @@ static enum status parse_legacy_bytecode(struct memfile *mf,
          || match_partial("SAVE_BC", V270)
          || match_partial("SAVE_ROBOT", V270))
         {
-          trace("SET: %s (%s)\n", src, function_counter);
+          trace("  SET: %s (%s)\n", src, function_counter);
           add_resource(src, file);
           break;
         }
@@ -1827,7 +1892,7 @@ static enum status parse_legacy_bytecode(struct memfile *mf,
           // Maximum version
           if(world_version < V290)
           {
-            trace("SET: %s (%s)\n", src, function_counter);
+            trace("  SET: %s (%s)\n", src, function_counter);
             add_resource(src, file);
           }
           break;
@@ -1839,15 +1904,12 @@ static enum status parse_legacy_bytecode(struct memfile *mf,
       case 38: // ROBOTIC_CMD_MOD
       {
         // Filename
-        src_len = mfgetc(mf);
-
-        if(mfread(src, 1, src_len, mf) != src_len)
+        src_len = param_string(src, sizeof(src), mf, file);
+        if(src_len < 0)
         {
           warnhere("Truncated command\n");
           return CORRUPT_WORLD;
         }
-        // Don't trust null termination from data read in
-        TERMINATE(src, src_len);
 
         // ignore MOD "", MOD "*"
         if(!src_len || !strcmp(src, "*"))
@@ -1857,33 +1919,25 @@ static enum status parse_legacy_bytecode(struct memfile *mf,
         if(src[src_len - 1] == '*')
           src[src_len - 1] = 0;
 
-        trace("MOD: %s\n", src);
+        trace("  MOD: %s\n", src);
         add_requirement_robot(src, file, board_num, robot_num, line_num);
         break;
       }
 
       case 39: // ROBOTIC_CMD_SAM
       {
-        // Frequency
-        src_len = mfgetc(mf);
-
-        if(src_len == 0)
-          mfgetw(mf);
-        else
-          mfseek(mf, src_len, SEEK_CUR);
+        // Period
+        param_int(mf, file);
 
         // Filename
-        src_len = mfgetc(mf);
-
-        if(mfread(src, 1, src_len, mf) != src_len)
+        src_len = param_string(src, sizeof(src), mf, file);
+        if(src_len < 0)
         {
           warnhere("Truncated command\n");
           return CORRUPT_WORLD;
         }
-        // Don't trust null termination from data read in
-        TERMINATE(src, src_len);
 
-        trace("SAM: %s\n", src);
+        trace("  SAM: %s\n", src);
         add_requirement_robot(src, file, board_num, robot_num, line_num);
         break;
       }
@@ -1893,15 +1947,12 @@ static enum status parse_legacy_bytecode(struct memfile *mf,
       case 49: // ROBOTIC_CMD_PLAY_IF_SILENT
       {
         // Play string
-        src_len = mfgetc(mf);
-
-        if(mfread(src, 1, src_len, mf) != src_len)
+        src_len = param_string(src, sizeof(src), mf, file);
+        if(src_len < 0)
         {
           warnhere("Truncated command\n");
           return CORRUPT_WORLD;
         }
-        // Don't trust null termination from data read in
-        TERMINATE(src, src_len);
 
         ret = parse_sfx(src, file, board_num, robot_num, line_num);
         if(ret != SUCCESS)
@@ -1911,71 +1962,56 @@ static enum status parse_legacy_bytecode(struct memfile *mf,
 
       case 79: // ROBOTIC_CMD_PUT_XY
       {
-        // Filename... maybe.
-        src_len = mfgetc(mf);
+        int id;
+        // MZMs were introduced in MegaZeux 2.68.
+        if(file->world_version < V268)
+        {
+          mfseek(mf, command_length - 1, SEEK_CUR);
+          break;
+        }
 
+        // Filename... maybe.
+        src_len = param_string(src, sizeof(src), mf, file);
         if(src_len != 0)
         {
-          if(mfread(src, 1, src_len, mf) != src_len)
+          if(src_len < 0)
           {
             warnhere("Truncated command\n");
             return CORRUPT_WORLD;
           }
-          // Don't trust null termination from data read in
-          TERMINATE(src, src_len);
-
-          fn_len = mfgetc(mf);
 
           // Thing
-          if(fn_len == 0)
+          id = param_int(mf, file);
+          if(id < 0)
           {
-            if(mfgetw(mf) == IMAGE_FILE && src[0] == '@')
-            {
-              trace("PUT @file: %s\n", src + 1);
-              add_requirement_robot(src + 1, file, board_num, robot_num,
-               line_num);
-            }
+            warnhere("Invalid parameter\n");
+            return CORRUPT_WORLD;
           }
-          else
+
+          if(id == IMAGE_FILE && src[0] == '@')
           {
-            mfseek(mf, fn_len, SEEK_CUR);
+            trace("  PUT @file: %s\n", src + 1);
+            add_requirement_robot(src + 1, file, board_num, robot_num, line_num);
           }
         }
         else
-        {
-          mfgetw(mf);
-
-          // Thing
-          src_len = mfgetc(mf);
-          mfseek(mf, src_len ? src_len : 2, SEEK_CUR);
-        }
-
-        // Param
-        src_len = mfgetc(mf);
-        mfseek(mf, src_len ? src_len : 2, SEEK_CUR);
+          param_skip(mf, file); // thing
 
-        // x
-        src_len = mfgetc(mf);
-        mfseek(mf, src_len ? src_len : 2, SEEK_CUR);
-
-        // y
-        src_len = mfgetc(mf);
-        mfseek(mf, src_len ? src_len : 2, SEEK_CUR);
+        param_skip(mf, file); // param
+        param_skip(mf, file); // x
+        param_skip(mf, file); // y
         break;
       }
 
       case 200: // ROBOTIC_CMD_MOD_FADE_IN
       {
         // Filename
-        src_len = mfgetc(mf);
-
-        if(mfread(src, 1, src_len, mf) != src_len)
+        src_len = param_string(src, sizeof(src), mf, file);
+        if(src_len < 0)
         {
           warnhere("Truncated command\n");
           return CORRUPT_WORLD;
         }
-        // Don't trust null termination from data read in
-        TERMINATE(src, src_len);
 
         // ignore MOD "", MOD "*"
         if(!src_len || !strcmp(src, "*"))
@@ -1985,55 +2021,43 @@ static enum status parse_legacy_bytecode(struct memfile *mf,
         if(src[src_len - 1] == '*')
           src[src_len - 1] = 0;
 
-        trace("MOD FADE IN: %s\n", src);
+        trace("  MOD FADE IN: %s\n", src);
         add_requirement_robot(src, file, board_num, robot_num, line_num);
         break;
       }
 
       case 201: // ROBOTIC_CMD_COPY_BLOCK
       {
-        // x1
-        src_len = mfgetc(mf);
-        mfseek(mf, src_len ? src_len : 2, SEEK_CUR);
-
-        // y1
-        src_len = mfgetc(mf);
-        mfseek(mf, src_len ? src_len : 2, SEEK_CUR);
-
-        // w
-        src_len = mfgetc(mf);
-        mfseek(mf, src_len ? src_len : 2, SEEK_CUR);
+        // MZMs were introduced in MegaZeux 2.68.
+        if(file->world_version < V268)
+        {
+          mfseek(mf, command_length - 1, SEEK_CUR);
+          break;
+        }
 
-        // h
-        src_len = mfgetc(mf);
-        mfseek(mf, src_len ? src_len : 2, SEEK_CUR);
+        param_skip(mf, file); // x1
+        param_skip(mf, file); // y1
+        param_skip(mf, file); // w
+        param_skip(mf, file); // h
 
         // x2 or @filename
-        src_len = mfgetc(mf);
+        src_len = param_string(src, sizeof(src), mf, file);
         if(src_len != 0)
         {
-          if(mfread(src, 1, src_len, mf) != src_len)
+          if(src_len < 0)
           {
             warnhere("Truncated command\n");
             return CORRUPT_WORLD;
           }
-          // Don't trust null termination from data read in
-          TERMINATE(src, src_len);
 
           if(src[0] == '@')
           {
-            trace("COPY BLOCK @file: %s\n", src + 1);
+            trace("  COPY BLOCK @file: %s\n", src + 1);
             add_resource(src + 1, file);
           }
         }
-        else
-        {
-          mfseek(mf, src_len ? src_len : 2, SEEK_CUR);
-        }
 
-        // y2
-        src_len = mfgetc(mf);
-        mfseek(mf, src_len ? src_len : 2, SEEK_CUR);
+        param_skip(mf, file); // y2
         break;
       }
 
@@ -2042,15 +2066,12 @@ static enum status parse_legacy_bytecode(struct memfile *mf,
         const char *rest = src;
 
         // Filename
-        src_len = mfgetc(mf);
-
-        if(mfread(src, 1, src_len, mf) != src_len)
+        src_len = param_string(src, sizeof(src), mf, file);
+        if(src_len < 0)
         {
           warnhere("Truncated command\n");
           return CORRUPT_WORLD;
         }
-        // Don't trust null termination from data read in
-        TERMINATE(src, src_len);
 
         if(src[0] == '+')
         {
@@ -2106,7 +2127,7 @@ static enum status parse_legacy_bytecode(struct memfile *mf,
             rest = src;
         }
 
-        trace("LOAD CHAR SET: %s\n", rest);
+        trace("  LOAD CHAR SET: %s\n", rest);
         add_requirement_robot(rest, file, board_num, robot_num, line_num);
         break;
       }
@@ -2114,17 +2135,14 @@ static enum status parse_legacy_bytecode(struct memfile *mf,
       case 222: // ROBOTIC_CMD_LOAD_PALETTE
       {
         // Filename
-        src_len = mfgetc(mf);
-
-        if(mfread(src, 1, src_len, mf) != src_len)
+        src_len = param_string(src, sizeof(src), mf, file);
+        if(src_len < 0)
         {
           warnhere("Truncated command\n");
           return CORRUPT_WORLD;
         }
-        // Don't trust null termination from data read in
-        TERMINATE(src, src_len);
 
-        trace("LOAD PALETTE: %s\n", src);
+        trace("  LOAD PALETTE: %s\n", src);
         add_requirement_robot(src, file, board_num, robot_num, line_num);
         break;
       }
@@ -2132,17 +2150,14 @@ static enum status parse_legacy_bytecode(struct memfile *mf,
       case 226: // ROBOTIC_CMD_SWAP_WORLD
       {
         // Filename
-        src_len = mfgetc(mf);
-
-        if(mfread(src, 1, src_len, mf) != src_len)
+        src_len = param_string(src, sizeof(src), mf, file);
+        if(src_len < 0)
         {
           warnhere("Truncated command\n");
           return CORRUPT_WORLD;
         }
-        // Don't trust null termination from data read in
-        TERMINATE(src, src_len);
 
-        trace("SWAP WORLD: %s\n", src);
+        trace("  SWAP WORLD: %s\n", src);
         add_requirement_robot(src, file, board_num, robot_num, line_num);
         break;
       }
@@ -2163,7 +2178,7 @@ static enum status parse_legacy_bytecode(struct memfile *mf,
 
     if(mfgetc(mf) != command_length)
     {
-      warnhere("Command start length != end length\n");
+      warnhere("Command start length != end length (%d)\n", command);
       return CORRUPT_WORLD;
     }
   }
@@ -2179,7 +2194,7 @@ static enum status parse_legacy_bytecode(struct memfile *mf,
 #define MAX_PASSWORD_LENGTH 15
 
 // From legacy_world.c
-static uint8_t get_pw_xor_code(char *password, int pro_method)
+static uint8_t get_pw_xor_code(char *password, int password_length, int pro_method)
 {
   static const char magic_code[16] =
    "\xE6\x52\xEB\xF2\x6D\x4D\x4A\xB7\x87\xB2\x92\x88\xDE\x91\x24";
@@ -2194,6 +2209,8 @@ static uint8_t get_pw_xor_code(char *password, int pro_method)
     password[i] -= 0x12 + pro_method;
     password[i] ^= 0x8D;
   }
+  // 1.x passwords store a length instead of a terminator.
+  password[password_length] = '\0';
 
   // Clear pw after first null
   for(i = strlen(password); i < MAX_PASSWORD_LENGTH; i++)
@@ -2245,15 +2262,28 @@ static uint8_t get_pw_xor_code(char *password, int pro_method)
 #define ALIGN_XOR(x) ((x) | (x << 8) | (x << 16) | (x << 24))
 #endif
 
-static void _decrypt_legacy_world(struct memfile *mf, char *password,
- int protection_method)
+static void _decrypt_legacy_world(struct memfile *mf, struct base_file *file)
 {
-  ALIGN_TYPE xor = get_pw_xor_code(password, protection_method);
+  ALIGN_TYPE xor = get_pw_xor_code(file->password, file->password_length, file->protection_method);
   ALIGN_TYPE xor_w = ALIGN_XOR(xor);
   unsigned char *pos = mf->current;
 
-  fprintf(stderr, "xor=%u, password: %s\n", (unsigned int)xor, password);
-  fflush(stderr);
+  if(!display_first_only)
+  {
+    fprintf(stderr, "password: %s\n", file->password);
+    fprintf(stderr, "--------  %.*s\n", (int)strlen(file->password), "----------------");
+    fflush(stderr);
+  }
+
+  /* 1.x doesn't actually encrypt anything... */
+  if(file->file_version < V200)
+    return;
+
+  if(!display_first_only)
+  {
+    fprintf(stderr, "xor: %u\n", (unsigned int)xor);
+    fflush(stderr);
+  }
 
   while(pos < mf->end && ((size_t)pos) % sizeof(ALIGN_TYPE))
     *(pos++) ^= xor;
@@ -2268,6 +2298,33 @@ static void _decrypt_legacy_world(struct memfile *mf, char *password,
     *(pos++) ^= xor;
 }
 
+static enum status parse_legacy_robot_100(struct memfile *mf,
+ struct base_file *file, int board_num, int robot_num)
+{
+  uint32_t program_size;
+  struct memfile prog;
+  enum status ret = SUCCESS;
+
+  // program_length (4),
+  program_size = mfgetd(mf);
+
+  // program_location (4), robot_name (15), robot char (1),
+  // cur_prog_line (4), pos_within_line (1), robot_cycle (1), cycle_count (1),
+  // bullet_type (1), is_locked (1), can_lavawalk (1), walk_dir (1),
+  // last_touch_dir (1), last_shot_dir (1)
+  if(mfseek(mf, 33, SEEK_CUR) != 0)
+    return FSEEK_FAILED;
+
+  if(program_size > 2)
+  {
+    mfopen(mf->current, program_size, &prog);
+    ret = parse_legacy_bytecode(&prog, program_size, file, board_num, robot_num);
+  }
+
+  mfseek(mf, program_size, SEEK_CUR);
+  return ret;
+}
+
 static enum status parse_legacy_robot(struct memfile *mf,
  struct base_file *file, int board_num, int robot_num)
 {
@@ -2277,6 +2334,9 @@ static enum status parse_legacy_robot(struct memfile *mf,
   enum status ret = SUCCESS;
   boolean used = false;
 
+  if(file->file_version < V200)
+    return parse_legacy_robot_100(mf, file, board_num, robot_num);
+
   // program_length (2),
   program_size = mfgetw(mf);
 
@@ -2316,7 +2376,99 @@ static enum status parse_legacy_robot(struct memfile *mf,
   return ret;
 }
 
+/* Version 1.x RLE. */
 static boolean skip_rle(struct memfile *mf)
+{
+  uint16_t w;
+  uint16_t h;
+  size_t size;
+  size_t pos = 0;
+
+  // There may be a terminating 0-length run prefixed(?!).
+  if(mf->current + 1 < mf->end)
+  {
+    uint8_t count = mfgetc(mf);
+    if(count == 0)
+      mf->current++;
+    else
+      mf->current--;
+  }
+  if(mf->current + 1 >= mf->end)
+    return false;
+
+  w = mfgetc(mf);
+  h = mfgetc(mf);
+  size = w * h;
+  if(size < 1)
+    return false;
+
+  while(pos < size && mf->current + 1 < mf->end)
+  {
+    uint8_t count = mfgetc(mf);
+    mf->current++;
+    pos += count;
+  }
+  return mf->current < mf->end;
+}
+
+static boolean load_rle(char **dest, uint16_t *width, uint16_t *height,
+ struct memfile *mf)
+{
+  uint16_t w;
+  uint16_t h;
+  size_t size;
+  size_t pos = 0;
+  char *plane;
+
+  // There may be a terminating 0-length run prefixed(?!).
+  if(mf->current + 1 < mf->end)
+  {
+    uint8_t count = mfgetc(mf);
+    if(count == 0)
+      mf->current++;
+    else
+      mf->current--;
+  }
+  if(mf->current + 1 >= mf->end)
+    return false;
+
+  w = mfgetc(mf);
+  h = mfgetc(mf);
+  size = w * h;
+  if(size < 1)
+    return false;
+
+  plane = cmalloc(size);
+
+  while(pos < size && mf->current + 1 < mf->end)
+  {
+    uint8_t count = mfgetc(mf);
+    uint8_t byte = mfgetc(mf);
+
+    if(pos + count > size)
+    {
+      free(plane);
+      return false;
+    }
+
+    memset(plane + pos, byte, count);
+    pos += count;
+  }
+
+  if(mf->current < mf->end)
+  {
+    *dest = plane;
+    *width = w;
+    *height = h;
+    return true;
+  }
+
+  free(plane);
+  return false;
+}
+
+/* Version 2.x RLE. */
+static boolean skip_rle2(struct memfile *mf)
 {
   uint16_t w = mfgetw(mf);
   uint16_t h = mfgetw(mf);
@@ -2339,7 +2491,7 @@ static boolean skip_rle(struct memfile *mf)
   return (mf->current < mf->end);
 }
 
-static boolean load_rle(char **dest, uint16_t *width, uint16_t *height,
+static boolean load_rle2(char **dest, uint16_t *width, uint16_t *height,
  struct memfile *mf)
 {
   uint16_t w = mfgetw(mf);
@@ -2402,48 +2554,69 @@ static enum status parse_legacy_board(struct memfile *mf,
   char *level_param = NULL;
   uint16_t width;
   uint16_t height;
+  boolean rle_success;
 
-  // junk the undocumented (and unused) board_mode
-  mfgetc(mf);
-
-  // whether the overlay is enabled or not
-  if(mfgetc(mf))
+  if(file->file_version >= V200)
   {
-    // not enabled, so rewind this last read
-    if(mfseek(mf, -1, SEEK_CUR) != 0)
-      return FSEEK_FAILED;
-  }
-  else
-  {
-    // junk overlay_mode
+    // Skip legacy board_mode, which was used to control maximum board dimensions.
     mfgetc(mf);
 
-    // Skip overlay char and color RLE blocks.
-    if(!skip_rle(mf) || !skip_rle(mf))
+    // whether the overlay is enabled or not
+    if(mfgetc(mf))
     {
-      warnhere("Failed to unpack overlay RLE\n");
-      return CORRUPT_WORLD;
+      // not enabled, so rewind this last read
+      if(mfseek(mf, -1, SEEK_CUR) != 0)
+        return FSEEK_FAILED;
+    }
+    else
+    {
+      // junk overlay_mode
+      mfgetc(mf);
+
+      // Skip overlay char and color RLE blocks.
+      if(!skip_rle2(mf) || !skip_rle2(mf))
+      {
+        warnhere("Failed to unpack overlay RLE\n");
+        return CORRUPT_WORLD;
+      }
     }
-  }
 
-  // NOTE: Robot xpos and ypos variables were always set to 0 in DOS-era worlds
-  // and can't be trusted. Instead, the level_id/level_param arrays need to be
-  // unpacked and scanned.
+    // NOTE: Robot xpos and ypos variables were always set to 0 in DOS-era worlds
+    // and can't be trusted. Instead, the level_id/level_param arrays need to be
+    // unpacked and scanned.
 
-  // level_id, level_color, level_param,
-  // level_under_id, level_under_color, level_under_param
-  if( !load_rle(&level_id, &width, &height, mf)
-   || !skip_rle(mf)
-   || !load_rle(&level_param, &width, &height, mf)
-   || !skip_rle(mf)
-   || !skip_rle(mf)
-   || !skip_rle(mf))
+    // level_id, level_color, level_param,
+    // level_under_id, level_under_color, level_under_param
+    rle_success =
+      load_rle2(&level_id, &width, &height, mf) &&
+      skip_rle2(mf) &&
+      load_rle2(&level_param, &width, &height, mf) &&
+      skip_rle2(mf) &&
+      skip_rle2(mf) &&
+      skip_rle2(mf);
+  }
+  else
+  {
+    // Version 1.x worlds start immediately with the RLE,
+    // i.e. no board_mode or overlay support.
+    rle_success =
+      load_rle(&level_id, &width, &height, mf) &&
+      skip_rle(mf) &&
+      load_rle(&level_param, &width, &height, mf) &&
+      skip_rle(mf) &&
+      skip_rle(mf) &&
+      skip_rle(mf);
+  }
+
+  if(!rle_success)
   {
     warnhere("Failed to unpack board RLE\n");
     free(level_id);
     free(level_param);
     return CORRUPT_WORLD;
   }
+  trace("  width  %d\n", width);
+  trace("  height %d\n", height);
 
   if(level_id && level_param)
   {
@@ -2487,12 +2660,20 @@ static enum status parse_legacy_board(struct memfile *mf,
   // check the board MOD exists
   if(strlen(board_mod) > 0 && strcmp(board_mod, "*"))
   {
-    trace("BOARD MOD: %s\n", board_mod);
+    trace("  BOARD MOD: %s\n", board_mod);
     add_requirement_board(board_mod, file, board_num, IS_BOARD_MOD);
   }
 
-  if(file->world_version < V283)
+  if(file->file_version < V200)
+  {
+    skip_bytes = 208;
+  }
+  else
+
+  if(file->file_version < V283)
+  {
     skip_bytes = 207;
+  }
   else
     skip_bytes = 25;
 
@@ -2505,6 +2686,7 @@ static enum status parse_legacy_board(struct memfile *mf,
 
   // walk the robot list, scan the robotic
   num_robots = mfgetc(mf);
+  trace("  robots %d\n", num_robots);
   for(i = 0; i < num_robots; i++)
   {
     ret = parse_legacy_robot(mf, file, board_num, i + 1);
@@ -2523,34 +2705,51 @@ struct legacy_board {
   int size;
 };
 
-static enum status parse_legacy_world(struct memfile *mf,
- struct base_file *file, int protection_method)
+static enum status parse_legacy_world(struct memfile *mf, struct base_file *file)
 {
-  int global_robot_offset;
   struct legacy_board board_list[MAX_BOARDS];
+  int global_robot_offset;
   int num_boards;
   int i;
 
   enum status ret = SUCCESS;
 
-  // Jump to the global robot offset
-  if(mfseek(mf, LEGACY_WORLD_GLOBAL_OFFSET_OFFSET, SEEK_SET) != 0)
+  if(file->file_version >= V200)
   {
-    warnhere("couldn't seek to global robot position (truncated)\n");
-    return CORRUPT_WORLD;
+    // Jump to the global robot offset
+    if(mfseek(mf, LEGACY_WORLD_GLOBAL_OFFSET_OFFSET, SEEK_SET) != 0)
+    {
+      warnhere("couldn't seek to global robot position (truncated)\n");
+      return CORRUPT_WORLD;
+    }
+    // Protected worlds: everything is offset 15 bytes.
+    if(file->protection_method)
+      mfseek(mf, MAX_PASSWORD_LENGTH, SEEK_CUR);
+
+    // Absolute offset (in bytes) of global robot
+    global_robot_offset = mfgetd(mf);
   }
-  // Protected worlds: everything is offset 15 bytes.
-  if(protection_method)
-    mfseek(mf, MAX_PASSWORD_LENGTH, SEEK_CUR);
+  else
+  {
+    // Jump to the board count (1.x doesn't have a global robot).
+    if(mfseek(mf, LEGACY_WORLD_BOARD_COUNT_100, SEEK_SET) != 0)
+    {
+      warnhere("couldn't seek to board count position (truncated)\n");
+      return CORRUPT_WORLD;
+    }
+    // Protected worlds: everything is offset 16 bytes.
+    if(file->protection_method)
+      mfseek(mf, MAX_PASSWORD_LENGTH + 1, SEEK_CUR);
 
-  // Absolute offset (in bytes) of global robot
-  global_robot_offset = mfgetd(mf);
+    global_robot_offset = 0;
+  }
 
-  // num_boards doubles as the check for custom sfx, if zero
+  // num_boards doubles as the check for custom sfx, if zero.
   num_boards = mfgetc(mf);
 
-  // if we have custom sfx, check them for resources
-  if(num_boards == 0)
+  // If the world has custom sfx, check them for resources.
+  // 1.x worlds don't have custom sfx and are limited to 127 boards.
+  if(num_boards == 0 && file->file_version >= V200)
   {
     unsigned short sfx_len_total = mfgetw(mf);
     char sfx_buf[LEGACY_SFX_SIZE + 1];
@@ -2599,6 +2798,11 @@ static enum status parse_legacy_world(struct memfile *mf,
     num_boards = mfgetc(mf);
   }
 
+  if(num_boards == 0)
+    warnhere("File contains 0 boards\n");
+  if(file->file_version < V200 && num_boards > 127)
+    warnhere("Version 1.x file contains more than 127 boards\n");
+
   // skip board names; we simply don't care
   if(mfseek(mf, num_boards * BOARD_NAME_SIZE, SEEK_CUR) != 0)
   {
@@ -2624,6 +2828,9 @@ static enum status parse_legacy_world(struct memfile *mf,
     if(board->size == 0)
       continue;
 
+    trace("  size   %d\n", board->size);
+    trace("  offset %d\n", board->offset);
+
     // seek to board offset within world
     if(mfseek(mf, board->offset, SEEK_SET) != 0)
     {
@@ -2640,18 +2847,23 @@ static enum status parse_legacy_world(struct memfile *mf,
     }
   }
 
-  trace("Global robot\n");
-
-  // Do the global robot too..
-  if(mfseek(mf, global_robot_offset, SEEK_SET) != 0)
+  if(global_robot_offset)
   {
-    warnhere("Failed to seek to global robot position\n");
-    return CORRUPT_WORLD;
-  }
+    trace("Global robot\n");
 
-  ret = parse_legacy_robot(mf, file, NO_BOARD, GLOBAL_ROBOT);
-  if(ret != SUCCESS)
-    warnhere("Failed processing global robot\n");
+    // Do the global robot too..
+    if(mfseek(mf, global_robot_offset, SEEK_SET) != 0)
+    {
+      warnhere("Failed to seek to global robot position\n");
+      return CORRUPT_WORLD;
+    }
+
+    ret = parse_legacy_robot(mf, file, NO_BOARD, GLOBAL_ROBOT);
+    if(ret != SUCCESS)
+      warnhere("Failed processing global robot\n");
+  }
+  else
+    trace("No global robot\n");
 
   return ret;
 }
@@ -2875,6 +3087,7 @@ static enum status parse_board_file(struct memfile *mf, struct base_file *file)
     return MAGIC_CHECK_FAILED;
 
   file->world_version = file_version;
+  file->file_version = file_version;
 
   if(file_version <= MZX_LEGACY_FORMAT_VERSION)
     return parse_legacy_board(mf, file, -1);
@@ -2888,7 +3101,6 @@ static enum status parse_board_file(struct memfile *mf, struct base_file *file)
 static enum status parse_world_file(struct memfile *mf, struct base_file *file)
 {
   unsigned char magic[4];
-  int protection_method;
   int file_version;
 
   // Truncation safety check.
@@ -2899,19 +3111,21 @@ static enum status parse_world_file(struct memfile *mf, struct base_file *file)
   if(mfseek(mf, LEGACY_WORLD_PROTECTED_OFFSET, SEEK_SET) != 0)
     return FSEEK_FAILED;
 
-  protection_method = mfgetc(mf);
-  if(protection_method != 0)
+  file->protection_method = mfgetc(mf);
+  if(file->protection_method != 0)
   {
     // World is probably protected (or possibly junk).
-    char password[16];
+    long password_pos;
     long magic_pos;
 
-    if(protection_method < 0 || protection_method > 3)
+    if(file->protection_method < 0 || file->protection_method > 3)
       return MAGIC_CHECK_FAILED;
 
-    if(mfread(password, 1, MAX_PASSWORD_LENGTH, mf) != MAX_PASSWORD_LENGTH)
+    password_pos = mftell(mf);
+    if(mfread(file->password, 1, MAX_PASSWORD_LENGTH, mf) != MAX_PASSWORD_LENGTH)
       return FREAD_FAILED;
-    password[MAX_PASSWORD_LENGTH] = '\0';
+    file->password[MAX_PASSWORD_LENGTH] = '\0';
+    file->password_length = MAX_PASSWORD_LENGTH;
 
     magic_pos = mftell(mf);
     if(mfread(magic, 1, 4, mf) != 4)
@@ -2925,10 +3139,19 @@ static enum status parse_world_file(struct memfile *mf, struct base_file *file)
       if(file_version != V100)
         return MAGIC_CHECK_FAILED;
 
-      return MZX_100_NOT_SUPPORTED;
+      // 1.x passwords are stored with a length, not an obfuscated nul.
+      mfseek(mf, password_pos, SEEK_SET);
+      file->password_length = mfgetc(mf);
+      if(file->password_length > MAX_PASSWORD_LENGTH)
+        return BAD_100_PASSWORD;
+
+      mfread(file->password, 1, file->password_length, mf);
+      magic_pos++;
     }
+
+    file->file_version = file_version;
     mfseek(mf, magic_pos + 3, SEEK_SET);
-    _decrypt_legacy_world(mf, password, protection_method);
+    _decrypt_legacy_world(mf, file);
     mfseek(mf, magic_pos, SEEK_SET);
   }
 
@@ -2941,13 +3164,13 @@ static enum status parse_world_file(struct memfile *mf, struct base_file *file)
   if(file_version <= 0)
     return MAGIC_CHECK_FAILED;
 
-  if(file_version < V200)
-    return MZX_100_NOT_SUPPORTED;
-
   file->world_version = file_version;
+  file->file_version = file_version;
+
+  trace("File version: %03x\n", file->file_version);
 
   if(file_version <= MZX_LEGACY_FORMAT_VERSION)
-    return parse_legacy_world(mf, file, protection_method);
+    return parse_legacy_world(mf, file);
 
   if(file_version <= MZX_VERSION)
     return parse_world(mf, file, true);
diff --git a/src/world.c b/src/world.c
index 191c4f59e..9ee3c5c1c 100644
--- a/src/world.c
+++ b/src/world.c
@@ -361,11 +361,11 @@ static inline int save_world_info(struct world *mzx_world,
     save_prop_w(WPROP_PLAYER_RESTART_Y, mzx_world->player_restart_y, mf);
     save_prop_c(WPROP_SAVED_PL_COLOR,   mzx_world->saved_pl_color, mf);
     save_prop_a(WPROP_KEYS,             mzx_world->keys, NUM_KEYS, 1, mf);
-    save_prop_c(WPROP_BLIND_DUR,        mzx_world->blind_dur, mf);
-    save_prop_c(WPROP_FIREWALKER_DUR,   mzx_world->firewalker_dur, mf);
-    save_prop_c(WPROP_FREEZE_TIME_DUR,  mzx_world->freeze_time_dur, mf);
-    save_prop_c(WPROP_SLOW_TIME_DUR,    mzx_world->slow_time_dur, mf);
-    save_prop_c(WPROP_WIND_DUR,         mzx_world->wind_dur, mf);
+    save_prop_d(WPROP_BLIND_DUR,        mzx_world->blind_dur, mf);
+    save_prop_d(WPROP_FIREWALKER_DUR,   mzx_world->firewalker_dur, mf);
+    save_prop_d(WPROP_FREEZE_TIME_DUR,  mzx_world->freeze_time_dur, mf);
+    save_prop_d(WPROP_SLOW_TIME_DUR,    mzx_world->slow_time_dur, mf);
+    save_prop_d(WPROP_WIND_DUR,         mzx_world->wind_dur, mf);
     save_prop_c(WPROP_SCROLL_BASE_COLOR,    mzx_world->scroll_base_color, mf);
     save_prop_c(WPROP_SCROLL_CORNER_COLOR,  mzx_world->scroll_corner_color, mf);
     save_prop_c(WPROP_SCROLL_POINTER_COLOR, mzx_world->scroll_pointer_color, mf);
@@ -2276,6 +2276,9 @@ static int load_world_zip(struct world *mzx_world, struct zip_archive *zp,
 }
 
 
+// Hack- forward declaration since this should stay near change_board.
+static void synchronize_current_board(struct world *mzx_world);
+
 int save_world(struct world *mzx_world, const char *file, boolean savegame,
  int world_version)
 {
@@ -2342,6 +2345,9 @@ int save_world(struct world *mzx_world, const char *file, boolean savegame,
     mzx_world->temp_output_pos = 0;
   }
 
+  // Synchronize global variables in the current board.
+  synchronize_current_board(mzx_world);
+
 #ifdef CONFIG_EDITOR
   if(world_version == MZX_VERSION_PREV)
   {
@@ -2778,10 +2784,23 @@ static boolean read_world_header(vfile *vf, boolean savegame,
     if(protected)
       *protected = pr;
 
-    if(!vfread(magic, 3, 1, vf))
-      return false;
+    if(pr)
+    {
+      vfseek(vf, 15, SEEK_CUR);
+      if(!vfread(magic, 4, 1, vf))
+        return false;
+
+      v = world_magic(magic);
+      if(v < V200)
+        v = world_magic(magic + 1);
+    }
+    else
+    {
+      if(!vfread(magic, 3, 1, vf))
+        return false;
 
-    v = world_magic(magic);
+      v = world_magic(magic);
+    }
   }
 
   if(protected) *protected = pr;
@@ -2880,7 +2899,7 @@ static struct zip_archive *try_load_zip_world(struct world *mzx_world,
     }
     else
 
-    if(v > 0 && v < V251)
+    if(v > 0 && v < V100)
     {
       error_message(E_WORLD_FILE_VERSION_OLD, v, NULL);
     }
@@ -2942,7 +2961,7 @@ void try_load_world(struct world *mzx_world, struct zip_archive **zp,
   _zp = try_load_zip_world(mzx_world, file, savegame, &v, &protected, name);
 
   if(!_zp)
-    if(protected || (v >= V251 && v <= MZX_LEGACY_FORMAT_VERSION))
+    if(protected || (v >= V100 && v <= MZX_LEGACY_FORMAT_VERSION))
       _vf = try_load_legacy_world(mzx_world, file, savegame, &v, name);
 
   *zp = _zp;
@@ -2951,11 +2970,29 @@ void try_load_world(struct world *mzx_world, struct zip_archive **zp,
 }
 
 
+static void synchronize_current_board(struct world *mzx_world)
+{
+  struct board *cur_board = mzx_world->current_board;
+
+  // MegaZeux 1.x- status durations were local to each board and need to be
+  // backed up to the current board.
+  if(mzx_world->version < V200 && cur_board)
+  {
+    cur_board->blind_dur_v1 = mzx_world->blind_dur;
+    cur_board->firewalker_dur_v1 = mzx_world->firewalker_dur;
+    cur_board->freeze_time_dur_v1 = mzx_world->freeze_time_dur;
+    cur_board->slow_time_dur_v1 = mzx_world->slow_time_dur;
+    cur_board->wind_dur_v1 = mzx_world->wind_dur;
+  }
+}
+
 void change_board(struct world *mzx_world, int board_id)
 {
   // Set the current board during gameplay.
   struct board *cur_board = mzx_world->current_board;
 
+  synchronize_current_board(mzx_world);
+
   // Is this board temporary? Clear it
   if(mzx_world->temporary_board)
   {
@@ -2980,6 +3017,17 @@ void change_board(struct world *mzx_world, int board_id)
 
     mzx_world->current_board = dup_board;
     mzx_world->temporary_board = 1;
+    cur_board = dup_board;
+  }
+
+  // MegaZeux 1.x- status durations were board local, restore the saved copies.
+  if(mzx_world->version < V200)
+  {
+    mzx_world->blind_dur = cur_board->blind_dur_v1;
+    mzx_world->firewalker_dur = cur_board->firewalker_dur_v1;
+    mzx_world->freeze_time_dur = cur_board->freeze_time_dur_v1;
+    mzx_world->slow_time_dur = cur_board->slow_time_dur_v1;
+    mzx_world->wind_dur = cur_board->wind_dur_v1;
   }
 }
 
diff --git a/src/world_format.h b/src/world_format.h
index d8e3338e7..41099fe8c 100644
--- a/src/world_format.h
+++ b/src/world_format.h
@@ -83,7 +83,7 @@ enum world_file_id
 #define BOUND_WORLD_PROPS (BOARD_NAME_SIZE + 5 + 455 + 24 + 9 + STATS_SIZE)
 
 #define COUNT_SAVE_PROPS  ( 2 +  32 +          3 +        1)
-#define BOUND_SAVE_PROPS  ( 2 + 105 + 3*MAX_PATH + NUM_KEYS)
+#define BOUND_SAVE_PROPS  ( 2 + 120 + 3*MAX_PATH + NUM_KEYS)
 
 // For world files, use WORLD_PROP_SIZE
 // For save files, use WORLD_PROP_SIZE + SAVE_PROP_SIZE
@@ -158,11 +158,11 @@ enum world_prop
   WPROP_PLAYER_RESTART_Y          = 0x804B, //   2
   WPROP_SAVED_PL_COLOR            = 0x804C, //   1
   WPROP_KEYS                      = 0x804D, // NUM_KEYS
-  WPROP_BLIND_DUR                 = 0x8050, //   1
-  WPROP_FIREWALKER_DUR            = 0x8051, //   1
-  WPROP_FREEZE_TIME_DUR           = 0x8052, //   1
-  WPROP_SLOW_TIME_DUR             = 0x8053, //   1
-  WPROP_WIND_DUR                  = 0x8054, //   1
+  WPROP_BLIND_DUR                 = 0x8050, //   4
+  WPROP_FIREWALKER_DUR            = 0x8051, //   4
+  WPROP_FREEZE_TIME_DUR           = 0x8052, //   4
+  WPROP_SLOW_TIME_DUR             = 0x8053, //   4
+  WPROP_WIND_DUR                  = 0x8054, //   4
   WPROP_SCROLL_BASE_COLOR         = 0x8058, //   1
   WPROP_SCROLL_CORNER_COLOR       = 0x8059, //   1
   WPROP_SCROLL_POINTER_COLOR      = 0x805A, //   1
@@ -241,8 +241,8 @@ enum sprite_prop
 #define COUNT_BOARD_PROPS (              1 +  7 +          3 + 25)
 #define BOUND_BOARD_PROPS (BOARD_NAME_SIZE + 10 + 3*MAX_PATH + 26)
 
-#define COUNT_BOARD_SAVE_PROPS (             2 + 15)
-#define BOUND_BOARD_SAVE_PROPS (2*ROBOT_MAX_TR + 25)
+#define COUNT_BOARD_SAVE_PROPS (             2 + 20)
+#define BOUND_BOARD_SAVE_PROPS (2*ROBOT_MAX_TR + 30)
 
 // For world files, use BOARD_PROPS_SIZE
 // For save files, use BOARD_PROPS_SIZE + BOARD_SAVE_PROPS_SIZE
@@ -322,6 +322,11 @@ enum board_prop
   BPROP_VOLUME                    = 0x0114, // 1
   BPROP_VOLUME_INC                = 0x0115, // 1
   BPROP_VOLUME_TARGET             = 0x0116, // 1
+  BPROP_BLIND_DUR                 = 0x0117, // 1
+  BPROP_FIREWALKER_DUR            = 0x0118, // 1
+  BPROP_FREEZE_TIME_DUR           = 0x0119, // 1
+  BPROP_SLOW_TIME_DUR             = 0x011a, // 1
+  BPROP_WIND_DUR                  = 0x011b, // 1
 };
 
 
diff --git a/testworlds/1.00/000 Format.mzx b/testworlds/1.00/000 Format.mzx
new file mode 100644
index 000000000..a0ca42e40
Binary files /dev/null and b/testworlds/1.00/000 Format.mzx differ
diff --git a/testworlds/1.00/000 Format.txt b/testworlds/1.00/000 Format.txt
new file mode 100644
index 000000000..7f7f33a8c
--- /dev/null
+++ b/testworlds/1.00/000 Format.txt	
@@ -0,0 +1,3 @@
+Title: 1.XX format test and swap hack test.
+Author: Alice Rowan
+Desc: Tests loading of 1.xx world files and of hacked SWAP WORLD commands. MegaZeux 1.xx does not support SWAP WORLD, but modern MZX allows it so that the regression tests can test 1.xx worlds.
diff --git a/testworlds/1.00/001 Locked.mzx b/testworlds/1.00/001 Locked.mzx
new file mode 100644
index 000000000..8ae6ae970
Binary files /dev/null and b/testworlds/1.00/001 Locked.mzx differ
diff --git a/testworlds/1.00/001 Locked.txt b/testworlds/1.00/001 Locked.txt
new file mode 100644
index 000000000..ff65075d1
--- /dev/null
+++ b/testworlds/1.00/001 Locked.txt	
@@ -0,0 +1,3 @@
+Title: 1.XX locked world test.
+Author: Alice Rowan
+Desc: 1.xx locked worlds are NOT encrypted, just password protected. Loading these should work.
diff --git a/testworlds/1.00/002 Robo-P Convert.mzx b/testworlds/1.00/002 Robo-P Convert.mzx
new file mode 100644
index 000000000..9c586c03f
Binary files /dev/null and b/testworlds/1.00/002 Robo-P Convert.mzx differ
diff --git a/testworlds/1.00/002 Robo-P Convert.txt b/testworlds/1.00/002 Robo-P Convert.txt
new file mode 100644
index 000000000..37dae21fc
--- /dev/null
+++ b/testworlds/1.00/002 Robo-P Convert.txt	
@@ -0,0 +1,3 @@
+Title: Robo-P Command Conversion
+Author: Alice Rowan
+Desc: This world contains a robot with every command, which should convert properly. This does not test execution of most commands.
diff --git a/testworlds/1.00/003 Char Escapes.mzx b/testworlds/1.00/003 Char Escapes.mzx
new file mode 100644
index 000000000..1213c0765
Binary files /dev/null and b/testworlds/1.00/003 Char Escapes.mzx differ
diff --git a/testworlds/1.00/003 Char Escapes.txt b/testworlds/1.00/003 Char Escapes.txt
new file mode 100644
index 000000000..527c5c4c5
--- /dev/null
+++ b/testworlds/1.00/003 Char Escapes.txt	
@@ -0,0 +1,3 @@
+Title: v1 Counter Symbol Escape Test
+Author: Alice Rowan
+Desc: Make sure various important symbols in modern Robotic are escaped when a v1 program is converted, or otherwise have no side effects when interpreted.
diff --git a/testworlds/1.00/004 cur_prog_line.mzx b/testworlds/1.00/004 cur_prog_line.mzx
new file mode 100644
index 000000000..e914eecb9
Binary files /dev/null and b/testworlds/1.00/004 cur_prog_line.mzx differ
diff --git a/testworlds/1.00/004 cur_prog_line.txt b/testworlds/1.00/004 cur_prog_line.txt
new file mode 100644
index 000000000..9f6550346
--- /dev/null
+++ b/testworlds/1.00/004 cur_prog_line.txt	
@@ -0,0 +1,3 @@
+Title: v1 Preset cur_prog_line
+Author: Alice Rowan
+Desc: Make sure v1 cur_prog_line is converted correctly.
diff --git a/testworlds/1.00/005 bad cur_prog_line.mzx b/testworlds/1.00/005 bad cur_prog_line.mzx
new file mode 100644
index 000000000..4186ec888
Binary files /dev/null and b/testworlds/1.00/005 bad cur_prog_line.mzx differ
diff --git a/testworlds/1.00/005 bad cur_prog_line.txt b/testworlds/1.00/005 bad cur_prog_line.txt
new file mode 100644
index 000000000..9a2d4f510
--- /dev/null
+++ b/testworlds/1.00/005 bad cur_prog_line.txt	
@@ -0,0 +1,3 @@
+Title: bad cur_prog_line
+Author: Alice Rowan
+Desc: These robots have bad cur_prog_line values, don't crash.
diff --git a/testworlds/tests.mzx b/testworlds/tests.mzx
index 1c152612f..23277c771 100644
Binary files a/testworlds/tests.mzx and b/testworlds/tests.mzx differ