### Create and Run a Compute Pipeline in Go

Source: https://context7.com/cogentcore/webgpu/llms.txt

This Go code demonstrates how to create a compute pipeline, dispatch workgroups, and process data on the GPU. Ensure you have the WebGPU Go bindings installed.

```go
package main

import (
    "fmt"
    "unsafe"
    "github.com/cogentcore/webgpu/wgpu"
)

const computeShader = `
@group(0) @binding(0) var<storage, read_write> data: array<u32>;

@compute @workgroup_size(64)
fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
    data[global_id.x] = data[global_id.x] * 2u;
}
`

func main() {
    instance := wgpu.CreateInstance(nil)
    defer instance.Release()

    adapter, _ := instance.RequestAdapter(nil)
    defer adapter.Release()

    device, _ := adapter.RequestDevice(nil)
    defer device.Release()
    queue := device.GetQueue()
    defer queue.Release()

    // Create compute shader
    shaderModule, _ := device.CreateShaderModule(&wgpu.ShaderModuleDescriptor{
        WGSLDescriptor: &wgpu.ShaderModuleWGSLDescriptor{Code: computeShader},
    })
    defer shaderModule.Release()

    // Create compute pipeline
    computePipeline, _ := device.CreateComputePipeline(&wgpu.ComputePipelineDescriptor{
        Label: "Compute Pipeline",
        Compute: wgpu.ProgrammableStageDescriptor{
            Module:     shaderModule,
            EntryPoint: "main",
        },
    })
    defer computePipeline.Release()

    // Create data buffer
    data := []uint32{1, 2, 3, 4, 5, 6, 7, 8}
    size := uint64(len(data)) * uint64(unsafe.Sizeof(uint32(0)))

    storageBuffer, _ := device.CreateBufferInit(&wgpu.BufferInitDescriptor{
        Contents: wgpu.ToBytes(data),
        Usage:    wgpu.BufferUsageStorage | wgpu.BufferUsageCopySrc | wgpu.BufferUsageCopyDst,
    })
    defer storageBuffer.Release()

    stagingBuffer, _ := device.CreateBuffer(&wgpu.BufferDescriptor{
        Size:  size,
        Usage: wgpu.BufferUsageMapRead | wgpu.BufferUsageCopyDst,
    })
    defer stagingBuffer.Release()

    // Create bind group
    bindGroupLayout := computePipeline.GetBindGroupLayout(0)
    defer bindGroupLayout.Release()

    bindGroup, _ := device.CreateBindGroup(&wgpu.BindGroupDescriptor{
        Layout: bindGroupLayout,
        Entries: []wgpu.BindGroupEntry{
            {Binding: 0, Buffer: storageBuffer, Size: wgpu.WholeSize},
        },
    })
    defer bindGroup.Release()

    // Run compute shader
    encoder, _ := device.CreateCommandEncoder(nil)
    computePass := encoder.BeginComputePass(nil)
    computePass.SetPipeline(computePipeline)
    computePass.SetBindGroup(0, bindGroup, nil)
    computePass.DispatchWorkgroups(uint32(len(data))/64+1, 1, 1)
    computePass.End()
    computePass.Release()

    encoder.CopyBufferToBuffer(storageBuffer, 0, stagingBuffer, 0, size)
    cmdBuffer, _ := encoder.Finish(nil)
    queue.Submit(cmdBuffer)

    // Read back results
    var status wgpu.BufferMapAsyncStatus
    stagingBuffer.MapAsync(wgpu.MapModeRead, 0, size, func(s wgpu.BufferMapAsyncStatus) {
        status = s
    })
    device.Poll(true, nil)

    if status == wgpu.BufferMapAsyncStatusSuccess {
        result := wgpu.FromBytes[uint32](stagingBuffer.GetMappedRange(0, uint(size)))
        fmt.Printf("Result: %v\n", result) // Output: [2 4 6 8 10 12 14 16]
    }
}

```

