nx

The nx namespace — 131 functions.

globals/nx/add

nx.add(dst: NxBuffer, x: NxScalarOrBuffer) -> boolean

b[i] += x (x scalar) or b[i] += x[i] (x buffer). Dispatches on type(x). For interleaved-stride writes use nx.addStrided.

Parameters

• dst NxBuffer — Target buffer (mutated).
• x NxScalarOrBuffer — Either a scalar or a same-shaped buffer.

Returns boolean — true on success, false on type / handle errors.

nx.add(b, 1.5)
nx.add(dst, src)

globals/nx/addStrided

nx.addStrided(b: NxBuffer, scalar: number, stride: number, offset: number?) -> boolean

Strided add: buf[k * stride + offset] += scalar for every valid k.

Parameters

• b NxBuffer — Target buffer (mutated).
• scalar number — Per-element addend.
• stride number — Element stride.
• offset number (optional) — Optional element offset (default 0).

Returns boolean — true on success, false on unknown handle.

nx.addStrided(buf, 1.0, 3, 1)

globals/nx/addStridedFrom

nx.addStridedFrom(dst: NxBuffer, src: NxBuffer, scale: number?, dst_stride: number, dst_off: number?, src_stride: number, src_off: number?) -> boolean

Strided BLAS-axpy from src into dst: dst[k * dst_stride + dst_off] += scale * src[k * src_stride + src_off].

Parameters

• dst NxBuffer — Target buffer (mutated).
• src NxBuffer — Source buffer.
• scale number (optional) — Optional src scale factor (default 1.0).
• dst_stride number — Destination element stride.
• dst_off number (optional) — Optional destination offset (default 0).
• src_stride number — Source element stride.
• src_off number (optional) — Optional source offset (default 0).

Returns boolean — true on success, false on shape mismatch / unknown handle.

nx.addStridedFrom(dst, src, 1, 3, 0, 3, 0)

globals/nx/applyAbs

nx.applyAbs(b: NxBuffer) -> boolean

In-place b[i] = abs(b[i]).

Parameters

• b NxBuffer — Target buffer.

Returns boolean — true on success, false on unknown handle.

nx.applyAbs(b)

globals/nx/applyCeil

nx.applyCeil(b: NxBuffer) -> boolean

In-place b[i] = ceil(b[i]).

Parameters

• b NxBuffer — Target buffer.

Returns boolean — true on success, false on unknown handle.

nx.applyCeil(b)

globals/nx/applyCos

nx.applyCos(b: NxBuffer) -> boolean

In-place b[i] = cos(b[i]).

Parameters

• b NxBuffer — Target buffer.

Returns boolean — true on success, false on unknown handle.

nx.applyCos(b)

globals/nx/applyExp

nx.applyExp(b: NxBuffer) -> boolean

In-place b[i] = exp(b[i]).

Parameters

• b NxBuffer — Target buffer.

Returns boolean — true on success, false on unknown handle.

nx.applyExp(b)

globals/nx/applyFloor

nx.applyFloor(b: NxBuffer) -> boolean

In-place b[i] = floor(b[i]).

Parameters

• b NxBuffer — Target buffer.

Returns boolean — true on success, false on unknown handle.

nx.applyFloor(b)

globals/nx/applyFract

nx.applyFract(b: NxBuffer) -> boolean

In-place b[i] = fract(b[i]) (fractional part).

Parameters

• b NxBuffer — Target buffer.

Returns boolean — true on success, false on unknown handle.

nx.applyFract(b)

globals/nx/applyLog

nx.applyLog(b: NxBuffer) -> boolean

In-place b[i] = ln(b[i]).

Parameters

• b NxBuffer — Target buffer.

Returns boolean — true on success, false on unknown handle.

nx.applyLog(b)

globals/nx/applyLog2

nx.applyLog2(b: NxBuffer) -> boolean

In-place b[i] = log2(b[i]).

Parameters

• b NxBuffer — Target buffer.

Returns boolean — true on success, false on unknown handle.

nx.applyLog2(b)

globals/nx/applyNeg

nx.applyNeg(b: NxBuffer) -> boolean

In-place b[i] = -b[i].

Parameters

• b NxBuffer — Target buffer.

Returns boolean — true on success, false on unknown handle.

nx.applyNeg(b)

globals/nx/applyRecip

nx.applyRecip(b: NxBuffer) -> boolean

In-place b[i] = 1 / b[i].

Parameters

• b NxBuffer — Target buffer.

Returns boolean — true on success, false on unknown handle.

nx.applyRecip(b)

globals/nx/applyRecipSqrt

nx.applyRecipSqrt(b: NxBuffer) -> boolean

In-place b[i] = 1 / sqrt(b[i]).

Parameters

• b NxBuffer — Target buffer.

Returns boolean — true on success, false on unknown handle.

nx.applyRecipSqrt(b)

globals/nx/applyRound

nx.applyRound(b: NxBuffer) -> boolean

In-place b[i] = round(b[i]).

Parameters

• b NxBuffer — Target buffer.

Returns boolean — true on success, false on unknown handle.

nx.applyRound(b)

globals/nx/applySign

nx.applySign(b: NxBuffer) -> boolean

In-place b[i] = sign(b[i]) (returns -1, 0, or +1).

Parameters

• b NxBuffer — Target buffer.

Returns boolean — true on success, false on unknown handle.

nx.applySign(b)

globals/nx/applySin

nx.applySin(b: NxBuffer) -> boolean

In-place b[i] = sin(b[i]).

Parameters

• b NxBuffer — Target buffer.

Returns boolean — true on success, false on unknown handle.

nx.applySin(b)

globals/nx/applySqrt

nx.applySqrt(b: NxBuffer) -> boolean

In-place b[i] = sqrt(b[i]).

Parameters

• b NxBuffer — Target buffer.

Returns boolean — true on success, false on unknown handle.

nx.applySqrt(b)

globals/nx/applySquare

nx.applySquare(b: NxBuffer) -> boolean

In-place b[i] = b[i] * b[i].

Parameters

• b NxBuffer — Target buffer.

Returns boolean — true on success, false on unknown handle.

nx.applySquare(b)

globals/nx/applyTan

nx.applyTan(b: NxBuffer) -> boolean

In-place b[i] = tan(b[i]).

Parameters

• b NxBuffer — Target buffer.

Returns boolean — true on success, false on unknown handle.

nx.applyTan(b)

globals/nx/applyTrunc

nx.applyTrunc(b: NxBuffer) -> boolean

In-place b[i] = trunc(b[i]).

Parameters

• b NxBuffer — Target buffer.

Returns boolean — true on success, false on unknown handle.

nx.applyTrunc(b)

globals/nx/applyWindow

nx.applyWindow(signal: NxBuffer, window: NxBuffer) -> boolean

Element-wise signal[i] *= window[i] in place. Operates over the shorter of the two — passing a longer window to window a shorter clip is intentional, not an error.

Parameters

• signal NxBuffer — Signal buffer (mutated).
• window NxBuffer — Window buffer.

