Categories

, if one was not specified.

Directives

$[break] - Exit the loop

Skip to the end of the loop and stop looping

$[while …]…$[break]…$[done]

$[foreach …]…$[break]…$[done]

Immediately

break

s out of the loop. The remainder of the code in the block will not be run and execution will continue after the

. It must occur between a

, and its corresponding

$[while ${expr 1}]This loop looks infinite$[break]$[done] but it is not
This loop looks infinite but it is not

$[continue] - Next loop iteration

Skip to the next loop iteration

$[while …]…$[continue]…$[done]

$[foreach …]…$[continue]…$[done]

continue

immediately loops, even if there is more code to run before the end of the loop block. It must occur between a

, and its corresponding

$[foreach ${array 1 2 3}]${loopvar} $[continue]This code is unreachable$[done]
1 2 3

$[done] - End the loop

End the loop

$[while …]…$[done]

$[foreach …]…$[done]

ends the loop body. Every

and

must have a corresponding

(which will be shared by any

s and

s).

$[else] - Final condition

Part of the response to use if all other conditions failed

$[if …]…$[else]…$[endif]

else

creates a conditional block whose code will only be executed if no other conditions have matched. It must come after

and any

s, and before

$[if ${expr ${random 1000} > 750}]You are very lucky 🐻$[else]How unlucky for you 😢$[endif]
You are very lucky 🐻

$[elseif] - Alternative condition

Use part of the response if a different condition is true

$[if …]…$[elseif ${VARIABLE}]…$[endif]

$[unless …]…$[elsief ${VARIABLE}]…$[endif]

elseif

creates a conditional block whose code will only be executed if VARIABLE is true. VARIABLE may be a regular variable or a function. It must be inside of ${ and }.

must come after a

and before the

. You can have any number of

elseif

You are $[if ${equals ${user.level} broadcaster}]a broadcaster$[elseif ${equals ${user.level} moderator}]a moderator $[else]a regular user$[endif]
You are a broadcaster

$[endif] - End the conditional

End the conditional part of the response

$[if …]…$[endif]

ends the last condition. Every

and

unless

must have a corresponding

