# Globals

The following global constants and functions are present alongside the standard library's classes.

# Constants

  • const NaN: auto // f32 or f64
    

    Not a number as a 32-bit or 64-bit float depending on context. Compiles to a constant.

  • const Infinity: auto // f32 or f64
    

    Positive infinity as a 32-bit or 64-bit float depending on context. Compiles to a constant.

# Functions

  • function isNaN<T>(value: T): bool
    

    Tests if a 32-bit or 64-bit float is NaN.

  • function isFinite<T>(value: T): bool
    

    Tests if a 32-bit or 64-bit float is finite, that is not NaN or +/-Infinity.

  • function parseInt(str: string, radix?: i32): f64
    

    Parses a string representing an integer to an f64 number Returns NaN on invalid inputs.

    Type-specific variants of parseInt are available separately:

    • F32.parseInt to parse to a 32-bit float.
    • I8.parseInt to parse to a signed 8-bit integer, respectively U8.parseInt if unsigned.
    • I16.parseInt to parse to a signed 16-bit integer, respectively U16.parseInt if unsigned.
    • I32.parseInt to parse to a signed 32-bit integer, respectively U32.parseInt if unsigned.
    • I64.parseInt to parse to a signed 64-bit integer, respectively U64.parseInt if unsigned.
  • function parseFloat(str: string): f64
    

    Parses a string to a 64-bit float. Returns NaN on invalid inputs.

# Builtins

The following builtins provide direct access to WebAssembly and compiler features. They form the low-level foundation of the standard library, while also being available for everyone to utilize where directly tapping into WebAssembly or the compiler is desired.

# Static type checks

By making use of the following special type checks, especially in generic contexts, untaken branches can be eliminated statically, leading to concrete WebAssembly functions that handle one type specificially.

  • function isInteger<T>(value?: T): bool
    

    Tests if the specified type or expression is of an integer type and not a reference. Compiles to a constant.

  • function isSigned<T>(value?: T): bool
    

    Tests if the specified type or expression can represent negative numbers. Compiles to a constant.

  • function isFloat<T>(value?: T): bool
    

    Tests if the specified type or expression is of a float type. Compiles to a constant.

  • function isVector<T>(value?: T): bool
    

    Tests if the specified type or expression is of a SIMD vector type. Compiles to a constant.

  • function isReference<T>(value?: T): bool
    

    Tests if the specified type or expression is of a reference type. Compiles to a constant.

  • function isString<T>(value?: T): bool
    

    Tests if the specified type or expression can be used as a string. Compiles to a constant.

  • function isArray<T>(value?: T): bool
    

    Tests if the specified type or expression can be used as an array. Compiles to a constant.

  • function isFunction<T>(value?: T): bool
    

    Tests if the specified type or expression is of a function type. Compiles to a constant.

  • function isNullable<T>(value?: T): bool
    

    Tests if the specified type or expression is of a nullable reference type. Compiles to a constant.

  • function isDefined(expression: auto): bool
    

    Tests if the specified expression resolves to a defined element. Compiles to a constant.

  • function isConstant(expression: auto): bool
    

    Tests if the specified expression evaluates to a constant value. Compiles to a constant.

  • function isManaged<T>(expression: auto): bool
    

    Tests if the specified type or expression is of a managed type. Compiles to a constant. Usually only relevant when implementing custom collection-like classes.

# Example of static type checking

function add<T>(a: T, b: T): T {
  return a + b // addition if numeric, string concatenation if a string
}

function add<T>(a: T, b: T): T {
  if (isString<T>()) { // eliminated if T is not a string
    return parseInt(a) + parseInt(b)
  } else { // eliminated if T is a string
    return a + b
  }
}

TIP

If you are not going to use low-level WebAssembly in the foreseeable future, feel free to come back to the following paragraphs at a later time.

# Utilities

  • function bswap<T>(value: T): T
    

    Reverses the byte order of the specified integer.

  • function sizeof<T>(): usize
    

    Determines the byte size of the respective basic type. Means: If T is a class type, the size of usize, the pointer type, is returned. To obtain the size of a class in memory, use offsetof<T>() instead. Compiles to a constant.

  • function offsetof<T>(fieldName?: string): usize
    

    Determines the offset of the specified field within the given class type. If fieldName is omitted, this returns what could be interpreted as either the size of the class, or the offset where the next field would be located, before alignment. Compiles to a constant. The fieldName argument must be a compile-time constant string because there is no information about field names anymore at runtime. Therefore, the field's name must be known at the time the returned constant is computed.

  • function alignof<T>(): usize
    

    Determines the alignment (log2) of the specified underlying basic type; i.e. If T is a class type, the alignment of usize is returned. Compiles to a constant.

  • function assert<T>(isTrueish: T, message?: string): T
    

    Traps if the specified value is not true-ish, otherwise returns the non-nullable value. Like assertions in C, aborting the entire program if the expectation fails. Where desired, the --noAssert compiler option can be used to disable assertions in production.

  • function trace(message: string, n?: i32, a0?: f64, a1?: f64, a2?: f64, a3?: f64, a4?: f64): void
    

    Simple trace function which prints message and 5 optional f64 arguments to a console. n is count of used arguments.

    # Usage examples

    trace("foo");
    trace("one arg:", 1, 5.0);
    trace("three args:", 3, 1.0, <f64>2, 3);
    
  • function instantiate<T>(...args: auto[]): T
    

    Instantiates a new instance of T using the specified constructor arguments.

  • function changetype<T>(value: auto): T
    

    Changes the type of a value to another one. Useful for casting class instances to their pointer values and vice-versa.

  • function idof<T>(): u32
    

    Obtains the computed unique id of a class type. Usually only relevant when allocating objects or dealing with RTTI externally.

  • function nameof<T>(value?: T): string
    

    Returns the name of a given type.