Returns boolean — true on success, false on unknown handle.

nx.applyWindow(signal, hann)

globals/nx/axpby

nx.axpby(dst: NxBuffer, a: number, src: NxBuffer, b: number) -> boolean

BLAS axpby: dst[i] = a*dst[i] + b*src[i].

Parameters

• dst NxBuffer — Target buffer (mutated).
• a number — Scale applied to dst.
• src NxBuffer — Source buffer.
• b number — Scale applied to src.

Returns boolean — true on success, false on stride mismatch / unknown handle.

nx.axpby(y, 0.5, x, 2.0)

globals/nx/clamp

nx.clamp(b: NxBuffer, min_v: number, max_v: number) -> boolean

In-place clamp: b[i] = clamp(b[i], min_v, max_v).

Parameters

• b NxBuffer — Target buffer (mutated).
• min_v number — Lower bound.
• max_v number — Upper bound.

Returns boolean — true on success, false on unknown handle.

nx.clamp(b, 0.0, 1.0)

globals/nx/copy

nx.copy(dst: NxBuffer, src: NxBuffer) -> boolean

Copy every record from src into dst (memcpy fast path).

Parameters

• dst NxBuffer — Target buffer (mutated).
• src NxBuffer — Source buffer.

Returns boolean — true on success, false on shape mismatch or unknown handle.

nx.copy(dst, src)

globals/nx/copyStridedFrom

nx.copyStridedFrom(dst: NxBuffer, src: NxBuffer, scale: number?, dst_stride: number, dst_off: number?, src_stride: number, src_off: number?) -> boolean

Strided copy from src into dst with optional scaling: dst[k * dst_stride + dst_off] = scale * src[k * src_stride + src_off].

Parameters

• dst NxBuffer — Target buffer (mutated).
• src NxBuffer — Source buffer.
• scale number (optional) — Optional src scale factor (default 1.0).
• dst_stride number — Destination element stride.
• dst_off number (optional) — Optional destination offset (default 0).
• src_stride number — Source element stride.
• src_off number (optional) — Optional source offset (default 0).

Returns boolean — true on success, false on shape mismatch / unknown handle.

nx.copyStridedFrom(dst, src, 1, 3, 0, 3, 0)

globals/nx/create

nx.create(type_: NxType, n: number) -> NxBuffer?

Allocate a CPU buffer of type × len records. Thin alias for substrate.createBuffer({type=type_, len=n, kind="cpu"}) — kept here so the public nx library is the canonical entry point and users never need to import buffer separately.

Parameters

• type_ NxType — Element layout ("f32", "vec3", "vec4", "quat", "mat4").
• n number — Record count.

Returns NxBuffer? — Freshly allocated buffer handle, or nil on failure.

local b = nx.create("vec3", 1024)

globals/nx/div

nx.div(dst: NxBuffer, x: NxScalarOrBuffer) -> boolean

b[i] /= x (x scalar) or b[i] /= x[i] (x buffer).

Parameters

• dst NxBuffer — Target buffer (mutated).
• x NxScalarOrBuffer — Either a scalar or a same-shaped buffer.

Returns boolean — true on success, false on type / handle errors.

nx.div(b, 2)
nx.div(dst, src)

globals/nx/dot

nx.dot(a: NxBuffer, b: NxBuffer) -> number?

Reduction: dot product of two same-shaped buffers.

Parameters

• a NxBuffer — First buffer.
• b NxBuffer — Second buffer.

Returns number? — Scalar dot product, or nil on shape mismatch / unknown handle.

local d = nx.dot(a, b)

globals/nx/fft1d

nx.fft1d(re: NxBuffer, im: NxBuffer, inverse: boolean?) -> boolean

In-place 1D FFT over parallel re / im CPU buffers. inverse=true runs the inverse transform scaled by 1/N (so ifft(fft(x)) ≈ x).

Parameters

• re NxBuffer — Real-component buffer (mutated).
• im NxBuffer — Imaginary-component buffer (mutated).
• inverse boolean (optional) — When true runs the inverse transform.

Returns boolean — true on success, false on length mismatch / invalid handle.

nx.fft1d(re, im)
nx.fft1d(re, im, true)

globals/nx/fft2d

nx.fft2d(re: NxBuffer, im: NxBuffer, width: number, height: number, inverse: boolean?) -> boolean

In-place 2D FFT over row-major parallel re / im buffers of length width*height. inverse=true is scaled by 1 / (width * height).

Parameters

• re NxBuffer — Real-component buffer (mutated).
• im NxBuffer — Imaginary-component buffer (mutated).
• width number — 2D width in samples.
• height number — 2D height in samples.
• inverse boolean (optional) — When true runs the inverse transform.

Returns boolean — true on success, false on length mismatch / invalid handle.

nx.fft2d(re, im, w, h)

globals/nx/fill

nx.fill(b: NxBuffer, value: number?) -> boolean

Fill the buffer with value (default 0.0). Equivalent to the scalar form of nx.add against a zeroed buffer, but skips the type-dispatch.

Parameters

• b NxBuffer — Target buffer (mutated).
• value number (optional) — Fill value (default 0.0).

Returns boolean — true on success, false on unknown handle.

nx.fill(b, 3.5)

globals/nx/fillRandomNormal

nx.fillRandomNormal(b: NxBuffer, mean: number?, stddev: number?, seed: NxSeed) -> boolean

Fill the buffer with Gaussian samples (Box-Muller), with the given mean and standard deviation, using a splitmix-keyed PRNG.

Parameters

• b NxBuffer — Target buffer (mutated).
• mean number (optional) — Optional mean (default 0.0).
• stddev number (optional) — Optional standard deviation (default 1.0).
• seed NxSeed — Optional seed — number, "frame", or nil (0).

Returns boolean — true on success, false on unknown handle.

nx.fillRandomNormal(b, 0, 1, 42)

globals/nx/fillRandomUniform

nx.fillRandomUniform(b: NxBuffer, min_v: number?, max_v: number?, seed: NxSeed) -> boolean

Fill the buffer with uniform-random samples in [min, max), using a splitmix-keyed deterministic PRNG.

Parameters

• b NxBuffer — Target buffer (mutated).
• min_v number (optional) — Optional lower bound (default 0.0).
• max_v number (optional) — Optional upper bound (default 1.0).
• seed NxSeed — Optional seed — number, "frame" (per-frame value), or nil (0).

Returns boolean — true on success, false on unknown handle.

nx.fillRandomUniform(b, -1, 1, "frame")

globals/nx/fillStrided

nx.fillStrided(b: NxBuffer, value: number, stride: number, offset: number?) -> boolean

Strided fill: buf[k * stride + offset] = value for every valid k.

Parameters

• b NxBuffer — Target buffer (mutated).
• value number — Per-element value.
• stride number — Element stride.
• offset number (optional) — Optional element offset (default 0).

Returns boolean — true on success, false on unknown handle.

nx.fillStrided(buf, 0, 3, 2)

globals/nx/fromTable

nx.fromTable(arr: { number }, type_: NxType?) -> NxBuffer?