(which will be shared by any

s and

$[foreach] - Loop over variables

Loop over items in an array (or a single item)

$[foreach ${VARIABLE}]…${loopvar}…$[done]

foreach

creates a block whose code will be executed once for every item in VARIABLE, which will be stored in

loopvar

. If VARIABLE is a regular variable, the loop body will execute once. If it is an array, the body will be executed as many times as there are items in the array. If VARIABLE is a function then its return value will be used.

foreach

must have a corresponding

$[foreach ${array 1 2 3}]${loopvar} $[done]
1 2 3
$[foreach ${array}]This loop iterates 0 times because the array is empty$[done]

$[if] - Conditional expressions

Make part of the response conditional

$[if ${VARIABLE}]…$[endif]

creates a conditional block whose code will only be executed if VARIABLE is true. VARIABLE may be a regular variable or a function. It must be inside of ${ and }.

must have a corresponding

You are $[if ${equals ${user.level} broadcaster}]the broadcaster, $[endif]${user}.
You are the broadcaster, Undeference.

$[unless] - Negated conditional expression

Use part of the response only if the condition is not true

$[unless ${VARIABLE}]…$[endif]

unless

creates a conditional block whose code will only be executed if VARIABLE is false. VARIABLE may be a regular variable or a function. It must be inside of ${ and }.

unless

must have a corresponding

${let targ ${randtarg}}$[unless ${targ.id}]${let targ.id "Unknown ID"}$[endif]Your ID is ${targ.id}
Your ID is 248929134

$[until] - Negated conditional loop

Repeat the loop body until a condition becomes true

$[until ${VARIABLE}]…$[done]

until

creates a block whose code will be repeatedly executed as long as VARIABLE is false. VARIABLE may be a regular variable or a function. It must be inside of ${ and }.

until

must have a corresponding

${let c 0}$[until ${expr ${c} >= 5}]${c}${let c ${sum ${c} 1}}$[done]
01234

$[while] - Conditional loop

Repeat the loop body while a condition is true

$[while ${VARIABLE}]…$[done]

while

creates a block whose code will be repeatedly executed as long as VARIABLE is true. VARIABLE may be a regular variable or a function. It must be inside of ${ and }.

while

must have a corresponding

${let c 0}$[while ${expr ${c} < 5}]${c}${let c ${sum ${c} 1}} $[done]
0 1 2 3 4

Functions

${and} - Boolean AND

Test if all arguments are true

${and ARGUMENTS}

and

returns true if all ARGUMENTS are true, and false otherwise. It actually returns the last true value or the first false value.

${and 1 2 3}
3
${and 1 2 3 0}
0
${and yes ""}

${array} - Create array

Return an array made up of the arguments

${array ARGUMENTS}

${array ARRAY}

Create a new array containing the items of ARGUMENTS or ARRAY. This is a shallow copy, meaning any array or object items will be shared.

${let arr ${array some items in an array}}${arr[4]}
array

${bind} - Call a function

Call a function with the provided array as arguments

${bind FUNCTION ARRAY}

bind

calls FUNCTION with arguments in ARRAY. Any argument checking the function does will still be done, but it will look in the array instead of a normal arguments list.

${let args ${array "An example" 3 4}}${bind substr ${args}}
exam

${call} - Use a command from a command

Call a command and return its result

${call [!]COMMAND ARGUMENTS}

Run COMMAND from within the current command and return its result. Standard user

level

and

!enable

checks are not done. This cannot currently be used to let lower level users use the commands

!join

!enable

, or

!command

${call !dice 2d20}
Undeference rolls 🎲17 🎲3

${clone}

Clone a possibly polyadic value

${let var ${clone ${VARIABLE}}}

clone

deeply copies a value and returns the clone. This is suitable for copying arrays and objects.

${decodeURI} - Decode URI

Decode encoded sequences in a URI

${decodeURI ENCODEDURI}

decodeURI

decodes an ENCODED URI that could have been encoded with

encodeURI

. This serves the same purpose as the Javascript decodeURI() function.

${decodeURI http%3A%2F%2Fexample%2Ecom%2F}
http://example.com/

${decodeURIComponent} - Decode URI component

Decode encoded components of a URI

${decodeURIComponent ENCODEDURICOMPONENT}

decodeURIComponent

decodes ENCODED URI COMPONENT that could have been encoded with

. This serves the same purpose as the Javascript decodeURIComponent() function.

${decodeURIComponent %5c%6f%2f}
\o/

${delete} - Delete from object

Remove items from an object

${delete OBJECT ARGUMENTS}

Removes items from OBJECT whose keys are in ARGUMENTS. Returns an array with the values for those keys. The array returned will contain empty items anywhere that an item did not exist in the OBJECT.

${let obj ${object type object name example}}${delete ${obj} name}

${each} - Object key-value pairs

Key-value pairs of an object as an array

${each OBJECT}

Returns

each

key and value of OBJECT in an array, in key-value order.

${let obj ${object type object name example}}${each ${obj}}
name example type object

${encodeURI} - Encode URI

Encode unsafe characters for a URI

${encodeURI URI}

encodeURI

encodes a URI by replacing unsafe characters with URI-encoded characters. This serves the same purpose as the Javascript encodeURI() function.

${encodeURI "https://www.example.com/URL=very weird&broken"}
https://www.example.com/URL=very%20weird&broken

${encodeURIComponent} - Encode URI component

Encode unsafe characters for a URI component

${encodeURIComponent URICOMPONENT}

encodeURIComponent

encodes URI COMPONENT by replacing potentially unsafe characters with URI-encoded characters. This serves the same purpose as the Javascript encodeURIComponent() function.

${http http://www.example.com/?${encodeURIComponent ${message}}}

${equals} - String equality

Test if two string arguments are equal

${equals STRINGa STRINGb}

equals

returns true if the specified STRINGs are lexically equal, and false if they are not.

If you want to ignore character case, casefold the strings with

$[if ${equals ${nick} bob}]uncle$[else]${nick}$[endif]
undeference

${eval} - Evaluate command response

Evaluate the arguments as a command response, catching errors

${eval RESPONSE}

eval

uate the command RESPONSE and return its result. If there was an error, it will be stored in

.

Do not

with untrusted code.

${eval '${fail error}123'}$[if ${evalerror}]Bad but not so bad ${evalerror}$[endif]
Bad but not so bad error

${expr} - Mathematical expression

Evaluate a mathematical expression

expr

evaluates a mathematical expression and returns the result. All of the normal math-type expressions are permitted as well as some things you might not expect.

Unary operators—these operators precede an operand (like the - in -1)

!: Boolean not: if the operand is true, then it is false and vice versa
~: Bitwise not: flips all of its bits from 1 to 0 and vice versa

Binary operators—these operators take two operands (like the - in 2-1)

==: Numerical equality: true if both operands are equal, and false if they are not
!=: Numerical inequality: true if the operands are not equal, and false if they are
%: Modulus: gives the remainder of dividing the left-hand side by the right-hand side
**: Power: raises the left-hand side to the power of the right-hand side
^: Bitwise exclusive or: bits in the output will be 1 if the corresponding input bits are not equal to each other, and 0 otherwise
&: Bitwise and: bits in the output will be 1 if both corresponding input bits are 1, and 0 otherwise
|: Bitwise not: bits in the output will be 1 if either corresponding input bit is 1, and 0 otherwise
&&: Boolean and: the output will be true if both inputs are true, and false otherwise
||: Boolean or: the output will be true if one or both inputs are true, and false otherwise

The ?: ternary operator is permitted.

Functions (may be used without parentheses)

atan2(Y,X): Returns the arctangent of Y/X
sin(X): Returns the sine of X
cos(X): Returns the cosine of X
exp(X): Returns the natural logarithm (base e) to the power of X
log(X): Returns the natural logarithm (base e) of X
sqrt(X): Returns the positive square root of X—equivalent to X**(1/2)

Numbers may be specified using exponential notation with e or E. I.e., XeY means X*(10**Y). Numbers are decimal (base 10) by default, but special notation can be used to change that.

0bNUMBER: NUMBER is binary (base 2: 0-1)
0NUMBER, 0oNUMBER: NUMBER is octal (base 8: 0-7)
0xNUMBER: NUMBER is hexadecimal (base 16: 0-9, a-f)

Hexadecimal numbers contain numerals from 0 to 9 and a to f (inclusive), with the letters a-f corresponding to the decimal values 10-15. The letters may be uppercase or lowercase.

If you wish to group digits, you may use underscores (_) but not commas (,). E.g., instead of ~~1,000,000~~, use 1_000_000.

${expr "sqrt(40/3 - sqrt 12)"}
3.14153333870509

${fail}

Fail

fail

causes execution of the current context to terminate in a failed state. Arguments to the function will be used as the error message.

${fail "That's a big oops"}
!eval: That's a big oops

${fc} - Casefolding

Casefolded string

${fc STRING}

folds the case of the specified STRING for comparing. This is not always the same as

${lc ß} is not ${fc ß}
ß is not ss

${flatten}

Flatten an argument as a string

${flatten VALUES}

flatten

returns an array made of the items in VALUES. Arrays in arguments will be flattened as will objects.

${let num ${array 1 2 3}
}${let alf ${array a b c}
}${let both ${flatten ${num} ${alf}}
}${both[4]}
b

${get}

Get a variable's value or a default value

${get NAME [VALUE]}

get

gets the value of the variable with the specified NAME, or VALUE if there is no variable with that name.

With ${get ARRAY[INDEX] VALUE} you will not get VALUE if ARRAY exists, even if ARRAY[INDEX] does not exist.

${http} - Make web request

Make a web request and return the response

${http URL}

Make an

http

(s) request and return its body as text. You can handle JSON responses with

json

${http https://twitch.center/customapi/quote?token=${quotetoken}&data=${querystring}}
131. "Go away, teammate!"

${index} - Offset of string

Find a string in a string or array

${index STR STRING [OFFSET]}

${index STR ARRAY [OFFSET]}

Return the first

index

of STR in the provided STRING or ARRAY, starting at OFFSET. Returns -1 if it could not be found.

${index "Match the substring in the string" string}
13
${index "Match the substring in the string" string 14}
27
${index ${array Match the element in the array} element}
2

${int} - Integer

The integer part of the the argument

${int VALUE}

int

returns the integer part of the specified VALUE. If the value is an array or an object then you get the number of values. If the value is a non-numeric string, you will get the value 0.

${int 3.1416}
3
${int 9.999}
9
${int ${array some items}}
2
${int ${object key1 value1 key2 value2}}
2

${isarray} - Is it an array?

Test if an argument is an array

${isarray ARGUMENT}

isarray

returns true if ARGUMENT is an array, and false otherwise.

${isarray ${array}}
1
${isarray "not an array"}

${isobject} - Is it an object?

Test if an argument is an object

${isobject ARGUMENT}

isobject

returns true if ARGUMENT is an object, and false otherwise.

${isobject ${object}}
1

${join} - Join array

Combine arguments (or an array) into a string

${join DELIMITER ARRAY}

${join DELIMITER ARGUMENTS}

join

the items of the ARRAY or ARGUMENTS into a string with the items separated by DELIMITER.

${join , Making a comma-separated value}
Making,a,comma-separated,value

${json} - Decode JSON

Decode a JSON string

${json JSONSTRING}

json

decodes JSONSTRING and returns the corresponding value.

${let example ${json ${http https://jsonplaceholder.typicode.com/todos/1}}}${example.title}
delectus aut autem

${keys} - Object keys

Return the keys of an object

${keys OBJECT}

Returns an array containing the

keys

of an OBJECT.

${keys ${object type object name example}}
name type

${lc} - Lowercase

Lowercase string

${lc STRING}

returns the lowercase version of the specified STRING.

${lc "There is no Dana"}
there is no dana

${lcfirst} - Lowercase first character

The first character in lowercase

${lc STRING}

lcfirst

returns the specified STRING with the first character lowercase.

${lcfirst "There is no Dana"}
there is no Dana

${length}

Get the number of items in an array or object, or the length of a string

${length STRING}

${length ARRAY}

${length OBJECT}

length

takes an argument and returns the number of values it has. In other words, this is the number of characters in a string or the number of values in an array or object.

Your name is ${length ${nick}} characters long
Your name is 11 characters long

${let} - Set a temporary variable

Set a variable for use in the current command

${let NAME VALUE}

let

sets a variable with the specified NAME to the specified VALUE. The variable can have a simple value like a string or a number, or it can be an

. Variables set with

only exist until the command ends.

If a variable with the specified name was (or becomes) declared with

, that variable will be masked, meaning that it will become inaccessible in the current command, but continues to exist.

${let fruit ${array apple orange grape lemon banana}}Have a(n) ${bind rand ${fruit}}
Have a(n) apple
${let str Something}${suppress ${substr ${str} 0 4 "A "}}${str}
A thing

${match} - Regex match

Match a regular expression against the string argument

${match STRING PATTERN [FLAGS]}

match

performs a regular expression PATTERN match on STRING with the specified FLAGS. PATTERN is a regular string, so escaping or quoting may be needed. Backtracking is disabled for greedy matches for greedy matchesto prevent catastrophic backtracking.

Capture groups will be saved in variables with names corresponding to each groups' number and name (if applicable).

Characters in FLAGS affect the matching.

m: Indicates the string contains multiple lines. ^ will only match the start of the first line and $ will only match the end of the last line.
s: Treat the string as a single line; . will match newlines.
i: Do case-insensitive matching.
x: Allow whitespaces and comments in PATTERN.
g: Match PATTERN repeatedly.
c: With g, keep the position of the previous match, which will be \G in PATTERN.

$[if ${match ${nick} ([aeiou]) i}]Found the vowel ${1}$[endif]
Found the vowel u
What vowels are there? $[while ${match ${nick} '([aeiou])' igc}] ${1}$[done]
What vowels are there?  u e e e e

${max} - Numerical max

Return the numerically greatest argument

${max NUMBERS}

max

returns the greatest of the NUMBERS provided.

${max 1 3 2}
3

${min} - Numerical min

Return the numerically smallest argument

${min NUMBERS}

min

returns the smallest of the NUMBERS provided.

${min 1 3 2}
1

${not} - Boolean NOT

Negate the argument

${not ARGUMENT}

not

negates ARGUMENT and returns the value. If ARGUMENT is true, it will return false, and vice versa.

${not ""}
1
${not 1}

${object} - Create object

Return an object with the arguments as key-value pairs

${object KEY VALUE…}

Create an

object

with KEY-VALUE pairs specified.

${let obj ${object key value}}${obj.key}
value
${let obj ${object weird-key-name value}}${obj[weird-key-name]}
value

${or} - Boolean OR

Test if any arguments are true

${or ARGUMENTS}

returns true if any of the ARGUMENTS are true, and false otherwise. It actually returns the first true value or the last false value.

${or 1 2 3}
1
${or 0 "" no}
no

${pop} - Array pop

Remove the last item from an array

${pop ARRAY}

pop

the last item off the end of ARRAY and return it. ARRAY will contain one less item.

${let arr ${array Some items in an array}}${pop ${arr}}
array

${push} - Array push

Add items to the end of an array

${push ARRAY ARGUMENTS}

push

adds the items of ARGUMENTS to the end of ARRAY and returns ARRAY itself.

${let arr ${array Some items}}${push ${arr} in an array}
Some items in an array
${let arrA ${array 1 2 3}}${let arrB ${array one two three}}${bind push ${array ${arrA} ${arrB}}}
1 2 3 one two three

${querystring} - Query string

Return the URI-encoded argument

${querystring [STRING]}

querystring

URI-encodes STRING or the command arguments for use in a URL query string. This uses

encodeURIComponent

${rand} - Random choice

Get a random choice

${rand ARGUMENTS}

${rand ARRAY}

rand returns a random argument. If a single argument provided and it is an array, rand will return a random item from that array instead.

Your color is ${rand red orange yellow green blue purple}
Your color is red

${random} - Random number

Get a random number

${random [[LOW] HIGH]}

random returns a random integer that is at least LOW and less than HIGH.

If a single argument is provided, it is HIGH. If LOW is not specified, it is 0. If HIGH is not specified, it is 4294967296.

Your random number is ${random 100}
Your random number is 30

${randtarg} - Random chatter

Return a random chatter

${randtarg}

randtarg

returns an object representing a random user in chat. The object returned is the same type as

target

. The object will stringify as though the display key had been referred to directly.

You cannot use keys directly but must store the result of

randtarg

first.

nick: This is the target user's Twitch login name.
name: Alias for the user's .nick.
id: The user's Twitch ID if it is known.
display: The user's display name (or .nick).
channel: The user's IRC channel name, usually # followed by .nick.

Hi @${randtarg}!
Hi @helenoloy!

${replace} - Regex substitution

Do a regular expression replacement on the string argument

${replace STRING PATTERN REPLACEMENT [FLAGS]}

replace

performs a regular expression PATTERN match on STRING with the specified FLAGS and replaces the match in the original string with REPLACEMENT. PATTERN and REPLACEMENT are regular strings, so escaping or quoting may be needed. Backtracking is disabled for greedy matches to prevent catastrophic backtracking.

Capture groups may be referenced in REPLACEMENT. This is done by having a backslash followed by the number of the capture group, or the name enclosed in braces. Capture groups will be saved in variables with the names corresponding to each groups' number and name (if applicable).

Characters in FLAGS affect the matching and are the same as with

match

m: Indicates the string contains multiple lines. ^ will only match the start of the first line and $ will only match the end of the last line.
s: Treat the string as a single line; . will match newlines.
i: Do case-insensitive matching.
x: Allow whitespaces and comments in PATTERN.
g: Match PATTERN repeatedly.
c: With g, keep the position of the previous match, which will be \G in PATTERN.

${let new ${nick}}(Remove vowels $[while ${replace ${new} ([aeiou]) "" i}]${1}$[done]) ${new}
(Remove vowels ueeee) ndfrnc

${reverse} - Reverse string/array

Reverse the characters of a string or the arguments (or array)

${reverse STRING}

${reverse ARGUMENTS}

${reverse ARRAY}

reverse

the characters in STRING or the ARGUMENTS or the items in ARRAY.

${join " " ${reverse ${split ", " "Saberhagen, Fred"}}}
Fred Saberhagen
${reverse ${nick}}
ecnerefednu

${rindex} - Last offset of string

Find the last instance of string in a string or array

${rindex STR STRING [OFFSET]}

${rindex STD ARRAY [OFFSET]}

rindex

returns the last index of STR in the provided STRING or ARRAY before OFFSET. If OFFSET is not provided, starts at the end of the string or array. Returns -1 if it could not be found.

${rindex "Match the substring in the string" string}
27
${rindex "Match the substring in the string" string 26}
13
${rindex "Match the substring in the string" string 12}
-1
${rindex ${array Match the element in the array} element}
2

${safeuri} - Safe URI

Return a URI safe for web requests

${safeuri URI}

${safeuri BASEURL URI}

safeuri

tries to make a canonical URL from the provided URI, optionally with BASEURL as the base URL. This is similar to what web browsers do when they see links.

${safeuri https://www.example.com/ /path/file/../../../other/file}
https://www.example.com/other/file

${set} - Set a persistent variable

Set a persistent variable

${set NAME VALUE}

sets a variable with the specified NAME to the specified VALUE. The variable can only have a simple value like a string or a number. Variables set with

exist until they are

. They can be used in other commands.

If you attempt to store arrays or objects with

, they will be stringified. You can use something like

to store arrays and objects persistantly (and then

to use them again later).

${shift} - Array shift

Remove the first item from an array

${shift ARRAY}

shift

removes the first item from ARRAY and returns it. ARRAY will contain one less item.

${let arr ${array Some items in an array}}${shift ${arr}}
Some

${slice} - Array slice

Return part of an array

${slice ARRAY [OFFSET [LENGTH]]}

slice

returns an array containing sequential items from ARRAY starting at OFFSET and containing LENGTH items. If OFFSET is not specified, it copies from the start. If LENGTH is not specified, it copies until the end. If LENGTH is specified, the resulting array will contain that many items even if the input ARRAY does not have that many items.

This is a shallow copy, meaning any array or object items will be shared.

${slice ${array An assortment of items} 3}
items

${split} - Split string

Split a string into parts

${split DELIMITER STRING [PARTS]}

split

the STRING into parts separated by the specified DELIMITER and return an array containing those parts. If PARTS is specified, the resulting array will contain up to that number of items, with the last item containing any additional delimiters.

If DELIMITER is an empty string,

split

returns an array containing STRING's characters.

${split "" ${nick}}
u n d e f e r e n c e

${substr} - Substring

Return (and optionally modify) part of a string

${substr STRING OFFSET [LENGTH [REPLACEMENT]]}

substr

takes a STRING and returns a substring starting at the specified OFFSET. The returned substring will have up to LENGTH characters, if specified. If LENGTH is not specified, the substring will continue until the end of the string.

If REPLACEMENT is specified, it replaces the characters in the original string. The substring is still returned.

${let str "In a while"}${substr ${str} 5}
while
${let str "In a while"}${substr ${str} 5 0 "little "}${str}
In a little while

${sum} - Mathematical sum

Adds the arguments together

${sum ARGUMENTS}

sum

adds up the ARGUMENTS and returns the result.

${sum 1 2 3 4}
10

${suppress}

Suppress output

suppress

takes an arbitrary number of arguments and returns nothing. This is useful for suppressing output from other functions.

${suppress ${match abC '([[:upper:]]+)'}}${1}
C

${target} - Command target

Return the named chatter

${target [NAME]}

target

returns an object representing the user whose name matches NAME. Partial name matching will be done if no user has that name exactly. The object returned is similar to

user

. The object will stringify as though the display key had been referred to directly.

You cannot use keys directly but must store the result of

(with

) first.

nick: This is the target user's Twitch login name.
name: Alias for the user's .nick.
id: The user's Twitch ID if it is known.
display: The user's display name (or .nick).
channel: The user's IRC channel name, usually # followed by .nick.

${target helenoloy}
helenoloy
${let targ ${target helen}}${targ.display}${and ${targ.id} #${targ.id}}
helenoloy#248929134

${tojson} - Encode to JSON

Create a JSON string

${tojson SOMETHING}

tojson

returns the JSON encoding of SOMETHING.

${tojson ${object nested ${array values}}}
{"nested":["values"]}

${twitch.announce} - Twitch announcement

Announce something in Twitch chat

${twitch.announce MESSAGE}

twitch.announce

announces a specified MESSAGE to chat. Returns 1 on success.

${twitch.announce "Welcome, chatters!"}
1

${twitch.ban} - Twitch: ban user

Ban a user on Twitch

${twitch.ban USERID [DURATION] [REASON]}

twitch.ban

tries to ban a Twitch user with the specified USERID. You may specify a DURATION in seconds and/or a REASON for the ban. On success, returns an object.

user_id: This is the USERID specified.
created_at: The date and time that the ban or timeout was placed.
end_time: The date and time that the timeout will end (if it will).

${twitch.bitsleaderboard} - Twitch bits leaderboard

Get the Twitch channel's bits leaderboard

${twitch.bitsleaderboard}

${twitch.bitsleaderboard DURATION}

twitch.bitsleaderboard

returns an array of objects containing information about the channel's bits leaderboard. If DURATION is specified (as day, week, month, year, or all), the results will be constrained to the specified time period.

user_id: The Twitch user ID of a user on the bits leaderboard.
user_login: The login name of a user on the bits leaderboard.
user_name: The display name of a user on the bits leaderboard.
rank: The rank of a user on the bits leaderboards.
score: The number of bits cheered by a user on the bits leaderboard.

${twitch.channel} - Twitch channel

Get information about a Twitch channel

${twitch.channel}

${twitch.channel BROADCASTERID}

twitch.channel

returns information about a Twitch channel. If no BROADCASTERID is specified, returns information about the current channel. Returns an object on success.

broadcaster_language: The two-letter code of the broadcaster's preferred language (or 'other').
game_id: The game ID.
game_name: The game name.
title: The title of the current or previous stream.
delay: The broadcaster's stream delay setting
tags: An array containing the channel's tags.
content_classification_labels: An array containing the channel's content classification labels.
is_branded_content: A boolean indicating if the channel has branded content.

${let twchan ${twitch.channel}}$[if ${twchan}]${broadcaster} last played ${twchan.game_name}$[endif]
Undeference last played Cities: Skylines

${twitch.chatsettings} - Twitch chat settings

Get or modify Twitch chat settings

${twitch.chatsettings}

${twitch.chatsettings OBJECT}

twitch.chatsettings

returns an object containing the channel's chat settings. If an OBJECT is provided, it contains a set of new chat settings to apply.

The return value contains these fields, and if an OBJECT is specified then it may contain any of these fields:

emote_mode: A boolean indicating if all messages are required to contain emotes.
follower_mode: A boolean indicating if users must be following the channel in order to chat.
follower_mode_duration: If follower_mode is true, this is the the minimum number of minutes a user must be following the channel to be able to chat.
non_moderator_chat_delay: A boolean indicating if messages from non-moderator chatters will be delayed so that they can be moderated before being displayed.
non_moderator_chat_delay_duration: If non_moderator_chat_delay is true, this is the number of seconds (2, 4, or 6) that messages from non-moderators will be delayed.
slow_mode: A boolean indicating if there is a delay between chat messages from the same user.
slow_mode_wait_time: If slow_mode is true, this is the number of seconds (3-120) to users must wait between chat messages.
subscriber_mode: A boolean indicating if a user must be subscribed to the channel to be able to chat.
unique_chat_mode: A boolean indicating if repeated messages will be blocked.

${let settings ${twitch.chatsettings}}${let check ${array "✖ Off" "✔ On"}}Emote mode is ${check[${int ${settings.emote_mode}}]}
Emote mode is ✖ Off

${twitch.clearchat} - Clear Twitch chat

Remove all messages from the Twitch chat

${twitch.clearchat}

twitch.clearchat

tries to clear all the messages from Twitch chat. On success, returns 1.

$[if ${twitch.clearchat}]Welcome to the new beginning of your chat!$[endif]
Welcome to the new beginning of your chat!

${twitch.clips} - Twitch clips

Get clips from a user's Twitch channel

${twitch.clips}

${twitch.clips BROADCASTERID}

twitch.clips

twitch.content_classifications

returns an array containing objects with information about the channel's clips. A channel can be specified by specifying a BROADCASTERID.

Each clip object contains:

id: The clip's ID.
url: The clip's URL.
embed_url: A URL for embedding the clip on a website.
creator_id: The Twitch user ID of the user who created the clip.
~~creator_login~~: This field should exist but does not.
creator_name: The display name of the user who created the clip.
video_id: The ID of the video the clip came from, if available.
game_id: The ID of the game in the clip.
~~game_name~~: This field should exist but does not.
language: The two-letter code for the language of the broadcast (or 'other').
title: The clip's title.
view_count: The number of times the clip has been viewed.
created_at: The date and time when the clip was created.
duration: The length of the clip is seconds.
vod_offset: The position of the clip from the start of the video, in seconds.
is_featured: A boolean indicating if the clip is featured.

${twitch.content_classifications} - Twitch content classification labels

Information about Twitch's content classification labels

${twitch.content_classifications}

returns an array of objects containing information about Twitch's content classification labels.

id: The content classification label's ID.
description: A description of the content classification label.
name: The name of the content classification label.

${twitch.delete} - Delete a message on Twitch

Delete a message from Twitch chat

${twitch.delete MESSAGEID}

twitch.delete

tries to delete the Twitch chat message with the specified MESSAGEID, i.e., ${msgid}. On success, returns 1.

$[if ${twitch.delete ${msgid}}]I deleted your message$[endif]

${twitch.follows} - Twitch user follows

Check if a Twitch user is following the channel

${twitch.follows USERID}

twitch.follows

checks if the user with the specified USERID is following the channel. If so, returns an object.

user_login: The user's login name.
user_name: The user's display name.
followed_at: The date and time when the user began following the channel.

${twitch.games} - Twitch games

Show Twitch's top games or search for games

${twitch.games}

${twitch.games GAMENAMES}

twitch.games

returns an array of objects containing information about games. If there are arguments, they are GAMENAMES to match (or an array of GAMENAMES).

id: The game's ID.
name: The game's name.

${let wc2 ${twitch.games wc2}}$[if ${length ${wc2}}]We're playing ${wc2[0].name}$[else]Wut?$[endif]
We're playing WarCraft II: Tides of Darkness

${twitch.marker} - Twitch stream marker

Create a stream marker on Twitch

${twitch.marker DESCRIPTION}

twitch.marker

tries to create a stream marker with the specified DESCRIPTION and returns an object on success.

id: The stream marker's ID.
created_at: The date and time when the stream marker was created.
position_seconds: The stream marker's offset in seconds from the start of the stream.
description: The DESCRIPTION.

${twitch.shieldmode} - Query/set Twitch shield mode

Query/enable/disable shield mode for Twitch chat

${twitch.shieldmode}

${twitch.shieldmode STATUS}

twitch.shieldmode

lets you get information about the Twitch chat's shield mode. Optionally, STATUS is a boolean indicating whether to turn shield mode on or off. If shield mode was/is enabled, returns an object.

is_active: A boolean value corresponding to whether shield mode is active.
moderator_id: The Twitch user ID of the moderator who enabled shield mode.
moderator_login: The Twitch login name of the moderator who enabled shield mode.
moderator_name: The Twitch display name of the moderator who enabled shield mode.
last_activated_at: The date and time when shield mode was enabled.

${let shield ${twitch.shieldmode}}Shield mode $[if ${shield.is_active}]was activated by ${shield.moderator_name} at ${shield.last_activated_at}$[else]is not active$[endif].
Shield mode is not active.

${twitch.shoutout} - Shoutout a Twitch broadcaster

Shoutout another broadcaster from Twitch chat

${twitch.shoutout BROADCASTERID}

twitch.shoutout

shouts out another broadcaster from Twitch chat. Returns 1 on success.

${twitch.stream} - Twitch stream

Get information about a Twitch stream

${twitch.stream}

${twitch.stream USERID}

${twitch.stream USERNAME}

twitch.stream

returns information about a Twitch stream. If no USERID or USERNAME is specified, returns information about the current stream. Returns an object on success.

id: The stream ID.
user_id: The broadcaster's Twitch user ID.
user_login: The broadcaster's login name.
user_name: The broadcaster's display name.
game_id: The game ID.
game_name: The game name.
title: The stream's title.
tags: An array containing the stream's tags.
viewer_count: The number of viewers watching the stream.
started_at: The date and time of when the broadcast began.
language: The two-letter code of the stream language (or 'other').
is_mature: A boolean indicating if the stream is intended for mature audiences.

${let stream ${twitch.stream}}$[if ${stream}]${stream.user_name} is playing ${stream.game_name} with ${stream.viewer_count} viewer$[if ${expr "${stream.viewer_count} != 1"}]s$[endif]$[else]Not live$[endif]
Not live

${twitch.unban} - Twitch: unban user

Unban a user on Twitch

${twitch.unban USERID}

twitch.unban

tries to unban a Twitch user with the specified USERID. On success, returns 1.

${twitch.user} - Twitch user info

Get information about a Twitch user

${twitch.user USERID}

${twitch.user USERNAME}

twitch.user

returns an object corresponding to a Twitch get users response. If the request failed or there is no matching user,

twitch.user

returns nothing.

id: This is the user's Twitch ID.
login: This is the user's login name (equivalent to user.nick).
display_name: This is the user's display name (equivalent to user.display).
type: admin, global_mod, staff, or "".
broadcaster_type: affiliate, partner, or "".
description: The user's description of their channel.
created_at: The date and time that the user's account was created.

${uc} - Uppercase

Uppercase string

${uc STRING}

returns the uppercase version of the specified STRING.

${uc "there is only zuul"}
THERE IS ONLY ZUUL

${ucfirst} - Uppercase first character

The first character in uppercase

${ucfirst STRING}

ucfirst

returns the specified STRING with the first character uppercase.

${ucfirst "there is only zuul"}
There is only zuul

${unset}

Unset a variable

${unset NAME}

unset

removes a variable with the specified NAME that was created by

. If two variables with the name name exist, the one creates with

let

will be removed first, unmasking the one created with

${let var 123}var=${var}, ${unset var}var=${var}
var=123, var=
${set var qwerty}var=${var}, ${let var uiop}var=${var}, ${unset var}var=${var}, ${unset var}var=${var}
var=qwerty, var=uiop, var=qwerty, var=

${unshift} - Array unshift

Add items at the start of an array

${unshift ARRAY ARGUMENTS}

unshift

inserts the items of ARGUMENTS at the start of ARRAY, with the first item of ARGUMENTS the new first item of ARRAY. ARRAY is returned.

${unshift ${array items in an array} Some more}
Some more items in an array

${values} - Object values

Return the values of an object

${values OBJECT}

Returns an array containing the

values

of an OBJECT.

${values ${object type object name example}}
example object

Triggers

`cuss` - Swearing

Inform chatters about their bad language

cuss warns users if a bad word was detected in their message.

The Cushite civilization was known for its rich cultural heritage.

s**t is a bad word

`happy` - Happy!

Respond to chatters' happiness

happy causes the bot to respond to chatters' happiness.

yay

🎈

`hi` - Greetings

Respond to greetings

hi causes the bot to respond to chatters' greetings.

✌️

`noats` - Ignore mentions

Prevent some triggers from firing when they contain @ mentions

When noats is enabled, ignores hi and happy if the message contains a @ mention.

KonCha

sup @User

Variables

${arg} - Command arguments

The arguments to the command

arg

is an array containing the command arguments ${arg[0]} contains the full argument string, with subsequent array items being individual arguments, such that the first argument is ${arg[1]} and so on.

A random argument: ${arg[${random 1 ${length ${arg}}}]}

${badges}

The user's badges

This is an object containing the user's Twitch badges in the current chat. Keys are the names of the badges and the value is the "version number".

Examples of some useful badges are admin, staff, subscriber, bits. Most badges have a "version" of 1, but some have more meaningful "versions", like bits.

${badges.broadcaster}
1

${broadcaster}

The broadcaster user

broadcaster

is an object similar to

user

, with various keys related to the broadcaster.

broadcaster

will be stringified as though ${broadcaster.display} was used directly.

nick: The broadcaster's Twitch login name.
name: Alias for ${broadcaster.nick}.
id: The broadcaster's Twitch ID.
display: The broadcaster's display name (or ${broadcaster.nick}).
channel: The IRC channel name: #${broadcaster.nick}.

${channel}

The channel name

channel

is an object with various keys related to the current chat.

channel

will be stringified as though ${channel.name} was used directly.

Welcome ${user} to ${channel}!
Welcome Undeference to #undeference 2454252 undeference!

name: The channel name. This is the same as ${broadcaster.nick}.
channel: The actual IRC channel name. This is the same as #${channel.name}.
id: The channel ID. This is the same as ${broadcaster.id}.

${command} - Command name

The name of the command

This is the name of the

command

, not including the leading !.

${evalerror} - Eval error

Error from eval

evalerror

is the error message of the last

eval

you used in this command, if it failed. It can be used to test if the last

eval

failed.

${eval '${fail "something failed"}'}$[if ${evalerror}]It failed: ${evalerror}$[endif]
It failed: something failed

${level} - User level

The user's level

level

has the user's level.

broadcaster: The user is the channel's broadcaster
moderator: The user is a moderator in this chat
user: The user has no special user level

${level}
broadcaster

${loopvar} - Loop variable

Variable for the loop item

This contains the current item of a

foreach

loop.

$[foreach ${array 1 2 3}]${loopvar} $[done]
1 2 3

${message}

The message itself

message

is the full message, including the command name and arguments. It is similar to doing !${command} ${arg[0]}.

${msgid} - Chat message ID

The chat message ID

msgid

contains the message ID, if available. This is used for

twitch.delete