# WebAssembly

# Math

The following generic built-ins compile to WebAssembly instructions directly.

  • function clz<T>(value: T): T
    
    Performs the sign-agnostic count leading zero bits operation on a 32-bit or 64-bit integer. All zero bits are considered leading if the value is zero.
    T Instruction
    i8, u8, i16, u16, i32, u32, bool i32.clz
    i64, u64 i64.clz
  • function ctz<T>(value: T): T
    
    Performs the sign-agnostic count tailing zero bits operation on a 32-bit or 64-bit integer. All zero bits are considered trailing if the value is zero.
    T Instruction
    i8, u8, i16, u16, i32, u32, bool i32.ctz
    i64, u64 i64.ctz
  • function popcnt<T>(value: T): T
    
    Performs the sign-agnostic count number of one bits operation on a 32-bit or 64-bit integer.
    T Instruction
    i8, u8, i16, u16, i32, u32 i32.popcnt
    i64, u64 i64.popcnt
    bool none
  • function rotl<T>(value: T, shift: T): T
    
    Performs the sign-agnostic rotate left operation on a 32-bit or 64-bit integer.
    T Instruction
    i32, u32 i32.rotl
    i64, u64 i64.rotl
    i8, u8, i16, u16 emulated
    bool none
  • function rotr<T>(value: T, shift: T): T
    
    Performs the sign-agnostic rotate right operation on a 32-bit or 64-bit integer.
    T Instruction
    i32, u32 i32.rotr
    i64, u64 i64.rotr
    i8, u8, i16, u16 emulated
    bool none
  • function abs<T>(value: T): T
    
    Computes the absolute value of an integer or float.
    T Instruction
    f32 f32.abs
    f64 f64.abs
    i8, i16, i32, i64 emulated
    u8, u16, u32, u64, bool none
  • function max<T>(left: T, right: T): T
    
    Determines the maximum of two integers or floats. If either operand is NaN, returns NaN.
    T Instruction
    f32 f32.max
    f64 f64.max
    i8, u8, i16, u16, i32, u32, i64, u64, bool emulated
  • function min<T>(left: T, right: T): T
    
    Determines the minimum of two integers or floats. If either operand is NaN, returns NaN.
    T Instruction
    f32 f32.min
    f64 f64.min
    i8, u8, i16, u16, i32, u32, i64, u64, bool emulated
  • function ceil<T>(value: T): T
    
    Performs the ceiling operation on a 32-bit or 64-bit float.
    T Instruction
    f32 f32.ceil
    f64 f64.ceil
    i8, u8, i16, u16, i32, u32, i64, u64, bool none
  • function floor<T>(value: T): T
    
    Performs the floor operation on a 32-bit or 64-bit float.
    T Instruction
    f32 f32.floor
    f64 f64.floor
    i8, u8, i16, u16, i32, u32, i64, u64, bool none
  • function copysign<T>(x: T , y: T): T
    
    Composes a 32-bit or 64-bit float from the magnitude of x and the sign of y.
    T Instruction
    f32 f32.copysign
    f64 f64.copysign
  • function nearest<T>(value: T): T
    
    Rounds to the nearest integer half to even of a 32-bit or 64-bit float.
    T Instruction
    f32 f32.nearest
    f64 f64.nearest
    i8, u8, i16, u16, i32, u32, i64, u64, bool none
  • function reinterpret<TTo>(value: auto): TTo
    
    Reinterprets the bits of the specified value as type T.
    TTo Instruction
    i32, u32 i32.reinterpret_f32
    i64, u64 i64.reinterpret_f64
    f32 f32.reinterpret_i32
    f64 f64.reinterpret_i64
  • function sqrt<T>(value: T): T
    
    Calculates the square root of a 32-bit or 64-bit float.
    T Instruction
    f32 f32.sqrt
    f64 f64.sqrt
  • function trunc<T>(value: T): T
    
    Rounds to the nearest integer towards zero of a 32-bit or 64-bit float.
    T Instruction
    f32 f32.trunc
    f64 f64.trunc
    i8, u8, i16, u16, i32, u32, i64, u64, bool none

# Memory

Similarly, the following built-ins emit WebAssembly instructions accessing or otherwise modifying memory.

NOTE

