As many already know by now, Grammer is a programming language with much to offer. The App version has more commands and features present and it also works as a shell. It is a work in progress and probably will never be "finished."

Math:

Grammer currently handles up to 16-bit inputs (so integers 0 to 65535). Some math commands return data in 2 16-bit vars called pointer vars or pvars (so multiplication could output a 32-bit result). Here are supported math commands:

There are also a bunch of drawing commands (there is also much to ask for .__.):

And there are then a bunch of memory features and fun features (like the particle commands). You can make OS variables, delete them, edit them, archive them or unarchive them, copy them to RAM as needed, read from them, execute them, use Assembly programs, use subroutines by jumping or calling them, use subprograms, comment code, as well as a slew of other commands and features.

So that is all good and great and yummy and tasty and all, but what you probably want to know is, what can it do? Well, I believe technically anything with enough time and memory, even without the available aid of assembly. So I will instead show what it has been able to do:

Math:

Grammer currently handles up to 16-bit inputs (so integers 0 to 65535). Some math commands return data in 2 16-bit vars called pointer vars or pvars (so multiplication could output a 32-bit result). Here are supported math commands:

**Code:**```
```

• / is used to divide two numbers. The remainder is stored in theta prime.

• * is used to multiply two values. The lower 16 bits are stored to "Ans" and the upper 16 bits (for the 32-bit value) are stored in theta prime.

• - is used to subtract two numbers. Numbers below 0 are calculated as if 65536 was added. For example, 3-6 would result in -3 which is 65536-3 or 65533. If the number goes below 0, theta prime is 1, else it is 0.

• + is used to add two numbers. If the number exceeds 65535, 65536 is subtracted from it and theta prime is 1. Otherwise, theta prime is 0. For example, 65534+99 would return 97, and theta prime as 1.

• 2 multiplies a number by itself

• √( takes the square root of the number

• √(' takes the rounded square root of the number

• sin( takes the sine of a number. This has a period of 256 and returns a value from -127 to 127.

• cos( takes the cosine of a number. This has a period of 256 and returns a value from -127 to 127.

• abs( returns the absolute value of a number. If the number is greater than or equal to 32768 (2^15), this returns 65536 minus the number. For example, abs(65533) would return 65536-65533=3.

• min( returns the lower of two values. For example, min(3,A) returns 3 if A is larger than 3 or the value of A if A is less than 3.

• max( returns the larger of two values.

• gcd( returns the Greatest Common Divisor of two numbers

• lcm( returns the Least Common Multiple of two numbers

• nCr will perform the operation n choose r.

There are also a bunch of drawing commands (there is also much to ask for .__.):

**Code:**```
```

• Pt-On( is used to draw tiles to the graph screen. These can be multiples of 8 bytes wide (up to 96) and 1 to 64 pixels tall. These are tiles as they can only be drawn at every 8th pixel in the X direction. Also worth noting, there are 6 methods currently of drawing a sprite in this mode as well as an input option of straight data or hex.

• Pt-Off( is used to draw sprites to the graph screen at pixel coordinates. There are only 5 options for drawing the sprite, here.

• Line( is used to draw rectangles. There are 12 rectangle drawing methods available

• Line(' is used to draw an actual line. There are 3 options here

• Pxl-On(

• Pxl-Off(

• Pxl-Change(

• pxl-Test(

• DispGraph draws the current drawing buffer to the LCD

• Disp changes the location of the drawing buffer

• Circle( draws a circle (there are 3 options)

• ClrDraw wipes the drawing buffer clean

• Tangent( shifts the screen a number of pixels in a given direction

• Text( has a bunch of options that would take a while to list here XD

• Fill( is a bunch of sub commands that do a bunch of things dealing with buffers (there are a little over 20 commands here)

And there are then a bunch of memory features and fun features (like the particle commands). You can make OS variables, delete them, edit them, archive them or unarchive them, copy them to RAM as needed, read from them, execute them, use Assembly programs, use subroutines by jumping or calling them, use subprograms, comment code, as well as a slew of other commands and features.

So that is all good and great and yummy and tasty and all, but what you probably want to know is, what can it do? Well, I believe technically anything with enough time and memory, even without the available aid of assembly. So I will instead show what it has been able to do: