DEV Community: Sahan Dilshan

Heirloom: Turning a Loved One's Rambling Voice Memo into a Family Cookbook (100% Local, with Gemma + Whisper)

Sahan Dilshan — Mon, 26 Oct 2026 18:57:11 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

What I Built

Every family has one person who cooks by feel. Ask [[NAME, e.g. my Seeya]] how much coconut goes into his pol sambol and the answer is "enough." The recipe isn't written anywhere. It lives in his hands.

So I built Heirloom. You hit record while they cook and talk, rambling, interrupting themselves, telling you who taught them. Heirloom turns that into a proper recipe page:

Clean recipe: ingredients with amounts, ordered steps, tips, tags and allergens
Their story, kept: the memories and "secrets" from the memo, not just the instructions
Ask them next time: when the memo is vague ("a spoon of Maldive fish"), Heirloom does not guess. It writes a question to take back to them
Their voice, kept: the original recording plays inside the recipe page
Cooking mode (one big step at a time for messy hands), a cookbook shelf, and a print-to-PDF family book you can actually hand over

The design rule I held to: a recipe app that invents quantities is worse than no app. Uncertainty becomes a conversation with the person, which is the whole point.

Demo

Live: https://heirloom-saza.onrender.com

A quick honest note: the hosted link runs in demo mode. A free Render instance can't run an LLM, so it returns a canned sample so you can click through the whole experience. The real pipeline (local Whisper + local Gemma) runs on your own machine, and the screenshots below are from that local setup. The free instance also sleeps when idle, so the first load can take about a minute.

Code

Sahan20030814 / heirloom-voice-recipes

Heirloom 🍲

Turn a loved one's rambling voice memo into a beautiful family recipe page, 100% on your own computer, with open-source AI.

Built for the Hacktoberfest 2026 Weekend Challenge: Build for a Friend (DEV). One real person, one real problem: a grandparent who cooks the best food in the family and has never written a single recipe down.

No account. No API key. No bill. The voice, the stories and the health details of the people you love never touch a server you don't control.

What it does

Feature	Details
🎙️ Capture	Record in the browser (live waveform), upload a voice note (WhatsApp `.opus`, `.m4a`, `.mp3`, `.wav`), or paste text
🧠 Understand	Local

…

View on GitHub

MIT licensed, with a full README (local setup for Windows/macOS/Linux and a Render guide).

How I Built It

The pipeline: voice memo → faster-whisper (local) → Gemma via Ollama (local) → structured recipe → cookbook

Speech-to-text: faster-whisper (CTranslate2, int8, runs on CPU) with voice-activity detection to skip silence and kitchen noise.
Understanding: Gemma 3 (open-weight) served by Ollama. I pass a JSON schema in Ollama's format field, so even a small 4B model returns valid, typed recipe JSON instead of free-form text I'd have to parse and pray over.
A prompt that refuses to invent: the model may never add ingredients, amounts or times that weren't said. Anything vague goes into an unclear list, which the UI shows as "Ask them next time." A normalise() step guarantees the response shape on the way out.
App: FastAPI backend, and a plain HTML/CSS/JS frontend with no framework, no build step and no CDN (system fonts), so it works fully offline. The recorder uses MediaRecorder with a live waveform, and a print stylesheet turns the cookbook into a PDF book.
Everything is one env var away from changing: OLLAMA_MODEL, WHISPER_MODEL, OLLAMA_URL.

I built it pair-programming with Claude as an AI coding assistant, then ran, tested and adjusted it myself.

Why Does Open Innovation Matter?

This project would be a different (and worse) product on a closed API.

Privacy is the feature. A recording of an elderly relative, plus the allergies and health details they mention while cooking, is exactly what shouldn't be uploaded to a server I don't control. With local Whisper and Gemma, nothing leaves the laptop. There's no account, no terms of service, no retention policy to read.
Swappable brains. Whisper's accuracy on Sinhala and Tamil lags English, so a bigger Whisper size is one variable away. If a better multilingual model appears next month, I change one line and keep every recipe.
It outlives pricing pages. A family archive should still work in 20 years. Local models cost nothing per memo and work in the kitchen with no signal.

The honest trade-off: running locally on CPU is slower than a hosted API, [[add your real timing for one memo, e.g. "about X seconds per 1-minute memo with whisper-small + gemma3:4b"]], and a 4B model needs the "never invent" guardrails to stay trustworthy. For an archive of voices I care about, I'll take slower and private every time.

Prize Categories

Best Use of Gemma: Gemma 3 runs fully locally through Ollama and does the core work: turning a messy spoken memo into a structured, honest recipe via schema-constrained output.

Best Use of Render: Heirloom's web app is deployed on Render as a free web service, using a render.yaml Blueprint and a /healthz health check, and that is the live demo linked above. To be upfront about scope: the hosted instance runs in demo mode (canned AI responses), because a free instance can't run the models. The real Whisper + Gemma pipeline runs locally. The README documents the paid path for running Ollama as a private service on Render, which I haven't deployed.

Bedtime Sloth: a story for tonight, written by Gemma on your own computer

Sahan Dilshan — Mon, 26 Oct 2026 04:24:03 +0000

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

What I Built

Bedtime is when parents are most tired and children most want one more story. Bedtime Sloth makes that part lazy. You type a child's name, pick a place, and press one button. It writes a new calm story, reads it slowly, and plays the sounds of the night. All of it runs on your own computer.

Here is what you can set before you press the button:

Who it is for, and an optional favourite thing to include, like "a red scarf and a sleepy owl".
Where it happens: Forest, Ocean, Space, Gentle dragons, Night trains or Clouds. Each place changes the colour of the night sky.
How long: 3, 5 or 8 minutes, and how it should feel (Gentle, Very sleepy, Cozy and warm).
How slowly it is read: Slow, Slower or Very slow.
The sounds of the night: rain, ocean, forest night, fireplace, wind or silence.

It is built for a dark room. The sounds fade out on a sleep timer, a Night light switches the screen to warm colours, Screen off turns it fully black, and the controls fade away on their own. At the end you can continue the story tomorrow night, save it as text, or delete it. Every story is saved on the computer, so a favourite can be replayed.

The people who get to be lazier are tired parents, carers and babysitters who do not have to invent a story every night, and anyone who would rather not send a child's name and favourite things to a cloud app.

Demo

The video shows a full run on my laptop: the settings, Gemma writing a story called "Cloud Dreams", and the night sounds, timer, night light and screen off. The narration I added in the video is synthetic (made with the open-source Piper text-to-speech) and the background music was generated for the video.

Hosted copy: https://bedtime-sloth.onrender.com/ runs on Render's free tier, which cannot run a language model, so it tells a short built-in tale and the browser's voice reads it. The real experience, with Gemma writing the story, is the local one.

Code

Sahan20030814 / bedtime-sloth

Bedtime Sloth

A bedtime story written for your child tonight, read slowly in a calm voice, with the sounds of the night. It runs on your own computer, so it works with no internet, and the child's name and every story stay on your machine.

Built for the Hacktoberfest 2026 Open-Source AI Challenge, Week 3 (theme: Slow and Steady).

The problem

Bedtime is the part of the day when parents are most tired and children most want "one more story". Books run out, repeating the same tale gets dull, and story apps usually need an account, an internet connection and a subscription, and they send your child's name and interests to someone else's server.

What Bedtime Sloth does

Feature	Detail
A new story every night	Gemma writes 8, 12 or 18 short paragraphs (about 3, 5 or 8 minutes) from a name, a place, an optional favourite thing and

…

View on GitHub

How I Built It

The storyteller: Gemma 3 4B (open weights), run locally with Ollama. The system prompt sets the tone: gentle and safe, nothing scary, every small worry solved kindly, slower and quieter towards the end, and the child falls asleep in the last paragraph.
The voice: each paragraph is read by Piper, an open-source text-to-speech model, and the next one is prepared while the current one plays. If Piper is not installed, the browser's own voice reads the story.
The sounds: rain, ocean, forest night, fireplace and wind are made live in the browser with the Web Audio API, from filtered noise and oscillators. There are no sound files.
The rest: one Python standard-library server and one HTML file. No framework, no packages for the server.

