Types

Scalar


`bool`	Boolean, values `true` and `false`.
`i32`	32-bit signed integer.
`u32`	32-bit unsigned integer.
`f32`	32-bit floating point of IEEE-754 binary32 (single precision) format.
`f16`	16-bit floating point of IEEE-754 binary16 (half precision) format.

Type inference for literals

var a = 1i;    // holds an i32
var b = 1u;    // holds an u32
var c = 1f;    // holds an f32
var d = 1;     // holds an i32
var e = 1.0;   // holds an f32
var f = true;  // holds a bool

All type conversions must be done explicitly.

var a = 1i;
var b = f32(a);

Vector

A vector is a grouped sequence of 2, 3, or 4 scalar components. vecN<T> denotes a vector of N components of type T. N must be in {2, 3, 4} and T must be one of the scalar types. T is the component type of the vector.

var a: vec3<f32> = vec3<f32>(1.0, 2.2, 3.1);

Matrix

A matrix is a grouped sequence of 2, 3, or 4 floating point vectors. matCxR<T> denotes a matrix of C columns and R rows of type T, where C and R are both in {2, 3, 4}, and T must be a scalar floating point type. Equivalently, it can be viewed as C column vectors of type vecR<T>.

mat2x3<f32>  // This is a 2 column, 3 row matrix of 32-bit floats.
             // Equivalently, it is 2 column vectors of type vec3<f32>.

Atomic

An atomic type encapsulates a concrete integer scalar type. atomic<T> denotes an atomic of type T. T must be either u32 or i32.

Atomic objects provide certain guarantees to concurrent observers. The only valid operations on atomic objects are the atomic builtin functions.

// TODO: Examples

Struct

A structure is a named grouping of named member values. Two members of the same structure type must not have the same name. A structure member type can be a scalar, vector, matrix, atomic type, or an array or structure type with a creation-fixed footprint. The last member may also be a runtime-sized array.

struct Data {
  a: i32,
  b: vec2<f32>,
  c: array<i32,10>, // last comma is optional
}

// Declare a variable storing a value of type Data.
var<private> some_data: Data;

Array

An array is an indexable grouping of element values. array<E,N> denotes a fixed-size array with N elements of type E. N is called the element count of the array. array<E> denotes a runtime-sized array of elements of type E. These may only appear in specific contexts.

The element type E can be a scalar, vector, matrix, atomic type, or an array or structure type with a creation-fixed footprint.

// a and b are different types
var<private> a: array<f32,8>;
var<private> b: array<i32,8>;

// fixed-size array sized by a constant
const width = 8;
var<private> d: array<i32,width>;

// workgroup array sized by an overridable constant
override blockSize = 16;
var<workgroup> odds: array<i32,blockSize>;

Language

Functions