Two ways to
write a shader.
One is going away.

01 The two shapes

Same shader, two source shapes

Here is the instanced-points vertex shader written both ways. It reads a particle position from a storage buffer indexed by the instance, expands a quad, and colors by height. Read the two side by side — the logic is identical; only the boundary differs.

const u = @extern(*addrspace(.uniform) const Uniforms, .{
    .name = "u",
    .decoration = .{ .descriptor = .{
        .set = 0, .binding = 0 } },
});
const positions = storageBuffer(Vec2,
    "positions", 0, 1);
const col_out = @extern(*addrspace(.output) Vec, .{
    .name = "col", .decoration = .{ .location = 0 },
});

export fn entry() callconv(.spirv_vertex) void {
    const vi: u32 = spirv.vertex_index;
    const ii: u32 = spirv.instance_index;
    const p = ssboLoad(Vec2, positions, ii);
    const uu = u.*;
    // ... quad expand, color ...
    spirv.position_out.* = .{ x, y, 0, 1 };
    col_out.* = color;
}

// points_vs_io.zig — the schema
pub const Ubo = extern struct { /* … */ };
pub const Storage = struct {
    positions: shader.StorageBuf(Vec2, .read),
};
pub const Builtins = struct {
    vertex_index:   shader.Builtin(.vertex_index),
    instance_index: shader.Builtin(.instance_index),
};
pub const Outputs = common.Interp;

// points_vs.zig — the body
pub fn shaderMain(io_in: Io) Out {
    var out: Out = undefined;
    const vi = io_in.vertex_index();
    const ii = io_in.instance_index();
    const p = io_in.positions(ii);
    const uu = io_in.u;
    // ... quad expand, color ...
    out.position = .{ x, y, 0, 1 };
    out.col = color;
    return out;
}

02 The signature move

The schema field is the binding

In the IoT world you never write a @group(N) @binding(M). You declare a field in a schema section, and the codegen derives the WGSL decoration from which section it's in and its position. Uniforms land at binding 0; storage buffers follow in the same group; samplers get their own group. Here is the actual derivation for the points shader:

03 Two more wins

Sampling, and the varying contract

Beyond bindings, the typed boundary changes two everyday things: how you sample a texture, and how a vertex shader's outputs stay matched to a fragment shader's inputs.

// declare the sampler by hand…
extern const decal_sampler2d: u32
    addrspace(.constant);
// …bind it by hand at the top of main…
binding(&decal_sampler2d, 2, 0);
// …then call the raw op:
const t = zsample2d(decal_sampler2d, uv);

// declare it once, named, in the schema:
pub const Samplers = struct {
    texture0: shader.Sampler2D(.albedo, .{}),
};
// call it as a method — no binding, no raw op:
const tex = io_in.texture0(io_in.frag_tex_coord);

The varyings between stages are the other quiet hazard. In the direct pattern the VS @extern(.output) list and the FS @extern(.input) list are written separately and must match by location index. In IoT they alias one shared struct, so they match by construction:

// points_common_io.zig — declared ONCE
pub const Interp = struct { col: Vec };

// points_vs_io.zig             points_fs_io.zig
pub const Outputs = common.Interp;   pub const Inputs = common.Interp;
// VS output === FS input. They cannot drift; renaming a field
// breaks both stages at compile time until you fix it.

04 Honest accounting

What it costs, what it buys

IoT is not free — it adds schema files. But it removes the per-binding @extern blocks from the body and the host-side bind-group code. On line count it's close to a wash; the real dividend is type-safety. Measured on real shaders:

The schema tax is real. The bug surface it removes is realer.

05 The decision

Which pattern, when

The goal is one pattern. The interface now expresses everything — storage buffers, builtins, samplers — so the direct pattern is no longer a capability, only a habit. Until the last shaders are ported, here's the rule: