core

Apr 30, 2026

Changes in this version

type CreateBindGroupError — darwin/amd64, linux/amd64, windows/amd64

+ MinBindingSize uint64

type CreateBindGroupErrorKind — darwin/amd64, linux/amd64, windows/amd64

+ const CreateBindGroupErrorMinBindingSizeMismatch

type CreateRenderPipelineErrorKind — darwin/amd64, linux/amd64, windows/amd64

+ const CreateRenderPipelineErrorDepthFormatNoDepthAspect

+ const CreateRenderPipelineErrorDepthFormatNoStencilAspect

Apr 30, 2026

Changes in this version

+ func IsCreatePipelineLayoutError(err error) bool — darwin/amd64, linux/amd64, windows/amd64

+ func ValidatePipelineLayoutDescriptor(desc *hal.PipelineLayoutDescriptor, limits gputypes.Limits) error — darwin/amd64, linux/amd64, windows/amd64

+ type BindGroupBufferInfo struct — darwin/amd64, linux/amd64, windows/amd64

+ Binding uint32

+ BufferSize uint64

+ Offset uint64

+ Size uint64

+ Usage gputypes.BufferUsage

type CreateBindGroupError — darwin/amd64, linux/amd64, windows/amd64

+ Actual int

+ ActualUsage uint64

+ Alignment uint64

+ Binding uint32

+ BufferSize uint64

+ Expected int

+ ExpectedUsage uint64

+ MaxSize uint64

+ Offset uint64

+ Size uint64

type CreateBindGroupErrorKind — darwin/amd64, linux/amd64, windows/amd64

+ const CreateBindGroupErrorBindingsNumMismatch

+ const CreateBindGroupErrorBufferBindingSizeTooLarge

+ const CreateBindGroupErrorBufferBindingZeroSize

+ const CreateBindGroupErrorBufferBoundsOverflow

+ const CreateBindGroupErrorBufferOffsetAlignment

+ const CreateBindGroupErrorBufferUsageMismatch

+ const CreateBindGroupErrorDuplicateBinding

+ const CreateBindGroupErrorMissingBindingDeclaration

+ const CreateBindGroupErrorStorageBufferSizeAlignment

+ type CreatePipelineLayoutError struct — darwin/amd64, linux/amd64, windows/amd64

+ Count int

+ HALError error

+ Kind CreatePipelineLayoutErrorKind

+ Label string

+ MaxGroups uint32

+ func (e *CreatePipelineLayoutError) Error() string

+ func (e *CreatePipelineLayoutError) Unwrap() error

+ type CreatePipelineLayoutErrorKind int — darwin/amd64, linux/amd64, windows/amd64

+ const CreatePipelineLayoutErrorHAL

+ const CreatePipelineLayoutErrorTooManyGroups

type CreateRenderPipelineError — darwin/amd64, linux/amd64, windows/amd64

+ Format string

+ TargetIndex uint32

type CreateRenderPipelineErrorKind — darwin/amd64, linux/amd64, windows/amd64

+ const CreateRenderPipelineErrorColorTargetDepthFormat

+ const CreateRenderPipelineErrorDepthStencilColorFormat

type EncoderStateError — darwin/amd64, linux/amd64, windows/amd64

+ Cause error

+ func (e *EncoderStateError) Unwrap() error

Apr 26, 2026

Changes in this version

type ProgrammableStage — darwin/amd64, linux/amd64, windows/amd64

+ ZeroInitializeWorkgroupMemory bool

Apr 26, 2026

Changes in this version

type CreateComputePipelineError — darwin/amd64, linux/amd64, windows/amd64

+ Dimension string

+ Limit uint32

+ Size uint32

+ TotalInvocations uint64

type CreateComputePipelineErrorKind — darwin/amd64, linux/amd64, windows/amd64

+ const CreateComputePipelineErrorTooManyInvocations

+ const CreateComputePipelineErrorWorkgroupSizeExceeded

+ const CreateComputePipelineErrorWorkgroupSizeZero

Apr 25, 2026

Changes in this version

type Surface — darwin/amd64, linux/amd64, windows/amd64

+ func (s *Surface) PresentWithDamage(queue hal.Queue, damageRects []image.Rectangle) error

Apr 21, 2026

Changes in this version

type Buffer

+ func (b *Buffer) BeginMap(mode MapModeInternal, offset, size uint64) *BufferMapError

+ func (b *Buffer) CurrentMapState() BufferMapState

+ func (b *Buffer) Generation() uint64

+ func (b *Buffer) InstallMappedAtCreation(guard SnatchGuard, halDevice hal.Device) error

+ func (b *Buffer) MappingInfo() (base unsafe.Pointer, offset, size uint64, ok bool)

+ func (b *Buffer) MarkDestroyed()

+ func (b *Buffer) ResolveMap(guard SnatchGuard, halDevice hal.Device)

+ func (b *Buffer) TryRegisterMappedRange(offset, size uint64) *BufferMapError

+ func (b *Buffer) UnmapBuffer(guard SnatchGuard, halDevice hal.Device) *BufferMapError

+ func (b *Buffer) Waiter() *MapWaiter

+ type BufferMapData struct

+ type BufferMapError struct

+ Kind BufferMapErrorKind

+ Wrapped error

+ func (e *BufferMapError) Error() string

+ func (e *BufferMapError) Unwrap() error

+ type BufferMapErrorKind uint8

+ const BufferMapErrKindAlignment

+ const BufferMapErrKindAlreadyMapped

+ const BufferMapErrKindAlreadyPending

+ const BufferMapErrKindCancelled

+ const BufferMapErrKindDestroyed

+ const BufferMapErrKindDeviceLost

+ const BufferMapErrKindHAL

+ const BufferMapErrKindInvalidMode

+ const BufferMapErrKindNone

+ const BufferMapErrKindNotMapped

+ const BufferMapErrKindRangeDetached

+ const BufferMapErrKindRangeOverflow

+ const BufferMapErrKindRangeOverlap

type BufferMapState

+ const BufferMapStateDestroyed

type Device

+ func (d *Device) HalDeviceHandle() (hal.Device, bool)

+ func (d *Device) HasPendingMaps() bool

+ func (d *Device) MaxKnownSubmissionIndex() uint64

+ func (d *Device) PollMaps(completedIdx uint64) (didWork bool)

+ func (d *Device) RegisterPendingMap(submissionIndex uint64, buf *Buffer)

+ type MapModeInternal uint8

+ const MapModeInternalRead

+ const MapModeInternalWrite

+ type MapWaiter struct

+ func (w *MapWaiter) Reset()

+ func (w *MapWaiter) Signal(err *BufferMapError)

+ func (w *MapWaiter) Status() (done bool, err *BufferMapError)

+ func (w *MapWaiter) Wait() *BufferMapError

+ type PollTypeInternal uint8

+ const PollTypePoll

+ const PollTypeWait

Apr 8, 2026

Changes in this version

type Device

+ func (d *Device) Backend() gputypes.Backend

type Instance

+ func (i *Instance) HALInstanceForBackend(backend gputypes.Backend) hal.Instance

+ func (i *Instance) HALInstanceMap() map[gputypes.Backend]hal.Instance

type Surface

+ func (s *Surface) SetRawSurface(raw hal.Surface)

Apr 6, 2026

Changes in this version

type CoreCommandEncoder

+ func (e *CoreCommandEncoder) TakeHALEncoder() hal.CommandEncoder

type Device

+ func (d *Device) CreateCommandEncoderWithHAL(halEncoder hal.CommandEncoder, label string) (*CoreCommandEncoder, error)

Apr 4, 2026

Changes in this version

type BindGroup

+ Ref *ResourceRef

type BindGroupLayout

+ Ref *ResourceRef

type Buffer

+ Ref *ResourceRef

type ComputePipeline

+ Ref *ResourceRef

+ type DeferredDestroy struct

+ type DestroyQueue struct

+ func NewDestroyQueue() *DestroyQueue

+ func (q *DestroyQueue) Defer(index uint64, label string, fn func())

+ func (q *DestroyQueue) FlushAll()

+ func (q *DestroyQueue) Len() int

+ func (q *DestroyQueue) TrackSubmission(index uint64, refs []*ResourceRef)

+ func (q *DestroyQueue) TrackedLen() int

+ func (q *DestroyQueue) Triage(completedIndex uint64)

type Device

+ func (d *Device) DestroyQueueRef() *DestroyQueue

type PipelineLayout

+ Ref *ResourceRef

type QuerySet

+ Ref *ResourceRef

type RenderPipeline

+ Ref *ResourceRef

+ type ResourceRef struct

+ func NewResourceRef(label string, onZero func()) *ResourceRef

+ func (r *ResourceRef) Clone()

+ func (r *ResourceRef) Drop()

+ func (r *ResourceRef) Label() string

+ func (r *ResourceRef) RefCount() int32

type Sampler

+ Ref *ResourceRef

type ShaderModule

+ Ref *ResourceRef

type Texture

+ Ref *ResourceRef

+ type TrackedSubmission struct

Mar 16, 2026

Changes in this version

type Instance

+ func (i *Instance) RequestAdapterWithSurface(options *gputypes.RequestAdapterOptions, surfaceHint hal.Surface) (AdapterID, error)

Mar 15, 2026

Changes in this version

+ var ErrSurfaceAlreadyAcquired = errors.New("core: surface texture already acquired")

+ var ErrSurfaceConfigureWhileAcquired = errors.New("core: cannot configure surface while texture is acquired")

+ var ErrSurfaceNilConfig = errors.New("core: surface configuration must not be nil")

+ var ErrSurfaceNilDevice = errors.New("core: device must not be nil")

+ var ErrSurfaceNoTextureAcquired = errors.New("core: no surface texture acquired")

+ var ErrSurfaceNotConfigured = errors.New("core: surface is not configured")

type BindGroup

+ func NewBindGroup(halGroup hal.BindGroup, device *Device, label string) *BindGroup

+ func (bg *BindGroup) Destroy()

+ func (bg *BindGroup) IsDestroyed() bool

+ func (bg *BindGroup) Label() string

+ func (bg *BindGroup) Raw(guard *SnatchGuard) hal.BindGroup

type BindGroupLayout

+ func NewBindGroupLayout(halLayout hal.BindGroupLayout, device *Device, ...) *BindGroupLayout

+ func (bgl *BindGroupLayout) Destroy()

+ func (bgl *BindGroupLayout) Entries() []gputypes.BindGroupLayoutEntry

+ func (bgl *BindGroupLayout) EntryCount() int

+ func (bgl *BindGroupLayout) IsDestroyed() bool

+ func (bgl *BindGroupLayout) Label() string

+ func (bgl *BindGroupLayout) Raw(guard *SnatchGuard) hal.BindGroupLayout

type CommandBuffer

+ func NewCommandBuffer(halBuffer hal.CommandBuffer, device *Device, label string) *CommandBuffer

+ func (cb *CommandBuffer) IsSubmitted() bool

+ func (cb *CommandBuffer) MarkSubmitted() error

+ func (cb *CommandBuffer) Raw(guard *SnatchGuard) hal.CommandBuffer

+ type CommandBufferSubmitState int

+ const CommandBufferSubmitStateAvailable

+ const CommandBufferSubmitStateSubmitted

type CommandEncoder

+ func NewCommandEncoder(halEncoder hal.CommandEncoder, device *Device, label string) *CommandEncoder

+ func (ce *CommandEncoder) RawEncoder() hal.CommandEncoder

+ func (e *CommandEncoder) BeginComputePass() error

+ func (e *CommandEncoder) BeginRenderPass() error

+ func (e *CommandEncoder) EncoderLabel() string

+ func (e *CommandEncoder) EndComputePass() error

+ func (e *CommandEncoder) EndRenderPass() error

+ func (e *CommandEncoder) ErrorMessage() string

+ func (e *CommandEncoder) Finish() error

+ func (e *CommandEncoder) PassState() CommandEncoderPassState

+ func (e *CommandEncoder) RecordError(msg string)

+ type CommandEncoderPassState int

+ const CommandEncoderPassStateError

+ const CommandEncoderPassStateFinished

+ const CommandEncoderPassStateInComputePass

+ const CommandEncoderPassStateInRenderPass

+ const CommandEncoderPassStateRecording

+ func (s CommandEncoderPassState) String() string

type ComputePipeline

