Glint

Source that reads like Trident

Glint takes Trident's grammar wherever both languages have the construct: type-first const bindings, brace blocks, # comments and ingot records. A module has exactly one entry, and its name is its stage: vertex, fragment or compute. The entry's parameters and result derive the stage interface, so no slot number is written twice.

Operators, resource member calls and builtins express the work. @ multiplies a matrix by a vector, albedo.sample(uv) samples a texture, and smoothstep, fwidth, clamp and select are builtins. A name that is a type spelling, such as color, refuses as a binding name.

ingot ValveVaryings { vec4 clip, vec4 world }
uniform<mat4,slot=0> clipFromWorld
uniform<mat4,slot=1> worldFromObject

ValveVaryings vertex(vec3 position) {
    const vec3 p = position
    const vec4 p4 = vec4(p.x, p.y, p.z, 1.0)
    const vec4 world = worldFromObject @ p4
    const vec4 clip = clipFromWorld @ world
    return { clip = clip, world = world }
}

uniform<vec4,slot=0> tint
texture2d<value=vec4,slot=0> albedo

vec4 fragment(vec2 uv) {
    const vec4 sampled = albedo.sample(uv)
    const vec4 tintValue = tint
    const vec4 graded = sampled * tintValue
    return graded
}

Resources and slots

Every resource is declared with its type, its element type and an explicit slot. Uniforms carry per-draw values such as a tint or a matrix. Textures are read through member calls. Storage buffers and storage images carry the arrays a compute module reads and writes.

Thalassa owns the memory behind every slot; the module only names it. Access words state intent, and the checker holds a module to them. A store into a readOnly buffer refuses with the line and the repair.

• uniform<vec4,slot=0> tint: one value for the whole draw or dispatch.
• texture2d<value=vec4,slot=0> albedo: a sampled 2D texture; textureCube is a cube map.
• storage<u32[],slot=1> counts: an array a compute module reads and writes; readOnly forbids the write.
• image2d<rgba8Unorm,slot=0> heatmap: a storage image; readWrite admits loads as well as stores.

uniform<vec4,slot=0> tint
uniform<mat4,slot=4> toClip
texture2d<value=vec4,slot=0> albedo
textureCube<vec4,1> sky

vec4 fragment(vec2 uv, vec3 normal) {
    const vec4 base = albedo.sample(uv)
    const vec4 ambient = sky.sample(normal)
    const vec4 tintValue = tint
    return base * ambient * tintValue
}

readOnly storage<f32[],slot=0> depths
storage<u32[],slot=1> counts
image2d<rgba8Unorm,slot=0> heatmap
readWrite image2d<r32Uint,slot=1> hits
uniform<f32,slot=0> limit

void compute(uvec3 globalId) workgroup (64, 1, 1) {
    const u32 i = globalId.x
    const f32 depth = depths[i]
    const f32 ceiling = limit
    counts[i] = u32(depth > ceiling)
}

Checked operations

Every operation has one defined answer, and the checker fixes every type before a device sees the module. Integer add, subtract and multiply wrap modulo 2^32. Integer division by zero yields zero, and a shift count uses its low five bits.

Float edges are defined as well. Normalizing a zero-length vector yields the zero vector, asin and acos clamp their argument into range, and round ties to even. The transcendental functions come from Keel kernels and are correctly rounded in binary32.

Each lowering writes these rules into its own output, so integer division and zero-length vectors mean the same thing on every backend. A module states its numeric relation in its first line. numerics reference; is exact and is the default; numerics bounded; with an accuracy row admits a stated bound.

numerics reference;
readOnly storage<f32[],slot=0> heights
storage<f32[],slot=1> slopes
uniform<f32,slot=0> spacing

void compute(uvec3 globalId) workgroup (64, 1, 1) {
    const u32 i = globalId.x
    const f32 here = heights[i]
    const f32 next = heights[i + 1]
    const f32 gap = spacing
    slopes[i] = (next - here) / gap
}

readOnly storage<f32[],slot=0> heights
storage<f32[],slot=1> slopes

void compute(uvec3 globalId) workgroup (64, 1, 1) {
    const u32 i = globalId.x
    heights[i] = 0.0
}
# refused at line 6: a `readOnly` buffer takes no store:
# remove `readOnly` or the store

From one module to every backend

Thalassa parses the source once into Glint IR, checks it, and names the checked module by the SHA-256 digest of its canonical image. The renderer joins modules by digest and stage, never by name or label. Local names enter no digest.

The Soft renderer executes the checked IR on the CPU, and four lowerings write the same IR for the GPU backends. Each backend's output is compared with the Soft renderer's under a tolerance declared before the run.

Thalassa owns resources and submission

A Glint module computes and does nothing else. It has no file, network, process, clock or random-source access, and it cannot allocate GPU memory or hold a device handle. Thalassa allocates every buffer and texture, records and submits the work, and reads results back.

A Trident program reaches Glint only through declared rows. A scene names a module by digest and stage, and Reef binds it by slot to resources Reef owns. A compute call takes typed data in and returns typed data out, with no callback and no shader text.

• A shader cannot read a file, open a socket or start a process, so a module copied from elsewhere carries no host authority.
• A script never names a GPU resource, so a buffer is freed when a later scene omits it.
• A module the Soft renderer cannot run refuses at compile, so every module has a CPU answer to compare against.

Related references