DEV Community: Vedant Shukla

Memory Lantern

Vedant Shukla — Fri, 30 Oct 2026 07:19:35 +0000

🏮 Memory Lantern: Keeping Family Stories Alive with Local AI

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

What I Built

I built Memory Lantern, an AI-powered family memory archive inspired by the Día de los Muertos theme.

We all have memories that we never want to forget. Sometimes, a small story about our grandparents, a childhood moment, or a family celebration means more than any photograph.

But these stories often remain scattered in notebooks, messages, or simply in our minds.

Memory Lantern is my attempt to create a digital space where people can preserve those moments.

With Memory Lantern, users can:

Save personal and family memories with titles, dates, names, and categories.
Organize and search their saved stories.
Use AI to turn simple notes into meaningful stories.
Ask questions about their saved memories using an AI assistant.
Keep their memories stored locally in their browser.

The main idea is simple: Technology should not only help us remember information; it should also help us preserve the moments that make us who we are.

Demo

🔗 Live Demo: https://vedantshukla-cracker.github.io/Memory-Lantern/

Code

💻 GitHub Repository: https://github.com/vedantshukla-cracker/Memory-Lantern.git

The project currently uses three main files:

index.html – Website structure.
style.css – Design and responsive layout.
script.js – Application functionality, memory storage, search, and AI integration.

How I Built It

I wanted to build something simple enough to understand as a beginner but meaningful enough to solve a real problem.

I used:

HTML for the website structure.
CSS for styling and responsive design.
JavaScript for memory management and application logic.
Local Storage to save memories in the browser.
Gemma 3 1B as the open-weight AI model.
Ollama to run the model locally on my computer.

The most interesting part is the AI integration.

Instead of depending on a paid cloud AI API, I connected the application to a locally running Gemma model through Ollama.

There are two main AI features:

1. AI Story Polishing

Users can write a simple memory in their own words. Gemma helps improve the language and makes the story more expressive while keeping the original meaning.

2. AI Memory Assistant

Users can ask questions about their saved family stories. The application provides the saved memory context to Gemma, which generates answers based on the available information.

The project uses Ollama's local API to communicate with the model. No separate cloud AI service is required by the current implementation.

Why Does Open Innovation Matter?

For a project like Memory Lantern, privacy is especially important.

Family stories can contain personal details, names, and meaningful experiences. I didn't want the basic experience to depend on sending this information to an external AI service.

Using an open-weight model with local inference gave me more control over how the AI works and where the data is processed.

It also provides some important advantages:

Privacy: Memory content and AI requests stay on the local machine in this implementation.
Offline AI: After downloading the model, AI inference can run without an internet connection.
Accessibility: Users don't need a paid cloud AI subscription or API key.
Flexibility: The model and its configuration can be changed as the project develops.
Learning: Running an AI model locally helped me understand how frontend applications communicate with AI systems.

Open innovation makes AI development more accessible to students and independent developers like me. It gives us an opportunity to experiment, learn, and build useful applications without depending entirely on closed platforms.

My Agent Session

I haven't recorded a DevRelay session for this project yet.

The Spirit of It

While building Memory Lantern, I kept thinking about one thing:

What happens to the little stories that our grandparents tell us? What happens to the memories of family celebrations, childhood adventures, and the people who made our lives special?

Photographs can preserve faces, but stories preserve feelings.

I wanted to build something that could help people keep those stories alive and pass them on to future generations.

Memory Lantern is not just about storing text. It is about making sure that meaningful moments don't get lost with time.

Because people may leave, photographs may fade, but the memories we preserve can continue telling their stories. ❤️

Prize Categories

Best Use of Gemma – Using Google's Gemma 3 1B open-weight model through Ollama for AI-powered story polishing and memory-based conversations.

I am also submitting Memory Lantern for the overall Hacktoberfest Open-Source AI Challenge.

Built with ❤️ and a little help from AI.