+ func NewComputePipeline(halPipeline hal.ComputePipeline, device *Device, label string) *ComputePipeline

+ func (cp *ComputePipeline) Destroy()

+ func (cp *ComputePipeline) IsDestroyed() bool

+ func (cp *ComputePipeline) Label() string

+ func (cp *ComputePipeline) Raw(guard *SnatchGuard) hal.ComputePipeline

type PipelineLayout

+ func NewPipelineLayout(halLayout hal.PipelineLayout, device *Device, bindGroupLayoutCount int, ...) *PipelineLayout

+ func (pl *PipelineLayout) BindGroupLayoutCount() int

+ func (pl *PipelineLayout) Destroy()

+ func (pl *PipelineLayout) IsDestroyed() bool

+ func (pl *PipelineLayout) Label() string

+ func (pl *PipelineLayout) Raw(guard *SnatchGuard) hal.PipelineLayout

+ type PrepareFrameFunc func() (width, height uint32, changed bool)

type QuerySet

+ func NewQuerySet(halQuerySet hal.QuerySet, device *Device, queryType hal.QueryType, ...) *QuerySet

+ func (qs *QuerySet) Count() uint32

+ func (qs *QuerySet) Destroy()

+ func (qs *QuerySet) IsDestroyed() bool

+ func (qs *QuerySet) Label() string

+ func (qs *QuerySet) QueryType() hal.QueryType

+ func (qs *QuerySet) Raw(guard *SnatchGuard) hal.QuerySet

type RenderPipeline

+ func NewRenderPipeline(halPipeline hal.RenderPipeline, device *Device, label string) *RenderPipeline

+ func (rp *RenderPipeline) Destroy()

+ func (rp *RenderPipeline) IsDestroyed() bool

+ func (rp *RenderPipeline) Label() string

+ func (rp *RenderPipeline) Raw(guard *SnatchGuard) hal.RenderPipeline

type Sampler

+ func NewSampler(halSampler hal.Sampler, device *Device, label string) *Sampler

+ func (s *Sampler) Destroy()

+ func (s *Sampler) IsDestroyed() bool

+ func (s *Sampler) Label() string

+ func (s *Sampler) Raw(guard *SnatchGuard) hal.Sampler

type ShaderModule

+ func NewShaderModule(halModule hal.ShaderModule, device *Device, label string) *ShaderModule

+ func (sm *ShaderModule) Destroy()

+ func (sm *ShaderModule) IsDestroyed() bool

+ func (sm *ShaderModule) Label() string

+ func (sm *ShaderModule) Raw(guard *SnatchGuard) hal.ShaderModule

type Surface

+ func NewSurface(halSurface hal.Surface, label string) *Surface

+ func (s *Surface) AcquireTexture(fence hal.Fence) (*hal.AcquiredSurfaceTexture, error)

+ func (s *Surface) Config() *hal.SurfaceConfiguration

+ func (s *Surface) Configure(device *Device, config *hal.SurfaceConfiguration) error

+ func (s *Surface) DiscardTexture()

+ func (s *Surface) Present(queue hal.Queue) error

+ func (s *Surface) RawSurface() hal.Surface

+ func (s *Surface) SetPrepareFrame(fn PrepareFrameFunc)

+ func (s *Surface) State() SurfaceState

+ func (s *Surface) Unconfigure()

+ type SurfaceState int

+ const SurfaceStateAcquired

+ const SurfaceStateConfigured

+ const SurfaceStateUnconfigured

type Texture

+ func NewTexture(halTexture hal.Texture, device *Device, format gputypes.TextureFormat, ...) *Texture

+ func (t *Texture) Destroy()

+ func (t *Texture) Dimension() gputypes.TextureDimension

+ func (t *Texture) Format() gputypes.TextureFormat

+ func (t *Texture) IsDestroyed() bool

+ func (t *Texture) Label() string

+ func (t *Texture) MipLevelCount() uint32

+ func (t *Texture) Raw(guard *SnatchGuard) hal.Texture

+ func (t *Texture) SampleCount() uint32

+ func (t *Texture) Size() gputypes.Extent3D

+ func (t *Texture) Usage() gputypes.TextureUsage

Mar 10, 2026

Changes in this version

+ func IsCreateBindGroupError(err error) bool

+ func IsCreateBindGroupLayoutError(err error) bool

+ func IsCreateComputePipelineError(err error) bool

+ func IsCreateRenderPipelineError(err error) bool

+ func IsCreateSamplerError(err error) bool

+ func IsCreateShaderModuleError(err error) bool

+ func IsCreateTextureError(err error) bool

+ func ValidateBindGroupDescriptor(desc *hal.BindGroupDescriptor) error

+ func ValidateBindGroupLayoutDescriptor(desc *hal.BindGroupLayoutDescriptor, limits gputypes.Limits) error

+ func ValidateComputePipelineDescriptor(desc *hal.ComputePipelineDescriptor) error

+ func ValidateRenderPipelineDescriptor(desc *hal.RenderPipelineDescriptor, limits gputypes.Limits) error

+ func ValidateSamplerDescriptor(desc *hal.SamplerDescriptor) error

+ func ValidateShaderModuleDescriptor(desc *hal.ShaderModuleDescriptor) error

+ func ValidateTextureDescriptor(desc *hal.TextureDescriptor, limits gputypes.Limits) error

type CoreCommandEncoder

+ func (e *CoreCommandEncoder) SetError(err error)

+ type CreateBindGroupError struct

+ HALError error

+ Kind CreateBindGroupErrorKind

+ Label string

+ func (e *CreateBindGroupError) Error() string

+ func (e *CreateBindGroupError) Unwrap() error

+ type CreateBindGroupErrorKind int

+ const CreateBindGroupErrorHAL

+ const CreateBindGroupErrorMissingLayout

+ type CreateBindGroupLayoutError struct

+ BindingCount uint32

+ DuplicateBinding uint32

+ HALError error

+ Kind CreateBindGroupLayoutErrorKind

+ Label string

+ MaxBindings uint32

+ func (e *CreateBindGroupLayoutError) Error() string

+ func (e *CreateBindGroupLayoutError) Unwrap() error

+ type CreateBindGroupLayoutErrorKind int