The immOffset and immAlign arguments, if provided, must be compile time constant values. See more details in rationale (opens new window).

  • function load<T>(ptr: usize, immOffset?: usize, immAlign?: usize): T
    
    Loads a value of the specified type from memory. Equivalent to dereferencing a pointer in other languages.
    T Instruction If contextual type is i64
    i8 i32.load8_s i64.load8_s
    u8 i32.load8_u i64.load8_u
    i16 i32.load16_s i64.load16_s
    u16 i32.load16_u i64.load16_u
    i32 i32.load i64.load32_s
    u32 i32.load i64.load32_u
    i64, u64 i64.load n/a
    f32 f32.load n/a
    f64 f64.load n/a
    <ref> i32/i64.load n/a
  • function store<T>(ptr: usize, value: auto, immOffset?: usize, immAlign?: usize): void
    
    Stores a value of the specified type to memory. Equivalent to dereferencing a pointer in other languages and assigning a value.
    T Instruction If value is i64
    i8, u8 i32.store8 i64.store8
    i16, u16 i32.store16 i64.store16
    i32, u32 i32.store i64.store32
    i64, u64 i64.store n/a
    f32 f32.store n/a
    f64 f64.store n/a
    <ref> i32/i64.store n/a
  • function memory.size(): i32
    

    Returns the current size of the memory in units of pages. One page is 64kb.

  • function memory.grow(value: i32): i32
    

    Grows linear memory by a given unsigned delta of pages. One page is 64kb. Returns the previous size of the memory in units of pages or -1 on failure.

    WARNING

    Calling memory.grow where a memory manager is present might break it.

  • function memory.copy(dst: usize, src: usize, n: usize): void
    

    Copies n bytes from src to dst . Regions may overlap. Emits the respective instruction if bulk-memory is enabled, otherwise ships a polyfill.

  • function memory.fill(dst: usize, value: u8, n: usize): void
    

    Fills n bytes at dst with the given byte value. Emits the respective instruction if bulk-memory is enabled, otherwise ships a polyfill.

  • function memory.repeat(dst: usize, src: usize, srcLength: usize, count: usize): void
    

    Repeats a sequence of bytes given as src with srcLength count times into destination dst.

  • function memory.compare(lhs: usize, rhs: usize, n: usize): i32
    

    Compares the first n bytes of left and right and returns a value that indicates their relationship:

    • Negative value if the first differing byte in lhs is less than the corresponding byte in rhs.
    • Positive value if the first differing byte in lhs is greater than the corresponding byte in rhs.
    • Zero​ if all n bytes of lhs and rhs are equal.
  • function memory.data(size: i32, align?: i32): usize
    

    Gets a pointer to a zeroed static chunk of memory of the given size. Alignment defaults to 16. Arguments must be compile-time constants.

  • function memory.data<T>(values: T[], align?: i32): usize
    

    Gets a pointer to a pre-initialized static chunk of memory. Alignment defaults to the size of T. Arguments must be compile-time constants.

# Control flow

  • function select<T>(ifTrue: T, ifFalse: T, condition: bool): T
    

    Selects one of two pre-evaluated values depending on the condition. Differs from an if/else in that both arms are always executed and the final value is picked based on the condition afterwards. Performs better than an if/else only if the condition is random (means: branch prediction is not going to perform well) and both alternatives are cheap. It is also worth to note that Binaryen will do relevant optimizations like switching to a select automatically, so simply using a ternary ? : may be preferable.

  • function unreachable(): auto
    

    Emits an unreachable instruction that results in a runtime error (trap) when executed. Both a statement and an expression of any type. Beware that trapping in managed code will most likely lead to memory leaks or even break the program because it ends execution prematurely.

# Atomics 🦄

The following instructions represent the WebAssembly threads and atomics (opens new window) specification. Must be enabled with --enable threads.

  • function atomic.load<T>(ptr: usize, immOffset?: usize): T
    

    Atomically loads an integer value from memory and returns it.

  • function atomic.store<T>(ptr: usize, value: auto, immOffset?: usize): void
    

    Atomically stores an integer value to memory.

  • function atomic.add<T>(ptr: usize, value: T, immOffset?: usize): T
    

    Atomically adds an integer value in memory.

  • function atomic.sub<T>(ptr: usize, value: T, immOffset?: usize): T
    

    Atomically subtracts an integer value in memory.

  • function atomic.and<T>(ptr: usize, value: T, immOffset?: usize): T
    

    Atomically performs a bitwise AND operation on an integer value in memory.

  • function atomic.or<T>(ptr: usize, value: T, immOffset?: usize): T
    

    Atomically performs a bitwise OR operation on an integer value in memory.

  • function atomic.xor<T>(ptr: usize, value: T, immOffset?: usize): T
    

    Atomically performs a bitwise XOR operation on an integer value in memory.

  • function atomic.xchg<T>(ptr: usize, value: T, immOffset?: usize): T
    

    Atomically exchanges an integer value in memory.

  • function atomic.cmpxchg<T>(ptr: usize, expected: T, replacement: T, immOffset?: usize): T
    

    Atomically compares and exchanges an integer value in memory if the condition is met.

  • function atomic.wait<T>(ptr: usize, expected: T, timeout: i64): AtomicWaitResult
    

    Performs a wait operation on an address in memory, suspending this agent if the integer condition is met. Return values are

    Value Description
    0 OK - Woken by another agent.
    1 NOT_EQUAL - Loaded value did not match the expected value.
    2 TIMED_OUT - Not woken before the timeout expired.
  • function atomic.notify(ptr: usize, count: i32): i32
    

    Performs a notify operation on an address in memory waking up suspended agents.

  • function atomic.fence(): void
    

    Performs a fence operation, preserving synchronization guarantees of higher level languages.