Build a CPU buffer from a Lua table of numbers. The table is written through buf:write in a single FFI crossing — no per-element Lua loop. For large arrays, prefer one of the nx.* constructors + a kernel pass over building a Lua array first.

Parameters

• arr { number } — Lua array of numbers.
• type_ NxType (optional) — Optional element layout (default "f32").

Returns NxBuffer? — Newly allocated buffer holding arr, or nil on failure.

local b = nx.fromTable({ 0.1, 0.2, 0.3 })

globals/nx/full

nx.full(n: number, type_: NxType?, value: number?) -> NxBuffer?

Allocate a buffer of type × len records and fill with value.

Parameters

• n number — Record count.
• type_ NxType (optional) — Optional element layout (default "f32").
• value number (optional) — Fill value (default 0.0).

Returns NxBuffer? — Buffer initialised to value.

local b = nx.full(1024, "f32", -1.0)

globals/nx/ifft1d

nx.ifft1d(re: NxBuffer, im: NxBuffer) -> boolean

Convenience: nx.fft1d(re, im, true).

Parameters

• re NxBuffer — Real-component buffer (mutated).
• im NxBuffer — Imaginary-component buffer (mutated).

Returns boolean — true on success, false on length mismatch / invalid handle.

nx.ifft1d(re, im)

globals/nx/ifft2d

nx.ifft2d(re: NxBuffer, im: NxBuffer, width: number, height: number) -> boolean

Convenience: nx.fft2d(re, im, w, h, true).

Parameters

• re NxBuffer — Real-component buffer (mutated).
• im NxBuffer — Imaginary-component buffer (mutated).
• width number — 2D width.
• height number — 2D height.

Returns boolean — true on success, false on length mismatch / invalid handle.

nx.ifft2d(re, im, w, h)

globals/nx/integratePosition

nx.integratePosition(pos: NxBuffer, vel: NxBuffer, dt: number) -> boolean

Per-vec3: pos[i] += vel[i] * dt — the position half of an Euler step. Both buffers must be vec3 (stride 3). The velocity step is the caller's: update vel BEFORE this call for semi-implicit Euler; updating it after gives forward Euler, which gains energy on stiff systems.

Parameters

• pos NxBuffer — Position buffer (mutated).
• vel NxBuffer — Velocity buffer.
• dt number — Time step.

Returns boolean — true on success, false on shape mismatch / unknown handle.

nx.integratePosition(pos, vel, dt)

globals/nx/irfft1d

nx.irfft1d(re: NxBuffer, im: NxBuffer) -> NxBuffer?

Real-output inverse 1D FFT. Input re / im are length N/2 + 1. Returns a fresh CPU f32 buffer of length 2 * (N/2 + 1 - 1) = N real samples.

Parameters

• re NxBuffer — Real-component buffer.
• im NxBuffer — Imaginary-component buffer.

Returns NxBuffer? — Real-valued output buffer on success, nil on failure.

local out = nx.irfft1d(re, im)

globals/nx/irfft2d

nx.irfft2d(re: NxBuffer, im: NxBuffer, width: number, height: number) -> NxBuffer?

Real-output inverse 2D FFT. Input re / im are (width/2 + 1) * height row-major. Returns a fresh f32 buffer of length width * height.

Parameters

• re NxBuffer — Real-component buffer.
• im NxBuffer — Imaginary-component buffer.
• width number — 2D width.
• height number — 2D height.

Returns NxBuffer? — Real-valued output buffer on success, nil on failure.

local out = nx.irfft2d(re, im, w, h)

globals/nx/lerpTo

nx.lerpTo(dst: NxBuffer, src: NxBuffer, t: number) -> boolean

dst[i] += t * (src[i] - dst[i]) — element-wise lerp toward src by t.

Parameters

• dst NxBuffer — Target buffer (mutated).
• src NxBuffer — Source buffer.
• t number — Interpolation factor.

Returns boolean — true on success, false on stride mismatch / unknown handle.

nx.lerpTo(current, target, 0.1)

globals/nx/max

nx.max(b: NxBuffer) -> number?

Reduction: maximum of all elements.

Parameters

• b NxBuffer — Source buffer.

Returns number? — Scalar max, or nil on unknown handle.

local m = nx.max(b)

globals/nx/maxOp

nx.maxOp(dst: NxBuffer, x: NxScalarOrBuffer) -> boolean

Element-wise b[i] = max(b[i], x) (scalar) or b[i] = max(b[i], x[i]) (buffer).

Parameters

• dst NxBuffer — Target buffer (mutated).
• x NxScalarOrBuffer — Scalar or same-shaped buffer.

Returns boolean — true on success, false on type / handle errors.

nx.maxOp(b, 0.0)

globals/nx/mean

nx.mean(b: NxBuffer) -> number?

Reduction: arithmetic mean of all elements.

Parameters

• b NxBuffer — Source buffer.

Returns number? — Scalar mean, or nil on unknown handle.

local m = nx.mean(b)

globals/nx/min

nx.min(b: NxBuffer) -> number?

Reduction: minimum of all elements.

Parameters

• b NxBuffer — Source buffer.

Returns number? — Scalar min, or nil on unknown handle.

local m = nx.min(b)

globals/nx/minOp

nx.minOp(dst: NxBuffer, x: NxScalarOrBuffer) -> boolean

Element-wise b[i] = min(b[i], x) (scalar) or b[i] = min(b[i], x[i]) (buffer).

Parameters

• dst NxBuffer — Target buffer (mutated).
• x NxScalarOrBuffer — Scalar or same-shaped buffer.

Returns boolean — true on success, false on type / handle errors.

nx.minOp(b, 1.0)

globals/nx/mul

nx.mul(dst: NxBuffer, x: NxScalarOrBuffer) -> boolean

b[i] *= x (x scalar) or b[i] *= x[i] (x buffer).

Parameters

• dst NxBuffer — Target buffer (mutated).
• x NxScalarOrBuffer — Either a scalar or a same-shaped buffer.

Returns boolean — true on success, false on type / handle errors.

nx.mul(b, 2)
nx.mul(dst, src)

globals/nx/mulStrided

nx.mulStrided(b: NxBuffer, scalar: number, stride: number, offset: number?) -> boolean

Strided multiply: buf[k * stride + offset] *= scalar for every valid k.

Parameters

• b NxBuffer — Target buffer (mutated).
• scalar number — Per-element multiplier.
• stride number — Element stride.
• offset number (optional) — Optional element offset (default 0).

Returns boolean — true on success, false on unknown handle.

nx.mulStrided(buf, 2, 4, 0)

globals/nx/normL1

nx.normL1(b: NxBuffer) -> number?

Reduction: L1 norm — sum(|b[i]|).

Parameters

• b NxBuffer — Source buffer.

Returns number? — Scalar L1 norm, or nil on unknown handle.

local n = nx.normL1(b)

globals/nx/normL2

nx.normL2(b: NxBuffer) -> number?

Reduction: L2 norm — sqrt(sum(b[i]^2)).

Parameters