+ const CreateBindGroupLayoutErrorDuplicateBinding

+ const CreateBindGroupLayoutErrorHAL

+ const CreateBindGroupLayoutErrorTooManyBindings

+ type CreateComputePipelineError struct

+ HALError error

+ Kind CreateComputePipelineErrorKind

+ Label string

+ func (e *CreateComputePipelineError) Error() string

+ func (e *CreateComputePipelineError) Unwrap() error

+ type CreateComputePipelineErrorKind int

+ const CreateComputePipelineErrorHAL

+ const CreateComputePipelineErrorMissingEntryPoint

+ const CreateComputePipelineErrorMissingModule

+ type CreateRenderPipelineError struct

+ HALError error

+ Kind CreateRenderPipelineErrorKind

+ Label string

+ MaxTargets uint32

+ SampleCount uint32

+ TargetCount uint32

+ func (e *CreateRenderPipelineError) Error() string

+ func (e *CreateRenderPipelineError) Unwrap() error

+ type CreateRenderPipelineErrorKind int

+ const CreateRenderPipelineErrorHAL

+ const CreateRenderPipelineErrorInvalidSampleCount

+ const CreateRenderPipelineErrorMissingFragmentEntryPoint

+ const CreateRenderPipelineErrorMissingFragmentModule

+ const CreateRenderPipelineErrorMissingVertexEntryPoint

+ const CreateRenderPipelineErrorMissingVertexModule

+ const CreateRenderPipelineErrorNoFragmentTargets

+ const CreateRenderPipelineErrorTooManyColorTargets

+ type CreateSamplerError struct

+ Anisotropy uint16

+ HALError error

+ Kind CreateSamplerErrorKind

+ Label string

+ LodMaxClamp float32

+ LodMinClamp float32

+ func (e *CreateSamplerError) Error() string

+ func (e *CreateSamplerError) Unwrap() error

+ type CreateSamplerErrorKind int

+ const CreateSamplerErrorAnisotropyRequiresLinearFiltering

+ const CreateSamplerErrorHAL

+ const CreateSamplerErrorInvalidAnisotropy

+ const CreateSamplerErrorInvalidLodMaxClamp

+ const CreateSamplerErrorInvalidLodMinClamp

+ type CreateShaderModuleError struct

+ HALError error

+ Kind CreateShaderModuleErrorKind

+ Label string

+ func (e *CreateShaderModuleError) Error() string

+ func (e *CreateShaderModuleError) Unwrap() error

+ type CreateShaderModuleErrorKind int

+ const CreateShaderModuleErrorDualSource

+ const CreateShaderModuleErrorHAL

+ const CreateShaderModuleErrorNoSource

+ type CreateTextureError struct

+ HALError error

+ Kind CreateTextureErrorKind

+ Label string

+ MaxDimension uint32

+ MaxMips uint32

+ RequestedDepth uint32

+ RequestedHeight uint32

+ RequestedMips uint32

+ RequestedSamples uint32

+ RequestedWidth uint32

+ func (e *CreateTextureError) Error() string

+ func (e *CreateTextureError) Unwrap() error

+ type CreateTextureErrorKind int

+ const CreateTextureErrorEmptyUsage

+ const CreateTextureErrorHAL

+ const CreateTextureErrorInvalidDimension

+ const CreateTextureErrorInvalidFormat

+ const CreateTextureErrorInvalidMipLevelCount

+ const CreateTextureErrorInvalidSampleCount

+ const CreateTextureErrorInvalidUsage

+ const CreateTextureErrorMaxArrayLayers

+ const CreateTextureErrorMaxDimension

+ const CreateTextureErrorMultisampleArrayLayers

+ const CreateTextureErrorMultisampleDimension

+ const CreateTextureErrorMultisampleMipLevel

+ const CreateTextureErrorMultisampleStorageBinding

+ const CreateTextureErrorZeroDimension

Feb 27, 2026

Changes in this version

type CoreCommandEncoder

+ func (e *CoreCommandEncoder) RawEncoder() hal.CommandEncoder

type CoreComputePassEncoder

+ func (p *CoreComputePassEncoder) RawPass() hal.ComputePassEncoder

type CoreRenderPassEncoder

+ func (p *CoreRenderPassEncoder) RawPass() hal.RenderPassEncoder

type Instance

+ func (i *Instance) HALInstance() hal.Instance

type TextureView

+ HAL hal.TextureView

Feb 9, 2026

Changes in this version

+ func DebugMode() bool

+ func ResetLeakTracker()

+ func SetDebugMode(enabled bool)

type Device

+ func (d *Device) PopErrorScope() *GPUError

+ func (d *Device) PushErrorScope(filter ErrorFilter)

+ type ErrorFilter int

+ const ErrorFilterInternal

+ const ErrorFilterOutOfMemory

+ const ErrorFilterValidation

+ func (f ErrorFilter) String() string

+ type ErrorScopeManager struct

+ func NewErrorScopeManager() *ErrorScopeManager

+ func (m *ErrorScopeManager) PopErrorScope() (*GPUError, error)

+ func (m *ErrorScopeManager) PushErrorScope(filter ErrorFilter)

+ func (m *ErrorScopeManager) ReportError(filter ErrorFilter, message string) bool

+ func (m *ErrorScopeManager) ScopeDepth() int

+ type GPUError struct

+ Message string

+ Type ErrorFilter

+ func (e *GPUError) Error() string

+ type LeakReport struct

+ Count int

+ Types map[string]int

+ func ReportLeaks() *LeakReport

+ func (r *LeakReport) String() string

Jan 15, 2026

Changes in this version

+ func AvailableBackendProviders() []types.Backend

+ func RegisterBackendProvider(provider BackendProvider)

+ func RegisterHALBackends()

type Adapter

+ func (a *Adapter) Capabilities() *hal.Capabilities

+ func (a *Adapter) HALAdapter() hal.Adapter

+ func (a *Adapter) HasHAL() bool

+ type BackendProvider interface

+ CreateInstance func(desc *hal.InstanceDescriptor) (hal.Instance, error)

+ IsAvailable func() bool

+ Variant func() types.Backend

+ func FilterBackendsByMask(mask types.Backends) []BackendProvider

+ func GetBackendProvider(variant types.Backend) (BackendProvider, bool)