--------------------------------

### Create WebGPU Instance

Source: https://context7.com/cogentcore/webgpu/llms.txt

Initializes a WebGPU instance, the entry point for all WebGPU operations. Supports default settings or custom configurations for backends and shader compilers. Remember to release the instance when done.

```go
package main

import (
    "github.com/cogentcore/webgpu/wgpu"
)

func main() {
    // Create a basic instance with default settings
    instance := wgpu.CreateInstance(nil)
    defer instance.Release()

    // Create instance with specific backend configuration
    instanceWithConfig := wgpu.CreateInstance(&wgpu.InstanceDescriptor{
        Backends:           wgpu.InstanceBackendVulkan | wgpu.InstanceBackendMetal,
        Dx12ShaderCompiler: wgpu.Dx12CompilerDxc,
    })
    defer instanceWithConfig.Release()

    // Generate a report of GPU resources
    report := instance.GenerateReport()
    // report contains information about surfaces, adapters, devices, buffers, etc.
}
```

--------------------------------

### Create Buffer with Initial Data in WebGPU

Source: https://context7.com/cogentcore/webgpu/llms.txt

Use `CreateBufferInit` to create a buffer and initialize it with data. The data is converted to bytes using `wgpu.ToBytes`. Ensure to release the buffer.

```go
vertices := []float32{
        // x, y, z positions
        0.0,  0.5, 0.0,
        -0.5, -0.5, 0.0,
        0.5, -0.5, 0.0,
    }

    vertexBuffer, err := device.CreateBufferInit(&wgpu.BufferInitDescriptor{
        Label:    "Triangle Vertices",
        Contents: wgpu.ToBytes(vertices),
        Usage:    wgpu.BufferUsageVertex,
    })
    if err != nil {
        panic(err)
    }
    defer vertexBuffer.Release()
```

--------------------------------

### Create Staging Buffer for Reading in WebGPU

Source: https://context7.com/cogentcore/webgpu/llms.txt

Create a staging buffer with `wgpu.BufferUsageMapRead` for reading data back from the GPU. Ensure to release the buffer.

```go
stagingBuffer, err := device.CreateBuffer(&wgpu.BufferDescriptor{
        Label: "Staging Buffer",
        Size:  256,
        Usage: wgpu.BufferUsageMapRead | wgpu.BufferUsageCopyDst,
    })
    if err != nil {
        panic(err)
    }
    defer stagingBuffer.Release()
```

--------------------------------

### Create WebGPU Render Pipeline

Source: https://context7.com/cogentcore/webgpu/llms.txt

Defines the structure and behavior of the rendering process, including vertex input, shaders, and output color targets. Ensure device and shader modules are set up before creating the pipeline.

