DEV Community: Lasyapriya Putti

👻 GhostArchive: Giving Family Memories a Voice with Offline AI

Lasyapriya Putti — Sat, 31 Oct 2026 14:52:34 +0000

Some voices deserve to live forever.

What if we could preserve not just photographs of our loved ones, but also their voices, stories, experiences, and the little things that make them unforgettable?

For Hacktoberfest 2026 – Open-Source AI Challenge, Week 4, I explored this idea through GhostArchive, an offline AI-powered family memory preservation application.

Inspired by this week's theme, Ghost in the Machine, and the spirit of Día de los Muertos, I wanted to explore how AI could help us preserve memories that might otherwise disappear with time.

💡 The Problem

We take hundreds of photographs and videos, but how often do we actually preserve the stories behind them?

Our grandparents have stories about their childhood, traditions, struggles, and experiences. Unfortunately, many of these stories are never recorded.

Once those voices are gone, their stories can become difficult to recover.

I wanted to build something that could help families preserve these memories in a more meaningful way.

👻 Introducing GhostArchive

GhostArchive is an offline AI-powered memory preservation tool that transforms recorded family conversations into searchable digital memories.

Instead of simply storing audio recordings, it uses AI to help organize, understand, and preserve the stories behind them.

What can it do?

1. Record a Memory

Users can record conversations, personal experiences, and family stories directly through the application.

2. Convert Voice into Text

Using Whisper.cpp, the application transcribes recorded conversations into readable text without depending on a cloud transcription service.

3. AI-Powered Storytelling

Using Gemma 3, the application transforms raw transcripts into organized, readable stories while preserving the original meaning.

4. Preserve Memories

Users can save transcripts, generated stories, dates, and associated photographs in a local database.

5. Search Past Memories

Users can search their saved memories and revisit stories whenever they want.

🛠️ Technology Stack

I chose technologies that support local execution and give users greater control over their data.

Technology	How it is used
Python	Application logic
Streamlit	Interactive user interface
Whisper.cpp	Local speech-to-text transcription
Gemma 3	Open-weight language model for storytelling
Ollama	Local model execution
SQLite	Local memory storage
SoundDevice	Audio recording

⚙️ How It Works

The application follows a simple pipeline:

A user records a family conversation.
Whisper.cpp converts the audio into text.
The transcript is passed to Gemma 3.
Gemma generates an organized story from the transcript.
The user reviews and saves the story.
SQLite stores the memory locally for future access.

Architecture:

       User
        |
        v
   Streamlit UI
        |
        v
  Audio Recording
        |
        v
    Whisper.cpp
        |
        v
  Text Transcript
        |
        v
     Gemma 3
        |
        v
  Story Generation
        |
        v
     SQLite
        |
        v
  Saved Memories

🔓 Why Open-Source AI?

For this project, using open-source tools and open-weight models is not just a technical choice. It is an important part of the idea itself.

Privacy: Family conversations can contain personal information. Processing recordings locally reduces the need to upload private memories to external AI services.

Offline Accessibility: Once the required models are downloaded, the application can work without an internet connection.

Freedom and Flexibility: Users can experiment with different models and customize how stories are generated.

Long-Term Preservation: The project does not depend entirely on one commercial AI service. Its local data and open technologies give it a more independent foundation.

I particularly liked the idea that technology could help preserve something as personal as a family memory without requiring those memories to leave someone's computer.

❤️ What Makes This Project Special?

AI is often used to generate content, automate tasks, or improve productivity.

But what if we used it to preserve something meaningful?

GhostArchive explores a different use of AI: helping people hold on to the stories, voices, and experiences that connect generations.

Technology continues to evolve, but the memories we share with one another are worth preserving.

🚀 Future Improvements

There are several features I would love to explore:

Multilingual transcription for regional languages such as Telugu.
Family memory timelines.
Voice-based memory search.
Support for photographs and scanned letters.
Automatic organization of memories by people, places, and events.
Exporting memories into a digital family history book.

🎃 Final Thoughts

The most interesting thing about AI is not just what it can create, but also what it can help us preserve.

With GhostArchive, I wanted to explore how open AI technologies could make personal memories more accessible, private, and lasting.

Because sometimes, the most valuable thing a machine can do is help us remember.

A voice may fade, but a story doesn't have to.

Built for: Hacktoberfest 2026 – Open-Source AI Challenge, Week 4

Theme: Ghost in the Machine

Project: GhostArchive – An Offline AI-Powered Family Memory Keeper

Tags: #devchallenges #hf26challenges #opensource #ai

Wildling 🌿: Discover the Nature You've Been Scrolling Past

Lasyapriya Putti — Sun, 11 Oct 2026 05:41:12 +0000

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

Think about how often we scroll past pictures of cute birds, beautiful flowers, butterflies, and fascinating insects on our phones.

