In the plans for a future Grammer, I did plan to support arbitrary sized numbers, since the OS version is planned to replace the current TI-OS, even in math. However, I don't think Grammer 2 will support that natively (though I made a program in Grammer code that could handle large numbers like that).

About 4 days ago, I started working on this project. Unfortunately, I am not home yet, so I cannot upload it, but I'll edit this post on the 30th (hopefully). Anyways, I decided to make a program like CopyProg, except it works with groups. Naturally, some features were excluded (you cannot delete lines from grouped program, for example), but I think this is a pretty neat program, so far. Here are its features:

• One command lets you read the names and variable types of each variable in the group. It also returns the size of the data in theta (this is similar to the GetName command in CopyProg). If you try to read the zeroth var name, it will instead return how many variables are in the group.
• Another command will let you extract a variable (by name) and copy it to another variable in RAM (this is like the CopyProg command)
• Another command will let you read a line from a variable (like ReadLine)
• Another command will let you recall a picture from the group, using one of these methods: Overwrite, AND logic, OR logic, XOR logic.

As you might imagine, this program can be useful for RPGs, and this is what I am keeping in my thoughts as I plan more routines. As it is, I think it is basically finished (for a version 1). I now need to clean up my code a bit to remove unused stuff. Also, it is a little over 800 bytes at the moment, so hopefully I can optimise it down a bit :/ The largest pieces of code come purely from reading the group data.

Here is an outdated screenie:


