DEV Community: Rhythm Gupta

Afterlight: Ghost in the Machine 👻

Rhythm Gupta — Tue, 27 Oct 2026 07:10:54 +0000

Afterlight: Ghost in the Machine 👻 | Hacktoberfest Week 4

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

What I Built

Afterlight is a browser-based supernatural storytelling studio powered by open-weight AI.

The idea came from the thought that some stories never really disappear. They stay with us as memories, old photographs, forgotten places, and stories passed down through generations.

I wanted to build something that combined that feeling with AI. Afterlight lets users create atmospheric ghost stories by choosing a premise, selecting a mood, and adjusting the story length.

It also includes a feature called Keep a Memory Glowing, which lets users incorporate a meaningful detail, song, or memory into a fictional remembrance-inspired story.

I designed the interface around the atmosphere of the project: dark colours, moonlight-inspired accents, subtle textures, and a quiet, cinematic layout.

The project focuses on three things:

Creative storytelling: Generate supernatural fiction from a user's own ideas.
Personal remembrance: Turn meaningful details into fictional tributes without pretending to contact or speak for deceased people.
Local-first AI: Explore how a creative AI application can run without relying on a hosted inference API.

Demo

RHYTHMGUPTA8 / afterlight-ghost-story

Afterlight — No Ollama version

An offline-first supernatural story studio. It runs as a static website and uses Transformers.js to load the open-weight Xenova/flan-t5-small model directly in the browser. No Python, Flask, Ollama, API key, or backend server is required.

Run it

