Parabun

para:parallel

pmap and preduce chunk arrays across a persistent worker pool. Functions are serialized via fn.toString(), so they must be pure — no closures, no outer references. TypedArrays are passed through a SharedArrayBuffer, so postMessage transfers a handle rather than a copy.

import { pmap } from "para:parallel";

const rows = Array.from({ length: 1_000_000 }, (_, i) => `record-${i}`);

function score(row: string): number {
  let h = 0;
  for (let i = 0; i < row.length; i++) h = (h * 31 + row.charCodeAt(i)) | 0;
  return h * h;
}

const scores = await pmap(score, rows, { concurrency: 8 });
console.log("scored", scores.length, "rows; first =", scores[0]);

import { pmap } from "para:parallel";

const rows = Array.from({ length: 1_000_000 }, (_, i) => `record-${i}`);

pure function score(row: string): number {
  let h = 0;
  for (let i = 0; i < row.length; i++) h = (h * 31 + row.charCodeAt(i)) | 0;
  return h * h;
}

const scores = await pmap(score, rows, { concurrency: 8 });
console.log("scored", scores.length, "rows; first =", scores[0]);

para:simd

WebAssembly v128 kernels for Float32Array (f32x4) and Float64Array (f64x2). Inputs above 4 MiB are processed in place rather than copied into WASM memory. alloc() returns a typed array backed by the WASM linear memory for zero-copy use.

import { mulScalar, add, dot, sum } from "para:simd";

const a = new Float32Array([1, 2, 3, 4]);
const b = new Float32Array([5, 6, 7, 8]);

const y = mulScalar(a, 3);     // [3, 6, 9, 12]
const z = add(a, b);          // [6, 8, 10, 12]
const d = dot(a, b);          // 70
const s = sum(a);             // 10

para:gpu

Metal on macOS, CUDA on Linux and Windows, CPU fallback on hosts without a GPU. A matrix passed to gpu.hold() stays resident across matVec calls, so only the input vector crosses the host↔device boundary per call. Pure Float32Array → Float32Array functions are runtime-compiled to PTX (via NVRTC) or MSL (via newLibraryWithSource:) when the body fits a supported shape: arithmetic, ternary, Math.*.

import gpu from "para:gpu";

const M = 1024, K = 768;
const mat = gpu.alloc(M * K, "f32");
for (let i = 0; i < mat.length; i++) mat[i] = Math.random();

const held = gpu.hold(mat);                          // uploaded once
const queries = [
  new Float32Array(K).fill(0.1),
  new Float32Array(K).fill(0.2),
];
for (const q of queries) {
  const scores = gpu.matVec(held, q, M, K);        // no copy
  console.log("top score:", Math.max(...scores));
}
gpu.release(held);

Beyond matVec / simdMap, para:gpu ships conv2D, scan, reduce, argMin / argMax, histogram, and median / quantile — CPU correctness paths today, with optional CUDA / Metal hooks on the same dispatch surface for follow-up device kernels.

para:arena

A pool of SharedArrayBuffer-backed typed arrays. para:parallel and para:pipeline draw from it so per-chunk work doesn't allocate a fresh buffer every time. Entries return to the pool at the end of an arena { } block or a pmap chunk, instead of waiting for the GC.

para:pipeline

A chain of para:simd calls (mulScalar, add, relu, …) is collapsed into a single pass at .run() time, so the intermediate arrays don't get allocated. If the input is large enough that GPU dispatch wins (gpu.winsForSize(...)), the fused chain runs as a single para:gpu simdMap instead.

para:signals

signal() is a reactive cell, derived() derives one from others, and effect() runs side effects when something it read changes. Reads inside an effect register a dependency; writes invalidate downstream and a microtask flush re-runs only the effects that observed a value that actually changed. batch() coalesces multi-write transactions; untrack() reads inside a reactive context without registering a dep. Pairs with the signal / effect { } / ~> language extensions.

Many other modules expose their own state as Signals — para:audio's capture stream (peakLevel, active), para:llm's LLM and WhisperModel instances (busy, device), para:speech's listen() stream (active, noiseFloor, lastUtterance), and para:assistant's state / history / lastTurn / interrupted. Wire any of them into UI without polling.

