Touch Grass Birder: On-Device Bird ID in the Browser with Open-Weight AI

Vaibhav Agrawal — Sat, 10 Oct 2026 15:54:50 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass*

What I Built

Touch Grass Birder is an offline, on-device bird call identifier that runs entirely in your browser. Record 6 seconds of a bird call, get a species ID in seconds, then put your phone away and go find the bird.

It identifies 6,522 species using the BirdNET v2.4 open model, running locally on your device via ONNX Runtime WebAssembly. There is no server, no API key, and no internet required after the first load.

It's for anyone who's ever heard a bird on a trail, pulled out their phone, and realized their bird ID app doesn't work — because it needs a server round trip, and there's no signal where the birds actually are.

The whole design is built around minimizing screen time. The user taps "Record 6 seconds," sees the result, and is told to pocket their phone and go find the bird. The screen is the shortest part of the experience.

Demo

Live app: https://hacktoberfest-week1-challenge.vercel.app/

Repo: https://github.com/competitive-programmer04/_hacktoberfest_week1_challenge

With network — first-time setup:

Airplane mode. No network. Still identifying birds.

Code

Repo: https://github.com/competitive-programmer04/_hacktoberfest_week1_challenge

Key files:

frontend/src/audio.js — resampling and 3-second chunking with 1.5s overlap

frontend/src/inference-worker.js — ONNX Runtime WebAssembly session, sigmoid post-processing

frontend/src/model.js — model download, Cache Storage, and worker orchestration

frontend/src/pages/Record.jsx — the recording UX and result display

How I Built It

The entire stack is open-source. This project uses an open-weight model, an open-source inference framework, and local inference.

The stack:

BirdNET v2.4 — an open acoustic classifier from the Cornell Lab of Ornithology. 6,522 species, open weights, trained on real-world field recordings. I used the INT8 ARM variant (converted by tphakala) — ~47 MB, optimized for mobile CPUs.

ONNX Runtime Web — the open-source inference engine. Runs the model via WebAssembly directly in the browser, no installation, no backend.

React + Vite — the frontend.

vite-plugin-pwa — makes the app installable and offline-capable.

The pipeline:

Record 6 seconds via MediaRecorder, producing a WebM/Opus blob.

Decode and resample to 48 kHz using the Web Audio API.

Chunk into 3-second windows with 1.5-second overlap.

Send each chunk to a Web Worker running ONNX Runtime WebAssembly.

Run inference — the model outputs logits for 6,522 species.

Apply sigmoid to convert logits to confidence scores.

Sort and filter — top match plus alternatives, with a low-confidence fallback if nothing scores above 25%.

The caching strategy: the service worker precaches the app shell and the ONNX Runtime WASM files. The 47 MB BirdNET model is downloaded from Hugging Face on first load and cached in the browser's Cache Storage by model.js. After first load, every subsequent visit serves everything from disk — no network required.

A few things I had to learn the hard way:

PWAs can't run a Python backend. My first version was FastAPI + Python BirdNET. It worked, but it required a laptop nearby. If the model doesn't run on the phone, "offline" is marketing, not engineering. Porting to ONNX Runtime Web meant rewriting the entire inference pipeline in JavaScript.

The ONNX Runtime WASM file is 14 MB, not the 3 MB I assumed. Workbox's default precache limit is 2 MiB, so the build failed until I raised maximumFileSizeToCacheInBytes.

BirdNET uses sigmoid, not softmax. It's a multi-label classifier — multiple species can be present simultaneously. I initially used softmax and got nonsensical confidence scores.

Threaded WASM requires SharedArrayBuffer, which needs COOP/COEP headers. Single-threaded WASM is slower but works everywhere without special server config, and it's fast enough for a 3-second chunk.

Why Does Open Innovation Matter?

This project literally would not exist without open-source AI.

Offline is only possible with open weights. A closed bird ID API requires a network round trip. The best places to hear birds — deep forest, high alpine, remote wetland — are exactly where that round trip fails. Only an open-weight model can be downloaded to the device and run locally. This isn't a nice-to-have; it's the entire premise.

Privacy by architecture, not policy. A rare sighting is sensitive. It reveals where you were, when you were there, and what you saw. With a closed API, that data goes to a company server. With BirdNET running on-device, the audio never leaves your phone. Not because of a privacy policy because there is no server to send it to.

Zero marginal cost. No API bills, no rate limits, no monthly fees. A free public tool is only viable when the marginal cost of one more user is zero. With open weights, it is.

Portability and no lock-in. The same BirdNET model runs on Python, Node.js, a Raspberry Pi, and — as here — in the browser via ONNX Runtime. If a better runtime appears tomorrow, you swap it in without retraining. No vendor owns your pipeline.

Inspectable and modifiable. Anyone can inspect the model, fine-tune it on local species, or replace it with a different classifier. A closed system gives you a black box and a rate limit. This gives you a file and a license.