```go
package main

import (
    "github.com/cogentcore/webgpu/wgpu"
)

func main() {
    // ... (device and shader setup)

    pipeline, err := device.CreateRenderPipeline(&wgpu.RenderPipelineDescriptor{
        Label: "Render Pipeline",
        Vertex: wgpu.VertexState{
            Module:     shaderModule,
            EntryPoint: "vs_main",
            Buffers: []wgpu.VertexBufferLayout{
                {
                    ArrayStride: 3 * 4, // 3 floats * 4 bytes
                    StepMode:    wgpu.VertexStepModeVertex,
                    Attributes: []wgpu.VertexAttribute{
                        {
                            Format:         wgpu.VertexFormatFloat32x3,
                            Offset:         0,
                            ShaderLocation: 0,
                        },
                    },
                },
            },
        },
        Primitive: wgpu.PrimitiveState{
            Topology:  wgpu.PrimitiveTopologyTriangleList,
            FrontFace: wgpu.FrontFaceCCW,
            CullMode:  wgpu.CullModeBack,
        },
        Fragment: &wgpu.FragmentState{
            Module:     shaderModule,
            EntryPoint: "fs_main",
            Targets: []wgpu.ColorTargetState{
                {
                    Format:    wgpu.TextureFormatBGRA8Unorm,
                    WriteMask: wgpu.ColorWriteMaskAll,
                    Blend: &wgpu.BlendState{
                        Color: wgpu.BlendComponent{
                            SrcFactor: wgpu.BlendFactorSrcAlpha,
                            DstFactor: wgpu.BlendFactorOneMinusSrcAlpha,
                            Operation: wgpu.BlendOperationAdd,
                        },
                        Alpha: wgpu.BlendComponent{
                            SrcFactor: wgpu.BlendFactorOne,
                            DstFactor: wgpu.BlendFactorOneMinusSrcAlpha,
                            Operation: wgpu.BlendOperationAdd,
                        },
                    },
                },
            },
        },
        Multisample: wgpu.MultisampleState{
            Count:                  1,
            Mask:                   0xFFFFFFFF,
            AlphaToCoverageEnabled: false,
        },
        DepthStencil: &wgpu.DepthStencilState{
            Format:            wgpu.TextureFormatDepth24Plus,
            DepthWriteEnabled: true,
            DepthCompare:      wgpu.CompareFunctionLess,
        },
    })
    if err != nil {
        panic(err)
    }
    defer pipeline.Release()
}
```

--------------------------------

### Configure Surface for Presentation

Source: https://context7.com/cogentcore/webgpu/llms.txt

Configures a surface for presenting rendered frames in windowed applications. Ensure the adapter and device are valid before calling.

```go
package main

import (
    "github.com/cogentcore/webgpu/wgpu"
)

func setupSurface(instance *wgpu.Instance, adapter *wgpu.Adapter,
                  device *wgpu.Device, surface *wgpu.Surface, width, height int) {

    // Get surface capabilities
    caps := surface.GetCapabilities(adapter)

    // Configure surface
    config := &wgpu.SurfaceConfiguration{
        Usage:       wgpu.TextureUsageRenderAttachment,
        Format:      caps.Formats[0],  // Use first supported format
        Width:       uint32(width),
        Height:      uint32(height),
        PresentMode: wgpu.PresentModeFifo,  // VSync
        AlphaMode:   caps.AlphaModes[0],
    }

    surface.Configure(adapter, device, config)
}
```

--------------------------------

### Create Shader Module from WGSL in WebGPU

Source: https://context7.com/cogentcore/webgpu/llms.txt

Create a shader module from WGSL code using `device.CreateShaderModule`. Ensure to release the shader module.

```go
const triangleShader = `
@vertex
fn vs_main(@builtin(vertex_index) in_vertex_index: u32) -> @builtin(position) vec4<f32> {
    let x = f32(i32(in_vertex_index) - 1);
    let y = f32(i32(in_vertex_index & 1u) * 2 - 1);
    return vec4<f32>(x, y, 0.0, 1.0);
}

@fragment
fn fs_main() -> @location(0) vec4<f32> {
    return vec4<f32>(1.0, 0.0, 0.0, 1.0);
}
`

shaderModule, err := device.CreateShaderModule(&wgpu.ShaderModuleDescriptor{
        Label: "Triangle Shader",
        WGSLDescriptor: &wgpu.ShaderModuleWGSLDescriptor{
            Code: triangleShader,
        },
    })
    if err != nil {
        panic(err)
    }
    defer shaderModule.Release()
```

--------------------------------

### Request GPU Adapter

Source: https://context7.com/cogentcore/webgpu/llms.txt

Requests a GPU adapter (physical GPU) from the instance. Allows specifying power preference and whether to force a fallback adapter. Retrieves adapter information, supported features, and device limits. Remember to release the adapter.

