Programming Reference
This is the reference for 's . In the first section of this chapter have a look at some aspects of the grammar of programs. The second section deals exclusively with mathematical operators, boolean (true/false) operators and comparison operators. The third section is basically a giant list of all commands explaining them one-by-one. Section four explains how to assign values to variables. Finally we explain how to arrange the execution of commands with execution controlling statements in section five and how to create you own commands with learn in section six.

The Grammar of
As in any language, has different types of words and symbols. In English we distinguish verbs (like 'to walk' or 'to sing') and nouns (like 'sister' or 'house'), they are used for different purposes. is a programming language, it is used to instruct what to do.
In this section some of 's different types of words and symbols are briefly explained. We explain comments, commands and the three different kinds of literals: numbers, strings and boolean (true/false) values.

Comments
A program consists instructions that are executed when the program is run and so called comments. Comments are not executed, simply ignores them when executing your program. Comment are there for other programmers to make them understand your program better. Everything that follows on a # symbol is considered a comment in . For example this little program that does nothing:

# this little program does nothing, it is only a comment!

It is a bit useless but it explain the matter well.
Comments get very useful when the program gets a little bit more complex. It can help to give some advice to other programmers. In the following program you see comments being used together with the print command.

# this program has been made by Cies Breijs.
print "this text will get printed on the canvas"
# the previous line is not a comment, but the next line is:
# print "this text will not get printed!"

The first line describes the program. The second line is executed by and prints this text will get printed on the canvas on the canvas. The third line is a comment. And the forth line is a comment that contains a piece of , if the # symbol would be removed on the fourth line the print statement will we executed by . Programmers say: the print statement on the fourth line is 'commented out'.
Commented lines are highlighted with light gray in the code editor.

Commands
Using commands you tell the turtle or to do something. Some commands need input, some give output.

# forward is a command that needs input, in this case the number 100:
forward 100

The first line is a comment. The second line contains the forward command and the number 100. The number is not part of command, it is considered 'input' for the command.
Some commands like ⪚ go need more than one input value. Multiple values have to be separated using the , character (comma).
For a detailed overview of all commands that supports go here. Built-in commands are highlighted in dark blue

Numbers
Most likely you already know quite a bit about numbers. The way numbers are used in is not much different from spoken language, or math.
We have the so called natural numbers: 0, 1, 2, 3, 4, 5, etc. The negative numbers: -1, -2, -3, etc. And the numbers with decimals, or dot-numbers, for example: 0.1, 3.14, 33.3333, -5.05, -1.0. The . character (dot) is used as decimal separator.
Numbers can be used in mathematical operators and comparison operators. They can also be stored in variables. Numbers are highlighted in dark red.

Strings
First an example:

print "Hello, I'm a string."

In this example print is a command where "Hello, I'm a string." is a string. Strings start and end with the " mark, by these marks knows it is a string.
Strings can be put in variables, just like numbers. Yet, unlike numbers, strings cannot be used in mathematical operators or comparison operators. Strings are highlighted with red.

Boolean (true/false) values
There are only two boolean values: true and false. Sometimes they are also called: on and off, yes and no, one and zero. But in we call them, always, true and false. Have a look at this piece of :

$a = true

If you look in the inspector you can see that the variable $a is set to true, and has the boolean type.
Often boolean values are the result of a comparison operator, like in the following piece of :

$answer = 10 > 3

The variable $answer is set to true because 10 is larger than 3.
Boolean values, true and false, are highlighted with dark red.

Mathematical, boolean and comparing operators
The title of this section might sound very difficult, yet it is not as difficult as it sound.

Mathematical operators
These are the basic math symbols known as: add (+), subtract (-), multiply (*), divide (/) and power (^).
Here a small example of the mathematical operators you can use in :

$add      = 1 + 1
$subtract = 20 - 5
$multiply = 15 * 2
$divide   = 30 / 30
$power    = 2 ^ 2

