TIO refers to Try it online! while ATO refers to Attempt This Online!.

Print(str);. Writes the string to the canvas.
Print(int);. Writes a line of one of -, |, / or \ depending on the current direction of the given length to the canvas.
Print(list);. For each element of list, prints it in the current direction without moving the cursor and then moves down a line.

；

Used by Wolfram expressions.

∧

Logical And(any, any). Returns the LHS unless it is falsy, in which case it evaluates the RHS.

∨

Logical Or(any, any). Returns the LHS if it is falsy, otherwise it evaluates the RHS.

“

Starts a compressed string, which is a single token.

“y

Starts a literal string (a string containing these command characters, excluding ”, ¶ or ⸿). (TIO: ¶ or ⸿ will also be quoted, but the deverbosifier erroneously converts \n or \r.)

”

Ends a compressed or literal string. (A terminating string does not require the end delimiter.)

⊞

Push(list, any);. Appends the value to the list.

⊞Ｏ

PushOperator(list, any). Appends the value to the list and returns the list.

⊟

Pop(list). Removes and returns the last element of the list.

➙

Used by Wolfram expressions.

⧴

Used by Wolfram expressions.

″

Used by Wolfram expressions.

¶

\n. Literal newline character; counts as part of an ASCII string literal. When printed to the canvas, causes the cursor to move to the start of the next "line" below the cursor position at the start of the print command.

‴

Used by Wolfram expressions.

＆

BitwiseAnd(int, int).
BitwiseAnd(int, list). Recursively vectorises over the list.
BitwiseAnd(list, int). Recursively vectorises over the list.

｜

BitwiseOr(int, int).
BitwiseOr(int, list). Recursively vectorises over the list.
BitwiseOr(list, int). Recursively vectorises over the list.
BitwiseOr(string, string). Creates a pair of Wolfram strings.

↶

PivotLeft(int=2);. Rotates the pivot anticlockwise by 45° times the argument.

↷

PivotRight(int=2);. Rotates the pivot clockwise by 45° times the argument.

⟲

Rotate(int=2);. Rotates the canvas anticlockwise by 45° times the argument.

⟲Ｔ

RotateTransform(int=2);. Rotates the canvas anticlockwise by 45° times the argument, rotating the characters if possible.

⟲Ｃ

RotateCopy(dir=↘, literal);. Rotates the canvas anticlockwise by 45° times each digit in the literal around the given corner of the canvas, overlaying the copies over the original.
RotateCopy(dir=↘, int=2);. Rotates the canvas anticlockwise by 45° times the argument around the given corner of the canvas, overlaying the copy over the original.
RotateCopy(dir=↘, list);. For each element of list, rotates the canvas anticlockwise by 45° times the element around the given corner of the canvas, overlaying the copy over the original.

⟲Ｐ

RotatePrism(dir=↘, literal);.
RotatePrism(dir=↘, int=2);.
RotatePrism(dir=↘, list);.

As RotateCopy but rotates the characters if possible.

⟲Ｏ

RotateOverlap(dir=↘, literal);.
RotateOverlap(dir=↘, int=2);.
RotateOverlap(dir=↘, list);.

As RotateCopy but rotates around the character in the corner (so that the rotated character overlaps itself).

⟲ＯＯ

RotateOverlapOverlap(dir=↘, literal, int);.
RotateOverlapOverlap(dir=↘, int=2, int);.
RotateOverlapOverlap(dir=↘, list, int);.

As RotateOverlap but specifies the amount of overlap.

⟲Ｓ

RotateShutter(dir=↘, literal);.
RotateShutter(dir=↘, int=2);.
RotateShutter(dir=↘, list);.

As RotateOverlap but rotates the characters if possible.

⟲ＳＯ

RotateShutterOverlap(dir=↘, literal, int);.
RotateShutterOverlap(dir=↘, int=2, int);.
RotateShutterOverlap(dir=↘, list, int);.

As RotateShutter but specifies the amount of overlap.

←

Move(:Left);. Moves the cursor one character to the left.
Print(:Left, any);. Prints the argument as if the pivot was pointing to the left.

Also used as a direction parameter to other commands.

↑

Move(:Up);. Moves the cursor one character to the left.
Print(:Up, any);. Prints the argument as if the pivot was pointing to the left.

