The code in the code sections is a simple language that has similarties to C. Some basic features of this language are:

• Parenthesis "(" and ")" are used to clarify precidence, contain parameters for functions, or collect blocks of code into one statement.
• A semicolon ";" is used to separate statements from eachother (even within parenthesis, though it is not required for the last statement within parenthesis).
• Variables do not need to be declared. Simply using a variable is enough to create it.
• All variables have a global scope (meaning you can access them from any code section).
• All variables represent real values (i.e. 0, 1, 3.14159, -3, 3000000000000000.0 are all values that they can represent).
• In addition to variables, JS effects also have approximately 8 million slots of local RAM, and 1 million slots of shared (global across all effects) RAM.
• Numbers by default are in normal decimal, however if you prefix an 'x' to them, they will be hexadecimal (i.e. x90, xDEADBEEF, etc), 'o' for octal (o755), or 'b' for binary (b10110101). $xDEADBEEf is an alternate way of specifying hex numbers.
• You may specify the ASCII value of a character using $'c' (where c is the character).
• Comments can be specified using:
  • // comments to end of line
  • /* comments block of code that span lines or be part of a line */

• =
  Example: y = z;
  Assigns the value of 'z' to 'y'. 'z' can be a variable or an expression.
• *
  Example: y * z
  Multiplies two values and returns the product.
• /
  Example: y / z
  Divides two values and returns the quotient.
• %
  Example: y % z
  Divides two values and returns the remainder.
• ^
  Example: y ^ z
  Returns the first parameter raised to the second parameter-th power.
• +
  Example: y + z
  Adds two values and returns the sum.
• -
  Example: y - z
  Subtracts two values and returns the difference.
• |
  Example: y | z
  Converts both values to integer, and returns bitwise OR of values.
• &
  Example: y & z
  Converts both values to integer, and returns bitwise AND of values.
• *=
  Example: y *= z
  Multiplies two values and stores the product back into 'y'.
• /=
  Example: y /= z
  Divides two values and stores the quotient back into 'y'.
• %=
  Example: y %= z
  Divides two values and stores the remainder back into 'y'.
• ^=
  Example: y ^= z
  Raises first parameter to the second parameter-th power, saves back to 'y'.
• +=
  Example: y += z
  Adds two values and stores the sum back into 'y'.
• -=
  Example: y -= z
  Subtracts two values and stores the difference back into 'y'.
• |=
  Example: y |= z
  Converts both values to integer, and stores the bitwise OR into 'y'
• &=
  Example: y &= z
  Converts both values to integer, and stores the bitwise AND into 'y'
• ||
  Example: y || z Returns logical OR of values. If y is nonzero, 'z' is not evaluated.
• &&
  Example: y && z
  Returns logical AND of values. If y is zero, 'z' is not evaluated.
• ==
  Example: y == z
  Compares two values, returns 1 if equal, 0 if not.
• !=
  Example: y != z
  Compares two values, returns 0 if equal, 1 if not.
• <
  Example: y < z
  Compares two values, returns 1 if first parameter is less than second.
• >
  Example: y > z
  Compares two values, returns 1 if first parameter is greater than second.
• <=
  Example: y <= z
  Compares two values, returns 1 if first is less than or equal to second.
• >=
  Example: y >= z
  Compares two values, returns 1 if first is greater than or equal to second.
• !
  Example: !z
  Returns the logical NOT of the parameter (if the parameter is 0.0, returns 1.0, otherwise returns 0.0).
• ?      -- this is how branching is done -- like C's if()
  ? :
  Example: y ? z;
  Example: y ? z : x;
  Evaluates the first parameter 'y', and if nonzero, evaluates and returns the second parameter 'z'. If a third parameter 'x' is specified (after the :), and the first parameter is zero, evaluates and returns 'x'. The latter two expressions may often contain multiple statements seperated by semicolons, i.e.

        x % 5 ? (
          f += 1;
          x *= 1.5;
        ) : (
          f=max(3,f);
          x=0;
        );
  

• [ ]
  Example: z=x[y]; or x[y]=z;
  Example: z=gmem[y]; or gmem[y]=z;
  In the first form, you may use brackets to index into memory that is local to your effect. Your effect has approximately 8 million (8,388,608) slots of memory and you may access them either with fixed offsets (i.e. 16811[0]) or with variables (myBuffer[5]). If a value in the brackets is omitted then 0 is used instead.
  
  If 'gmem' is specified (the second form), then instead of local effect memory, the buffer is the global storage buffer, which is approximately 1 million (1,048,576) slots that are shared across all effects.

• sin(angle)
  Example: s = sin(theta);
  Returns the Sine of the angle specified (specified in radians).
  
  (To convert from degrees to radians, multiply by $pi/180, or 0.017453)
  
  
• cos(angle)
  Example: s = cos(theta);
  Returns the Cosine of the angle specified (specified in radians).
  
  
• tan(angle)
  Example: s = tan(theta);
  Returns the Tangent of the angle specified (specified in radians).
  
  
• asin(x)
  Example: theta = asin(s);
  Returns the Arc Sine of the value specified (return value is in radians).
  
  
• acos(x)
  Example: theta = acos(s);
  Returns the Arc Cosine of the value specified (return value is in radians).
  
  
• atan(x)
  Example: theta = atan(s);
  Returns the Arc Tangent of the value specified (return value is in radians).
  
  
• atan2(x,y)
  Example: theta = atan2(s,sd);
  Returns the Arc Tangent of s divided by sd (return value is in radians). This uses the signs of the inputs to determine the correct quadrant.
  
  
• sqr(x)
  Example: ss = sqr(s);
  Returns the square of the parameter (i.e. same as ss=s*s;).
  
  
• sqrt(x)
  Example: ss = sqrt(s);
  Returns the square root of the parameter.
  The parameter should be greater than or equal to zero.
  
  
• pow(x,y)
  Example: p = pow(s,y);
  Returns the first parameter raised to the second parameter-th power.
  Note: This is exactly the same as the operator ^, and is provided for compatibility.
  
  
• exp(x)
  Example: ss = exp(s);
  Returns the number e (approx 2.718) raised to the parameter-th power.
  
  
• log(x)
  Example: ss = log(s);
  Returns the natural logarithm (base e) of the parameter.
  
  
• log10(x)
  Example: ss = log10(s);
  Returns the logarithm (base 10) of the parameter.
  
  
• abs(x)
  Example: ss = abs(s);
  Returns the absolute value of the parameter.
  
  
• min(x,y)
  Example: s = min(x,y); Returns the minimum value of the two parameters.
  
  
• max(x,y)
  Example: s = max(x,y);
  Returns the maximum value of the two parameters.
  
  
• sign(x)
  Example: s = sign(x);
  Returns the sign of the parameter (-1, 0, or 1).
  
  
• rand(x)
  Example: s = rand(x);
  Returns a psuedorandom whole number between 0 and the parameter.
  
  
• floor(x)
  Example: s = floor(x);
  Rounds the value to the lowest integer possible (i.e. 3.9 becomes 3).
  
  
• ceil(x)
  Example: s = ceil(x);
  Rounds the value to the highest integer possible (i.e. 3.1 becomes 4).
  
  
• invsqrt(x)
  Example: s = invsqrt(x);
  Returns a fast inverse square root (1/sqrt(x)) approximation of the parameter.