fieldmemo: keep the phone in your pocket, talk to it, get a field journal at home

Darren — Wed, 07 Oct 2026 22:06:52 +0000

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

AI disclosure: I built this with an AI coding agent, which wrote most of the code and the first draft of this post. I read it, watched the demo and approved the text. Everything below about what worked and what broke comes from the build log in the repo, not from memory.

What I Built

fieldmemo turns the voice memos you record on a walk into a field journal, on your own machine, with no internet.

The idea is that the phone stays in your pocket. When you see something, you press record and say it: "two buzzards circling over the ridge", "the stile after the second field has a broken step, report it to the council", "come back for the blackberries next September". No app to open, no form to fill in, no typing with cold fingers. Then you put the phone away and keep walking.

At home you run one command on the folder of memos, plus the GPX track from your phone or watch if you recorded one:

fieldmemo walks/2026-10-08/memos --gpx walks/2026-10-08/track.gpx

and get three files:

journal.md: what you saw, what you heard but didn't see, path problems with a map link for each, a to-do list, and a timeline with every memo's transcript.
walk.geojson: the track and a pin for each memo, for QGIS, uMap or geojson.io.
notes.csv: one row per sighting, hazard or to-do.

It's for walkers, birders and ramblers who want a record of a walk without spending the walk looking at a screen, and for anyone who reports broken stiles and flooded paths to their council and wants the time and position written down for them.

Demo

That's the full run on the sample walk in the repo: seven memos in, journal out, about 48 seconds on an 8-core CPU with no GPU. This is the "At a glance" block it wrote, with only the map links shortened:

**Seen:** buzzard, fly agaric x12, blackberry

**Heard (not seen):** green woodpecker

**Path problems**
- 10:02 ground: soaked from last night (map)
- 10:02 path: by the first gate is basically a pond (map)

**To do**
- 10:41 stile: note to self the style after the second field has a broken step; report it to the council rights of way team when i get home (map)
- 11:37 tub: come back with a tub in early September next year (map)

One thing to be upfront about: the sample walk is synthetic. The memos are spoken by Piper, an open-source text-to-speech engine, with brown noise mixed in to imitate wind, and the GPX track is a made-up loop. I did that so anyone can rerun the exact demo, but a TTS voice is much cleaner than a real person on a windy hill, so treat the accuracy here as a best case.

Code

darrenmakes / fieldmemo

Voice memos + GPX track -> offline field journal, map layer and CSV (Whisper + Gemma 4 via Ollama). AI-assisted build.

fieldmemo

Talk on the trail, read it at home.

Keep your phone in your pocket on a walk. When you see something, press record and say it "two buzzards over the ridge", "stile after the second field is broken", "come back for the blackberries next September". Afterwards, point fieldmemo at the folder of voice memos (and the GPX track from your watch or phone, if you have one) and it writes:

journal.md: a readable field journal. What you saw, what you heard, path problems with map links, a to-do list, and a timeline with every memo's transcript.
walk.geojson: your track plus a pin per memo. Opens in QGIS, uMap, geojson.io or any GIS tool.
notes.csv: one row per sighting, hazard or to-do, ready for a spreadsheet.

Everything runs on your own machine: speech-to-text with Whisper (through faster-whisper) and note-taking with Google's open-weight Gemma served by Ollama…

View on GitHub

Python, MIT licensed, about 640 lines plus tests. The repo includes the sample walk, the script that generates it, and docs/BUILD-LOG.md, which records every problem below as it happened.

How I Built It

Four open pieces do the work:

Whisper (small.en) through faster-whisper, for speech-to-text on the CPU.
Gemma 4 E2B, Google's open-weight model, in a 4-bit GGUF (3.1 GB), served by Ollama. It reads each transcript and returns JSON in a fixed schema: seen, heard, hazard, todo or note, each with a subject, a count and a few words of detail.
The GPX track for position, and plain Python for timing.

The interesting part was everything that went wrong.

Whisper heard "buzzers". On the first pass base.en turned buzzards into "buzzers", fly agaric into "fly are gariconder", the council rights of way team into the "cancel rights of Wei Team", and a green woodpecker into a "green whoop cat". Whisper takes an initial_prompt, so fieldmemo passes in a glossary of about 55 countryside words (birds, fungi, stiles, kissing gates, bridleways). That fixed all four. It's a plain text file you can edit for wherever you walk. The test is flattering, because those words are in the glossary and the voice is synthetic, but the effect was immediate.

