DEV Community: Jagannath Padhi

Afterlight: The Memory Keeper --- A Local-First AI Sanctuary for Stories & Remembrance

Jagannath Padhi — Sun, 01 Nov 2026 06:38:54 +0000

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

What I Built

Afterlight: The Memory Keeper is a privacy-first, local-first AI
memory preservation platform created individually for Hacktoberfest Week
4: Ghost in the Machine.

Afterlight helps people preserve and rediscover meaningful stories,
photographs, voice recordings, family traditions, and personal memories.
It brings together two interpretations of the challenge theme:

Ghost in the Machine: Forgotten stories and recordings can feel like voices trapped in old photographs, tapes, and folders. Afterlight uses local AI to transcribe, organize, search, and creatively reinterpret saved memories.
Día de los Muertos: The Virtual Ofrenda offers a customizable digital space to honor loved ones through photographs, remembrance messages, favorite foods, songs, flowers, traditions, and associated stories.

Afterlight is designed around a simple principle:

Your memories belong to you. Your stories should not depend on a
server you do not control.

The Problem

Family stories and personal histories are often scattered across paper
notes, old photographs, audio recordings, phones, and disconnected
folders. Finding a particular detail can be difficult, and valuable oral
histories may remain inaccessible because they have never been
transcribed or organized.

At the same time, sending intimate memories, photographs, and voice
recordings to third-party AI services can create privacy and
data-ownership concerns. Hosted AI services can also introduce recurring
usage costs and dependence on a provider's availability, pricing, and
terms.

The Solution

Afterlight brings memory preservation and AI-assisted discovery into a
local-first application:

Memory Vault: Preserve stories, photographs, dates, people, locations, tags, and personal experiences in an organized archive.
Voice of the Past: Transcribe uploaded oral-history recordings with locally running speech recognition, review the transcript, and save it with related memories.
AI Memory Companion: Ask natural-language questions about saved memories. Retrieval-augmented generation (RAG) finds relevant records and presents the supporting sources.
Virtual Ofrenda: Create a customizable Día de los Muertos-inspired remembrance altar with portraits, candles, marigold-inspired decorations, offerings, and tribute messages.
Ghost Echoes: Create atmospheric fictional stories inspired by selected memories, with a clear notice that generated stories are creative fiction---not real communications from deceased people.
Memory Timeline: Explore saved stories and events chronologically.
Privacy & Model Control Center: Inspect the local AI runtime, available models, local data controls, export options, and setup status.

The application is designed to keep personal records and AI inference on
the user's machine. Any offline claims in this submission should reflect
the exact features verified with the network disconnected.

Demo

<!-- Replace these placeholders with real links before publishing. -->

GitHub Repository: https://github.com/Jagannath357/Hacktoberfest-week4
Video Demonstration: [Insert a Loom, YouTube, or other walkthrough link]
Live Demo: Afterlight is designed for local execution. [Add a hosted demo only if one is actually available.]
DevRelay Agent Session (Optional): [Insert the real session link if saved.]

Feature Walkthrough

Feature What to demonstrate AI / technical
foundation

Memory Vault Create, edit, search, Local database and file
filter, and revisit storage
saved memories

Voice of the Past Upload an audio file, faster-whisper
transcribe it, review

the transcript, and

save it

AI Memory Companion Ask a question and Ollama, an open-weight
inspect the retrieved model, embeddings, and
source memories ChromaDB

Virtual Ofrenda Create a remembrance Local records and
profile and customize frontend presentation
its altar

Ghost Echoes Generate and save a Local LLM and
fictional story controlled prompts
inspired by selected

memories

Memory Timeline Browse memories by year Local database queries
and date

Privacy & Model Control Inspect runtime/model Ollama and local
Center status, export data, file/database storage
and review

local-storage controls

Screenshots

<!-- Add screenshots captured from the actual running application. Suggested screenshots: -->

Landing page and local-first privacy explanation.
Dashboard populated with real saved records.
Memory Vault showing a saved memory and its details.
Voice of the Past showing an actual transcript.
AI Memory Companion answer with supporting source-memory cards.
Virtual Ofrenda with a user-created remembrance profile.
Ghost Echoes showing a generated story and its fiction disclaimer.
Privacy & Model Control Center showing actual local runtime/model status.

Code

GitHub Repository: https://github.com/Jagannath357/Hacktoberfest-week4

<!-- Optional GitHub embed. Replace the URL before publishing. -->

Jagannath357 / Hacktoberfest-week4

AFTERLIGHT — THE MEMORY KEEPER

"Some stories deserve to live beyond a lifetime."

📖 Executive Summary

AFTERLIGHT is a privacy-first, locally powered AI memory preservation platform developed for the Hacktoberfest Week 4 Challenge — "Ghost in the Machine".

It unifies two poignant themes:

The Ghost in the Machine: Awakening forgotten family memories, cassette recordings, and heirloom photographs through local open-source AI retrieval and atmospheric creative storytelling.
Día de los Muertos (Day of the Dead): Honoring departed ancestors through an interactive, culturally reverent virtual altar (ofrenda) adorned with flickering candlelight physics, golden cempasúchil petals, traditional offerings, and printable tribute keepsakes.

Every AI capability in Afterlight—from speech-to-text audio transcription and dense semantic vector retrieval to conversational memory companion RAG—runs 100% locally on your own machine using open-weight models (Qwen2.5 3B, faster-whisper, ChromaDB).

Core Philosophy: "Your memories belong to you. Your stories should…

View on GitHub

Project Structure

The planned application structure separates the frontend, backend, AI
services, and local user data. Adjust this tree to match the repository
that is actually submitted.

