You could do pic1->DispGraph, and it will display on the screen immediately.

Loading pics...
How do you do that?
I know you do [Pic1] or whatever pic it is but then what?

I'm pretty sure [Pic1] absorbs a picture into the program data (meaning that the data for the TI-OS variable Pic1 (the one you actually use in BASIC programs) is copied directly into the program). So if you had a variable Pic1 that was all blank,

[Pic1]→Pic1

is read as

[ ... ]→Pic1

where the ... is 756 bytes of 0. It's useful if the BASIC variable Pic1 has the sprites, one after the other, starting from the top left. That way, instead of having to find the hex code of each individual sprite and typing them into the program, [Pic1]→Pic1 will copy it all for you and store it to the static variable Pic1.

Actually, there's a good chance I have no idea what I'm talking about. I've never actually used the command, and I can't use my calculator right now, so I'm just basing this on my interpretation of the documentation. I wouldn't trust me if I were you unless someone else said the same thing

Deep Thought, you're exactly correct.  The only thing I might add to that, because its a new feature, is that not all OS Pic variables are created equal.  The ones that are made using StorePic are 756 bytes yes, but many pic vars made on the computer are actually 768 bytes since they can edit the last row and so the amount of data it imports will depend on the picture itself.

As for 0.4.0 features, there will be some small GUI changes probably, I'll try to check off some of those wishlist features, and hopefully there will be some more optimizations to make the code smaller possibly involving a third pass.

well, perhaps that would be used for 7 lvl grayscale or something, because 3 * 768 = 2304?

Another thing. I was reading through the Axe documentation, and it was saying I sould use a Str token for a pointer.  It also said L1-L6 were pointers.  Could a Str token substitute for the Axe-type L1-L6 so I don't have to work around the various corruptions?

This is the hardest concept in axe.  Okay, so in basic, you do "Hello"->Str1.  That stores the string "Hello" to the variable Str1.  As a basic programmer, that's all that you have to worry about.  However, behind the scenes, this what happens:

• Calculator looks up variable Str1
• Calculator finds variable in memory
• Calculator returns the variable data.  (In this case, "hello")

In axe, it's different.  the strings are stored inside the program, and the calculator doesn't have to look them up.  Say I do this: "Hello"->Str1.  It's the same command as before, but in this case, when the program is compiled, the compiler sees that line and does this:

• Writes the word "hello" into the compiled program, followed by a zero.  (The zero is to tell any commands that access it, that there is no more text.)
  
• Finds the location of the "h" in "hello".
• Puts that value into Str1, so that whenever it is accessed again, it returns that value instead of the String itself

Also, because the strings are zero terminated, and Str1 points to the "H" character in memory, you can do stuff like Str1+3, which points to the second "L" in memory.
So try this program:
"HELLOL"->Str1
ClrHome
Disp Str1+3
pause 5000
That routine displays LOL, and then pauses for about 5 seconds.

Now, for the L1-L6 variables.  They are all pointing to locations in memory where you can store things as well.  Try the same program, but replace Str1 with L1.  It doesn't work, does it?  Well, that's because you can't really store into L1 like that.  When using L1, since it's already predefined to certain locations, You can only access it by using {L1+n}, where n is the the byte you want to access, starting with 0.  For example, the first byte of L1 is {L1}.  It takes a while to get use to, but once you do, it's a very powerful feature.  Just remember, Basic is not Axe, and Axe is not basic.

From now on, I'm going to greet people with "Hellol"

I'm changing a token name.  You know how programs have the "prgm" token in front of them?  Well, I'm doing the same thing with appvars.  The problem is that its impossible to distinguish between the lowercase "v" and the recursive "v" because they share an identical ascii character.  It has led to confusion in the past, and I think it will do so in the future so I've decided to change it to "apvr" to mimic the way "prgm" is formatted so that it is both distinguishable and recognizable as to how to use it since its interchangeable with prgm.  Thoughts?