+ func GetOrderedBackendProviders() []BackendProvider

+ func SelectBestBackendProvider() BackendProvider

type Instance

+ func NewInstanceWithMock(desc *types.InstanceDescriptor) *Instance

+ func (i *Instance) Destroy()

+ func (i *Instance) HasHALAdapters() bool

+ func (i *Instance) IsMock() bool

Jan 4, 2026

Changes in this version

+ var ErrDeviceDestroyed = errors.New("device destroyed")

+ var ErrDeviceLost = errors.New("device lost")

+ var ErrResourceDestroyed = errors.New("resource destroyed")

+ func IsCreateBufferError(err error) bool

+ func IsCreateCommandEncoderError(err error) bool

+ func IsEncoderStateError(err error) bool

type Buffer

+ func NewBuffer(halBuffer hal.Buffer, device *Device, usage types.BufferUsage, size uint64, ...) *Buffer

+ func (b *Buffer) Destroy()

+ func (b *Buffer) Device() *Device

+ func (b *Buffer) HasHAL() bool

+ func (b *Buffer) IsDestroyed() bool

+ func (b *Buffer) IsInitialized(offset, size uint64) bool

+ func (b *Buffer) Label() string

+ func (b *Buffer) MapState() BufferMapState

+ func (b *Buffer) MarkInitialized(offset, size uint64)

+ func (b *Buffer) Raw(guard *SnatchGuard) hal.Buffer

+ func (b *Buffer) SetMapState(state BufferMapState)

+ func (b *Buffer) Size() uint64

+ func (b *Buffer) TrackingData() *TrackingData

+ func (b *Buffer) Usage() types.BufferUsage

+ type BufferInitTracker struct

+ func NewBufferInitTracker(size uint64) *BufferInitTracker

+ func (t *BufferInitTracker) IsInitialized(offset, size uint64) bool

+ func (t *BufferInitTracker) MarkInitialized(offset, size uint64)

+ type BufferMapState int

+ const BufferMapStateIdle

+ const BufferMapStateMapped

+ const BufferMapStatePending

+ type BufferUses uint32

+ const BufferUsesCopyDst

+ const BufferUsesCopySrc

+ const BufferUsesIndex

+ const BufferUsesIndirect

+ const BufferUsesNone

+ const BufferUsesStorage

+ const BufferUsesUniform

+ const BufferUsesVertex

+ type CommandBufferMutable struct

+ type CommandEncoderStatus int32

+ const CommandEncoderStatusConsumed

+ const CommandEncoderStatusError

+ const CommandEncoderStatusFinished

+ const CommandEncoderStatusLocked

+ const CommandEncoderStatusRecording

+ func (s CommandEncoderStatus) String() string

+ type CoreCommandBuffer struct

+ func (cb *CoreCommandBuffer) Device() *Device

+ func (cb *CoreCommandBuffer) Label() string

+ func (cb *CoreCommandBuffer) Raw() hal.CommandBuffer

+ type CoreCommandEncoder struct

+ func (e *CoreCommandEncoder) BeginComputePass(desc *CoreComputePassDescriptor) (*CoreComputePassEncoder, error)

+ func (e *CoreCommandEncoder) BeginRenderPass(desc *RenderPassDescriptor) (*CoreRenderPassEncoder, error)

+ func (e *CoreCommandEncoder) Device() *Device

+ func (e *CoreCommandEncoder) EndComputePass(pass *CoreComputePassEncoder) error

+ func (e *CoreCommandEncoder) EndRenderPass(pass *CoreRenderPassEncoder) error

+ func (e *CoreCommandEncoder) Error() error

+ func (e *CoreCommandEncoder) Finish() (*CoreCommandBuffer, error)

+ func (e *CoreCommandEncoder) Label() string

+ func (e *CoreCommandEncoder) MarkConsumed()

+ func (e *CoreCommandEncoder) Status() CommandEncoderStatus

+ type CoreComputePassDescriptor struct

+ Label string

+ type CoreComputePassEncoder struct

+ func (p *CoreComputePassEncoder) Dispatch(x, y, z uint32)

+ func (p *CoreComputePassEncoder) DispatchIndirect(buffer *Buffer, offset uint64)

+ func (p *CoreComputePassEncoder) End() error

+ func (p *CoreComputePassEncoder) SetPipeline(pipeline *ComputePipeline)

+ type CoreRenderPassEncoder struct

+ func (p *CoreRenderPassEncoder) Draw(vertexCount, instanceCount, firstVertex, firstInstance uint32)

+ func (p *CoreRenderPassEncoder) DrawIndexed(indexCount, instanceCount, firstIndex uint32, baseVertex int32, ...)

+ func (p *CoreRenderPassEncoder) DrawIndexedIndirect(buffer *Buffer, offset uint64)

+ func (p *CoreRenderPassEncoder) DrawIndirect(buffer *Buffer, offset uint64)

+ func (p *CoreRenderPassEncoder) End() error

+ func (p *CoreRenderPassEncoder) SetBlendConstant(color *types.Color)

+ func (p *CoreRenderPassEncoder) SetIndexBuffer(buffer *Buffer, format types.IndexFormat, offset uint64)

+ func (p *CoreRenderPassEncoder) SetPipeline(pipeline *RenderPipeline)

+ func (p *CoreRenderPassEncoder) SetScissorRect(x, y, width, height uint32)

+ func (p *CoreRenderPassEncoder) SetStencilReference(reference uint32)

+ func (p *CoreRenderPassEncoder) SetVertexBuffer(slot uint32, buffer *Buffer, offset uint64)

+ func (p *CoreRenderPassEncoder) SetViewport(x, y, width, height, minDepth, maxDepth float32)

+ type CreateBufferError struct

+ HALError error

+ Kind CreateBufferErrorKind

+ Label string

+ MaxSize uint64

+ RequestedSize uint64

+ func (e *CreateBufferError) Error() string

+ func (e *CreateBufferError) Unwrap() error

+ type CreateBufferErrorKind int

+ const CreateBufferErrorEmptyUsage

+ const CreateBufferErrorHAL

+ const CreateBufferErrorInvalidUsage

+ const CreateBufferErrorMapReadWriteExclusive

+ const CreateBufferErrorMaxBufferSize