Also used as a direction parameter to other commands.

→

Move(:Right);. Moves the cursor one character to the left.
Print(:Right, any);. Prints the argument as if the pivot was pointing to the left.

Also used as a direction parameter to other commands.

↓

Move(:Down);. Moves the cursor one character to the left.
Print(:Down, any);. Prints the argument as if the pivot was pointing to the left.

Also used as a direction parameter to other commands.

⎇

Ternary(any, any, any). Evaluates the second or third argument depending on whether the first argument is falsy.

‽

Random(). Returns 0 or 1 randomly.
Random(int). Returns a random integer from 0 to (but not including) the argument. (Must be at least 1.)
Random(str). Returns a random character from the string. (Must not be empty.)
Random(list). Returns a random element from the list. (Must not be empty.)

↧

Lowercase(str). Returns the given string in lowercase.
Lowercase(list). Recursively vectorises over the list.

↥

Uppercase(str). Returns the given string in uppercase.
Uppercase(list). Recursively vectorises over the list.

⌊

Floor(float).
Minimum(list). Returns None if the list is empty.

⌈

Ceiling(float).
Maximum(list). Returns None if the list is empty.

±

Negate(number).
Negate(string). Removes a leading -, or adds one if none was present.
Negate(list). Recursively vectorises over the list.

↖

Move(:UpLeft);. Moves the cursor one character to the left.
Print(:UpLeft, any);. Prints the argument as if the pivot was pointing to the left.

Also used as a direction parameter to other commands.

↗

Move(:UpRight);. Moves the cursor one character to the left.
Print(:UpRight, any);. Prints the argument as if the pivot was pointing to the left.

Also used as a direction parameter to other commands.

↘

Move(:DownRight);. Moves the cursor one character to the left.
Print(:DownRight, any);. Prints the argument as if the pivot was pointing to the left.

Also used as a direction parameter to other commands.

↙

Move(:DownLeft);. Moves the cursor one character to the left.
Print(:DownLeft, any);. Prints the argument as if the pivot was pointing to the left.

Also used as a direction parameter to other commands.

⭆

StringMap(int, any). Maps over the integers from 0 up to the argument and joins the results into a string.
StringMap(iter, any). Maps over the elements of the argument and joins the results into a string. (Does not work for dictionaries on TIO.)

？

Used by Wolfram expressions.

⪫

Join(any, iter). Converts the first argument and the elements of the second argument to string and joins the latter using the former.

⪪

Split(iter, int). Splits the argument into pieces of the given length (with a short piece at the end if necessary).
Split(str, str). Splits the first argument at matches of the second argument.
Split(str, list). Splits the first argument at matches of the elements of the second argument.

℅

Character(int). Returns the Unicode character with the given codepoint.
Ordinal(char). Returns the code point of the given Unicode character.
Ordinal(""). Returns 0.

◧

PadLeft(str, int). Pads the first argument with spaces if its length is less than the second argument.

◨

PadRight(str, int). Pads the first argument with spaces if its length is less than the second argument.

⮌

Reverse(iter). Reverses the order of the elements or characters in the argument.
Reverse(number). Reverses the digits in the number, including any decimal point but excluding the sign.

≡

switch (any) { case:s... (default:) }

≡«

Like switch but uses a closing » to mark the end of the switch statement. (Technically the closing » is optional at the end of the program but in that case you would simply omit the «.) (Not available on TIO.)

№

Count(list, any). Counts the number of occurrences of the given value in the list's elements.
Count(str, str). Counts the number of non-overlapping matches of the second argument in the first. (Use Length(FindAll(str, str)) to count overlapping matches.)

⊙

Any(int, any). Maps over the integers from 0 up to the argument and returns 0 if the given expression returns a falsy value for all of them or 1 if not. (Not available on TIO.)
Any(iter, any). Maps over the elements of the argument and returns 0 if the given expression returns a falsy value for all of them or 1 if not. (Does not work for dictionaries on TIO.)

⸿

\r. Literal carriage return character; counts as part of an ASCII string literal. When printed to the canvas, causes the cursor to move to the start of the next line.

⬤

