Ebyafaayo: keeping my grandparents' stories alive with Gemma 4, offline

Nuwahereza Peter — Fri, 30 Oct 2026 11:33:07 +0000

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

What I Built

Ask a young person in Kampala today what their clan is, and many will pause. Ask about their totem, the taboos their family keeps, or the names of their great-grandparents, and the pause gets longer.

I see it in my own generation. We grew up with phones, school and the city, and somewhere along the way we stopped sitting with our grandparents in the evening to listen. The knowledge did not disappear because it was unimportant. It disappeared because nobody wrote it down. In our culture, history lives in the voices of our jjajjas: who our people were, where they came from, which clan we belong to, what we must never eat, why a child is given a certain name, the proverbs that taught right from wrong.

Every time an elder passes on, a whole library closes, and most of those libraries were never written down.

This week's theme asks us to honour the past, in the spirit of Día de los Muertos. For my family, the past is not in a book. It is in jjajja's voice, and a voice is the first thing we lose. So my "ghost in the machine" is a gentle one: a machine that listens to our elders while they are still with us and keeps their words for the grandchildren who will never meet them.

That is why I built Ebyafaayo, which means "history" in Luganda. It lets a family sit with jjajja omusajja or jjajja omukazi, press record, and keep their stories in their own words, in Luganda, for the generations that come after us. Everything stays on the family's own laptop.

The family asks the elder for consent and records the story.
An open Luganda speech model transcribes it.
The family checks and corrects the transcript.
Gemma 4, running locally, turns it into a memory: the story in Luganda and English, the people and places mentioned, the clan and totem if the elder named them, proverbs, and gentle questions to ask next time.
The family can add old photos from the album. Gemma describes what it can see, never who anyone is, and suggests questions to ask about each photo.
Each elder gets a remembrance page, and the family can print a memory book.

Gemma is only allowed to use what the elder actually said. Every name, place and relationship links back to the sentence it came from, and anything unclear stays marked as unclear. A family's history is not something an AI should guess.

Demo

These screenshots use a short sample story written for testing, not a real family's story.

Consent comes first. The consent text is stored with the recording.

The memory Gemma wrote. Every person, place and time links to the sentence it came from. Clan and totem stay empty because the elder did not say them.

The remembrance page, with a timeline and questions to ask next time.

The memory book, ready to save as a PDF.

Code

Nuwahereza-eng / Ebyafaayo

Ebyafaayo

An offline family oral-history keeper for Luganda speakers. Record an elder telling a story, get a transcript from an open Luganda speech model, correct it together, and let Gemma 4 (running on your own laptop) turn it into a family memory: the story in clean Luganda, an English translation, the people, places and times mentioned, and gentle questions to ask next time. Every story goes onto a remembrance page for that elder and into a printable memory book.

Nothing leaves the computer. No cloud AI, no analytics, no telemetry.

Ebyafaayo is Luganda for history: the things that happened.

Built for the DEV Hacktoberfest Open-Source AI Challenge, Week 4: "Ghost in the Machine".

The story behind it

Ask a young person in Kampala today what their clan is, and many will pause. Ask about their totem, the taboos their family keeps, or the names of their great-grandparents, and the pause…

View on GitHub

How I Built It

