DEV Community: Gaurav Sethi

Touch Grass — A Bird ID App That Works When There's No Signal

Gaurav Sethi — Wed, 07 Oct 2026 06:48:02 +0000

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

What I Built

I built Touch Grass because identifying a bird call shouldn't mean uploading your life to someone else's server. Most nature apps work like this: you record audio, it ships to a cloud API, you wait, you get a result, and somewhere a company logs that you were near a lake at 7am. I didn't want any of that.

Touch Grass is a Progressive Web App that runs open-weight AI models entirely inside the browser. You record a 3-second bird clip, the app converts it to a mel spectrogram locally, and an ONNX model predicts the species — all without a network call after the initial download. The same approach works for plants and insects from photos. Once the model is cached in IndexedDB, the app works completely offline. No accounts, no tracking, no "please sign in."

It's for people who actually want to spend time outside. The whole philosophy is: identify quickly, then put the phone back in your pocket and enjoy the trees.

Demo

Live site: https://touch-grass-143.pages.dev

Install it like a normal app — the service worker caches the shell, the manifest is set up, and offline identification works after the first model download. I tested the PWA install on Android Chrome: add to home screen, open it, allow the mic, record 3 seconds, and you'll see results come back from the local BirdNET model with no signal required. I haven't done a long birding trip yet, but the whole point is that it works exactly where the map stops — on the trail with no bars.

Code

Gaurav5189 / touch-grass

A Progressive Web App that helps people identify birds, plants, and insects using open-weight AI models running entirely on-device. Works offline, keeps all data local, and minimizes screen time so you can get back to nature.

Touch Grass — Local-First Nature Identification PWA

A Progressive Web App that helps people identify birds, plants, and insects using open-weight AI models running entirely on-device. Works offline, keeps all data local, and minimizes screen time so you can get back to nature.

Philosophy: Identify quickly, then put the phone away and enjoy the outdoors.

Features

Bird Call ID — Record 3-second audio clips, identify species via BirdNET-ONNX (~20MB, quantized, 3000+ species), all on-device.
Plant & Insect Photo ID — Capture or import a photo, get top-5 matches from a MobileNetV3 model (~5MB), with descriptions and similar species.
Fully Offline — After initial model downloads, no internet required. Service worker caches the app shell; IndexedDB stores observations and model cache.
Private by Default — No accounts, no tracking, no server requests for inference. Optional GPS tagging is opt-in only.
Observation History — Auto-save after every identification. Filter, search, and export…

View on GitHub

Repo: Gaurav5189/touch-grass

Key parts worth looking at:

src/features/bird-id/ — AudioRecorder hook, BirdResults UI, RegionFilter
src/features/photo-id/ — CameraCapture, GalleryImport, MobileNet inference stub
src/features/history/ — Observation list, filters, CSV/JSON/iNaturalist export
src/workers/inference.worker.ts — ONNX Runtime Web with WebGPU preferred, WASM fallback
public/manifest.json + vite-plugin-pwa — full PWA setup

How I Built It

Stack is straightforward: React 18, TypeScript 5.3, Vite 5, Tailwind 3.4. Nothing exotic. The interesting part is what runs inside the browser.

Bird identification: BirdNET-ONNX (quantized INT8, ~20MB, Apache-2.0, 3000+ species). It runs in a Web Worker via onnxruntime-web, with WebGPU first and WASM fallback.
Plant / insect identification: MobileNetV3 + custom iNaturalist head (~5MB, Apache-2.0 / CC-BY data).
Offline storage: IndexedDB (idb) for observations and model cache; Cache API for the app shell.
Privacy: Zero server requests for inference. Optional GPS is opt-in only. No analytics, no telemetry.

I used OpenCode for the main structure — scaffolding the PWA, setting up the folder layout, and getting the build pipeline clean (CI with typecheck, lint, build). Then Antigravity helped with refinements and bug fixes — fixing TypeScript casting issues with navigator.gpu, cleaning up import paths for onnxruntime-web.d.ts, resolving build errors in useModelDownload, and fixing the Playwright / Vitest conflict so E2E tests could run separately.

The model strategy is open-weight all the way: BirdNET from the BirdNET-Analyzer repo, MobileNet weights fine-tuned on public iNaturalist data. All licenses documented in DOCS/RULES.md. No proprietary or GPL dependencies.

Why Does Open Innovation Matter?

If this was a closed API, you couldn't swap the bird model for a regional 8MB pack. You couldn't upload your own ONNX file for a custom species set. You couldn't verify that your audio isn't being stored somewhere else. And you definitely couldn't run it in a cabin with no signal.

