DEV Community: Gabby Gill

Marigold — a private ofrenda that catches the ghosts AI writes into our memories

Gabby Gill — Sat, 31 Oct 2026 02:14:23 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine

What I Built

For Día de los Muertos, families build an ofrenda: an altar with photos of the people they've lost, their favourite foods, marigolds to guide them home, and the stories that keep them close.

Marigold helps you build one on your own computer:

Add someone and drop in a few old photos.
Write down what you remember: what they always said, what they cooked, the song they hummed on Saturday afternoons.
A local open-weight model (Gemma 3 4B via Ollama) looks at each photo and suggests a gentle caption. Then it writes a short remembrance using only what you gave it.
Marigold builds the ofrenda: papel picado, their photos, your words, their favourite things as the offerings, and candles. It's saved as one HTML file you can keep, print or share.

The photos are public-domain archive photos and the memories are fictional; with your own family photos, it's their faces on the ofrenda.

My take on "Ghost in the Machine": the scariest ghost in AI isn't a spooky one. It's the confident little invention. Ask a model to write about your grandmother and it may "remember" a town she never lived in, a year that's off by one, or a sister who never existed. In most apps that's a bug. In a remembrance, it's a ghost that rewrites someone's life.

So Marigold has a ghost check. It doesn't just tell the model to stick to the facts; it checks. Every name, place, number, month and weekday in the written text is compared against everything you wrote and everything the model saw in the photos. Anything that came from nowhere is flagged as a 👻 and highlighted, so you can remove it, or add it to your memories if it's true. Here it is catching a city that was planted in a test:

Demo

Try it: download marigold-win-x64.zip (or the macOS/Linux build) from Releases, install Ollama, run ollama pull gemma3:4b, and double-click marigold. It opens in your browser at 127.0.0.1:5180.

Code

GurminderKaur / Marigold

Marigold 🌼

A private, offline ofrenda for the people you remember.

Add a few old photos and write down what you remember: what they always said, what they cooked, the song they hummed. A local open-weight model (Gemma 3 4B via Ollama) looks at each photo and writes a short remembrance using only what you gave it. Marigold then builds an ofrenda page with their photos, your words and their favourite things, saved as one HTML file you can keep, print or share.

The ghost check 👻

A language model writing about someone you loved will sometimes "remember" things that never happened: a town she never lived in, a year that's wrong, a name nobody had. In a remembrance, that's the worst kind of mistake.

So Marigold doesn't just ask the model to stick to the facts. It checks. Every name, place, number, month and weekday…

View on GitHub

How I Built It

Stack: .NET 8 (an ASP.NET Core minimal API) serving one offline HTML page, with Ollama running Gemma 3 4B, which reads images as well as text. There are zero third-party NuGet packages, no CDN scripts and no web fonts.

Two jobs for the model. Both go through Ollama's /api/chat:

