Reference

Declaration and module structure

Keyword	Description
CLASS	A declared structure composed of constant and variable data fields and defined methods, following normal object-oriented protocols of inheritance by extending a parent class and overriding methods, and implementing interface types. It could be a generic type with a template qualifier declared before it.
NAMESPACE	A declared structure composed of stateless, constant data fields and methods. It cannot extend a parent namespace or class, and it cannot implement an interface.
EXTENDS	A declarative statement that establishes the relationship between a class and its parent, following object-oriented protocols.
IMPLEMENTS	A declarative statement that establishes the relationship between a class and an interface, following object-oriented protocols. Every method declared on the interface must be implemented by the class declaring it.
INTERFACE	A declared structure composed of declared methods without a defined body.
STRUCT	A declared structure composed of constant and variable data fields. It cannot have methods, nor participate in object-oriented protocols of inheritance or interface implementation.
ENUM	A declared ordered structure of named elements, where each is optionally assigned a numeric value.
GROUP	A declared structure that is an external mechanism to combine primitives, groups, and user-defined types without those having any knowledge of this declared structure. Ideal for an interface with no methods.
METHOD	A defined function on a class or namespace that evaluates some expression or statement, returning types as defined.
INIT	A special method on a class that executes when CREATE() is called.
CLEANUP	A special method on a class that executes just before a class instance is destroyed by falling out of scope of the {} it was created in, or at the end of the method, or, if its a data field on another class, when that enclosing class is destroyed.
MODULE	A collection of classes in the same folder, usually providing related functionality.
UNION	A grouping of multiple types for which an assigned value could only be one of those types, primary example is the 'number' primitive.
ALIAS	A means to provide shorthand to long namespace names. Must be defined at the top of that class file.
FOREIGN	A declaration of a C function, written with matching Envzn types, usually combined with BIND. Always at the top of the file.
FOREIGN_TYPE	A declaration of a C structure or type, written with matching Envzn types, usually related to a C function that may require it or return it.
BIND	Always combined with FOREIGN; a functional declaration in Envzn that maps to a C function.
SETS_ERRNO	A declarative that attaches to the end of the FOREIGN BIND declaration if that C function also sets ERRNO.
LOAD	A declarative that is added to a parameter if the C function will write into that parameter space.
UNSAFE	A declarative at the start of a {...} block, inside which a FOREIGN_TYPE handle — a raw C pointer the compiler cannot vouch for — may be reached through to read or write a field. It is a narrow permission rather than a suspension of checking: everything else is checked as usual, and only that one otherwise-rejected access (E3036) becomes legal. Provides additional functionality to opaque types.
TEMPLATE	A declaration that the following class will be generic and bound by template qualifier.
GIVEN	Part of the template qualifier declaration where the generic elements are type-limited.
TYPE	The single-parameter form of a template qualifier, naming one generic element and the constraints it must satisfy — TEMPLATE: GIVEN TYPE T IS Cloneable, PRIMITIVE:.
TYPES	The multi-parameter form of a template qualifier, naming several generic elements whose constraint groups are then separated by semicolons — TEMPLATE: GIVEN TYPES V, H; V IS Cloneable; H IS Hashable:.
EXCEPT	Part of the template qualifier declaration where the generic elements are type-limited, but this clause excludes subelements of a group, commonly seen with "PRIMITIVE (EXCEPT boolean)"
PRIMITIVE	A group defined by the compiler as foundational types, such as int32, float64, char32, binary, number, and complex.
IDENTITY	A language mechanism that returns a STRUCT populated with everything the compiler knows about this element at that point.

Type-system modifiers