Open-weight models make this possible because the weights are files you download, not services you call. The BirdNET team released their quantized model under Apache-2.0. The iNaturalist dataset is CC-BY. That means I can bundle them into a browser app without licensing anxiety or vendor lock-in. Open innovation here isn't a marketing line — it's the reason the app can work offline, stay private, and let users control which model they run.

Prize Categories

Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass
Open Source / Open Weight Models
Open Source AI Challenge

LocalCommit: Offline Conventional Git Commits with Local LLMs

Gaurav Sethi — Sun, 04 Oct 2026 21:20:48 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend (https://dev.to/challenges/hacktoberfest-weekend-2026-10-01)

What I Built

I built LocalCommit, a lightweight CLI tool that inspects your staged git diffs and drafts concise Conventional Commit messages (feat(auth): add refresh token rotation) running entirely on your local machine using Ollama.
I built this for my friend Manish, a software engineer working under strict client non-disclosure agreements. Manish's team requires strict Conventional Commits for automated changelogs and semantic releases, but company policy strictly forbids piping source code or git diffs to proprietary cloud LLM APIs (like OpenAI or Anthropic). Whenever Manish makes multi-file changes across large codebases, writing detailed conventional commit messages by hand slows down their workflow.
LocalCommit solves this by reading git diff --staged and running inference on an open-weights model locally. Zero tokens leave the machine, no API keys are required, and the tool works even when working offline on a train or during an internet outage.

Demo

Here is how running LocalCommit looks in terminal:

$ git add src/auth/token.ts src/middleware/jwt.ts
$ npx localcommit
[localcommit] Checking staged changes...
[localcommit] Sending diff to qwen2.5-coder:3b...

Proposed commit message:
  feat(auth): implement refresh token rotation and validation

Commit with this message? [y/N/e (edit)/r (regenerate)]: y
[main 7f2a1b9] feat(auth): implement refresh token rotation and validation
 2 files changed, 48 insertions(+), 6 deletions(-)
You can confirm with [y] to commit immediately, hit [e] to edit in place, [r] to regenerate with a slightly different phrasing, or [n] to cancel without touching git state.

Code

The source code and setup instructions are open source on GitHub:

Gaurav5189 / LocalCommit

Local-first CLI for generating conventional commit messages via Ollama.

LocalCommit

Local-first CLI for generating conventional commit messages with Ollama.

LocalCommit reads your staged Git diff, generates a Conventional Commit message with the configured local model, and asks for confirmation before committing.

Requirements

Node.js 18+
Git CLI
Ollama
A model configured in the root model file (default: qwen2.5-coder:3b)

If Ollama is not installed, follow the platform-specific instructions in INSTRUCTION.md.

Setup

npm run setup

The setup command verifies Node.js and Git, checks that Ollama is running, downloads qwen2.5-coder:3b if it is missing, installs dependencies, and builds the project.

If setup reports that Ollama is unavailable, install it and start the Ollama service by following INSTRUCTION.md.

Usage

Start Ollama in a separate terminal if it is not already running:

ollama serve

Stage your changes in a Git repository, then run:

npx localcommit

Inside a checkout of this project, npx localcommit resolves the local package binary. To use it from…

View on GitHub

Repository link: Gaurav5189/LocalCommit

How I Built It

LocalCommit is written in TypeScript and connects to Ollama (https://ollama.com/) running locally:

Default Model: By default, it targets qwen2.5-coder:3b—a fast, open-weights code model capable of running with low latency on modest CPU or laptop GPU hardware without draining battery.
Context Auto-Detection: Instead of assuming a static token limit, LocalCommit queries Ollama's /api/ps and /api/show endpoints at runtime to discover the exact context window allocated by your environment.
Two-Stage Summarization for Large Diffs:
Small diffs fit in a single prompt and produce an immediate message.
For larger, multi-file changes exceeding the context window, it switches to a hierarchical strategy: it prioritizes source code files (src/, tests/), generates concise per-file summaries bounded by a strict 60-second budget, and feeds that synthesized context into a final commit prompt.
Deterministic Post-Processing: Small local models can occasionally output markdown fences or descriptive preambles. LocalCommit passes the raw output through a deterministic formatting engine that enforces standard type(scope): subject syntax, cleans generic scopes, and converts verbs into imperative mood (add, fix, refactor).
Cross-Platform Host Detection: Handles network boundary quirks across Linux, macOS, Windows, and containerized setups (like Docker) by probing OLLAMA_HOST, 127.0.0.1:11434, and localhost:11434.

Why Does Open Innovation Matter?

Open-weights models and local runtimes like Ollama make use cases possible that cloud AI endpoints fundamentally cannot support:

Complete Data Sovereignty & Privacy: Codebases under NDAs, proprietary IP, or internal air-gapped networks cannot send raw git diffs over external APIs. Open models let developers use AI assistance without ever leaking code.
Offline Reliability: You don't need active Wi-Fi, metered bandwidth, or cloud service uptime to commit your work.
Zero Ongoing Costs & No API Keys: Developers don't have to manage credit cards, rate limits, or monthly token bills.
Flexibility to Swap Models: You can drop in any local model (e.g. llama3.2, codellama, deepseek-coder) simply by editing the model file or setting the LOCALCOMMIT_MODEL environment variable.

My Agent Session

The development session where I debugged the container connectivity issues and fixed the Ollama host resolution:

LocalCommit: Fixing cross-platform Ollama connectivity for containers

You

The setup script and CLI are failing to connect to Ollama in GitHub Codespaces because localhost resolves to ::1 but Ollama binds to [REDACTED]. Need multi-host resolution and proper URL construction.

Agent

I'll create a shared Ollama client utility for host resolution and fix both the setup script and CLI.

▸ write src/ollama-client.ts

Input

src/ollama-client.ts

Output

Created shared utility with getOllamaHosts(), ollamaFetch(), checkOllamaReachable()

▸ edit src/llm.ts

Input

src/llm.ts

Output

Updated to use multi-host resolution for /api/chat, /api/show, /api/ps

▸ edit src/env-check.ts

Input

src/env-check.ts

Output

Updated to use shared checkOllamaReachable()

▸ edit scripts/setup.js

Input

scripts/setup.js

Output

Fixed double-slash URL bug (new URL('/api/tags', base)) and reordered host priority

You

Build succeeded but setup still fails - need to debug the http.get call in setup.js

Agent

Found the issue - urlObj.toString() + '/api/tags' creates double slash. Fixed with new URL(path, base).

▸ edit scripts/setup.js

Input

scripts/setup.js

Output

Fixed URL construction using new URL('/api/tags', base)

You

Setup now works. But when model in 'model' file doesn't match installed Ollama model, error message is unclear. Add guidance to run 'npm run setup'.

Agent

Added special case handling for 404 'model not found' error with actionable message pointing to 'npm run setup'.

▸ edit src/llm.ts

Input

src/llm.ts

Output

Added model-not-found error handling with setup guidance

You

Now help me write a DEV post for Hacktoberfest Weekend Challenge submission.

Prize Categories

Hacktoberfest Weekend Challenge: Build for a Friend
Open-Source AI / Open Weights Integration (Llama 3.3, Qwen 2.5, gemma 4)
Local Inference & Edge AI (Ollama 100% offline laptop execution)

LICENSE

This project is open source and available under the MIT License.

Building LinkCut: A Sub-20ms URL Shortener with Next.js, FastAPI, and Redis

Gaurav Sethi — Mon, 24 Aug 2026 19:29:42 +0000

Hi, i'm Gaurav. This is my first post to dev.to

What is LinkCut?

LinkCut is a free, open-source URL shortener with no signup required — paste a link, cut it, share it. No accounts, no tracking cookies, no dashboard bloat.

🔗 Live app: https://linkcut-nine.vercel.app/
💻 Repo: https://github.com/Gaurav5189/url-shortener

Why I built it

I wanted to design a system where redirect latency actually mattered, not just a CRUD app with a UI wrapper. That meant thinking about caching, write-amplification, and decoupling reads from writes — not just "shorten a string and save it to a DB."

Architecture

The core idea: separate the fast path from the slow path.

Fast path (Edge Middleware): checks Redis first, returns a 302 redirect directly from the edge, and fires a non-blocking INCR for click tracking.
Slow path (Backend fallback): on a cache miss, FastAPI decodes the Base62 short code to an integer ID for an O(1) indexed lookup in SQLite, then repopulates Redis with a 12-hour TTL.
Background path (Cron): flushes Redis click counters into SQLite periodically using an atomic Lua script — read-and-delete in a single Redis transaction, so counts never get double-counted or lost.

This keeps redirects fast (sub-20ms) while analytics writes stay off the hot path entirely.

Tech stack

Frontend/Edge: Next.js (App Router) on Vercel Edge Middleware
Cache/Counter: Redis
Backend: FastAPI
Database: SQLite
Encoding: Base62, 5-character codes from auto-incrementing IDs (~916M capacity)

What I learned

I underestimated this going in. The URL shortening part is trivial — the interesting engineering is in the caching strategy, avoiding database write-amplification on every click, and making sure the analytics counter flush is atomic so nothing gets lost or double-counted under concurrent traffic.

Feedback on the caching strategy or architecture decisions welcome — always looking to improve it.