Extract the ZIP.
Open a terminal in the extracted folder.
Run a simple local static server (recommended because browser modules may not work from file://)
```
py -m http.server 8000
```
Open http://localhost:8000.

VS Code users can also use the Live Server extension and click Go Live.

First run

The browser needs internet access on the first run to download Transformers.js and the model files. The first load can take a while. After the files are cached, inference runs in your browser; exact offline behavior depends on whether all assets have been cached and your browser settings.

If the model fails to load or your device cannot…

View on GitHub

The application is designed to run as a static website. After the required model files have been downloaded, the model can perform inference in the browser.

The first run requires an internet connection to download the AI library and model. If model loading fails, the application switches to a built-in fallback story generator so users can still explore the interface.

Code

GitHub repository: [Add your public GitHub repository URL here]

The project uses a simple, accessible structure:

index.html — the user interface and application layout
static/styles.css — visual design, responsive layout, and animations
static/app.js — story generation, browser model integration, and fallback handling
README.md — installation instructions and project documentation

The code is structured so that the interface and model integration can be modified independently.

How I Built It

I built Afterlight using HTML, CSS, and JavaScript. Instead of creating a Python backend or depending on a hosted AI API, I used Transformers.js to run text generation directly in the browser.

The application is configured to use the Xenova/flan-t5-small model package. This allows the browser to load model files and perform inference on the user's device, rather than sending each prompt to a remote inference service.

The main workflow is straightforward:

The user enters a story premise.
The user selects an atmosphere and story length.
The application prepares a prompt using those choices and, optionally, a remembrance detail.
The browser attempts to generate a story using the local model.
If the model cannot load or generate a usable response, the application displays a built-in fallback story.

I also added suggested story premises, a copy-to-clipboard feature, loading feedback, and responsive styling to make the application feel like a finished creative tool rather than a bare text-generation demo.

The goal was to keep the project easy to understand, run, and extend.

Why Does Open Innovation Matter?

For me, open innovation is about having more control over the tools we build with.

When an application relies entirely on a closed, hosted AI service, its functionality can depend on API availability, pricing, usage limits, and decisions made by an external provider.

Afterlight explores a different approach.

By using a browser-based model, the application can perform inference on the user's device without requiring a paid inference API key. Prompts are processed locally by the application, rather than being sent to a hosted model endpoint.

This approach offers several advantages:

More control: Developers can experiment with compatible models and change the implementation.
Privacy: Story prompts do not need to be sent to a hosted AI inference service.
Accessibility: Anyone can explore the project without setting up an Ollama server or obtaining a cloud AI API key.
Resilience: The built-in fallback allows the application to remain usable when model loading fails.

There are trade-offs, too. Browser inference depends on the device's available memory and processing power. The first model download requires internet access, and the quality of generated stories depends on the selected model.

Afterlight is a small experiment, but it demonstrates why open models and accessible tooling can make creative AI development more flexible.

My Agent Session

Afterlight uses a browser-based text-generation pipeline rather than a separate agent framework.

The generation workflow takes the user's premise, mood, and length preference and combines them into a prompt. An optional remembrance detail can be included as creative context.

The application then attempts inference through Transformers.js. If the model cannot be loaded or returns an unusable result, the fallback logic takes over.

This keeps the application simple and makes the distinction between model-generated output and fallback-generated output visible to the user.

Agent session recording: Not applicable to this implementation; no separate agent-session recording is included.

The Spirit of It

The idea behind Afterlight is that a ghost does not always have to be frightening.

Sometimes, the things that linger are memories, places we miss, or stories that deserve to be remembered.

I wanted the application to capture both sides of that idea: the eerie atmosphere of a supernatural story and the warmth of remembering something meaningful.

The remembrance feature is deliberately framed as fiction. AI can help people express a feeling or build a story around a memory, but it should not pretend to contact the dead or claim to know what a real person would say.

For me, that balance is what makes this project fit the theme. The machine creates the words, but the meaning comes from the person who brings the story to life.

Prize Categories

Partner-specific prize categories: None selected yet.

I will add any applicable categories after checking the official challenge's partner requirements and confirming that the project meets their eligibility criteria.

Team Submissions

Submission type: Individual project.

Afterlight is being prepared as an individual submission. No teammate credits are required.

Thanks for reading! 👻

If you try Afterlight, experiment with an unusual premise, change the atmosphere, and see what kind of story emerges.

Sometimes the most interesting part of AI isn't the answer it gives us. It's the possibility it helps us imagine.

challenge 1

Rhythm Gupta — Wed, 21 Oct 2026 17:48:45 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

What I Built

Demo

Code

How I Built It

Why Does Open Innovation Matter?

My Agent Session

Prize Categories

challenge 1

Rhythm Gupta — Wed, 21 Oct 2026 17:18:28 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

What I Built

Demo

Code

How I Built It

Why Does Open Innovation Matter?

My Agent Session

Prize Categories

SlothSort 🦥 — Let Local AI Organize Your Files

Rhythm Gupta — Mon, 19 Oct 2026 21:52:09 +0000

What I Built

Meet SlothSort — a local-first AI file organizer that takes the boring work out of managing a cluttered Downloads folder.

Instead of manually opening files, renaming them, and deciding where they belong, simply upload your documents and let SlothSort suggest meaningful filenames, categories, and summaries.

It supports documents, invoices, certificates, notes, spreadsheets, code files, and more.

The best part? You stay in control. Review the AI's suggestions, edit them if needed, and approve files before they move into your organized library. Made a mistake? Undo the move.

The goal is simple: spend less time organizing files and more time doing what matters.

Demo

Code

RHYTHMGUPTA8 / SlothSort

The project includes the Flask backend, a web dashboard, local AI integration, SQLite storage, and file organization with undo support.

How I Built It

I built SlothSort using:

Python + Flask — application backend and web interface.
Ollama — runs the language model locally.
Qwen 2.5 3B — the default open-weight model for generating file organization suggestions.
SQLite — stores file metadata and action history.
HTML, CSS, and JavaScript — powers the interactive dashboard.
Local file-processing libraries — extract text from supported documents before analysis.

When a file is uploaded, SlothSort extracts available text, sends the relevant content to the local model, and receives a suggested filename, category, and summary. The user can review the result before the file is moved.

If Ollama is unavailable, the application has a basic rule-based fallback so the workflow can still be tested.

Why Does Open Innovation Matter?

Files can contain personal information, financial details, academic certificates, and work documents. Uploading all of them to a third-party AI service is not always desirable.

That's why I wanted to explore a local-first approach.

With Ollama and an open-weight model, SlothSort can analyze files on the user's own machine instead of relying on a hosted AI API.

Open innovation makes three things possible:

Privacy: File contents do not need to be sent to an external AI provider.
Control: Users can change the model, adjust prompts, and customize the organization rules.
Accessibility: After the initial setup and model download, the core workflow can run offline without per-request AI API charges.

There is still a cost in hardware and electricity, and local models can make mistakes. That's why SlothSort includes a review-before-moving workflow instead of blindly trusting every prediction.

For me, open-source AI is not just about using a different model. It's about giving people more control over where their data goes and how their tools work.

The Lazy Payoff 🦥

Think about the files that accumulate in your Downloads folder: invoices, certificates, notes, screenshots, and documents with names like final_v2_revised.pdf.

Each file takes only a few seconds to organize, but the repeated effort adds up.

SlothSort aims to reduce that repetitive work by generating suggestions automatically and letting users approve them in batches of small, manageable actions.

I haven't measured a reliable time-saving figure yet, so I won't claim a specific number. That's something I'd like to benchmark as the project develops.

Local AI Expense Assistant: Turn Invoices Into Organized Expense Records Without Cloud AI

Rhythm Gupta — Sat, 17 Oct 2026 20:15:06 +0000

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

What I Built

Local AI Invoice & Expense Assistant

Managing invoices and receipts can be tedious for freelancers and small business owners. Manually entering merchant names, dates, taxes, and amounts into spreadsheets takes time, and sending financial documents to third-party AI services may raise privacy concerns.

I built a Local AI Invoice & Expense Assistant that uses a locally running AI model to extract structured information from invoices and receipts, categorize expenses, and save the results in a dashboard.

The goal is to help freelancers, tutors, and small business owners spend less time on repetitive bookkeeping while keeping their documents on their own computers.

Code

RHYTHMGUPTA8 / local-ai-expense-assistant

How I Built It

I built the application with a simple architecture:

Python and Flask: Handle document uploads, processing, and application routes.
Ollama: Runs the language model locally to extract structured invoice information.
Qwen 2.5 3B: The default model for extracting merchant names, dates, amounts, taxes, and expense categories.
SQLite: Stores the extracted expense records locally.
HTML and CSS: Provide the expense dashboard and upload interface.
PDF text extraction and OCR support: Extract text from supported documents and images.

The application requests structured JSON from the model so that extracted fields can be saved consistently in the database.

An important design goal is to keep AI inference local instead of sending each invoice to a paid cloud AI API.

Why Does Open Innovation Matter?

Open-source and open-weight AI make this project practical for users who want greater control over their financial data and operating costs.

Privacy: Documents can be processed on the user's own computer instead of being uploaded to an external AI provider.

Cost control: Local inference avoids per-request charges from proprietary AI APIs, although hardware, electricity, and maintenance still have costs.

Flexibility: The model can be replaced with another compatible model as performance and requirements change.

Customization: The extraction prompts and expense categories can be adapted for freelancers, independent professionals, and small businesses.

For this use case, open AI makes it possible to explore a private, locally operated bookkeeping assistant without requiring a recurring cloud AI API subscription.

Thanks for checking out my project!

TouchGrass AI — An Open-Source AI Companion That Gets You Outside

Rhythm Gupta — Sun, 11 Oct 2026 11:26:31 +0000

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

What I Built

We spend so much time looking at screens that sometimes we need a little help getting away from them.

TouchGrass AI is an open-source, AI-powered outdoor activity companion that helps people turn their free time into small, meaningful real-world adventures.

Instead of recommending another app to scroll through, it helps you discover something to do outside.

Whether you have 10 minutes between classes or an entire afternoon to explore, the idea is simple: tell the app how much time you have, choose your energy level and surroundings, and let AI suggest an outdoor mission.

Some examples:

🌳 Take a mindful walk and notice five things you usually overlook.

🐦 Spend a few minutes observing birds in your neighbourhood.

🌱 Explore a small gardening or nature observation activity.

🚶 Discover a short outdoor challenge that fits your available time.

The goal is to make the screen the shortest part of the experience. Generate your mission, head outside, and come back only when you want to record your progress.

Demo

touchgrass-ai-eta.vercel.app

Code

RHYTHMGUPTA8 / touchgrass-ai

TouchGrass AI 🌿

A local-first outdoor mission generator powered by an open-weight language model. TouchGrass turns a few free minutes into a practical real-world activity, then gets out of the way. No account, cloud AI API, streaks, or social feed.

Hacktoberfest theme: Touch Grass — the screen should be the shortest part of the experience.

Why open innovation matters

Privacy by default: the user's preferences are sent to the Ollama process running on their own machine, not to a hosted model API.
Works without internet after setup: download the app dependencies and model once; mission generation then runs locally. The PWA caches its static shell, but generating a new mission still requires the local Ollama service.
Model choice: OLLAMA_MODEL can be changed to another compatible model. The prompt and safety constraints are visible and editable.
Accessible experimentation: contributors can run, inspect, test, and extend the project without paying per-token API…

View on GitHub

How I Built It

I built TouchGrass AI with a local-first architecture.

Technologies used:

Python and FastAPI for the backend.

HTML, CSS, and JavaScript for the frontend.

Ollama to run an AI model locally.

Qwen2.5 3B as the default open-weight model.

Progressive Web App features for an installable, app-like experience.

The application sends activity preferences to the locally running model, which generates suggestions based on the user's available time, energy level, and environment.

The architecture is intentionally modular so that developers can experiment with different models, improve the prompts, and extend the application without being locked into a single AI provider.

Why Does Open Innovation Matter?

For this project, open innovation is not just a technology choice. It is central to how the application works.

🔒 Privacy by design: User preferences can be processed locally instead of being sent to a third-party AI provider.

📴 Offline potential: After downloading the application dependencies and model, the core mission-generation workflow can run without an internet connection, provided the local AI service is running.

🔄 Freedom to experiment: Developers can change the model, modify prompts, inspect the implementation, and adapt the experience to different communities.

💸 Lower ongoing API costs: Local inference avoids per-request charges from hosted AI APIs, although it still uses the computer's hardware and electricity.

A closed AI API could generate outdoor recommendations too. However, a local, open-weight approach makes privacy, model choice, and offline operation much more accessible.

I wanted to explore how AI could encourage people to spend less time interacting with technology and more time experiencing the world around them.

The technology should enable the experience, not become the experience.