```go
package main

import (
    "fmt"
    "github.com/cogentcore/webgpu/wgpu"
)

func main() {
    instance := wgpu.CreateInstance(nil)
    defer instance.Release()

    // Request adapter with options
    adapter, err := instance.RequestAdapter(&wgpu.RequestAdapterOptions{
        PowerPreference:      wgpu.PowerPreferenceHighPerformance,
        ForceFallbackAdapter: false,
    })
    if err != nil {
        panic(err)
    }
    defer adapter.Release()

    // Get adapter information
    info := adapter.GetInfo()
    fmt.Printf("GPU: %s (%s)\n", info.Name, info.VendorName)
    fmt.Printf("Backend: %s\n", info.BackendType)
    fmt.Printf("Adapter Type: %s\n", info.AdapterType)

    // Query supported features
    features := adapter.EnumerateFeatures()
    for _, f := range features {
        fmt.Printf("Feature: %s\n", f)
    }

    // Get device limits
    limits := adapter.GetLimits()
    fmt.Printf("Max Texture Dimension 2D: %d\n", limits.Limits.MaxTextureDimension2D)
    fmt.Printf("Max Buffer Size: %d\n", limits.Limits.MaxBufferSize)
}
```

--------------------------------

### Create Empty Buffer in WebGPU

Source: https://context7.com/cogentcore/webgpu/llms.txt

Use `CreateBuffer` to create an empty buffer with specified size and usage flags. Ensure to release the buffer when done.

```go
buffer, err := device.CreateBuffer(&wgpu.BufferDescriptor{
        Label: "Vertex Buffer",
        Size:  1024,
        Usage: wgpu.BufferUsageVertex | wgpu.BufferUsageCopyDst,
        MappedAtCreation: false,
    })
    if err != nil {
        panic(err)
    }
    defer buffer.Release()
```

--------------------------------

### Create Shader Module from SPIR-V in WebGPU

Source: https://context7.com/cogentcore/webgpu/llms.txt

Create a shader module from SPIR-V bytecode using `device.CreateShaderModule`. Ensure to release the shader module.

```go
spirvCode := []byte{ /* SPIR-V bytecode */ }
    spirvShader, err := device.CreateShaderModule(&wgpu.ShaderModuleDescriptor{
        Label: "SPIR-V Shader",
        SPIRVDescriptor: &wgpu.ShaderModuleSPIRVDescriptor{
            Code: spirvCode,
        },
    })
    if err != nil {
        panic(err)
    }
    defer spirvShader.Release()
```

--------------------------------

### Create Bind Group Layout in Go

Source: https://context7.com/cogentcore/webgpu/llms.txt

Define the structure of resources that will be bound to shaders using `device.CreateBindGroupLayout`. This includes specifying binding points, visibility, and the type of resource (texture, sampler, buffer).

```go
package main

import (
    "github.com/cogentcore/webgpu/wgpu"
)

func main() {
    // ... (device setup)

    // Create bind group layout
    bindGroupLayout, err := device.CreateBindGroupLayout(&wgpu.BindGroupLayoutDescriptor{
        Label: "Bind Group Layout",
        Entries: []wgpu.BindGroupLayoutEntry{
            {
                Binding:    0,
                Visibility: wgpu.ShaderStageFragment,
                Texture: wgpu.TextureBindingLayout{
                    SampleType:    wgpu.TextureSampleTypeFloat,
                    ViewDimension: wgpu.TextureViewDimension2D,
                    Multisampled:  false,
                },
            },
            {
                Binding:    1,
                Visibility: wgpu.ShaderStageFragment,
                Sampler: wgpu.SamplerBindingLayout{
                    Type: wgpu.SamplerBindingTypeFiltering,
                },
            },
            {
                Binding:    2,
                Visibility: wgpu.ShaderStageVertex | wgpu.ShaderStageFragment,
                Buffer: wgpu.BufferBindingLayout{
                    Type:             wgpu.BufferBindingTypeUniform,
                    HasDynamicOffset: false,
                    MinBindingSize:   64,
                },
            },
        },
    })
    if err != nil {
        panic(err)
    }
    defer bindGroupLayout.Release()

    // Create sampler
    sampler, _ := device.CreateSampler(&wgpu.SamplerDescriptor{
        AddressModeU:  wgpu.AddressModeRepeat,
        AddressModeV:  wgpu.AddressModeRepeat,
        MagFilter:     wgpu.FilterModeLinear,
        MinFilter:     wgpu.FilterModeLinear,
        MipmapFilter:  wgpu.MipmapFilterModeLinear,
        MaxAnisotropy: 16,
    })
    defer sampler.Release()

    // Create bind group
    bindGroup, err := device.CreateBindGroup(&wgpu.BindGroupDescriptor{
        Label:  "Bind Group",
        Layout: bindGroupLayout,
        Entries: []wgpu.BindGroupEntry{
            {Binding: 0, TextureView: textureView},
            {Binding: 1, Sampler: sampler},
            {Binding: 2, Buffer: uniformBuffer, Offset: 0, Size: 64},
        },
    })
    if err != nil {
        panic(err)
    }
    defer bindGroup.Release()
}
```