• b NxBuffer — Source buffer.

Returns number? — Scalar L2 norm, or nil on unknown handle.

local n = nx.normL2(b)

globals/nx/normalizeVec3

nx.normalizeVec3(b: NxBuffer) -> boolean

Normalise each vec3 in-place. Vectors below 1e-8 are left untouched.

Parameters

• b NxBuffer — Vec3 buffer (mutated).

Returns boolean — true on success, false on stride mismatch / unknown handle.

nx.normalizeVec3(directions)

globals/nx/ones

nx.ones(n: number, type_: NxType?) -> NxBuffer?

Allocate a buffer of type × len records and fill with 1.0.

Parameters

• n number — Record count.
• type_ NxType (optional) — Optional element layout (default "f32").

Returns NxBuffer? — Buffer initialised to one.

local b = nx.ones(1024)

globals/nx/pow

nx.pow(b: NxBuffer, p: number) -> boolean

In-place b[i] = b[i] ^ p (scalar exponent).

Parameters

• b NxBuffer — Target buffer (mutated).
• p number — Scalar exponent.

Returns boolean — true on success, false on unknown handle.

nx.pow(b, 2.2)

globals/nx/quatFromYaw

nx.quatFromYaw(dst: NxBuffer, yaw: NxBuffer) -> boolean

Per-quat: dst[i] = (0, sin(yaw[i]/2), 0, cos(yaw[i]/2)) — the pure-Y axis-angle quaternion for each yaw value. dst must be stride-4 (quat); yaw must be stride-1 (f32).

Parameters

• dst NxBuffer — Quaternion buffer (mutated).
• yaw NxBuffer — Source yaw scalars buffer.

Returns boolean — true on success, false on shape mismatch / unknown handle.

nx.quatFromYaw(quats, yaws)

globals/nx/rfft1d

nx.rfft1d(signal: NxBuffer?) -> (NxBuffer?, NxBuffer?)

Real-input forward 1D FFT. Allocates two new CPU f32 buffers of length N/2 + 1 holding the (re, im) parts of the Hermitian-symmetric spectrum (same convention as NumPy np.fft.rfft).

Parameters

• signal NxBuffer (optional) — Real-valued input buffer.

Returns (NxBuffer?, NxBuffer?) — (re_buf, im_buf) on success, nil otherwise.

local re, im = nx.rfft1d(signal)

globals/nx/rfft2d

nx.rfft2d(signal: NxBuffer, width: number, height: number) -> (NxBuffer?, NxBuffer?)

Real-input forward 2D FFT. Input signal is row-major width*height. Returns (re_buf, im_buf) of length (width/2 + 1) * height each (matches np.fft.rfft2 layout).

Parameters

• signal NxBuffer — Real-valued input buffer (row-major).
• width number — 2D width.
• height number — 2D height.

Returns (NxBuffer?, NxBuffer?) — (re_buf, im_buf) on success, nil on failure.

local re, im = nx.rfft2d(image, w, h)

globals/nx/scale

nx.scale(b: NxBuffer, s: number) -> boolean

In-place b[i] *= s.

Parameters

• b NxBuffer — Target buffer (mutated).
• s number — Scalar multiplier.

Returns boolean — true on success, false on unknown handle.

nx.scale(b, 0.5)

globals/nx/sinCosTo

nx.sinCosTo(src: NxBuffer, sin_dst: NxBuffer, cos_dst: NxBuffer) -> boolean

Compute sin_dst[i] = sin(src[i]) and cos_dst[i] = cos(src[i]) in one pass using cheaper paired-trig argument reduction.

Parameters

• src NxBuffer — Source angles buffer.
• sin_dst NxBuffer — Destination buffer for the sine values.
• cos_dst NxBuffer — Destination buffer for the cosine values.

Returns boolean — true on success, false on stride mismatch / unknown handle.

nx.sinCosTo(angles, s, c)

globals/nx/sub

nx.sub(dst: NxBuffer, x: NxScalarOrBuffer) -> boolean

b[i] -= x (x scalar) or b[i] -= x[i] (x buffer).

Parameters

• dst NxBuffer — Target buffer (mutated).
• x NxScalarOrBuffer — Either a scalar or a same-shaped buffer.

Returns boolean — true on success, false on type / handle errors.

nx.sub(b, 0.5)
nx.sub(dst, src)

globals/nx/sum

nx.sum(b: NxBuffer) -> number?

Reduction: sum of all elements.

Parameters

• b NxBuffer — Source buffer.

Returns number? — Scalar sum, or nil on unknown handle.

local s = nx.sum(b)

globals/nx/wanderYaw

nx.wanderYaw(args: NxWanderArgs) -> boolean

Fused per-entity wander step. Each entity's yaw[i] walks by a uniform random delta in [-yawDelta, +yawDelta], then pos[i] advances forward in the (sin yaw, cos yaw) direction by step. Optional rot quat output writes a pure-Y axis-angle rotation. Replaces the per-entity Luau loop pattern (~12 ms / 5000 in interpreter) with a single Rust pass (~0.2 ms / 5000). Buffer requirements: pos vec3 (stride 3), yaw f32 (stride 1), rot optional quat (stride 4). All counts should match (kernel walks min(count_i)).

Parameters

• args NxWanderArgs — Table with { pos, yaw, rot?, step?, yawDelta?, seed }.

Returns boolean — true on success, false on stride / shape failures.

nx.wanderYaw({ pos = pos, yaw = yaw, step = 0.5, yawDelta = 0.2, seed = "frame" })

globals/nx/window/blackman

nx.window.blackman(n: number) -> NxBuffer?

Allocate a fresh CPU f32 buffer of length n filled with a symmetric Blackman window (NumPy np.blackman convention).

Parameters

• n number — Number of samples in the window.

Returns NxBuffer? — Buffer holding the window samples, or nil on failure.

local w = nx.window.blackman(1024)

globals/nx/window/hamming

nx.window.hamming(n: number) -> NxBuffer?

Allocate a fresh CPU f32 buffer of length n filled with a symmetric Hamming window (NumPy np.hamming convention).

Parameters

• n number — Number of samples in the window.

Returns NxBuffer? — Buffer holding the window samples, or nil on failure.

local w = nx.window.hamming(1024)

globals/nx/window/hann

nx.window.hann(n: number) -> NxBuffer?

Allocate a fresh CPU f32 buffer of length n filled with a symmetric Hann window (NumPy np.hanning convention).

Parameters

• n number — Number of samples in the window.

Returns NxBuffer? — Buffer holding the window samples, or nil on failure.

local w = nx.window.hann(1024)

globals/nx/zeros

nx.zeros(n: number, type_: NxType?) -> NxBuffer?

Allocate a buffer of type × len records and fill with 0.0.

Parameters

• n number — Record count.
• type_ NxType (optional) — Optional element layout (default "f32").

Returns NxBuffer? — Buffer initialised to zero.

local b = nx.zeros(2048)

typed/builtin//modules/nx/nx/add

nx.add(dst: NxBuffer, x: NxScalarOrBuffer) -> boolean

