Update README and comment for new GpuProcess

Now GpuProcess isnt limited to 2 in, 1 out but to anything.

.gitignore

@@ -1,2 +1,3 @@
 .zig-cache
 zig-out
+examples/mnist

README.md

@@ -1,6 +1,7 @@
 # Minimal Zig WebGPU Compute Library
 
-This is a minimal, self-contained Zig library designed to simplify running compute shaders using WebGPU. It abstracts away much of the boilerplate required for GPU device initialization, memory management, and pipeline execution.
+This is a minimal, self-contained Zig library designed to simplify running compute shaders using WebGPU.
+It abstracts away much of the boilerplate required for GPU device initialization, memory management, and pipeline execution.
 
 ## Core Modules
 
@@ -16,7 +17,6 @@ The library exports five primary components:
 Below is a complete, self-contained example demonstrating how to initialize the GPU, load data, run a compute shader, and read the results back to the CPU:
 
 ```zig
-
 const std = @import("std");
 const gpu = @import("gpu");
 const GpuDevice = gpu.GpuDevice;
@@ -37,7 +37,15 @@ pub fn main(init: std.process.Init) !void {
     const gloc = grena.gpuAllocator();
 
     // 3. Load the WGSL compute pipeline
-    const add_process = try GpuProcess.init(device, @embedFile("shaders/add.wgsl"));
+    const add_process = try GpuProcess.init(
+        device,
+        @embedFile("shaders/add.wgsl"),
+        .{ .bindings = &.{
+            .{ .element_size = @sizeOf(f16) },
+            .{ .element_size = @sizeOf(f16) },
+            .{ .element_size = @sizeOf(f16) },
+        } },
+    );
     defer add_process.deinit();
 
     // 4. Setup CPU data
@@ -53,7 +61,6 @@ pub fn main(init: std.process.Init) !void {
     }
 
     // 5. Initialize raw GPU Buffers
-    // We pass the EnumSet inline using `.initMany` since the Enum itself isn't exported
     const byte_size = len * @sizeOf(f16);
     const buf_a = try GpuBuffer.init(gloc, byte_size, .initMany(&.{ .Storage, .CopyDst, .CopySrc }));
     const buf_b = try GpuBuffer.init(gloc, byte_size, .initMany(&.{ .Storage, .CopyDst, .CopySrc }));
@@ -67,8 +74,7 @@ pub fn main(init: std.process.Init) !void {
     try buf_b.load(f16, data_b);
 
     // 7. Dispatch the Compute Process
-    // We pass the data type (f16) to allow GpuProcess to calculate chunks correctly
-    try add_process.run(gloc, f16, buf_a, buf_b, buf_out);
+    try add_process.run(gloc, .{ buf_a, buf_b, buf_out });
 
     // 8. Map and copy the resulting buffer back to the CPU
     const out = try buf_out.read(allocator, f16);
@@ -76,8 +82,61 @@ pub fn main(init: std.process.Init) !void {
 
     std.debug.print("Result: {any}\n", .{out});
 }
+
 ```
 
 ## Dependencies
 
 * **`wgpu.h`**: The library relies on the WebGPU C API headers to bind to the native system graphics.