The values resulting from the mathematical operations get assigned to various variables. Using the inspector you can see the values.
If you just want a simple calculation to be done you can do something like this:

print 2010-12

Now an example with parentheses:

print ( ( 20 - 5 ) * 2 / 30 ) + 1

The expressions inside parentheses will be calculated first. In this example, 20-5 will be calculated, then multiplied by 2, divided by 30, and then 1 is added (giving 2). Parentheses can also be used in other cases.
also has more advanced mathematical features in the form of commands. Have a look at the following commands but be aware that it concerns advanced operations: round, random, sqrt , pi, sin, cos, tan, arcsin, arccos, arctan.

Boolean (true/false) operators
Where mathematical operators are mainly for numbers, boolean operators are for boolean values (true and false). There are only three boolean operators, namely: and, or, and not. The following piece of shows how to use them:

$and_1_1 = true and true    # -> true
$and_1_0 = true and false   # -> false
$and_0_1 = false and true   # -> false
$and_0_0 = false and false  # -> false

$or_1_1 = true or true    # -> true
$or_1_0 = true or false   # -> true
$or_0_1 = false or true   # -> true
$or_0_0 = false or false  # -> false

$not_1 = not true   # -> false
$not_0 = not false  # -> true

Using the inspector you can see the values, yet we also supply these results as little comments at the end of the lines. and evaluates true only if both sides are true. or evaluates true if either side is true. And not turns a true into false and a false into true.
Boolean operators are highlighted with pink.

Some more advanced examples
Consider the following example with and:

$a = 1
$b = 5
if (($a < 10) and ($b == 5)) and ($a < $b) {
  print "hello"
}

In this piece of the result of three comparing operators are merged using and operators. This means that all three have to evaluate "true" in order for the "hello" to be printed.
An example with or:

$n = 1
if ($n < 10) or ($n == 2) {
  print "hello"
}

In this piece of the left side of the or is evaluating to 'true', the right side to 'false'. Since one of the two sides of the or operator is 'true', the or operator evaluates 'true'. That means "hello" gets printed.
And finally an example with not which changes 'true' into 'false' and 'false' into 'true'. Have a look:

$n = 1
if not ($n == 3) {
  print "hello"
} else {
  print "not hello ;-)"
}

Comparing operators
Consider this simple comparison:

$answer = 10 > 3

Here 10 is compared to 3 with the 'greater than' operator. The result of this comparison, the boolean value true is stored in the variable $answer.
All numbers and variables (that contain numbers) can be compared to each other with comparing operators.
Here are all possible comparing operators:

Types of questions
$A == $B	equals	answer is true if $A equals $B
$A != $B	not-equals	answer is true if $A does not equal $B
$A > $B	greater than	answer is true if $A is greater than $B
$A < $B	smaller than	answer is true if $A is smaller than $B
$A >= $B	greater than or equals	answer is true if $A is greater than or equals $B
$A <= $B	smaller than or equals	answer is true if $A is smaller than or equals $B
Please note that $A and $B have to be numbers or variables that contain numbers.

Commands
Using commands you tell the turtle or to do something. Some commands need input, some give output. In this section we explain all the built-in commands of . Alternatively, using learn, you can create your own commands. Built-in commands we discuss here are highlighted with dark blue.

Moving the turtle
There are several commands to move the turtle over the screen.
forward (fw) 	

forward X

forward moves the turtle forward by the amount of X pixels. When the pen is down the turtle will leave a trail. forward can be abbreviated to fw
backward (bw) 	

backward X

backward moves the turtle backward by the amount of X pixels. When the pen is down the turtle will leave a trail. backward can be abbreviated to bw.
turnleft (tl) 	

turnleft X

turnleft commands the turtle to turn an amount of X degrees to the left. turnleft can be abbreviated to tl.
turnright (tr) 	

turnright X

turnright the turtle to turn an amount of X degrees to the right. turnright can be abbreviated to tr.
direction (dir) 	

direction X

direction set the turtle's direction to an amount of X degrees counting from zero, and thus is not relative to the turtle's previous direction. direction can be abbreviated to dir.
getdirection 	

getdirection

getdirection returns the turtle's direction as an amount of degrees counting from zero, where zero is the direction when the turtle is pointing upwards.
center 	

center

center moves the turtle to the center on the canvas.
go 	

go X,Y

go commands the turtle to go to a certain place on the canvas. This place is X pixels from the left of the canvas, and Y pixels from the top of the canvas.
gox 	

gox X

gox using this command the turtle will move to X pixels from the left of the canvas whilst staying at the same height.
goy 	

goy Y

goy using this command the turtle will move to Y pixels from the top of the canvas whilst staying at the same distance from the left border of the canvas.
Using the commands go, gox, goy and center the turtle will not draw a line, no matter if the pen is up or down.

Where is the turtle?
There are two commands which return the position of the turtle on the screen.
getx 	 getx returns the number of pixels from the left of the canvas to the current position of the turtle.
gety 	 gety returns the number of pixels from the top of the canvas to the current position of the turtle.

The turtle has a pen
The turtle has a pen that draws a line when the turtle moves. There are a few commands to control the pen. In this section we explain these commands.
penup (pu) 	

penup

penup lifts the pen from the canvas. When the pen is up no line will be drawn when the turtle moves. See also pendown. penup can be abbreviated to pu.
pendown (pd) 	

pendown

pendown presses the pen down on the canvas. When the pen is press down on the canvas a line will be drawn when the turtle moves. See also penup. pendown can be abbreviated to pd.
penwidth (pw) 	

penwidth X

penwidth sets the width of the pen (the line width) to an amount of X pixels. penwidth can be abbreviated to pw.
pencolor (pc) 	

pencolor R,G,B

pencolor sets the color of the pen. pencolor takes an RGB combination as input. pencolor can be abbreviated to pc.

Commands to control the canvas
There are several commands to control the canvas.
canvassize (cs) 	

canvassize X,Y

With the canvassize command you can set the size of the canvas. It takes X and Y as input, where X is the new canvas width in pixels, and Y is the new height of the canvas in pixels. canvassize can be abbreviated to cs.
canvascolor (cc) 	

canvascolor R,G,B

canvascolor set the color of the canvas. canvascolor takes an RGB combination as input. canvascolor can be abbreviated to cc.

Commands to clean up
There are two commands to clean up the canvas after you have made a mess.
clear (ccl) 	

clear

With clear you can clean all drawings from the canvas. All other things remain: the position and angle of the turtle, the canvascolor, the visibility of the turtle, and the canvas size.
reset 	

reset

reset cleans much more thoroughly than the clear command. After a reset command everything is like is was when you had just started . The turtle is positioned at the middle of the screen, the canvas color is white, the turtle draws a black line on the canvas and the canvassize is set to 400 x 400 pixels.

The turtle is a sprite
First a brief explanation of what sprites are: sprites are small pictures that can be moved around the screen, like we often see in computer games. Our turtle is also a sprite. For more info see the glossary on sprites.
Next you will find a full overview on all commands to work with sprites.
[The current version of does not yet support the use of sprites other than the turtle. With future versions you will be able to change the turtle into something of your own design]
spriteshow (ss) 	

spriteshow

spriteshow makes the turtle visible again after it has been hidden. spriteshow can be abbreviated to ss.
spritehide (sh) 	

spritehide

spritehide hides the turtle. This can be used if the turtle does not fit in your drawing. spritehide can be abbreviated to sh.

Can the turtle write?
The answer is: yes. The turtle can write: it writes just about everything you command it to.
print 	

print X

The print command is used to command the turtle to write something on the canvas. print takes numbers and strings as input. You can print various numbers and strings using the + symbol. See here a small example:

$year = 2003
$author = "Cies"
print $author + " started the KTurtle project in " + $year + " and still enjoys working on it!"

fontsize 	

fontsize X

fontsize sets the size of the font that is used by print. fontsize takes one input which should be a number. The size is set in pixels.

Mathematical commands
The following commands are 's more advanced mathematical commands.
round 	

round(x)

round the given number to the nearest integer.

print round(10.8)
forward 20
print round(10.3)

With this code the turtle will print the numbers 11 and 10.
random (rnd) 	

random X,Y

random is a command that takes input and gives output. As input are required two numbers, the first (X) sets the minimum output, the second (Y) sets the maximum. The output is a randomly chosen number that is equal or greater than the minimum and equal or smaller than the maximum. Here a small example:

repeat 500 {
  $x = random 1,20
  forward $x
  turnleft 10 - $x
}

Using the random command you can add a bit of chaos to your program.
mod 	

mod X,Y

The mod returns remainder of the division of first number by the second number.
sqrt 	

sqrt X

The sqrt command is sued to find the square root of a number, X.
pi 	

pi

This command returns the constant Pi, 3.14159.
sin, cos, tan 	

sin X
cos X
tan X

These three commands represent the world famous trigoniometrical functions sin, cos and tan. The input argument of these commands, X, is a number.
arcsin, arccos, arctan 	

arcsin X
arccos X
arctan X

These commands are the inverse functions of sin, cos and tan. The input argument of these commands, X, is a number.

Input and feedback though dialogs
A dialog is a small pop-up window that provides some feedback or asks for some input. has two commands for dialogs, namely: message and ask
message 	

message X

The message command takes a string as input. It shows a pop-up dialog containing the text from the string.

message "Cies started KTurtle in 2003 and still enjoys working on it!"

ask 	

ask X

ask takes a string as input. It shows this string in a pop-up dialog (similar to message), along with an input field. After the user has entered a number or a string into this, the result can be stored in a variable or passed as an argument to a command. For example:

$in = ask "What is your year of birth?"
$out = 2003 - $in
print "In 2003 you were " + $out + " years old at some point."

If the user cancels the input dialog, or does not enter anything at all, the variable is empty.

Assignment of variables
First we have a look at variables, then we look at assigning values to those variables.
Variables are words that start with a $, in the editor they are highlighted with purple.
Variables can contain any number, string or boolean (true/false) value. Using the assignment, =, a variable is given its content. It will keep that content until the program finishes executing or until the variable is reassigned to something else.
You can use variables, once assigned, just as if they are their content. For instance in the following piece of :

$x = 10
$x = $x / 3
print $x

First the variable $x is assigned to 10. Then $x is reassigned to itself divided by 3 — this effectively means $x is reassigned to product of 10 / 3. Finally $x is printed. In line two and three you see that $x is used as if it is its contents.
Variables have to be assigned in order to be used. For example:

print $n

Will result in an error message.
Please consider the following piece of :

$a = 2004
$b = 25

# the next command prints "2029"
print $a + $b
backward 30
# the next command prints "2004 plus 25 equals 2029"
print $a + " plus " + $b + " equals " + ($a + $b)

In the first two lines the variables $a and $b are set to 2004 and 25. Then in two print commands with a backward 30 in between are executed. The comments before the print commands explain what they are doing. The command backward 30 is there to make sure every output is on a new line. As you see variables can be used just as if their where what they contain, you can use them with any kind of operators or give them as input when invoking commands.
One more example:

$name = ask "What is your name?"
print "Hi " + $name + "! Good luck while learning the art of programming..."

Pretty straight forward. Again you can see that the variable $name, treated just like a string.
When using variables the inspector is very helpful. It shows you the contents of all variables that are currently in use.

Controlling execution
The execution controllers enable you — as their name implies — to control execution.
Execution controlling commands are highlighted with dark green in a bold font type. The brackets are mostly used together with execution controllers and they are highlighted with black.