A bug that taught me something. My first version asked Gemma for strict JSON. Sometimes a small model answers in a shape you did not plan for, and my app quietly fell back to a built-in tale. I only noticed because the screen said "(built-in story)" on a recording I thought was a Gemma story. The fix was to stop being strict:

the prompt now asks for plain text, a title on the first line and paragraphs separated by blank lines
the parser accepts plain text, JSON with other key names, markdown, numbered paragraphs, or one long block that it splits into paragraphs
it retries once with a simpler prompt
when it still has to fall back, a red banner says why, and python server.py --test checks the model

I tested the parser against a fake model that answered in nine different ways, including a missing model, an out-of-memory error and a refused connection. I have not tried every Gemma answer, so the banner stays.

Why Does Open Innovation Matter?

A bedtime app learns a child's name, what they love and when they go to sleep. With an open-weight model, all of that stays on the computer. The model, the voice and the sounds all run locally, so once the model and the voice are downloaded, nothing in the app needs the internet. A closed API cannot promise that.

It also changes the cost. A story every night, for years, would normally mean a subscription or a per-call fee. Here the cost of one more story is electricity. I can swap the model with one setting (BS_MODEL), and in future I could fine-tune a small model on a family's own favourite stories. I have not done that part yet.

There is a trade-off. A 4B model sometimes writes an odd line or a weak ending, and a prompt cannot guarantee a story is suitable for every child. My advice in the README is to read a story first if the child is sensitive. I would rather say that than pretend the model is perfect.

My Agent Session

I built this with Claude in a chat window, not in a coding-agent tool, so there is no agent session file to embed. I used it for the code, the README and a first draft of this post. I ran the app, found the fallback bug, recorded the demo and decided what to keep.

The Lazy Payoff

The effort that disappears is the part at the start of bedtime: thinking of a story, then reading it aloud for five or ten minutes. With Bedtime Sloth it is typing a name and pressing one button. In my screen recording (a 3 minute story on my laptop with 24 GB of RAM), the story appeared about five seconds after I pressed the button. A 3 minute story is 8 short paragraphs.

Who used it this week: My niece asked for a story about her red scarf, and fell asleep before the last paragraph."

Prize Categories

Best Use of Gemma: Gemma 3 4B runs locally through Ollama and writes every story the app tells.
Best Use of Render: The web app and story player are hosted on Render from a Docker blueprint in the repo. The model does not run on Render, so this category is only for the front end.

ListingLab: a local Gemma model that writes your Etsy and eBay listings and keeps your photos private

Sahan Dilshan — Sun, 18 Oct 2026 06:56:35 +0000

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

What I Built

Writing listings is the part of selling online that eats the time. Every item needs a title that fits the platform's limit, a description, key details and a full set of tags, and then you do it all again for the next product.

ListingLab is a small web app that writes the first draft. You drop up to four product photos, add a few notes about the item, pick Etsy or eBay, a voice and a language, and it writes a listing you can paste into the marketplace. It runs on your own laptop with Gemma through Ollama, so your photos and notes never leave your machine, and each listing shows $0.00 in API fees.

What it does:

Writes the listing: title, a two-paragraph description, key details and tags.
Knows the marketplace rules: Etsy titles up to 140 characters with up to 13 tags of 20 characters or fewer, eBay titles up to 80 characters. A live meter shows how close the title is to the limit.
Lets you steer it: four voices (Warm, Minimal, Playful, Premium), four languages (English, Spanish, French, German), two alternative titles, and Regenerate, Shorter and More detail buttons.
Checks the result: a 0 to 100 score from six listing basics. It is a checklist, not a sales prediction.
Does the maths: a Profit tab turns your item cost, selling price, shipping and fee percentage into profit, margin and break-even price.
Keeps a history of recent listings, exports to .txt or CSV, and lets you click a photo to enlarge it.

Who would pay for it? My guess is sellers with a growing catalogue, such as small Etsy shops and people reselling items on eBay, for whom time per listing matters and who would rather not send product photos to a cloud service. Because it costs nothing to run per listing, it could be sold for a one-off price or a small monthly fee. I have not tested whether anyone would pay, so please read that as a hypothesis, not a result.

