Model Nano · on-device hmbrd.dev →
On-device · no server WebGPU

Inference that never leaves this tab.

Model Nano is the smallest model in the HummingRelay lineup, and the only one that runs on your own GPU. A 1.7B-parameter language model, executed in the browser by hand-written WGSL kernels. No endpoint, no API key.

How it works

The first run downloads 1.1 GB of weights from this origin and keeps them in browser storage. After that the model starts without a network.

This device
checking WebGPU…
Weights · browser storage model-nano-q4km.gguf
Model Nano WGSL kernels · your GPU
tokens → this tab local
inference server none
requests per prompt zero

The weights are fetched once and cached in the browser's private storage (OPFS). From then on, prompts, tokens and replies stay inside the tab.

01 / The model

One small model. Entirely on your device.

Model Zero and Model One run on HummingRelay infrastructure, behind the API. Model Nano takes the other route: the weights come to you, and the GPU you already own does the work.

On-device Runs locally

Model Nano

LFM3-1.7B · Q4_K_M · GGUF

A compact language model for short answers and quick drafts. The whole model is a 1.1 GB file that loads into GPU memory.

  • Short answers
  • Drafts
  • Summaries
  • Simple code
Parameters
1.7B
Quantization
Q4_K_M
Weights · one download
1.1 GB
Layers
24 · 13 conv, 11 attention
Hidden width
2,048
Vocabulary
128,000
Context window
4,096 tokens
Runtime
WebGPU · WGSL
Network after first load
None

Speed and memory depend on your GPU, so they are not listed here. The console shows what this device actually measures once the model is running. The API models are in the HummingRelay model catalog.

02 / How it works

Four steps. All inside the tab.

From a file in browser storage to a word on screen. There is no general-purpose runtime in between: the kernels are written for this one model.

  1. Read the GGUF file

    The browser parses the header, the vocabulary and the tensor table. It is the same .gguf format llama.cpp uses; nothing is converted.

  2. Move quantized weights to the GPU

    Q4_K, Q5_K and Q6_K blocks go into GPU buffers as they are. They are never expanded to 32-bit floats, which keeps memory low.

  3. Run the WGSL kernels

    Compute shaders unpack the weights on the fly and run all 24 layers: convolutions, attention, normalization and the output logits.

  4. Stream tokens

    The next token is sampled from the logits, the BPE tokenizer turns it into text, and it appears in the console right away.

import { ModelNano } from "./nano.js";

const engine = await ModelNano.create({
  modelUrl: "./model-nano-q4km.gguf",
  cache: "opfs",  // keep the weights in browser storage
});

const messages = [{ role: "user", content: "Explain WebGPU in one line." }];

for await (const ev of engine.generate(messages, { maxTokens: 256 })) {
  if (ev.type === "token") write(ev.text);
  if (ev.type === "done") console.log(ev.stats.tokPerSec);
}
Event shape · engine.generate()
{ type: "token", text, id, thinking }
{ type: "done", finishReason: "stop" | "length" | "abort", stats }

stats: { promptTokens, cachedTokens, promptMs, ttftMs, genTokens, genMs, tokPerSec }

The engine is plain ES modules: no bundler, no framework, no runtime dependency. This page uses the same interface.

03 / Speed

Measured, not promised.

Generation speed in tokens per second, against other ways to run the same weights on the same hardware. No number appears here until it has been measured.

Reading benchmark results…

04 / Privacy

What stays. What travels.

There is no server behind this page that could receive a conversation. Here is exactly what touches the network and what never does.

Stays on your device

Local
  • Prompts and replies

    Text becomes tokens and is processed by this device's GPU. The conversation lives in the tab's memory and is gone when you close it.

  • The weights, after the first run

    The model file is kept in OPFS, the browser's private storage for this site. Later runs load it from there.

  • Your settings

    Sampling parameters and the system prompt are saved in this browser's local storage, nowhere else.

Crosses the network

Once
  • The page itself

    HTML, styles, scripts and fonts, all served from this origin. No CDN, no third-party fonts, no analytics.

  • The weights, one time

    1.1 GB, downloaded from this origin on the first run. Skipped on every run after that.

  • Nothing else

    Generation makes no requests at all. You can go offline after the first load and keep working.

Small model

Fast and private is not the same as right.

Model Nano is small. It is good at short answers, drafts and simple code, and like any model of this size it can be wrong, sometimes confidently. Check anything that matters.

Larger models
05 / FAQ

Questions, answered plainly.

01Do I need an internet connection?

Only to open the page and to download the weights once, 1.1 GB. They are saved in browser storage, so later runs start without a network. Generation itself never uses the network.

02Where do my messages go?

Nowhere. Text is turned into tokens and processed by the GPU in this device. The page has no server that could receive a conversation and loads no third-party scripts.

03Which browsers are supported?

You need a browser with WebGPU. Model Nano is developed and tested in desktop Chrome. Other WebGPU browsers may work but have not been verified. If WebGPU is unavailable, the page says so before it downloads anything.

04How much memory does it need?

The weights take about 1.1 GB, plus buffers for the context. The console reports the GPU memory actually in use once the model is loaded.

05Why is the first start slow?

It has four stages: download the file, move the weights into GPU memory, compile the shaders and warm them up. From the second run on, the download is skipped.

06How does it relate to the HummingRelay API?

Model Nano is part of the same lineup but needs no account, key or credits: it runs on your hardware. Model Zero and Model One are larger models served through the HummingRelay API.

The model is already here.

Load it once. After that it starts from browser storage and answers without a network.

Explore API models