Looking at a photo: a JSON schema in format makes the model return caption, description and era. The prompt says to describe only what's visible and never guess a name, age, relationship or city. Captions are suggestions; you can change any of them.
Writing the remembrance: the prompt lists the facts (name, years, your memories, their favourite things, what's in the photos) under a STRICT RULE: use only these, add no name, place, date, year, age, job, food, song or event. "It is better to be short than to invent." A lesson from the real model. I first used a JSON schema for the remembrance too. It worked with my test stand-in, but on the real Gemma 3 4B it failed twice in CI: wrapped in forced JSON, the model kept writing until it hit the length limit and never closed the string. Plain text ("title on the first line, then the remembrance") fixed it. Now a cut-off answer is detected and retried once with a different seed. Structured output is great for short fields, but for a few paragraphs of prose, plain text is more reliable on a small model.

The ghost check is plain C#, not another model. A prompt is a request, not a guarantee, so I check the output with about 120 lines of string matching (Ghosts.cs):

It builds a bag of words from everything you wrote and everything the model saw.
It flags capitalized words mid-sentence (names, places), numbers (years, ages), and months and weekdays that aren't in that bag.
It avoids false alarms: sentence-start words don't count, "May she rest" isn't a month but "married in May" is, family words like Abuela or Nani are fine, and plurals match ("Halloween costumes" covers "costume").
It runs again every time you edit, so adding "She was born in Guadalajara" to your memories turns the warning off. It's predictable, it's explainable, and it's tested.

The ofrenda outlives the app. The page is a single file with photos embedded as data URIs, no scripts, no links and no fonts to download. It prints to PDF. Photos are resized in the browser before saving (canvas → JPEG), so a 12 MB scan becomes a few hundred KB without any image library.

Private by construction. The server binds to 127.0.0.1, rejects any other host name (blocking DNS-rebinding), and needs a custom header for every change, so another website in your browser can't read or edit anything. Uploaded files are checked by their first bytes (JPEG/PNG only), and photos are only ever served by ID from Marigold's own folder.

Tests. There are 33 built-in self-tests for the ghost check, photo validation, storage and the ofrenda page, run on Windows, macOS and Linux. Then CI does the real thing: it installs Ollama and gemma3:4b, downloads a few public-domain photos from Wikimedia Commons (licence checked, credits recorded), and a Playwright test uses the app like a person would. It adds a (fictional) grandmother, uploads the photos, waits for Gemma, writes the remembrance, checks the ghost check, then opens and downloads the ofrenda.

Here's the real Gemma 3 4B, on a GitHub runner with no GPU:

	Result
Photos described	4 / 4, no names guessed
Era guesses vs. the archive's dates	1944 sewing photo → "1930s–1950s" ✅, c. 1942 radio photo → "1950s" (close), 1922 homestead → "1930s–1950s" (a bit late)
Time per photo / for the remembrance	~67 s / ~42 s
Invented details in the real remembrance	0 (in both the browser run and the command-line run)

And this is what it wrote, from the family's memories, with a clean ghost check:

Why Does Open Innovation Matter?

Family photos and memories of someone who has died are about as private as data gets. To describe a photo, a model has to see it. With a closed API, your grandmother's face, her kitchen and your memories of her would be uploaded to a server you don't control, under terms that can change. With an open-weight model, Gemma looks at them on your own laptop. That isn't a promise in a privacy policy; it's how the app is built. Turn off the Wi-Fi and it still works.

Open also matters for time, and remembrance is about time. An ofrenda should still open in twenty years. A closed service can shut down, change its prices or retire the model. Marigold's output is a plain HTML file, the model weights sit on your disk, and the code is MIT. Nothing here needs anyone's permission to keep working.

And open let me build the safety I wanted instead of hoping for it. I could pin the exact model, set temperature and seed, choose when to force a JSON schema (and when not to), and put my own check on the output. I can swap in gemma3:12b or qwen2.5vl:7b with one flag if a bigger model writes better. With a closed API I'd get whatever the model does that day.

Prize Categories

Best Use of Gemma. Gemma 3 4B runs locally through Ollama and does both halves of the work: its vision input describes the photos, and it writes the remembrance in English, Spanish, French, Portuguese, Punjabi or Hindi. A GitHub Actions job runs the real model end to end in a browser on every push.

Sloth Sort — a local Gemma 3 tidies my Downloads folder while I do nothing

Gabby Gill — Thu, 22 Oct 2026 02:19:05 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady

What I Built

My Downloads folder is where files go to be forgotten: document(7).pdf, download.pdf, Untitled document.docx, scan0001.jpg. Every few months I promise myself I'll sort it. I never do.

Sloth Sort sorts it for me. It reads each file on my own computer, and a local open-weight model (Gemma 3 4B via Ollama) decides what the file actually is:

document(7).pdf → Bills & Receipts/2026-10-14 Chinook Mobile Monthly Bill.pdf
Untitled document.docx → Home & Car/2026-11-01 Rental Lease Agreement.docx
download.pdf → Medical/2026-10-02 Bow River Medical Laboratory.pdf 🔒 Installers, zips, audio/video and screenshots are filed by simple rules, with no AI needed. Everything else gets a folder, a readable name and the document's real date.

Who gets to be lazier? Anyone whose Downloads folder is a junk drawer: students, freelancers, parents juggling school forms, and the person who becomes the family's "computer person" every time someone can't find a document.

The whole effort is two clicks: Look through it, then Tidy. In between you can go make tea.

Being lazy shouldn't mean being reckless, so:

Nothing moves until you've seen the plan. You can untick a file, rename it or change its folder first.
It never deletes and never overwrites. Name clashes become (2), (3).
Every tidy-up has an Undo button that puts every file back under its original name.
It skips files that are still downloading (.crdownload, .part) and anything changed in the last two minutes.

Demo

Try it: download slothsort-win-x64.zip (or the macOS/Linux build) from Releases, install Ollama, run ollama pull gemma3:4b, and double-click slothsort. Your browser opens with your Downloads folder already filled in. Click Look through it; nothing moves until you click Tidy.

Watch the real model work: every push re-runs the messy-folder test with Gemma 3 in GitHub Actions. The run summary shows each file, the folder and name Gemma chose, and the score.

Code

GurminderKaur / SlothSort

Sloth Sort 🦥

A local AI tidies your messy Downloads folder while you do nothing.

document(7).pdf becomes Bills & Receipts/2026-10-14 Chinook Mobile Bill.pdf. Untitled document.docx becomes Home & Car/2026-11-01 Rental Lease Agreement.docx. Installers, zips and screenshots get filed too. It takes two clicks: Look through it, then Tidy.

Reads your files locally. It pulls a short text excerpt from PDFs, Word, Excel, PowerPoint, text and HTML files (and, if you turn it on, looks at photos). A local open-weight model, Gemma 3 4B via Ollama, decides the folder, a human-friendly name and the document's date.
Rules first, AI second. Installers, archives, audio/video and screenshots are sorted by rules instantly, with no AI needed.
Shows you the plan before anything moves. Untick files, rename them or change their folder, or just click Tidy.
Never deletes, never overwrites. Every change is a move, recorded in…

View on GitHub

How I Built It

Stack: .NET 8 (an ASP.NET Core minimal API) serving one offline HTML page, with Ollama running Gemma 3 4B. It uses zero third-party NuGet packages. That matters for a tool that's allowed to move your files around.

Reading files without libraries. The model can only sort what it can read, so Sloth Sort pulls a short excerpt (up to 1,500 characters) from each file:

PDFs: inflates the compressed content streams with .NET's built-in ZLibStream and collects the text-drawing operators. If the result looks like garbage, it's dropped and Sloth Sort falls back to the file name.
Word, Excel and PowerPoint files: these are zip files of XML, so it reads them with ZipArchive and a hardened XmlReader (DTDs off).
Text and HTML files: read directly, with tags stripped.
Photos: optional; the image itself goes to Gemma's vision input, so a photographed receipt can land in Bills & Receipts instead of Photos. Asking the model for a decision, not a conversation. Each file goes to Ollama's /api/chat with a JSON schema in format. The model must answer with a folder from a fixed list, a short title and a date. Temperature is 0. The prompt says "do not invent": with no clear date, the file's own date is used.

One thing I moved out of the model: I first asked Gemma to flag "sensitive" files, and it flagged 10 of 11, which makes a warning useless. Now the 🔒 simply comes from the folder (Banking & Taxes, Medical, IDs & Personal). It's predictable, and it's one less thing to ask a 4B model.

C# does the risky parts, not the model. The model never chooses a path. C# builds the name (yyyy-MM-dd Title.ext), removes characters Windows doesn't allow, avoids reserved names like CON, rejects dates that are impossible or more than two years ahead, and adds (2) instead of overwriting. Moves are recorded in a journal, so undo works even after you restart the app.

Guard rails. The app only tidies folders inside your user folder. It refuses your whole user folder, AppData/Library/.ssh, and system folders, and it only touches the top level. The page is served on 127.0.0.1, rejects other host names (to block DNS-rebinding tricks), and needs a custom header for every change, so another website in your browser can't trigger a tidy-up.

Tests. There are 31 built-in self-tests covering names, dates, skip rules, PDF and Word reading, the folder guard, never-overwrite, and undo surviving a restart. On every push, GitHub Actions runs them on Windows, macOS and Linux. It then installs Ollama, pulls gemma3:4b, generates a messy folder of 16 clearly-labelled fictional files, and has the real model plan the tidy-up. Each file is scored on "right folder?" and "sensible name?":

	Result
Right folder	15 / 15
Sensible new name	10 / 10
Half-finished `.crdownload` skipped	yes
Files the dry run moved	0

Before	After (chosen by Gemma 3 4B)
`statement_0923.pdf`	`Banking & Taxes/2026-09-01 Prairie Credit Union Chequing Statement.pdf` 🔒
`notes.txt`	`School/2026-11-02 COMP 2510 Assignment 3.txt`
`scan0001.jpg` (a receipt photo)	`Bills & Receipts/2026-10-05 Chinook Coffee House Receipt.jpg`
`booking-confirmation.html`	`Travel/2026-11-20 Aurora Air Booking Confirmation.html`

To be fair to the model and to you: sixteen tidy test files are easier than a real Downloads folder. That's why the plan is always shown first, and every tidy-up can be undone.

Why Does Open Innovation Matter?

A Downloads folder is the most private place on a computer. Mine has bank statements, a lease with my address, lab results, my ID scan and my résumé. To sort those files, a model has to read them.

With a closed API, every one of those files would leave my laptop to be sorted. With an open-weight model, Gemma reads them on my machine, and the files never go anywhere. That isn't a policy promise; it's how the app is built. You can unplug the network cable and it still works.

Open weights also changed what was worth building:

Cost: a cloud API charges per file. Sloth Sort tidying 2,000 files costs the same as tidying 20: nothing. That makes "tidy my Downloads every night" a reasonable thing to schedule.
Running it unattended: slothsort tidy ~/Downloads --yes can run from Task Scheduler. There's no API key to expire and no rate limit to hit at 3 a.m.
Yours to change: swap in gemma3:12b or qwen2.5vl:7b with one flag, edit the folder list or the prompt, or add rules. The code is MIT; the model's terms are Gemma's. Open source also means you can check that a tool which moves your files around does what it says. Every move, and every undo, happens in one short C# file (Engine.cs) that anyone can read.

The Lazy Payoff

This challenge rewards laziness, so here's the honest accounting.

My effort: 2 clicks. Look through it, then Tidy. That's zero decisions if I trust the plan, or a few seconds per file if I want to fix one. On a schedule (slothsort tidy ~/Downloads --yes), it's zero clicks. I ran it on my Downloads folder this week: 143 files, and I changed 9 suggestions before clicking Tidy.

The machine's effort: slow, and that's fine. On a CPU-only GitHub runner with no GPU, Gemma 3 4B takes about 31 seconds per file it has to read. The 4 rule-sorted files are instant. So the sample folder took roughly 6 minutes. That's slower than me sorting a single file. But I'm not the one waiting: I'm making tea. Slow and steady, and none of it on my time.

By hand, it's the part I never actually do. Each file means opening it, working out what it is, finding the date, typing a name and dragging it somewhere. At a rough 30 seconds a file, that's about 8 minutes for the 16-file test folder, and a whole afternoon for a real one with hundreds of files. That's why my Downloads folder has never been sorted.

The payoff that matters: a year from now, when I need last October's phone bill, I can search Chinook in Bills & Receipts instead of opening document(1).pdf through document(7).pdf one by one.

Prize Categories

Best Use of Gemma. Gemma 3 4B runs locally through Ollama and does all of the understanding: it reads text excerpts and, optionally, photos through its vision input. A GitHub Actions job runs the real model against a test folder on every push.

Shoebox — a private receipt & GST sorter for Alberta freelancers, powered by a local Gemma 3

Gabby Gill — Sat, 17 Oct 2026 23:39:52 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

What I Built

Every April or end of financial year, self-employed people across Alberta sit down with a shoebox of faded receipts and a spreadsheet. I wanted the boring part, reading and sorting, to happen in minutes without handing a year of financial data to a cloud service.

Shoebox is a small app for self-employed people in Alberta. You drop in photos of your receipts and get back a year of expenses sorted the way CRA's T2125 form wants them, with the GST worked out. It runs entirely on your own computer.

Drop in receipt photos. A local open-weight vision model, Google's Gemma 3 (4B) running through Ollama, reads the vendor, date, subtotal, GST, tip and total.
Shoebox checks the AI's work with plain arithmetic, not more AI. It flags any receipt where subtotal + tax + tip doesn't equal the total, where the tax isn't Alberta's 5% GST (a BC receipt with PST, or Ontario HST), where the date is in the future, or where it looks like a duplicate.
Each expense goes to a T2125 line. Gas goes to 9281 Motor vehicle, coffee with a client to 8523 Meals (counted at 50%), printer ink to 8811 Office supplies. Business-use percentages for your vehicle and phone are applied.
GST is handled both ways. If you're GST-registered, Shoebox deducts the pre-GST cost and totals your input tax credits. If you're not, the GST is part of your expense.
Export a CSV for your accountant, or for yourself at tax time.

Every flagged receipt opens side by side with its photo, so fixing a misread takes seconds:

Who would pay for it? Ride-share and delivery drivers, realtors, hairstylists, trades and consultants. These are people with a few hundred receipts a year who either pay a bookkeeper by the hour or lose deductions because the shoebox never gets sorted. Because it runs locally, there's no per-receipt cost to pass on. That means a one-time price works, instead of yet another monthly subscription.

Demo

Try it: download for Windows, macOS or Linux from the Shoebox 0.1.0 release. Every push also runs Gemma 3 on the sample receipts: see the CI runs.

Code

GurminderKaur / ShoeBox

Shoebox 🧾

Sort a year of receipts for tax time, privately, on your own computer.

You drop in photos of your receipts. A local open-weight AI model (Google's Gemma 3, run through Ollama) reads the vendor, date, subtotal, GST and total. Shoebox then:

checks the arithmetic itself, flagging any receipt where the numbers don't add up, the tax isn't Alberta's 5% GST, or the date looks wrong;
sorts each expense into its CRA T2125 line;
totals your deductible expenses and GST input tax credits;
exports a CSV for you or your accountant.

It's built for Alberta freelancers and gig workers: drivers, realtors, stylists, trades, consultants.

Nothing leaves your computer. The web page is served from 127.0.0.1 only. The AI model runs on your own machine. Receipts are stored in a normal folder (~/Shoebox) that you can back up or delete.

What it does

…

View on GitHub

How I Built It

Stack: .NET 8 (an ASP.NET Core minimal API) serving one self-contained HTML page, with Ollama running Gemma 3 4B for vision. There are zero third-party NuGet packages and no CDN scripts or web fonts, so the whole thing works offline and there's very little supply chain to trust with financial data.

Reading receipts. Each photo goes to Ollama's /api/chat with a JSON schema in the format field (Ollama's structured outputs). The model must answer with vendor, date, subtotal, gst, other_tax, tip, total, items and a category drawn from a fixed list of T2125 codes. Temperature is 0. The parser is still lenient: it accepts "$12.50" as a string, month names in dates, and stray chatter around the JSON.

Not trusting the model. A 4B model will misread a digit sometimes. Rather than pretend otherwise, Shoebox sorts its findings into two kinds:

Problems keep a receipt flagged until it's fixed: the numbers don't add up, there's no total, or the date is invalid or in the future.
Cautions clear once you've looked and saved: PST on an out-of-province receipt, a GST rate under 5% (some items may be exempt), or a possible duplicate.

A misread total becomes a highlighted row to check, not a silent error in your tax numbers.

Categories: rules first, AI second. Keyword rules handle the obvious cases (Petro-Canada, Tim Hortons, Canada Post, Telus to name a few and many more) predictably and explainably. Gemma's suggestion is only used when no rule matches, and the UI shows whether a category came from a rule, the AI or you.

Tax maths in C#, not in the model. Meals are counted at 50%. Vehicle and phone use your business-use %. GST registrants get deductible = (total − GST) × share and ITC = GST × share. Non-registrants deduct total × share. There are 23 built-in self-tests covering this maths, the checks, category rules and CSV safety: text read off a receipt like =HYPERLINK(...) is neutralized so it can't run as an Excel formula.

Privacy by construction. The server binds to 127.0.0.1 only, rejects requests for any other host name (to block DNS-rebinding tricks), and requires a custom header on every change, so a website open in another tab can't upload, edit or delete anything.

Testing with a real model. On every push, GitHub Actions builds and self-tests on Windows, macOS and Linux, then installs Ollama, pulls gemma3:4b, and has it read six clearly-labelled sample receipts from fictional businesses. Each field is scored against the known values and the results are posted in the run summary:

Field	Vendor	Date	Subtotal	GST	Total	Category
Correct (of 6)	6	6	6	4	6	5

Each receipt took about 80 seconds on GitHub's CPU-only runner. A laptop with a decent GPU is much faster.

The two misreads are exactly why the checks exist:

Courier receipt: Gemma read the GST as $25.00, copying the subtotal line, instead of $1.25. Shoebox flagged it twice: "Amounts don't add up (off by $23.75)" and "GST is 100% of the subtotal."
Grocery receipt: the receipt clearly printed $0.00 GST (basic groceries are zero-rated). Gemma "helpfully" filled in $1.87, which is exactly 5%. The model assumed Alberta GST instead of reading it. Shoebox flagged it: "off by $1.87."

Both wrong amounts were caught; neither slipped into the totals. The one thing no check can catch is judgement: Gemma filed the groceries under "Other" instead of "Personal". That's why every category shows whether it came from a rule, the AI or you.

Why Does Open Innovation Matter?

The business model only works with an open model. A cloud vision API charges per image. That's fine for a demo, but it turns a sorting tool into a subscription that has to cover someone else's inference bill. With Gemma running locally, reading the 500th receipt costs the same as the first, which is nothing. That's what makes a one-time-price tool for a freelancer viable.

The data is the most sensitive kind. A year of receipts shows where you drive, what you buy, who your clients are and roughly what you earn. Shoebox's answer to "where does my data go?" is "a folder on your laptop". That isn't a privacy policy; it's how the software is built.

I can tune it for a niche general tools handle poorly. Alberta has GST but no PST, CRA has its own T2125 lines, and meals are counted at 50%. Owning the whole pipeline means the prompt, the categories and the checks all speak Canadian tax. I can swap in a bigger model (--model gemma3:12b) for someone with a faster computer, or fine-tune later on corrected receipts, without asking anyone's permission or changing pricing.

No lock-in. If Ollama, Gemma or I disappear tomorrow, the user still has a CSV and a folder of their own photos.

Honest limits: Shoebox gives estimates, not tax advice. It doesn't handle capital cost allowance, home-office expenses or receipts that mix personal and business items, and a small model on a laptop is slower than a cloud API (about 80 seconds per receipt on a CPU-only machine in my tests; faster with a GPU). For a once-a-month sorting session, that trade-off is worth it.

My First User

I haven't landed one yet: I'm new to Calgary's freelance scene and didn't have contacts to ask this week. So here's an open invitation. If you're self-employed in Canada, download the release, try it on a few receipts, and tell me in the comments what it got wrong and whether you'd pay for it. I'll update this post with what I hear.

Why someone would pay for this

The customer: an Alberta ride-share driver, realtor, stylist or contractor with a few hundred receipts a year. Today they either pay a bookkeeper by the hour to type them in, or they don't sort them at all and miss deductions. That's real money: meals count at 50%, gas at your business-use %, and GST input tax credits are free money for registrants who track them.

What they're paying for: an evening of sorting instead of a weekend, a CSV their accountant can use as is, and a check that catches the misread numbers a tired human (or an AI) would miss.

Why a one-time price works: because Gemma runs on their own laptop, my cost per receipt is zero. I don't have a cloud bill to pass on, so I can sell it once (I'm thinking [$29] as side hustle) instead of adding another monthly subscription to a freelancer's expenses. And "your receipts never leave your laptop" is a selling point no cloud tool can match.

