DEV Community: ANUSHKA BAJPAI

AFTERLIGHT — A Garden of Memories: Keeping Stories Alive with Open-Source AI

ANUSHKA BAJPAI — Sat, 31 Oct 2026 16:48:03 +0000

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

AFTERLIGHT — A Garden of Memories ✳

What I Built

What if the memories we are afraid of losing could find a home in technology?

Introducing AFTERLIGHT, a local-first AI-powered memory garden designed to preserve the little things that make life meaningful.

Inspired by the idea of Halloween and Día de los Muertos, I wanted to explore a different side of the Ghost in the Machine theme.

Instead of building something that creates fear, I built something that keeps memories alive.

With AFTERLIGHT, users can:

🌼 Plant a Memory: Preserve personal stories, family traditions, recipes, and meaningful moments.
🕯️ Memory Garden: Organize, search, and revisit saved memories.
✨ The Lantern Room: Transform memories into remembrance notes, gentle ghost stories, and family-history entries.
🔒 Privacy First: Keep memories stored locally in the browser.

The idea is simple: technology should not replace memories. It should help us preserve them.

Demo

Live Demo: file:///C:/Users/lenovo/Desktop/AFTERLIGHT/index.html

Code

GitHub Repository: https://github.com/anushkabajpaigarg10-debug/AFTERLIGHT.git
The project is built using:

index.html — Application structure
style.css — User interface and styling
app.js — Application logic and AI integration

How I Built It

I wanted to keep the project beginner-friendly and build it using HTML, CSS, and JavaScript rather than relying on a complicated backend.

The main technologies are:

HTML5
CSS3
Vanilla JavaScript
WebLLM
Qwen2.5 0.5B Instruct
Browser LocalStorage

The AI Behind AFTERLIGHT

I integrated Qwen2.5 0.5B Instruct through WebLLM.

WebLLM enables language models to run directly inside the browser using WebGPU.

The AI powers the Lantern Room, where users can select a saved memory and generate different forms of writing.

The application does not require a hosted AI API or an application backend.

The first model download requires internet access. Once cached, local inference can work offline, subject to browser and device support.

Why Does Open Innovation Matter?

This is probably the most important part of AFTERLIGHT.

Memories can be deeply personal. Family stories, personal experiences, and traditions deserve privacy.

Using an open-weight model and browser-based inference makes it possible to build an AI experience without sending those memories to a hosted AI provider.

Open innovation gives this project:

1. Privacy and Control

The memories are stored in the user's browser. AI inference happens locally rather than through a hosted AI API.

2. Independence

The project does not depend on a paid AI API subscription or a proprietary hosted model.

3. Flexibility

Open-weight models make it possible to experiment with different models and adapt the AI experience.

4. Accessibility

There is no application backend or hosted AI API charge required to run the prototype.

For AFTERLIGHT, open-source AI is not just an additional feature. It is what makes the privacy-first approach possible.

My Agent Session

[Add your DevRelay agent session link if available.]

The Spirit of It

I kept coming back to one thought while building this:

Some people leave, some moments pass, and some stories slowly fade. But what if we could preserve the smallest pieces of them?

A recipe that has been passed down through generations.

A familiar phrase someone always used.

A story that everyone in the family knows but nobody has written down.

AFTERLIGHT is my small attempt to give those memories a place to stay.

It is not about bringing the past back.

It is about making sure we don't lose the parts of it that matter.

Keep the stories. Keep the memories. Keep the light.

Prize Categories

[Add the applicable partner prize categories from the challenge page.]

LazyLeaf : An Open-Source AI That Turns Procrastination into Progress

ANUSHKA BAJPAI — Tue, 20 Oct 2026 14:03:01 +0000

LazyLeaf 🍃 — Do Less, Feel Lighter

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

What I Built

Meet LazyLeaf, a gentle AI-powered productivity tool designed for people who have a lot to do but don't know where to start.

We all have those tasks we keep postponing — preparing for an exam, cleaning our room, finishing an assignment, or completing a project. Sometimes, the hardest part isn't doing the work. It's figuring out the first step.

LazyLeaf makes that easier.

