DEV Community: Hardik Agarwal

AFTERLIGHT — Memories Never Die 🕯️

Hardik Agarwal — Sat, 31 Oct 2026 16:35:51 +0000

AFTERLIGHT — Memories Never Die 🕯️

What if the stories we never want to forget could live on, without depending on the cloud?

What I Built

For this week's Ghost in the Machine challenge, I built AFTERLIGHT, an offline-first, AI-powered digital memory archive inspired by Halloween and Día de los Muertos.

The idea is simple: our memories are some of the most personal things we own, so why should preserving them require uploading them to someone else's servers?

AFTERLIGHT provides a private space where users can preserve photographs, personal stories, important moments, and little details about people they want to remember.

It includes:

Memory Vault: Save personal stories, photographs, dates, and memorable moments.

AI Remembrance Writer: Transform saved memories into heartfelt letters, poems, captions, and short stories.

Memory Companion: Ask questions about your saved memories and get answers grounded in the information you've preserved.

Digital Ofrenda: A Día de los Muertos-inspired interface featuring warm candlelight, marigolds, and a peaceful memorial atmosphere.

Private Memory Storage: Your memories and photographs remain on your own device.

AFTERLIGHT isn't about pretending to bring someone back. It's about making sure the stories they left behind are never forgotten.

The best way to experience AFTERLIGHT is to add a few memories, generate a remembrance letter, and ask the Memory Companion a question about them.

You can also disconnect from the internet after the initial setup and experience local AI generation.

Code

GitHub Repository: https://github.com/MrHardik/afterlight

The project is open-source, and contributions are welcome!

How I Built It

I wanted the AI to be more than just an API integration. The open-source model needed to be at the core of the application.

Here's the technology stack:

Ollama: Runs the language model locally.

Qwen 2.5 (3B): Powers remembrance writing and memory-based conversations.

Python + Flask: Handles the backend and API endpoints.

HTML, CSS, JavaScript: Powers the frontend and interactive experience.

JSON + Local File Storage: Stores memories and uploaded photographs directly on the device.

When a user requests a remembrance letter, the application retrieves their selected memories and sends that context to the locally running Qwen model through Ollama.

The Memory Companion follows the same approach, answering questions using only the selected memories instead of inventing personal details.

Once the model is downloaded and installed, inference works without an internet connection.

Why Does Open Innovation Matter?

This is probably the most important part of AFTERLIGHT.

Personal memories deserve privacy.

Using a closed, cloud-based AI API would mean sending deeply personal stories and potentially sensitive photographs to an external service.

With an open-weight model running locally:

Privacy: Personal memories never need to leave the user's device.

Offline access: AI generation works without an active internet connection after setup.

Freedom: Models can be replaced, experimented with, and customized.

Independence: The application isn't dependent on a third-party AI service, its pricing, or its continued availability.

Accessibility: There are no per-request cloud AI API charges.

Open innovation made it possible to build something personal without compromising ownership of the data.

I believe the technology we use to preserve our memories should give us control over those memories, not take that control away.

The Spirit of It

Halloween is usually associated with ghosts, darkness, and things we cannot explain.

Día de los Muertos, however, reminds us that remembering someone is another way of keeping them close.

That inspired the name AFTERLIGHT.

Even after someone is gone, the light they left behind continues through their stories, photographs, words, and the memories we carry.

Technology cannot replace those people. But perhaps it can help us preserve the little things we might otherwise forget.

Some things fade with time. Their stories shouldn't have to.

Built with ❤️ using open-source technology.

AFTERLIGHT — Memories Never Die.

LazyNotes: Study Smarter with Local AI, Not Cloud APIs

Hardik Agarwal — Thu, 22 Oct 2026 20:03:25 +0000

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

What I Built

Meet LazyNotes - a local-first AI study assistant that helps students turn lengthy study materials into concise, revision-ready notes.

Students often spend hours reading lengthy PDFs, identifying important concepts, writing summaries, and preparing revision questions. LazyNotes aims to simplify that workflow by letting students upload their study materials and generate structured learning resources using AI running locally on their own machine.

With LazyNotes, students can work toward generating:

Smart summaries - understand lengthy study materials faster.
Key concepts - identify the most important topics to revise.
Definitions - collect important terms in one place.
Revision questions - turn study material into active-recall practice.
Downloadable notes - keep generated study resources for later revision.

The goal is simple: spend less time organizing notes and more time actually learning.

Demo

Live demo: Running locally on my machine; a public deployment or video demo is not available yet.

The project uses a local backend and an Ollama-hosted model, so the complete experience is intended to run on the user's computer.

Code

GitHub Repository: MrHardik/LazyNotes

Explore the source code, follow the development, and contribute ideas or improvements. Contributions that improve the interface, document processing, AI-generated notes, or documentation are welcome.

How I Built It

LazyNotes is built around the idea that useful AI study tools shouldn't require every document to be sent to a third-party cloud API.

Tech stack

React + Vite - frontend and user interface.
Python + FastAPI - backend API.
Ollama - runs the AI model locally.
Qwen 2.5 3B - the intended lightweight open-weight language model.
PyMuPDF - extracts text from PDF documents.
Requests - communicates with Ollama's local API.

How it works

A student uploads a PDF or text file.
The FastAPI backend extracts the document's text.
The backend sends the relevant text to the locally running model through Ollama.
The model generates structured study material.
The frontend presents the results for review and revision.

The application is designed to avoid relying on paid, cloud-hosted LLM APIs for inference. This makes local experimentation more accessible and gives users greater control over their study documents.

Why Does Open Innovation Matter?

Open innovation made the central idea behind LazyNotes possible: building an AI-powered learning tool without depending on a proprietary inference API.

Open-weight models and tools such as Ollama let developers experiment with AI on personal hardware. Frameworks such as React and FastAPI make it practical to connect that local intelligence to a usable application.

This matters especially for students. Not everyone can afford recurring API costs, and study materials may contain personal notes, assignments, or other documents users would prefer to keep on their own devices.

A local-first approach can offer three important advantages:

Accessibility: no per-request cloud inference bill.
Privacy and control: documents can be processed locally instead of being sent to an external AI provider, provided the application is configured to keep processing local.
Experimentation: developers can inspect, modify, and improve the application and choose the model that suits their hardware.

Open innovation isn't just about making technology available. It's about giving more people the ability to build on it.

My Agent Session

I used AI-assisted development to help build and refine the project, while connecting the frontend, backend, document-processing workflow, and local model.

Agent session recording: not linked yet.

The Lazy Payoff

The biggest potential payoff is reducing the repetitive work between opening a textbook PDF and getting ready to revise.

Instead of manually extracting definitions, outlining chapters, and drafting practice questions, a student can use generated notes as a starting point and spend more time checking understanding, solving problems, and revising.

I still need to measure the time saved across real study sessions, so I won't claim a specific percentage or number of hours yet. The aim is to make the first step of revision faster without removing the student's role in understanding and verifying the material.

Prize Categories

Open-Source AI: LazyNotes is designed around an open-weight model running locally through Ollama.

I'll finalize the applicable partner categories according to the official challenge rules before submitting.

LazyNotes is built on a simple belief: AI should help students learn more effectively without making useful tools expensive or complicated to access.

Less time formatting notes. More time understanding concepts.

If you're interested in local AI, open-source development, or tools that make student life easier, check out the repository and share your feedback!

hi

Hardik Agarwal — Thu, 22 Oct 2026 14:45:27 +0000