The Last Light: Keeping Memories Alive with Local, Open-Weight AI 🕯️

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

What I Built

What if the most meaningful use of AI wasn't answering questions, writing code, or automating work - but helping us keep the stories we never want to forget?

That question inspired The Last Light, a cinematic, privacy-first AI memory keeper built around the idea that memories deserve a place to live, without having to leave the devices where they are stored.

The Last Light brings together the atmosphere of a candlelit remembrance altar, the intimacy of a personal journal, and the creative possibilities of open-weight AI. Here is what it offers:

• The Digital Ofrenda: An interactive remembrance altar featuring candlelight, marigolds, photographs, and personal dedications.
• The Memory Archive: A personal space for preserving names, dates, family stories, favorite foods, songs, meaningful places, and photographs.
• Let the Memory Speak: A local AI writing studio that transforms a memory into a first-person remembrance, a heartfelt letter, an atmospheric story, a poem, or a family chronicle.
• Private by design: Memories and photographs are stored locally in the browser, with tools for exporting and restoring personal archives.
• Offline-oriented AI: Open-weight language models can run directly in the browser on compatible hardware, rather than requiring every generation request to go through a hosted AI service.

The goal isn't to make a machine pretend it can bring someone back. It's to give people a thoughtful way to preserve the details, stories, and little things that make a memory meaningful.

Demo 🕯️

Experience The Last Light: https://the-last-light.ai.studio/

Explore the experience, discover the digital ofrenda, and try the memory-writing studio on a compatible device.

The first model download requires an internet connection. Local generation depends on browser support, available device resources, and the model being downloaded successfully.

Code 💻

GitHub repository: https://github.com/babuyasinghchauhan-eng/the_last_light

The project is built with React, TypeScript, Vite, and WebLLM, with browser-native storage and a design focused on privacy and data portability.

The repository includes the source code, project documentation, and an MIT license for the application. The model weights have their own respective licenses. Contributions, improvements, and ideas are welcome.

How I Built It

I approached this as a local-first application rather than a conventional chatbot wrapped in a beautiful interface.

The frontend uses React, TypeScript, Vite, and Tailwind CSS. The visual direction combines cinematic lighting, dark editorial layouts, candlelight, and marigold-inspired details to create an experience that feels more like entering a quiet digital sanctuary than opening another AI dashboard.

For the AI layer, I used WebLLM, which enables language-model inference in the browser using supported WebGPU execution paths. The application is designed to work with quantized open-weight models, including options from the Qwen2.5 and SmolLM2 families. Model selection and actual inference depend on the model configuration and the device's capabilities.

Instead of sending personal memories to a remote LLM endpoint, the writing studio passes the user's chosen memory and writing instructions to the locally running model. The model then generates a literary interpretation of those details.

The prompts are designed to preserve the user's supplied information, avoid inventing biographical facts as truth, and treat first-person writing as a creative device rather than a claim of communication with a deceased person.

For persistence, the application uses IndexedDB to keep memories and photographs in the browser. Export and restore functionality gives users a way to retain control over their own collection.

A few technical realities are worth acknowledging:

• The initial application and model downloads require connectivity.
• Subsequent offline use depends on assets and model files being cached and available, along with a compatible browser and sufficient device resources.
• Local inference is not equally fast on every device, and WebGPU support can vary.
• Open-weight models have their own license terms, which must be respected independently of the application's MIT license.

These constraints are part of the engineering challenge. Running AI locally is not magic; it is a trade-off between control, privacy, hardware requirements, and convenience.

Why Does Open Innovation Matter?

Because a memory is too personal to treat as just another API request.

Many AI experiences depend on sending prompts and data to a service controlled by someone else. That can be useful, but it also introduces external dependencies, usage limits, potential costs, and questions about where personal information goes.

The Last Light explores another approach.

1. Privacy should be an architectural decision. Family photographs, personal stories, and intimate memories deserve care. By keeping memory storage in the browser and using local inference, the application can reduce the need to transmit this personal information to a third-party AI provider. The intention is simple: your stories should remain yours.
2. The experience should not depend on a single AI provider. With an open-weight model and a transparent inference layer, developers can inspect the architecture, adapt the prompts, and explore compatible models. The project is not conceptually tied to a single hosted model or API. That flexibility matters for a tool whose purpose is to preserve stories over time.
3. AI should remain useful beyond a network connection. After the required resources have been downloaded and cached, a compatible local setup can support offline generation. No recurring hosted inference request is inherently necessary for each story. That makes the experience more independent of network availability and external service uptime, although it still depends on the user's hardware, browser, and locally available model files.
4. Open innovation makes experimentation accessible. I can experiment with different model sizes, adjust the writing instructions, and make the experience behave differently without redesigning the whole product around a closed API.

There are real trade-offs: local models may be slower or less capable than larger hosted models, and the first download can be substantial. But for this particular application, privacy, control, and the possibility of continued use are valuable design goals.

Open innovation is not simply about making software free. It is about giving people more control over the technology they depend on.

The Spirit of It

A favorite recipe. A familiar expression. A song that immediately brings someone to mind. A story told so many times that the family knows every word.

Sometimes, what we fear losing isn't a grand story. It's one of these little details.

That is the spirit behind The Last Light. The digital ofrenda draws inspiration from the remembrance traditions of Día de los Muertos, which honors the continuing connections people have with loved ones who have died. The intention is to approach that tradition with respect rather than reduce it to a Halloween effect.

The AI writing studio adds a different dimension: it can help someone turn a scattered memory into something they can reread, share, edit, or preserve for the next generation. The result is still a human memory, shaped by the person who shared it. The AI is a writing companion, not a replacement for the person being remembered.

And that distinction matters.

Technology changes. Services disappear. Models evolve. But the stories people choose to preserve should not have to disappear with them.

Some things disappear from the world. They don't have to disappear from our stories.

That is The Last Light: a small experiment in making AI feel a little more personal, a little more private, and a little more human. 🕯️