b[i] += x (x scalar) or b[i] += x[i] (x buffer). Dispatches on type(x). For interleaved-stride writes use nx.addStrided.

Parameters

• dst NxBuffer — Target buffer (mutated).
• x NxScalarOrBuffer — Either a scalar or a same-shaped buffer.

Returns boolean — true on success, false on type / handle errors.

nx.add(b, 1.5)
nx.add(dst, src)

typed/builtin//modules/nx/nx/addStrided

nx.addStrided(b: NxBuffer, scalar: number, stride: number, offset: number?) -> boolean

Strided add: buf[k * stride + offset] += scalar for every valid k.

Parameters

• b NxBuffer — Target buffer (mutated).
• scalar number — Per-element addend.
• stride number — Element stride.
• offset number (optional) — Optional element offset (default 0).

Returns boolean — true on success, false on unknown handle.

nx.addStrided(buf, 1.0, 3, 1)

typed/builtin//modules/nx/nx/addStridedFrom

nx.addStridedFrom(dst: NxBuffer, src: NxBuffer, scale: number?, dst_stride: number, dst_off: number?, src_stride: number, src_off: number?) -> boolean

Strided BLAS-axpy from src into dst: dst[k * dst_stride + dst_off] += scale * src[k * src_stride + src_off].

Parameters

• dst NxBuffer — Target buffer (mutated).
• src NxBuffer — Source buffer.
• scale number (optional) — Optional src scale factor (default 1.0).
• dst_stride number — Destination element stride.
• dst_off number (optional) — Optional destination offset (default 0).
• src_stride number — Source element stride.
• src_off number (optional) — Optional source offset (default 0).

Returns boolean — true on success, false on shape mismatch / unknown handle.

nx.addStridedFrom(dst, src, 1, 3, 0, 3, 0)

typed/builtin//modules/nx/nx/applyAbs

nx.applyAbs(b: NxBuffer) -> boolean

In-place b[i] = abs(b[i]).

Parameters

• b NxBuffer — Target buffer.

Returns boolean — true on success, false on unknown handle.

nx.applyAbs(b)

typed/builtin//modules/nx/nx/applyCeil

nx.applyCeil(b: NxBuffer) -> boolean

In-place b[i] = ceil(b[i]).

Parameters

• b NxBuffer — Target buffer.

Returns boolean — true on success, false on unknown handle.

nx.applyCeil(b)

typed/builtin//modules/nx/nx/applyCos

nx.applyCos(b: NxBuffer) -> boolean

In-place b[i] = cos(b[i]).

Parameters

• b NxBuffer — Target buffer.

Returns boolean — true on success, false on unknown handle.

nx.applyCos(b)

typed/builtin//modules/nx/nx/applyExp

nx.applyExp(b: NxBuffer) -> boolean

In-place b[i] = exp(b[i]).

Parameters

• b NxBuffer — Target buffer.

Returns boolean — true on success, false on unknown handle.

nx.applyExp(b)

typed/builtin//modules/nx/nx/applyFloor

nx.applyFloor(b: NxBuffer) -> boolean

In-place b[i] = floor(b[i]).

Parameters

• b NxBuffer — Target buffer.

Returns boolean — true on success, false on unknown handle.

nx.applyFloor(b)

typed/builtin//modules/nx/nx/applyFract

nx.applyFract(b: NxBuffer) -> boolean

In-place b[i] = fract(b[i]) (fractional part).

Parameters

• b NxBuffer — Target buffer.

Returns boolean — true on success, false on unknown handle.

nx.applyFract(b)

typed/builtin//modules/nx/nx/applyLog

nx.applyLog(b: NxBuffer) -> boolean

In-place b[i] = ln(b[i]).

Parameters

• b NxBuffer — Target buffer.

Returns boolean — true on success, false on unknown handle.

nx.applyLog(b)

typed/builtin//modules/nx/nx/applyLog2

nx.applyLog2(b: NxBuffer) -> boolean

In-place b[i] = log2(b[i]).

Parameters

• b NxBuffer — Target buffer.

Returns boolean — true on success, false on unknown handle.

nx.applyLog2(b)

typed/builtin//modules/nx/nx/applyNeg

nx.applyNeg(b: NxBuffer) -> boolean

In-place b[i] = -b[i].

Parameters

• b NxBuffer — Target buffer.

Returns boolean — true on success, false on unknown handle.

nx.applyNeg(b)

typed/builtin//modules/nx/nx/applyRecip

nx.applyRecip(b: NxBuffer) -> boolean

In-place b[i] = 1 / b[i].

Parameters

• b NxBuffer — Target buffer.

Returns boolean — true on success, false on unknown handle.

nx.applyRecip(b)

typed/builtin//modules/nx/nx/applyRecipSqrt

nx.applyRecipSqrt(b: NxBuffer) -> boolean

In-place b[i] = 1 / sqrt(b[i]).

Parameters

• b NxBuffer — Target buffer.

Returns boolean — true on success, false on unknown handle.

nx.applyRecipSqrt(b)

typed/builtin//modules/nx/nx/applyRound

nx.applyRound(b: NxBuffer) -> boolean

In-place b[i] = round(b[i]).

Parameters

• b NxBuffer — Target buffer.

Returns boolean — true on success, false on unknown handle.

nx.applyRound(b)

typed/builtin//modules/nx/nx/applySign

nx.applySign(b: NxBuffer) -> boolean

In-place b[i] = sign(b[i]) (returns -1, 0, or +1).

Parameters

• b NxBuffer — Target buffer.

Returns boolean — true on success, false on unknown handle.

nx.applySign(b)

typed/builtin//modules/nx/nx/applySin

nx.applySin(b: NxBuffer) -> boolean

In-place b[i] = sin(b[i]).

Parameters

• b NxBuffer — Target buffer.

Returns boolean — true on success, false on unknown handle.

nx.applySin(b)

typed/builtin//modules/nx/nx/applySqrt

nx.applySqrt(b: NxBuffer) -> boolean

In-place b[i] = sqrt(b[i]).

Parameters

• b NxBuffer — Target buffer.

Returns boolean — true on success, false on unknown handle.

nx.applySqrt(b)

typed/builtin//modules/nx/nx/applySquare

nx.applySquare(b: NxBuffer) -> boolean

In-place b[i] = b[i] * b[i].

Parameters

• b NxBuffer — Target buffer.

Returns boolean — true on success, false on unknown handle.

nx.applySquare(b)

typed/builtin//modules/nx/nx/applyTan

nx.applyTan(b: NxBuffer) -> boolean

In-place b[i] = tan(b[i]).

Parameters

• b NxBuffer — Target buffer.

Returns boolean — true on success, false on unknown handle.

nx.applyTan(b)

typed/builtin//modules/nx/nx/applyTrunc

nx.applyTrunc(b: NxBuffer) -> boolean

In-place b[i] = trunc(b[i]).

Parameters

• b NxBuffer — Target buffer.

Returns boolean — true on success, false on unknown handle.

nx.applyTrunc(b)