# SIMD 🦄

Likewise, these represent the WebAssembly SIMD (opens new window) specification. Must be enabled with --enable simd.

  • function v128(a: i8, ... , p: i8): v128
    

    Initializes a 128-bit vector from sixteen 8-bit integer values. Arguments must be compile-time constants.

    See Constructing constant vectors for additional type-specific options.

  • function v128.splat<T>(x: T): v128
    
    Creates a vector with identical lanes.
    T Instruction
    i8, u8 i8x16.splat
    i16, u16 i16x8.splat
    i32, u32 i32x4.splat
    i64, u64 i64x2.splat
    f32 f32x4.splat
    f64 f64x2.splat
  • function v128.extract_lane<T>(x: v128, idx: u8): T
    
    Extracts one lane as a scalar.
    T Instruction
    i8 i8x16.extract_lane_s
    u8 i8x16.extract_lane_u
    i16 i16x8.extract_lane_s
    u16 i16x8.extract_lane_u
    i32, u32 i32x4.extract_lane
    i64, u64 i64x2.extract_lane
    f32 f32x4.extract_lane
    f64 f64x2.extract_lane
  • function v128.replace_lane<T>(x: v128, idx: u8, value: T): v128
    
    Replaces one lane.
    T Instruction
    i8, u8 i8x16.replace_lane
    i16, u16 i16x8.replace_lane
    i32, u32 i32x4.replace_lane
    i64, u64 i64x2.replace_lane
    f32 f32x4.replace_lane
    f64 f64x2.replace_lane
  • function v128.shuffle<T>(a: v128, b: v128, ...lanes: u8[]): v128
    
    Selects lanes from either vector according to the specified lane indexes.
    T Instruction
    i8, u8 i8x16.shuffle
    i16, u16 i8x16.shuffle emulating i16x8.shuffle
    i32, u32 i8x16.shuffle emulating i32x4.shuffle
    i64, u64 i8x16.shuffle emulating i64x2.shuffle
    f32 i8x16.shuffle emulating f32x4.shuffle
    f64 i8x16.shuffle emulating f64x2.shuffle
  • function v128.swizzle(a: v128, s: v128): v128
    

    Selects 8-bit lanes from the first vector according to the indexes [0-15] specified by the 8-bit lanes of the second vector.

  • function v128.load(ptr: usize, immOffset?: usize, immAlign?: usize): v128
    

    Loads a vector from memory.

  • function v128.load_ext<TFrom>(ptr: usize, immOffset?: usize, immAlign?: usize): v128
    
    Creates a vector by loading the lanes of the specified integer type and extending each to the next larger type.
    TFrom Instruction
    i8 v128.load8x8_s
    u8 v128.load8x8_u
    i16 v128.load16x4_s
    u16 v128.load16x4_u
    i32 v128.load32x2_s
    u32 v128.load32x2_u
  • function v128.load_zero<TFrom>(ptr: usize, immOffset?: usize, immAlign?: usize): v128
    
    Creates a vector by loading a value of the specified type into the lowest bits and initializing all other bits of the vector to zero.
    TFrom Instruction
    i32, u32, f32 v128.load32_zero
    i64, u64, f64 v128.load64_zero
  • function v128.load_lane<T>(
      ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize
    ): v128
    
    Loads a single lane from memory into the specified lane of the given vector. Other lanes are bypassed as is.
    T Instruction
    i8, u8 v128.load8_lane
    i16, u16 v128.load16_lane
    i32, u32, f32 v128.load32_lane
    i64, u64, f64 v128.load64_lane
  • function v128.store_lane<T>(
      ptr: usize, vec: v128, idx: u8, immOffset?: usize, immAlign?: usize
    ): v128
    
    Stores the single lane at the specified index of the given vector to memory.
    T Instruction
    i8, u8 v128.store8_lane
    i16, u16 v128.store16_lane
    i32, u32, f32 v128.store32_lane
    i64, u64, f64 v128.store64_lane
  • function v128.load_splat<T>(ptr: usize, immOffset?: usize, immAlign?: usize): v128
    
    Creates a vector with identical lanes by loading the splatted value.
    T Instruction
    i8, u8 v128.load8_splat
    i16, u16 v128.load16_splat
    i32, u32, f32 v128.load32_splat
    i64, u64, f64 v128.load64_splat
  • function v128.store(ptr: usize, value: v128, immOffset?: usize, immAlign?: usize): void
    

    Stores a vector to memory.

  • function v128.add<T>(a: v128, b: v128): v128
    
    Adds each lane.
    T Instruction
    i8, u8 i8x16.add
    i16, u16 i16x8.add
    i32, u32 i32x4.add
    i64, u64 i64x2.add
    f32 f32x4.add
    f64 f64x2.add
  • function v128.sub<T>(a: v128, b: v128): v128
    
    Subtracts each lane.
    T Instruction
    i8, u8 i8x16.sub
    i16, u16 i16x8.sub
    i32, u32 i32x4.sub
    i64, u64 i64x2.sub
    f32 f32x4.sub
    f64 f64x2.sub
  • function v128.mul<T>(a: v128, b: v128): v128
    
    Multiplies each lane.
    T Instruction
    i16, u16 i16x8.mul
    i32, u32 i32x4.mul
    i64, u64 i64x2.mul
    f32 f32x4.mul
    f64 f64x2.mul
  • function v128.div<T>(a: v128, b: v128): v128
    
    Divides each floating point lane.
    T Instruction
    f32 f32x4.div
    f64 f64x2.div
  • function v128.neg<T>(a: v128): v128
    
    Negates each lane.
    T Instruction
    i8, u8 i8x16.neg
    i16, u16 i16x8.neg
    i32, u32 i32x4.neg
    i64, u64 i64x2.neg
    f32 f32x4.neg
    f64 f64x2.neg
  • function v128.add_sat<T>(a: v128, b: v128): v128
    
    Adds each signed small integer lane using saturation.
    T Instruction
    i8 i8x16.add_sat_s
    u8 i8x16.add_sat_u
    i16 i16x8.add_sat_s
    u16 i16x8.add_sat_u
  • function v128.sub_sat<T>(a: v128, b: v128): v128
    
    Subtracts each signed small integer lane using saturation.
    T Instruction
    i8 i8x16.sub_sat_s
    u8 i8x16.sub_sat_u
    i16 i16x8.sub_sat_s
    u16 i16x8.sub_sat_u
  • function v128.shl<T>(a: v128, b: i32): v128
    
    Performs a bitwise left shift by a scalar on each integer lane.
    T Instruction
    i8, u8 i8x16.shl
    i16, u16 i16x8.shl
    i32, u32 i32x4.shl
    i64, u64 i64x2.shl
  • function v128.shr<T>(a: v128, b: i32): v128
    
    Performs a bitwise right shift by a scalar on each integer lane.
    T Instruction
    i8 i8x16.shr_s
    u8 i8x16.shr_u
    i16 i16x8.shr_s
    u16 i16x8.shr_u
    i32 i32x4.shr_s
    u32 i32x4.shr_u
    i64 i64x2.shr_s
    u64 i64x2.shr_u
  • function v128.and(a: v128, b: v128): v128
    

    Performs the bitwise a & b operation on each lane.

  • function v128.or(a: v128, b: v128): v128
    

    Performs the bitwise a | b operation on each lane.

  • function v128.xor(a: v128, b: v128): v128
    

    Performs the bitwise a ^ b operation on each lane.

  • function v128.andnot(a: v128, b: v128): v128
    

    Performs the bitwise !a & b operation on each lane.

  • function v128.not(a: v128): v128
    

    Performs the bitwise !a operation on each lane.

  • function v128.bitselect(v1: v128, v2: v128, mask: v128): v128
    

    Selects bits of either vector according to the specified mask. Selects from v1 if the bit in mask is 1, otherwise from v2.

  • function v128.any_true(a: v128): bool
    

    Reduces a vector to a scalar indicating whether any lane is considered true.

  • function v128.all_true<T>(a: v128): bool
    
    Reduces a vector to a scalar indicating whether all lanes are considered true.
    T Instruction
    i8, u8 i8x16.all_true
    i16, u16 i16x8.all_true
    i32, u32 i32x4.all_true
    i64, u64 i64x2.all_true
  • function v128.bitmask<T>(a: v128): bool
    
    Extracts the high bit of each integer lane (except 64-bit) and produces a scalar mask with all bits concatenated.
    T Instruction
    i8, u8 i8x16.bitmask
    i16, u16 i16x8.bitmask
    i32, u32 i32x4.bitmask
    i64, u64 i64x2.bitmask
  • function v128.popcnt<T>(a: v128): v128
    
    Counts the number of bits set to one within each lane.
    T Instruction
    i8, u8 i8x16.popcnt
  • function v128.min<T>(a: v128, b: v128): v128
    
    Computes the minimum of each lane.
    T Instruction
    i8 i8x16.min_s
    u8 i8x16.min_u
    i16 i16x8.min_s
    u16 i16x8.min_u
    i32 i32x4.min_s
    u32 i32x4.min_u
    f32 f32x4.min
    f64 f64x2.min
  • function v128.max<T>(a: v128, b: v128): v128
    
    Computes the maximum of each lane.
    T Instruction
    i8 i8x16.max_s
    u8 i8x16.max_u
    i16 i16x8.max_s
    u16 i16x8.max_u
    i32 i32x4.max_s
    u32 i32x4.max_u
    f32 f32x4.max
    f64 f64x2.max
  • function v128.pmin<T>(a: v128, b: v128): v128
    
    Computes the psuedo-minimum of each lane.
    T Instruction
    f32 f32x4.pmin
    f64 f64x2.pmin
  • function v128.pmax<T>(a: v128, b: v128): v128
    
    Computes the pseudo-maximum of each lane.
    T Instruction
    f32 f32x4.pmax
    f64 f64x2.pmax
  • function v128.dot<T>(a: v128, b: v128): v128
    
    Computes the dot product of two 16-bit integer lanes each, yielding lanes one size wider than the input.
    T Instruction
    i16 i32x4.dot_i16x8_s
  • function v128.avgr<T>(a: v128, b: v128): v128)
    
    Computes the rounding average of each unsigned small integer lane.
    T Instruction
    u8 i8x16.avgr_u
    u16 i16x8.avgr_u
  • function v128.abs<T>(a: v128): v128
    
    Computes the absolute value of each lane (except 64-bit integers).
    T Instruction
    i8, u8 i8x16.abs
    i16, u16 i16x8.abs
    i32, u32 i32x4.abs
    i64, u64 i64x2.abs
    f32 f32x4.abs
    f64 f64x2.abs
  • function v128.sqrt<T>(a: v128): v128
    
    Computes the square root of each floating point lane.
    T Instruction
    f32 f32x4.sqrt
    f64 f64x2.sqrt
  • function v128.ceil<T>(a: v128): v128
    
    Performs the ceiling operation on each lane.
    T Instruction
    f32 f32x4.ceil
    f64 f64x2.ceil
  • function v128.floor<T>(a: v128): v128
    
    Performs the floor operation on each lane.
    T Instruction
    f32 f32x4.floor
    f64 f64x2.floor
  • function v128.trunc<T>(a: v128): v128
    
    Rounds to the nearest integer towards zero of each lane.
    T Instruction
    f32 f32x4.trunc
    f64 f64x2.trunc
  • function v128.nearest<T>(a: v128): v128
    
    Rounds to the nearest integer half to even of each lane.
    T Instruction
    f32 f32x4.nearest
    f64 f64x2.nearest
  • function v128.eq<T>(a: v128, b: v128): v128
    
    Computes which lanes are equal.
    T Instruction
    i8, u8 i8x16.eq
    i16, u16 i16x8.eq
    i32, u32 i32x4.eq
    i64, u64 i64x2.eq
    f32 f32x4.eq
    f64 f64x2.eq
  • function v128.ne<T>(a: v128, b: v128): v128
    
    Computes which lanes are not equal.
    T Instruction
    i8, u8 i8x16.ne
    i16, u16 i16x8.ne
    i32, u32 i32x4.ne
    i64, u64 i64x2.ne
    f32 f32x4.ne
    f64 f64x2.ne
  • function v128.lt<T>(a: v128, b: v128): v128
    
    Computes which lanes of the first vector are less than those of the second.
    T Instruction
    i8 i8x16.lt_s
    u8 i8x16.lt_u
    i16 i16x8.lt_s
    u16 i16x8.lt_u
    i32 i32x4.lt_s
    u32 i32x4.lt_u
    i64 i64x2.lt_s
    f32 f32x4.lt
    f64 f64x2.lt
  • function v128.le<T>(a: v128, b: v128): v128
    
    Computes which lanes of the first vector are less than or equal those of the second.
    T Instruction
    i8 i8x16.le_s
    u8 i8x16.le_u
    i16 i16x8.le_s
    u16 i16x8.le_u
    i32 i32x4.le_s
    u32 i32x4.le_u
    i64 i64x2.le_s
    f32 f32x4.le
    f64 f64x2.le
  • function v128.gt<T>(a: v128, b: v128): v128
    
    Computes which lanes of the first vector are greater than those of the second.
    T Instruction
    i8 i8x16.gt_s
    u8 i8x16.gt_u
    i16 i16x8.gt_s
    u16 i16x8.gt_u
    i32 i32x4.gt_s
    u32 i32x4.gt_u
    i64 i64x2.gt_s
    f32 f32x4.gt
    f64 f64x2.gt
  • function v128.ge<T>(a: v128, b: v128): v128
    
    Computes which lanes of the first vector are greater than or equal those of the second.
    T Instruction
    i8 i8x16.ge_s
    u8 i8x16.ge_u
    i16 i16x8.ge_s
    u16 i16x8.ge_u
    i32 i32x4.ge_s
    u32 i32x4.ge_u
    i64 i64x2.ge_s
    f32 f32x4.ge
    f64 f64x2.ge
  • function v128.convert<TFrom>(a: v128): v128
    
    Converts each lane of a vector from integer to single-precision floating point.
    TFrom Instruction
    i32 f32x4.convert_i32x4_s
    u32 f32x4.convert_i32x4_u
  • function v128.convert_low<TFrom>(a: v128): v128
    
    Converts the low lanes of a vector from integer to double-precision floating point.
    TFrom Instruction
    i32 f64x2.convert_low_i32x4_s
    u32 f64x2.convert_low_i32x4_u
  • function v128.trunc_sat<TTo>(a: v128): v128
    
    Truncates each lane of a vector from single-precision floating point to integer with saturation. Takes the target type.
    TTo Instruction
    i32 i32x4.trunc_sat_f32x4_s
    u32 i32x4.trunc_sat_f32x4_u
  • function v128.trunc_sat_zero<TTo>(a: v128): v128
    
    Truncates each lane of a vector from double-precision floating point to integer with saturation. Takes the target type.
    TTo Instruction
    i32 i32x4.trunc_sat_f64x2_s_zero
    u32 i32x4.trunc_sat_f64x2_u_zero
  • function v128.narrow<TFrom>(a: v128, b: v128): v128
    
    Narrows wider integer lanes to their respective narrower lanes.
    TFrom Instruction
    i16 i8x16.narrow_i16x8_s
    u16 i8x16.narrow_i16x8_u
    i32 i16x8.narrow_i32x4_s
    u32 i16x8.narrow_i32x4_u
  • function v128.extend_low<TFrom>(a: v128): v128
    
    Extends the low half of narrower integer lanes to their respective wider lanes.
    TFrom Instruction
    i8 i16x8.extend_low_i8x16_s
    u8 i16x8.extend_low_i8x16_u
    i16 i32x4.extend_low_i16x8_s
    u16 i32x4.extend_low_i16x8_u
    i32 i64x2.extend_low_i32x4_s
    u32 i64x2.extend_low_i32x4_u
  • function v128.extend_high<TFrom>(a: v128): v128
    
    Extends the high half of narrower integer lanes to their respective wider lanes.
    TFrom Instruction
    i8 i16x8.extend_high_i8x16_s
    u8 i16x8.extend_high_i8x16_u
    i16 i32x4.extend_high_i16x8_s
    u16 i32x4.extend_high_i16x8_u
    i32 i64x2.extend_high_i32x4_s
    u32 i64x2.extend_high_i32x4_u
  • function v128.extadd_pairwise<TFrom>(a: v128): v128
    
    Adds lanes pairwise producing twice wider extended results.
    TFrom Instruction
    i16 i16x8.extadd_pairwise_i8x16_s
    u16 i16x8.extadd_pairwise_i8x16_u
    i32 i32x4.extadd_pairwise_i16x8_s
    u32 i32x4.extadd_pairwise_i16x8_u
  • function v128.demote_zero<T>(a: v128): v128
    
    Demotes each float lane to lower precision. The higher lanes of the result are initialized to zero.
    T Instruction
    f64 f32x4.demote_f64x2_zero
  • function v128.promote_low<T>(a: v128): v128
    
    Promotes the lower float lanes to higher precision.
    T Instruction
    f32 f64x2.promote_low_f32x4
  • function v128.q15mulr_sat<T>(a: v128, b: v128): v128
    
    Performs the line-wise saturating rounding multiplication in Q15 format ((a[i] * b[i] + (1 << (Q - 1))) >> Q where Q=15).
    T Instruction
    i16 i16x8.q15mulr_sat_s
  • function v128.extmul_low<T>(a: v128, b: v128): v128
    
    Performs the lane-wise integer extended multiplication of the lower lanes producing a twice wider result than the inputs.
    T Instruction
    i8 i16x8.extmul_low_i8x16_s
    u8 i16x8.extmul_low_i8x16_u
    i16 i32x4.extmul_low_i16x8_s
    u16 i32x4.extmul_low_i16x8_u
    i32 i64x2.extmul_low_i32x4_s
    u32 i64x2.extmul_low_i32x4_u
  • function v128.extmul_high<T>(a: v128, b: v128): v128
    
    Performs the lane-wise integer extended multiplication of the higher lanes producing a twice wider result than the inputs.
    T Instruction
    i8 i16x8.extmul_high_i8x16_s
    u8 i16x8.extmul_high_i8x16_u
    i16 i32x4.extmul_high_i16x8_s
    u16 i32x4.extmul_high_i16x8_u
    i32 i64x2.extmul_high_i32x4_s
    u32 i64x2.extmul_high_i32x4_u