afterlight/
├── frontend/                  # React, TypeScript, Vite, Tailwind CSS
│   └── src/
│       ├── components/         # Memory, altar, audio, story, and layout UI
│       ├── pages/              # Dashboard, Vault, Ofrenda, Companion, etc.
│       ├── services/           # Backend API clients
│       ├── hooks/
│       ├── contexts/
│       └── types/
├── backend/                   # Python, FastAPI, SQLAlchemy
│   ├── app/
│   │   ├── api/                # REST endpoints
│   │   ├── core/               # Configuration and shared utilities
│   │   ├── database/            # SQLite setup
│   │   ├── models/              # Database models
│   │   ├── schemas/             # Request/response validation
│   │   └── services/
│   │       ├── ai/              # Ollama/model adapter
│   │       ├── embeddings/      # Local embeddings and retrieval
│   │       ├── memory/          # Memory operations
│   │       ├── transcription/   # faster-whisper integration
│   │       └── storytelling/    # Grounded creative generation
│   └── tests/
├── local_data/                 # User data; excluded from Git
│   ├── database/
│   ├── photographs/
│   ├── audio/
│   ├── embeddings/
│   └── exports/
├── docs/
├── scripts/
├── .env.example
├── .gitignore
├── README.md
└── LICENSE

How I Built It

Afterlight uses a modular, local-first architecture. The frontend
communicates with a local FastAPI backend. The backend manages
persistent records, local files, retrieval, transcription, and requests
to the local model runtime.

Architecture Overview

+--------------------------------------------------------------+
|                    Afterlight Frontend                       |
|             React + TypeScript + Vite + Tailwind              |
+------------------------------+-------------------------------+
                               |
                         Local REST API
                               |
+------------------------------v-------------------------------+
|                    Python FastAPI Backend                     |
|                                                              |
|  +----------------+  +----------------+  +----------------+  |
|  | Memory Service |  | Audio Service  |  | Story Service  |  |
|  +----------------+  +----------------+  +----------------+  |
|          |                   |                   |            |
|          v                   v                   v            |
|  +----------------+  +----------------+  +----------------+  |
|  | SQLite         |  | faster-whisper |  | Ollama Adapter |  |
|  | Local Records  |  | Local Speech   |  | Local LLM      |  |
|  +----------------+  +----------------+  +----------------+  |
|          |                                       |            |
|          v                                       v            |
|  +----------------+                    +----------------+    |
|  | ChromaDB       |<-------------------| Embedding Model|    |
|  | Vector Search  |                    | Local Embedding|    |
|  +----------------+                    +----------------+    |
+--------------------------------------------------------------+
                               |
                               v
+--------------------------------------------------------------+
|                  User-Controlled Local Data                   |
|         Database / Photographs / Audio / Exports               |
+--------------------------------------------------------------+

1. Frontend & Experience

Framework: React with TypeScript and Vite.
Styling: Tailwind CSS with a dark, cinematic visual identity.
Visual direction: Midnight backgrounds, warm amber and candlelight accents, marigold-inspired details, framed photographs, and restrained atmospheric animation.
Interface: Responsive pages for the dashboard, Memory Vault, Voice of the Past, AI Memory Companion, Virtual Ofrenda, Ghost Echoes, Memory Timeline, and privacy controls.

2. Backend & Local Persistence

Backend: Python and FastAPI for local REST APIs.
Database: SQLite for structured memory records, people, photographs, recordings, transcripts, ofrendas, stories, and related metadata.
File storage: Photographs and audio are stored as local files; the database stores their metadata and local references rather than Base64 copies.
Validation: Pydantic schemas and file validation are used at API boundaries.
Data ownership: Local records can be backed up and exported by the user.

3. Open-Weight AI & Local Inference

Runtime: Ollama provides a local interface for running compatible open-weight language models.
Default model target: qwen2.5:3b (or another compatible model selected in the application).
Model flexibility: The AI service is separated behind a model adapter so compatible local models can be changed without rewriting feature logic.
AI tasks: Memory summaries, contextual question answering, categorization, remembrance-writing assistance, and fictional story generation.
No mandatory hosted LLM: The core AI design does not require OpenAI, Gemini, Claude, or another hosted LLM API.

Model availability, model licenses, and actual tested model names should
be confirmed against the implementation before publishing.

4. Local Speech Recognition

Engine: faster-whisper, using a locally available Whisper model.
Workflow: Upload audio → transcribe locally → review/edit transcript → save transcript and associate it with a memory.
Formats: Support depends on the installed FFmpeg configuration and the formats enabled by the application.
Privacy: Audio is processed locally when the local transcription pipeline and model are installed.

5. Semantic Search & Grounded Memory Companion

Embeddings: A locally installed sentence-transformers model, such as all-MiniLM-L6-v2.
Vector store: ChromaDB for semantic retrieval.
Retrieval flow: Embed the question → retrieve relevant memory chunks → load their source records → provide context to the local LLM → return an answer with source references.
Grounding: The assistant should state when saved memories do not contain enough information. It should not present unsupported model-generated details as facts.
Source visibility: Responses should link to the memory records used as context, allowing users to inspect the original material.

6. Creative Storytelling & Remembrance

Ghost Echoes: Generates original atmospheric fiction inspired by user-selected memories.
Virtual Ofrenda: Provides a customizable digital remembrance space for portraits, stories, offerings, and messages.
Ethical boundary: Generated stories are clearly labeled as fiction. The application does not claim to contact, recreate, or speak for deceased people.
Cultural respect: Ofrenda elements are customizable; the experience does not assume that every user follows the same traditions.

7. Testing & Verification

<!-- Replace this section with actual commands, results, and test counts from your final run. -->

Backend tests: [Add test command and actual result.]
Frontend checks: [Add lint/type-check/build commands and actual result.]
AI integration: [State which local model and AI workflows were tested.]
Offline verification: [List only the workflows personally tested with the network disconnected.]
Known limitations: [Document hardware, model, performance, or platform limitations.]

Why Does Open Innovation Matter?