Gemma 4 (gemma4:e2b) through Ollama does the thinking (more on that below). I chose E2B because my laptop has 8 GB of RAM and no GPU; the bigger Gemma 4 models do not fit.
Sunbird AI's open speech model asr-whisper-large-v3-salt (MIT licence, adapted from Whisper Large v3 for Ugandan languages) transcribes Luganda. I convert it once to an 8-bit version for faster-whisper. It is the same Sunbird weights, but it needs about 1.5 GB of RAM instead of 6 GB.
The Gemma audio test did not happen. I planned to test whether Gemma 4 could transcribe Luganda directly, but I expected it to need the full model through transformers, another ~10 GB download my laptop could not hold. So Sunbird does the listening and Gemma does the writing. (Late in the week I noticed my Ollama now lists audio among Gemma 4 E2B's abilities, so that test is next.)
Temporal, running locally, makes every job durable. More on that below too.
FastAPI and SQLite keep everything on one laptop. React with MUI for the interface.

How Gemma writes a memory without making things up

A family history is the worst place for an AI to be creative. A wrong clan or a wrong grandfather is not a typo; it gets passed down. So I set Gemma one rule: use only what the elder said. Three things make that rule hold on a 2-billion-parameter model.

1. Gemma must fill in a fixed form. Ollama can force Gemma's answer to match a JSON schema while it writes. I build the schema from the same Pydantic models the app saves, so Gemma cannot leave out a field, invent a new one, or write an essay where a name should go:

body = {
    "model": "gemma4:e2b",
    "messages": [{"role": "user", "content": prompt}],
    "format": schema,      # JSON schema from Pydantic: every field required, every list and string capped
    "think": False,
    "options": {"temperature": 0.2, "num_ctx": 8192, "num_predict": 3000},
}

2. Every fact carries its proof. Each person, place, time, proverb, clan and totem must come with the exact sentence the elder said it in. Here is what Gemma returned for one sentence of my test story:

{
  "name": "Kizito",
  "relationship_to_speaker": "father",
  "source_sentence": "Taata wange yali ayitibwa Kizito, era yali mulimi wa mmwanyi.",
  "confidence": "clear"
}

("My father was called Kizito, and he was a coffee farmer.") In the app, a small quote icon sits next to every item; tap it and the sentence appears.

3. The app checks Gemma's work. Gemma is good, but I do not take its word for it. After it answers, plain Python code:

looks for every quoted sentence in the transcript, and swaps in the elder's exact words when Gemma's copy is slightly off;
checks that every name and place really appears in the transcript, and marks the ones that don't;
deletes any clan or totem the elder never said, and tells the family why.

On my test story, Gemma found all 4 people with the right relationships (the speaker, her father, her mother, her husband), all 3 places and both time periods. Every quote matched the transcript. Clan and totem came back empty, which is correct, because the story never names them. It took 170 seconds on a laptop CPU.

Gemma also writes 3 to 5 gentle follow-up questions in Luganda and English, about things the elder mentioned but did not explain. They go on the elder's remembrance page, so the next visit to jjajja starts with a question.

Gemma reads the old photos too

Every family has a box of photos nobody can name any more. Gemma 4 E2B can read images, so the family can add a photo from the album to an elder's page. Gemma describes what it can see and suggests questions to ask about it. The family writes who is in it, because Gemma never says who anyone is. As a safety net, the app removes any sentence of the description that contains the name of someone the family knows.

Getting this right taught me how easily a small model can be led. My first photo prompt talked about a Ugandan family, gomesi and kanzu. Given a 1965 photo of an empty living room, Gemma confidently described "at least four people", then "two individuals standing outdoors". Asked the same thing without any of that framing, it said: "There are no people visible in the photo." The fix was a short, neutral prompt. A small model can see what you tell it to expect, so the prompt should not tell it what to expect.

Gemma's Luganda questions about photos looped ("nnyo nnyo nnyo…") or drifted into Kinyarwanda. So for photos, Gemma writes the questions in English, and the family writes them the way they would actually ask jjajja.

Test photos from Wikimedia Commons (public domain), not a family's.

When the laptop runs out of memory: Temporal

My laptop has 8 GB of RAM. Gemma needs about 5 of them, and the out-of-memory killer stopped it again and again while I built this (once taking my code editor with it). For a family, that would mean a story half-written and lost, and starting again.

So every slow job is now a Temporal workflow, split into small steps:

A memory: Gemma writes the story → Gemma finds the details → check everything against the transcript and save.
A transcript: cut the audio into 30-second pieces → one step per piece → join and save.
A photo: Gemma describes it → remove any names and save.

Temporal records each finished step. If the app dies, the steps that finished stay finished. When the app starts again, the worker inside it picks up the unfinished step. While a step runs, it sends Temporal a heartbeat every 20 seconds, so a dead app is noticed within a minute. A failed step (say, Ollama was killed) is tried up to five times over about four minutes, which gives Ollama time to restart. Then, if it still fails, the family sees a clear "try again".

The Temporal server is the open-source dev server (temporal server start-dev), running on the same laptop with its history in a local SQLite file. Nothing leaves the house.

I tested it the hard way: I started a memory, waited for Gemma to finish step 1, then killed the app with kill -9 in the middle of step 2:

Time	What happened
13:24:26	Job starts. Step 1: Gemma writes the story.
13:25:47	Step 1 done (81 s) and recorded by Temporal. Step 2 starts.
13:26:18	App killed in the middle of step 2.
13:26:29	App restarted. Log: `Resuming 1 job(s) with Temporal: ebyafaayo-memory-3`
13:27:03	Step 2 starts again on the new worker. Step 1 is not repeated.
13:28:34	Done. Same result as a run with no crash: 4 people, 3 places, 2 times, no invented clan.

Temporal's web UI shows it plainly: the "find the details" step on its second attempt, and the first step untouched.

My first version of that test took 5 minutes to resume, because the heartbeat only came while Gemma was writing, so the timeout had to be long enough to cover Gemma loading. A separate heartbeat thread fixed it. There is also an automated test that starts a real local Temporal server, makes the "find the details" step crash once, and checks that Gemma's first answer is reused rather than asked for again.

Without a Temporal server the app still works: the same steps run in a background thread, and an interrupted job is marked for the family to retry.

Problems I hit along the way:

Out of memory. The first time Gemma loaded, Linux's out-of-memory killer stopped it, and my editor went with it. Now Ollama runs in its own memory-capped service that restarts itself, and the app runs one heavy step at a time: Gemma is unloaded before transcription, and the speech model is dropped afterwards. Temporal (above) handles the crashes that still happen.
One big prompt was too much for a small model. Asked for everything at once, Gemma E2B sometimes returned every list empty. Splitting the work into two focused calls fixed it: one for the text and translation, one for people, places and times. After that it found every person with the right relationship (father, mother, husband), every place and every date in my test story.
A runaway loop. Once, Gemma wrote the same Luganda word over and over for eight minutes. Now every field in the JSON schema has a maximum length and every list a maximum size, and Ollama enforces them while Gemma writes.
Gemma still makes up facts in translation. In one test, "that is where I met my husband" came out as "my husband was killed". The app checks every quote and name against the transcript, and it drops any clan or totem the elder never said. But it cannot check a translation, so the family's review matters most there.

I wrote the build spec (the rules on consent, honesty and the stack) and built the app with an AI coding agent. Here is the session, trimmed to the real development work:

Built AI assistance

Why Does Open Innovation Matter?

Family stories are private. Many families would never upload a grandmother's voice to a company's server, and many Ugandan homes do not have steady internet. With open-weight models, Ebyafaayo runs fully offline on a laptop, costs nothing per story, and keeps every recording in the family's hands.

Even the crash recovery is open: Temporal's server runs on the same laptop, so a durable job does not need a cloud service either.

Open models also mean our languages can grow. Sunbird AI trained an open model for Luganda and other Ugandan languages, and anyone can build on it. Closed tools rarely serve languages like ours first. Open ones let us do it ourselves.

Prize Categories

Best Use of Gemma. Gemma 4 E2B is the part of Ebyafaayo that turns a transcript into a family memory. It runs locally through Ollama on an 8 GB laptop with no GPU and no internet. It writes the story in Luganda and English, finds the people, places and times, and gives a source sentence for every one. Its answers are held to a JSON schema and checked against what the elder actually said. It also reads old family photos, using Gemma 4's image input, and turns them into questions for the next visit to jjajja. I chose a small open model on purpose: it means a family can run this at home, for free, without sending a grandmother's voice anywhere.

Best Use of Temporal. On an 8 GB laptop, the out-of-memory killer is a regular visitor; it stopped Gemma (and my editor) several times while I built this. Every slow job in Ebyafaayo is now a Temporal workflow made of small steps, running on a local Temporal server. When the app is killed half way, the job picks up at the step it was on instead of starting again, and a failed step is retried until Ollama is back. Temporal is open source, and its server runs on the same laptop, so the stories still never leave the house.

Best Use of Render. Families run Ebyafaayo at home, but judges and curious readers should not have to install anything to try it. So the same app runs as a public demo on Render, with Render as its AI runtime: one Docker service (4 CPUs, 8 GB, no GPU) runs Ollama with Gemma 4 E2B on the CPU, a Temporal dev server, and the app, all talking over 127.0.0.1 inside the container. A persistent disk keeps Gemma, the database and Temporal's history, so a job survives a redeploy just as it survives a crash at home. The whole setup is one render.yaml Blueprint. The demo holds only a sample story and public-domain test photos, and a banner asks visitors not to upload real family recordings: the private version is the one on your own laptop.

Credits

Gemma 4 by Google DeepMind (open weights)
Sunbird/asr-whisper-large-v3-salt by Sunbird AI (MIT)
Temporal (MIT), Ollama, faster-whisper, FastAPI, React, MUI
Test photos: Wikimedia Commons, public domain
Built with help from an AI coding agent (Claude Code); the session is embedded above, and a summary of the decisions is in the repo at docs/agent-log.md.

DEV Community: Nuwahereza Peter

plesase check it out