Users enter an overwhelming task, and LazyLeaf breaks it down into smaller, manageable steps. They can check off completed tasks and track their progress without feeling pressured to do everything at once.

🌱 The idea is simple: make productivity less exhausting.

Demo

Live Demo: file:///C:/Users/lenovo/Desktop/LazyLeaf/index.html

Code

GitHub Repository: https://github.com/anushkabajpaigarg10-debug/LazyLeaf.git
The project uses three separate files:

index.html — website structure
style.css — styling and responsive layout
script.js — task planning, AI integration, and progress tracking

Built with HTML, CSS, and JavaScript, without a custom backend or database.

How I Built It

I built LazyLeaf using HTML, CSS, and JavaScript to keep the project lightweight and beginner-friendly.

For the AI component, I integrated Transformers.js with the open-weight LaMini-Flan-T5-77M model. The goal is to generate small, practical steps from a user's task directly in the browser.

The application also includes a JavaScript-based fallback planner. If the model cannot load or generate a response, users can still receive a basic checklist.

The architecture is intentionally simple:

The user enters a task.
The open-weight model attempts to turn it into actionable steps.
The generated steps appear as an interactive checklist.
Users mark completed steps and track their progress.

The model and its supporting library need to be downloaded, so the AI feature requires internet access during initial setup. The project does not rely on a paid AI API key.

Why Does Open Innovation Matter?

For a productivity tool, privacy and accessibility matter.

Tasks can contain personal information about someone's studies, work, responsibilities, or everyday life. Running inference in the browser means the application does not need to send those tasks to a custom application backend or a paid AI API.

Open-weight models also make experimentation more accessible. Developers can explore different models, adapt the experience, and build AI-powered tools without depending entirely on a closed AI service.

For LazyLeaf, open innovation makes it possible to explore a lightweight, browser-based AI experience without building an expensive backend.

It also gives the project room to grow. Future versions could experiment with other open-weight models, improved offline support, and more personalized task breakdowns.

Open AI should make useful technology more accessible, not add another barrier to getting started.

My Agent Session

Optional: Add your DevRelay agent session link or embed it here if you saved one.

The Lazy Payoff

LazyLeaf is built around a small but useful idea: reduce the effort it takes to get started.

Instead of staring at a long to-do list, users can focus on one small action at a time.

The project is a prototype, so I haven't established a measured time-saving figure yet. The next step is to test it with real tasks and compare how useful its generated plans are against manually planning the same work.

Prize Categories

Open-source AI / open-weight model application.

I'll update this section to match the official partner prize categories I qualify for.

Sometimes, productivity isn't about doing more.

Sometimes, it's about making the first step small enough that you actually take it. 🍃

LazyLeaf — Do less. Feel lighter.

SellCraft AI: Your Smart Sidekick for Creating Product Listings

ANUSHKA BAJPAI — Wed, 14 Oct 2026 07:41:30 +0000

SellCraft AI: Making Product Listing Creation Easier for Small Sellers ✨

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

What I Built

I built SellCraft AI, a product listing assistant designed for small business owners, Instagram sellers, resellers, and people who sell products online.

Writing product descriptions, finding keywords, and creating social media captions for every product can take a lot of time. For small sellers who manage everything themselves, this can become a repetitive task.

SellCraft AI aims to make that process easier. Users can enter their product name, category, target audience, and product details, then generate content they can edit and use for their listings.

The current prototype includes:

Product titles and descriptions
Key features and search keywords
Social media captions
Different writing tones
Editable results
Copy and text-file export options
Saved drafts and dark mode

My long-term goal is to turn this into a useful product that saves small sellers time and is valuable enough for them to pay for.

Demo

Live demo: https://anushkabajpaigarg10-debug.github.io/SELLCRAFTAI/

The application currently runs in a browser and does not require an API key or a backend.

Code

GitHub repository:https://github.com/anushkabajpaigarg10-debug/SELLCRAFTAI.git
The project currently uses three main files:

index.html — the application structure
style.css — the interface and responsive styling
script.js — listing generation, copying, downloads, and saved drafts

How I Built It

I built the initial prototype using HTML, CSS, and JavaScript, keeping the setup simple and beginner-friendly.