# Constructing constant vectors

  • function i8x16(a: i8, ... , p: i8): v128
    

    Initializes a 128-bit vector from sixteen 8-bit integer values.

  • function i16x8(a: i16, ..., h: i16): v128
    

    Initializes a 128-bit vector from eight 16-bit integer values.

  • function i32x4(a: i32, b: i32, c: i32, d: i32): v128
    

    Initializes a 128-bit vector from four 32-bit integer values.

  • function i64x2(a: i64, b: i64): v128
    

    Initializes a 128-bit vector from two 64-bit integer values.

  • function f32x4(a: f32, b: f32, c: f32, d: f32): v128
    

    Initializes a 128-bit vector from four 32-bit float values.

  • function f64x2(a: f64, b: f64): v128
    

    Initializes a 128-bit vector from two 64-bit float values.

# Relaxed SIMD 🦄

The following instructions represent the WebAssembly Relaxed SIMD (opens new window) specification. Must be enabled with --enable relaxed-simd.

  • function v128.relaxed_swizzle(a: v128, s: v128): v128
    

    Selects 8-bit lanes from a using indices in s. Indices in the range [0-15] select the i-th element of a.

    Unlike v128.swizzle, the result of an out of bounds index is implementation-defined, depending on hardware capabilities: Either 0 or a[s[i]%16].

  • function v128.relaxed_trunc<T>(a: v128): v128
    
    Truncates each lane of a vector from 32-bit floating point to a 32-bit signed or unsigned integer as indicated by T.
    T Instruction
    i32 i32x4.relaxed_trunc_f32x4_s
    u32 i32x4.relaxed_trunc_f32x4_u

    Unlike v128.trunc_sat, the result of lanes out of bounds of the target type is implementation defined, depending on hardware capabilities:

    • If the input lane contains NaN, the result is either 0 or the respective maximum integer value.
    • If the input lane contains a value otherwise out of bounds of the target type, the result is either the saturatated result or maximum integer value.
  • function v128.relaxed_trunc_zero<T>(a: v128): v128
    
    Truncates each lane of a vector from 64-bit floating point to a 32-bit signed or unsigned integer as indicated by T. Unused higher integer lanes of the result are initialized to zero.
    T Instruction
    i32 i32x4.relaxed_trunc_f64x2_s_zero
    u32 i32x4.relaxed_trunc_f64x2_u_zero

    Unlike v128.trunc_sat_zero, the result of lanes out of bounds of the target type is implementation defined, depending on hardware capabilities:

    • If the input lane contains NaN, the result is either 0 or the respective maximum integer value.
    • If the input lane contains a value otherwise out of bounds of the target type, the result is either the saturatated result or maximum integer value.
  • function v128.relaxed_madd<T>(a: v128, b: v128, c: v128): v128
    
    Performs the fused multiply-add operation (a * b + c) on 32- or 64-bit floating point lanes as indicated by T.
    T Instruction
    f32 f32x4.relaxed_madd
    f64 f64x2.relaxed_madd

    The result is implementation defined, depending on hardware capabilities:

    • Either a * b is rounded once and the final result rounded again, or
    • The expression is evaluated with higher precision and only rounded once
  • function v128.relaxed_nmadd<T>(a: v128, b: v128, c: v128): v128
    
    Performs the fused negative multiply-add operation (-(a * b) + c) on 32- or 64-bit floating point lanes as indicated by T.
    T Instruction
    f32 f32x4.relaxed_nmadd
    f64 f64x2.relaxed_nmadd

    The result is implementation defined, depending on hardware capabilities:

    • Either a * b is rounded once and the final result rounded again, or
    • The expression is evaluated with higher precision and only rounded once
  • function v128.relaxed_laneselect<T>(a: v128, b: v128, m: v128): v128
    
    Selects 8-, 16-, 32- or 64-bit integer lanes as indicated by T from a or b based on masks in m.
    T Instruction
    i8, u8 i8x16.relaxed_laneselect
    i16, u16 i16x8.relaxed_laneselect
    i32, u32 i32x4.relaxed_laneselect
    i64, u64 i64x2.relaxed_laneselect

    Behaves like v128.bitselect if masks in m do have all bits either set (result is a[i]) or unset (result is b[i]). Otherwise the result is implementation-defined, depending on hardware capabilities: If the most significant bit of m is set, the result is either bitselect(a[i], b[i], mask) or a[i], otherwise the result is b[i].

  • function v128.relaxed_min<T>(a: v128, b: v128): v128
    
    Computes the minimum of each 32- or 64-bit floating point lane as indicated by T.
    T Instruction
    f32 f32x4.relaxed_min
    f64 f64x2.relaxed_min

    Unlike v128.min, the result is implementation-defined if either value is NaN or both are -0.0 and +0.0, depending on hardware capabilities: Either a[i] or b[i].

  • function v128.relaxed_max<T>(a: v128, b: v128): v128
    
    Computes the maximum of each 32- or 64-bit floating point lane as indicated by T.
    T Instruction
    f32 f32x4.relaxed_max
    f64 f64x2.relaxed_max

    Unlike v128.max, the result is implementation-defined if either value is NaN or both are -0.0 and +0.0, depending on hardware capabilities: Either a[i] or b[i].

  • function v128.relaxed_q15mulr<T>(a: v128, b: v128): v128
    
    Performs the lane-wise rounding multiplication in Q15 format ((a[i] * b[i] + (1 << (Q - 1))) >> Q where Q=15).
    T Instruction
    i16 i16x8.relaxed_q15mulr_s

    Unlike v128.q15mulr_sat, the result is implementation-defined if both inputs are the minimum signed value: Either the minimum or maximum signed value.

  • function v128.relaxed_dot<T>(a: v128, b: v128): v128
    
    Computes the dot product of two 8-bit integer lanes each, yielding lanes one size wider than the input.
    T Instruction
    i16 i16x8.relaxed_dot_i8x16_i7x16_s

    Unlike v128.dot, if the most significant bit of b[i] is set, whether b[i] is interpreted as signed or unsigned by the intermediate multiplication is implementation-defined.

  • function v128.relaxed_dot_add<T>(a: v128, b: v128, c: v128): v128
    
    Computes the dot product of two 8-bit integer lanes each, yielding lanes two sizes wider than the input with the lanes of c accumulated into the result.
    T Instruction
    i32 i32x4.relaxed_dot_i8x16_i7x16_add_s

    Unlike v128.dot, if the most significant bit of b[i] is set, whether b[i] is interpreted as signed or unsigned by the intermediate multiplication is implementation-defined.

# Inline instructions

In addition to using the generic builtins above, most WebAssembly instructions can be written directly in AssemblyScript code. For example, the following is equivalent:

// generic builtin
v128.splat<i32>(42);

// inline instruction
i32x4.splat(42);