+
+## System Requirements
+
+Because this library binds to native system graphics APIs via `wgpu-native`,
+you must ensure the appropriate development headers and libraries are available on your system before compiling.
+
+### Linux (Vulkan)
+You need the Vulkan development headers to compile the project, and a Vulkan-compatible driver to run it. 
+
+Depending on your distribution, install the following packages:
+* **Ubuntu / Debian:**
+  ```bash
+  sudo apt update
+  sudo apt install libvulkan-dev mesa-vulkan-drivers
+  ```
+* **Fedora / RHEL:**
+  ```bash
+  sudo dnf install vulkan-devel mesa-vulkan-drivers
+  ```
+* **Arch Linux:**
+  ```bash
+  sudo pacman -S vulkan-headers vulkan-icd-loader
+  ```
+
+### macOS (Metal)
+No extra installation is required.
+The build script automatically links against the standard Apple frameworks provided by the Xcode Command Line Tools
+(`Metal`, `QuartzCore`, `Foundation`, `CoreGraphics`).
+
+### Windows (DirectX 12)
+No extra installation is required.
+The build script automatically links against the standard Windows SDK libraries (`d3d12`, `dxgi`, `user32`).
+Ensure you have the MSVC build tools installed.
+
+---
+
+## Adding to your project
+
+To use this module in your own Zig project, add it to your `build.zig.zon`:
+```bash
+zig fetch --save git+https://git.bouvais.lu/adrien/zig-wgpu
+```
+
+Then, in your `build.zig`, import and add the module to your executable:
+```zig
+const zig_wgpu = b.dependency("zig-wgpu", .{
+    .target = target,
+    .optimize = optimize,
+});
+
+exe.root_module.addImport("gpu", zig_wgpu.module("zig-wgpu"));
+```

build.zig