Keyword	Description
ABSTRACT	A declarative on a class stating that this class has at least one method declared but not defined, requiring an override by a subclass.
FINAL	A declarative on a class stating that this class cannot be extended with inheritance.
OVERRIDE	A declarative on a method stating that this method will be called to override a method of the same name and signature in a parent.
SINGLETON	A declarative on a class limiting that class to one instance.
PRIVATE	A modifier on a data field or method stating that this item cannot be accessed outside of this class. Only usable by class and namespace types.
PROTECTED	A modifier on a data field or method stating that this item can only be accessed outside of this class by subclasses. Only usable by class types.
INTERNAL	A class data field modifier that allows other classes in the same module to access it freely, yet classes outside of the module are forbidden acces to it. Only usable by class types.
SHARED	A specialization of a class that allows instances of it to become shared mutable references, meaning two handles can modify the same object. Also a modifier on a MUTABLE REFERENCE that allows a second to be created.
VOLATILE	Reserved for future use.
VALUE	A modifier on a class declaration that gives it value identity and inline storage instead of a heap handle, so it is passed and copied as a whole value — VALUE CLASS Money { ... }. It still carries methods, generics and interface conformance, but it is an inheritance leaf: it may implement an interface but it may neither extend nor be extended.
HIDDEN	A specialization of a class that forces access to a one or a group of classes through a defined interface.
REFERENCE	A borrowed handle for an owned object; created by =@ or by passing an owned object into a REFERENCE parameter into method.
MUTABLE	A modifier on a data field or local variable allowing MODIFY methods to be accessed freely.
MOVE	Reserved; RETIRED as a parameter marker (2026-10-01). A plain parameter owns its argument; writing MOVE on a parameter is E1164.
DUPLICATE	A mechanism to duplicate whatever is adjacent to the keyword, whether it is an object (it will call clone()), a struct or a primitive.
CONSTANT	A modifier on a data field or local variable that establishes that element at compile-time as unchangeable.
MODIFY	A declarative on a class method stating that this method will change the internal state of the instance.
AUTO	A method modifier that asks the compiler to generate the method body rather than writing one. In V1 it applies to a single form, AUTO METHOD clone() RETURNS <classname> { }.
DERIVED	A modifier on a class data field as a marker for Json serializer/deserializer to not touch it.
BLITTABLE	A Group defined in the compiler as types that are able to be trivially copied by value.
DEPRECATED	A modifier that marks a class or a method as obsolete without removing it. A call to a deprecated method, and a construction of a deprecated class, compile and run exactly as before — the mark is advisory and warns at the call site.

Method semantics and instance

Keyword	Description
RETURNS	A declarative part of a method stating what types that method should return.
RETURN	A language mechanism for exiting a method/function. Requires any type being returned to be in ().
VOID	A language mechanism for stating that a method will return nothing when it finishes.
LAMBDA	A keyword that defines an anonymous function, as in LAMBDA (int32 x) { RETURN (x * 2) }. There is no implicit-lambda form anywhere in the language: a bare brace block or a parenthesized parameter list is not a lambda unless LAMBDA precedes it.
OF	A language mechanism used with templates to state that this generic type is "of T", example: Array OF T, equivalent to Array[T]
IS	A language mechanism used in many situations related to checking the type, some examples: WHEN x IS <interface>, IF y IS VALID THEN {...}
CREATE	A language mechanism for (a) allocating memory for a class or struct, (b) calling the INIT() method on the class, and (c) returning the handle to assign it to the left-hand side of the ':='.
SELF	A keyword reserved for future use.
SUPER	A language mechanism for a subclass to explicitly access data fields and methods of its parent.

Control flow

Keyword	Description
IF	A language mechanism to evaluate a given expression, and if true to follow the THEN path, and if false to follow the ELSE path.
THEN	A language mechanism for the block used when the IF expression evaluates to true.
ELSE	A language mechanism for the block used when the IF expression evaluates to false.
WHILE	A language mechanism to evaluate a given expression, and if true to continue into the following block, and if false to skip the following block. When the block ends, return to the WHILE line to re-evaluate the expression again.
DO	A language mechanism associated with WHILE that sits between the evaluated expression and the following block {}
FOR	A language looping mechanism declaring an expression to be evaluated with an auto-increment, and if true to continue into the following block, and if false ot skip the following block. When the block ends, return to the FOR line to re-evaluate the expression again.
FOREACH	Reserved for future use.
LOOP	A language looping mechanism over a collection iterator that carries the element's position alongside the element, written as "LOOP name IN collection WITH INDEX index".
REPEAT	A language looping mechanism that counts without a variable and runs the following block, in two forms: "REPEAT n {...}" or "REPEAT {...}". The latter form runs indefinitely requiring a BREAK to exit that loop.
UNTIL	A language mechanism associated with FOR and DO that precedes a conditioanl expression: if true with the FOR, enter the following block; if true with the DO, repeat the prevous block. Used like "FOR index=0 UNTIL length {...}" or "DO { ... } UNTIL (<expression>)".
TO	The clause of a counted FOR that names an inclusive upper bound. FOR i = 1 TO 6 runs six times and ends with i == 6, where FOR i = 1 UNTIL 6 runs five times and stops before its bound.
STEP	The optional clause of a counted FOR range that sets the increment between iterations, as in FOR i = 0 TO 10 STEP 2.
IN	The clause that names the collection a loop walks, in both FOR e IN items and LOOP e IN items WITH INDEX i. The element binds as a non-owning reference, and the collection is locked against mutation for the duration of the body.
BREAK	A language looping mechanism that exits the current loop, moving the the closing "}". Could be followed by a label, like "BREAK copying" if "copying" is a LABEL declared just before the top of the block (really helpful for exiting nested loops).
CONTINUE	A language looping mechanism that jumps back to the start of the FOR or WHILE loop.
MATCH	A statement that selects one arm from a set of cases, most often the cases of an enum, with an absence arm available for a value that may be EMPTY. It is the dispatch form for a closed set, where IF is the form for a condition.
WHEN	A language mechanism for evaluating an expression related to class identity, like if a given class extends a parent or implements an interface. Used like "WHEN x IS <classname> {...}"
DEFAULT	Used with MATCH...
WITH	The first half of WITH INDEX, the mandatory clause of LOOP. Both halves are required — a LOOP without WITH INDEX is a compile error, and WITH INDEX on any other loop keyword is one too.
INDEX	The second half of LOOP's mandatory WITH INDEX clause, naming the read-only int64 that carries the element's zero-based position — LOOP e IN items WITH INDEX i. Assigning to it is a compile error, because it is the loop's own state and a writable copy reintroduces the off-by-one the form exists to remove.
HOTLOOP	A language mechanism asking the compiler to attempt to optimize that loop; only valid on FOR and WHILE loops.
LABEL	A declarative name given to a code block, used by BREAK or CONTINUE.