typed/builtin//modules/nx/nx/applyWindow

nx.applyWindow(signal: NxBuffer, window: NxBuffer) -> boolean

Element-wise signal[i] *= window[i] in place. Operates over the shorter of the two — passing a longer window to window a shorter clip is intentional, not an error.

Parameters

• signal NxBuffer — Signal buffer (mutated).
• window NxBuffer — Window buffer.

Returns boolean — true on success, false on unknown handle.

nx.applyWindow(signal, hann)

typed/builtin//modules/nx/nx/axpby

nx.axpby(dst: NxBuffer, a: number, src: NxBuffer, b: number) -> boolean

BLAS axpby: dst[i] = a*dst[i] + b*src[i].

Parameters

• dst NxBuffer — Target buffer (mutated).
• a number — Scale applied to dst.
• src NxBuffer — Source buffer.
• b number — Scale applied to src.

Returns boolean — true on success, false on stride mismatch / unknown handle.

nx.axpby(y, 0.5, x, 2.0)

typed/builtin//modules/nx/nx/clamp

nx.clamp(b: NxBuffer, min_v: number, max_v: number) -> boolean

In-place clamp: b[i] = clamp(b[i], min_v, max_v).

Parameters

• b NxBuffer — Target buffer (mutated).
• min_v number — Lower bound.
• max_v number — Upper bound.

Returns boolean — true on success, false on unknown handle.

nx.clamp(b, 0.0, 1.0)

typed/builtin//modules/nx/nx/copy

nx.copy(dst: NxBuffer, src: NxBuffer) -> boolean

Copy every record from src into dst (memcpy fast path).

Parameters

• dst NxBuffer — Target buffer (mutated).
• src NxBuffer — Source buffer.

Returns boolean — true on success, false on shape mismatch or unknown handle.

nx.copy(dst, src)

typed/builtin//modules/nx/nx/copyStridedFrom

nx.copyStridedFrom(dst: NxBuffer, src: NxBuffer, scale: number?, dst_stride: number, dst_off: number?, src_stride: number, src_off: number?) -> boolean

Strided copy from src into dst with optional scaling: dst[k * dst_stride + dst_off] = scale * src[k * src_stride + src_off].

Parameters

• dst NxBuffer — Target buffer (mutated).
• src NxBuffer — Source buffer.
• scale number (optional) — Optional src scale factor (default 1.0).
• dst_stride number — Destination element stride.
• dst_off number (optional) — Optional destination offset (default 0).
• src_stride number — Source element stride.
• src_off number (optional) — Optional source offset (default 0).

Returns boolean — true on success, false on shape mismatch / unknown handle.

nx.copyStridedFrom(dst, src, 1, 3, 0, 3, 0)

typed/builtin//modules/nx/nx/create

nx.create(type_: NxType, n: number) -> NxBuffer?

Allocate a CPU buffer of type × len records. Thin alias for substrate.createBuffer({type=type_, len=n, kind="cpu"}) — kept here so the public nx library is the canonical entry point and users never need to import buffer separately.

typed/builtin//modules/nx/nx/div

nx.div(dst: NxBuffer, x: NxScalarOrBuffer) -> boolean

b[i] /= x (x scalar) or b[i] /= x[i] (x buffer).

Parameters

• dst NxBuffer — Target buffer (mutated).
• x NxScalarOrBuffer — Either a scalar or a same-shaped buffer.

Returns boolean — true on success, false on type / handle errors.

nx.div(b, 2)
nx.div(dst, src)

typed/builtin//modules/nx/nx/dot

nx.dot(a: NxBuffer, b: NxBuffer) -> number?

Reduction: dot product of two same-shaped buffers.

Parameters

• a NxBuffer — First buffer.
• b NxBuffer — Second buffer.

Returns number? — Scalar dot product, or nil on shape mismatch / unknown handle.

local d = nx.dot(a, b)

typed/builtin//modules/nx/nx/fft1d

nx.fft1d(re: NxBuffer, im: NxBuffer, inverse: boolean?) -> boolean

In-place 1D FFT over parallel re / im CPU buffers. inverse=true runs the inverse transform scaled by 1/N (so ifft(fft(x)) ≈ x).

Parameters

• re NxBuffer — Real-component buffer (mutated).
• im NxBuffer — Imaginary-component buffer (mutated).
• inverse boolean (optional) — When true runs the inverse transform.

Returns boolean — true on success, false on length mismatch / invalid handle.

nx.fft1d(re, im)
nx.fft1d(re, im, true)

typed/builtin//modules/nx/nx/fft2d

nx.fft2d(re: NxBuffer, im: NxBuffer, width: number, height: number, inverse: boolean?) -> boolean

In-place 2D FFT over row-major parallel re / im buffers of length width*height. inverse=true is scaled by 1 / (width * height).

Parameters

• re NxBuffer — Real-component buffer (mutated).
• im NxBuffer — Imaginary-component buffer (mutated).
• width number — 2D width in samples.
• height number — 2D height in samples.
• inverse boolean (optional) — When true runs the inverse transform.

Returns boolean — true on success, false on length mismatch / invalid handle.

nx.fft2d(re, im, w, h)

typed/builtin//modules/nx/nx/fill

nx.fill(b: NxBuffer, value: number?) -> boolean

Fill the buffer with value (default 0.0). Equivalent to the scalar form of nx.add against a zeroed buffer, but skips the type-dispatch.

Parameters

• b NxBuffer — Target buffer (mutated).
• value number (optional) — Fill value (default 0.0).

Returns boolean — true on success, false on unknown handle.

nx.fill(b, 3.5)

typed/builtin//modules/nx/nx/fillRandomNormal

nx.fillRandomNormal(b: NxBuffer, mean: number?, stddev: number?, seed: NxSeed) -> boolean

Fill the buffer with Gaussian samples (Box-Muller), with the given mean and standard deviation, using a splitmix-keyed PRNG.

Parameters

• b NxBuffer — Target buffer (mutated).
• mean number (optional) — Optional mean (default 0.0).
• stddev number (optional) — Optional standard deviation (default 1.0).
• seed NxSeed — Optional seed — number, "frame", or nil (0).

Returns boolean — true on success, false on unknown handle.

nx.fillRandomNormal(b, 0, 1, 42)

typed/builtin//modules/nx/nx/fillRandomUniform

nx.fillRandomUniform(b: NxBuffer, min_v: number?, max_v: number?, seed: NxSeed) -> boolean

Fill the buffer with uniform-random samples in [min, max), using a splitmix-keyed deterministic PRNG.

Parameters

• b NxBuffer — Target buffer (mutated).
• min_v number (optional) — Optional lower bound (default 0.0).
• max_v number (optional) — Optional upper bound (default 1.0).
• seed NxSeed — Optional seed — number, "frame" (per-frame value), or nil (0).

Returns boolean — true on success, false on unknown handle.

nx.fillRandomUniform(b, -1, 1, "frame")

typed/builtin//modules/nx/nx/fillStrided

nx.fillStrided(b: NxBuffer, value: number, stride: number, offset: number?) -> boolean