For Afterlight, open innovation is directly connected to privacy,
ownership, accessibility, and long-term control.

Memories can include intimate family stories, personal photographs, and
recordings of people who trusted us with their words. A
memory-preservation tool should not require those materials to be sent
to a third-party AI provider.

1. Privacy & Data Sovereignty

Local inference allows supported AI operations to run on the user's own
machine. Afterlight is designed to keep its memory archive, photographs,
recordings, and local database under the user's control rather than
making a hosted AI service the default destination for personal
material.

2. Model Choice & Freedom to Experiment

A local model adapter makes it possible to test and switch between
compatible models. Developers can compare model quality, hardware
requirements, languages, and response behavior without redesigning the
entire application around one provider.

3. Offline Access & Independence

Once the application dependencies, model weights, and required assets
have been downloaded, supported local workflows can operate without an
internet connection. This reduces dependence on a hosted service being
available whenever someone wants to revisit a memory.

4. Accessibility Without Per-Request AI Fees

Local inference avoids mandatory per-request hosted LLM charges. It does
not mean the application has no costs: users still need suitable
hardware, storage, electricity, and initial downloads. However, it gives
people another way to use AI without a recurring API bill.

5. Community Adaptation & Longevity

An open implementation can be inspected, modified, extended, and adapted
by contributors. Communities can experiment with language support,
oral-history workflows, accessibility improvements, and culturally
appropriate remembrance experiences.

Honest Technical Trade-offs

Hardware: Local inference performance depends on RAM, CPU/GPU, quantization, and model size.
Storage: Model weights, audio recordings, photographs, and vector indexes require disk space.
Initial setup: Ollama, Python packages, frontend dependencies, and model assets generally need to be installed or downloaded before offline use.
Performance: CPU-only transcription and LLM inference may take longer than hosted GPU services.
Model licensing: Each model has its own license and usage conditions. Check and document the exact license of every model distributed or recommended.
Offline scope: Do not describe the entire application as offline unless every claimed workflow has been tested without network access.

What Worked Better With an Open-Based Approach?

The local-first architecture makes privacy and model choice design
properties rather than optional settings in a hosted service. It also
allows the project to keep working with locally installed models without
requiring a particular commercial AI provider's API.

My Agent Session

This project was developed individually with assistance from Google
Antigravity as an agentic coding environment.

Developer: Individual project submission.
AI coding tool: Google Antigravity.
Development work: [Describe the architecture, implementation, debugging, and testing work actually completed.]
DevRelay Session (Optional): [Insert a real DevRelay session link if one was saved.]

<!-- Do not claim a DevRelay session was recorded unless you have a real shareable link. -->

Individual Submission Note

Afterlight is submitted as an individual project for the Hacktoberfest
Open-Source AI Challenge Week 4: Ghost in the Machine.

I independently conceived and developed the project, including its
application design, implementation, integration, and documentation, with
AI coding assistance where applicable. Any external libraries, models,
frameworks, and third-party assets are credited through their respective
licenses and attributions.

Prize Categories

<!-- Only list categories that are officially available and that you are eligible to enter. Do not assume a category or prize exists. -->

Challenge: Hacktoberfest Week 4 --- Ghost in the Machine.
Submission Type: Individual.
Partner / Special Categories: [Add only verified eligible categories, if applicable.]

Closing

Afterlight explores a different kind of ghost in the machine: not a
supernatural presence, but the stories and voices that risk being
forgotten in old recordings, photographs, and disconnected archives.

By combining local open-weight AI with
memory preservation, oral-history
transcription, grounded search, creative
storytelling, and a digital
remembrance altar, Afterlight aims to make
technology a respectful
bridge between generations.

The machine may be artificial. The memories
are real.

Built individually with care, cultural respect,
and open-source AI for
Hacktoberfest 2026. 🎃🕯️🌼

Afterlight: The Memory Keeper --- A Local-First AI Sanctuary for Stories & Remembrance

Jagannath Padhi — Sat, 31 Oct 2026 15:02:21 +0000

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

What I Built

Afterlight: The Memory Keeper is a privacy-first, local-first AI
memory preservation platform created individually for Hacktoberfest Week
4: Ghost in the Machine.

Ghost in the Machine: Forgotten stories and recordings can feel like voices trapped in old photographs, tapes, and folders. Afterlight uses local AI to transcribe, organize, search, and creatively reinterpret saved memories.
Día de los Muertos: The Virtual Ofrenda offers a customizable digital space to honor loved ones through photographs, remembrance messages, favorite foods, songs, flowers, traditions, and associated stories.

Afterlight is designed around a simple principle:

Your memories belong to you. Your stories should not depend on a
server you do not control.

The Problem

The Solution

Afterlight brings memory preservation and AI-assisted discovery into a
local-first application:

Memory Vault: Preserve stories, photographs, dates, people, locations, tags, and personal experiences in an organized archive.
Voice of the Past: Transcribe uploaded oral-history recordings with locally running speech recognition, review the transcript, and save it with related memories.
AI Memory Companion: Ask natural-language questions about saved memories. Retrieval-augmented generation (RAG) finds relevant records and presents the supporting sources.
Virtual Ofrenda: Create a customizable Día de los Muertos-inspired remembrance altar with portraits, candles, marigold-inspired decorations, offerings, and tribute messages.
Ghost Echoes: Create atmospheric fictional stories inspired by selected memories, with a clear notice that generated stories are creative fiction---not real communications from deceased people.
Memory Timeline: Explore saved stories and events chronologically.
Privacy & Model Control Center: Inspect the local AI runtime, available models, local data controls, export options, and setup status.

Demo

<!-- Replace these placeholders with real links before publishing. -->

GitHub Repository: https://github.com/Jagannath357/Hacktoberfest-week4
Video Demonstration: [Insert a Loom, YouTube, or other walkthrough link]
Live Demo: Afterlight is designed for local execution. [Add a hosted demo only if one is actually available.]
DevRelay Agent Session (Optional): [Insert the real session link if saved.]