Have the turtle wait
If you have done some programming in you have might noticed that the turtle can be very quick at drawing. This command makes the turtle wait for a given amount of time.
wait 	

wait X

wait makes the turtle wait for X seconds.

repeat 36 {
  forward 5
  turnright 10
  wait 0.5
}

This code draws a circle, but the turtle will wait half a second after each step. This gives the impression of a slow-moving turtle.

Execute "if"
if 	

if boolean { ... }

The code that is placed between the brackets will only be executed if the boolean value evaluates true.

$x = 6
if $x > 5 {
  print "$x is greater than five!"
}

On the first line $x is set to 6. On the second line a comparing operator is used to evaluate $x > 5. Since this evaluates true, 6 is larger than 5, the execution controller if will allow the code between the brackets to be executed.

If not, in other words: "else"
else 	

if boolean { ... } else { ... }

else can be used in addition to the execution controller if. The code between the brackets after else is only executed if the boolean evaluates false.

reset
$x = 4
if $x > 5 {
  print "$x is greater than five!"
} else {
  print "$x is smaller than six!"
}

The comparing operator evaluates the expression $x > 5. Since 4 is not greater than 5 the expression evaluates false. This means the code between the brackets after else gets executed.

The "while" loop
while 	

while boolean { ... }

The execution controller while is a lot like if. The difference is that while keeps repeating (looping) the code between the brackets until the boolean evaluates false.

$x = 1
while $x < 5 {
  forward 10
  wait 1
  $x = $x + 1
}

On the first line $x is set to 1. On the second line $x < 5 is evaluated. Since the answer to this question is true the execution controller while starts executing the code between the brackets until the $x < 5 evaluates false. In this case the code between the brackets will be executed 4 times, because every time the fifth line is executed $x increases by 1.

The "repeat" loop
repeat 	

repeat number { ... }

The execution controller repeat is a lot like while. The difference is that repeat keeps repeating (looping) the code between the brackets for as many times as the given number.

The "for" loop, a counting loop
for 	

for variable = number to number { ... }

The for loop is a counting loop, it keeps count for you. The first number sets the variable to the value in the first loop. Every loop the number is increased until the second number is reached.

for $x = 1 to 10 {
  print $x * 7
  forward 15
}

Every time the code between the brackets is executed the $x is increased by 1, until $x reaches the value of 10. The code between the brackets prints the $x multiplied by 7. After this program finishes its execution you will see the times table of 7 on the canvas.
The default step size of a loop is 1, you can use an other value with

for variable = number to number step number { ... }

Leave a loop
break 	

break

Terminates the current loop immediately and transfers control to the statement immediately following that loop.

Stop executing your program
exit 	

exit

Finishes the execution of your program.

Create your own commands with learn
learn is special as it is used to create your own commands. The commands you create can take input and return output. Let us take a look at how a new command is created:

learn circle $x {
  repeat 36 {
    forward $x
    turnleft 10
  }
}

The new command is called circle. circle takes one input argument, to set the size of the circle. circle returns no output. The circle command can now be used like a normal command in the rest of the code. See this example:

learn circle $X {
  repeat 36 {
    forward $X 
    turnleft 10 
  }
}

go 200,200 
circle 20

go 300,200 
circle 40

In the next example, a command with a return value is created.

learn faculty $x {
  $r = 1
  for $i = 1 to $x {
    $r = $r * $i
  }
  return $r
}

print faculty 5

In this example a new command called faculty is created. If the input of this command is 5 then the output is 5*4*3*2*1. By using return the output value is specified and the execution is returned.
Commands can have more than one input. In the next example, a command that draws a rectangle is created:

learn box $x, $y {
  forward $y
  turnright 90
  forward $x
  turnright 90
  forward $y
  turnright 90
  forward $x
  turnright 90
}

Now you can run box 50, 100 and the turtle will draw a rectangle on the canvas.