para:rtp

RFC 3550 packet pack / parse and a jitter buffer. Built to sit under para:audio's Opus encoder for a WebRTC-style send/receive path. rtp.pack({ payloadType, sequence, timestamp, ssrc, payload }) produces a wire-format packet; the jitter buffer reorders by sequence number with a configurable depth.

para:image

A Sharp-class image module baked into the runtime — JPEG / PNG / WebP decode and encode (libjpeg-turbo, libpng, libwebp + libsharpyuv vendored statically), bilinear and Lanczos resize, separable Gaussian blur, unsharp-mask sharpen, Sobel edge-detect, 90 / 180 / 270 rotate, flip, crop, brightness / contrast / saturation adjust, threshold, invert, grayscale, per-channel histogram, and Porter-Duff source-over alpha compositing. No npm install sharp, no Node-ABI-versioned binary distribution.

import image from "para:image";

const bytes = await Bun.file("photo.jpg").bytes();
const img = image.decode(bytes);
const small = image.resize(img, { width: 800, height: 600, kernel: "lanczos" });
const sharp = image.sharpen(small, { amount: 1.5 });
const webp = image.encode(sharp, { format: "webp", quality: 85 });
await Bun.write("photo.webp", webp);

para:audio

A from-scratch audio toolkit: WAV / MP3 decode, Opus encode and decode (libopus 1.6.1), rnnoise-based denoiser, FFT, RBJ Audio EQ Cookbook biquads (lowpass / highpass / bandpass / notch), resample, STFT spectrogram, mel spectrogram (Whisper-mode included for STT pipelines), voice-activity detection, AGC, peak / RMS / windowed envelope, mix, normalize, interleave / deinterleave, and PCM type conversion. Heavy codecs (libopus, minimp3, rnnoise) ship statically.

OS audio I/O is wired on Linux: audio.devices() enumerates ALSA capture and playback devices, audio.capture({ device, sampleRate, channels }) returns a stream whose .frames() async-iterator yields Float32Array PCM straight from snd_pcm_readi, and audio.play({ ... }).write(samples) pushes PCM through snd_pcm_writei. The capture stream exposes reactive peakLevel and active Signals — RMS rate-limited to 10 Hz so a level meter is one effect() away. CoreAudio + WASAPI mount on the same surface in follow-ups.

import audio from "para:audio";
import rtp from "para:rtp";

await using mic = await audio.capture({ sampleRate: 48000, channels: 1 });
const enc = new audio.OpusEncoder({ sampleRate: 48000, channels: 1, application: "voip" });
const den = new audio.Denoiser();
const agc = new audio.Gain({ targetLevel: 0.1 });

const ssrc = 0x12345678;
let sequence = 0, timestamp = 0;

for await (const frame of mic.frames()) {
  den.process(frame.samples);                                       // suppress noise (in place)
  agc.process(frame.samples);                                       // normalize loudness
  const opus = enc.encode(frame.samples);
  const packet = rtp.pack({ payloadType: 111, sequence: sequence++, timestamp, ssrc, payload: opus });
  // send `packet` over your transport (UDP, WebRTC, …)
  timestamp += frame.samples.length;
}

para:csv

Streaming RFC 4180 parser — async generator, full quote and escape handling, configurable delimiter, header mode that yields records keyed by column name, per-cell type inference (number / boolean / null). An opt-in parallel: true mode chunks the input across para:parallel's worker pool when the input has no quoted cells and is large enough.

import csv from "para:csv";

for await (const row of csv.parseCsv(Bun.file("rows.csv"), { header: true })) {
  console.log(row.id, row.name, row.score);
}

parallel: true is not a per-file speedup. The serial state machine is already memory-bandwidth-bound, and the parallel path's materialize-and-fork overhead grows with input size — so it helps a little at small files, breaks even around 50 MB, and gets worse from there. Use it to keep the event loop responsive while parsing (parsing N files concurrently does scale across cores), not because you expect bigger files to go faster. bench/parabun-csv-parallel/ reproduces these numbers.

