RAMANUJAN

EDGE · WEBGPU · 0.92 MB

React,
don't generate.

A 5.94M-parameter span encoder that answers the fragment you highlight — in the page, on your GPU, with no server in the loop.

● RECONCILING · 110 EDGES

5.94M

PARAMS

8192

BYTE-BPE

6L · 256d

ENCODER

0.92MB

TARGET DISK

<10ms

PER REACTION

0

API CALLS

01 — REACT

Highlight half a sentence.

The selection is the input. The bubble is the output. Nothing leaves the tab.

ANY PAGE · CONTENT SCRIPT · CLOSED SHADOW ROOT
The ranking stage uses MMR to trade relevance against redundancy, then hands the surviving candidates to the pointer head. Because every character it emits was already on the page, the failure mode is honest: below threshold, the bubble says the page never explains the term instead of inventing one. Inference happens through WebGPU, so the weights are dequantised straight into GPU buffers on load, and the tab keeps them warm — pipeline creation is the one-time cost, not the reaction. Upstream, the edge worker will reconcile its observed status against the expected state held by the central network.

SELECT ANY FRAGMENT ABOVE ↑  ·  INTERACTION PREVIEW, CANNED REACTIONS

INPUT

span + [S] markers + ±150 tokens of context

OUTPUT

≤ 40 tokens, one bubble, one pass

WHY NOT SUMMARISE

Shortening text you already chose to read is not a feature. Explaining what you didn't understand is.

02 — MODEL

One encoder. Two heads.

A bidirectional pre-norm trunk. One head points at text already on the page. One writes. The trunk is the same either way, so the output head stays a swappable fork.

SELECTION IN CONTEXT …uses [S] MMR [/S] to trade relevance… byte-level BPE · 8192 SPAN ENCODER · BIDIRECTIONAL layer 1 — attn 4h · ffn 1024 · GELU layer 2layer 3 layer 4layer 5 layer 6 × 6 sinusoidal positions · 0 params HEAD A · POINTER bilinear span scorer verbatim · 0 hallucination null class + threshold +0.13M params HEAD B · WRITER 4L copy-decoder cross-attends to encoder ≤ 40 tokens, capped +6.6M params · planned ZERO NEW WGSL — FORGE'S OP SET COVERS ALL OF IT

D_MODEL

256

EMBED RANK

128, factorised

HEADS / D_FF

4 / 1024

MAX SEQ

256

NORM / ACT

LayerNorm pre-norm / GELU

POSITIONS

sinusoidal · 0 bytes

COMPUTE / PASS

≈ 2.5 GFLOP @ 192 tok

FORMAT

.fzm · per-group affine q4

03 — SIZE

Small enough to bundle.

Trained from scratch, so the aggressive compression is available from step zero — not bolted on after. Under a megabyte means the weights ship inside the app. No download, no CDN, no cold start.

fp32 baseline

23.7 MB

q4 everywhere · shipping today

3.0 MB

q4 embed + 1.58-bit encoder

1.55 MB

+ 2 shared layers × 3

0.92 MB

3.65MB

CHECKPOINT ON DISK NOW

~20ms

LAPTOP iGPU, PER REACTION

f32

DEQUANTISED AT LOAD · NO NEW KERNELS

04 — EDGE

The edge is the
deployment target.

Not a degraded fallback for when the network is down. The model is built to live on devices and edge clusters, reached through WebGPU — a browser API, not a vendor endpoint. Nothing here is lockable behind someone's backend.

CONTROL LOOP OBSERVE DIFF APPLY EXPECT edge task status observed vs expected weights · thresholds · policy remote network state

01 · NO BACKEND LOCK-IN

Weights bundled, runtime is forge compiled to WASM + WGSL. The only dependency is a GPU the browser already exposes.

02 · FANS OUT TO A CLUSTER

At 0.92 MB and 2.5 GFLOP a reaction, one model instance per node is free. Scale is replication, not routing.

03 · RECONCILES, DOESN'T CALL

Edges report observed task status upward; the centralised network holds the expected state and streams the delta back down. Convergence is continuous and asynchronous — the reaction never waits on it.

04 · DEGRADES HONESTLY

Offline, an edge keeps reacting from the weights it has. The loop resumes when it can reach the centre again.

05 — STATUS

Built in the open,
from scratch.

No pretrained checkpoint, no fine-tune of someone else's model. Tokenizer, corpus, encoder and training loop are all in this repo, and stage A is running on a single A5000.

CORPUS

12.3B tok

FineWeb sample-10BT → byte-BPE 8192

MLM LOSS

20.9 → 3.55

unigram floor 7.29 nats

THROUGHPUT

29.7k tok/s

A5000, batch 32 × 256, masked-row head

HARDWARE

1 GPU

24 GB, 2.5 GB used at this batch

P0a

Encoder + pointer head in Rust on forge, .fzm round-trip

DONE

P0b

Byte-level BPE tokenizer + FineWeb preprocessing

DONE

P2

MLM pretraining, batched autograd on WebGPU/Vulkan

RUNNING

P1

Bubble + offscreen WebGPU runtime on real pages

NEXT

P3

Selection mining + teacher labelling, train Head A

PLANNED

P5

Head B copy-decoder · ternary QAT · cross-layer sharing

PLANNED