The current version uses JavaScript templates to organize product details into titles, descriptions, features, keywords, and captions. It also uses browser local storage to save drafts.

I chose a simple frontend first because I wanted to build something usable before adding more complex infrastructure.

My next step is integrating a locally running open-weight language model. I want to explore how local AI can make the generated content more flexible and relevant to each seller's products and writing style.

The current version does not yet run an AI model, so local inference is a planned improvement rather than a completed feature.

Why Does Open Innovation Matter?

For a tool like SellCraft AI, open innovation could make a real difference.

Privacy: Sellers may work with unpublished products, private catalogues, or business information. Local inference could allow them to generate content without sending every request to a third-party AI API.

Cost control: A local model could reduce per-request API expenses, which matters when building a product for small businesses with limited budgets. However, local hardware, electricity, and maintenance still have costs.

Freedom to experiment: Open-weight models would let me experiment with different models, prompts, and writing styles instead of depending entirely on one provider.

Learning and customization: As a student building this project, I want to understand how the model works as part of the application rather than treating AI as a black-box API call.

I am still at the beginning of this journey. My goal is to make open-source AI a core part of the working product, not just add it as a feature for the sake of the challenge.

My First User

I am looking for small online sellers who would be willing to test SellCraft AI with their real product details.

My first goal is to learn whether the tool genuinely saves them time, whether they find the generated content useful, and what they would need before paying for it.

I haven't claimed any paying customers or validated willingness to pay yet. That is one of the next milestones I want to work toward.

What's Next?

My roadmap includes:

Integrating a locally running open-weight model
Improving product-specific content generation
Adding reusable brand voice settings
Supporting more languages
Generating listings in batches
Testing the product with real sellers

I started SellCraft AI as a small project, but I want to explore whether it can grow into something genuinely useful for people running small businesses.

The goal is simple: spend less time writing listings and more time building the business. ✨

OutsideIRL: Less Scrolling, More Living | Touch Grass Challenge

ANUSHKA BAJPAI — Sun, 11 Oct 2026 18:13:23 +0000

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

OutsideIRL: Less Scrolling, More Living 🌿

What I Built

OutsideIRL is a web app built around a simple idea: technology should help us experience the real world, not keep us stuck in front of a screen.

As students, we spend a lot of time on our laptops and phones for classes, assignments, and entertainment. Sometimes, we forget to take a break, step outside, and notice what's happening around us.

OutsideIRL encourages people to take small steps toward a more active and mindful lifestyle through simple outdoor missions.

Users can explore missions, filter activities by category, use a timer, track completed activities, and record personal reflections.

The goal isn't to spend more time using the app. It's to use the app as a starting point, put the phone away, and actually experience the activity.

Demo

Live Demo: https://anushkabajpaigarg10-debug.github.io/OUTSIDEIRL/

Code

GitHub Repository: https://github.com/anushkabajpaigarg10-debug/OUTSIDEIRL.git

The project currently uses HTML, CSS, and JavaScript, with browser local storage for supported progress data.

How I Built It

I built OutsideIRL using HTML for the structure, CSS for the design and responsive layout, and JavaScript for the interactive features.

The current prototype includes predefined outdoor missions, category filters, a mission timer, progress tracking, and personal reflections.

For this first version, I focused on creating a working frontend prototype that demonstrates the core experience.

Integrating an open-weight AI model to generate personalized outdoor missions is a planned next step. I want to explore running an open-source model locally so the experience can become more adaptive while giving users greater control over their data.

Why Does Open Innovation Matter?

I believe open innovation matters because useful technology should be something people can explore, understand, adapt, and improve.

For OutsideIRL, open-source AI could make it possible to generate outdoor activities based on a person's interests, available time, and surroundings without depending entirely on a closed AI service.

Local inference could also offer more control over personal data and allow developers to experiment with models on their own devices.

I haven't implemented that AI integration yet, but it's an important part of where I want to take this project.

For me, the bigger idea is that AI doesn't always have to give people another reason to stay online. It can help them discover reasons to step outside.

Prize Categories

I'll add the applicable partner categories after confirming which ones my implementation qualifies for.