All(int, any). Maps over the integers from 0 up to the argument and returns 0 it the given expression returns a falsy value for any of them or 1 if not. (Not available on TIO.)
All(iter, any). Maps over the elements of the argument and returns 0 it the given expression returns a falsy value for any of them or 1 if not. (Does not work for dictionaries on TIO.)

≔

Assign(any, var);.

§≔

AssignAtIndex(list, int, any);. Updates an element of a dictionary, or of a list (including list of cells) using cyclic indexing.

≕

GetVariable(str). Gets a Charcoal variable indirectly by succinct name or a Python constant such as math.tau.

▷

EvaluateVariable(str);. Executes the named Python function.
EvaluateVariable(str, list);. Executes the named Python function, passing it the given arguments.
EvaluateVariable(str, value);. Executes the named Python function, passing it the given argument.

▶

ExecuteVariable(str, list);. Executes the named Python function, passing it the given arguments.

✂

Slice(list). Returns a shallow clone of list.
Slice(iter, int). Returns the argument with the given number of elements removed from the front, or the last elements of the argument if the given number is negative.
Slice(iter, int, int). Returns the given range of elements of the argument.
Slice(iter, int, int, int). Returns the given range including step of elements of the argument.

Σ

Sum(number). Returns the sum of the digits of the argument, excluding any exponent.
Sum(str). If the argument looks like a number, returns the sum of its digits, otherwise returns the sum of any embedded numbers, or 0 if there were none.
Sum(list). Returns the sum, join or concatenation of the elements of the list depending on whether the first element is an integer, string or list (list not available on TIO).

Π

Product(int). Returns the product of the digits of the argument.
Product(float). Returns the product of the non-zero digits of the argument, excluding any exponent.
Product(str). If the argument looks like a number, returns the product of its digits, otherwise returns the product of any embedded numbers, or 1 if there were none.
Product(list). Returns the product of the elements of the list, or 1 if there were none (None if there were none on TIO).

↨

Base(int, int). Converts the first argument to an array of integers representing it in the base of the second argument, with the most significant digit first. Returns an empty array if the first argument is 0.
Base(int, str). Equivalent to BaseString(int, str).
Base(str, int). Equivalent to BaseString(int, str).
Base(str, str). Equivalent to BaseString(str, str) but with the arguments exchanged.
Base(list, int). Evaluates the list as a polynomial using the second argument, with the most significant degree first. This also works for converting a number from a custom base. If the number is 0, returns the last element of the list, or 0 if it was empty. (Does not remove the last element like Pop would.) If the number is 1, returns the sum of the list, or 0 if it was empty. (Sum does not work in this case.)
Base(int, list). Equivalent to Base(list, int).

⍘

BaseString(number, int). Converts the first argument to a string representing it in the base of the second argument, using the characters 0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ as digits, with the most significant digit first. Returns 0 if the first argument is 0.
BaseString(number, str). Converts the number to a string representing it in the base of the length of the given string, using its characters as digits, with the most significant digit first. Returns the first character of the given string if the first argument is 0 (0 if the first argument is 0 on TIO). Does not convert a floating-point fraction if the given string contains ..
BaseString(number, list). Converts the number to a string representing it in the base of the length of the list, using its elements as digits, with the most significant digit first. Returns the first element of the list if the first argument is 0 (0 if the first argument is 0 on TIO). Does not convert a floating-point fraction if the list contains ..
BaseString(str, int). Converts the first argument as if it was a representation of the base of the second argument, using the characters 0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ as digits, with the most significant digit first.
BaseString(str, str). Converts the first argument as if it was a representation of the base of the length of the second argument, using its characters as digits, with the most significant digit first.
BaseString(str, list). Like BaseString(str, str) but using a list of characters instead of a string.
BaseString(list, int). Like BaseString(str, int) but using a list of characters instead of a string.
BaseString(list, str). Like BaseString(str, str) but using a list of characters instead of a string.
BaseString(list, list). Converts the first argument as if it was a representation of the base of the length of the second argument, using its elements as digits, with the most significant digit first.

✳

Direction(int). Represents a computed direction arrow where 0 is → and 7 is ↘.
Direction(string). Represents a computed direction arrow where the string is any of Up, Down, Left, Right or their combinations, or a prefix thereof, in any case, considering only the letters of the string.
✳✳

Directions(list). Represents a computed multidirectional given by the elements of the list as individual direction arrows.

↔

Absolute(number). Returns the norm of the number. (Does not work for complex numbers on TIO.)
Absolute(string). Removes a leading - from the string.
Absolute(list). Recursively vectorises over the list.

≦

MapAssign(unary, var);. Applies the unary operator to the contents of the variable and updates the variable. Works for integers and vectorises over lists.
MapAssignLeft(binary, any, var);. Applies the binary operator to the given value and the contents of the variable and updates the variable. Works for integers and vectorises over lists (and strings if the binary operator returns a string).

≧

MapAssign(unary, var);. Applies the unary operator to the contents of the variable and updates the variable. Works for integers and lists.
MapAssignRight(binary, any, var);. Applies the binary operator to the contents of the variable and the given value and updates the variable. Works for integers and vectorises over lists (and strings if the binary operator returns a string).

ⅈ

X(). Returns the X-coordinate of the cursor position on the canvas.

ⅉ

Y(). Returns the Y-coordinate of the cursor position on the canvas.

⌕

Find(list, any). Finds the index of the value in the list, or -1 if the value is not present.
Find(str, str). Finds the index of the second string in the first, or -1 if the string is not present.
⌕Ａ

FindAll(list, any). Returns a list of indices of the value in the list.
FindAll(str, str). Returns a list of indices of overlapping matches of the second string in the first.

⊕

Incremented(value).
Incremented(list). Recursively vectorises over list. (Does not work on empty lists on TIO.)

⊖

Decremented(value).
Decremented(list). Recursively vectorises over list. (Does not work on empty lists on TIO.)

⊗

Doubled(value).
Doubled(list). Recursively vectorises over list. (Does not work on empty lists on TIO.)

⊘

Halved(value). Division by 2. (Always floating-point on TIO, but integer divide if the original value is even on ATO.) Halved(list). Recursively vectorises over list. (Does not work on empty lists on TIO.)

⎚

Clear();. Clears the canvas and moves the cursor to the origin, but does not change other settings such as the pivot direction.

¬

Not(any). Returns 1 if the value is falsy, 0 otherwise.

₂

SquareRoot(number).

Φ

Filter(int, any). Returns a list of the integers from 0 up to the argument where the expression is truthy.
Filter(iter, any). Returns only those elements where the expression is truthy. (Does not work for dictionaries on TIO.)

§

AtIndex(iter, int). Cyclically indexes into the iterable.

§≔

AssignAtIndex(list, int, any);. Updates an element of a dictionary, or of a list (including a list of cells) using cyclic indexing.

﹪

Modulo(number, number).
Modulo(str, number). Formats a string with a single format parameter.
Modulo(str, str). Formats a string with a single format parameter.
Modulo(list, number). Recursively vectorises over list.
Modulo(list, str). Recursively vectorises over list.
Modulo(str, list). Recursively vectorises over list.
Modulo(number, list). Recursively vectorises over list.

«

Begins a block or a lambda. The block does not need to be closed at the end of the program.

»

Ends a block or lambda.

×

Times(number, number).
Times(number, str). Repeats the string the given number of times, including fractional parts of the string, e.g. Times(1.5, "12") gives "121".
Times(str, number).
Times(list, str). Joins the elements of the list with the string.
Times(str, list). Joins the elements of the list with the string.
Times(list, number). Recursively vectorises over list. (Not recursive on TIO.)
Times(number, list). Recursively vectorises over list. (Not recursive on TIO.)
Times(list, list). Pairwise recursive multiplication. (Not available on TIO.)

⁺

Plus(number, number).
Plus(iter, iter). Concatenates two iterators of the same type. (Does not work for dictionaries on TIO.)
Plus(list, number). Recursively vectorises over list. (Not recursive on TIO.)
Plus(list, str). Recursively vectorises over list. (Not recursive on TIO.)
Plus(number, list). Recursively vectorises over list. (Not recursive on TIO.)
Plus(str, list). Recursively vectorises over list. (Not recursive on TIO.)

⁻