+ const CreateBufferErrorZeroSize

+ type CreateCommandEncoderError struct

+ HALError error

+ Kind CreateCommandEncoderErrorKind

+ Label string

+ func (e *CreateCommandEncoderError) Error() string

+ func (e *CreateCommandEncoderError) Unwrap() error

+ type CreateCommandEncoderErrorKind int

+ const CreateCommandEncoderErrorHAL

type Device

+ func NewDevice(halDevice hal.Device, adapter *Adapter, features types.Features, ...) *Device

+ func (d *Device) AssociatedQueue() *Queue

+ func (d *Device) CreateBuffer(desc *types.BufferDescriptor) (*Buffer, error)

+ func (d *Device) CreateCommandEncoder(label string) (*CoreCommandEncoder, error)

+ func (d *Device) Destroy()

+ func (d *Device) HasHAL() bool

+ func (d *Device) IsValid() bool

+ func (d *Device) ParentAdapter() *Adapter

+ func (d *Device) Raw(guard *SnatchGuard) hal.Device

+ func (d *Device) SetAssociatedQueue(queue *Queue)

+ func (d *Device) SnatchLock() *SnatchLock

+ func (d *Device) TrackerIndices() *TrackerIndexAllocators

+ type EncoderStateError struct

+ Operation string

+ Status CommandEncoderStatus

+ func (e *EncoderStateError) Error() string

+ type ExclusiveSnatchGuard struct

+ func (g *ExclusiveSnatchGuard) Release()

+ type RenderPassColorAttachment struct

+ ClearValue types.Color

+ LoadOp types.LoadOp

+ ResolveTarget *TextureView

+ StoreOp types.StoreOp

+ View *TextureView

+ type RenderPassDepthStencilAttachment struct

+ DepthClearValue float32

+ DepthLoadOp types.LoadOp

+ DepthReadOnly bool

+ DepthStoreOp types.StoreOp

+ StencilClearValue uint32

+ StencilLoadOp types.LoadOp

+ StencilReadOnly bool

+ StencilStoreOp types.StoreOp

+ View *TextureView

+ type RenderPassDescriptor struct

+ ColorAttachments []RenderPassColorAttachment

+ DepthStencilAttachment *RenderPassDepthStencilAttachment

+ Label string

+ type SnatchGuard struct

+ func (g *SnatchGuard) Release()

+ type SnatchLock struct

+ func NewSnatchLock() *SnatchLock

+ func (l *SnatchLock) Read() *SnatchGuard

+ func (l *SnatchLock) Write() *ExclusiveSnatchGuard

+ type Snatchable struct

+ func NewSnatchable[T any](value T) *Snatchable[T]

+ func (s *Snatchable[T]) Get(_ *SnatchGuard) *T

+ func (s *Snatchable[T]) IsSnatched() bool

+ func (s *Snatchable[T]) Snatch(_ *ExclusiveSnatchGuard) *T

+ type TextureUses uint32

+ const TextureUsesCopyDst

+ const TextureUsesCopySrc

+ const TextureUsesNone

+ const TextureUsesRenderAttachment

+ const TextureUsesSampled

+ const TextureUsesStorage

+ type TrackerIndex uint32

+ const InvalidTrackerIndex

+ type TrackerIndexAllocators struct

+ func NewTrackerIndexAllocators() *TrackerIndexAllocators

+ type TrackingData struct

+ func NewTrackingData(_ *TrackerIndexAllocators) *TrackingData

+ func (t *TrackingData) Index() TrackerIndex

Dec 28, 2025

Changes in this version

+ func DeviceDestroyComputePipeline(pipelineID ComputePipelineID) error

type CommandBufferID

+ func CommandEncoderFinish(id CommandEncoderID) (CommandBufferID, error)

type CommandEncoderID

+ func DeviceCreateCommandEncoder(id DeviceID, label string) (CommandEncoderID, error)

+ type CommandEncoderImpl struct

+ func (e *CommandEncoderImpl) BeginComputePass(desc *ComputePassDescriptor) (*ComputePassEncoder, error)

+ type CommandEncoderState int

+ const CommandEncoderStateEnded

+ const CommandEncoderStateError

+ const CommandEncoderStateRecording

+ type ComputePassDescriptor struct

+ Label string

+ TimestampWrites *ComputePassTimestampWrites

+ type ComputePassEncoder struct

+ func (e *ComputePassEncoder) Dispatch(x, y, z uint32)

+ func (e *ComputePassEncoder) DispatchIndirect(buffer BufferID, offset uint64) error

+ func (e *ComputePassEncoder) End()

+ func (e *ComputePassEncoder) SetBindGroup(index uint32, group BindGroupID, offsets []uint32) error

+ func (e *ComputePassEncoder) SetPipeline(pipeline ComputePipelineID) error

+ type ComputePassTimestampWrites struct

+ BeginningOfPassWriteIndex *uint32

+ EndOfPassWriteIndex *uint32

+ QuerySet QuerySetID

type ComputePipeline

+ func GetComputePipeline(id ComputePipelineID) (*ComputePipeline, error)

+ type ComputePipelineDescriptor struct

+ Compute ProgrammableStage

+ Label string

+ Layout PipelineLayoutID

type ComputePipelineID

+ func DeviceCreateComputePipeline(deviceID DeviceID, desc *ComputePipelineDescriptor) (ComputePipelineID, error)

+ type ProgrammableStage struct

+ Constants map[string]float64

+ EntryPoint string

+ Module ShaderModuleID

Dec 9, 2025

Changes in this version

+ var ErrAlreadyDestroyed = errors.New("resource already destroyed")

+ var ErrEpochMismatch = errors.New("epoch mismatch: resource was recycled")

+ var ErrInvalidID = errors.New("invalid resource ID")

+ var ErrRegistryFull = errors.New("registry full: maximum resources reached")

+ var ErrResourceInUse = errors.New("resource is still in use")

+ var ErrResourceNotFound = errors.New("resource not found")

+ func AdapterDrop(id AdapterID) error

+ func DeviceDrop(id DeviceID) error

+ func GetAdapterFeatures(id AdapterID) (types.Features, error)

+ func GetAdapterInfo(id AdapterID) (types.AdapterInfo, error)

+ func GetAdapterLimits(id AdapterID) (types.Limits, error)