Demo

Live: https://listinglab-15yt.onrender.com/

An honest note about the hosted copy: it runs on Render's free tier, which cannot run a language model. There, the app says Model offline, template mode and builds a plain template from your notes. Everything else works, including the platform limits, the Check tab and the Profit tab. The first load can take up to a minute while the free instance wakes up. The real experience is the local one, where Gemma writes the listing.

The empty app, with the drop zone, notes box, platform switch, voice and language:

The Check tab scoring a listing:

The Profit tab:

Code

Sahan20030814 / listinglab

ListingLab

Photos and a few notes in. A ready-to-paste Etsy or eBay listing out. It runs on the seller's own laptop, so product photos stay private and every listing costs nothing in API fees.

Built for the Hacktoberfest 2026 Open-Source AI Challenge, Week 2 (theme: Side Hustle).

The problem

Small sellers spend more time writing listings than making products. A good listing needs a title that fits the platform's limit, a clear description, key details and a full set of tags, repeated for every item. Paid AI tools charge per listing or per month, and they upload your photos and product ideas to someone else's server.

What ListingLab does

Feature	Detail
Listing writer	Title, two-paragraph description, key details and tags from up to 4 photos and your notes
Etsy and eBay rules	Etsy: title up to 140 characters, up to 13 tags of at most 20 characters. eBay: title

…

View on GitHub

How I Built It

Model: Gemma 3 4B (open weights), run locally with Ollama. The server calls Ollama's local chat API and asks for JSON.
Server: one Python standard-library file, no framework and no pip packages.
Interface: one HTML file with inline CSS and JavaScript. Photos are shrunk to 768 px in the browser before they are sent.
Deploy: a Dockerfile and a render.yaml blueprint for Render. The public demo sets LL_NO_HISTORY=1 so visitors never see each other's listings.

The model writes the words. Everything that has to be right is ordinary code. The marketplace rules live in a small table, and the server clips the title to the limit and cleans the tags (lowercase, no duplicates, at most 20 characters each):

RULES = {"etsy": (140, 13, "Etsy: title up to 140 characters, up to 13 tags, each tag at most 20 characters."),
         "ebay": (80, 8, "eBay: title up to 80 characters, factual and keyword-first, up to 8 keyword tags.")}

The score and the profit maths are plain JavaScript, so they never depend on the model. If the model cannot read photos, the app falls back to your notes and says so. If Ollama is off, it uses a plain template and says so. It never pretends.

What I found when I tested it

I ran it on my own laptop with gemma3:4b. One run with four photos and a long set of notes took 18.7 seconds and 709 tokens, and the app showed $0.00 in API fees. Two honest things from that run:

The model did not read my photos. The copy of the model on my laptop could not take image input in that run, so ListingLab fell back to my notes and said so on screen ("Used your notes only"). Photo reading needs a vision-capable model. I have not verified photo reading end to end.
The model added a detail I did not give it. The title it wrote included a condition, "Excellent Condition", that was not in my notes. My prompt tells it not to invent facts, and a small model still does. That is why the Check tab exists and why the app is a drafting tool, not an autopilot: read every listing before you publish it.

The Check tab scored that listing 50 out of 100 and flagged a short description and too few key details. For the Profit tab, an item cost of 2000, a selling price of 3000, shipping of 50 and fees of 5% gave a profit of 800.00, a 27% margin and a break-even price of 2157.89. The numbers are currency-neutral, and you enter your platform's current fee percentage because fees change.

Why Does Open Innovation Matter?

A listing writer sees exactly what a seller is about to sell: unreleased products, handmade designs, photos of stock at home. With open weights, that all stays on the seller's machine. The app also works with the Wi-Fi off, because the model, the server and the page are all local.

Cost is the other reason. A seller with hundreds of products would pay per listing, or per month, to a closed API. Running the model locally means the marginal cost of one more listing is electricity, and the seller is not tied to someone else's pricing. The model is also one setting (LL_MODEL), so it can be swapped for a different open model, and in future fine-tuned on a shop's own best listings. I have not done that fine-tuning yet.