Minus(number, number).
Minus(str, str). Removes matches of the second string from the first.
Minus(list, list). Filters out elements of the first list that appear in the second.
Minus(dict, dict). Filters out elements of the first dictionary whose keys appear in the second. (Not available on TIO.)
Minus(list, number). Recursively vectorises over list. (Not recursive on TIO.)
Minus(list, str). Recursively vectorises over list. (Not recursive on TIO.)
Minus(number, list). Recursively vectorises over list. (Not recursive on TIO.)
Minus(str, list). Recursively vectorises over list. (Not recursive on TIO.)

·

Used as the decimal point in a floating-point literal.

See also …·.

÷

IntDivide(number, number). Integer or truncating division.
IntDivide(number, str). Repeats the string the reciprocal of given number of times, including fractional parts of the string, e.g. Divide("121", 1.5) gives "12".
IntDivide(str, number).
IntDivide(str, str). Splits the first string at occurrences of the second.
IntDivide(list, number). Recursively vectorises over list. (Not recursive on TIO.)
IntDivide(number, list). Recursively vectorises over list. (Not recursive on TIO.)

⁰¹²³⁴⁵⁶⁷⁸⁹

Used to create integer and floating-point literals.

¦

Used to separate consecutive integers or strings or as placeholders for optional arguments.

‖

Reflect(dir=→);. Reflects the canvas in the specified direction.

‖Ｔ

ReflectTransform(dir=→);. Reflects the canvas in the specified direction, reflecting the characters if possible.

‖Ｃ

ReflectCopy(dirs=→);. Reflects the canvas in each specified direction in turn, adding the reflected copy to the canvas after each reflection.

‖Ｍ

ReflectMirror(dirs=→);. As ReflectCopy but reflecting the characters if possible.

‖Ｏ

ReflectOverlap(dirs=→);. As ReflectOverlap but reflects around the edge characters (so that the reflected axis overlaps itself).

‖Ｂ

ReflectButterfly(dirs=→);. As ReflectOverlap but reflecting the characters if possible.

‖ＯＯ

ReflectOverlapOverlap(dirs=→, num);. As ReflectOverlap but specifies the amount of overlap.

‖ＢＯ

ReflectButterflyOverlap(dirs=→, num);. As ReflectOverlapOverlap but reflecting the characters if possible.

‹

Less(number, number).
Less(str, str).
Less(list, list).

⁼

Equals(any, any).

›

Less(number, number).
Less(str, str).
Less(list, list).

¿

if (any) stmt.
if (any) stmt else stmt.

Note that the first form is only possible at the end of a block or program.

Ａ

Input(). Returns the next input, but doesn't cast it to string or integer. Only relevant for JSON input.
Input(var);. Sets var to the the next input, but doesn't cast it to string or integer. Only relevant for JSON input.
ＫＡ

PeekAll(). Returns a list of all the non-background cells in the canvas. Cells can be assigned to using AssignAtIndex.

See also ⌕Ａ.

Ｂ

Box(int, str);. Draws the string around the sides of a square of the given size.
Box(int, int);. Draws a rectangle of the given size, using +s for the corners and -s and |s for the horizontal and vertical sides.
Box(int, int, str);. Draws the string around the sides of a rectangle of the given size.
‖Ｂ

ReflectButterfly(dirs=→);. As ReflectOverlap but reflecting the characters if possible.

‖ＢＯ

ReflectButterflyOverlap(dirs=→, num);. As ReflectOverlapOverlap but reflecting the characters if possible.

ＵＢ

SetBackground(str);. Sets the string that should fill the background when the canvas is output. Defaults to a space.

Ｃ

Copy(int, int);. Overlays the canvas with a copy of it offset by the given horizontal and vertical amounts.

‖Ｃ

ReflectCopy(dirs=→);. Reflects the canvas in each specified direction in turn, adding the reflected copy to the canvas after each reflection.

See also ⟲Ｃ.

Ｄ

Dump();. Outputs a copy of the canvas to standard output. Delays by 10ms since the last dump. (ATO: Use --nt to disable the delay.)

ＫＤ

PeekDirection(int, dir). Returns a list of the cell under the cursor and continuing in the given direction up to the given length. Cells can be assigned to using AssignAtIndex.

Ｅ

Map(int, any). Maps over the integers from 0 up to the argument and returns a list of the results.
Map(iter, any). Maps over the elements of the argument and returns a list of the results. (Does not work for dictionaries on TIO.)
See also ＵＥ.

Ｆ