We stop to admire them. We like the picture. Maybe we share it with a friend. Then we keep scrolling.

But have you ever thought about how many of those things are living just a few steps away from you?

Imagine walking past the same garden every day, your eyes fixed on your phone. You might never notice that the garden is home to dozens of different flowers, birds visiting the trees, butterflies moving between plants, and tiny insects living in places you rarely look.

You don't need to travel to a forest or visit a national park to experience nature. Sometimes, an entire world of discoveries is waiting in a garden you pass every morning.

We have become so used to experiencing nature digitally that we sometimes forget to notice it in real life.

I wanted to build something that could change that.

What if, the next time you walked past a flower, instead of scrolling through another post, you stopped for a moment, took a picture, and discovered what it actually was?

What if a walk became a small adventure? What if you had a reason to explore a little more every day, notice a species you had never seen before, and learn something about the environment around you?

That's the idea behind Wildling — an AI-powered nature explorer designed to turn everyday walks into opportunities for discovery.

🌱 Meet Wildling

Wildling encourages you to step away from passive screen time and actively explore the nature around you.

The idea is simple: don't just scroll past nature. Go out and discover it.

Here's what you can do with Wildling.

📸 1. Discover and identify species with AI

You notice an unfamiliar flower, a bird sitting on a wall, or an insect resting on a leaf. Instead of wondering what it is and forgetting about it, open Wildling and take or upload a picture.

Wildling uses AI to compare the image with its species catalogue and suggest possible matches.

The current catalogue contains 921 species, covering categories such as plants, birds, insects, fungi, mammals, reptiles, amphibians, fish, and more.

You don't need to be a botanist, birdwatcher, or wildlife expert to start exploring. Curiosity is enough.

🔎 2. Explore possible matches

Sometimes identifying a species from a photograph isn't straightforward.

Wildling ranks candidate species and presents possible matches, giving you a starting point for learning about what you've found.

The goal isn't to pretend every identification is certain. The catalogue has limitations, and the model can make mistakes, particularly when a species isn't represented well.

Think of the result as an invitation to investigate further, not a scientific confirmation.

📚 3. Build your own nature collection

Every discovery can become a memory.

Wildling includes a collection feature that lets you keep track of the species you've explored and revisit your discoveries.

Over time, your collection can become a personal record of your encounters with the natural world.

Instead of remembering only the posts you've liked, you can look back at the things you've actually found around you.

🔥 4. Maintain your exploration streak

Want to make spending time in nature a regular habit?

Wildling includes streak tracking to encourage you to return to your exploration journey.

The idea is to build consistency through small actions. You don't need to spend hours outdoors every day. Even a short walk where you deliberately notice something new can be a meaningful start.

🏅 5. Earn badges as you explore

Wildling includes badges and progress features that make discovering nature more rewarding.

As you continue exploring, these features give you milestones to work toward and reasons to keep learning.

Instead of rewarding how long you remain on an app, the intention is to reward curiosity and exploration.

🧭 6. Take on quests

Wildling also includes quests that encourage you to approach nature exploration with a goal.

Rather than walking past the same surroundings without noticing them, you can use a quest as a prompt to look more carefully and seek out new discoveries.

It turns the question from “What should I do on my phone?” into “What can I discover outside today?”

🎨 7. Share your discoveries

Found something interesting? Wildling includes a sharing feature that lets you create shareable cards from your discoveries.

You can share what you've found with friends and inspire them to look more closely at the nature around them, too.

Imagine a friend sharing a picture of an unfamiliar flower they discovered in their neighbourhood. It might encourage you to investigate the plants growing along your own street.

That is the kind of interaction I want to encourage: sharing discoveries that bring our attention back to the real world.

🌍 The bigger picture

All these features work toward the same goal.

Wildling isn't trying to replace one endless feed with another. It's meant to give you a reason to open the app, explore something in the real world, learn from the experience, and then put your phone away again.

You might start by identifying one flower. Tomorrow, you might notice a bird. A few days later, you might find yourself looking more carefully at a garden you've passed hundreds of times.

The surroundings haven't changed. Your attention has.

Try Wildling

Live demo: https://huggingface.co/spaces/LasyapriyaPutti/wildling

Take a look at the app and try uploading a nature photograph to see what the model suggests.

💻 Code