There is a trade-off, and I want to be straight about it. A 4B model writes less polished text than the biggest closed models and sometimes invents details, as my test showed. I leaned on that by keeping the limits, the score and the profit maths in code, and by labelling every fallback on screen.

My Agent Session

I built this with Claude as a coding assistant and AI-assisted drafting. I ran the app, tested it, took the screenshots and decided what to keep.

Prize Categories

Best Use of Gemma: Gemma 3 4B runs locally through Ollama and writes every listing the app produces on my machine.
Best Use of Render: the web app is deployed on Render from a Docker blueprint in the repo. The model does not run on Render, so the hosted demo uses the template fallback.

Touch Grass Planner: a local Gemma model that plans your walk, then turns the screen dark

Sahan Dilshan — Sun, 11 Oct 2026 08:34:46 +0000

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

What I Built

Touch Grass Planner is a web app whose whole job is to get closed quickly.

You say what you feel like doing (walk, hike, run, birdwatching, gardening) and how many minutes you have. A Gemma model running on your own machine writes a short plan. The app draws a loop sized to your time, and gives you five things to notice on the way. Then you press Start and the page turns into a dark countdown with your route on it. You leave. When you get back you press I'm back, and it keeps your streak.

It is for anyone who opens the laptop "for a minute" and would rather be outside. I built it in Sri Lanka, so it also has a garden planner with a tropical mode (Maha and Yala seasons) and a frost mode for colder places.

What it does:

Plan: a short, specific outing plan from Gemma, using your activity, time, weather and garden jobs.
Loop: a triangle route sized to your time, computed on the device from compass bearings, drawn on an OpenStreetMap map, with a walking-directions link.
What to notice: a five-item checklist tied to your activity. The count goes into your journal.
Start timer: a dark full-screen countdown that shows the loop map and legs.
Garden planner: what to sow this week, from a plain data table you can edit.
Weather: live conditions from Open-Meteo when you have internet.
Journal and streak: stored in a local file.
Bird ID (optional): BirdNET identifies bird sounds you record. It needs a separate install.

Planner page: live weather, a plan from Gemma 3 4B running locally, a notice checklist, and a triangle loop on the map.

Demo

Live: https://touch-grass-planner-oi06.onrender.com/

One honest note: the hosted copy runs on Render's free tier, which cannot run a language model. There, the app shows a clearly labelled template plan instead of Gemma. Everything else (garden, loop, map, timer, notice list) works. The first load can take up to a minute while the free instance wakes up. The real experience is the local version, where Gemma writes the plan.

The dark Start screen: a countdown with the loop map and legs. Press "I'm back" to log the outing.

Code

Sahan20030814 / touch-grass-planner

Touch Grass Planner

A local-first outdoor companion. An open-weight model on your own machine plans the outing, then the screen goes dark and you go outside.

Built for the Hacktoberfest 2026 Open-Source AI Challenge, Week 1 (theme: Touch Grass).

Live demo: https://touch-grass-planner-oi06.onrender.com/ (the hosted copy cannot run the model, so it shows a clearly labelled template plan; the first load can take up to a minute on Render's free tier)

What it does

Feature	What you get	Needs internet?
Outing plan	A short, specific plan written by Gemma (via Ollama) from your activity, time, conditions, garden jobs, route, and your climate and season	No
Loop route	A triangle loop sized to your time, computed on-device from compass bearings, drawn as a sketch and on a map, with a Google Maps walking link. With internet it checks OpenStreetMap tiles and rotates or shortens the loop to keep it out of

…

View on GitHub

How I Built It

Model: Gemma 3 4B (open weights), run locally with Ollama. The server calls Ollama's local HTTP API.
Server: one standard-library Python file, no framework and no pip installs.
UI: one HTML file with inline CSS and JavaScript.
Weather and map: Open-Meteo (no API key), Leaflet and OpenStreetMap tiles.
Bird ID: BirdNET-Analyzer, optional, run on the same machine.
Deploy: a Dockerfile and a render.yaml blueprint for Render.

