The task-oriented overview below groups every builtin once. The table under All builtins is exhaustive and character-code sorted; each Name link in the main table opens a dedicated reference page. See printStack for the notation used in stack dumps.

The Stack effect column uses a compact notation: (a b -- c d). The left side lists consumed inputs from lower stack position to top, the right side lists produced outputs in the same order, and an empty side means none. In callable stack effects, inputs... and outputs... denote sequences of zero or more stack objects; their number and schemas depend on the selected callable.

Some builtin names are historical.

The Description column summarizes semantics and notable special cases. Dedicated builtin pages give the full behavior, constraints, and examples.

Task-oriented overview

All builtins

Name Stack effect Description
! (source ordinal structTarget --) Writes one selected item by zero-based ordinal, with the source object and ordinal before the Struct target. For selection, structTarget is dereferenced; source keeps its form.
& (prefix suffix -- text) Concatenates two known Text objects.
* (multiplicand multiplier -- product) Multiplies two numeric objects.
+ (left right -- sum) Adds two numeric objects.
- (minuend subtrahend -- difference) Subtracts the second numeric operand from the first.
/ (dividend divisor -- quotient) Divides numeric objects within the same schema; Whole division stays whole, while Real schemas use floating division.
< (leftValue rightValue -- isLess) Tests whether the left operand is less than the right operand for supported same-schema numbers or known Text.
= (leftValue rightValue -- isEqual) Tests dereferenced value equality for same-schema Cond and numeric objects. For known Text operands, it compares UTF-8 contents. Ref inputs are dereferenced before comparison.
> (leftValue rightValue -- isGreater) Tests whether the left operand is greater than the right operand for supported same-schema numbers or known Text.
@ (ordinal structValue -- selectedItem) Reads one selected item by zero-based ordinal, with the ordinal before the Struct object. Callable items are read, not called.
DEBUG (-- debugCondition) Pushes a known Cond that reports whether debug mode is enabled.
FALSE (-- falseCondition) Pushes the false condition object.
LF (-- lineFeed) Pushes a line-feed Text constant.
TRUE (-- trueCondition) Pushes the true condition object.
^ (base exponent -- power) Raises one Real object to another of the same schema and keeps that real schema in the result.
addressToReference (address modelValue -- reconstructedValue) Builds a typed result from a known or unknown Natx storage address (non-NIL when supplied through a Ref) and a model object. Ref-like model objects keep their schema, direct non-Meta, non-Ref-like model objects produce a Ref to the model schema, and addresses known at compile time to be zero produce the corresponding known nil result. Meta models are invalid.
alignment (schema -- alignment) Known Natx alignment requirement of the dereferenced schema; current contents do not participate.
and (leftOperand rightOperand -- combinedValue) Combines two Cond or Whole objects with bitwise or logical AND semantics.
array (item itemCount -- array) Creates a repeated-item List when count is positive; count 0 yields the empty Tuple ().
attribute (attribute --) Stores a pending LLVM attribute for the next known Text; duplicate or unused attributes are errors. It attaches to the LLVM constant of the next known Text created in the current scope.
call (inputs... callable -- outputs...) Calls an already-selected callable through a call boundary. The callable may be a Block, Code, callable Dict, or known Text; surrounding stack objects pass through the call boundary as the callable’s inputs and outputs.
callField (inputs... dict name -- outputs...) Selects a known-name Dict field. Callable fields are called; non-callable fields are read. Selection follows .NAME-style field handling.
cast (object schema -- convertedValue) Casts a Cond or numeric object to the numeric schema selected by the schema input.
ceil (object -- ceilingValue) Rounds a Real object upward and keeps the same real schema.
code? (schema -- isBlock) Despite its name, tests whether the schema is Block, not Code; codeRef? is the Code test.
codeRef (inputsSchema output options -- code) Constructs a Code schema from an input descriptor, an output descriptor, and an options descriptor, then pushes a known NIL Code object of that schema.
codeRef? (schema -- isCode) Tests whether the schema is Code; value usability and NIL status do not participate.
const (object -- immutableView) Current stack-object immutable-view conversion; only Ref inputs change view, while Code, Text, and Meta are returned unchanged. In-place inputs are invalid.
cos (angle -- cosine) Computes the cosine of a Real object and keeps the same real schema.
def (object name --) Creates a named local or field using a known Text name.
dynamic (object -- dynamicValue) Current stack-object forgotten-contents conversion; keeps the same schema and general object kind while erasing current value knowledge where applicable.
exportFunction (inputsSchema output options callable name --) Exports a named function built from a Block and a signature, and creates an immediately usable Code name in the current module.
failCompilation (--) Aborts compilation immediately.
fieldCount (schema -- itemCount) Counts every item in a Struct, including duplicate, unnamed, static, and Meta items. Valid ordinals run from 0 through itemCount - 1.
fieldIndex (schema itemName -- ordinal) Returns the last matching Struct item ordinal; a non-empty List or Tuple accepts only the empty name, while no name is valid for an empty List or Tuple.
fieldIsPrivate (schema ordinal -- isPrivate) Selected-item visibility predicate; tests whether the item is a Dict field created with private. The mark is part of the schema; List and Tuple items always report FALSE.
fieldIsRef (schema ordinal -- isRefLike) Selected-item schema predicate; tests whether the item schema is Ref, Code, or Text. Current field contents, knownness, and NIL status do not participate, so read results can differ for In-place items.
fieldIsVirtual (schema ordinal -- hasNoStorage) Schema predicate for the selected item; tests whether it has no runtime field storage, including virtual and Meta items.
fieldName (schema ordinal -- itemName) Ordinal-to-name lookup on a Struct schema; repeated names remain repeated, and unnamed items are reported as the empty Text "".
fieldRead (structValue ordinal -- selectedItem) Data-input ordinal selection and read, with the Struct object before the ordinal. Callable items are read, not called.
fieldWrite (source structTarget ordinal --) Data-input ordinal selection and write, with the source object and Struct target before the ordinal. For selection, structTarget is dereferenced; source keeps its form.
floor (object -- floorValue) Rounds a Real object downward and keeps the same real schema.
getCallTrace (-- callTrace) Returns an immutable Ref to the current top call-trace item, or NIL when unavailable.
has (schema itemName -- hasName) Tests known-name presence without choosing an ordinal. For Dict, any matching field is enough and "" also matches unnamed items; a non-empty List/Tuple matches only "", while an empty one matches no name.
if (inputs... condition trueCallable falseCallable -- outputs...) Selects between two already-selected Block branches by Cond. Unknown conditions require both branches to use the same input stack, and their resulting outputs must have matching counts and compatible schemas.
importFunction (inputsSchema output options name --) Declares or imports a named function with the supplied signature and binds it in the current scope as a usable Code local. Repeating the same signature still creates another current-scope name.
importVariable (schema name --) Creates an unknown local for external storage of the requested non-Meta schema. The schema input may be an object or Ref.
is (leftValue rightValue -- isIdentityLike) Tests identity-like equality for Ref, Text, and Code objects of the same dereferenced schema; same-schema In-place objects still give FALSE.
isCombined (schema -- isCombined) Tests whether the dereferenced schema is any Struct. That is Dict, List, or Tuple, including (); zero item count does not matter.
isConst (object -- isConst) Current stack-object immutability predicate; tests the current stack object itself, and const or unconst change its result only for Ref inputs.
isDirty (object -- isDirty) Current stack-object instability predicate; exact opposite of stable?. For an In-place object, forgotten contents alone do not make it unstable; forgetting Text contents destabilizes Text.
isDynamic (object -- isDynamic) Current stable-and-unknown predicate; same predicate as unknownStable?, and Text, Code, and Meta objects still report FALSE.
isRef (object -- object isRefLike) Reports whether the current object's schema is Ref-like: Ref, Code, or Text.
isStatic (object -- isKnown) Historical name for the current stack-object knownness predicate; knownness follows known non-NIL Ref targets, same as known?.
known? (object -- isKnown) Preferred name for the current stack-object knownness predicate; knownness follows known non-NIL Ref targets, same as isStatic.
log (argument -- naturalLogarithm) Computes the natural logarithm of a Real object and keeps the same real schema.
log10 (argument -- decimalLogarithm) Computes the base-10 logarithm of a Real object and keeps the same real schema.
loop (inputs... callable -- outputs...) Repeatedly calls one already-selected Block through a call boundary. The run-time repetition invariant is (A -- A Cond): each body call preserves the carried stack’s shape — the number of objects and their schemas — not necessarily their values, and leaves a final Cond; known-condition iterations may add items or change schemas.
lshift (object shiftCount -- shiftedValue) Performs a bitwise left shift on a Whole object and keeps the same schema.
managed? (schema -- isManaged) Tests whether the dereferenced schema has managed lifetime behavior; this is a schema property, not a current-value state or stability test.
manuallyDestroyVariable (object --) Designated-storage destruction without freeing the storage address.
manuallyInitVariable (object --) Designated-storage initialization in existing storage without allocating the storage address.
mod (dividend divisor -- remainder) Computes the remainder of numeric division; signed Int, unsigned Nat, and Real objects each follow their own remainder semantics.
neg (object -- negatedValue) Negates a signed Int or Real object and keeps the same schema.
new (object -- newValue) Fresh-object creation from the current stack object. Block and unmanaged Meta inputs create a new object of the same schema; managed Meta inputs are invalid. Ref inputs use current referenced contents, so immutable Ref views copy, mutable Ref views move, and known NIL Ref objects are invalid. In-place inputs are invalid.
newVarOfTheSameType (schema -- newValue) Fresh-object creation from only the dereferenced input schema. Current contents, access path, and NIL status do not participate, so known NIL Ref inputs can still be valid.
or (leftOperand rightOperand -- combinedValue) Combines two Cond or Whole objects with bitwise or logical OR semantics.
overload (--) Creates a pending overload specifier. It marks the next name created by NAME: ...;, def, exportFunction, or importFunction, and is invalid for importVariable. When followed by use, it instead marks every directly imported name as an overload and is cleared when use completes, including an import of no names.
printCompilerMessage (message --) Prints a known Text message during compilation and appends one line-feed character.
printStack (--) Prints the current data stack in canonical formatter form; it does not itself pop stack objects.
printStackTrace (--) Prints the current scope stack as file path, line, column, and node source text information.
private (--) Creates a pending visibility specifier for the next successful name creation. It applies to NAME: ...;, def, exportFunction, importFunction, and importVariable. A private module-level name is not imported by use; a private Dict field is hidden from source-text member selection through .NAME, .@NAME, or .!NAME outside the Dict, and privacy is part of the schema. Ordinal access and callField can still reach the field.
raiseStaticError (message --) Raises a compile-time error with the given known Text message.
rshift (object shiftCount -- shiftedValue) Performs a bitwise right shift on a Whole object and keeps the same schema.
same (leftSchema rightSchema -- isSameSchema) Tests whether two dereferenced schemas are identical; matching schemaName text does not imply equality.
schemaName (schema -- reportedName) Returns the default formatted name of the dereferenced schema, unless a Dict schema overrides it with a static Text field named SCHEMA_NAME. Matching reported names still do not imply same.
set (source destination --) Already-selected destination replacement after dereferencing both inputs. No selection happens inside the builtin, and a Ref destination rewrites the referenced object itself rather than a stored Ref value.
sin (angle -- sine) Computes the sine of a Real object and keeps the same real schema.
sqrt (radicand -- squareRoot) Computes the square root of a Real object and keeps the same real schema.
stable? (object -- isStable) Current stack-object stability predicate; exact opposite of isDirty. For an In-place object, forgotten contents alone do not make it unstable; forgetting Text contents destabilizes Text.
static (--) Reserved builtin name. It consumes nothing, produces nothing, and has no effect, not even on a pending declaration specifier. The modifier that marks the next local as static is virtual.
storageAddress (object -- address) Current stack-object storage-address query; known NIL Ref, Text, and Code objects yield 0nx. For a known non-NIL Ref, taking the address destabilizes the referenced target, even through an immutable view.
storageSize (schema -- size) Known Natx storage size of the dereferenced schema; current contents do not participate.
textSize (text -- size) Returns the UTF-8 code-unit (byte) count of a Text object as known or unknown Natx; known NIL text is invalid.
textSplit (text -- characterList) Splits known Text by decoded UTF-8 characters into one-character Text items. Empty text yields the empty Tuple ().
ucall (inputs... callable -- outputs...) Processes an already-selected Block or known Text inline in the current scope.
uif (inputs... condition trueCallable falseCallable -- outputs...) Selects between two already-selected Block branches by a known Cond and processes the selected branch inline. No branch-output merge occurs.
unconst (object -- mutableView) Current stack-object mutable-view conversion; only Ref inputs change view, while Code, Text, and Meta are returned unchanged. In-place inputs are invalid.
unknownStable? (object -- isUnknownStable) Same current stable-and-unknown predicate as isDynamic.
use (moduleDescriptor --) Loads a module by known Text and imports its public names or one selected public name. A selected-name descriptor splits at the last dot after the last path separator.
virtual (--) Creates a pending static specifier for the next successful local creation through NAME: ...; or def. It is invalid for exportFunction, importFunction, and importVariable; virtual is the historical name for this declaration modifier.
virtual? (schema -- isMeta) Despite its name, it does not test whether a local or field was declared with virtual; it tests whether the schema is Meta.
xor (leftOperand rightOperand -- combinedValue) Combines two Cond or Whole objects with logical exclusive-OR or bitwise XOR semantics.
~ (object -- invertedValue) Performs logical NOT for Cond or bitwise complement for a Whole object.

Examples

These calls show the overview's stack-effect notation in use: (left right -- sum), (schema -- itemCount), and (text -- size).

Stack effects in use

{} () {} [
  2 3 + printStack _:;
  (1 2 3) fieldCount printStack _:;
  "MPL" textSize printStack _:;
] "main" exportFunction

Expected Output During Compilation

5
3
3nx