GitHub repository: [https://github.com/lasyapriyaputti/wildling.git]

Wildling is built with React and Vite, with Python tools for preparing the species catalogue and embeddings.

🛠️ How I Built It

I wanted to make Wildling more than a static collection of species information. I wanted people to be able to photograph something they encountered and use AI to explore what it might be.

For the recognition system, I chose BioCLIP, an open-weight vision model designed for biological image understanding.

Here's how the main components work together.

1. Preparing the species catalogue

I prepared a catalogue of 921 species and generated text embeddings for the catalogue entries.

These embeddings act as reference representations. The application compares an image representation with the species embeddings to find candidate matches.

Keeping the catalogue and embeddings aligned is essential because each embedding must correspond to the correct species.

2. Bringing BioCLIP into the browser

The model's image encoder was exported to ONNX and integrated with ONNX Runtime Web.

This allowed the application to run image inference in the browser instead of requiring a dedicated remote inference API for each prediction.

3. Connecting images to species

When a user submits an image, Wildling preprocesses it and passes it through the image encoder.

The resulting image representation is compared with the catalogue embeddings. The application ranks the candidate matches and displays the suggested species.

The current system is catalogue-based, so its predictions depend on the species represented in the catalogue. A high-ranked match should not be treated as a calibrated probability or guaranteed identification.

4. Building the exploration experience

The frontend uses React and Vite. Around the recognition pipeline, I built the collection, streak, badge, quest, and sharing experiences to encourage people to return to nature exploration.

5. Testing and deployment

Getting an AI model working in a browser involved more than connecting a few components.

I had to validate the embeddings, check the ONNX model, manage the browser runtime files, and make sure the production build could load the model and generate predictions.

The image encoder is approximately 346 MB, which also made deployment and large-file management important parts of the work.

I deployed Wildling on Hugging Face Spaces and tested that the live application could run its browser-based recognition flow.

Wildling is still an early version. The catalogue needs continued validation, and the recognition system needs broader testing with real-world photographs. Those are important next steps for making the experience more reliable.

Why Does Open Innovation Matter?

Open innovation made Wildling possible in a way that would have been much harder if I had needed to build everything from scratch.

Building on existing research

BioCLIP gave me access to a model designed for biological image understanding. Instead of first training a vision model myself, I could focus on integrating the model into a useful application.

For an individual student developer, that access makes it possible to experiment with specialized AI using resources that would otherwise be difficult to obtain.

Running inference in the browser

Using ONNX Runtime Web allowed me to build a browser-based inference pipeline without relying on a separate hosted inference API for every image.

This gives the application more control over image processing and offers a path toward keeping images local. The model and required assets still need to be downloaded, so the whole experience is not automatically offline.

Making the project open to improvement

Open tools make it easier for developers to understand an implementation, test it, and experiment with different approaches.

Wildling can benefit from continued improvements to its catalogue, evaluation process, recognition pipeline, and user experience.

Open innovation doesn't mean the work is finished or every result is correct. It means more people can learn from the work and help make it better.

🌿 A Small Change in What We Notice

The next time you walk past a garden, you might be tempted to reach for your phone and start scrolling.

But what if you looked up instead?

What if you noticed a flower you've never seen before, followed a butterfly for a few seconds, or wondered which bird was making that sound?

You don't need to become a wildlife expert. You don't need to travel somewhere extraordinary. You just need to start noticing what's already around you.

I built Wildling because I believe AI can be useful in ways that don't demand more of our attention, but help us direct it toward things that matter.

The goal isn't to spend more time using Wildling. It's to spend more time discovering the world that exists beyond it.

So the next time you're walking past that familiar garden, put the scrolling on pause.

There might be a whole world waiting for you to notice it.

🌱 Wildling: Discover more. Scroll less. Touch grass.

#devchallenge #hf26challenge #opensource #ai #webdev

My friend's kirana store runs out of milk every Sunday. So I gave it a voice.

Lasyapriya Putti — Mon, 05 Oct 2026 05:47:38 +0000

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

What I Built

My friend Surya runs a kirana: the small neighbourhood grocery store you'll find on almost every street in India. Milk, bread, sugar, dal, biscuits, soap. His shop is a few steps from my house.

Two problems keep coming back. On Sundays and during festivals, demand jumps: Indian festival sweets and snacks are made from milk, flour and sugar, so those run out first. On other days he sometimes overstocks by mistake: packets get pushed behind other items, look finished, get reordered, and the extra stock expires and goes to waste.

Nobody is careless here. Running a kirana means making change, serving a queue and answering questions at the same time. Nobody has a free hand to type into inventory software, and that software is in English anyway. So most owners run their stock from memory and gut feeling.

KiranaVoice is a stock assistant you talk to. One big button, in your own language.

You say what happened:

"5 packets milk sold"
"20 kg sugar aaya" (20 kg of sugar arrived)
"ఈరోజు 20 కేజీల పంచదార దిగుమతి అయింది"

You ask what's left:

"milk kitna bacha hai?" (how much milk is left?)
"How many eggs do we have?"

The app answers straight away, on screen and out loud. No typing and no menus.

It repeats everything back before it saves anything. A shop is noisy, and a speech recogniser can mishear. So for every sale or delivery, KiranaVoice says what it understood, for example "Sale: 5 milk", and changes the stock only when the owner taps Confirm. A wrong entry is one tap on Undo away.

It warns you before the shelf is empty. KiranaVoice looks at past sales, including weekend spikes and festival days. If tomorrow's expected demand is higher than what is on the shelf, it shows an urgent morning alert in the owner's language, with a suggested reorder quantity: "Tomorrow's demand for milk is about 54 packets, but only 18 are left. Order 45 more today!"

It works in 11 languages: Telugu, Hindi, Tamil, Kannada, Bengali, Marathi, Gujarati, Malayalam, Punjabi, Hinglish and English. The interface, item names, units and spoken alerts all switch together. It understands several items in one sentence ("2 milk, 3 sugar sold"), spoken numbers ("paanch", "ఐదు") and amounts like "250 gram" or "half".

Demo

🔗 Live demo: https://kiranavoice.streamlit.app/

A note on the hosted demo. The cloud server has no GPU or Ollama, so the live link uses the rule-based parser and a weekday-average forecast on demo data. The full setup, with Gemma through Ollama and TabPFN, runs on the shop's own machine.

Open it in Chrome or Edge and allow the microphone. You can also type, and any of these will work:

5 packets milk sold
2 milk 3 sugar sold
20 kg sugar aaya
sugar kitna bacha hai

Video:

Screenshots:

Code

lasyapriyaputti / KiranaVoice

How I Built It

 Voice ─▶ browser speech recognition ─▶ rule-based parser ──┐
                                                            ├─▶ checked against the item catalog
 Unclear speech ─▶ Gemma 2 (2B) via Ollama ─────────────────┘            │
                                                                         ▼
        Stock question ─▶ answered at once       Sale / delivery ─▶ read back aloud ─▶ Confirm ─▶ SQLite
                                                                                                    │
                                              sales history ─▶ TabPFN (or weekday average) ─▶ morning alert

The AI is not the whole system. If a plain program can decide something reliably, a plain program should. Telling "sold" from "aaya", reading "250 gram", or knowing that "kg" is a unit and not an item are all done by ordinary code. Gemma 2 (2B) via Ollama is asked only when the rules understand nothing. Its answer must then match a real item in the catalog, or it is thrown away.

The system never guesses. If it doesn't understand, it says so and asks again. It will not quietly record "milk" because that was the default.

Forecasting. For every item with enough history, I train TabPFN on small tabular features: day of week, weekend, festival, same day last week and a rolling average. TabPFN is built for small datasets, and one shop's history is small. With too little data it falls back to a weekday/weekend average. Each alert includes a range and a reorder amount with a 15% safety buffer. Every confirmed sale feeds back into the history.

Stack: Python, Streamlit, SQLite (WAL mode), Ollama with Gemma 2 2B, TabPFN, and a small custom browser component for the mic.

What testing taught me. My first version had bugs that would have quietly wrecked a real shop's stock:

It looked up items with LIKE '%Milk%', so one sale could change several products.
It treated the word "kg" as proof that the item was sugar.
When it understood nothing, it recorded Milk anyway.
Every spoken sentence reloaded the whole page and reset the language.

I fixed each one with exact item matching, unit words ignored when choosing items, an explicit "I didn't understand", and a mic component that hands text straight to Python. I also made every confirmation idempotent, so a double tap can't record a sale twice.

Why Does Open Innovation Matter?

A kirana's daily sales are its business. Here is what open tooling made possible that a closed API would not have:

The shop's data stays in the shop. Stock and sales live in a local SQLite file, and the AI can run on the owner's own machine. Nothing has to be sent to a company's server.
No meter running. There is no per-request fee. Kirana margins are thin, and a bill that grows with every sale would end the idea before it started.
I can change it. Adding a language means adding item names and keywords, not retraining or renegotiating anything. A better open model can replace Gemma without touching the rest of the app.
It can get more private. Chrome's speech recognition still sends audio to Google, so KiranaVoice is not fully offline yet. The fix is an offline Indian-language speech model from the open Whisper family, and only open weights let me plan that.

Known Limits, and What's Next

Gemma 2 2B is still learning Telugu, Tamil and Kannada. That's why plain rules handle most sentences, with Gemma as a safety net. Next: test a larger open model and fine-tune on real shop speech.
Speech recognition still needs internet, because Chrome sends audio to Google. Next: an offline Indian-language model from the open Whisper family.
The forecast on the demo uses sample sales history, not real sales. It learns from every confirmed sale, so it improves with use.
Brand-name items still appear in English. Next: regional-language names, which native speakers can contribute.
The morning alert shows when the app is opened. Next: WhatsApp delivery, since that's where owners actually look.

Beyond that, I plan to add udhaar (credit given to regular customers) tracking by voice.

Prize Categories

Best Use of Gemma
Best Use of TabPFN