The main design decision was to let the model write words and nothing else. A 4B model should not be trusted with facts, so everything that has to be right is ordinary code: the crop calendars, the loop geometry and the journal. The model only gets a short, factual prompt: your activity, minutes, weather, garden jobs, the loop, and the climate and season (for example "Tropical Sri Lanka, Maha season, no autumn or winter"). If the model is not running, the app says so on screen and uses a plain template. It never pretends.

One extra feature came from a problem I hit. The loop is a straight-line triangle, and on my first test it ran into the sea, because I live near the coast. So the app now reads the colour of the OpenStreetMap tile under points along the loop. If it sees water, it rotates the loop, or shortens it, until it stays on land. This needs internet, and it only avoids water, not fences or private land.

To run it yourself:

ollama pull gemma3:4b
python server.py

Then open http://localhost:8000. Set TG_MODEL to use a different model.

Why Does Open Innovation Matter?

The app is about leaving the laptop, so it should work where you go, and that includes places with no signal. With open weights the planning step runs on my machine. The plan, garden list, timer, journal and notice list all work with the wifi off. A closed API cannot promise that.

It also keeps my data with me. Where I walk, when, and what I noticed is saved in a local file, not on a server I do not control.

The weights are ordinary files. When the model download kept failing on my connection, there were other ways to get it instead of depending on one service. I can swap the model with one setting (TG_MODEL), and the app costs nothing to run because there are no API keys or per-call fees.

There is a trade-off. A 4B model is less polished than a big closed one. My first plan for a walk in Sri Lanka was called an "autumn walk", because my prompt only told it the month. I fixed that by passing the climate and season in the prompt and stripping season words that do not apply. That is why the facts live in code and the model only writes the words.

Taking It Outside

I have tested this on my laptop, not on a long walk. Here is what I found. The timer, journal, notice checklist and loop all work end to end. My first loop ran into the sea, because a laptop's location is a guess from the internet connection, not GPS. That is why the app now checks the map for water and lets you click the map to set your start. Gemma also called a Sri Lanka walk an "autumn walk" at first, which is why the prompt now carries the climate and season.

I did not field-test the bird identification feature on a trail. Next, I want to take it on a real walk and see how the plan and the loop hold up.

My Agent Session

I built this with Claude as a coding assistant, and I tested and ran it myself.

Prize Categories

Best Use of Gemma: Gemma 3 4B runs locally through Ollama and writes every plan.
Best Use of Render: the web app is deployed on Render from a Docker blueprint in the repo. The model itself runs locally, and the hosted demo uses the template fallback.

Known limits: the loop is a rough straight-line shape (use the maps link for real streets), a laptop's location can be kilometres off (you can click the map to set your start), and a small model sometimes gets details wrong.

DEV Community: Sahan Dilshan

Heirloom: Turning a Loved One's Rambling Voice Memo into a Family Cookbook (100% Local, with Gemma + Whisper)

What I Built

Demo

Code

Sahan20030814 / heirloom-voice-recipes

Heirloom 🍲

Table of contents

What it does

How I Built It

Why Does Open Innovation Matter?

Prize Categories

Bedtime Sloth: a story for tonight, written by Gemma on your own computer

What I Built

Demo

Code

Sahan20030814 / bedtime-sloth

Bedtime Sloth

The problem

What Bedtime Sloth does

How I Built It

Why Does Open Innovation Matter?

My Agent Session

The Lazy Payoff

Prize Categories

ListingLab: a local Gemma model that writes your Etsy and eBay listings and keeps your photos private

What I Built

Demo

Code

Sahan20030814 / listinglab

ListingLab

The problem

What ListingLab does

How I Built It

What I found when I tested it

Why Does Open Innovation Matter?

My Agent Session

Prize Categories

Touch Grass Planner: a local Gemma model that plans your walk, then turns the screen dark

What I Built

Demo

Code

Sahan20030814 / touch-grass-planner

Touch Grass Planner

What it does

How I Built It

Why Does Open Innovation Matter?

Taking It Outside

My Agent Session

Prize Categories