--------------------------------

### Create 2D Texture in Go

Source: https://context7.com/cogentcore/webgpu/llms.txt

Use `device.CreateTexture` to create a 2D texture for storing image data. Ensure the texture usage flags are set appropriately for binding and destination copying.

```go
package main

import (
    "github.com/cogentcore/webgpu/wgpu"
)

func main() {
    // ... (device setup)

    // Create a 2D texture
    texture, err := device.CreateTexture(&wgpu.TextureDescriptor{
        Label: "My Texture",
        Size: wgpu.Extent3D{
            Width:              256,
            Height:             256,
            DepthOrArrayLayers: 1,
        },
        MipLevelCount: 1,
        SampleCount:   1,
        Dimension:     wgpu.TextureDimension2D,
        Format:        wgpu.TextureFormatRGBA8Unorm,
        Usage:         wgpu.TextureUsageTextureBinding | wgpu.TextureUsageCopyDst,
    })
    if err != nil {
        panic(err)
    }
    defer texture.Release()

    // Create texture view for shader binding
    textureView, err := texture.CreateView(&wgpu.TextureViewDescriptor{
        Label:           "Texture View",
        Format:          wgpu.TextureFormatRGBA8Unorm,
        Dimension:       wgpu.TextureViewDimension2D,
        BaseMipLevel:    0,
        MipLevelCount:   1,
        BaseArrayLayer:  0,
        ArrayLayerCount: 1,
        Aspect:          wgpu.TextureAspectAll,
    })
    if err != nil {
        panic(err)
    }
    defer textureView.Release()

    // Write image data to texture
    imageData := make([]byte, 256*256*4) // RGBA
    queue.WriteTexture(
        &wgpu.ImageCopyTexture{
            Texture:  texture,
            MipLevel: 0,
            Origin:   wgpu.Origin3D{X: 0, Y: 0, Z: 0},
            Aspect:   wgpu.TextureAspectAll,
        },
        imageData,
        &wgpu.TextureDataLayout{
            Offset:       0,
            BytesPerRow:  256 * 4,
            RowsPerImage: 256,
        },
        &wgpu.Extent3D{Width: 256, Height: 256, DepthOrArrayLayers: 1},
    )
}
```

--------------------------------

### Record and Submit Render Commands

Source: https://context7.com/cogentcore/webgpu/llms.txt

Uses a command encoder to record drawing operations and then submits the encoded commands to the GPU queue for execution. Ensure all necessary resources like pipeline and texture views are available.

