lumbda.

bend is a Lumbda primitive that decides per call whether to evaluate locally or ship to a CUDA worker over our wire protocol. Tiny inputs stay local; heavy inputs bend to a worker that holds a warm CUDA context across requests. The decision uses a cost estimator on the argument shape, not the operation name.

Start a GPU worker

# On any host with nvcc + a CUDA-capable GPU:
make gpu-worker
# → builds examples/cuda-fanout/shake256-fanout
# → builds the C tier (~10× faster wire orchestration than Python)
# → launches gpu-worker.lsp on TWO ports:
#     8320  — wire-TCP protocol (native callers: bend.lsp, asm clients)
#     8321  — HTTP/1.1 + CORS  (browser callers: the playground/REPL tabs)

# Port 8320 = BEND mnemonic:
#   8 ~= B (implied infinity B flattened; bake a cake; baby & me)
#   3 ~= E (backward)
#   2 ~= N (pivoted 90 degrees)
#   0 ~= D (flattened)
# Port 8321 = 8320 + 1 (HTTP is always wire-port + 1, override via --http-port).

# Override tier (default port stays 8320 / BEND):
make gpu-worker LUMBDA=python             # easier debugging
make gpu-worker LUMBDA=asm                # smallest footprint
# Override port too (only when running a second worker on the same host):
make gpu-worker LUMBDA=python PORT=9320   # second worker (wire 9320, http 9321)

Run your own bend → use it from a browser tab

Browsers cannot open raw TCP sockets, but they can fetch / XHR to http://localhost:<port> even from an HTTPS page (a permissive "potentially trustworthy" exception every major browser ships). So the playground field accepts a URL that points at a bend worker running on your own machine. No fox-owned ingress, no certificate, no proxy hop.

# 1. Start a worker on your laptop / desktop / homelab
git clone https://lumbda.com/lumbda.git && cd lumbda
make gpu-worker LUMBDA=python   # CPU works; CUDA path lights up if nvcc is present
# → "gpu-worker listening on port 8320"
# → "gpu-worker HTTP listening on port 8321"

# 2. In a separate shell, smoke-test the HTTP path
curl -sS -X POST -H 'Content-Type: text/plain' \
    --data-binary '(ping)' http://localhost:8321/
# → (ok pong)

# 3. Open https://lumbda.com/playground/ and paste into the ⚡ bend field:
#      http://localhost:8321/
# Save, then in the REPL:
#      λ> (bend!-call '(ping))

Both ports share the same handle-request dispatcher: whatever an op-head (ping, echo, cuda-shake-fanout, cuda-sim-ops-bin, …) returns over wire is what HTTP returns. Adding a new op-head exposes it on both transports automatically.

HTTP scope today is the S-expression text path — for browser-friendly recipes the server understands today, with no binary blobs crossing the wire. Binary modes (BSHK / BCGB / BSCP / BSRT / BSB3) stay wire-only because they exist for native callers who already hold the binary locally.

Phase 2 (deferred until authentication lands): upload an .lsp recipe describing a champion circuit, dispatch into a server-side factory that compiles the .bin on the worker's filesystem and bends it. Same playground field, same single endpoint. Auth gates write access; today a worker on the public internet would let any caller occupy your GPU.

Call it from any tier

;; bend works on every tier — Python, C, asm — through the same
;; tcp-* + portal primitives lumbda already ships.
(load "examples/cuda-fanout/wire.lsp")
(load "examples/cuda-fanout/bend.lsp")
(load "examples/cuda-fanout/bend-macros.lsp")  ; Python/C only — asm uses bend-call