Whisper heard "You" in the wind. One sample memo is nine seconds of wind and nobody talking, the kind of recording you make by accident in a pocket. Without help, Whisper transcribed it as "You". Turning on its voice-activity filter made it return nothing, and the journal now lists that memo as "no speech, skipped" instead of inventing a note.

The small model made things up. I started with Gemma 3 1B because it fits in about 1.2 GB of RAM. It labelled a woodpecker "seen" when the memo says "didn't see it though", turned "two buzzards, maybe three, they keep dropping behind the trees" into buzzards plus three trees, and in one run added "fly agaric: a small, pale mushroom growing on a stone" to the car-park memo, which doesn't mention a single fungus. My guess is that it picked "fly agaric" up from the examples in my own prompt.

Gemma 4 E2B got the kinds right on the same memos: heard vs seen, the flooded path as a hazard, the blackberries as a to-do. It needs about 3 GB of RAM and takes 4 to 8 seconds a memo on the CPU, so it's the default, and Gemma 3 1B is a flag away for smaller machines.

So every answer gets checked. A small model will invent things sooner or later, so fieldmemo doesn't trust the JSON. Every item's subject has to be made of words that are actually in the transcript, and a count has to be said ("two", "a dozen", "12"). Anything that fails is struck through in the journal with the reason, not quietly deleted. That's what caught the invented mushroom.

Then the check rejected a correct answer. Whisper wrote "the style after the second field". Gemma 4 read that as "stile", which is right, and my new check threw it out because "stile" isn't in the transcript. The fix: a word that isn't in the transcript is allowed only if it's in your glossary and the transcript has a word within two letters of it. The journal shows it as corrected: heard "style", read as "stile", so you can see the model's fix and decide whether you agree.

Time zones. Android recorders put the local time in the file name (Recording_20261008_101940.m4a). An iPhone export is called New Recording 4.m4a and keeps its time in a UTC metadata tag. GPX is always UTC. Get one of those wrong and every pin slides along the track by an hour. Run the sample with the wrong zone and the iPhone memo jumps to the top of the timeline, and the last two memos land "27 min after the track ends" and "53 min after the track ends". fieldmemo can't spot an hour's error that still lands somewhere on the track, but it won't guess beyond the track: a memo outside the track, or in a GPS gap longer than five minutes, gets no position rather than a wrong one, and you get a warning that points at --tz and --clock-offset.

Smaller snags: ollama pull was blocked by the network I built on, so I downloaded the GGUF from Hugging Face and imported it with a one-line Modelfile, which the README now documents. faster-whisper 1.2.1 crashed with the newest PyAV (unexpected keyword argument 'metadata_errors'), so fieldmemo decodes audio with the ffmpeg binary instead. As a bonus, it now reads anything ffmpeg can.

There are eight unit tests covering timing, interpolation and the grounding check, and the whole pipeline runs on CPU.

Why Does Open Innovation Matter?

Look at what fieldmemo handles: a timestamped trace of where you walk, and recordings of your voice. That's a record of where you live, when you're out, and what you sound like. With open weights running locally, none of it goes anywhere. There's no account, no API key and no server I'd have to trust. Once the models are downloaded, nothing touches the network.

It also costs nothing to run. The sample walk took about 48 seconds of CPU, with no per-minute transcription bill and no per-token bill for the notes.

The bigger difference showed up while building it:

I could swap the model in one flag. Comparing Gemma 3 1B with Gemma 4 E2B on the same seven memos took minutes, and seeing the small model's mistakes side by side is why the grounding check exists. With the weights on disk, the choice comes down to how much RAM your machine has, not which plan you're on.
I could steer the speech model. The glossary works because a local Whisper lets you set its prompt. Someone walking in the Cairngorms can add "ptarmigan" and "bothy" and get better transcripts the same day.
The results stay put. The weights in the repo's instructions are fixed files. Run the sample next month and you should get the same answers I got, give or take small numerical differences between machines, so the README and the build log stay true. A hosted model can change underneath you without notice.

I didn't benchmark a closed API against this, so I won't claim the open stack is more accurate. What I can say is that for a tool built around your location and your voice, local and open is the version I'd actually want to use.

My Agent Session

This was built with an AI coding agent. I don't have a DevRelay export, but docs/BUILD-LOG.md in the repo is the step-by-step record of the session: what was tried, what broke, and what changed as a result.

Prize Categories

Best Use of Gemma: Gemma 4 E2B runs locally through Ollama and does the core job of turning each transcript into structured field notes. The repo compares it with Gemma 3 1B on the same memos, and it's the default.

DEV Community: Darren