para:camera

V4L2 capture on Linux. camera.devices() reads /sys/class/video4linux/ and runs VIDIOC_QUERYCAP on each to filter to actual capture devices. camera.formats(path) enumerates the supported (format, width, height, fps) tuples. camera.open(...) mmaps the kernel ring buffer and starts streaming, and cam.frames() is an async iterator of frames. AVFoundation (macOS) and Media Foundation (Windows) backends are planned on the same JS surface.

para:video

Scaffold only — the JS surface is in place (video.probe, video.decode, video.encode, video.decodeAll, with codec / container / acceleration options) but the native side hasn't been wired yet. The plan is libavcodec on desktop, V4L2 M2M on Pi 5, NVDEC/NVENC on Jetson, all behind the same JS API.

para:llm

An in-tree native inference stack covering three model classes: Llama / Qwen2 chat + completion (LLM), BERT-family sentence embedders (Encoder), and Whisper STT (WhisperModel). Weights mmap off disk; residual stream and KV cache live on-device. Per-token traffic across PCIe is a 4-byte argmax. Q4_K and Q6_K matVec kernels use a 1-warp-per-row, 4-warps-per-block layout; QKV and Gate+Up projections are byte-concatenated at load time and dispatched as one matVec per layer.

import llm from "para:llm";

using m = await llm.LLM.load("./Llama-3.2-1B-Instruct-Q4_K_M.gguf");

for await (const piece of m.chat([
  { role: "system", content: "You are helpful and concise." },
  { role: "user", content: "What is the capital of France?" },
])) {
  process.stdout.write(piece);
}

Numbers are within run-to-run noise of ollama on this model and hardware. Chat templates for Llama-3, ChatML, and Mistral-Instruct are detected from the GGUF's tokenizer.chat_template. Only the CUDA backend is wired in this module today; Metal kernels are pending.

llm.serve({ engine, modelId, port }) exposes any model (or anything else implementing .chat() / .generate() / .embed()) over an OpenAI-compatible HTTP API. Routes: GET /v1/models, POST /v1/chat/completions (sync and SSE streaming), POST /v1/completions, POST /v1/embeddings. Optional bearer auth and a FIFO concurrency gate (default 1). Default port is 11434, matching ollama's, so OpenAI clients that auto-discover a local ollama work unchanged.

WhisperModel loads whisper.cpp ggml-*.bin files (F32 / F16 / Q4_0 / Q5_0 / Q5_1 / Q8_0) and runs encoder-decoder STT — KV cache, chunked long-audio, beam search, language detection across all 99 Whisper languages. CUDA-accelerated end-to-end (encoder im2col conv + matmuls + per-head batched attention; decoder per-token matVecs + LM head). On an RTX 4070 Ti, an 11 s JFK clip transcribes in 1.6 s with tiny.en — about 6.9× real-time.

Both LLM and WhisperModel instances expose reactive para:signals Signals: m.busy (refcounted, flips while a chat / generate / embed / transcribe call is in flight) and m.device ("cuda" | "metal" | "cpu", stable for the life of the instance). Wire a busy spinner or a backend badge with a one-liner effect().

para:vision