Error handling and STATUS narrowing

Keyword	Description
TRY	A declarative given to a code block warning the compiler that the following block could raise a PANIC.
RECOVER	A defined block following a TRY block that acts as landing pad to start recovery when a PANIC was raised inside the TRY block; note there could be more than one if a given PANIC type is named with the RECOVER block.
FINALLY	A defined block following a TRY block and RECOVER blocks that executes regardless of what path is taken before it.
PANIC	A language mechanism raised when an invariant condition that should not exist is detected, like DivideByZero.
ASSERT	A statement that halts the program when its condition is false, written ASSERT(p.age == 30) => "age should match". It is the dev-only tier of the assertion family and is stripped entirely under -prod, condition and all; unlike a PANIC it aborts without unwinding, so no CLEANUP runs and it cannot be recovered.
ASSERT!	The always-on tier of the same family — identical to ASSERT except that the ! marks an assertion that survives -prod and so fires in production. Use it for an invariant that must hold in a shipped build, where ASSERT is for a check that need only hold while developing.
UNREACHABLE!	An unconditional, always-on marker for a branch that cannot be reached — the exhaustive-MATCH default, a not-yet-implemented stub, a dead arm. The message is optional, and the analyzer treats it as a control-flow terminator, so it satisfies definite-return and exhaustiveness in a branch that cannot produce a value.
SNAPSHOT	A language mechanism for showing what variables are in scope at the given point, along with their type and their value.
STACKTRACE	A language mechanism for showing vertically what methods were called from the top, down the stack, to arrive at the given point.
SUCCESS	A language mechanism part of the STATUS field.
FAILURE	A language mechanism part of the STATUS field.
PARTIAL_SUCCESS	A language mechanism part of the STATUS field.
OK	A short spelling of SUCCESS in a STATUS narrowing test — IF s IS OK reads as IF s IS SUCCESS.
PARTIAL	A short spelling of PARTIAL_SUCCESS in a STATUS narrowing test — IF s IS PARTIAL reads as IF s IS PARTIAL_SUCCESS.
VALID	A language mechanism usually acting as a guard on a reference or shared mutual reference to test if the object pointed to is valid.

Logical and boolean literals

Keyword	Description
AND	A language feature for evaluating a boolean AND expression.
OR	A language feature for evaluating a boolean OR expression.
NOT	A language feature for evaluating a boolean NOT expression.
XOR	A language feature for evaluating a boolean exclusive-OR expression.
TRUE	A boolean value.
FALSE	A boolean value.
EMPTY	A possible value for a WEAK REFERENCE when it contains no value.
NONE	The absence spelling that survives beside EMPTY. A MATCH absence arm accepts either, and the legacy IS NONE reads as IS NOT VALID; the canonical absence model remains bare-type EMPTY.

Bitwise and shift (keyword form — no C-style operator symbols)