Feature Walkthrough

Feature What to demonstrate AI / technical
foundation

Memory Vault Create, edit, search, Local database and file
filter, and revisit storage
saved memories

Voice of the Past Upload an audio file, faster-whisper
transcribe it, review

the transcript, and

save it

AI Memory Companion Ask a question and Ollama, an open-weight
inspect the retrieved model, embeddings, and
source memories ChromaDB

Virtual Ofrenda Create a remembrance Local records and
profile and customize frontend presentation
its altar

Ghost Echoes Generate and save a Local LLM and
fictional story controlled prompts
inspired by selected

memories

Memory Timeline Browse memories by year Local database queries
and date

Privacy & Model Control Inspect runtime/model Ollama and local
Center status, export data, file/database storage
and review

local-storage controls

Screenshots

<!-- Add screenshots captured from the actual running application. Suggested screenshots: -->

Landing page and local-first privacy explanation.
Dashboard populated with real saved records.
Memory Vault showing a saved memory and its details.
Voice of the Past showing an actual transcript.
AI Memory Companion answer with supporting source-memory cards.
Virtual Ofrenda with a user-created remembrance profile.
Ghost Echoes showing a generated story and its fiction disclaimer.
Privacy & Model Control Center showing actual local runtime/model status.

Code

GitHub Repository: https://github.com/Jagannath357/Hacktoberfest-week4

<!-- Optional GitHub embed. Replace the URL before publishing. -->

Jagannath357 / Hacktoberfest-week4

AFTERLIGHT — THE MEMORY KEEPER

"Some stories deserve to live beyond a lifetime."

📖 Executive Summary

AFTERLIGHT is a privacy-first, locally powered AI memory preservation platform developed for the Hacktoberfest Week 4 Challenge — "Ghost in the Machine".

It unifies two poignant themes:

The Ghost in the Machine: Awakening forgotten family memories, cassette recordings, and heirloom photographs through local open-source AI retrieval and atmospheric creative storytelling.
Día de los Muertos (Day of the Dead): Honoring departed ancestors through an interactive, culturally reverent virtual altar (ofrenda) adorned with flickering candlelight physics, golden cempasúchil petals, traditional offerings, and printable tribute keepsakes.

Core Philosophy: "Your memories belong to you. Your stories should…

View on GitHub

Project Structure

The planned application structure separates the frontend, backend, AI
services, and local user data. Adjust this tree to match the repository
that is actually submitted.

afterlight/
├── frontend/                  # React, TypeScript, Vite, Tailwind CSS
│   └── src/
│       ├── components/         # Memory, altar, audio, story, and layout UI
│       ├── pages/              # Dashboard, Vault, Ofrenda, Companion, etc.
│       ├── services/           # Backend API clients
│       ├── hooks/
│       ├── contexts/
│       └── types/
├── backend/                   # Python, FastAPI, SQLAlchemy
│   ├── app/
│   │   ├── api/                # REST endpoints
│   │   ├── core/               # Configuration and shared utilities
│   │   ├── database/            # SQLite setup
│   │   ├── models/              # Database models
│   │   ├── schemas/             # Request/response validation
│   │   └── services/
│   │       ├── ai/              # Ollama/model adapter
│   │       ├── embeddings/      # Local embeddings and retrieval
│   │       ├── memory/          # Memory operations
│   │       ├── transcription/   # faster-whisper integration
│   │       └── storytelling/    # Grounded creative generation
│   └── tests/
├── local_data/                 # User data; excluded from Git
│   ├── database/
│   ├── photographs/
│   ├── audio/
│   ├── embeddings/
│   └── exports/
├── docs/
├── scripts/
├── .env.example
├── .gitignore
├── README.md
└── LICENSE

How I Built It

Architecture Overview

+--------------------------------------------------------------+
|                    Afterlight Frontend                       |
|             React + TypeScript + Vite + Tailwind              |
+------------------------------+-------------------------------+
                               |
                         Local REST API
                               |
+------------------------------v-------------------------------+
|                    Python FastAPI Backend                     |
|                                                              |
|  +----------------+  +----------------+  +----------------+  |
|  | Memory Service |  | Audio Service  |  | Story Service  |  |
|  +----------------+  +----------------+  +----------------+  |
|          |                   |                   |            |
|          v                   v                   v            |
|  +----------------+  +----------------+  +----------------+  |
|  | SQLite         |  | faster-whisper |  | Ollama Adapter |  |
|  | Local Records  |  | Local Speech   |  | Local LLM      |  |
|  +----------------+  +----------------+  +----------------+  |
|          |                                       |            |
|          v                                       v            |
|  +----------------+                    +----------------+    |
|  | ChromaDB       |<-------------------| Embedding Model|    |
|  | Vector Search  |                    | Local Embedding|    |
|  +----------------+                    +----------------+    |
+--------------------------------------------------------------+
                               |
                               v
+--------------------------------------------------------------+
|                  User-Controlled Local Data                   |
|         Database / Photographs / Audio / Exports               |
+--------------------------------------------------------------+

1. Frontend & Experience

Framework: React with TypeScript and Vite.
Styling: Tailwind CSS with a dark, cinematic visual identity.
Visual direction: Midnight backgrounds, warm amber and candlelight accents, marigold-inspired details, framed photographs, and restrained atmospheric animation.
Interface: Responsive pages for the dashboard, Memory Vault, Voice of the Past, AI Memory Companion, Virtual Ofrenda, Ghost Echoes, Memory Timeline, and privacy controls.

2. Backend & Local Persistence