vision.frames(stream, { decodeMjpg? }) takes a frame iterator from para:camera (or any source yielding the same shape) and yields packed-RGBA8 frames. yuyv, nv12, and rgb24 are converted inline; mjpeg requires the caller to pass image.decode from para:image (cross-builtin imports between bun: modules aren't supported, so dependencies are passed in at the call site). vision.detectMotion adds a downsampled-luma frame-diff estimator with temporal smoothing.

vision.detect (YOLO / SSD / RT-DETR) and vision.recognize (Tesseract / EasyOCR) are typed but throw — both need an ONNX runtime vendored before they can do anything. The interfaces are there so callers can write against them now and have them work later.

para:speech

speech.listen(stream, { sampleRate }) takes an audio chunk iterator (para:audio's capture stream, a file reader, anything yielding { samples }) and yields one utterance per detected speech burst. The classifier is RMS-against-an-adaptive-noise-floor, with pre-roll to catch word onsets, hangover to seal on silence, and a minimum-length filter to drop clicks and breath sounds.

speech.transcribe(utt, { engine: "whisper", model }) dispatches to the WhisperModel in para:llm, with a per-process model cache so the weights aren't reloaded between calls. speech.speak(text, { engine: "piper", model }) drives the Piper voice synthesizer (subprocess in v1, libpiper FFI v2 tracked) and returns f32 mono PCM at the voice's native sample rate, ready to hand straight to audio.play().write(). The listen stream also exposes reactive active / noiseFloor / lastUtterance signals.

para:assistant

The 3-line case. Composes para:audio (mic + speaker), para:speech (VAD + STT + TTS), and para:llm (Llama / Qwen2 inference) into a complete on-device voice loop: await using bot = await assistant.create({ llm, stt, tts, system });, then await bot.run(). Mic captures, VAD gates, Whisper transcribes, the LLM generates, Piper synthesizes, ALSA plays — fully local, no cloud round-trip. bot.turns() exposes the loop as an async iterator; bot.ask(text) skips STT for text-only turns; bot.say(text) pushes a proactive utterance.

Reactive surface: bot.state ("idle" | "listening" | "thinking" | "speaking"), bot.history, bot.lastTurn, and bot.interrupted are all para:signals Signals — wire them straight into UI without polling. Persistent memory is one option away: pass memory: "/path/to/memory.sqlite" and the conversation transcript replays into history on every create. Power users keep their seat — bot.llm exposes the underlying model, so anything reachable directly via para:llm / para:speech / para:audio is reachable through bot too.

para:arrow

In-memory columnar tables. arrow.recordBatch({ ... }) takes a map of typed arrays (or plain arrays — types are inferred) and returns a RecordBatch with a Schema. Columns are typed-array views with optional validity bitmaps; arrow.table([...]) concatenates batches across one schema. Computes: sum, mean, min, max, count, variance, stddev, quantile, median, distinct, filter, groupBy. fromRows / toRows bridge between row-shaped JS data (e.g. para:csv output) and the columnar form; concat materializes a table-wide column into one typed array.

arrow.toIPC(table) and arrow.fromIPC(bytes) handle both the Arrow IPC streaming format (continuation-prefixed Schema + RecordBatch messages) and the file format (ARROW1-bracketed messages + a Footer flatbuffer with random-access Block offsets). fromIPC auto-detects via the head/tail magic bytes. Pass "file" as the second arg to toIPC to write the file format; default is streaming.

Seven logical types round-trip: int32, int64, float32, float64, bool (bit-packed on the wire), utf8 (offsets + bytes), and list<T> (offsets + recursive child column — including list<list<T>>). On read, narrow ints (int8 / int16 / uint8 / uint16) are widened to int32, uint32 widens to int64; Date / Time / Timestamp coerce to int / int64. DictionaryBatch decode handles apache-arrow's default Dictionary<Utf8>. The FlatBuffers builder/reader is hand-rolled — no npm dep.

Wire compat verified against apache-arrow@21.1.0 in bench/parabun-arrow-ipc-interop/ — six round-trip directions (streaming + file × Parabun↔apache-arrow, plus Parabun→apache-arrow → Parabun for List). The bytes Parabun produces are the same wire format pyarrow, arrow-rs, nanoarrow, polars, and duckdb consume on both the streaming and file paths.

arrow.fromParquet(bytes) and arrow.toParquet(table, opts?) read and write Apache Parquet files. Hand-rolled Thrift compact-protocol codec, Snappy compressor + decompressor, dictionary + RLE + bit-pack hybrid decoders, RLE writer for definition levels — no npm dep. Covers BOOLEAN / INT32 / INT64 / FLOAT / DOUBLE / BYTE_ARRAY physical types under UNCOMPRESSED, SNAPPY, and GZIP. Verified end-to-end against pyarrow in both directions on 10,000-row multi-row-group fixtures with scattered nulls; null counts match exactly across all three codecs.