Keyword	Description
BAND	A language feature for bitwise AND operation.
BOR	A language feature for bitwise OR operation.
BXOR	A language feature for bitwise exclusive OR operation.
BNOT	A language feature for bitwise NOT operation.
LSHIFT	A language feature for bitwise shift left; number following the number of bits to shift.
RSHIFT	A language feature for bitwise shift right; number following the number of bits to shift; the logical form and fills with zero.
ASHIFT	The arithmetic right shift, which fills the vacated high bits with the sign bit so a negative value stays negative — value ASHIFT 4.
LROTATE	A language feature for bitwise rotate left; number following the number of bits to move.
RROTATE	A language feature for bitwise rotate right; number following the number of bits to move.

Bit-pattern equality

Keyword	Description
BEQUALS	A comparison that tests two values for an identical bit pattern rather than an equal value, which is how NaN BEQUALS NaN is true and 0.0 BEQUALS -0.0 is false. Ordinary == compares values and answers the opposite in both cases.
BNEQUALS	The negation of BEQUALS, true when two bit patterns differ.

Concurrency

Keyword	Description
SYNCHRONIZED	A specialized label for a block so that only one thread at a time is able to execute that block.
ATTACHED	Reserved for future use.
CONCURRENT	A special label for a block that could execute multiple threads concurrently.
DETACHED	Reserved for future use.
LONG_LIVED	Reserved for future use.
PARALLEL	A specialized label for a block that assumes it will run multiple threads in parallel over the following block.

Conversion operators (I.D.viii)

Keyword	Description
CONVERSIONS	A specialized type of NAMESPACE reserved exclusively for type conversions.
OPERATOR	A language mechanism that allows for user-defined operations, like ">>" or whatever.
AS	A language mechanism for converting between types; note AS is lossy.
INTO	A language mechanism for converting between types; note INTO is lossless.
FROM	Used in conversions.

Reserved-only (claimed, no V1 semantics — using one is an error, E1163)

Keyword	Description
NO_RETURN	Reserved for future use.
FREEZE	Reserved for future use.
POISON	Reserved for future use.
FENCE	Reserved for future use.
SECRET	Reserved for future use.
ENCRYPTED	Reserved for future use.
TEMPORARY	Reserved for future use.
DIRTY	Reserved for future use.
PUBLIC	Reserved for future use.
FEATURE	Reserved for future use.
UNREACHABLE	Reserved for compiler error catching reminding the dev to use UNREACHABLE!
THROW	Reserved for compiler error catching reminding the dev to use PANIC.
CATCH	Reserved for compiler error catching reminding the dev to use RECOVER.