Backend: Python and FastAPI for local REST APIs.
Database: SQLite for structured memory records, people, photographs, recordings, transcripts, ofrendas, stories, and related metadata.
File storage: Photographs and audio are stored as local files; the database stores their metadata and local references rather than Base64 copies.
Validation: Pydantic schemas and file validation are used at API boundaries.
Data ownership: Local records can be backed up and exported by the user.

3. Open-Weight AI & Local Inference

Runtime: Ollama provides a local interface for running compatible open-weight language models.
Default model target: qwen2.5:3b (or another compatible model selected in the application).
Model flexibility: The AI service is separated behind a model adapter so compatible local models can be changed without rewriting feature logic.
AI tasks: Memory summaries, contextual question answering, categorization, remembrance-writing assistance, and fictional story generation.
No mandatory hosted LLM: The core AI design does not require OpenAI, Gemini, Claude, or another hosted LLM API.

Model availability, model licenses, and actual tested model names should
be confirmed against the implementation before publishing.

4. Local Speech Recognition

Engine: faster-whisper, using a locally available Whisper model.
Workflow: Upload audio → transcribe locally → review/edit transcript → save transcript and associate it with a memory.
Formats: Support depends on the installed FFmpeg configuration and the formats enabled by the application.
Privacy: Audio is processed locally when the local transcription pipeline and model are installed.

5. Semantic Search & Grounded Memory Companion

Embeddings: A locally installed sentence-transformers model, such as all-MiniLM-L6-v2.
Vector store: ChromaDB for semantic retrieval.
Retrieval flow: Embed the question → retrieve relevant memory chunks → load their source records → provide context to the local LLM → return an answer with source references.
Grounding: The assistant should state when saved memories do not contain enough information. It should not present unsupported model-generated details as facts.
Source visibility: Responses should link to the memory records used as context, allowing users to inspect the original material.

6. Creative Storytelling & Remembrance

Ghost Echoes: Generates original atmospheric fiction inspired by user-selected memories.
Virtual Ofrenda: Provides a customizable digital remembrance space for portraits, stories, offerings, and messages.
Ethical boundary: Generated stories are clearly labeled as fiction. The application does not claim to contact, recreate, or speak for deceased people.
Cultural respect: Ofrenda elements are customizable; the experience does not assume that every user follows the same traditions.

7. Testing & Verification

<!-- Replace this section with actual commands, results, and test counts from your final run. -->

Backend tests: [Add test command and actual result.]
Frontend checks: [Add lint/type-check/build commands and actual result.]
AI integration: [State which local model and AI workflows were tested.]
Offline verification: [List only the workflows personally tested with the network disconnected.]
Known limitations: [Document hardware, model, performance, or platform limitations.]

Why Does Open Innovation Matter?

For Afterlight, open innovation is directly connected to privacy,
ownership, accessibility, and long-term control.

1. Privacy & Data Sovereignty

2. Model Choice & Freedom to Experiment

3. Offline Access & Independence

4. Accessibility Without Per-Request AI Fees

5. Community Adaptation & Longevity

Honest Technical Trade-offs

Hardware: Local inference performance depends on RAM, CPU/GPU, quantization, and model size.
Storage: Model weights, audio recordings, photographs, and vector indexes require disk space.
Initial setup: Ollama, Python packages, frontend dependencies, and model assets generally need to be installed or downloaded before offline use.
Performance: CPU-only transcription and LLM inference may take longer than hosted GPU services.
Model licensing: Each model has its own license and usage conditions. Check and document the exact license of every model distributed or recommended.
Offline scope: Do not describe the entire application as offline unless every claimed workflow has been tested without network access.

What Worked Better With an Open-Based Approach?

My Agent Session

This project was developed individually with assistance from Google
Antigravity as an agentic coding environment.

Developer: Individual project submission.
AI coding tool: Google Antigravity.
Development work: [Describe the architecture, implementation, debugging, and testing work actually completed.]
DevRelay Session (Optional): [Insert a real DevRelay session link if one was saved.]

<!-- Do not claim a DevRelay session was recorded unless you have a real shareable link. -->

Individual Submission Note

Afterlight is submitted as an individual project for the Hacktoberfest
Open-Source AI Challenge Week 4: Ghost in the Machine.

Prize Categories

<!-- Only list categories that are officially available and that you are eligible to enter. Do not assume a category or prize exists. -->

Challenge: Hacktoberfest Week 4 --- Ghost in the Machine.
Submission Type: Individual.
Partner / Special Categories: [Add only verified eligible categories, if applicable.]

Closing

By combining local open-weight AI with memory preservation, oral-history
transcription, grounded search, creative storytelling, and a digital
remembrance altar, Afterlight aims to make technology a respectful
bridge between generations.

The machine may be artificial. The memories are real.

Built individually with care, cultural respect, and open-source AI for
Hacktoberfest 2026. 🎃 🕯️ 🌼

SoloBooks AI — Your business finances. Organized privately.

Jagannath Padhi — Sun, 18 Oct 2026 16:11:07 +0000

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

What I Built

SoloBooks AI is a privacy-first, local-first financial document assistant designed specifically for freelancers, independent software developers, creative studios, tutors, and small business owners.

The Problem

Solo operators are routinely bombarded with receipts, software subscription invoices, contractor timesheets, client billing PDFs, and dining slips in fragmented formats. Traditional accounting platforms pose two major drawbacks for independent professionals:

Privacy & Data Security Risks: Commercial tools mandate uploading private bank invoices, tax IDs, and confidential client rates to third-party cloud servers and proprietary AI APIs.
Excessive Subscription Overhead: Monolithic accounting suites cost between $30 and $60 per month for complex enterprise features that solo entrepreneurs rarely need.

The Solution

SoloBooks AI replaces manual spreadsheet entry with local open-weight intelligence while guaranteeing that financial documents remain quarantined on the user's personal hardware:

