01 Shared field math for 3D worlds · CPU + TSL + optional TypeGPU

The field you draw is the field you can touch.

Let CPU collision, buoyancy, forces, and hit tests query procedural fields that Three.js materializes on the GPU—then measure the remaining float drift instead of asserting equality.

Play the dogfood mission Read the contract

MIT
zero-dependency core
cross-runtime CI
public preview

Live 3D terrain instrument / dunesField sampling…

CPU / f64: —
Assay / f32: —
Absolute drift: —

02 The split-world problem

GPU 3D displacement is invisible to CPU gameplay.

CPU physics, AI, servers, and hit tests cannot sample the vertex shader shaping a 3D world. Copying procedural math into JavaScript and shader code creates two authorities that can drift.

Matter Field makes the pure function authoritative and treats each backend as a materialization of it.

03 One expression tree

Write the field, not its copies.

terrain.jsone field

export function terrain(A, x, z) {
  const n = fbm(A, x, z, 0.0016, 2);
  return A.mul(
    A.sub(n, A.f(0.5)),
    A.f(24)
  );
}

numberAdapter

CPU oracle

Collision, AI, Workers, and Node servers evaluate the authoritative ECMAScript f64 tree.

makeTslAdapter

Native GPU graph

The zero-dependency core accepts the caller’s three/tsl namespace and preserves one adapter-authored tree.

dualAdapter

Analytic gradients

Dual numbers derive normals and tangents from the exact same expression tree.

matter-field/typegpu

TypeGPU materialization

An optional, separately authored WebGPU port is precompiled for TypeGPU and @typegpu/three, then checked against the canonical fields.

04 Touch the contract

One game. Four labs. Consequences you can feel.

FIELDWORK combines the package into one mission. The focused labs isolate each field and its CPU gameplay consumer.

FIELDWORK / dogfood mission

Run the flooded basin

Recover a survey core while dunes, swell, wind, and a moving breach body all affect one amphibious craft.

Play Breach Run 01 / 3D terrain

Drive the 3D dunes

Move across GPU-displaced terrain while the CPU collision oracle samples the same function.

Open live field 02 / 3D water

Steer the hull

One field drives the GPU-rendered swell and its CPU four-point buoyancy response.

Open live field 03 / 3D flow

Push with wind

GPU particles reveal the same vector field applying force to a CPU gameplay body.

Open live field 04 / TSL animation

Probe the moving volume

Freely orbit the animated 3D body while a CPU world ray queries its authored spine and changing radius.

Open live field Lab / your hardware

Measure the 3D field

Run the same TSL graphs used by the 3D demos on WebGPU or WebGL2 and keep the JSON receipt.

Run parity assay TypeGPU / exact artifact

Inspect the port receipt

One clean RTX 3070 WebGPU run records adapter-oracle migration, numeric drift, raw u32 hash agreement, and five Three integration smokes.

Open raw JSON

05 Measured, not asserted

Current hardware receipts

Absolute error in field units decides pass/fail. ULP counts remain diagnostic because they explode near zero crossings.

Recorded parity results by graphics hardware and browser backend
Hardware	Backend	Max observed abs	Max ULP	u32 hash	Status

06 The honest contract

Three contract levels, no stronger.

Tier 1
CPU ↔ CPU
tested bit-exact
One committed golden agrees in browser, Worker, and supported Node CI.
Tier 2
Integer hash
observed bit-exact
Eleven raw u32 vectors agree in the current hardware receipts.
Tier 3
Float tree
measured per field
Restricted f32 operations tested against a declared absolute field-unit budget on each receipt.

07 Open fieldwork

Bring a GPU.
Add a receipt.

The parity claim gets stronger through public measurement, not louder marketing. Run the assay, inspect the JSON, and contribute a missing vendor cell.

Run on this hardware