@@ -4,7 +4,6 @@ pub fn build(b: *std.Build) !void {
     const target = b.standardTargetOptions(.{});
     const optimize = b.standardOptimizeOption(.{});
 
-    // Define the module so other projects can import it
     const mod = b.addModule("zig-wgpu", .{
         .root_source_file = b.path("src/lib.zig"),
         .target = target,

examples/add.zig

@@ -18,7 +18,15 @@ pub fn main(init: std.process.Init) !void {
     const gloc = grena.gpuAllocator();
 
     // 3. Load the WGSL compute pipeline
-    const add_process = try GpuProcess.init(device, @embedFile("shaders/add.wgsl"));
+    const add_process = try GpuProcess.init(
+        device,
+        @embedFile("shaders/add.wgsl"),
+        .{ .bindings = &.{
+            .{ .element_size = @sizeOf(f16) },
+            .{ .element_size = @sizeOf(f16) },
+            .{ .element_size = @sizeOf(f16) },
+        } },
+    );
     defer add_process.deinit();
 
     // 4. Setup CPU data
@@ -34,7 +42,6 @@ pub fn main(init: std.process.Init) !void {
     }
 
     // 5. Initialize raw GPU Buffers
-    // We pass the EnumSet inline using `.initMany` since the Enum itself isn't exported
     const byte_size = len * @sizeOf(f16);
     const buf_a = try GpuBuffer.init(gloc, byte_size, .initMany(&.{ .Storage, .CopyDst, .CopySrc }));
     const buf_b = try GpuBuffer.init(gloc, byte_size, .initMany(&.{ .Storage, .CopyDst, .CopySrc }));
@@ -48,8 +55,7 @@ pub fn main(init: std.process.Init) !void {
     try buf_b.load(f16, data_b);
 
     // 7. Dispatch the Compute Process
-    // We pass the data type (f16) to allow GpuProcess to calculate chunks correctly
-    try add_process.run(gloc, f16, buf_a, buf_b, buf_out);
+    try add_process.run(gloc, .{ buf_a, buf_b, buf_out });
 
     // 8. Map and copy the resulting buffer back to the CPU
     const out = try buf_out.read(allocator, f16);

examples/digit.zig

@@ -0,0 +1,77 @@
+// I am using this mnist reduced dataset https://www.kaggle.com/datasets/mohamedgamal07/reduced-mnist
+
+const std = @import("std");
+const gpu = @import("gpu");
+const GpuDevice = gpu.GpuDevice;
+const GpuArena = gpu.GpuArena;
+const GpuBuffer = gpu.GpuBuffer;
+const GpuProcess = gpu.GpuProcess;
+
+const BATCHSIZE = 10;
+const EPOCH = 10;
+
+pub fn main(init: std.process.Init) !void {
+    const allocator = init.gpa;
+    const io = init.io;
+
+    // 1. Open GPU Device
+    const device = try GpuDevice.init(.{});
+    defer device.deinit();
+
+    // 2. Create a GPU Arena to manage VRAM
+    var grena = GpuArena.init(allocator, device);
+    defer grena.deinit();
+    const gloc = grena.gpuAllocator();
+
+    // 3. Load the WGSL compute pipeline
+    const add_process = try GpuProcess.init(device, @embedFile("shaders/add.wgsl"));
+    defer add_process.deinit();
+
+    var train_dir = try std.Io.Dir.cwd().openDir(io, "mnist/train", .{});
+
+    var images: [BATCHSIZE * 28 * 28]f16 = undefined;
+    for (EPOCH) |epoch| {
+        // Load random images from train dir
+        train_dir.openDir(io, "0", .{});
+        for (BATCHSIZE) |i| {
+            const file = try train_dir.openFile(io, "0.jpg", .{});
+            images[28 * 28 * i .. 28 * 28 * (i + 1)] = file.read
+        }
+    }
+
+    // 4. Setup CPU data
+    const len: usize = 16;
+    const data_a = try allocator.alloc(f16, len);
+    defer allocator.free(data_a);
+    const data_b = try allocator.alloc(f16, len);
+    defer allocator.free(data_b);
+
+    for (0..len) |i| {
+        data_a[i] = @floatFromInt(i);
+        data_b[i] = @floatFromInt(len - 1 - i);
+    }
+
+    // 5. Initialize raw GPU Buffers
+    // We pass the EnumSet inline using `.initMany` since the Enum itself isn't exported
+    const byte_size = len * @sizeOf(f16);
+    const buf_a = try GpuBuffer.init(gloc, byte_size, .initMany(&.{ .Storage, .CopyDst, .CopySrc }));
+    const buf_b = try GpuBuffer.init(gloc, byte_size, .initMany(&.{ .Storage, .CopyDst, .CopySrc }));
+    const buf_out = try GpuBuffer.init(gloc, byte_size, .initMany(&.{ .Storage, .CopyDst, .CopySrc }));
+
+    // Note: The buffers are safely tied to the GpuArena which will automatically
+    // release them at the end. You can also manually call buf_x.deinit() if desired.
+
+    // 6. Transfer data from CPU slices to GPU Buffers
+    try buf_a.load(f16, data_a);
+    try buf_b.load(f16, data_b);
+
+    // 7. Dispatch the Compute Process
+    // We pass the data type (f16) to allow GpuProcess to calculate chunks correctly
+    try add_process.run(gloc, f16, buf_a, buf_b, buf_out);
+
+    // 8. Map and copy the resulting buffer back to the CPU
+    const out = try buf_out.read(allocator, f16);
+    defer allocator.free(out);
+
+    std.debug.print("Result: {any}\n", .{out});
+}

src/GpuProcess.zig

@@ -1,6 +1,3 @@
-/// GpuProcess is just a pipeline with 2 inpout and 1 output
-/// for now, to see if I make it a bit more generic
-///
 const std = @import("std");
 const c = @import("utils.zig").c;
 const sv = @import("utils.zig").sv;
@@ -8,9 +5,25 @@ const GpuAllocator = @import("GpuAllocator.zig");
 const GpuBuffer = @import("GpuBuffer.zig");
 const GpuDevice = @import("GpuDevice.zig");
 
-pip: c.WGPUComputePipeline,
+pub const Binding = struct {
+    /// Element size in bytes for this binding. E.g. @sizeOf(f32).
+    /// If 0, no element-based size validation is performed for this buffer.
+    element_size: u32 = 0,
+};
 
-pub fn init(device: GpuDevice, wgsl: []const u8) !@This() {
+pub const ProcessDef = struct {
+    bindings: []const Binding,
+    workgroup_size: u32 = 256,
+    max_workgroups: u32 = 65535,
+    /// If true, automatically adds a Uniform Buffer containing `elements_count` as a `u32`
+    /// to the next available binding slot.
+    append_info_buffer: bool = true,
+};
+
+pip: c.WGPUComputePipeline,
+def: ProcessDef,
+
+pub fn init(device: GpuDevice, wgsl: []const u8, def: ProcessDef) !@This() {
     var wgsl_src = c.WGPUShaderSourceWGSL{
         .chain = .{ .sType = c.WGPUSType_ShaderSourceWGSL },
         .code = sv(wgsl),
@@ -20,71 +33,116 @@ pub fn init(device: GpuDevice, wgsl: []const u8) !@This() {
     }) orelse return error.Shader;
     defer c.wgpuShaderModuleRelease(shader);
 
-    return .{ .pip = c.wgpuDeviceCreateComputePipeline(device.device, &.{
+    const pip = c.wgpuDeviceCreateComputePipeline(device.device, &.{
         .compute = .{ .module = shader, .entryPoint = sv("main") },
-    }) orelse return error.Pipeline };
+    }) orelse return error.Pipeline;
+
+    return .{
+        .pip = pip,
+        .def = def,
+    };
 }
 
 pub fn deinit(self: @This()) void {
     c.wgpuComputePipelineRelease(self.pip);
 }
 
-fn onMapped(
-    status: c.WGPUMapAsyncStatus,
-    _: c.WGPUStringView,
-    userdata1: ?*anyopaque,
-    _: ?*anyopaque,
-) callconv(.c) void {
-    const flag: *bool = @ptrCast(@alignCast(userdata1.?));
-    flag.* = (status == c.WGPUMapAsyncStatus_Success);
-}
-
-// Changed: gloc is passed by value instead of *GpuAllocator
+/// Execute the compute pass with arbitrary buffer bindings via a tuple.
+/// Example: `try proc.run(gloc, .{ buf_a, buf_b, buf_out });`
 pub fn run(
     self: @This(),
     gloc: GpuAllocator,
-    T: type,
-    buf_a: GpuBuffer,
-    buf_b: GpuBuffer,
-    buf_out: GpuBuffer,
+    args: anytype,
 ) !void {
-    const max_chunk_bytes: u64 = 1024 * 1024 * 1024; // 1 GB
+    const type_info = @typeInfo(@TypeOf(args));
+    if (type_info != .@"struct" or !type_info.@"struct".is_tuple)
+        @compileError("Expected a tuple of GpuBuffers for args. E.g. .{ buf_a, buf_b }");
 
-    const bytes = buf_a.size;
-    var offset: u64 = 0;
-    while (offset < bytes) {
-        const current_chunk_bytes = @min(max_chunk_bytes, bytes - offset);
-        const current_chunk_elements: u32 = @intCast(current_chunk_bytes / @sizeOf(T));
+    const fields = type_info.@"struct".fields;
+    if (fields.len != self.def.bindings.len) {
+        std.log.err("Process expected {d} arguments, got {d}", .{ self.def.bindings.len, fields.len });
+        return error.InvalidArgumentCount;
+    }
 
-        const info_buf = try GpuBuffer.init(
+    var elements_count: u32 = 0;
+
+    // Infer elements_count from the first arg with a defined element_size
+    inline for (fields, 0..) |field, i| {
+        if (elements_count == 0) {
+            const buf = @field(args, field.name);
+            const el_size = self.def.bindings[i].element_size;
+            if (el_size > 0) {
+                elements_count = @intCast(buf.size / el_size);
+            }
+        }
+    }
+
+    // Validate runtime buffer sizes before dispatching
+    inline for (fields, 0..) |field, i| {
+        const buf = @field(args, field.name);
+        const el_size = self.def.bindings[i].element_size;
+        if (el_size > 0) {
+            const expected_min_bytes = @as(u64, elements_count) * el_size;
+            if (buf.size < expected_min_bytes) {
+                std.log.err("Argument {d} size mismatch: expected at least {d} bytes, got {d}", .{ i, expected_min_bytes, buf.size });
+                return error.BufferTooSmall;
+            }
+        }
+    }
+
+    var entries_buf: [32]c.WGPUBindGroupEntry = undefined;
+    var entry_count: usize = 0;
+
+    // Unpack tuple into WebGPU BindGroupEntries
+    inline for (fields, 0..) |field, i| {
+        const buf = @field(args, field.name);
+        if (@TypeOf(buf) != GpuBuffer) {
+            @compileError("All arguments in the tuple must be of type GpuBuffer");
+        }
+        entries_buf[entry_count] = .{
+            .binding = @intCast(i),
+            .buffer = buf.raw,
+            .offset = 0,
+            .size = buf.size, // Size exposes the fully allocated length
+        };
+        entry_count += 1;
+    }
+
+    // Optional uniform dispatch buffer appended at the end
+    var info_buf: ?GpuBuffer = null;
+    defer if (info_buf) |b| b.deinit();
+
+    if (self.def.append_info_buffer) {
+        info_buf = try GpuBuffer.init(
             gloc,
             @sizeOf(u32),
             .initMany(&.{ .Uniform, .CopyDst }),
         );
-        defer info_buf.deinit();
+        c.wgpuQueueWriteBuffer(gloc.device.queue, info_buf.?.raw, 0, &elements_count, @sizeOf(u32));
 
-        c.wgpuQueueWriteBuffer(gloc.device.queue, info_buf.raw, 0, &current_chunk_elements, @sizeOf(u32));
-
-        const entries = [_]c.WGPUBindGroupEntry{
-            .{ .binding = 0, .buffer = buf_a.raw, .offset = offset, .size = current_chunk_bytes },
-            .{ .binding = 1, .buffer = buf_b.raw, .offset = offset, .size = current_chunk_bytes },
-            .{ .binding = 2, .buffer = buf_out.raw, .offset = offset, .size = current_chunk_bytes },
-            .{ .binding = 3, .buffer = info_buf.raw, .offset = 0, .size = @sizeOf(u32) },
+        entries_buf[entry_count] = .{
+            .binding = @intCast(entry_count),
+            .buffer = info_buf.?.raw,
+            .offset = 0,
+            .size = @sizeOf(u32),
         };
-
-        try submitPass(gloc, self.pip, &entries, current_chunk_elements);
+        entry_count += 1;
+    }
 
-        offset += current_chunk_bytes;
-    }
+    const entries = entries_buf[0..entry_count];
+    try submitPass(gloc, self.pip, entries, elements_count, self.def.workgroup_size, self.def.max_workgroups);
 }
 
-// Changed: gloc is passed by value instead of *GpuAllocator
 fn submitPass(
     gloc: GpuAllocator,
     pipeline: c.WGPUComputePipeline,
     entries: []const c.WGPUBindGroupEntry,
     n: usize,
+    workgroup_size: u32,
+    max_workgroups: u32,
 ) !void {
+    if (n == 0) return;
+
     const bgl = c.wgpuComputePipelineGetBindGroupLayout(pipeline, 0);
     defer c.wgpuBindGroupLayoutRelease(bgl);
 
@@ -95,17 +153,13 @@ fn submitPass(
     }) orelse return error.BindGroup;
     defer c.wgpuBindGroupRelease(bg);
 
-    const enc = c.wgpuDeviceCreateCommandEncoder(gloc.device.device, null) orelse
-        return error.Encoder;
+    const enc = c.wgpuDeviceCreateCommandEncoder(gloc.device.device, null) orelse return error.Encoder;
     const pass = c.wgpuCommandEncoderBeginComputePass(enc, null);
     c.wgpuComputePassEncoderSetPipeline(pass, pipeline);
     c.wgpuComputePassEncoderSetBindGroup(pass, 0, bg, 0, null);
 
-    const WORKGROUP_SIZE = 256;
-    const MAX_WORKGROUPS = 65535;
-
-    const desired_workgroups = ceilDiv(n, WORKGROUP_SIZE);
-    const dispatch_count = @min(desired_workgroups, MAX_WORKGROUPS);
+    const desired_workgroups = ceilDiv(n, workgroup_size);
+    const dispatch_count = @min(desired_workgroups, max_workgroups);
 
     c.wgpuComputePassEncoderDispatchWorkgroups(pass, @intCast(dispatch_count), 1, 1);
     c.wgpuComputePassEncoderEnd(pass);