What I Built
Most AI interfaces invite another message. I wanted this one to end with the phone in my pocket.
Pocket Wild turns a little context about your surroundings into three short nature-noticing missions: something to listen for, something to look at, and something to watch. Read the card, start a 10-, 20-, or 30-minute pause, then put the phone away. A seated outdoor pause counts too.
When you return, write what you actually noticed. Gemma can turn those observations into an editable field note, or you can keep your exact words. Optional photographs and completed notes become a local field journal.
The deliberate constraint is that AI gets two small jobs: help you begin, and help you reflect. It does not accompany you through an endless conversation. There is no feed, leaderboard, account, GPS tracking, or claim to identify species from a photograph. The interesting part should happen outside the interface.
Demo
Try Pocket Wild on Render · Watch the demo on YouTube
The field-note screen brings the reflection, local photo attachments, and app-visibility timing together. “Away” means this app was hidden—not verified outdoor time or phone-wide screen time. Photos are journal attachments, not inputs to the model.
For a first visit, use a compatible WebGPU browser and Wi-Fi: the model download is approximately 900 MB. Once the app, runtime, and weights are cached, the tested Gemma flow also works after an offline reload. A separately labelled preset option lets people try the interaction without loading the model.
Code
Application code is MIT licensed. Gemma retains its own model terms; the repository licence does not replace them.
How I Built It
The interface is plain HTML, CSS, and JavaScript. A dedicated worker runs Gemma 3 1B's community ONNX export using Transformers.js and ONNX Runtime Web. Model revision and dependency versions are pinned. The tested Mac path uses WebGPU with four-bit weights; there is no inference API key or remote inference endpoint.
IndexedDB stores the active draft and up to 30 completed walks, including optional local photo blobs. The walk timer freezes when you tap “I'm back,” so writing the reflection does not inflate the walk duration. Page Visibility measures whether this app is visible, with that limitation stated in the UI.
An exported evidence file records the actual engine, model revision, backend, quantization, inference duration, raw output, connection flag, and whether the reflection was edited. It excludes photo bytes. That makes “Gemma generated this” something inspectable rather than just a badge.
Small models still need boundaries
An early 270M prototype ran quickly, but invented scenery and expanded observations into unsupported weather and sensations. Switching to 1B improved the reviewed examples at the cost of a larger download. It did not eliminate hallucinations.
I kept the original observations separate, made the reflection editable, and added an option to save the person's exact words. A pleasant sentence is not worth replacing what somebody actually saw.
Constrained JSON decoding enforces three mission fields. Implementing it exposed a tokenizer/logits vocabulary mismatch; a grammar-only adapter excludes unreachable tokens without changing normal tokenization. The earlier model export also required a newer ONNX runtime. Both were useful reminders that an open model is a stack of compatible parts, not a single file you drop into a page.
Offline means testing a fresh load
Caching weights was only half the work. The service worker also caches the app and inference runtime. A cold offline test caught a metadata request to the mutable main branch despite the pinned model revision; loading the model components directly with a pinned URL template removed that dependency.
A hosting file-size constraint prompted another packaging change: the runtime is distributed as four smaller binary pieces, reassembled and SHA-256 verified before execution. The dependency binary itself is unchanged.
On the public Render deployment, the reviewed Mac/WebGPU fixtures produced three contextual cards in 0.825, 0.814, and 0.890 seconds, and a reflection in 0.550 seconds. After an offline reload, loading cached weights took 1.652 seconds, followed by a new card in 0.886 seconds. These are observed test timings, not guarantees for other devices.
The verification includes 11 unit checks and nine browser checks against the public deployment. The full offline Gemma flow, evidence download, and journal reload passed without browser errors or failed requests in the recorded run. Actual phone/browser coverage and outdoor usability still need broader testing.
Why Does Open Innovation Matter?
For this project, the benefit is concrete: a person's observations do not have to travel to an inference server before becoming a field note. Once everything is cached, the tested inference path does not need network coverage.
The open-weight model and open-source runtime also made failures inspectable. I could compare model sizes, trace compatibility problems, repair the offline loading path, and publish the evidence. Someone else can inspect the prompts, improve the validators, or swap the model export without depending on a private service I control.
There are real trade-offs. The first download is large, browser storage can be evicted, GPU support varies, and the local journal is not encrypted. Asset providers receive normal download requests. Local inference reduces what the app sends away; it does not make every privacy or reliability concern disappear.
Pocket Wild is small on purpose. The model supplies a starting point, but the person supplies the experience—and has the last word about how it is recorded.
Prize Categories
- Best Use of Gemma: Gemma performs the two core AI tasks locally: generating a contextual field card and drafting a reflection from observations. Exported evidence records actual inference; preset mode is explicitly separate.
- Best Use of Render: the live Render Static Site hosts the complete application and packaged inference runtime, built from the public GitHub repository. Render delivers the app; the visitor's device runs the model.
- Best Use of GitHub Copilot, through the GitHub Actions criterion: the challenge explicitly accepts project automation with GitHub Actions for this category. Pocket Wild uses a passing workflow for unit tests, production builds, and browser checks. This entry is based on Actions automation, not a claim that Copilot wrote the code.
Top comments (0)