for (int). Loops over the integers from 0 up to the argument.
for (iter). Loops over the elements of the argument. (Does not work for dictionaries on TIO.)
ＲＦ

RefreshFor(int, int). Loops over the integers from 0 up to the second argument, but displays the canvas at every step, with the given delay. RefreshFor(int, iter). Loops over the elements of the argument, but displays the canvas at every step, with the given delay.

Ｇ

Polygon(dir, int, ... str);. Draws a polygon using the given directions and lengths, filling it with the given string. (Note that the lengths are inclusive.)
Polygon(dirs, int, str);. Draws a polygon using the given directions and length, filling it with the given string. (Note that the length is inclusive.)
ＧＨ

PolygonHollow(dir, int, ... str);. Draws the string along the given directions and path lengths. (Note that the lengths are inclusive.)
PolygonHollow(dirs, int, str);. Draws the string along the given directions and path length. (Note that the length is inclusive.)

Ｈ

See ＧＨ.

Ｉ

Cast(int). Casts the value to a string. (TIO: Tries to remove the trailing .0 for floating-point values that represent integers, but floors the result instead of rounding it. Also the output for large floating-point values is suboptimal.)
Cast(str). Interprets the contents of string as a Python literal, or returns 0 if the string is empty. (TIO: Only supports integers and floats.)
Cast(list). Recursively vectorises over the list.

Ｊ

JumpTo(int, int);. Moves the cursor to the given absolute position.

Ｋ

ＫＡ

PeekAll(). Returns a list of all the non-background cells in the canvas. Cells can be assigned to using AssignAtIndex.

ＫＤ

PeekDirection(int, dir). Returns a list of the cell under the cursor and continuing in the given direction up to the given length. Cells can be assigned to using AssignAtIndex.

ＫＫ

Peek(). Returns the character under the cursor.

ＫＭ

PeekMoore(). Returns a list of the cells orthogonally and diagonally adjacent, starting with the cell above and to the left and working clockwise around the cursor. Cells can be assigned to using AssignAtIndex.

ＫＶ

PeekVonNeumann(). Returns a list of the cells orthogonally adjacent, starting with the cell above and working clockwise around the cursor. Cells can be assigned to using AssignAtIndex.

Ｌ

Length(iter). Returns the length of the iterable.

Ｍ

Move(dir). Moves one character in the given direction. Needed if the direction would otherwise be interpreted as a Print command.
Move(int, dir). Moves one character the given amount in the given direction.
Move(int, int). Moves the cursor to the given relative position.
ＵＭ

MapCommand(iter, any);. Maps over the elements of the argument and updates the argument if possible. (Does not work for dictionaries on TIO.)

See also ＫＭ.

Ｎ

InputNumber(). Returns the next input cast to integer.
InputNumber(var);. Sets var to the the next input cast to integer.

Ｏ

⊞Ｏ

PushOperator(list, any). Appends the value to the list and returns the list.

See also ⟲Ｏ.
See also ⟲ＯＯ.
See also ⟲ＳＯ.
See also ‖Ｏ.
See also ‖ＯＯ.
See also ‖ＢＯ.

Ｐ

Multiprint(str); Writes the string to the canvas without moving the cursor.
Multiprint(int); Writes a line of one of -, |, / or \ depending on the current direction of the given length to the canvas without moving the cursor.
Multiprint(dirs, str); Writes the string to the canvas in each of the specified directions without moving the cursor.
Multiprint(dirs, int); Writes the appropriate lines of -, |, / or \ for each direction of the given length to the canvas without moving the cursor. Note that the resulting character under the cursor will be that of the last direction used.
See also ⟲Ｐ.

Ｑ

Unused.

Ｒ

Refresh(int=0); Displays the canvas to the screen, but with an optional delay since the last refresh.

ＲＷ

RefreshWhile(any) Loops while the argument is true, saving it in the next loop variable, but displays the canvas at every step, with the given delay. The argument is evaluated after the RefreshWhile loop variable is reserved.

See also ＲＦ.
See also ＵＲ.

Ｓ

InputString(). Returns the next input cast to string.
InputString(var);. Sets var to the the next input cast to string.
See also ⟲Ｓ.
See also ⟲ＳＯ.

Ｔ

