Basically, you can use free ram as your 'name string' For example, the following code is totally valid:
Copy("HI",L1+1,2)
0->{L1+3}
E15->{L1}
GetCalc(L1)->A
It does the same thing as GetCalc("appvHI")->A, but I'm sure you can think of many applications of this method instead (shells and mem readers come to mind). You can use 05 to get a program or 06 to get a protected program (instead of $15). Other prefixes you may be able to use are (taken from the SDK. also I haven't tested all of these and would be wary if you tried GetCalc'ing an application for example)
00h Real
01h List
02h Matrix
03h Equation
04h String
05h Program
06h Protected Program
07h Picture
08h Graph Database
0Bh New EQU 
0Ch Complex
0Dh Complex
14h Application
15h AppVar
17h Group

Appvars and programs have just about the same structure when accessed through Axe. They can have names up to 8 characters in length, that do not start with a number. Appvars can contain lowercase letters in their name, and while programs can, it is more common practice for them to have all uppercase names. This is because if a program contains lowercase letters in its name, it cannot be run from the homescreen.

To access an appvar:
GetCalc("appvAPPVAR")→PointerWhere 'APPVAR' is to be substituted with the name of the appvar you want to access, and Pointer is where you want the data to point to.
For example:
GetCalc("appvAPPVAR")→AThis stores the location in RAM of the appvar APPVAR to the pointer A. You can then access data in the appvar by using pointers as you normally would.
GetCalc("appvAPPVAR")→A
1→{A}The code above would store 1 to the first byte of the appvar APPVAR.
The code above will only work if the appvar exists and is in the RAM.

Now, if your appvar doesn't exist, you can easily create it by adding a second argument to your GetCalc() command.
GetCalc("appvAPPVAR",Size)→PointerWhere Size is the size in bytes of the appvar you want to create.

If the appvar exists, but is in the archive, there are a number of things you can do.
You could unarchive it, but if you are only going to read data from it, this is not the best way to do it.
UnArchive "appvAPPVAR"Most of the time if you do this, you'll have to end up archiving it when you're done with it.
Archive "appvAPPVAR"This can take more and more time if you haven't GarbageCollected recently, though. However, this does allow you to save your data in the archive.

If you simply want to read data from an archived appvar, then you could copy it to a file.
GetCalc("appvAPPVAR",File)Where File is the token for a Y-Var (Y₀-Y₉).

Once the appvar is copied to a file, you can read from it like a pointer.
GetCalc("appvAPPVAR",Y0)
{Y0}→AThis would store the first byte of your appvar to the pointer A.

Once you no longer need an appvar, you can simply delete it.
DelVar "appvAPPVAR"This will only work if the appvar is in the RAM. If you copied your appvar to a file, you don't need to worry about deleting a file, as ending the program will take care of clearing the file for you. In addition, you can copy an appvar to a file that you previously used with no adverse effects.
GetCalc("appvAPPVAR",Y0)
GetCalc("appvAPPVAR2",Y0)This would copy the appvar APPVAR to file Y₀, then copy the appvar APPVAR2 to file Y₀. Accessing file Y₀ would then allow you to access the data in APPVAR2.

Please note that data cannot be stored to files, merely read from files.


Programs can be accessed exactly the same way as appvars, except that you use the 'prgm' token instead of the 'v' you get from [2nd]+[8] (which becomes 'appv' with the Axe Tokens).

Accessing real vars is fairly easy to do, actually.
First, getting the pointer to a real var is:
GetCalc("varA")→PointerWhere A can be substituted with any real var, A-θ, and Pointer is the where you want the data to point to.

Now, the tricky part is accessing the data in a real var. Simply doing:
GetCalc("varA")→P
1→float{P}will not give you proper results. In fact, it will render the variable A invalid until you overwrite it properly, whether inside or outside the Axe program.

The correct offset for accessing a real var is Pointer-2.
GetCalc("varA")→P
1→float{P-2}This code will store one to the real var A, and you can see that now outside of the Axe program. You can store 0-65535 to real vars using Axe, as Axe only supports two byte numbers. Note: You don't need to put a ^r after the float command if you are storing a two byte number.
The 'var' token is the 'u' you get from [2nd]+[7] (it becomes 'var' with the Axe tokens).

Copy("HI",L₁+1,2)
0->{L₁+3}
_E15->{L₁}
GetCalc(L₁)->A

It does the same thing as GetCalc("appvHI")->A, but I'm sure you can think of many applications of this method instead (shells and mem readers come to mind). You can use 05 to get a program or 06 to get a protected program (instead of $15). Other prefixes you may be able to use are (taken from the SDK. also I haven't tested all of these and would be wary if you tried GetCalc'ing an application for example)

Data Types:
00h Real
01h List
02h Matrix
03h Equation
04h String
05h Program
06h Protected Program
07h Picture
08h Graph Database
0Bh New EQU 
0Ch Complex
0Dh Complex
14h Application
15h AppVar
17h Group

This could be taken as a little confusing, so let's break this down a little bit.


Copy("HI",L₁+1,2)
This line copies the name of the variable (in this case, "HI") to L₁+1.

0->{L₁+3}
This line adds the null byte or terminating zero to the end of the name string starting at L₁+1. Where 3 is would be the length of the variable name + 1.

_E15->{L₁}
This line stores the type byte of the variable to L₁. In this case, it's denotating an appvar. The _E means the number that follows is the hexadecimal equivalent, so any of the hex numbers from the above list would work here in place of the 15.

GetCalc(L₁)->A
This uses the string you just constructed at the beginning of L₁ to create the variable.