t0-alpha Q8_0, WebGPU

Q8_0-quantized weights for theforecastingcompany/t0-alpha, packaged for client-side browser forecasting via WASM + WebGPU.

Runs entirely in the browser, no server required. Probabilistic multi-horizon time-series forecasting, ~102M parameters.

Try the demo →

What you gain, what you lose

On one us_births window, the largest deviation from the F32 reference is 0.20% of the series range for this Q8_0 file against 0.79% for the official INT8 ONNX export, at about the same size (109 MB), and the single-signal browser forecast takes 34.5 ms against 64.0 ms (Apple M2). Both were measured against the t0-alpha-onnx-int8 revision 1c18a3e2. The Forecasting Company later fixed a float32 precision issue in that export's input normalization (2026-10-18), which affected long histories whose values sit far from zero relative to their variation, such as us_births. On the full 97-config GIFT-Eval protocol it costs +0.04% MASE and +0.02% CRPS against our own F32 control, within 0.25% of the published t0-alpha card.

Files

Usage

These weights are consumed by t0-web, a Rust/WASM forecasting engine: its own WGSL kernels on WebGPU, and Burn's ndarray backend on CPU.

await t0wasm.initBackend();
const modelBuf = await fetch('t0-alpha-q8_0.gguf').then(r => r.arrayBuffer());
const model = t0wasm.T0Wasm.load(new Uint8Array(modelBuf));

const context = series.slice(-512);
const quantiles = await model.forecast(context, 32);

Weights are fetched from this repo and cached by the browser.

Requirements

• WebGPU when available (Chrome or Edge 113+, over HTTPS), otherwise CPU (WebAssembly)
• ~109 MB download on first load (cached afterward)

Pipeline

Series → patches of 32 (96-vector each)
  → 24 transformer blocks [WASM, WebGPU] → time and group attention, embed 512
    → 32-step quantile decoder → 5 quantile levels
      → autoregressive rollout for longer horizons

Benchmarks

GIFT-Eval, full 97 configs, normalized to Seasonal Naive

Isolating quantization from any pipeline effect (Q8_0 vs our own F32 control): +0.04% MASE, +0.02% CRPS, at 0.27x the F32 file size. The same protocol on the Q4_0 export gives 0.7334 / 0.4973.

Drift vs our own F32 reference (54 synthetic cases)

Inside the 2% mean / 10% point drift gates The Forecasting Company states on its t0-beta INT8 card.

Browser latency (headless Chromium, Apple M2, single signal, context 512)

Single-call latency is lower than the official ONNX export's (34.5 vs 64.0 ms). Batched throughput is slower on this file (11.2 vs 8.87 ms/signal). Both were measured against the t0-alpha-onnx-int8 revision 1c18a3e2, before its 2026-10-18 re-export.

These time the forecast call alone; the demo page shows the full round trip, about 40 ms on the same M2.

Model Details

• Base model: theforecastingcompany/t0-alpha by The Forecasting Company
• Architecture: Patch transformer, time and group attention
• Parameters: ~102M
• Quantization: Q8_0 for attention.wQKV.weight, attention.wO.weight, mlp.0.weight, mlp.2.weight per layer; norms, embeddings, biases, and the quantile head kept at f16
• Quantile levels: 5 (0.1, 0.25, 0.5, 0.75, 0.9)
• License: Apache-2.0 (same as original), see LICENSE and NOTICE

Quantization

Weights-only quantization using standard GGUF Q8_0 blocks (32 values per block, fp16 scale), in ggml-compatible layout, dequantized on-GPU inside the WGSL matmul with F32 compute. Exported from the F32 safetensors by t0-web's own packer. The F32 path itself matches the PyTorch reference to 1.2e-6 max-abs.

Citation

@article{meyer2026t0,
  title   = {$t_0$: A Time-Series Foundation Model for Forecasting with Context},
  author  = {Meyer, Lucas and Sole, Claudio and Xiang, Huikan and Li, Nicolas and Franceschino, Lucas and Quera-Bofarull, Arnau and Scholl, Maarten P. and Fainberg, Joachim and N{\'e}giar, Geoffrey},
  journal = {arXiv preprint arXiv:2609.24559},
  year    = {2026},
  url     = {https://arxiv.org/abs/2609.24559},
}

Disclaimer

This is an independent port by idle-intelligence, not affiliated with or endorsed by The Forecasting Company. Forecast values may differ slightly from the original PyTorch implementation due to quantization.