Local Document Ingestion: Processes PDF invoices, PNG receipts, and JPEG photos through on-device text parsing and local Tesseract.js WebAssembly OCR.
Local Open-Weight Extraction: Integrates with local Ollama to extract candidate financial fields (merchant, date, subtotal, tax, total amount, category, and payment status).
Human-in-the-Loop Verification: AI extractions are strictly treated as draft proposals. Users review, edit, and confirm values before committing them to SQLite.
Deterministic Math: Financial amounts are stored in integer minor units (paise/cents) to eliminate floating-point drift and prevent hallucinated numbers.
Grounded AI Financial Assistant: Answers natural-language questions (e.g., "How much did I spend on software this month?") by executing deterministic SQL queries and presenting verified supporting transaction cards alongside narrative summaries.
Data Sovereignty & Direct Exports: Records and files stay in local ./data/ directories, with one-click RFC 4180 CSV and structured JSON exports.

Demo

Video Demonstration:
Live Demo (Optional):

Verified Local Walkthrough Screenshots

Code

GitHub Repository:

SoloBooks AI is released under the permissive MIT License.

How I Built It

SoloBooks AI is built on a modern, decoupled architecture prioritizing local persistence, deterministic calculations, and modular AI inference.

+-----------------------------------------------------------------------------------+
|                              SoloBooks AI Client                                  |
|   Next.js 16 App Router (React 19, TypeScript Strict, Tailwind CSS v4, Recharts)  |
+-----------------------------------------------------------------------------------+
        |                                       |
        | Server Actions / Local API Routes     | Client State & Dark/Light Theme
        v                                       v
+-----------------------------------------------------------------------------------+
|                           Local Application Services Layer                        |
|                                                                                   |
|  +-------------------------+  +-------------------------+  +--------------------+ |
|  |     Document Service    |  |       OCR & Parser      |  |   Model Adapter    | |
|  | (Validation, Storage)   |  | (pdf-parse, Tesseract)  |  | (Ollama Connector) | |
|  +-------------------------+  +-------------------------+  +--------------------+ |
|               |                            |                          |           |
|               v                            v                          v           |
|  +------------------------------------------------------------------------------+ |
|  |                         Deterministic Accounting Engine                      | |
|  |       (Minor-unit integer math, aggregation, date filters, deduplication)     | |
|  +------------------------------------------------------------------------------+ |
+-----------------------------------------------------------------------------------+
        |                                                         |
        v                                                         v
