Doppler is an evidence-backed JavaScript and WGSL WebGPU runtime for local model inference. It loads deliberately supported RDRR artifacts and runs generation, embedding, and reranking in browsers and Node. Bun lanes remain experimental. Candidate manifests, execution plans, and kernels pass scoped correctness and benchmark gates before they can support a product claim.
Doppler’s mission is to make model execution inspectable at the artifact, kernel, and receipt boundary.
The current goal is to make local inference lanes easier to compare and improve. An engineer can change a manifest, execution plan, or WGSL kernel; parity checks compare the output with a reference; benchmark checks compare the same workload with the retained lane; the receipts record why the candidate was retained or rejected.
Doppler serves:
- Application builders who need local generation, embeddings, or reranking.
- Runtime engineers who work on model loading, kernels, scheduling, and GPU execution.
- Adapter and training engineers working with SafeTensors LoRA artifacts.
- Evidence reviewers who need the model, workload, parity result, and timing receipt behind a comparison.
Run the CLI without installing a global package:
npx doppler-gpu "Summarize WebGPU in one sentence"
npx doppler-gpu --model qwen3-0.8b --prompt "Write a haiku about GPUs"
npx doppler-gpu --list-modelsThe live browser demo is at d4da.com/doppler. The first documentation path is getting started, followed by the Pack Runtime API.
import { createFetchPackArtifactStore, openPack } from 'doppler-gpu';
const packUrl = new URL('./model.pack.json', import.meta.url).href;
const artifactStore = createFetchPackArtifactStore(packUrl);
const pack = await (await fetch(packUrl)).json();
const session = await openPack(pack, {
device,
artifactStore,
trustedSigners: new Map([[signerId, signerPublicKey]]),
programFactory,
});
const result = await session.generateText(generationOptions);
console.log(result.text, session.selectedTargetPlanDigest);
await session.close();The application supplies its device adapter, trusted signer set, and generic program factory. Pack validation selects one qualified TargetPlan; TargetPlan v2 additionally binds the loaded program's observed initial execution identity before resource allocation or prefill dispatch.
The former manifest-loading facade remains available only as an explicit compatibility import:
import { dr } from 'doppler-gpu/compat';
const session = await dr.open('qwen3-0.8b');
const result = await session.generate('Describe WebGPU briefly');
await session.close();npx doppler-serve --model qwen3-0.8b --port 8080The server accepts requests at http://localhost:8080/v1. Registry IDs resolve
to hosted RDRR artifacts from clocksmith/rdrr by default.
npx doppler-gpu lora --config ./workload.json --surface nodeDoppler supports SafeTensors LoRA loading and hot swap at runtime. SFT/LoRA
training is available through the experimental Node, Bun, and browser training
surface. Cataloged adapter identities and lifecycle states are listed in
models/adapters/catalog.json. See the
LoRA format, training handbook,
and Training API.
Doppler classifies artifacts by what they consume and produce. This is
separate from lineage (family), runtime implementation (modelType), and
artifact-size tier.
| Type | Input → output | Runtime-verified / cataloged | Representative lanes |
|---|---|---|---|
| Text generators | text → text | 12 / 14 | gemma-3-1b-it-q4k-ehf16-af32 gemma-3-270m-it-f16-af32 gemma-3-270m-it-q4k-ehf16-af32 +11 more |
| Multimodal generators | audio + image + text → text | 3 / 3 | gemma-4-e2b-it-q4k-ehf16-af16-int4ple gemma-4-e2b-it-q4k-ehf16-af32 gemma-4-e2b-it-q4k-ehf16-af32-int4ple |
| Diffusion language models | text → text | 0 / 1 | diffusiongemma-26b-a4b-it-q4k-ehf16-af16 |
| Translation specialists | text → text | 2 / 2 | translategemma-4b-1b-enes-q4k-ehf16-af32 translategemma-4b-it-q4k-ehf16-af32 |
| Language embedders | text → pooled-embedding | 2 / 2 | google-embeddinggemma-300m-q4k-ehf16-af32 qwen-3-embedding-0-6b-q4k-ehf16-af32 |
| Rerankers | text-pair → relevance-score | 2 / 2 | qwen-3-reranker-0-6b-f16-af32 qwen-3-reranker-0-6b-q4k-ehf16-af32 |
| Protein encoders | protein-sequence → pooled-embedding + token-embedding + token-logits | 3 / 3 | amplify-120m-f16-af32 esm2-t12-35m-ur50d-f32-af32 esmc-300m-f32-af32 |
| Nucleotide encoders | dna-sequence → pooled-embedding + token-embedding | 1 / 1 | nucleotide-transformer-v2-50m-f32-af32 |
The full model-support matrix lists every lane and its lifecycle evidence. Classification says what an artifact is shaped to do; only lifecycle receipts establish what is verified, and a runtime pass does not by itself qualify every declared input modality.
Doppler has accepted browser WebGPU comparisons with higher steady-state inference throughput (higher is faster) than Transformers.js where the declared workload correctness and throughput gates pass. Loading is a separate measurement; the referenced Vulkan embedding and reranker artifacts load faster in Transformers.js. The scoreboard links the receipts and the benchmark methodology defines the gates.
flowchart TB
C[Candidate manifest, plan, or WGSL] --> V[Validate contracts]
A[RDRR artifact] --> V
R[Request and runtime profile] --> V
V --> X[Resolve execution graph]
X --> L[Load and bind]
L --> D[Dispatch WGSL]
D --> O[Tokens, embeddings, or scores]
O --> P{Parity gate}
P -- fail --> N[Reject with finding]
P -- pass --> B{Benchmark gate}
B -- fail --> N
B -- pass --> K[Retain lane and receipt]
Candidates enter through manifests, execution plans, or WGSL kernels. The runtime validates the artifact and request, resolves the execution graph, loads the model and buffers, dispatches the selected kernels, and reads back the result. A failed parity or benchmark gate rejects the candidate. A passed candidate becomes a versioned lane with a receipt.
Doppler is intended to support a growing set of local model families and runtime variants without hiding the model contract or execution path. Registered variant calibration, paired performance gates, and WGSL experiments remain human-reviewed. Ouroboros and Reploid sit above Doppler as orchestration or product layers; Doppler owns the artifact and execution boundary.
New model families require RDRR conversion and may require tokenizer, graph, or kernel support. Native packed-Q4K LoRA support is available for the declared Qwen target; other packed-Q4K training targets use external backends.
WebGPU is required. Use a current Chromium browser; Node installs the WebGPU provider as an optional dependency. A runtime pass does not verify every input modality, and a receipt records what ran without establishing output quality. Throughput comparisons are valid only when the workload, timing scope, and correctness path are comparable. Unsupported paths fail closed.
- Component charters — recursive repository and subsystem intent
- Component index — generated authority and parent map
src/— runtime, model loading, inference, and execution contractsdemo/— browser demo and its public API boundarymodels/adapters/— adapter catalog, lifecycle, identity, and evidence metadatabenchmarks/— vendor comparisons and retained resultsdocs/— APIs, architecture, formats, methodology, and release matricestests/— runtime, contract, browser, and benchmark teststools/— conversion, qualification, and operator tools
MIT License. See NOTICE for attribution.