;; Tiny — cost below threshold, evaluates locally
(bend (cuda-shake-fanout '("00" "01" "deadbeef") 32))

;; Heavy — cost above threshold, ships to the GPU worker
(bend (cuda-shake-fanout one-million-inputs 32))

Wire protocol

Two modes: S-expression text (the default) and binary (magic BSHK header + raw bytes). Binary mode bypasses S-expression parsing entirely.

Binary mode wins by 30–200× over S-expression at scale; at 1 M × 16 B inputs C tier binary is 157 ms vs 23,811 ms for S-exp, and bend beats host hashlib by ~12×. The CUDA toolchain stays isolated to the leaf binary the worker spawns — no tier links libcudart; asm tier hosts workers through hand-written pipe2 + fork + execve syscalls.

Fleet

Production default: single host. Multi-host fan-out is built (round-robin in bend.lsp via *bend-workers* + BEND_WORKERS env), available on demand for long-running parallel workloads — not used routinely.

3-node mesh active. 3090 + 4090 + P40 all serve bend workloads on port 8320 (BEND mnemonic). Round-robin or explicit selection via (bend-set-workers! '(("3090-ai.foxhop.net" . 8320) ("ai.foxhop.net" . 8320) ("cammy.foxhop.net" . 8320))). Cost-routed coordinator pattern: greedy bin-pack candidates by predicted cost; per-host wall factor 1.00 / 0.51 / 1.84 (3090 / 4090 / P40 — Pascal lags but contributes a third concurrent stream); one worker thread per node fires concurrently against our wire protocol. Each node serializes its own queue (workers do not multiplex requests cleanly inside one CUDA context). Full hardware table, bench numbers, & LLM-coexistence detail at foxhop gpu-mesh.

Worker health heartbeat

Every dispatch goes through a lazy-refresh health probe so bend never wastes a payload on a worker that is down, overloaded, or VRAM-starved. The worker exposes a (health) op returning measured numbers; the client caches results & ranks healthy peers by free VRAM descending.

Worker side — (health)

; over the same wire as any other op:
(health)
→ (ok (load-avg 0.42)
         (vram-free-mb 22777)
         (uptime-ms 1780752288371))

• load-avg — 1-minute load average from /proc/loadavg
• vram-free-mb — free VRAM from nvidia-smi --query-gpu=memory.free --format=csv,noheader,nounits; 0 on a host without an NVIDIA GPU
• uptime-ms — current wallclock (millisecond), so a worker that hangs & restarts between probes shows a uptime jump

Backward compatible: older workers without a (health) handler return (error (unknown-op health)) — the client treats that as ok with vram-free-mb=0 so a pre-heartbeat build still ranks as available.

Client side — *worker-health* cache

An alist keyed by "host:port" maps each known peer to a record (last-checked-ms status vram-mb) where status ∈ {ok, down}.

• Cache TTL on ok: 5 s. A fresh probe runs only when a cache entry ages past this; idle bursts never re-probe.
• Cooldown on down: 30 s. A worker that fails an (health) call or a regular dispatch gets skipped for half a minute before a re-probe, so a transient failure costs at most one call.
• VRAM-ranked pick. When more than one peer caches as ok, bend-pick-worker sorts by vram-free-mb descending & returns the top entry. Long-running jobs route to whichever box carries the most spare GPU memory.
• Round-robin fallback. When every worker is in down-cooldown, the client falls back to plain round-robin so a recovering box still gets a real attempt rather than refusing dispatch outright.

Failure handling

Mid-flight failures in bend-dispatch-to-gpu — tcp-connect raising on a connect-refused, the worker dropping a connection mid-reply, a malformed reply — flip the worker to down. The next pick skips it for the cooldown window. A single failed call never aborts a multi-worker iteration: probes wrap in with-exception-handler so a dead peer surfaces as 'transport-fail rather than propagating up.

Form catalog

A form earns a slot here only after we have published a benchmark or measured one on our hardware. "I think this would be fast" does not earn a slot — the form-status column says planned until numbers exist.

Status legend

• live — binary built, worker dispatches it, numbers recorded on our hardware
• surveyed — published benchmark cited, prototype binary not yet wrapped

Live forms

Surveyed forms (Wave 1)

Surveyed forms (Wave 2)

Sorted by reported speedup descending.

Surveyed forms (Wave 3)

Surveyed forms (Wave 4)

Wave 4 filter-outs: MAFFT MSA (11–20×, surpassed), RAxML likelihood (32× kernel only, ~3–10× end-to-end), AmgX CG (3–4× vs AmgX baseline), BVH Karras LBVH (2–3× over prior GPU LBVH), LDPC decode (40–160 Mbps, not ≥10× over modern SIMD CPU), mesh decimation (application-dependent), discrete Gaussian sampler (single-digit % gains; fold into Kyber NTT). Revisit when the published number changes.

Why a form earns its slot

A form is GPU-worth-it when at least one of:

1. Embarrassingly parallel. N independent items, no cross-item dependency.
2. Dense, branch-free inner loop. Same operation on every element.
3. Reduction-friendly. Tree-reduce / prefix-sum / parallel-scan patterns.
4. Big batch amortizes fixed kernel overhead.

When none of these hold, find a different decomposition: parallelize on a different axis, or stay on CPU & fan out across fleet hosts.

Source & specs

examples/cuda-fanout/ — wire contract, daemon protocol, bench data, per-tier integration.
CATALOG.md — canonical source for form metadata.