+----------------------------------+          +-------------------------------------+
|        Local SQLite Database     |          |       Local Ollama Daemon           |
|     (via @libsql/client engine)  |          |      (http://127.0.0.1:11434)       |
|    Path: ./data/solobooks.db     |          |   Models: llama3:latest, qwen2.5:3b |
+----------------------------------+          +-------------------------------------+

1. Frontend & Visual Design

Framework: Next.js 16 (App Router) with React 19 and TypeScript in strict mode.
Styling: Tailwind CSS v4 customized with a dedicated forest green and deep emerald design system (#059669 / #10b981), soft-neutral light mode surfaces, and deep charcoal dark mode surfaces.
Charts: Recharts for client-side monthly cash flow bar charts and categorical expense distribution pie charts.
Icons: Lucide React for consistent financial and interface iconography.

2. Local Database & Persistence

Engine: SQLite managed via @libsql/client, providing crash-proof, zero-native-build embedded database operations across platforms.
Data Integrity: All currency values are stored as integer minor units (e.g., 4500000 paise for ₹45,000.00 or 4999 cents for $49.99). This completely eliminates floating-point precision drift.
File Quarantine: Uploaded receipts and invoices are validated (15 MB limit, whitelist of MIME types, path traversal stripping) and saved to ./data/documents/ using random UUIDs. Only relative storage paths are tracked in the database.

3. Document Processing & Local OCR

Tesseract.js v7: Pure JavaScript and WebAssembly OCR engine for scanned receipts and photos. Runs in a dedicated background worker without needing external C++ system binaries.
PDF-Parse: Extracts native text streams from digital invoices and e-receipts without OCR latency.

4. Local Open-Weight AI & Structured Validation

Ollama Local API: Connects via http://127.0.0.1:11434 to execute inference entirely on-device.
Verified Models:
- llama3:latest (8.03B parameters, Meta Llama 3 Community License) — Verified locally.
- qwen2.5:3b (3.09B parameters, Apache 2.0 Open-Source License) — Supported lightweight model for 8GB RAM laptops.
Schema Validation with Zod: Extraction prompts enforce format: "json", and raw responses are validated through a strict ExtractedLlmSchema. Missing fields are preserved as null rather than allowing the model to hallucinate dates or invoice numbers.
Prompt Injection Defense: Document text is passed in delimited <document_text> blocks with explicit system instructions to ignore prompt injection attempts embedded inside invoices.
Replaceable Model Adapter: AI communication is decoupled behind a generic ModelAdapter interface (src/lib/ai/adapter.ts), enabling seamless model swapping and automated mocking in tests.

5. Automated Testing

Verified test suite running on Vitest (npm test): 17 passed out of 17 tests covering minor-unit arithmetic, document security, schema validation, duplicate detection, invoice state transitions, and real Ollama connectivity.

Why Does Open Innovation Matter?

Commercial AI platforms have democratized language capabilities, but sending proprietary financial records, client names, invoice totals, and tax documents to remote APIs introduces severe compliance, confidentiality, and financial liabilities for independent business operators.

Key Benefits of Open Innovation in Small-Business AI:

Absolute Data Sovereignty: When a model runs locally, your client lists, hourly rates, and tax deductions never leave your device.
Zero Marginal Inference Cost: Once weights are downloaded, analyzing 10 receipts or 10,000 receipts costs exactly $0.00 in API tokens.
Freedom from Vendor Lock-In: With open-weight models (like Qwen 2.5 under Apache 2.0), developers and users are not vulnerable to arbitrary pricing hikes, deprecation notices, or sudden API terms changes.

Honest Technical Trade-offs & Limitations:

Local Storage Overhead: Downloading model weights requires between ~1.9 GB (for 3B models) and ~4.7 GB (for 8B models) of disk space.
Hardware Requirements: Smooth inference requires at least 8 GB of RAM for 3B parameter models and 16 GB of RAM (or dedicated VRAM) for 8B models.
Processing Time: On pure CPU hardware, local OCR and inference may take 5 to 15 seconds per document, compared to near-instant results on GPU-accelerated rigs.
Offline vs. Local: While model inference and database operations run 100% offline once setup is complete, initial setup requires downloading Ollama and pulling model weights while connected to the internet.
Verified Behavior:  I personally verified that with the network disconnected, SoloBooks AI continues to serve the full dashboard, process local PDF text, execute SQLite queries, calculate deterministic totals, and export RFC 4180 CSV files.

Business Model: Who Might Pay for It?

SoloBooks AI is conceived as a sustainable side hustle aimed at solo operators who want professional recordkeeping without enterprise SaaS subscriptions.

Current Implementation vs. Commercial Roadmap

Free Core (Currently Implemented & Open-Source):
- Unlimited local document OCR and PDF extraction.
- Local Ollama model integration and schema validation.
- Expense and invoice tracking with status transitions.
- Grounded AI Financial Assistant.
- RFC 4180 CSV and JSON data exports.
Proposed Pro Tier (Planned Commercial Feature Concept):
- Automated Bank Statement CSV Mapping: Intelligent schema mapping for diverse credit card and bank export formats.
- Bulk Queue Processing: Drag-and-drop batch import of up to 50 documents simultaneously.
- Encrypted Local Backups: One-click password-encrypted snapshot archives for tax audit preparation.
- Native Desktop Packaging: Tauri-based single-binary executable for zero-terminal installation.
- Target Pricing Concept: Proposed at a modest ₹499/month ($6/month) one-time or subscription license.

(Note: In accordance with challenge rules, payment processing and subscriptions are strictly proposals and have not been falsely implemented.)

My First User

Tester Profile:
Workflow Tested:
Actual Feedback Received:
Willingness to Pay:

My Agent Session

Agent Framework / Tooling: Built with Google Antigravity Advanced Agentic Coding pairing on architecture, database schema, local AI adapter, and Vitest test suite.
Session Reference:

Prize Categories

Primary Category: Hacktoberfest Week 2: Side Hustle
Applicable Partner Categories:

Individual Submission Note

This project was conceived, architected, and built individually by me for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle. All source code, database schemas, local model adapters, and UI components were developed without uncredited external collaborators.

Closing

SoloBooks AI demonstrates that local open-weight AI is not merely an alternative to cloud APIs—it is the foundational technology that makes privacy-first, zero-marginal-cost software a viable and sustainable side hustle for the next generation of independent creators.

TerraQuest AI: The Open-Weight AI Companion Built to Get You Off Screens and Into Nature

Jagannath Padhi — Sun, 11 Oct 2026 18:41:42 +0000

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

What I Built

Modern humans spend over 7 hours a day staring into glowing screens. This chronic screen exposure fuels digital fatigue, fragmented attention, and sensory deprivation. While many of us genuinely want to spend more time outdoors, turning that intention into reality is often blocked by subtle cognitive friction:

"Where should I go? What should I do? I only have 15 minutes between meetings, so why bother?"

Most AI applications worsen this problem: they are conversational chatbots engineered to maximize on-screen engagement, encouraging users to stay seated and keep typing.

TerraQuest AI turns this paradigm upside down.

Core Product Principle:

"AI creates the plan. The user experiences the physical world."

TerraQuest AI is a personal outdoor adventure companion powered by open-weight AI (Google's Gemma instruction architecture). In less than 10 seconds, it converts your available schedule (10 to 120 minutes), energy level, environmental setting, group type, and mobility needs into an actionable, real-life Outdoor Mission Card.

How It Gets People Off the Screen and Into Nature

Time-Bounded Precision: Generates structured timelines whose steps sum accurately to your available time (e.g., a 15-minute Green Reset, a 30-minute detective walk, or a 45-minute family nature scavenger safari).
Action Over Scrolling: It produces a concise, practical checklist—not a chat thread—ready to be put away before you step out the door.
Screen-Free Challenges: Every mission issues an explicit commitment to keep smartphones pocketed on silent, set to airplane mode, or left indoors.
Distraction-Free Mission Mode (/adventure/[id]): An outdoor-optimized interface with oversized high-contrast typography readable in bright sunlight, an activity timer, and step progression.
Private Nature Reflection Journal (/journal): After returning indoors, users capture tactile, auditory, and visual observations and record state shifts (how they felt before vs. after). Data remains 100% private in local browser storage and can be exported to CSV or JSON.

Who Is It For?

Screen-Fatigued Remote Workers: Seeking a quick 10–15 minute reset to reduce eye strain and lower cortisol levels.
Urban & Suburban Explorers: Discovering hidden biodiversity (micro-canopy lichens, tree heritage, bird flight patterns) right on their neighborhood streets.
Balcony & Container Gardeners: Engaging hands-on with living soil, moisture gradients, and root aeration in small spaces.
Mindful Observers & Photographers: Practicing observation of natural geometries without phone filters.
Families & Small Groups: Collaborative sensory quests that engage children and companions in the physical world.

Demo

Local Running App: Accessible at http://localhost:3000
Cover Art & Visuals: public/cover.jpg (included in repository)

To run the live interactive demo locally:

git clone https://github.com/Jagannath357/Hacktoberfest-week1.git
cd Hacktoberfest-Week1
npm install
npm run dev

Visit http://localhost:3000

Interface Preview

Quick-Start Planner: Instant time pills (10, 15, 30, 60, 120 min), category selectors, and energy filters.
Distraction-Free Mission Mode: Clean outdoor player with Screen-Free Mode toggle and completion confetti.
Curated Mission Library: Ready-to-go activities filterable by difficulty and category without external network calls.
Personal Dashboard: Calculates real outdoor minutes and completed activities.

(Tip: You can attach the included generated cover image from public/cover.jpg as your article header!)

Code

The entire codebase is open-source under the MIT License on GitHub:

Jagannath357 / Hacktoberfest-week1

🌲 TerraQuest AI

"Less scrolling. More exploring."
An open-weight AI outdoor adventure companion built for Hacktoberfest 2026 Week 1: Touch Grass.

Quick Start • Core Concept • Features • Architecture • Open-Weight AI • Docs • License

📖 The Problem & Vision

Modern humans spend over 7 hours a day staring into backlit displays. This chronic screen exposure fuels digital fatigue, shortened attention spans, and sensory deprivation. While many intend to spend more time outdoors, turning that intention into reality is blocked by friction: Where do I go? What should I do? I only have 15 minutes.

Most AI tools worsen this issue: they are conversational chatbots designed to maximize on-screen session duration.

TerraQuest AI inverts this paradigm.

Core Product Principle:
"AI creates the plan. The user experiences the world."

TerraQuest AI takes your available time (10 to 120 minutes), energy level, environmental setting, group dynamic, and accessibility preferences, and…

View on GitHub

Repository: https://github.com/Jagannath357/Hacktoberfest-week1
Tech Stack: Next.js 16 (App Router), React 19, TypeScript (strict mode), Tailwind CSS, @google/genai SDK, Zod, and Vitest.

How I Built It

1. Open-Weight AI Integration: Gemma Instruction Models

The project is built around Google's Gemma open-weight instruction models (gemma-2-9b-it) using the official @google/genai (v2.28) unified SDK.

To protect the user experience from conversational drift and hallucinations, TerraQuest uses a structured system prompt that enforces strict real-world principles:

Grounded Realism: Never invent current weather, business opening hours, trail conditions, or local events.
Location Boundaries: Recommends general setting types (e.g., "community park, tree-lined street") rather than fabricating proprietary coordinates.
Outdoor Safety & Leave No Trace: Explicitly forbids recommending disturbing wildlife, entering restricted areas, approaching dangerous animals, or consuming unidentified wild plants.
Structured JSON Schema: The model returns valid JSON strictly conforming to AdventureMissionSchema.

2. Provider Adapter Architecture

The backend uses a decoupled provider adapter pattern:

export interface AIProvider {
  name: string;
  generateAdventure(input: AdventureRequestInput): Promise<GenerationResult>;
}

GoogleAIProvider: Directly queries the configured Gemma open-weight instruction model via Google AI Studio.
CuratedFallbackProvider: A deterministic local activity engine that proportionally scales step durations and adapts safety notes without requiring an API key or network connection.

3. Resilience & Rate-Limit Strategy

If the remote API encounters an HTTP 429 rate limit, quota exhaustion, network disruption, or an invalid key:

TerraQuest automatically routes through the curated fallback engine.
Every card displays an honest Source Disclosure Badge (Gemma Open-Weight vs Curated Engine). The application never fails and never misrepresents fallback data as live AI output.

4. System Architecture Flow

User (Browser) 
  ──> Next.js App Router Client (/create)
  ──> POST /api/adventures/generate (Zod Validated, Rate Limited: 20 req/min)
  ──> Provider Adapter (Google Gemma / Curated Fallback)
  ──> Validated Mission Card
  ──> Distraction-Free Mode (/adventure/:id)
  ──> User Locks Device & Explores Outdoors
  ──> Private Nature Reflection Journal (/journal in localStorage)

5. Automated Verification & Testing

13 automated tests via Vitest verifying input validation, duration proportionality, and curated library integrity (npm test — 100% pass rate).
Strict TypeScript: Checked with zero errors (npx tsc --noEmit).
Production Build: Prerendered with Next.js Turbopack (npm run build).

Why Does Open Innovation Matter?

Open-source and open-weight AI are foundational to this project for several critical reasons:

Freedom From Closed-Model Lock-In:

Proprietary closed-API models can change pricing, alter system prompts, or deprecate endpoints overnight. Because Gemma's model weights and architecture are published openly under the Gemma Terms of Use, developers have long-term predictability. The provider adapter in TerraQuest can easily be retargeted to run on self-hosted Ollama or vLLM instances without changing a single line of business logic.
Algorithmic Transparency & Safety:

When building software that guides people in the physical outdoors, safety and predictability are paramount. Open architectures allow developers to inspect model cards, evaluate safety benchmarks, and test behavior openly rather than trusting a corporate black box.
The Path to True Offline Edge Inference:

While this MVP uses Google AI Studio endpoints for fast evaluation, the long-term goal of an outdoor app is zero-connectivity field execution. Because Gemma has lightweight open-weight variants (such as Gemma 2B), future iterations of TerraQuest AI can compile the model directly to on-device WebGPU (via Transformers.js or ONNX Runtime Web). You can truly be in the deep backcountry with no cell reception and still generate a mindful nature expedition.

My Agent Session

This project was architected, implemented, tested, and documented in pair programming sessions using Google DeepMind's Antigravity agentic environment. The agent assisted in scaffold generation, Zod schema validation, Vitest test authoring, responsive Tailwind layout creation, Next.js 16 partial prerendering compliance, and end-to-end browser verification.

Prize Categories

Touch Grass (Week 1 Theme): Primary challenge submission directly designed to minimize screen addiction and guide humans into the natural world.
Open-Weight AI Innovation: Built on Google's Gemma open-weight instruction models with provider-agnostic architecture.

Team Submissions

Individual submission by Jagannath (@jagannath357).

Less scrolling. More exploring. Step outside, breathe deeply, and touch grass!