devchallenge #hf26challenge #hacktoberfest #opensourceai #Gemma #Ollama #JavaScript #WebDevelopment #AIProjects

HabitForge AI

Vedant Shukla — Sat, 24 Oct 2026 07:14:36 +0000

HabitForge AI: Building Better Habits, One Small Step at a Time 🤖

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

What I Built

I built HabitForge AI, a habit-building application designed to help people develop consistent routines through small, manageable daily actions.

Many people start new habits with motivation but struggle to maintain them over time. Whether it's studying, exercising, reading, or learning to code, consistency is often more difficult than getting started.

HabitForge AI focuses on making this process simpler. Instead of expecting users to change everything overnight, it encourages them to take small steps, track their progress, and build better routines gradually.

The project uses a behavioral-science-inspired approach to habit formation, with an offline-first design that allows its core functionality to work without depending on a cloud AI service.

The idea behind it is simple: you don't need to be perfect every day; you need to keep showing up.

Demo

🚀 Live Demo: https://vedantshukla-cracker.github.io/HabitForge-AI/

The demo will show how users can interact with HabitForge AI and explore its habit-building features.

Code

💻 GitHub Repository: https://github.com/vedantshukla-cracker/HabitForge-AI.git

The project source code, setup instructions, and implementation details are available in the repository.

How I Built It

I built HabitForge AI with the goal of exploring how AI-inspired functionality can support everyday productivity without making users completely dependent on external services.

The project follows an offline-first approach, with an optional integration for live AI responses.

Here are the main ideas behind the implementation:

Offline-first functionality: The core habit-building experience is designed to work locally.
Behavioral-science-inspired logic: The application focuses on consistency, manageable goals, and gradual progress.
Optional AI integration: Users can provide a Google Gemini API key to enable live AI responses.
User-focused design: The goal is to make habit tracking simple and encourage users to keep moving forward.

For this project, I explored how local logic and optional AI integration can work together to create a more accessible application.

One important distinction is that the offline behavioral engine is not itself a generative AI model. The optional Gemini integration provides live AI responses, while the core functionality is intended to remain available without it.

Why Does Open Innovation Matter?

Open innovation makes it possible for developers, students, and independent builders to experiment, learn, and create without needing access to expensive infrastructure or proprietary development environments.

For a project like HabitForge AI, this matters because the core experience should not disappear when an external AI service is unavailable.

An offline-first approach offers several advantages:

Accessibility: Core features can remain usable without an internet connection.
More control: Developers can inspect, modify, and improve the application's implementation.
Lower dependency: The basic experience does not need a paid AI API to function.
Room to experiment: Open development makes it easier to test ideas and improve the project over time.

The optional Gemini integration also demonstrates that local functionality and hosted AI can complement each other.

I believe open innovation is especially valuable for students because it turns learning into building. Instead of only studying concepts, we get to experiment with them and create something useful.

My Agent Session

I used AI-assisted development to explore the project idea, structure the implementation, and improve the overall user experience.

Agent Session: [Add your DevRelay session link here, if available]

This section is optional. If you did not save a session using DevRelay, you can remove this section before publishing.

The Lazy Payoff 😌

HabitForge AI is built around reducing the effort required to stay consistent.

Instead of repeatedly figuring out how to begin, users can focus on small actions and gradually build routines.

The intended benefits include:

Less friction when starting a daily habit.
A simpler way to keep track of progress.
Less pressure to make huge changes immediately.
A practical reminder that consistency matters more than occasional bursts of motivation.

I haven't measured a specific time-saving figure yet, so I won't claim an exact number. The real payoff I want to explore is whether making habits easier to manage helps people stick with them for longer.

Prize Categories

Primary submission: Hacktoberfest Open-Source AI Challenge Week 3 — Slow and Steady.

Partner categories: Add any applicable partner categories only if the project meets their requirements and you are entering them. Otherwise, remove this section.

Final Thoughts

Building HabitForge AI has been an opportunity to explore how a simple idea can become a practical software project.