As an example, if you want to copy prgmFOO from the group named BACKUP to the protected program named BAR:
"BACKUP:EFOO:FBAR→Str1
Asm(prgmGRPREAD
I plan to modify this command to use Ans instead of Str1, by the way. And to recall Pic3 using XOR logic to the graph screen from the same group:
"RecallPic  xor BACKUP→Str1
2     ;2 corresponds to Pic3, 0 corresponds to Pic1
Asm(prgmGRPREAD
I hope I get home on time (9 days from now) so I can upload the program :P
EDIT: I have now uploaded the program and documentation! Here is the readme:

GRPREAD    985 bytes
by Zeda Elnara
================================================================
  GrpRead is a program for BASIC programmers that want to work
with groups in some pretty cool ways. For example, say you have
an RPG that uses all 10 picture variables and it uses tons of
memory just for item names or monster names, or something like
that. If you group them (using the OS menu), GrpRead will let
you recall those pictures directly from the group and read lines
of code from programs in the group. These are just a few
examples of what GrpRead can do, so read on and I hope this
proves useful!
=============/
Installation/
===========/
  Send GRPREAD.8xp to your calculator. You can now use it.
===========/
How to Use/
=========/
  Arguments are passed mostly through strings or numbers. It
will then return data or perform some function.
==========/
Functions/
========/
     /=========================================================\
     |GetName                                                  |
     \=========================================================/
     |  The group variable will have variables in it. If you   |
     |want to figure out the names of the variables, their type|
     |and their size, this is the command to use. This returns |
     |info on the 'nth' variable in the group. It can also be  |
     |used to figure out how many variables are in the group.  |
     \=========================================================/
     Inputs:
        Str1 has the name of the group
        Ans is the nth var name to return, or zero
     Outputs:
        Ans has the name of the variable (with a prefix byte)*
        Theta has the size of the variable's data
       *A prefix byte is used to specify the type of the
        variable. This is either the " and " token or a letter.
        See the text document named "Prefix Bytes.txt" for info.
     Alternate:
        If the input Ans was 0, this instead returns the number
        of variables in the group. If the group doesn't exist,
        0 is returned.
     Errors:
        "." is returned if the nth variable doesn't exist
     Examples:
        Check if group BACKUP exists and how many vars it has:
             :"BACKUP->Str1
             :0
             :Asm(prgmGRPREAD
        Get the name/size/type of the first variable:
             :"BACKUP->Str1
             :1
             :Asm(prgmGRPREAD
     /=========================================================\
     |ExtractVar                                               |
     \=========================================================/
     |  This command allows you to extract a variable from the |
     |group, copying it to some variable in RAM. This also     |
     |allows you to rename the variable and it automatically   |
     |overwrites a preexisting variable (unless you specify not|
     |to overwrite). There are some pretty neat things you can |
     |do with this, especially for games.                      |
     \=========================================================/
     Inputs:
       Ans is a string containing the name of the group, the
       name of the variable to extract, and possibly the new
       name to extract to. The format:
         "<groupname>:<varname>:<newname>"
       The last argument is optional. If you put a "+" before
       the new name, the var will not be ungrouped if it already
       exists.
     Outputs:
       The variable is copied from the group to a var in RAM.
     Errors:
       0 is returned if the group does not exist.
     Examples:
       First, note that the prefix byte for a program is E and
       the prefix for an appvar is U. Now, to extract prgmFOO
       from group BACKUP:
            :"BACKUP:EFOO
            :Asm(prgmGRPREAD
       Now to extract prgmFOO to appvar BAR:
            :"BACKUP:EFOO:UBAR
            :Asm(prgmGRPREAD
       Now to extract it to appvar BAR without overwriting:
            :"BACKUP:EFOO:+UBAR
            :Asm(prgmGRPREAD
       To extract prgmFOO without overwriting it if it exists:
            :"BACKUP:EFOO:+
            :Asm(prgmGRPREAD
     Notes:
       As you can see, you are able to extract to completely
     different variable types. Use this to your advantage, but
     since lists, real numbers, and matrices have a different
     structure from the other variable types, you should not try
     to extract them or extract to them (or you will lose RAM).
     /=========================================================\
     |RecallPic                                                |
     \=========================================================/
     |  This will let you recall pictures directly from the    |
     |group. Not only that, but it gives you four different    |
     |methods of recalling the picture instead of the 1 way    |
     |that the OS provides.                                    |
     \=========================================================/
     Input (syntax 1):
       Ans is a string with the format
         "RecallPic <Pic#><logic><groupname>"
     Input (syntax 2):
       Ans is the picture number (0=Pic1, 1=Pic2,...,9=Pic0)
       Str1 has the format:
         "RecallPic <logic><groupname>"
       (This is useful for maps and monsters and hacked pics)
     Output:
       The picture var is drawn and the screen is updated if the
       picture variable exists.
     Notes:
       The logic tokens are as follows:
            xor
            and
            or    (This is what the OS uses).
       They can be found at [2nd][Math][Right]. If this argument
       is omitted, the picture will simply overwrite the data on
       the screen.
     Examples:
       Recall Pic1 from group BACKUP, overwriting the data on
     the screen:
            :"RecallPic Pic1BACKUP
            :Asm(prgmGRPREAD
       Recall Pic3 from group RPG using XOR logic (syntax 2):
            :"RecallPic  xor RPG->Str1
            :2
            :Asm(prgmGRPREAD
     /=========================================================\
     |LineRead                                                 |
     \=========================================================/
     |  This lets you read a line of code from a program in a  |
     |group. Note that the line doesn't actually need to be    |
     |code. You can store a bunch of names or words line by    |
     |line in a program. Then, using this function, you can    |
     |recall the data as a string in Ans. Enjoy!               |
     \=========================================================/
     Input:
       Str1 is of the form "Line(<groupname>,<varname>"
       Ans is the line number to read (or zero)
     Output:
       Ans is a string containing the name contents of the line.
       If Input Ans was zero, this instead returns the number of
         lines in the variable.
     Errors:
       ".NO DATA" is returned if the line is empty.
     Examples:
       Read the fourth line of prgmRPGDATA from the group RPG:
            :"Line(RPG,RPGDATA->Str1
            :4
            :Asm(prgmGRPREAD
================================================================
Notes:
  When I wrote this program, I was away from my computer,
internet (or electricity, for that matter) for several weeks. I
wrote the program using a combination of hex and a program named
ASMCOMP. It was basically like writing the program in hex the
normal way, but with the advantage of having labels and equates
and whatnot. Therefore, the source is in the form of a program
to be compiled by prgmASMCOMP.
================================================================
History:
7:37 PM 12/30/2012- Wrote the readme and prepared for initial
release. GetName,ExtractVar,RecallPic,LineRead.        985 bytes

Awesome! So, if you are drawing the sprite using XOR logic, you might be doing this:

XOR sprite 1 to the screen
XOR sprite 1 to erase it
XOR sprite 2 tot he screen
XOR sprite 2 to erase it

...

But really, you don't need to do that. You can create a sprite that will erase the previous sprite with XOR logic and replace it with the new sprite all at once. It is a little tricky to understand, but it might make your animation much smoother since it won't be blinking. For example, here are two sprites:

3C4281818181423C
0000182424180000

Instead of  doing :
XOR 3C4281818181423C
XOR 3C4281818181423C
XOR 0000182424180000
XOR 0000182424180000

You can draw the first sprite outside of the loop, then use a single sprite to toggle between the two images:
XOR 3C4281818181423C
Repeat <<main loop>>
XOR 3C4299A5A599423C   ;toggle between the two sprites
End
How do you find the "toggle" sprite? Simple: XOR the two sprites together and use the data it makes That will get rid of the moments where there is nothing on the screen, so there won't be any more blinking

Why is it having that issue? I'll try to see if I can use a link instead. For now, it is attached to this post.

That is awesome, thanks persalteas! I have not gotten around to creating that. Have you shown Merth that?

That looks rather awesome, if I do say so myself ^^

That version in the screenie updates the LCD every single frame, even if nothing has changed. The grayscale tiles update every frame, the ones in the middle-ish of the map update every 5 frames and the ones on the outer edge update once every 16 frames. I'm pretty sure speed won't be an issue, and even if I add the variable speed to the Axe version, it will only add a thousand cycles or less (still keeping it >60FPS). I am still trying to figure out a more clever and efficient method for this, though. It will be particularly difficult to smooth scroll the map with masking and a player sprite on it

Hmm, I must have never released the newer version Maybe it's because I had a bug in it or something ? Regardless, I used that version and it still worked fine. Do you have other apps installed? Maybe zStart or something that could be causing issues even after a RAM clear?