Let me see if i understand the concept behind the global data concept.  When the program is run, it is copied to RAM somewhere safe where the TiOS can run it.  After it is finished executing, it is NOT copied back, making the program effectively write protected . So all we need to do is write a little bit of code to find out where the program acualy located (the first hex code) and store it in a safe place (L4) until the end of the program where we use it.  Once we get to the end, we merely copy the program right back to where it started again, so that any changes we made are permanent.  We are not using any of the L1-L6 variables for anything more than a 4 byte address storage during the program execution, so there is no possibility that we could run out of memory due to large programs.

(did i get that correctly?)

Yeah, calc84 is right.  When you first run a program, TIOS stores the name of it to OP1 (a RAM area).  I read OP1 and store it to the end of L4.  That is what the first routine does.  Only 9 bytes.

If you don't want to read a huge post, the juicy stuff is in the last two paragraphs, down at the bottom.

Here, let me do my best to explain it.
The memory is a series of bytes.  A very long series of bytes.  Each byte is represented by an offset from the first byte, called an address.  Addresses are almost always written in hex.  For example, 0A00h is 10 bytes from the first byte.  0000h is the first byte.  Notice that numbers in hex are ended with an 'h'.  Now, Axe creates program LOL and outputs it to a spot in memory.  For the purposes of this example, we will say it's at B2C4h.  When you run a program, there is another address in memory called OP1 that TIOS copies the name of the program to.  So, when you run prgmLOL, OP1 looks like this:
ProtProgObj (this represents a protected program), L, O, L, 0, 0, 0, 0, 0
You may have noticed that you can only have up 8 character names in TIOS.  In reality, all names have 9 characters - the identifier (ProtProgObj in this case), and the name, buffered by zeros.  So, if a name is less than 8 characters (like LOL), zeros are added to make it equal 8.
Now, when you run the first routine, it looks at OP1, and copies it to 8384h (tempSwapArea, or L4, plus 223).  This means that it copies the name of the program to the end of L4.
Additionally, programs are not run from where they are saved.  If a program is saved to B2C4h, TIOS copies it to 9D95h to run it.  When the program ends, however, it is not copied back to B2C4h, essentially making it write protected.  This is important, because any changes we make will not be copied.
When you run the second routine, it copies the end of L4 back to OP1.  This is because, during the course of the program, it is possible for OP1 to change, so we back up the name first.  There is a routine provided by TIOS for looking up variables by name.  It requires the name to be in OP1, and when we call it, it will return B2C4h (remember, that's where the program is saved?).  We already know the program is running at 9D95h.  This is the most up-to-date version, the one with the modified data.  We need to keep that modified data, and the only way to do that is to copy it back to B2C4h.  So, when TIOS tells us the program is at B2C4h, we copy all the data from 9D95h to B2C4h.  This saves the modified data for the next time.

If you have any questions about this, please feel free to ask.  I want to make sure that you are comfortable with this, because it is the only way right now to save external data.

Also, if you are concerned about speed and the time it would take to copy it, think of it this way.  TIOS copies the program to 9D95h before running it.  We copy it from 9D95h when you call the second routine.  So, if you want to get a general idea of how long it might take, watch how long it takes to start, because that is exactly how long it will take to run the second routine.

OK so basically it's not the entire program content that is copied to OP1, just the name, right? No data from the program where your routine is ran is copied to OP1?

Right.  Just 9 bytes.  Never enough to do damage.

I made another routine, here is is:
Axe Programs in MirageOS
The attached program will help you get your Axe programs to show up in MirageOS.  Draw a 15x15 icon in the top-left hand corner of the graph screen and run the attached program.  Copy the resulting code into the first line of your program.  If you are also using my writeback routine, make sure this code comes before the first writeback routine.

wow awesome! Thanks a lot for this ^^

Sure thing!

Nice! Thats very useful until Quigibo can get out the official version.  Will this interfere with any of the L1-L6 ram areas?

No.  The outputted code is never run.  It's a header, what it looks like is this:
ret      ; Return to the TIOS, because it shouldn't run a mirage program
01       ; MirageOS ID
Icon
Description
0
The icon is taken from the graph screen, converted to hex and copied in.  The description is converted to hex (supported characters are A-Z, a-z, and [space]), and copied in.  MirageOS skips past all this to the first line of your code.  All this does is places some data into your program for MirageOS to read.

true, but does Mirage use any of the same safe areas that Axe uses?

I think StatVars holds Mirage's interrupt vector. To disable this, you might want to put Asm(ED56) after the header to make it use the TI-OS interrupt instead.

I might be mistaken, but I believe that MOS uses one of the safe ram spots to hold the program lists, for speed.