there is passing then there is accelerating accelerating is what looks through a function tagged with #[gpu_use] and finds invocation of gpu_do!() an

Helps with building a `DeviceFnMutArgs` `ArgsBuilder` helps you build a `DeviceFnMutArgs` by providing references to each `DeviceBox` argument. It's

A trait for creating a `DeviceBox<T>` from a reference to an object `T` It is implemented for all `T` (even unsized) where `T` can be safely serializ

A trait to implement to create your own cache The [`compile`](../compile/fn.compile.html) function is generic over a `Cache` implementation. So you c

An error for compilation failures

The trait to implement when adding support for a new source language (e.g. - HLSL, XLA, Swift SIL, etc.). This trait is generic over the input langua

An error for failure to complete data movement or computation

Represents a single device Since its fields are public, you can easily construct and mutate a `Device`'s WebGPU internals. To get a `Device` from an

A type for [boxing](https://en.wikipedia.org/wiki/Object_type_(object-oriented_programming)#Boxing) stuff stored on a device It is generic over a typ

this is used for storing info about the functions that #[gpu_use] is usually tagged with

this is what is used to generate OpenCL code it implements Syn's Visit traits so that it can visit nodes in Rust AST and generate code it holds code

A simple in-memory LRU cache for up to 32 JIT-ed kernels

TODO in the future, generalize this to other types, not just struct A trait for structures that can exist in both Rust and GLSL

A container that holds information needed for interacting with a GPU using OpenCL. You should really only use this if you intend to drop down to low-

looks through a function for all invocations of given helper functions it will then make sure that those functions have the GPU passed to them and the

this is what we use to modify the return statements we want to modify the return statements so that they return the GPU

A trait for creating a `DeviceBox<T>` by consuming an object `T` It is implemented for all `T` that is sized as well as iterators over `T` (for itera

An error for when there is no device to complete a certain operation

represents a parameter of a kernel every time someone does gpu_do!(launch()), we try to launch a kernel by using the next for loop we find the parame

An error that occurs when you attempt to initialize an already initialized pool of devices

A runtime error that occurs on the device

A "builder" for a space of threads that are to be spawned See [`spawn`](fn.spawn.html) for more details.

A builder for constructing a [`Spirv`](struct.Spirv.html) You can use it in the case where you are starting from either `u8` bytes or 4-byte `u32` wo

A SPIR-V-to-SPIR-V compiler! Yeah, this doesn't really do anything. But it _does_ implement `CompileToSpirv` so it _is_ what you should use as the ty

Either a finished `DeviceFnMut` or compiled SPIR-V You can either call `finish` on this to get your final compiled `DeviceFnMut` or you can inspect/m

An error when a device is there but not available for use