Strided fill: buf[k * stride + offset] = value for every valid k.

Parameters

• b NxBuffer — Target buffer (mutated).
• value number — Per-element value.
• stride number — Element stride.
• offset number (optional) — Optional element offset (default 0).

Returns boolean — true on success, false on unknown handle.

nx.fillStrided(buf, 0, 3, 2)

typed/builtin//modules/nx/nx/fromTable

nx.fromTable(arr: { number }, type_: NxType?) -> NxBuffer?

Build a CPU buffer from a Lua table of numbers. The table is written through buf:write in a single FFI crossing — no per-element Lua loop. For large arrays, prefer one of the nx.* constructors + a kernel pass over building a Lua array first.

Parameters

• arr { number } — Lua array of numbers.
• type_ NxType (optional) — Optional element layout (default "f32").

Returns NxBuffer? — Newly allocated buffer holding arr, or nil on failure.

local b = nx.fromTable({ 0.1, 0.2, 0.3 })

typed/builtin//modules/nx/nx/full

nx.full(n: number, type_: NxType?, value: number?) -> NxBuffer?

Allocate a buffer of type × len records and fill with value.

Parameters

• n number — Record count.
• type_ NxType (optional) — Optional element layout (default "f32").
• value number (optional) — Fill value (default 0.0).

Returns NxBuffer? — Buffer initialised to value.

local b = nx.full(1024, "f32", -1.0)

typed/builtin//modules/nx/nx/ifft1d

nx.ifft1d(re: NxBuffer, im: NxBuffer) -> boolean

Convenience: nx.fft1d(re, im, true).

Parameters

• re NxBuffer — Real-component buffer (mutated).
• im NxBuffer — Imaginary-component buffer (mutated).

Returns boolean — true on success, false on length mismatch / invalid handle.

nx.ifft1d(re, im)

typed/builtin//modules/nx/nx/ifft2d

nx.ifft2d(re: NxBuffer, im: NxBuffer, width: number, height: number) -> boolean

Convenience: nx.fft2d(re, im, w, h, true).

Parameters

• re NxBuffer — Real-component buffer (mutated).
• im NxBuffer — Imaginary-component buffer (mutated).
• width number — 2D width.
• height number — 2D height.

Returns boolean — true on success, false on length mismatch / invalid handle.

nx.ifft2d(re, im, w, h)

typed/builtin//modules/nx/nx/integratePosition

nx.integratePosition(pos: NxBuffer, vel: NxBuffer, dt: number) -> boolean

Per-vec3: pos[i] += vel[i] * dt — the position half of an Euler step. Both buffers must be vec3 (stride 3). The velocity step is the caller's: update vel BEFORE this call for semi-implicit Euler; updating it after gives forward Euler, which gains energy on stiff systems.

Parameters

• pos NxBuffer — Position buffer (mutated).
• vel NxBuffer — Velocity buffer.
• dt number — Time step.

Returns boolean — true on success, false on shape mismatch / unknown handle.

nx.integratePosition(pos, vel, dt)

typed/builtin//modules/nx/nx/irfft1d

nx.irfft1d(re: NxBuffer, im: NxBuffer) -> NxBuffer?

Real-output inverse 1D FFT. Input re / im are length N/2 + 1. Returns a fresh CPU f32 buffer of length 2 * (N/2 + 1 - 1) = N real samples.

Parameters

• re NxBuffer — Real-component buffer.
• im NxBuffer — Imaginary-component buffer.

Returns NxBuffer? — Real-valued output buffer on success, nil on failure.

local out = nx.irfft1d(re, im)

typed/builtin//modules/nx/nx/irfft2d

nx.irfft2d(re: NxBuffer, im: NxBuffer, width: number, height: number) -> NxBuffer?

Real-output inverse 2D FFT. Input re / im are (width/2 + 1) * height row-major. Returns a fresh f32 buffer of length width * height.

Parameters

• re NxBuffer — Real-component buffer.
• im NxBuffer — Imaginary-component buffer.
• width number — 2D width.
• height number — 2D height.

Returns NxBuffer? — Real-valued output buffer on success, nil on failure.

local out = nx.irfft2d(re, im, w, h)

typed/builtin//modules/nx/nx/lerpTo

nx.lerpTo(dst: NxBuffer, src: NxBuffer, t: number) -> boolean

dst[i] += t * (src[i] - dst[i]) — element-wise lerp toward src by t.

Parameters

• dst NxBuffer — Target buffer (mutated).
• src NxBuffer — Source buffer.
• t number — Interpolation factor.

Returns boolean — true on success, false on stride mismatch / unknown handle.

nx.lerpTo(current, target, 0.1)

typed/builtin//modules/nx/nx/max

nx.max(b: NxBuffer) -> number?

Reduction: maximum of all elements.

Parameters

• b NxBuffer — Source buffer.

Returns number? — Scalar max, or nil on unknown handle.

local m = nx.max(b)

typed/builtin//modules/nx/nx/maxOp

nx.maxOp(dst: NxBuffer, x: NxScalarOrBuffer) -> boolean

Element-wise b[i] = max(b[i], x) (scalar) or b[i] = max(b[i], x[i]) (buffer).

Parameters

• dst NxBuffer — Target buffer (mutated).
• x NxScalarOrBuffer — Scalar or same-shaped buffer.

Returns boolean — true on success, false on type / handle errors.

nx.maxOp(b, 0.0)

typed/builtin//modules/nx/nx/mean

nx.mean(b: NxBuffer) -> number?

Reduction: arithmetic mean of all elements.

Parameters

• b NxBuffer — Source buffer.

Returns number? — Scalar mean, or nil on unknown handle.

local m = nx.mean(b)

typed/builtin//modules/nx/nx/min

nx.min(b: NxBuffer) -> number?

Reduction: minimum of all elements.

Parameters

• b NxBuffer — Source buffer.

Returns number? — Scalar min, or nil on unknown handle.

local m = nx.min(b)

typed/builtin//modules/nx/nx/minOp

nx.minOp(dst: NxBuffer, x: NxScalarOrBuffer) -> boolean

Element-wise b[i] = min(b[i], x) (scalar) or b[i] = min(b[i], x[i]) (buffer).

Parameters

• dst NxBuffer — Target buffer (mutated).
• x NxScalarOrBuffer — Scalar or same-shaped buffer.

Returns boolean — true on success, false on type / handle errors.

nx.minOp(b, 1.0)

typed/builtin//modules/nx/nx/mul

nx.mul(dst: NxBuffer, x: NxScalarOrBuffer) -> boolean

b[i] *= x (x scalar) or b[i] *= x[i] (x buffer).

Parameters

• dst NxBuffer — Target buffer (mutated).
• x NxScalarOrBuffer — Either a scalar or a same-shaped buffer.

Returns boolean — true on success, false on type / handle errors.

nx.mul(b, 2)
nx.mul(dst, src)

typed/builtin//modules/nx/nx/mulStrided

nx.mulStrided(b: NxBuffer, scalar: number, stride: number, offset: number?) -> boolean