My Agent Session

I built Shoebox with an AI coding agent (Claude), working from the CRA rules down to the arithmetic checks, a security pass on the local server, browser testing on desktop and mobile, and a CI run against a real local Gemma model.

Prize Categories

Gemma: Gemma 3 (4B, vision) runs locally through Ollama and reads every receipt. It's the app's default model, and CI tests it on every push.

Credits

Gemma 3 by Google DeepMind (Gemma Terms of Use), served by Ollama.
.NET 8 / ASP.NET Core.
CRA guidance on T2125 expenses and GST/HST registration. Shoebox gives estimates only, not tax advice.

TrailBirder — offline bird-song ID and a local-LLM field journal for Alberta trails

Gabby Gill — Sun, 11 Oct 2026 18:36:18 +0000

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

What I Built

Hearing birds on Calgary walks and not knowing what they were.

TrailBirder is a small C# / .NET 8 app that listens to birds on the trail, names them, and writes you a short field-journal entry. It runs entirely on your own device, with no signal, account or cloud.

The idea is that the screen should be the shortest part of the walk. You start it and put the device away. This is what live mode looks like (example output from BirdNET's sample recording):

▸ Listening · Inglewood Bird Sanctuary · Oct 10 — press Ctrl+C to stop
  11:18:17  Black-capped Chickadee       0.81 likely    ★ new today
  11:18:26  House Finch                  0.64 probable  ★ new today
  11:18:58  Dark-eyed Junco              0.74 likely    ★ new today

It's built for Alberta. It has presets for places like Inglewood Bird Sanctuary, Fish Creek, Frank Lake, Kananaskis, Elk Island and Waterton. You can also ask it before you leave:

trailbirder species --where fish-creek
▸ Likely around Fish Creek Provincial Park the week of Oct 10
   88 %  Black-billed Magpie
   81 %  Black-capped Chickadee
   77 %  Common Raven
   ...

It's for anyone who wants to learn the birds they keep hearing, from a first-time birder to someone keeping a season list. It works three ways: a phone voice memo you analyze later, a laptop at a viewpoint, or a Raspberry Pi with a USB mic left by a marsh.

Demo

The CI run is a working demo anyone can inspect. On every push, GitHub Actions does two things:

It builds the app on Windows, macOS and Linux and runs the bird models on each.
On Ubuntu, it installs Ollama, pulls Gemma 3 (1B), and analyzes BirdNET's example recording end to end. The journal it writes appears in the run summary.

You can also run it yourself in about 20 minutes. The README has a step-by-step Windows setup, and BirdNET's sample recording makes a quick first test.

Code

GurminderKaur / TrailBirder

TrailBirder 🐦

⚠️ Models are for non-commercial use only. The BirdNET models in models/ are licensed CC BY-NC-SA 4.0 (see models/LICENSE.md). The TrailBirder source code is MIT licensed.

Offline bird-sound ID and field journal for Alberta trails, built in C# / .NET 8.

Leave your phone in your pocket, record or listen on the trail, and get a species list plus a short field-journal entry. Everything runs on your own device. No signal, account, or cloud is needed.

▸ Listening · Inglewood Bird Sanctuary · Oct 10 — press Ctrl+C to stop
  11:18:17  Black-capped Chickadee       0.81 likely    ★ new today
  11:18:26  House Finch                  0.64 probable  ★ new today
  11:18:58  Dark-eyed Junco              0.74 likely    ★ new today

How it works

Step	Open piece	Runs on
Hear	Your mic (NAudio on Windows, `arecord` on Linux/Pi, ffmpeg on macOS) or recordings from your phone	Device
Identify	BirdNET v2.4 (open-weight model from the

…

View on GitHub

How I Built It

There are three open pieces, and all of them run locally:

Step	Open piece	What it does
Identify	BirdNET v2.4 (Cornell Lab of Ornithology and TU Chemnitz), run with ONNX Runtime in .NET	Turns 3 s of audio into scores for 6,522 sound classes
Filter	BirdNET's range model	Turns latitude, longitude and week into which species are plausible here right now
Write	Gemma 3 through Ollama (any Ollama model works via `--model`)	Turns the detection table into a grounded journal entry

Getting BirdNET into C# was the interesting part. BirdNET ships as TensorFlow Lite, and .NET has no good TFLite runtime, so I converted it to ONNX. The standard converter (tf2onnx) failed on BirdNET's built-in spectrogram layer. That layer takes an FFT and then casts the complex result to float, which keeps only the real part. That's an unusual pattern the converter doesn't support.

Because the weights are open, I could fix it myself. The real part of an FFT is just a matrix multiply by a cosine table:

Re(RFFT(x))[k] = Σₙ x[n] · cos(2πkn/N)

I wrote a small graph rewriter that swaps that step for a MatMul, then checked the result against the original model on real audio. The largest difference in any bird's probability was 0.00005, so the converted model is effectively identical. The converter script is in the repo.

The range filter does more work than you'd expect. On the test recording, the raw classifier also suggested a Chestnut-winged Cuckoo (Southeast Asia) and a Hawfinch (Europe). The range model scores both at 0.000 for Calgary in October, so they never reach the user. It also reflects the season: mid-October around Calgary means magpies, ravens, chickadees, Bohemian waxwings and late waterfowl, and that's what it expects.

The LLM is fenced in. Small models will happily invent a Great Horned Owl. The journal prompt gives the model only two lists, both computed on the device: what BirdNET detected and what the range model expects nearby. It is told to:

never mention species outside those lists,
flag IDs below 0.5 confidence as uncertain and point you to the clip,
remember that "4 clips" doesn't mean 4 birds.

If Ollama isn't running, nothing breaks. Detections and clips are still saved, and trailbirder journal writes the entry later.

Other details:

Microphone input uses NAudio on Windows, arecord on Linux/Pi and ffmpeg on macOS.
There's a built-in resampler for when ffmpeg isn't installed.
The models are split into pieces under 25 MB for GitHub and reassembled on first run, with a SHA-256 check.

Why Does Open Innovation

It costs nothing to run. On a CPU with no GPU, two minutes of audio is analyzed in about two seconds. A full morning of recordings costs nothing, and nobody needs an API key.

Taking It Outside

On Sunday, October 11, I went to Inglewood Bird Santuary around 10:00 am. It was -1 °C with snow/wind, an early taste of Alberta winter.

I kept my phone in my pocket and only took my glove off to start voice memos of about minutes each. The screen was out for less than a minute in total.

At home, TrailBirder analyzed 1 minutes of audio in 25 seconds on my laptop, fully offline.

Black-capped chickadee clips 1 best 0.81 likely
Black eyed junco clips 4 best 0.74 likely
House finch clips 4 best 0.64 probable
American Goldfinch clips 3 best 0.48 possible
Blue Jay clips 1 best 0.44 possible

My Agent Session

I built this with an AI coding agent (Claude). We worked through choosing the stack and the model conversion, then testing against the original model, CI on three operating systems, and an end-to-end run with a real Ollama model.

Building TrailBirder: BirdNET to ONNX in C#, a local Gemma field journal, and CI on 3 operating systems

Prize Categories

Gemma. Gemma 3 runs locally through Ollama to write the field journal. It's the default model (gemma3:4b), and CI tests it end to end with gemma3:1b.

Credits

BirdNET v2.4 models © K. Lisa Yang Center for Conservation Bioacoustics (Cornell Lab of Ornithology) and Chemnitz University of Technology, licensed CC BY-NC-SA 4.0. Kahl et al. (2021), Ecological Informatics 61, 101236.
ONNX Runtime, tf2onnx, Ollama, Gemma, NAudio, ffmpeg.
TrailBirder code: MIT.