---
title: @vgpu/wgsl-std/hash
description: Pure WGSL hash utilities for deterministic shader randomness. Import them for integer hashing, multi-output PCG-style lattice hashes, and stable conversion from `u32` hashes to unit floats.
---

# @vgpu/wgsl-std/hash



## Import

```wgsl
import { hash1, hash2, hash3, hashU32, pcg2d, pcg3d, unitFloat } from "@vgpu/wgsl-std/hash";
```

## Signature

```wgsl
export fn hashU32(value: u32) -> u32;
export fn pcg2d(value: vec2u) -> vec2u;
export fn pcg3d(value: vec3u) -> vec3u;
export fn unitFloat(hash: u32) -> f32;
export fn hash1(seed: f32) -> f32;
export fn hash2(seed: vec2f) -> vec2f;
export fn hash3(seed: vec3f) -> vec3f;
```

## Parameters

| Param | Type    | Required | Default | Notes                                                                                                    |
| ----- | ------- | -------- | ------- | -------------------------------------------------------------------------------------------------------- |
| value | `u32`   | ✔        | —       | Input integer for `hashU32`, implemented with Wellons lowbias32 constants.                               |
| value | `vec2u` | ✔        | —       | Two-dimensional unsigned seed for `pcg2d`; returns two decorrelated unsigned outputs.                    |
| value | `vec3u` | ✔        | —       | Three-dimensional unsigned seed for `pcg3d`; returns three decorrelated unsigned outputs.                |
| hash  | `u32`   | ✔        | —       | Hash bits passed to `unitFloat`. The low 8 bits are discarded, then the top 24 bits map to `[0.0, 1.0)`. |
| seed  | `f32`   | ✔        | —       | Float seed for `hash1`; bitcast to `u32` before hashing. `-0.0` and `0.0` hash differently.              |
| seed  | `vec2f` | ✔        | —       | Float vector seed for `hash2`; bitcast to `vec2u`, hashed with `pcg2d`, converted with `unitFloat`.      |
| seed  | `vec3f` | ✔        | —       | Float vector seed for `hash3`; bitcast to `vec3u`, hashed with `pcg3d`, converted with `unitFloat`.      |

**Returns:** `hashU32` returns `u32`; `pcg2d`/`pcg3d` return unsigned vectors; `unitFloat` and `hash1` return `f32` in `[0.0, 1.0)`; `hash2`/`hash3` return float vectors with each component in `[0.0, 1.0)`.

**Throws:** These WGSL declarations do not throw. `resolveShader()` can still throw `VGPU-WGSL-SYM-NOEXPORT` for misspelled imports, `VGPU-WGSL-PKG-NOTFOUND` if the package import cannot be resolved, or validation errors such as `VGPU-WGSL-NAGA-UNKNOWN` if caller WGSL is invalid.

## Examples

```ts
const hashWgsl = `
import { pcg3d, unitFloat } from "@vgpu/wgsl-std/hash";

fn cellRandom(cell: vec3i) -> f32 {
  return unitFloat(pcg3d(bitcast<vec3u>(cell)).x);
}
`;

console.log(hashWgsl.includes("cellRandom"));
```

```ts
const jitterWgsl = `
import { hash2 } from "@vgpu/wgsl-std/hash";

fn jitter(pixel: vec2f) -> vec2f {
  return hash2(pixel) - vec2f(0.5);
}
`;

console.log(jitterWgsl.length > 0);
```

## Notes

* This module is pure WGSL: it declares no `@group`, no `@binding`, no overrides, no hidden state, and no entry points.
* `hashU32` is Wellons lowbias32, not PCG. `pcg2d` and `pcg3d` are multi-output PCG-style vector hashes for lattice coordinates.
* `unitFloat(hash)` computes `f32(hash >> 8u) * (1.0 / 16777216.0)`, so it never returns `1.0`.
* Float wrappers hash raw IEEE bit patterns. Normalize NaNs and signed zero yourself if those values should collide.
* For lattice noise, prefer integer cell coordinates (`vec*i` bitcast to `vec*u`) over sine/fract-style float hashes.
* **See also:** `@vgpu/wgsl-std/noise`, `@vgpu/wgsl-std/color`, `resolveShader`.


---

For a semantic overview of all documentation, see [/sitemap.md](/sitemap.md)

For an index of all available documentation, see [/llms.txt](/llms.txt)

For agent-facing discovery, including API and MCP surfaces, see [/agents.md](/agents.md)