Link search Menu Expand Document

Tell the truth

And what is truth anyway? Fortunately Teletype (and pretty much all digital systems) have a reductive view on the matter:

  • 0 → FALSE

And why do we care about truth? Because sometimes we need to ask hard questions… like, is variable X greater than 2?

GT X 2

Teletype will tell you. If X is greater than 2, the value 1 (TRUE) will be returned. Otherwise you’ll get 0 (FALSE).

Here’s a list of relational operators that can let you test a condition:

EQ x y
NE x y
GT x y
LT x y

Represented are EQuals (x == y), Not Equals (x != y), Greater Than (x > y), and Less Than (x < y). All return true or false, represented as 1 or 0.

And what shall we compare? How about we check if CV input IN is greater than 3V, and then output that as a gate on TR output A:


There are some helper operators for comparing to zero:

EZ x
NZ x

These are Equals Zero and Not Zero. Both take only one argument: the number to be compared to zero.

There ends up being a neat trick for flipping a variable between 0 and 1:


Here, when X is 0, it will become 1. And conversely, if 1, will become 0. Having this in a script will create a toggle. For example, you could use a trigger input to toggle the metronome:


The moment of decision

Now that we’re full of truths and falsehoods, let’s conditionally execute some commands. Introducing a new word: PRE. It’s basically a short command that comes ahead of another command, separated by a : (colon). Here’s a simple example:


The PRE IF takes one argument which is evaluated as true or false. If true, the remaining command after the separator (:) will be executed. So, according to our understanding of truth:

  • if X is 0, nothing happens
  • if X is anything but 0, TR output A gets toggled

We can expand the command within a PRE to become more complicated, however:


Here knob input PARAM is read and compared to 5 volts. If greater, CV output 1 is assigned to PARAM, basically limiting the lower bound of the knob-to-cv-output assignment. (Note that this could more effectively be accomplished with CV 1 LIM PARAM V 5 V 10.)

We like randomness, right?


Here we maybe (50/50 chance) advance the pattern sequence.

IF LT RAND 100 75 : P.NEXT

Here we have a 75% chance of advancing the sequence. Given this is the sort of thing some of us like to do a lot, we created a simplified PRE just for probabilities:


This command is identical to the one above. The argument is a number from 0-100, representing chance to execute.


Sometimes the inquiry must continue.

IF X : TR 1 0
ELIF Y : TR 1 1

When an IF gets a false argument (and the command is bypassed) we have the opportunity to match a new condition (with ELIF), or just have a fallback command (with ELSE). Let’s trace this script given some assumed values of X and Y:

  • X = 0, Y = 0 → TR 1 TOSS
  • X = 0, Y = 1 → TR 1 1
  • X = 1, Y = 1 → TR 1 0

Note that in the last condition (where X is 1) it simply doesn’t matter what value is in Y as the ELIF and ELSE will be skipped. Similarly, if an ELIF is successfully executed, the following ELSE will not be executed.

You can stack up several ELIF statements in a row:

IF EQ X 0 : CV 1 V RAND 5
ELIF EQ X 1 : CV 1 0
ELIF EQ X 2 : CV 1 V RAND 10
ELIF EQ X 3 : CV 1 V 10

This script checks the variable X against the values 0-3 and has a “default” action if it isn’t within range.

Note that you might run into command length issues while doing conditional statements. You may need to break up the condition command. This command is too long:


This is not:

IF X : CV 1 V RRAND 2 8

Later, dudes

For your scheduling needs, there is a PRE for postponing a command:

DEL 250 : TR.TOG 1

DEL takes one argument: delay time in milliseconds. The command above will toggle TR output 1 after 250ms.

In LIVE mode the second icon (an upside-down U) will be lit up when there is a command in the DEL buffer. You can delay a command up to 16 seconds, and 8 commands can fit into the buffer.

You can clear the delay buffer (canceling the pending commands) with a single op:


A sort-of TODO list?

Teletype has a command stack which can lead to some musically interesting exploration. This might feel weird at first, but stick with us though it.

Say you want a command to execute later, not based on a time (where you’d use DEL) but rather by another command. We can achieve said desire thusly:

S : TR.TOG 1

Now the command TR.TOG 1 is on the stack– it has not been executed. To execute the command:


This executes the most recently added command on the stack. Think of the stack as a pile of donuts– the most recently added is the one on top. S.POP executes and removes the top command. If you’re really hungry, though:


This executes the entire stack, which leaves it empty. Why is this interesting, though? Take the following two scripts:

1:  S : CV 1 N RAND 10

2:  S.ALL

Say script 2 was executing on a regular interval, and script 1 was somewhat random. Given we’re using the stack, musical events get time quantized to only happen on the execution of script 2. This is a great method to achieve sync when desired.

The stack can hold 8 commands. If you try to add more, and the stack is full, the command will simply be thrown away. We can read the stack length (height):


This will return the number of commands waiting. We can also clear the stack:


Another interesting use of the stack is the “not sure what’ll come out” method:

1:  S : TR.TOG A

2:  S : CV 1 V RAND 5

3:  S : TR.PULSE B

4:  S.POP

If we’re triggering scripts 1-4 at irregular intervals, the stack will fill up with commands while script 4 is executing and removing a single command at a time.


This scene is featured in the banner video above.

A metronome triggers a pulse and executes the stack. Trigger inputs 1 and 3 add commands to the stack. All input scripts possibly modulate the tempo using a PROB PRE.

Script 2 conditionally changes CV output 4 based on the state of var X. X is toggled between 1 and 0 by script 3– creating some additional dynamic behavior between the two scripts.

In the banner video, all inputs are driven by a WW sequence that has a few trigger-choice steps. TT is driving the frequency of an oscillator from CV out 1. CV out 2 controls an overtone timbre of this oscillator. CV out 4 controls the level of an additional sub oscillator. Trigger out 1 is connected to an envelope to spike the oscillator’s level.



EQ x y          x == y
NE x y          x != y
GT x y          x > y
LT x y          x < y
EZ x            x == 0
NZ x            x != 0

IF x : ..       execute command if x is true
ELIF x : ..     execute command (else) if x is true
ELSE : ..       execute command after failed if

PROB x : ..     probability to execute command, 0-100

DEL x : ..      delay command by x milliseconds
DEL.CLR         clear in-process delays

S : ..          add command to stack
S.POP           execute and remove most recently added command
S.ALL           execute and remove all commands on stack
S.CLR           clear stack
S.L             read only, size of stack

Full Command Chart

Teletype Key Reference

You can also browse help within Teletype by using ALT-H to toggle help mode.

Teletype Studies Continued

Part 7: Incantations →

Part 6: Maybe later remembering

Part 5: Pattern tracking ←

Part 4: Collect and transform ←

Part 3: Playing with numbers ←

Part 2: Curves and repetition ←

Part 1: Navigating and making edges ←