As a student learning to build AI-powered applications, I wanted to create something that connects technology with an everyday problem.

The biggest lesson behind this project is that progress doesn't always come from doing more. Sometimes, it comes from making the next step easier.

Start small. Stay consistent. Let progress compound.

Hacktoberfest #OpenSourceAI #BuildInPublic #AI #WebDevelopment #HabitBuilding

ScamShield AI

Vedant Shukla — Wed, 14 Oct 2026 09:24:11 +0000

ScamShield AI: Detect Scams Locally with Open-Source AI 🛡️

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

What I Built

I built ScamShield AI, an AI-powered scam detection tool designed to help people identify suspicious messages, phishing attempts, fraudulent links, and potential online scams.

Online scams are becoming increasingly sophisticated, and many people struggle to distinguish legitimate messages from fraudulent ones. ScamShield AI aims to make scam detection easier by analyzing user-provided text and explaining the warning signs in simple language.

Key Features

🛡️ AI-Powered Analysis: Analyzes suspicious messages using a locally running AI model.
🔍 Scam Detection: Identifies potential phishing, fraud, impersonation, and social engineering attempts.
💻 Local AI Inference: Uses Ollama to run an open-weight language model locally.
🔐 Privacy-Focused Design: Message analysis can run locally without sending message contents to a third-party AI API.
📋 Explainable Results: Provides understandable reasons why a message may be suspicious.
🌐 Simple Web Interface: Makes scam analysis accessible through a user-friendly interface.

Who Could Benefit?

ScamShield AI could be useful for students, individual internet users, freelancers, small businesses, and organizations that want an additional layer of protection against online scams.

The project could eventually evolve into a freemium security tool, a browser extension, or a subscription-based service for small businesses.

ScamShield AI is a decision-support tool, not a guarantee that a message is safe or fraudulent.

Demo

Live Demo: https://vedantshukla-cracker.github.io/ScamShield-AI/

The demo will showcase how users can submit a suspicious message, analyze it with AI, and review the generated risk assessment and explanation.

Code

GitHub Repository: https://github.com/vedantshukla-cracker/ScamShield-AI

The project source code, installation instructions, configuration, and testing guidance will be available in the repository.

Contributions, bug reports, feature requests, and improvements are welcome!

How I Built It

ScamShield AI combines a lightweight web interface with local AI inference to analyze potentially fraudulent messages.

Technology Stack

HTML, CSS, and JavaScript: Frontend interface and user interactions.
Ollama: Runs the AI model locally.
Open-Weight Language Model: An instruction-following model suitable for text classification and scam analysis.
Python / Backend (if applicable): Connects the web interface to the local inference service.

How It Works

The user enters a suspicious message.
The application sends the text to the locally running model through Ollama.
The model analyzes possible scam indicators, including urgency, suspicious requests, impersonation, and requests for sensitive information.
ScamShield AI displays a risk assessment and an explanation of the warning signs.
The user can make a more informed decision about the message.

Open-Source AI and Model Licensing

The project is designed around local inference using Ollama and an open-weight model.

The exact model name, version, and license should be documented in the repository before release. Model licenses differ, so the selected model's license must be checked independently rather than assuming every Ollama model is fully open-source.

Local inference reduces dependence on paid external AI APIs and can improve privacy by keeping message content on the user's machine, provided the application does not transmit that content through other services.

Limitations and Testing

ScamShield AI is an experimental security assistant. It may produce false positives or false negatives, and its results should not replace independent verification.

Testing should include:

Legitimate messages to check for false alarms.
Known phishing and scam examples.
Messages containing urgent payment requests.
Impersonation and credential-stealing attempts.
Empty, malformed, and unusually long inputs.
Verification that message contents are not unintentionally transmitted to external services.

The goal is to build a useful, privacy-conscious starting point for accessible AI-assisted scam awareness.

Why Does Open Innovation Matter?

Open innovation makes projects like ScamShield AI more accessible, transparent, and adaptable.