+ func GetDeviceFeatures(id DeviceID) (types.Features, error)

+ func GetDeviceLimits(id DeviceID) (types.Limits, error)

+ func IsFeatureError(err error) bool

+ func IsIDError(err error) bool

+ func IsLimitError(err error) bool

+ func IsValidationError(err error) bool

+ func QueueOnSubmittedWorkDone(id QueueID) error

+ func QueueSubmit(id QueueID, commandBuffers []CommandBufferID) error

+ func QueueWriteBuffer(id QueueID, buffer BufferID, offset uint64, data []byte) error

+ func QueueWriteTexture(id QueueID, dst *types.ImageCopyTexture, data []byte, ...) error

+ func ResetGlobal()

+ type Adapter struct

+ Backend types.Backend

+ Features types.Features

+ Info types.AdapterInfo

+ Limits types.Limits

+ type AdapterID = ID[adapterMarker]

+ type BindGroup struct

+ type BindGroupID = ID[bindGroupMarker]

+ type BindGroupLayout struct

+ type BindGroupLayoutID = ID[bindGroupLayoutMarker]

+ type Buffer struct

+ type BufferID = ID[bufferMarker]

+ func DeviceCreateBuffer(id DeviceID, desc *types.BufferDescriptor) (BufferID, error)

+ type CommandBuffer struct

+ type CommandBufferID = ID[commandBufferMarker]

+ type CommandEncoder struct

+ type CommandEncoderID = ID[commandEncoderMarker]

+ type ComputePipeline struct

+ type ComputePipelineID = ID[computePipelineMarker]

+ type Device struct

+ Adapter AdapterID

+ Features types.Features

+ Label string

+ Limits types.Limits

+ Queue QueueID

+ func GetDevice(id DeviceID) (*Device, error)

+ type DeviceID = ID[deviceMarker]

+ func CreateDevice(adapterID AdapterID, desc *types.DeviceDescriptor) (DeviceID, error)

+ func RequestDevice(adapterID AdapterID, desc *types.DeviceDescriptor) (DeviceID, error)

+ type Epoch = uint32

+ type FeatureError struct

+ Feature string

+ Resource string

+ func NewFeatureError(resource, feature string) *FeatureError

+ func (e *FeatureError) Error() string

+ type Global struct

+ func GetGlobal() *Global

+ func (g *Global) Clear()

+ func (g *Global) GetSurface(id SurfaceID) (Surface, error)

+ func (g *Global) Hub() *Hub

+ func (g *Global) RegisterSurface(surface Surface) SurfaceID

+ func (g *Global) Stats() map[string]uint64

+ func (g *Global) SurfaceCount() uint64

+ func (g *Global) UnregisterSurface(id SurfaceID) (Surface, error)

+ type Hub struct

+ func NewHub() *Hub

+ func (h *Hub) Clear()

+ func (h *Hub) GetAdapter(id AdapterID) (Adapter, error)

+ func (h *Hub) GetBindGroup(id BindGroupID) (BindGroup, error)

+ func (h *Hub) GetBindGroupLayout(id BindGroupLayoutID) (BindGroupLayout, error)

+ func (h *Hub) GetBuffer(id BufferID) (Buffer, error)

+ func (h *Hub) GetCommandBuffer(id CommandBufferID) (CommandBuffer, error)

+ func (h *Hub) GetCommandEncoder(id CommandEncoderID) (CommandEncoder, error)

+ func (h *Hub) GetComputePipeline(id ComputePipelineID) (ComputePipeline, error)

+ func (h *Hub) GetDevice(id DeviceID) (Device, error)

+ func (h *Hub) GetPipelineLayout(id PipelineLayoutID) (PipelineLayout, error)

+ func (h *Hub) GetQuerySet(id QuerySetID) (QuerySet, error)

+ func (h *Hub) GetQueue(id QueueID) (Queue, error)

+ func (h *Hub) GetRenderPipeline(id RenderPipelineID) (RenderPipeline, error)

+ func (h *Hub) GetSampler(id SamplerID) (Sampler, error)

+ func (h *Hub) GetShaderModule(id ShaderModuleID) (ShaderModule, error)

+ func (h *Hub) GetTexture(id TextureID) (Texture, error)

+ func (h *Hub) GetTextureView(id TextureViewID) (TextureView, error)

+ func (h *Hub) RegisterAdapter(adapter *Adapter) AdapterID

+ func (h *Hub) RegisterBindGroup(group BindGroup) BindGroupID

+ func (h *Hub) RegisterBindGroupLayout(layout BindGroupLayout) BindGroupLayoutID

+ func (h *Hub) RegisterBuffer(buffer Buffer) BufferID

+ func (h *Hub) RegisterCommandBuffer(buffer CommandBuffer) CommandBufferID

+ func (h *Hub) RegisterCommandEncoder(encoder CommandEncoder) CommandEncoderID

+ func (h *Hub) RegisterComputePipeline(pipeline ComputePipeline) ComputePipelineID

+ func (h *Hub) RegisterDevice(device Device) DeviceID

+ func (h *Hub) RegisterPipelineLayout(layout PipelineLayout) PipelineLayoutID

+ func (h *Hub) RegisterQuerySet(querySet QuerySet) QuerySetID

+ func (h *Hub) RegisterQueue(queue Queue) QueueID

+ func (h *Hub) RegisterRenderPipeline(pipeline RenderPipeline) RenderPipelineID

+ func (h *Hub) RegisterSampler(sampler Sampler) SamplerID

+ func (h *Hub) RegisterShaderModule(module ShaderModule) ShaderModuleID

+ func (h *Hub) RegisterTexture(texture Texture) TextureID

+ func (h *Hub) RegisterTextureView(view TextureView) TextureViewID

+ func (h *Hub) ResourceCounts() map[string]uint64

+ func (h *Hub) UnregisterAdapter(id AdapterID) (Adapter, error)

+ func (h *Hub) UnregisterBindGroup(id BindGroupID) (BindGroup, error)

+ func (h *Hub) UnregisterBindGroupLayout(id BindGroupLayoutID) (BindGroupLayout, error)

+ func (h *Hub) UnregisterBuffer(id BufferID) (Buffer, error)

