How would that work? If it is what I think, I might have to work on a routine for that...

That wasn't too difficult, that is why it was fast However, particle effects might be

Also, I added the /Text( as another option and I found an issue If you tried using Typewriter Textas well as displaying a number or displaying text at the last cursor position, it would not work. So, I fixed that
Now Text( has four operators

And I would also like to point out that the only "tricky" part to this was making tokens display one character at a time. Luckily, I use my own text display routine, so it wasn't impossible

So now I have a question: What modes should I add? For example, Text Inverse is one I can add. I plan to change modes using Fix, so for example, Fix 1 is text inverse, Fix 0 turns it off. Does anybody else have mode ideas?

This is probably going to gloss over a lot of key aspects, so if you have questions, feel free to ask
I realised that I still have yet to actually upload a tutorial anywhere for how to program with Grammer, so here goes This first section will describe some of the key aspects and it will provide an example

Part 1:
First off, I would like to introduce you to Grammer. Grammer is an interpreted programming language (like TI-BASIC), that can be programmed on your calculator (like TI-BASIC). If you program a lot in TI-BASIC, that will be helpful in learning Grammer, but it might cause some confusion, too. Because of that, I will introduce you to some of the key differences:

Numbers:
(simple) In Grammer, values are integers from 0 to 65535. Anything above or below is looped back around.
(complicated) Grammer uses 16-bit math. This makes things fast and simple for the interpreter while still being useful for games (I could have gone with 8-bit for even faster speed)

Math:
(simple) Math is done right to left and doesn't use order of operations. There are no parantheses. Also, overflow is detected for many operations and the overflow is stored to another var (theta prime)
(extra) Theta prime usually holds remainders or "carry." For example, if adding exceeds 16-bit range, 1 is returned as a "seventeenth bit."

Variables:
(simple) The letters can be used like in BASIC. These are called pointer vars in Grammer. You have A through Theta as well as their primes. For example, A and A' are two different pointer vars. Theta prime is used by the interpreter to return extra data or info so there are 53 vars to use and a system var. There are also strings and programs that can be accessed. To do this, you store them to a pointer var. For example, "HELLO→A is valid.
(complicated) When storing strings to a pointer var, you are actually storing the memory address that the data is located at. This is why they are called pointer vars. They point to the data, they don't actually contain it.

Using this information and a command reference, you will be on your way to making games!
(you can even use this to run algorithms faster than BASIC, if you are interested!)

So no we will make a simple program that moves a cursor around the screen! To do this, we will use the rectangle commands, getKey, and a Repeat loop. Depending on how you want the program to run will determine the header. For now, use .0:Asm(prgmGRAMMER as that will work universally for any method:
.0:Asm(prgmGRAMMER         ;This is the start of the program
0→X →Y                     ;Initiallises the coordinates. Note the space.
Repeat A=15                ;A will hold have the keypress, so this checks for [CLEAR]
Line(X,Y,6,6,2             ;draws an inverted 8x8 rectangle
DispGraph                  ;updates the LCD screen
Line(X,Y,6,6,2             ;Reinverts the rectangle.
Repeat A                   ;Repeats loop until A is not 0
getKey→A                   ;Stores the key code to A
End                        ;Ends the Repeat loop
X+A=3 -A=2                 ;Updates X coordinate based on key press, Result in Ans
If <91                     ;If it goes below zero, so this checks for going offscreen!
→X                         ;If it is on screen still, the new value is stored to X
Y+A=1 -A=4                 ;Updates X coordinate based on key press, Result in Ans
If <59                     ;Checks if the cursor would be offscreen
→Y                         ;If it is on screen still, the new value is stored to Y
End

Stop                       ;Ends the program
Press Clear or ON to exit

Sorry, I have never done anything like that, so I can't help off the top of my head I know you can use the actual bcalls to those commands, I am just not sure of the syntax for things like prompt.

What do you mean by token changes?

Maybe, I am not sure yet. If I do, I will have to create my own variable storage system, which could be interesting. If I make lists, for example, to access the first element, you would need to do something like {L1→A or to access the next element, {L1+2→A because it would really just be an array of data.

I think I could add a way to create your own vars and then use them for data storage

Stefan Bauwens: Thanks Also, you are almost evil
As long as you need to rely on Ans. Otherwise, you can do something like this:
getKey=9
If *C=1
<<code>>
That will be like using getKey=9 and C=1. Likewise, you can do:
getKey=9
If +C=1
<<code>>
That will be like using or .