# Stories We Keep: Carrying Amharic and English Family Memories Forward

> Source: <https://dev.to/lilymercy/stories-we-keep-carrying-amharic-and-english-family-memories-forward-21p4>
> Published: 2026-10-31 01:11:34+00:00

*This is a submission for the [Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine](https://dev.to/challenges/hacktoberfest-week4-2026-10-26).*

Sometimes, when my grandma tells a story, or my family shares funny memories, I record a video for fun. I enjoy those moments, and I want to return to them and pass them on.

Language was another reason I wanted to build this. So many of the tools I encounter center on English. Someone shouldn’t have to speak English to preserve their own story.

**Stories We Keep** lets someone record a family memory in Amharic or English, review the transcript, and turn it into a picture storybook with family photos and the original recording.

For “Ghost in the Machine,” I wanted to explore the past through the stories our families carry. A grandparent remembering their childhood home, an ordinary afternoon, or a funny family moment can become something another generation gets to hear.

The app starts with a question, but the person telling the story decides where it goes. The question can stay with the finished book so a future reader understands what prompted the memory. Families can also add a translation they have reviewed themselves.

Amharic support currently covers transcription and the story prompts. The rest of the interface is primarily English; translating that experience is still work to do.

*The homepage introduces the recording workflow and a fictional example storybook.*

Choose **See an example book** for a quick look. The sample uses fictional text and an illustration; it is not a real family recording.

To make your own:

No account or API key is required. Saving stories in the browser asks you to create a password for encrypted local storage. Downloads are unencrypted copies, so keep and share them carefully.

Transcription uses a free GPU service with queues and usage limits. If the free GPU quota is exhausted, recordings up to 60 seconds can fall back to CPU transcription. Longer recordings still depend on GPU availability. You can explore the example book without waiting for a model.

[Source code and setup instructions](https://github.com/mercyg/stories-we-keep)

The app is MIT-licensed. The repository includes the frontend, hosted speech service, optional local backend, deployment configuration, and tests. Model checkpoints retain their upstream licenses.

Transcription is the core AI step:

`b1n1yam/shook-tiny-amharic-600hr`` openai/whisper-small.en`
Both checkpoint pages list Apache-2.0. I use the existing weights; I did not train the models.

The frontend runs on Vercel. A Gradio service on Hugging Face ZeroGPU runs the models with Transformers and PyTorch. FFmpeg decodes the recording bytes in memory, including browser WebM recordings.

``` php
flowchart TD
    A["Recording and consent"] --> B["Hosted speech model"]
    B --> C["Encrypted transcript returned to browser"]
    C --> D["Review words and add photos"]
    D --> E["Encrypted storage on this device"]
    D --> F["Download HTML book or PDF"]
```

**The book editor divides reviewed text into editable pages without asking a model to invent more of the memory.** The original recording stays available to listen to alongside the transcript. Pictures come from uploads; automatic translation and AI illustration generation are not connected in the hosted version.

These stories can contain names, places, and details that belong within a family. Privacy needs to be part of the implementation.

Saved stories, including text, questions, photos, and original audio, are encrypted in the browser using **AES-256-GCM**. A key is derived from the user’s password with PBKDF2-SHA256 and 600,000 iterations. Neither the password nor that key is sent to the speech service. Reloading the app starts protected storage locked.

Hosted transcription is a separate decision. Before sending a recording, the app asks for permission and identifies the Hugging Face destination. The service processes audio in memory without creating downloadable audio files. Public file upload and download routes are blocked, and queued transcript responses are encrypted for a fresh key held by the requesting browser.

**Hugging Face still handles readable audio during transcription.** This is not end-to-end private inference, and I cannot guarantee provider-wide deletion. Exported books are unencrypted, browser-data deletion removes local stories, and there is no password recovery. These protections have automated checks, but no independent security audit.

The documented checks include **14 JavaScript tests and 6 Python tests** covering text preservation, exports, encrypted storage, migration rollback, blocked file routes, and rejection of encrypted results by a different recipient key.

Integration testing transcribed a 6.28-second synthetic English sample in WAV and WebM through the client module.

To test the Amharic workflow, I recorded a sample answer to “What did home look like when you were little?” I was happy with the transcription. Seeing spoken Amharic become readable text made the purpose of the app feel more tangible: a family could keep a story in the language it was told.

This was an initial hands-on test, not a formal accuracy evaluation across speakers, dialects, or recording conditions.

The current recording limit is five minutes / 30 MB. Longer conversations and broader family testing remain next steps.

The clearest benefit was **being able to build around Amharic**. I could choose a community-published Amharic checkpoint alongside an English one and run the weights myself, rather than depend on one proprietary transcription endpoint’s language support.

Open weights also make that choice replaceable. I can compare checkpoints, change where inference runs, or adopt a better Amharic model as one becomes available. Other developers can adapt the code for their own languages and communities.

The demo uses free hosting resources and no paid inference API. That does not make computing unlimited or free everywhere: ZeroGPU has quotas, and running your own models requires suitable hardware. But it let me build and share this prototype within a zero-dollar budget.

The repository also includes an optional local backend. The hosted demo sends audio to Hugging Face; open weights give someone the option to run transcription on infrastructure they control.

Finally, I wanted the keepsake to outlast the demo. The downloadable HTML book works offline, with its text, pictures, and attached recording. That portability comes from the export design; open models separately make the transcription service replaceable.

I started with something I already do: recording a family story because it makes me smile. I wanted to give those recordings a form we could keep and make room for the language in which those memories were first told.

**What’s a story someone in your family tells that you’d like to preserve?**

*AI assistance: Codex helped with development and drafting this post.*