+ func (h *Hub) UnregisterCommandBuffer(id CommandBufferID) (CommandBuffer, error)

+ func (h *Hub) UnregisterCommandEncoder(id CommandEncoderID) (CommandEncoder, error)

+ func (h *Hub) UnregisterComputePipeline(id ComputePipelineID) (ComputePipeline, error)

+ func (h *Hub) UnregisterDevice(id DeviceID) (Device, error)

+ func (h *Hub) UnregisterPipelineLayout(id PipelineLayoutID) (PipelineLayout, error)

+ func (h *Hub) UnregisterQuerySet(id QuerySetID) (QuerySet, error)

+ func (h *Hub) UnregisterQueue(id QueueID) (Queue, error)

+ func (h *Hub) UnregisterRenderPipeline(id RenderPipelineID) (RenderPipeline, error)

+ func (h *Hub) UnregisterSampler(id SamplerID) (Sampler, error)

+ func (h *Hub) UnregisterShaderModule(id ShaderModuleID) (ShaderModule, error)

+ func (h *Hub) UnregisterTexture(id TextureID) (Texture, error)

+ func (h *Hub) UnregisterTextureView(id TextureViewID) (TextureView, error)

+ func (h *Hub) UpdateQueue(id QueueID, queue Queue) error

+ type ID struct

+ func FromRaw[T Marker](raw RawID) ID[T]

+ func NewID[T Marker](index Index, epoch Epoch) ID[T]

+ func (id ID[T]) Epoch() Epoch

+ func (id ID[T]) Index() Index

+ func (id ID[T]) IsZero() bool

+ func (id ID[T]) Raw() RawID

+ func (id ID[T]) String() string

+ func (id ID[T]) Unzip() (Index, Epoch)

+ type IDError struct

+ Cause error

+ ID RawID

+ Message string

+ func NewIDError(id RawID, message string, cause error) *IDError

+ func (e *IDError) Error() string

+ func (e *IDError) Unwrap() error

+ type IdentityManager struct

+ func NewIdentityManager[T Marker]() *IdentityManager[T]

+ func (m *IdentityManager[T]) Alloc() ID[T]

+ func (m *IdentityManager[T]) Count() uint64

+ func (m *IdentityManager[T]) FreeCount() int

+ func (m *IdentityManager[T]) NextIndex() Index

+ func (m *IdentityManager[T]) Release(id ID[T])

+ type Index = uint32

+ type Instance struct

+ func NewInstance(desc *types.InstanceDescriptor) *Instance

+ func (i *Instance) Backends() types.Backends

+ func (i *Instance) EnumerateAdapters() []AdapterID

+ func (i *Instance) Flags() types.InstanceFlags

+ func (i *Instance) RequestAdapter(options *types.RequestAdapterOptions) (AdapterID, error)

+ type LimitError struct

+ Actual uint64

+ Limit string

+ Maximum uint64

+ Resource string

+ func NewLimitError(resource, limit string, actual, maximum uint64) *LimitError

+ func (e *LimitError) Error() string

+ type Marker interface

+ type PipelineLayout struct

+ type PipelineLayoutID = ID[pipelineLayoutMarker]

+ type QuerySet struct

+ type QuerySetID = ID[querySetMarker]

+ type Queue struct

+ Device DeviceID

+ Label string

+ func GetQueue(id QueueID) (*Queue, error)

+ type QueueID = ID[queueMarker]

+ func GetDeviceQueue(id DeviceID) (QueueID, error)

+ type RawID uint64

+ func Zip(index Index, epoch Epoch) RawID

+ func (id RawID) Epoch() Epoch

+ func (id RawID) Index() Index

+ func (id RawID) IsZero() bool

+ func (id RawID) String() string

+ func (id RawID) Unzip() (Index, Epoch)

+ type Registry struct

+ func NewRegistry[T any, M Marker]() *Registry[T, M]

+ func (r *Registry[T, M]) Clear()

+ func (r *Registry[T, M]) Contains(id ID[M]) bool

+ func (r *Registry[T, M]) Count() uint64

+ func (r *Registry[T, M]) ForEach(fn func(ID[M], T) bool)

+ func (r *Registry[T, M]) Get(id ID[M]) (T, error)

+ func (r *Registry[T, M]) GetMut(id ID[M], fn func(*T)) error

+ func (r *Registry[T, M]) Register(item T) ID[M]

+ func (r *Registry[T, M]) Unregister(id ID[M]) (T, error)

+ type RenderPipeline struct

+ type RenderPipelineID = ID[renderPipelineMarker]

+ type Sampler struct

+ type SamplerID = ID[samplerMarker]

+ type ShaderModule struct

+ type ShaderModuleID = ID[shaderModuleMarker]

+ func DeviceCreateShaderModule(id DeviceID, desc *types.ShaderModuleDescriptor) (ShaderModuleID, error)

+ type Storage struct

+ func NewStorage[T any, M Marker](capacity int) *Storage[T, M]

+ func (s *Storage[T, M]) Capacity() int

+ func (s *Storage[T, M]) Clear()

+ func (s *Storage[T, M]) Contains(id ID[M]) bool

+ func (s *Storage[T, M]) ForEach(fn func(ID[M], T) bool)

+ func (s *Storage[T, M]) Get(id ID[M]) (T, bool)

+ func (s *Storage[T, M]) GetMut(id ID[M], fn func(*T)) bool

+ func (s *Storage[T, M]) Insert(id ID[M], item T)

+ func (s *Storage[T, M]) Len() int

+ func (s *Storage[T, M]) Remove(id ID[M]) (T, bool)

+ type StorageItem interface

+ type Surface struct

+ type SurfaceID = ID[surfaceMarker]

+ type Texture struct

+ type TextureID = ID[textureMarker]

+ func DeviceCreateTexture(id DeviceID, desc *types.TextureDescriptor) (TextureID, error)

+ type TextureView struct

+ type TextureViewID = ID[textureViewMarker]

+ type ValidationError struct

+ Cause error

+ Field string

+ Message string

+ Resource string

+ func NewValidationError(resource, field, message string) *ValidationError

+ func NewValidationErrorf(resource, field, format string, args ...any) *ValidationError

+ func (e *ValidationError) Error() string

+ func (e *ValidationError) Unwrap() error