builtin

Signature

func print(value: T) -> Unit

Rendering must fit the machine string bound. Logs are a bounded ring buffer: when full, the oldest retained line is discarded, and no external I/O occurs.

Signature

func noop() -> Res[Unit, DataError]

It is a concrete function value, so it can be stored in Button.action without a string callback name or a host effect.

Signature

func ignore_number(value: Number) -> Res[Unit, DataError]

It is a concrete function value for Slider.action. The Number is checked then discarded, with no scene or host state update.

Signature

func bytes(values: List[u8]) -> Bin

Each element is a u8, so out-of-range literal bytes are compile errors. The Bin owns shared immutable storage and has no text encoding until decoded explicitly.

Signature

Number

Number remains a source alias for f64 and this host representation remains compatible with native spatial interfaces. Literals without numeric context default to f64. Exact integer widths and f16/f32/f128 use Scalar instead. Numeric variables never implicitly change dtype; use .convert[T]() for an explicit conversion, which rejects overflow and loss of information.

Signature

Bool

Bool stores a Rust bool and has exactly two values: true and false. if and while require Bool; numeric zero and empty collections do not act as false. and and or evaluate their right side only when needed.

Signature

Str

Clones share an Arc allocation. Concatenation creates a new value without implicit conversion. len, indexing, and slices count Unicode scalar values, while allocation limits count UTF-8 bytes. utf8 encodes to Bin and decode validates Bin as UTF-8. Text is the separate visible scene component.

Signature

String = Str

Clones share an Arc allocation. Concatenation creates a new value without implicit conversion. len, indexing, and slices count Unicode scalar values, while allocation limits count UTF-8 bytes. utf8 encodes to Bin and decode validates Bin as UTF-8. Text is the separate visible scene component.

Signature

Bin

Cloning shares a packed Arc allocation. bytes constructs Bin from List[u8], Str.utf8 encodes text, and Bin.decode validates UTF-8 with a Res result. Indexing returns Res[u8, DataError]; slicing produces Res[Bin, DataError]. Concatenation creates independent data and respects byte limits.

Signature

Unit

Unit is represented by the payload-free Rust Value::Unit variant and spelled () in the language. A function returning Unit may end without a value or use ret;. Unit is not null, an absent field, or an optional value.

Signature

time: Number

time advances with accepted simulation ticks, not wall-clock time or browser rendering. The embedding host chooses the fixed cadence. Failed ticks do not publish new time; this immutable binding is unavailable at module scope.

Signature

tick: Number

tick is an immutable Number supplied by the runtime. It counts accepted simulation updates; browser animation frames and rejected updates do not increment it. It is available only inside init, frame and done callbacks.

Signature

i8

Integer arithmetic checks overflow; floating-point arithmetic rounds each operation at its declared precision and rejects nonfinite results. Mixed representations require explicit conversion, which rejects loss of range or precision. Values serialize as decimal strings so JSON hosts retain the exact value.

Signature

i16

Integer arithmetic checks overflow; floating-point arithmetic rounds each operation at its declared precision and rejects nonfinite results. Mixed representations require explicit conversion, which rejects loss of range or precision. Values serialize as decimal strings so JSON hosts retain the exact value.

Signature

i32

Integer arithmetic checks overflow; floating-point arithmetic rounds each operation at its declared precision and rejects nonfinite results. Mixed representations require explicit conversion, which rejects loss of range or precision. Values serialize as decimal strings so JSON hosts retain the exact value.

Signature

i64

Integer arithmetic checks overflow; floating-point arithmetic rounds each operation at its declared precision and rejects nonfinite results. Mixed representations require explicit conversion, which rejects loss of range or precision. Values serialize as decimal strings so JSON hosts retain the exact value.

Signature

i128

Integer arithmetic checks overflow; floating-point arithmetic rounds each operation at its declared precision and rejects nonfinite results. Mixed representations require explicit conversion, which rejects loss of range or precision. Values serialize as decimal strings so JSON hosts retain the exact value.

Signature

u8

Integer arithmetic checks overflow; floating-point arithmetic rounds each operation at its declared precision and rejects nonfinite results. Mixed representations require explicit conversion, which rejects loss of range or precision. Values serialize as decimal strings so JSON hosts retain the exact value.

Signature

u16

Integer arithmetic checks overflow; floating-point arithmetic rounds each operation at its declared precision and rejects nonfinite results. Mixed representations require explicit conversion, which rejects loss of range or precision. Values serialize as decimal strings so JSON hosts retain the exact value.

Signature

u32

Integer arithmetic checks overflow; floating-point arithmetic rounds each operation at its declared precision and rejects nonfinite results. Mixed representations require explicit conversion, which rejects loss of range or precision. Values serialize as decimal strings so JSON hosts retain the exact value.

Signature

u64

Integer arithmetic checks overflow; floating-point arithmetic rounds each operation at its declared precision and rejects nonfinite results. Mixed representations require explicit conversion, which rejects loss of range or precision. Values serialize as decimal strings so JSON hosts retain the exact value.

Signature

u128

Integer arithmetic checks overflow; floating-point arithmetic rounds each operation at its declared precision and rejects nonfinite results. Mixed representations require explicit conversion, which rejects loss of range or precision. Values serialize as decimal strings so JSON hosts retain the exact value.

Signature

f16

Integer arithmetic checks overflow; floating-point arithmetic rounds each operation at its declared precision and rejects nonfinite results. Mixed representations require explicit conversion, which rejects loss of range or precision. Values serialize as decimal strings so JSON hosts retain the exact value.

Signature

f32

Integer arithmetic checks overflow; floating-point arithmetic rounds each operation at its declared precision and rejects nonfinite results. Mixed representations require explicit conversion, which rejects loss of range or precision. Values serialize as decimal strings so JSON hosts retain the exact value.

Signature

f64

Integer arithmetic checks overflow; floating-point arithmetic rounds each operation at its declared precision and rejects nonfinite results. Mixed representations require explicit conversion, which rejects loss of range or precision. Values serialize as decimal strings so JSON hosts retain the exact value.

Signature

f128

Integer arithmetic checks overflow; floating-point arithmetic rounds each operation at its declared precision and rejects nonfinite results. Mixed representations require explicit conversion, which rejects loss of range or precision. Values serialize as decimal strings so JSON hosts retain the exact value.

Signature

enum Opt[T] { Some(T), None }

Match both Some and None before using an optional result.

Signature

enum Res[T, E] { Ok(T), Err(E) }

Use ? to propagate Err to a compatible Res-returning boundary, or match both cases locally.

Signature

enum DataError { ... }

Each case name and description comes from the Rust SDK data-error registry.

Signature

func range(end: Number) -> Res[List[Number], DataError]
func range(start: Number, end: Number) -> Res[List[Number], DataError]

Each bound must be finite, integral, and exactly representable from -9007199254740991 through 9007199254740991. End is exclusive; descending bounds produce an empty list. Invalid endpoints return DataError; a host resource limit remains a Diagnostic.

Signature

func tensor[T](values: List[T], dimensions: List[Number]) -> Res[Tensor[T], DataError]

T is a numeric dtype. Values are row-major and their count must equal the checked product of the dimensions. Invalid shapes return Err(DataError). Host byte and execution limits reject execution before allocation.

Signature

Tensor[T]

A tensor stores one numeric dtype and a runtime shape. Comma-separated indices select scalar elements; slices preserve tensors and share their allocation. Arithmetic broadcasts trailing dimensions; @ multiplies matrices and batches. Arithmetic and indexing return Res; get returns Opt for a scalar lookup. Dtypes must match, with contextual typing reserved for literal operands.

Signature

List[T]

List[T] stores Rust Vec<Value> data. The compiler retains T and the runtime checks elements at typed boundaries. An empty literal needs a contextual element type, such as let values: List[f64] = [];.

Indexing starts at zero and rejects out-of-range indices. Assignment copies a list value; .append(value) returns a new list. .get(index) returns Opt[T], while indexing returns Res[T, DataError]. Collection length and nested values remain subject to the embedding host's Limits.

Signature

type Vec3 {
  x: Number = 0;
  y: Number = 0;
  z: Number = 0;
}

Spatial consumers interpret components as meters, directions, or radians based on their containing field; Vec3 itself carries no unit.

Signature

type Transform {
  position: Vec3 = Vec3 {};
  rotation: Vec3 = Vec3 {};
  scale: Vec3 = Vec3 { x: 1, y: 1, z: 1 };
}

Position is meters, rotation is XYZ Euler radians, and scale defaults to one on every axis. Physics owns the position and rotation of dynamic bodies.

Signature

pi: Number

pi is a finite binary64 approximation. Angles passed to sin and cos are radians; one full turn is 2 * pi. The name is available in ordinary expressions.

Signature

func spawn(component: C) -> Entity

The C placeholder means one concrete type value, never a trait or primitive. Entity creation is bounded and rejected when the machine has no remaining entity capacity.

Signature

func add(entity: Entity, component: C) -> Unit

C means a concrete type value. Adding a component that the entity already owns, or addressing a missing entity, rejects the current transaction.

Signature

func get[C](entity: Entity) -> C

C means a concrete type selector. The result is a component copy; update the live entity with set, or use a system binding or bind[C](entity) method callback for persistent mutation.