```go
package main

import (
    "github.com/cogentcore/webgpu/wgpu"
)

func render(device *wgpu.Device, queue *wgpu.Queue, pipeline *wgpu.RenderPipeline,
            textureView *wgpu.TextureView) error {

    // Create command encoder
    encoder, err := device.CreateCommandEncoder(&wgpu.CommandEncoderDescriptor{
        Label: "Render Encoder",
    })
    if err != nil {
        return err
    }
    defer encoder.Release()

    // Begin render pass
    renderPass := encoder.BeginRenderPass(&wgpu.RenderPassDescriptor{
        Label: "Main Render Pass",
        ColorAttachments: []wgpu.RenderPassColorAttachment{
            {
                View:    textureView,
                LoadOp:  wgpu.LoadOpClear,
                StoreOp: wgpu.StoreOpStore,
                ClearValue: wgpu.Color{
                    R: 0.1, G: 0.2, B: 0.3, A: 1.0,
                },
            },
        },
    })

    // Record drawing commands
    renderPass.SetPipeline(pipeline)
    renderPass.SetViewport(0, 0, 800, 600, 0, 1)
    renderPass.SetScissorRect(0, 0, 800, 600)
    renderPass.Draw(3, 1, 0, 0) // Draw 3 vertices, 1 instance

    renderPass.End()
    renderPass.Release() // Must release before submit

    // Finish encoding and submit
    cmdBuffer, err := encoder.Finish(nil)
    if err != nil {
        return err
    }
    defer cmdBuffer.Release()

    queue.Submit(cmdBuffer)
    return nil
}
```

--------------------------------

### Request GPU Device

Source: https://context7.com/cogentcore/webgpu/llms.txt

Requests a logical device from an adapter, specifying required features, limits, and a callback for device loss. Retrieves the command queue and queries device-specific features and limits. Remember to release the device and queue.

```go
package main

import (
    "fmt"
    "github.com/cogentcore/webgpu/wgpu"
)

func main() {
    instance := wgpu.CreateInstance(nil)
    defer instance.Release()

    adapter, err := instance.RequestAdapter(nil)
    if err != nil {
        panic(err)
    }
    defer adapter.Release()

    // Request device with specific features and limits
    device, err := adapter.RequestDevice(&wgpu.DeviceDescriptor{
        Label: "My GPU Device",
        RequiredFeatures: []wgpu.FeatureName{
            wgpu.FeatureNameTimestampQuery,
        },
        RequiredLimits: &wgpu.RequiredLimits{
            Limits: wgpu.Limits{
                MaxBindGroups: 4,
            },
        },
        DeviceLostCallback: func(reason wgpu.DeviceLostReason, message string) {
            fmt.Printf("Device lost: %s - %s\n", reason, message)
        },
    })
    if err != nil {
        panic(err)
    }
    defer device.Release()

    // Get the command queue
    queue := device.GetQueue()
    defer queue.Release()

    // Query device features and limits
    deviceFeatures := device.EnumerateFeatures()
    deviceLimits := device.GetLimits()

    fmt.Printf("Device has %d features\n", len(deviceFeatures))
    fmt.Printf("Max compute workgroup size X: %d\n", deviceLimits.Limits.MaxComputeWorkgroupSizeX)
}
```

--------------------------------

### Set WebGPU Log Level

Source: https://context7.com/cogentcore/webgpu/llms.txt

Configures the logging verbosity for debugging GPU operations. Call `wgpu.SetLogLevel` before creating a `wgpu.Instance` to ensure all messages are captured.

```go
package main

import (
    "github.com/cogentcore/webgpu/wgpu"
)

func main() {
    // Set log level before creating instance
    wgpu.SetLogLevel(wgpu.LogLevelWarn)  // Show warnings and errors only

    // Available log levels:
    // wgpu.LogLevelOff   - No logging
    // wgpu.LogLevelError - Errors only
    // wgpu.LogLevelWarn  - Warnings and errors
    // wgpu.LogLevelInfo  - Informational messages
    // wgpu.LogLevelDebug - Debug information
    // wgpu.LogLevelTrace - Detailed trace logging

    instance := wgpu.CreateInstance(nil)
    defer instance.Release()

    // Get wgpu version
    version := wgpu.GetVersion()
    fmt.Printf("wgpu version: %s\n", version)
}
```

