Enum WebGpuInitError 

pub enum WebGpuInitError {
    NavigatorLookup(JsValue),
    NavigatorGpuMissing,
    RequestAdapterLookup(JsValue),
    RequestAdapterCall(JsValue),
    AdapterPromise(JsValue),
    AdapterUnavailable,
    RequestDeviceLookup(JsValue),
    RequestDeviceCall(JsValue),
    DevicePromise(JsValue),
    DeviceUnavailable,
    CanvasNotFound(String),
    CanvasQuery(JsValue),
    CanvasContextUnavailable,
    PreferredFormatLookup(JsValue),
    PreferredFormatCall(JsValue),
    PreferredFormatType(JsValue),
    ConfigureLookup(JsValue),
    QueueLookup(JsValue),
}

Errors that can occur while asynchronously initializing a WebGpuRenderer.

Each variant maps to one specific failure mode that the WebGPU init pipeline can encounter when calling into the browser’s GPU API. The underlying JS error (when available) is carried as a JsValue so callers can surface the exact diagnostic string without losing fidelity.

Instead of logging diagnostics inside the engine, WebGpuRenderer::init returns Result<WebGpuRenderer, WebGpuInitError> and lets the caller decide how to react — typically via Console::error on the example side or by falling back to the Canvas 2D backend.

Variants

NavigatorLookup(JsValue)

Reflect::get(navigator, "webgpu") threw an exception.

Surfaced when the JavaScript binding lookup itself fails rather than simply returning undefined/null. Carries the original JS error.

NavigatorGpuMissing

navigator.gpu is undefined or null.

The browser does not expose WebGPU on the current origin. The most common causes are serving over an insecure origin (must be HTTPS or localhost) or running in a browser that lacks the WebGPU feature.

RequestAdapterLookup(JsValue)

Reflect::get(gpu, "requestAdapter") threw an exception.

Carries the original JS error returned by the reflect call.

RequestAdapterCall(JsValue)

gpu.requestAdapter() threw an exception synchronously.

Carries the thrown JS error or value.

AdapterPromise(JsValue)

The adapter promise rejected, or the INIT_PROMISE_TIMEOUT_MILLIS race timer fired before the adapter was produced.

Carries the rejection value, which may be a string, an error object, or undefined when the timeout won the race.

AdapterUnavailable

requestAdapter() resolved to null or undefined.

No compatible GPU adapter exists for the requested powerPreference.

RequestDeviceLookup(JsValue)

Reflect::get(adapter, "requestDevice") threw an exception.

RequestDeviceCall(JsValue)

adapter.requestDevice() threw an exception synchronously.

DevicePromise(JsValue)

The device promise rejected, or the INIT_PROMISE_TIMEOUT_MILLIS race timer fired before the device was produced.

DeviceUnavailable

requestDevice() resolved to null or undefined.

The adapter could not allocate a device, typically because the adapter is in a device-lost state.

CanvasNotFound(String)

document.querySelector(canvas_selector) returned None.

The canvas element is not in the DOM yet (or its selector is wrong). Carries the selector string that was queried.

CanvasQuery(JsValue)

document.querySelector(canvas_selector) threw an exception.

CanvasContextUnavailable

canvas.get_context("webgpu") returned None.

The canvas is already using a different context type, or WebGPU is disabled for this canvas.

PreferredFormatLookup(JsValue)

Reflect::get(gpu, "getPreferredCanvasFormat") threw an exception.

PreferredFormatCall(JsValue)

gpu.getPreferredCanvasFormat() threw an exception synchronously.

PreferredFormatType(JsValue)

getPreferredCanvasFormat() resolved to a value that is not a string.

Carries the offending JS value so callers can log its type/name.

ConfigureLookup(JsValue)

Reflect::get(context, "configure") threw an exception.

QueueLookup(JsValue)

Reflect::get(device, "queue") threw an exception.

Implementations

impl WebGpuInitError

Implements helper methods on WebGpuInitError.

These methods provide ergonomic access to the diagnostic code and the underlying JS error value, which are useful when surfacing the failure to the user (e.g. via Console::error from the example crate).

pub fn code(&self) -> &'static str

Returns a short, machine-readable identifier for this error variant.

Suitable for use as a stable error code in logs or telemetry. The codes are stable across releases.

Returns

• &'static str - The error code (e.g. "WEBGPU_NAVIGATOR_GPU_MISSING").

pub fn js_error(&self) -> Option<&JsValue>

Returns the underlying JS error value if this variant carries one.

Variants that do not capture a JS value (e.g. NavigatorGpuMissing, AdapterUnavailable, CanvasNotFound, CanvasContextUnavailable) return None.

Returns

• Option<&JsValue> - The captured JS error, if any.

Trait Implementations

impl Clone for WebGpuInitError

fn clone(&self) -> WebGpuInitError

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for WebGpuInitError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for WebGpuInitError

Implements std::fmt::Display for WebGpuInitError.

The formatted message is intended for end-user diagnostic output (typically forwarded to Console::error by the calling application) and includes the variant code plus a human-readable description. When the variant carries a JS error, its Debug form is appended.

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Error for WebGpuInitError

Implements the standard std::error::Error trait for WebGpuInitError.

The source() method delegates to the underlying JS error’s toString() representation when present, otherwise returns None. The engine never logs or prints anything; this impl exists solely so the error composes with Result-based APIs and ? operator chains.

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.