By using an open-weight model and local inference, developers can experiment with AI without depending entirely on proprietary APIs or paying for every inference request.

It also creates opportunities to:

Inspect and improve the application's source code.
Experiment with different models and compare their performance.
Adapt the tool for different languages and scam patterns.
Encourage community contributions to testing and security.
Learn about practical AI deployment, privacy, and responsible development.

Open innovation does not automatically guarantee security or unrestricted model usage. Model licenses, dependencies, and data-handling practices still need to be reviewed carefully.

For me, this project is an opportunity to explore how open AI can solve a real-world problem while making AI development more approachable.

My Agent Session

[Optional: Add your DevRelay agent session link here.]

This section can document how an AI coding agent helped with implementation, testing, debugging, or project development.

Prize Categories

Challenge: Hacktoberfest Open-Source AI Challenge — Week 2: Side Hustle.

Project Focus: Open-source AI, local inference, scam awareness, and privacy-conscious security tooling.

[Add the official partner prize categories you are entering, after checking the challenge rules.]

Built with curiosity, open-source AI, and a mission to make the internet a little safer. 🛡️

Hacktoberfest #OpenSource #AI #Ollama #CyberSecurity #MachineLearning #ScamDetection

Earth Detective: AI That Turns the Real World Into Your Investigation

Vedant Shukla — Wed, 07 Oct 2026 19:40:25 +0000

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

What I Built

I built Earth Detective, an AI-powered outdoor investigation game designed to get people away from their screens and into the real world.

Instead of spending the entire experience inside an app, players receive an environmental mystery and have to step outside to investigate it. They observe their surroundings, look for real-world clues, record their observations, and solve the case.

Players can choose different investigation themes such as:

🌿 Nature Detective
💧 Water Mystery
🏙️ Urban Detective
♻️ Sustainability Detective

The game includes missions, clues, hints, a timer, difficulty-based scoring, investigation history, and a final field report.

The idea is simple:

The real world becomes the dataset. AI becomes the game master. You become the investigator.

The project is designed for students, curious explorers, and anyone who wants a more meaningful reason to go outside and observe the world around them.

Demo

🌐 Live Website:
https://vedantshukla-cracker.github.io/Earth-Detective/

Code

💻 GitHub Repository:
https://github.com/vedantshukla-cracker/Earth-Detective

How I Built It

Earth Detective is built using:

HTML5
CSS3
Vanilla JavaScript
LocalStorage
Fetch API
Ollama for local AI inference

The application does not require a frontend framework such as React or Vue.

The AI integration is designed around local inference using Ollama, allowing the project to work with an open-weight AI model running on the user's own machine.

AI can be used to:

Generate investigation missions
Create environmental clues
Provide hints without directly revealing the answer
Evaluate the user's observations
Generate a final investigation report

The application also has built-in missions as a fallback, so the core experience remains usable even when local AI is unavailable.

The basic architecture is:

Earth Detective
      │
      ▼
HTML + CSS + JavaScript
      │
      │ Fetch API
      ▼
Ollama
      │
      ▼
Open-Weight AI Model

Why Does Open Innovation Matter?

Open innovation makes it possible to experiment with AI without making the entire experience dependent on a closed cloud API.

With local inference, the AI can run on the user's own machine, which gives the project more control over privacy, experimentation, and how the AI is integrated into the experience.

It also makes the project easier to modify and extend. Developers can experiment with different open-weight models and build new investigation mechanics without redesigning the entire application around a proprietary API.

For Earth Detective, this is especially important because the goal is not just to add an AI chatbot to a website. The AI is being used as a game master that creates reasons for users to interact with the physical world.

My Agent Session

Not included yet.

Prize Categories

Open-Source AI
Touch Grass / Real-World Exploration

Project Links

🌐 Website: https://vedantshukla-cracker.github.io/Earth-Detective/

💻 GitHub: https://github.com/vedantshukla-cracker/Earth-Detective