Nice. However, I think I should tell you that RLE is typically done slightly differently, with a reserved number to indicate runs. For example:
.Uncompressed (each tile is a half-byte)
[567222220874999F
[033AAAAAAAAAAAAA
[AAA23279BBBBB8FF
.24 bytes
.Compressed
[567F520874999F1F
[033F0A23279F5B8F
[2F
.17 bytesWhere normal data is just inserted, and a run (more than three here) is indicated by 'F' followed by the run length (one nibble, 0 is length 16) followed by the tile number. An 'F' tile is always recorded in run format because it would otherwise be treated as the start of a run.
I'll try to get some code up in a bit.

Mine takes three nibbles, while his takes one byte, or two nibbles. It's only 50% larger Not to mention I'm assuming the 'F' tile won't be used as often.

builderboy, i could make the routine compress half-byte tilemaps, but it would be more complicated, so i just stuck with one tile as being equal to one byte, though my compression is preferably used in maps that have 15 or less tiles, and have long runs of the same data. if you need more than 15 tiles and have very, very long runs of the same data,  you could use a method where one byte holds frequency, and the next holds the tile number.
so [43050320] would represent tile 5 67 times, then tile 32 3 times. but that can be very memory inefficient unless you have many runs of data, specifically runs of data that last more than 4 tiles.

calcdude, wouldn't RLE under your example only allow tiles 0-E, since F is reserved for indicating a run? and sometimes you could end up with an odd number of nibbles. regardless, i like that type of RLE and i'll probably post some de/compression routines about it.

edit: and my routines will have the uncompressed map data as each tile being one byte.

edit2: compression is working.

.ROUTINE
0->C->D
"0123456789ABCDE0->Str1    .Make sure you have 0 at the end, not F.
For(Y,0,S                  .Replace S with the height of your uncompressed map minus 1
For(X,0,T                  .Replace T with the width of your uncompressed map minus 1
If {T+1*Y+X+GDB1}->A={T+1*Y+X+GDB1+1} and (C!=14)
C+1->C
Else
If C>3
70->{L1+D}
{Str1+C+1}->{L1+D+1}
{Str1+A}->{L1+D+2}
D+3->D
Else
For(Z,0,C
{Str1+A}->{L1+D}
D+1->D
End:End:0->C:End:End:End
GetCalc("Str4",D^2+D)->I
For(Z,0,D-1
{L1+Z}->{I+Z}
End
If D^2
70->{I+Z+1}
End

that was much more difficult to write... i wonder how decompression will be.

yes, mine works by row. i think decompression will be harder, though. because if you run into an F, all your arithmetic has to change to compensate for reading the bytes differently. i think it'd be easiest to make the sequence for starting a run be a full byte, like FF, unless you've found an easy way to decompress already.

Maybe it would make it easier to write a quick subroutine that extracts each nibble from the data and returns them one at a time?  That way you dont even have to think about the half byte compression going on?

This thread shouldn't be floating down this far! And since I just answered a question in the main thread about how to retrieve data from OS matrices, I may as well post these two routines here:

.Returns an element of OS matrix (pointer to matrix, 0-based column, 0-based row)
Lbl M
  float{r₃*{r₁-2}+r₂*9+r₁}
Return

.Returns an element of OS matrix (pointer to matrix, 1-based column, 1-based row)
Lbl M
  float{r₃-1*{r₁-2}+(r₂-1)*9+r₁}
Return

.Returns an element of OS list (pointer to list, 0-based entry)
Lbl L
  float{r₂*9+r₁}
Return

.Returns an element of OS list (pointer to list, 1-based entry)
Lbl L
  float{r₂-1*9+r₁}
Return


darn, I am really out of the loop on new functions, I really need to re-read the command index when I get some time (I last did on 0.2.6)

Lol, I know the feeling