--------------------------------

### Render a Frame

Source: https://context7.com/cogentcore/webgpu/llms.txt

Renders a single frame to the configured surface. This function assumes a valid render pipeline and queue are available. It handles texture acquisition, command encoding, and submission.

```go
package main

import (
    "github.com/cogentcore/webgpu/wgpu"
)

func renderFrame(surface *wgpu.Surface, device *wgpu.Device,
                 queue *wgpu.Queue, pipeline *wgpu.RenderPipeline) error {

    // Get current texture to render to
    texture, err := surface.GetCurrentTexture()
    if err != nil {
        return err
    }

    view, err := texture.CreateView(nil)
    if err != nil {
        return err
    }
    defer view.Release()

    // Record render commands
    encoder, _ := device.CreateCommandEncoder(nil)
    defer encoder.Release()

    renderPass := encoder.BeginRenderPass(&wgpu.RenderPassDescriptor{
        ColorAttachments: []wgpu.RenderPassColorAttachment{
            {
                View:       view,
                LoadOp:     wgpu.LoadOpClear,
                StoreOp:    wgpu.StoreOpStore,
                ClearValue: wgpu.Color{R: 0.0, G: 0.5, B: 0.0, A: 1.0},
            },
        },
    })

    renderPass.SetPipeline(pipeline)
    renderPass.Draw(3, 1, 0, 0)
    renderPass.End()
    renderPass.Release()

    cmdBuffer, _ := encoder.Finish(nil)
    defer cmdBuffer.Release()

    queue.Submit(cmdBuffer)
    surface.Present()

    return nil
}
```

--------------------------------

### Map Buffer for Reading in WebGPU

Source: https://context7.com/cogentcore/webgpu/llms.txt

Asynchronously map a buffer for reading using `MapAsync`. Call `device.Poll` to wait for the mapping to complete. Process the mapped data and then unmap the buffer.

```go
var status wgpu.BufferMapAsyncStatus
    stagingBuffer.MapAsync(wgpu.MapModeRead, 0, 256, func(s wgpu.BufferMapAsyncStatus) {
        status = s
    })
    device.Poll(true, nil) // Wait for mapping

    if status == wgpu.BufferMapAsyncStatusSuccess {
        data := stagingBuffer.GetMappedRange(0, 256)
        // Process data...
        stagingBuffer.Unmap()
```

--------------------------------

### Convert Go Slices to Bytes

Source: https://context7.com/cogentcore/webgpu/llms.txt

Converts Go slices of various types (e.g., float32, uint32) into byte slices for GPU buffer operations. This is useful for uploading data to GPU buffers. The `wgpu.FromBytes` function performs the reverse conversion.

```go
package main

import (
    "fmt"
    "github.com/cogentcore/webgpu/wgpu"
)

func main() {
    // Convert typed slice to bytes for buffer upload
    vertices := []float32{1.0, 2.0, 3.0, 4.0}
    bytes := wgpu.ToBytes(vertices)
    fmt.Printf("Bytes: %d\n", len(bytes)) // 16 bytes (4 floats * 4 bytes)

    // Convert bytes back to typed slice for reading
    readBack := wgpu.FromBytes[float32](bytes)
    fmt.Printf("Values: %v\n", readBack) // [1.0 2.0 3.0 4.0]

    // Works with any type
    indices := []uint32{0, 1, 2, 2, 1, 3}
    indexBytes := wgpu.ToBytes(indices)

    // Use in buffer creation
    buffer, _ := device.CreateBufferInit(&wgpu.BufferInitDescriptor{
        Label:    "Index Buffer",
        Contents: wgpu.ToBytes(indices),
        Usage:    wgpu.BufferUsageIndex,
    })
    defer buffer.Release()
}
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.