Strided multiply: buf[k * stride + offset] *= scalar for every valid k.

Parameters

• b NxBuffer — Target buffer (mutated).
• scalar number — Per-element multiplier.
• stride number — Element stride.
• offset number (optional) — Optional element offset (default 0).

Returns boolean — true on success, false on unknown handle.

nx.mulStrided(buf, 2, 4, 0)

typed/builtin//modules/nx/nx/normL1

nx.normL1(b: NxBuffer) -> number?

Reduction: L1 norm — sum(|b[i]|).

Parameters

• b NxBuffer — Source buffer.

Returns number? — Scalar L1 norm, or nil on unknown handle.

local n = nx.normL1(b)

typed/builtin//modules/nx/nx/normL2

nx.normL2(b: NxBuffer) -> number?

Reduction: L2 norm — sqrt(sum(b[i]^2)).

Parameters

• b NxBuffer — Source buffer.

Returns number? — Scalar L2 norm, or nil on unknown handle.

local n = nx.normL2(b)

typed/builtin//modules/nx/nx/normalizeVec3

nx.normalizeVec3(b: NxBuffer) -> boolean

Normalise each vec3 in-place. Vectors below 1e-8 are left untouched.

Parameters

• b NxBuffer — Vec3 buffer (mutated).

Returns boolean — true on success, false on stride mismatch / unknown handle.

nx.normalizeVec3(directions)

typed/builtin//modules/nx/nx/ones

nx.ones(n: number, type_: NxType?) -> NxBuffer?

Allocate a buffer of type × len records and fill with 1.0.

Parameters

• n number — Record count.
• type_ NxType (optional) — Optional element layout (default "f32").

Returns NxBuffer? — Buffer initialised to one.

local b = nx.ones(1024)

typed/builtin//modules/nx/nx/pow

nx.pow(b: NxBuffer, p: number) -> boolean

In-place b[i] = b[i] ^ p (scalar exponent).

Parameters

• b NxBuffer — Target buffer (mutated).
• p number — Scalar exponent.

Returns boolean — true on success, false on unknown handle.

nx.pow(b, 2.2)

typed/builtin//modules/nx/nx/quatFromYaw

nx.quatFromYaw(dst: NxBuffer, yaw: NxBuffer) -> boolean

Per-quat: dst[i] = (0, sin(yaw[i]/2), 0, cos(yaw[i]/2)) — the pure-Y axis-angle quaternion for each yaw value. dst must be stride-4 (quat); yaw must be stride-1 (f32).

Parameters

• dst NxBuffer — Quaternion buffer (mutated).
• yaw NxBuffer — Source yaw scalars buffer.

Returns boolean — true on success, false on shape mismatch / unknown handle.

nx.quatFromYaw(quats, yaws)

typed/builtin//modules/nx/nx/rfft1d

nx.rfft1d(signal: NxBuffer?) -> (NxBuffer?, NxBuffer?)

Real-input forward 1D FFT. Allocates two new CPU f32 buffers of length N/2 + 1 holding the (re, im) parts of the Hermitian-symmetric spectrum (same convention as NumPy np.fft.rfft).

Parameters

• signal NxBuffer (optional) — Real-valued input buffer.

Returns (NxBuffer?, NxBuffer?) — (re_buf, im_buf) on success, nil otherwise.

local re, im = nx.rfft1d(signal)

typed/builtin//modules/nx/nx/rfft2d

nx.rfft2d(signal: NxBuffer, width: number, height: number) -> (NxBuffer?, NxBuffer?)

Real-input forward 2D FFT. Input signal is row-major width*height. Returns (re_buf, im_buf) of length (width/2 + 1) * height each (matches np.fft.rfft2 layout).

Parameters

• signal NxBuffer — Real-valued input buffer (row-major).
• width number — 2D width.
• height number — 2D height.

Returns (NxBuffer?, NxBuffer?) — (re_buf, im_buf) on success, nil on failure.

local re, im = nx.rfft2d(image, w, h)

typed/builtin//modules/nx/nx/scale

nx.scale(b: NxBuffer, s: number) -> boolean

In-place b[i] *= s.

Parameters

• b NxBuffer — Target buffer (mutated).
• s number — Scalar multiplier.

Returns boolean — true on success, false on unknown handle.

nx.scale(b, 0.5)

typed/builtin//modules/nx/nx/sinCosTo

nx.sinCosTo(src: NxBuffer, sin_dst: NxBuffer, cos_dst: NxBuffer) -> boolean

Compute sin_dst[i] = sin(src[i]) and cos_dst[i] = cos(src[i]) in one pass using cheaper paired-trig argument reduction.

Parameters

• src NxBuffer — Source angles buffer.
• sin_dst NxBuffer — Destination buffer for the sine values.
• cos_dst NxBuffer — Destination buffer for the cosine values.

Returns boolean — true on success, false on stride mismatch / unknown handle.

nx.sinCosTo(angles, s, c)

typed/builtin//modules/nx/nx/sub

nx.sub(dst: NxBuffer, x: NxScalarOrBuffer) -> boolean

b[i] -= x (x scalar) or b[i] -= x[i] (x buffer).

Parameters

• dst NxBuffer — Target buffer (mutated).
• x NxScalarOrBuffer — Either a scalar or a same-shaped buffer.

Returns boolean — true on success, false on type / handle errors.

nx.sub(b, 0.5)
nx.sub(dst, src)

typed/builtin//modules/nx/nx/sum

nx.sum(b: NxBuffer) -> number?

Reduction: sum of all elements.

Parameters

• b NxBuffer — Source buffer.

Returns number? — Scalar sum, or nil on unknown handle.

local s = nx.sum(b)

typed/builtin//modules/nx/nx/wanderYaw

nx.wanderYaw(args: NxWanderArgs) -> boolean

Fused per-entity wander step. Each entity's yaw[i] walks by a uniform random delta in [-yawDelta, +yawDelta], then pos[i] advances forward in the (sin yaw, cos yaw) direction by step. Optional rot quat output writes a pure-Y axis-angle rotation. Replaces the per-entity Luau loop pattern (~12 ms / 5000 in interpreter) with a single Rust pass (~0.2 ms / 5000). Buffer requirements: pos vec3 (stride 3), yaw f32 (stride 1), rot optional quat (stride 4). All counts should match (kernel walks min(count_i)).

Parameters

• args NxWanderArgs — Table with { pos, yaw, rot?, step?, yawDelta?, seed }.

Returns boolean — true on success, false on stride / shape failures.

nx.wanderYaw({ pos = pos, yaw = yaw, step = 0.5, yawDelta = 0.2, seed = "frame" })

typed/builtin//modules/nx/nx/zeros

nx.zeros(n: number, type_: NxType?) -> NxBuffer?

Allocate a buffer of type × len records and fill with 0.0.

Parameters

• n number — Record count.
• type_ NxType (optional) — Optional element layout (default "f32").

Returns NxBuffer? — Buffer initialised to zero.

local b = nx.zeros(2048)