Trim(int);. Removes any part of the canvas outside the square with the given size, but also any part of the canvas above or to the left of the origin. Trim(int, int);. Removes any part of the canvas outside the rectangle with the given size, but also any part of the canvas above or to the left of the origin.

⟲Ｔ

RotateTransform(int=2);. Rotates the canvas anticlockwise by 45° times the argument, rotating the characters if possible.

‖Ｔ

ReflectTransform(dir=→);. Reflects the canvas in the specified direction, reflecting the characters if possible.

ＵＴ

ToggleTrim();. Toggles whether the canvas output is right-padded (default true).

Ｕ

ＵＢ

SetBackground(str);. Sets the string that should fill the background when the canvas is output. Defaults to a space.

ＵＥ

Extend(int);. Inserts a gap between every column of the canvas.
Extend(int, int);. Inserts a gap between every column and row of the canvas.

ＵＭ

MapCommand(iter, any);. Maps over the elements of the argument and updates the argument if possible. (Does not work for dictionaries on TIO.)

ＵＯ

Oblong(int, str);. Fills a square of the given size with the string.
Oblong(int, int, str);. Fills a rectangle of the given size with the string.

ＵＲ

Rectangle(int);. Draws a square of the given size, using +s for the corners and -s and |s for the horizontal and vertical sides.
Rectangle(int, str);. Draws the string around the sides of a square of the given size.
Rectangle(int, int);. Draws a rectangle of the given size, using +s for the corners and -s and |s for the horizontal and vertical sides.

ＵＴ

ToggleTrim();. Toggles whether the canvas output is right-padded (default true).

ＵＶ

PythonEvaluate(). Evaluates the string as Python code.

ＵＸ

PythonExecute(str). Executes the string as Python code.

Ｖ

Evaluate(str) Evalutes the string as Charcoal code.
Evaluate(str); Executes the string as Charcoal code.
ＫＶ

PeekVonNeumann(). Returns a list of the cells orthogonally adjacent, starting with the cell above and working clockwise around the cursor. Cells can be assigned to using AssignAtIndex.

ＵＶ

PythonEvaluate(). Evaluates the string as Python code.

Ｗ

while (any) Loops while the argument is true, saving it in the next loop variable. The argument is evaluated after the while loop variable is reserved.

ＲＷ

RefreshWhile(any) Loops while the argument is true, saving it in the next loop variable, but displays the canvas at every step, with the given delay. The argument is evaluated after the RefreshWhile loop variable is reserved.

Ｘ

Power(number, number).
Power(list, number). Recursively vectorises over the list.
Power(number, list). Recursively vectorises over the list.
ＵＸ

PythonExecute(str). Executes the string as Python code.

Ｙ

Unused.

Ｚ

Unused

⟦

Begins a list.

∕

Divide(number, number). Floating-point division.
Divide(number, str). Repeats the string the reciprocal of given number of times, including fractional parts of the string, e.g. Divide("121", 1.5) gives "12".
Divide(str, number).
Divide(str, str). Splits the first string at occurrences of the second.
Divide(list, number). Recursively vectorises over list. (Not recursive on TIO.)
Divide(number, list). Recursively vectorises over list. (Not recursive on TIO.)

⟧

Ends a list. Optional at the end of the program.

…

Range(int). Returns the range [0, value).
Range(int, int).
Range(char, char).
CycleChop(iterable, int). Cyclically extends or truncates the iterable to the given length, e.g. CycleChop("12", 5) gives "12121". (TIO: iterable must not be empty, even if the length is zero.)
…·

InclusiveRange(int). Returns the range [0, value].
InclusiveRange(int, int).
InclusiveRange(char, char).

´

Quotes a command character, allowing it to be used as part of a string literal.

αβχδεφγηικλμνπθρστυςωξψζ

Variables. αβχφγυωψ have predefined values. ικλμνξπρςστδεζηθ are used by loop variables, if possible. (Note that expression loops consume two variables, one for the value and one for the index.) θηζεδ attempt to retrieve the first five inputs, if not being used as loop variables.

¤

Fill(str);. If the cursor is in an empty space, fills that space with the given string, repeating as needed.

⦃

Begins a dictionary.

⦄

Ends a dictionary. Optional at the end of the program.

～

BitwiseNot(int).