routine: starts the definition of a routine. Example:

routine: routine1       # Creates a routine with the name routine1
...

end is used to mark the end of the routine. Example:

...
end      # All that's needed to end the routine definition

var is used to create variables. Currently a variable can only hold a single value (i.e. not a str) from 0x0 to 0xEFFF. Variables can be loaded into registers, be stored to from registers or be printed to the screen using draw var <variable>. Examples:

var age = num 34
var addr = lit 0xBEEF

lit will use the given value as is (thus "lit" for "literal") without any conversion, which is why the value must not be longer than four characters (without the prefix) and it must not contain any special symbols; only 0-9and A-F are allowed. Especially useful when you need to specify addresses. Examples:

lit 0x0FA3
lit 0FA3
lit FA3
# These are all the same

hex Interprets the following value as character, converting it to its numerical ASCII representation. A hex must only be a single character. Examples:

load A hex U        # "U" will be converted to 0x0055 and loaded into Register A
load A lit 0x0055   # Same value

num enables you to use any decimal number from 0 to 61439. Examples:

load A num 7        # Number 7 will be loaded into the A register. Would be the same as "lit 0x0007"
load B num 61439    # Number 61439 will be loaded into the B register. Would be the same as "lit 0xEFFF"

str is currently only used for drawing and will simply convert each character into a u16 that will be stored into the GPU buffer without interruption. The assembler will automatically add an escape character ("`") to the end of the string so the GPU knows when to exit drawing mode. Whitespace is not allowed inside a str, use the character ^ instead. Example:

draw str Hello^World!  # Will print "Hello World!" to the screen

col is currently only used for drawing. It is placed behind a str to color it. You can also just not use it, then the assembler will default to making the str white. Example:

draw str Hello^World! col red  # Will print a red "Hello World!" to the screen

reg is used to tell some instructions to get the value from the specififed register. It is needed for instructions that aren't directly linked to the registers, e.g. the comp instruction. There are four available registers: A, B, C and D. Example:

comp reg A num 8   # Compares the register A to the number 8, setting the eq_flag accordingly

1. In "entry": Loads the A register with the value 1
2. In "entry": Jumps to a routine called "loop"
3. In "loop": Add 1 to the value in the A register
4. In "loop": Compare the value in the A register to 10000, set the eq_flag if true
5. In "loop": If the eq_flag is not set, jump to a routine called "loop" (itself here), otherwise continue
6. In "loop": "Return to origin" instruction returns to where the program came from, moving on from there
7. In "entry": Send the CPU into the halt loop, stopping execution

load is used to load a value into a register. Which register is specified by the first argument, the value by the second. Examples:

load A num 7
load B hex H
load C lit 0x06AF

stor is used to store a value from the register specified by the first argument to the address specified in the second argument. It's also possible to store a registers value to a variable Examples:

stor A lit 0x56FA  # Stores the value in the A register to address 0x56FA (the 22266th address) in the memory
stor A num 22266
stor A var <variable> # Stores the value in the A register to the specified variable

jump is used to simply jump to a given address or routine. Examples:

jump lit 0x56FA    # Jumps to the address 0x56FA (the 22266th address) in the memory
jump num 22266     # You can also use a number directly

jump <routine>

juie is used just like jump with the slight difference that it only jumps to the specified address if the CPU's eq_flag is set. Examples:

juie lit 0x56FA    # Jumps to the address 0x56FA (the 22266th address) in the memory if the eq_flag is set
juie num 22266     # You can also use a number directly

juin is used just like jump with the slight difference that it only jumps to the specified address if the CPU's eq_flag is NOT set. Examples:

juin lit 0x56FA    # Jumps to the address 0x56FA (the 22266th address) in the memory if the eq_flag is NOT set
juin num 22266     # You can also use a number directly

bran is used just like jump with the slight difference that it saves the previous position to the stack, allowing the program to return to the previous position using rtor. Examples:

bran lit 0x56FA    # Jumps to the address 0x56FA (the 22266th address) in the memory
bran num 22266     # You can also use a number directly

brie is used just like bran with the slight difference of it being conditional, here if the equal flag is set. Example:

comp num 8 num 9
brie <routine>    # Will not jump to the specified routine

comp num 9 num 9
brie <routine>    # Will jump to the specified routine

brin is used just like bran with the slight difference of it being conditional, here if the equal flag is NOT set. Example:

comp num 8 num 9
brin <routine>    # Will jump to the specified routine

comp num 9 num 9
brin <routine>    # Will not jump to the specified routine

rtor is used to return from a routine to the previous position. Example:

rtor    # This doesn't take any arguments

noop Simply makes the CPU do nothing for one cycle. Example:

noop    # Makes the CPU do nothing for one cycle

setv is used to set an address in the memory to the specified value. Examples:

setv lit 0x56FA hex U       # Sets the address 0x56FA (the 22266th address) in the memory to the ASCII representation of the character 'U'
setv num 22266 lit 0x0055   # You can also use a number or hex values directly

comp is used to compare two values. These values must not be bigger than 0xEFFF (61439). If those values are equal, the CPU's eq_flag will be set. The values to be compared can either be registers or specified directly. Examples:

comp lit 0x4000 num 8    # Compares the hexadecimal value 0x4000 with the decimal value 8
comp reg A num 8         # Compares the content of register A with the decimal value 8
comp reg A reg B         # Compares two registers

radd is used to increment a register's value by the following value. Examples:

radd A num 8      # Increases the value in the A register by 8
radd B hex 12     # Increases the value in the B register by 0x12 (18 in decimal)

rsub is used to decrement a register's value by the following value. Examples:

rsub A num 8      # Decreases the value in the A register by 8
rsub B hex 12     # Decreases the value in the B register by 0x12 (18 in decimal)

rmul is used to multiply a register's value by the following value. Examples:

rmul A num 8      # Multiplies the value in the A register by 8
rmul B hex 12     # Multiplies the value in the B register by 0x12 (18 in decimal)

rdiv is used to divide a register's value by the following value. Examples:

rdiv A num 8      # Divides the value in the A register by 8
rdiv B hex 12     # Divides the value in the B register by 0x12 (18 in decimal)

draw is a versatile instruction used to print things to the VM's monitor. It can be used to print str types, the content of registers or variables. It supports colored printing of str types. Currently available colors are red, green, blue, cyan and magenta. Examples:

draw str Hello^World! col green    # Prints a green "Hello World!" to the screen
draw str Hello^World!              # No color specification will default to white

draw reg A        # Prints the content of the A register
draw var value    # Prints the value of the variable "value"

ctrl is used to control the GPU and the CPU. Examples:

ctrl cpu halt     # Stops the CPU and execution of the program

ctrl gpu clear    # Clears the screen
ctrl gpu reset    # Resets the gpu