Keyword	Group	Description
ABSTRACT	Type-system modifiers	A declarative on a class stating that this class has at least one method declared but not defined, requiring an override by a subclass.
ALIAS	Declaration and module structure	A means to provide shorthand to long namespace names. Must be defined at the top of that class file.
AND	Logical and boolean literals	A language feature for evaluating a boolean AND expression.
AS	Conversion operators (I.D.viii)	A language mechanism for converting between types; note AS is lossy.
ASHIFT	Bitwise and shift (keyword form — no C-style operator symbols)	The arithmetic right shift, which fills the vacated high bits with the sign bit so a negative value stays negative — value ASHIFT 4.
ASSERT	Error handling and STATUS narrowing	A statement that halts the program when its condition is false, written ASSERT(p.age == 30) => "age should match". It is the dev-only tier of the assertion family and is stripped entirely under -prod, condition and all; unlike a PANIC it aborts without unwinding, so no CLEANUP runs and it cannot be recovered.
ASSERT!	Error handling and STATUS narrowing	The always-on tier of the same family — identical to ASSERT except that the ! marks an assertion that survives -prod and so fires in production. Use it for an invariant that must hold in a shipped build, where ASSERT is for a check that need only hold while developing.
ATTACHED	Concurrency	Reserved for future use.
AUTO	Type-system modifiers	A method modifier that asks the compiler to generate the method body rather than writing one. In V1 it applies to a single form, AUTO METHOD clone() RETURNS <classname> { }.
BAND	Bitwise and shift (keyword form — no C-style operator symbols)	A language feature for bitwise AND operation.
BEQUALS	Bit-pattern equality	A comparison that tests two values for an identical bit pattern rather than an equal value, which is how NaN BEQUALS NaN is true and 0.0 BEQUALS -0.0 is false. Ordinary == compares values and answers the opposite in both cases.
BIND	Declaration and module structure	Always combined with FOREIGN; a functional declaration in Envzn that maps to a C function.
BLITTABLE	Type-system modifiers	A Group defined in the compiler as types that are able to be trivially copied by value.
BNEQUALS	Bit-pattern equality	The negation of BEQUALS, true when two bit patterns differ.
BNOT	Bitwise and shift (keyword form — no C-style operator symbols)	A language feature for bitwise NOT operation.
BOR	Bitwise and shift (keyword form — no C-style operator symbols)	A language feature for bitwise OR operation.
BREAK	Control flow	A language looping mechanism that exits the current loop, moving the the closing "}". Could be followed by a label, like "BREAK copying" if "copying" is a LABEL declared just before the top of the block (really helpful for exiting nested loops).
BXOR	Bitwise and shift (keyword form — no C-style operator symbols)	A language feature for bitwise exclusive OR operation.
CATCH	Reserved-only (claimed, no V1 semantics — using one is an error, E1163)	Reserved for compiler error catching reminding the dev to use RECOVER.
CLASS	Declaration and module structure	A declared structure composed of constant and variable data fields and defined methods, following normal object-oriented protocols of inheritance by extending a parent class and overriding methods, and implementing interface types. It could be a generic type with a template qualifier declared before it.
CLEANUP	Declaration and module structure	A special method on a class that executes just before a class instance is destroyed by falling out of scope of the {} it was created in, or at the end of the method, or, if its a data field on another class, when that enclosing class is destroyed.
CONCURRENT	Concurrency	A special label for a block that could execute multiple threads concurrently.
CONSTANT	Type-system modifiers	A modifier on a data field or local variable that establishes that element at compile-time as unchangeable.
CONTINUE	Control flow	A language looping mechanism that jumps back to the start of the FOR or WHILE loop.
CONVERSIONS	Conversion operators (I.D.viii)	A specialized type of NAMESPACE reserved exclusively for type conversions.
CREATE	Method semantics and instance	A language mechanism for (a) allocating memory for a class or struct, (b) calling the INIT() method on the class, and (c) returning the handle to assign it to the left-hand side of the ':='.
DEFAULT	Control flow	Used with MATCH...
DEPRECATED	Type-system modifiers	A modifier that marks a class or a method as obsolete without removing it. A call to a deprecated method, and a construction of a deprecated class, compile and run exactly as before — the mark is advisory and warns at the call site.
DERIVED	Type-system modifiers	A modifier on a class data field as a marker for Json serializer/deserializer to not touch it.
DETACHED	Concurrency	Reserved for future use.
DIRTY	Reserved-only (claimed, no V1 semantics — using one is an error, E1163)	Reserved for future use.
DO	Control flow	A language mechanism associated with WHILE that sits between the evaluated expression and the following block {}
DUPLICATE	Type-system modifiers	A mechanism to duplicate whatever is adjacent to the keyword, whether it is an object (it will call clone()), a struct or a primitive.
ELSE	Control flow	A language mechanism for the block used when the IF expression evaluates to false.
EMPTY	Logical and boolean literals	A possible value for a WEAK REFERENCE when it contains no value.
ENCRYPTED	Reserved-only (claimed, no V1 semantics — using one is an error, E1163)	Reserved for future use.
ENUM	Declaration and module structure	A declared ordered structure of named elements, where each is optionally assigned a numeric value.
EXCEPT	Declaration and module structure	Part of the template qualifier declaration where the generic elements are type-limited, but this clause excludes subelements of a group, commonly seen with "PRIMITIVE (EXCEPT boolean)"
EXTENDS	Declaration and module structure	A declarative statement that establishes the relationship between a class and its parent, following object-oriented protocols.
FAILURE	Error handling and STATUS narrowing	A language mechanism part of the STATUS field.
FALSE	Logical and boolean literals	A boolean value.
FEATURE	Reserved-only (claimed, no V1 semantics — using one is an error, E1163)	Reserved for future use.
FENCE	Reserved-only (claimed, no V1 semantics — using one is an error, E1163)	Reserved for future use.
FINAL	Type-system modifiers	A declarative on a class stating that this class cannot be extended with inheritance.
FINALLY	Error handling and STATUS narrowing	A defined block following a TRY block and RECOVER blocks that executes regardless of what path is taken before it.
FOR	Control flow	A language looping mechanism declaring an expression to be evaluated with an auto-increment, and if true to continue into the following block, and if false ot skip the following block. When the block ends, return to the FOR line to re-evaluate the expression again.
FOREACH	Control flow	Reserved for future use.
FOREIGN	Declaration and module structure	A declaration of a C function, written with matching Envzn types, usually combined with BIND. Always at the top of the file.
FOREIGN_TYPE	Declaration and module structure	A declaration of a C structure or type, written with matching Envzn types, usually related to a C function that may require it or return it.
FREEZE	Reserved-only (claimed, no V1 semantics — using one is an error, E1163)	Reserved for future use.
FROM	Conversion operators (I.D.viii)	Used in conversions.
GIVEN	Declaration and module structure	Part of the template qualifier declaration where the generic elements are type-limited.
GROUP	Declaration and module structure	A declared structure that is an external mechanism to combine primitives, groups, and user-defined types without those having any knowledge of this declared structure. Ideal for an interface with no methods.
HIDDEN	Type-system modifiers	A specialization of a class that forces access to a one or a group of classes through a defined interface.
HOTLOOP	Control flow	A language mechanism asking the compiler to attempt to optimize that loop; only valid on FOR and WHILE loops.
IDENTITY	Declaration and module structure	A language mechanism that returns a STRUCT populated with everything the compiler knows about this element at that point.
IF	Control flow	A language mechanism to evaluate a given expression, and if true to follow the THEN path, and if false to follow the ELSE path.
IMPLEMENTS	Declaration and module structure	A declarative statement that establishes the relationship between a class and an interface, following object-oriented protocols. Every method declared on the interface must be implemented by the class declaring it.
IN	Control flow	The clause that names the collection a loop walks, in both FOR e IN items and LOOP e IN items WITH INDEX i. The element binds as a non-owning reference, and the collection is locked against mutation for the duration of the body.
INDEX	Control flow	The second half of LOOP's mandatory WITH INDEX clause, naming the read-only int64 that carries the element's zero-based position — LOOP e IN items WITH INDEX i. Assigning to it is a compile error, because it is the loop's own state and a writable copy reintroduces the off-by-one the form exists to remove.
INIT	Declaration and module structure	A special method on a class that executes when CREATE() is called.
INTERFACE	Declaration and module structure	A declared structure composed of declared methods without a defined body.
INTERNAL	Type-system modifiers	A class data field modifier that allows other classes in the same module to access it freely, yet classes outside of the module are forbidden acces to it. Only usable by class types.
INTO	Conversion operators (I.D.viii)	A language mechanism for converting between types; note INTO is lossless.
IS	Method semantics and instance	A language mechanism used in many situations related to checking the type, some examples: WHEN x IS <interface>, IF y IS VALID THEN {...}
LABEL	Control flow	A declarative name given to a code block, used by BREAK or CONTINUE.
LAMBDA	Method semantics and instance	A keyword that defines an anonymous function, as in LAMBDA (int32 x) { RETURN (x * 2) }. There is no implicit-lambda form anywhere in the language: a bare brace block or a parenthesized parameter list is not a lambda unless LAMBDA precedes it.
LOAD	Declaration and module structure	A declarative that is added to a parameter if the C function will write into that parameter space.
LONG_LIVED	Concurrency	Reserved for future use.
LOOP	Control flow	A language looping mechanism over a collection iterator that carries the element's position alongside the element, written as "LOOP name IN collection WITH INDEX index".
LROTATE	Bitwise and shift (keyword form — no C-style operator symbols)	A language feature for bitwise rotate left; number following the number of bits to move.
LSHIFT	Bitwise and shift (keyword form — no C-style operator symbols)	A language feature for bitwise shift left; number following the number of bits to shift.
MATCH	Control flow	A statement that selects one arm from a set of cases, most often the cases of an enum, with an absence arm available for a value that may be EMPTY. It is the dispatch form for a closed set, where IF is the form for a condition.
METHOD	Declaration and module structure	A defined function on a class or namespace that evaluates some expression or statement, returning types as defined.
MODIFY	Type-system modifiers	A declarative on a class method stating that this method will change the internal state of the instance.
MODULE	Declaration and module structure	A collection of classes in the same folder, usually providing related functionality.
MOVE	Type-system modifiers	Reserved; RETIRED as a parameter marker (2026-10-01). A plain parameter owns its argument; writing MOVE on a parameter is E1164.
MUTABLE	Type-system modifiers	A modifier on a data field or local variable allowing MODIFY methods to be accessed freely.
NAMESPACE	Declaration and module structure	A declared structure composed of stateless, constant data fields and methods. It cannot extend a parent namespace or class, and it cannot implement an interface.
NONE	Logical and boolean literals	The absence spelling that survives beside EMPTY. A MATCH absence arm accepts either, and the legacy IS NONE reads as IS NOT VALID; the canonical absence model remains bare-type EMPTY.
NOT	Logical and boolean literals	A language feature for evaluating a boolean NOT expression.
NO_RETURN	Reserved-only (claimed, no V1 semantics — using one is an error, E1163)	Reserved for future use.
OF	Method semantics and instance	A language mechanism used with templates to state that this generic type is "of T", example: Array OF T, equivalent to Array[T]
OK	Error handling and STATUS narrowing	A short spelling of SUCCESS in a STATUS narrowing test — IF s IS OK reads as IF s IS SUCCESS.
OPERATOR	Conversion operators (I.D.viii)	A language mechanism that allows for user-defined operations, like ">>" or whatever.
OR	Logical and boolean literals	A language feature for evaluating a boolean OR expression.
OVERRIDE	Type-system modifiers	A declarative on a method stating that this method will be called to override a method of the same name and signature in a parent.
PANIC	Error handling and STATUS narrowing	A language mechanism raised when an invariant condition that should not exist is detected, like DivideByZero.
PARALLEL	Concurrency	A specialized label for a block that assumes it will run multiple threads in parallel over the following block.
PARTIAL	Error handling and STATUS narrowing	A short spelling of PARTIAL_SUCCESS in a STATUS narrowing test — IF s IS PARTIAL reads as IF s IS PARTIAL_SUCCESS.
PARTIAL_SUCCESS	Error handling and STATUS narrowing	A language mechanism part of the STATUS field.
POISON	Reserved-only (claimed, no V1 semantics — using one is an error, E1163)	Reserved for future use.
PRIMITIVE	Declaration and module structure	A group defined by the compiler as foundational types, such as int32, float64, char32, binary, number, and complex.
PRIVATE	Type-system modifiers	A modifier on a data field or method stating that this item cannot be accessed outside of this class. Only usable by class and namespace types.
PROTECTED	Type-system modifiers	A modifier on a data field or method stating that this item can only be accessed outside of this class by subclasses. Only usable by class types.
PUBLIC	Reserved-only (claimed, no V1 semantics — using one is an error, E1163)	Reserved for future use.
RECOVER	Error handling and STATUS narrowing	A defined block following a TRY block that acts as landing pad to start recovery when a PANIC was raised inside the TRY block; note there could be more than one if a given PANIC type is named with the RECOVER block.
REFERENCE	Type-system modifiers	A borrowed handle for an owned object; created by =@ or by passing an owned object into a REFERENCE parameter into method.
REPEAT	Control flow	A language looping mechanism that counts without a variable and runs the following block, in two forms: "REPEAT n {...}" or "REPEAT {...}". The latter form runs indefinitely requiring a BREAK to exit that loop.
RETURN	Method semantics and instance	A language mechanism for exiting a method/function. Requires any type being returned to be in ().
RETURNS	Method semantics and instance	A declarative part of a method stating what types that method should return.
RROTATE	Bitwise and shift (keyword form — no C-style operator symbols)	A language feature for bitwise rotate right; number following the number of bits to move.
RSHIFT	Bitwise and shift (keyword form — no C-style operator symbols)	A language feature for bitwise shift right; number following the number of bits to shift; the logical form and fills with zero.
SECRET	Reserved-only (claimed, no V1 semantics — using one is an error, E1163)	Reserved for future use.
SELF	Method semantics and instance	A keyword reserved for future use.
SETS_ERRNO	Declaration and module structure	A declarative that attaches to the end of the FOREIGN BIND declaration if that C function also sets ERRNO.
SHARED	Type-system modifiers	A specialization of a class that allows instances of it to become shared mutable references, meaning two handles can modify the same object. Also a modifier on a MUTABLE REFERENCE that allows a second to be created.
SINGLETON	Type-system modifiers	A declarative on a class limiting that class to one instance.
SNAPSHOT	Error handling and STATUS narrowing	A language mechanism for showing what variables are in scope at the given point, along with their type and their value.
STACKTRACE	Error handling and STATUS narrowing	A language mechanism for showing vertically what methods were called from the top, down the stack, to arrive at the given point.
STEP	Control flow	The optional clause of a counted FOR range that sets the increment between iterations, as in FOR i = 0 TO 10 STEP 2.
STRUCT	Declaration and module structure	A declared structure composed of constant and variable data fields. It cannot have methods, nor participate in object-oriented protocols of inheritance or interface implementation.
SUCCESS	Error handling and STATUS narrowing	A language mechanism part of the STATUS field.
SUPER	Method semantics and instance	A language mechanism for a subclass to explicitly access data fields and methods of its parent.
SYNCHRONIZED	Concurrency	A specialized label for a block so that only one thread at a time is able to execute that block.
TEMPLATE	Declaration and module structure	A declaration that the following class will be generic and bound by template qualifier.
TEMPORARY	Reserved-only (claimed, no V1 semantics — using one is an error, E1163)	Reserved for future use.
THEN	Control flow	A language mechanism for the block used when the IF expression evaluates to true.
THROW	Reserved-only (claimed, no V1 semantics — using one is an error, E1163)	Reserved for compiler error catching reminding the dev to use PANIC.
TO	Control flow	The clause of a counted FOR that names an inclusive upper bound. FOR i = 1 TO 6 runs six times and ends with i == 6, where FOR i = 1 UNTIL 6 runs five times and stops before its bound.
TRUE	Logical and boolean literals	A boolean value.
TRY	Error handling and STATUS narrowing	A declarative given to a code block warning the compiler that the following block could raise a PANIC.
TYPE	Declaration and module structure	The single-parameter form of a template qualifier, naming one generic element and the constraints it must satisfy — TEMPLATE: GIVEN TYPE T IS Cloneable, PRIMITIVE:.
TYPES	Declaration and module structure	The multi-parameter form of a template qualifier, naming several generic elements whose constraint groups are then separated by semicolons — TEMPLATE: GIVEN TYPES V, H; V IS Cloneable; H IS Hashable:.
UNION	Declaration and module structure	A grouping of multiple types for which an assigned value could only be one of those types, primary example is the 'number' primitive.
UNREACHABLE	Reserved-only (claimed, no V1 semantics — using one is an error, E1163)	Reserved for compiler error catching reminding the dev to use UNREACHABLE!
UNREACHABLE!	Error handling and STATUS narrowing	An unconditional, always-on marker for a branch that cannot be reached — the exhaustive-MATCH default, a not-yet-implemented stub, a dead arm. The message is optional, and the analyzer treats it as a control-flow terminator, so it satisfies definite-return and exhaustiveness in a branch that cannot produce a value.
UNSAFE	Declaration and module structure	A declarative at the start of a {...} block, inside which a FOREIGN_TYPE handle — a raw C pointer the compiler cannot vouch for — may be reached through to read or write a field. It is a narrow permission rather than a suspension of checking: everything else is checked as usual, and only that one otherwise-rejected access (E3036) becomes legal. Provides additional functionality to opaque types.
UNTIL	Control flow	A language mechanism associated with FOR and DO that precedes a conditioanl expression: if true with the FOR, enter the following block; if true with the DO, repeat the prevous block. Used like "FOR index=0 UNTIL length {...}" or "DO { ... } UNTIL (<expression>)".
VALID	Error handling and STATUS narrowing	A language mechanism usually acting as a guard on a reference or shared mutual reference to test if the object pointed to is valid.
VALUE	Type-system modifiers	A modifier on a class declaration that gives it value identity and inline storage instead of a heap handle, so it is passed and copied as a whole value — VALUE CLASS Money { ... }. It still carries methods, generics and interface conformance, but it is an inheritance leaf: it may implement an interface but it may neither extend nor be extended.
VOID	Method semantics and instance	A language mechanism for stating that a method will return nothing when it finishes.
VOLATILE	Type-system modifiers	Reserved for future use.
WHEN	Control flow	A language mechanism for evaluating an expression related to class identity, like if a given class extends a parent or implements an interface. Used like "WHEN x IS <classname> {...}"
WHILE	Control flow	A language mechanism to evaluate a given expression, and if true to continue into the following block, and if false to skip the following block. When the block ends, return to the WHILE line to re-evaluate the expression again.
WITH	Control flow	The first half of WITH INDEX, the mandatory clause of LOOP. Both halves are required — a LOOP without WITH INDEX is a compile error, and WITH INDEX on any other loop keyword is one too.
XOR	Logical and boolean literals	A language feature for evaluating a boolean exclusive-OR expression.