DEV Community: Lavish Sheth

GhostWriter AI: Bringing Stories to Life with Local Open-Source AI

Lavish Sheth — Tue, 27 Oct 2026 06:17:49 +0000

👻 GhostWriter AI: Bringing Stories to Life with Local Open-Source AI

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

What I Built

For this week's Hacktoberfest challenge, I explored an idea that combines Halloween, storytelling, and open-source artificial intelligence: GhostWriter AI — a local AI-powered horror story generator.

The idea is simple: what if you could create your own spooky stories without sending your prompts to an external AI service?

GhostWriter AI is designed to generate personalized horror stories based on a user's imagination. You can choose a setting, describe a mysterious event, select a mood, and let a locally running AI model turn those ideas into a chilling story.

Imagine entering a prompt like:

"An abandoned railway station where the last train arrives every night, even though the tracks were removed years ago."

The AI transforms that idea into a suspenseful story filled with eerie discoveries, unexpected twists, and an unsettling ending.

The goal is to make storytelling creative, accessible, and privacy-friendly while exploring what open-source AI can do beyond traditional chatbots.

How I Built It

The project is designed around a simple Python-based architecture with local AI inference.

Here is the planned technology stack:

Python: Handles the application logic and story generation workflow.
Ollama: Runs an AI model locally instead of relying on a hosted inference API.
Qwen2.5: An open-weight language model that can generate creative text.
Streamlit: Provides a simple interface for entering prompts and reading generated stories.

The workflow is straightforward:

The user enters a story idea and selects a preferred atmosphere.
Python combines the input with a carefully designed storytelling prompt.
Ollama sends the prompt to the locally running language model.
The model generates a unique horror story.
The application displays the finished story for the user to read.

The architecture is intentionally lightweight so that it can be adapted to different models and expanded with additional features.

Why Does Open Innovation Matter?

For me, the most interesting part of this project is not just generating horror stories. It is exploring how open-weight AI makes experimentation more accessible.

🔒 Privacy Comes First

When inference runs locally, prompts can remain on the user's machine rather than being sent to a third-party AI API. This is especially valuable for personal writing, private ideas, and experimental projects.

🌐 Creativity Without an Internet Connection

After the model has been downloaded and the local environment is configured, story generation can work without an active internet connection.

This makes the application useful even when connectivity is limited.

🛠️ Freedom to Experiment

Using an open-weight model gives developers more flexibility to experiment with different models, adjust prompts, customize the application, and explore local inference without depending entirely on a single hosted AI provider.

💰 Lower Dependence on Paid APIs

Local inference avoids per-request API charges, although it still uses computing resources such as memory, processing power, and electricity.

For hobby projects and learning experiments, this can make repeated testing more accessible.

Open innovation matters because it gives developers the opportunity to understand, customize, and build on AI technology instead of treating it as a black box.

The Spirit of It 👻

Halloween is the perfect excuse to experiment with the mysterious side of technology.

The phrase Ghost in the Machine makes me think about something invisible working behind the scenes: a model running on a computer, interpreting a few words, and turning them into an entire world of suspense.

A simple prompt can become a haunted house, a forgotten village, a mysterious voice from an old radio, or a story about something that should never have returned.

That is what makes this project interesting to me. The AI does not need to know the story beforehand. It takes an idea from the user and builds something new from it.

At the same time, Día de los Muertos reminds us that stories can preserve memories, traditions, and the voices of people who are no longer with us. Although this project focuses on fictional horror, the same principle of accessible, locally controlled AI could also support storytelling and preserving personal narratives.

Technology becomes more meaningful when it gives people new ways to express their imagination and preserve what matters to them.

What I Learned

This project explores several important concepts:

Running an open-weight language model locally.
Integrating AI inference into a Python application.
Designing prompts for creative text generation.
Building an interface for an AI-powered tool.
Understanding the trade-offs between local inference and hosted AI APIs.
Exploring privacy, accessibility, and model flexibility in open-source AI.

It also demonstrates that an AI project does not always need an expensive API or a complicated cloud architecture to be worth exploring.

What's Next?

There are several features I would love to explore as the project develops:

Multiple horror styles, including psychological horror, supernatural mysteries, and folklore.
Adjustable story length and suspense levels.
A library for saving and revisiting generated stories.
Optional text-to-speech narration for an immersive storytelling experience.
A fully offline mode once all required models and dependencies are installed.

These are possible future improvements rather than features I am claiming are already implemented.

Prize Categories

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

The focus is on creative experimentation with an open-weight model and local AI inference.

Thanks to the DEV Community and Hacktoberfest organizers for creating opportunities to experiment, learn, and build with open-source technology.

Sometimes, the most interesting thing about a machine is what it creates when you give it an idea.

And sometimes, that idea is a ghost. 👻

devchallenge #hf26challenge #Hacktoberfest #OpenSourceAI #Python #Ollama #Qwen #GenerativeAI #MachineLearning #BuildInPublic

A Local AI File Organizer That Cleans Up Your Digital Mess

Lavish Sheth — Tue, 20 Oct 2026 05:05:23 +0000

LazyDesk: A Local AI File Organizer That Cleans Up Your Digital Mess

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

What I Built

LazyDesk is a privacy-first AI file organizer that does the boring work of cleaning up your computer for you.

My Downloads folder often becomes a mess of PDFs, screenshots, documents, images, ZIP files, code files, and random files with confusing names. Organizing everything manually takes time, and I keep postponing it because it feels like a chore.

LazyDesk is designed to solve this problem with a small, locally running AI model.

Instead of manually opening every file and deciding where it belongs, LazyDesk can:

Automatically categorize files into folders such as Documents, Images, Code, Projects, and Archives.
Suggest meaningful filenames based on file contents when supported.
Identify potential duplicates and help prevent unnecessary clutter.
Generate a simple summary of what is inside a messy folder.
Create a cleanup plan showing which files should be moved, renamed, or reviewed.
Ask for confirmation before making changes, so the user stays in control.

The goal is simple: spend less time managing files and more time doing the work that actually matters.

No complicated setup of cloud AI services is required for the core AI workflow. LazyDesk is designed to run locally using an open-weight model, keeping personal documents on the user's own machine.

Demo

The demo will show LazyDesk taking an unorganized Downloads folder and turning it into a clean, structured workspace.

The workflow:

Select a folder to organize.
Let the local AI analyze supported files and suggest categories.
Preview the proposed changes.
Approve the cleanup plan.
Watch LazyDesk organize the files and generate a summary.

The demo will include a before-and-after comparison to demonstrate the result.

Code

Project: LazyDesk

Planned technology stack:

Python for file handling and automation.
Ollama for running an open-weight language model locally.
Qwen2.5 3B as the initial model for classification and filename suggestions.
A lightweight interface for selecting folders, reviewing suggestions, and approving actions.
Standard Python libraries for filesystem operations and duplicate detection.

The project will be organized into separate modules for AI-based classification, file scanning, cleanup planning, safe file operations, and reporting.

All file operations will use a preview-first workflow. The application will avoid deleting files automatically and will keep a record of completed changes so users can review what happened.

How I Built It

LazyDesk is designed around the idea that AI should handle repetitive decisions without taking control away from the user.

The workflow begins with a Python file scanner that collects basic metadata, such as filenames, extensions, file sizes, and folder locations. Where supported, the application can extract limited text from documents to improve classification.

The local language model then suggests a category, a clearer filename, and a reason for each recommendation. Python validates the suggestions and prepares a cleanup plan.

Before anything changes on disk, the user can inspect the plan and approve or reject individual actions.

The key components are:

Local inference: Ollama runs the selected open-weight model.
AI reasoning: The model suggests file categories and descriptive names.
Automation: Python handles folder creation, file movement, and reporting.
Safety: Preview mode, user approval, collision checks, and error handling help prevent accidental changes.

The initial implementation will focus on common file types and a manageable folder size. More advanced document understanding and additional models can be introduced later.

Why Does Open Innovation Matter?

For a tool that reads and organizes personal files, privacy should not be an afterthought.

A cloud-based AI service could perform similar classification, but it might require uploading filenames, document contents, or other sensitive information to an external provider.

LazyDesk takes a different approach: the AI can run locally, allowing file analysis to happen on the user's own computer.

Open-weight models also make experimentation possible. Developers can compare different models, adjust prompts, change the classification rules, and improve the workflow without tying the project to a single proprietary AI API.

Open innovation makes this project more accessible because developers can inspect the implementation, adapt it to their needs, and contribute improvements to the community.

The goal isn't to prove that local AI is always better than cloud AI. It is to show that a small, focused model can be useful for everyday automation while offering greater control over data, model selection, and running costs.

My Agent Session

The initial version will focus on building and testing the local file-organization workflow.

An agent session or development walkthrough can be added after implementation and testing. It will demonstrate how the model makes recommendations, how the cleanup plan is validated, and how the application handles errors or conflicting filenames.

The Lazy Payoff

The real win is eliminating a task that people repeatedly postpone.

For an initial experiment, I plan to test LazyDesk on a folder containing approximately 100 mixed files and compare the time needed for manual organization against the time needed to review and approve the AI-generated cleanup plan.

The goal is to reduce repetitive sorting and renaming while keeping the user in control.

The application will also measure how long local inference takes, how many suggestions are accepted, and how many files require manual review.

Rather than claiming a time-saving figure without evidence, I'll use these measurements to understand where the tool genuinely helps.

My definition of lazy productivity: automate the boring parts, review the important decisions, and get back to work.

Prize Categories

Open-source AI and local inference.

WildWalk AI: An Open-Source AI Companion That Gets You Off the Screen & Into the Real World

Lavish Sheth — Tue, 06 Oct 2026 07:19:24 +0000

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

What I Built

🌿 WildWalk AI — Your AI Guide to the World Outside

I built WildWalk AI, an open-source AI-powered outdoor companion designed to help people spend less time on screens and more time in the real world.

Instead of using AI to keep people chatting with a screen, WildWalk uses AI to create personalized outdoor adventures and encourage users to actually go outside.

A user can tell WildWalk:

"I have 60 minutes free and want to go for a peaceful walk."

WildWalk then creates a personalized outdoor mission based on their available time, interests, and activity level.

For example:

🌳 60-Minute Nature Quest

Distance: 3 km

Difficulty: Easy

Duration: 60 minutes

Your missions:

Find 3 different types of leaves
Listen for 2 different bird calls
Take one interesting photograph
Find something you've never noticed before
Spend the final 10 minutes without looking at your phone

WildWalk can also help users explore nature by identifying plants, flowers, birds, and other things they discover outdoors.

After completing an adventure, users can create an AI-generated Adventure Journal containing their experience, discoveries, and observations.

The goal is simple:

Generate the adventure. Put the phone away. Go outside. Touch grass. 🌿

The project is designed for people who want to walk, hike, run, explore nature, practice photography, go birdwatching, garden, or simply spend more intentional time outdoors.

Demo

The demo will show the complete WildWalk experience:

User enters their available time and preferred outdoor activity.
WildWalk generates a personalized outdoor adventure.
The user receives nature challenges and missions.
The user goes outside and completes the adventure.
The user can document their discoveries.
WildWalk generates an Adventure Journal from the experience.

How I Built It

WildWalk is built around open-weight AI, with Gemma serving as the core AI model.

The project is designed so that the AI can run locally using Ollama, allowing the adventure-generation experience to work without depending entirely on a closed cloud AI API.

The planned architecture uses:

React for the frontend
Python + FastAPI for the backend
Gemma as the open-weight AI model
Ollama for local inference
MongoDB Atlas for storing adventures and journals
Render for deployment
Sentry for monitoring and debugging
ElevenLabs for optional voice guidance

The AI is responsible for generating personalized outdoor adventures, missions, nature challenges, explanations, and post-adventure journals.

The important part is that the open-weight model isn't just an add-on. It is part of what makes the experience work.

Why Does Open Innovation Matter?

Most AI applications are designed to keep people interacting with technology.

WildWalk takes the opposite approach.

The question behind the project is:

What if AI could help us spend less time with technology?

Using an open-weight model makes this idea more practical because the AI can potentially run locally rather than requiring every interaction to be sent to a closed AI provider.

That provides several advantages:

🔒 More control over user data
📴 Potential offline functionality
💰 Lower running costs
🔧 Ability to experiment with different models
🧠 Ability to customize the AI experience
🌐 Less dependence on a single closed AI provider

For an outdoor application, local AI is especially interesting because users may be hiking, walking, camping, or exploring places with limited connectivity.

The user can prepare their adventure before leaving and take the experience outside with them.

This project demonstrates a different philosophy for AI:

AI shouldn't always make us spend more time online. Sometimes, its job should be to help us log off.

My Agent Session

Prize Categories

Potential categories for WildWalk AI include:

Gemma — Best Use of Gemma
Render — Best Use of Render
MongoDB — Best Use of MongoDB Atlas
Sentry — Best Use of Sentry Agent Tracing
ElevenLabs — Best Use of ElevenLabs

Dose Buddy: a Medicine Reminder That Reads Prescriptions Locally with Gemma

Lavish Sheth — Sun, 04 Oct 2026 08:17:14 +0000

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

What I Built

Dose Buddy is a privacy-first medicine reminder that turns a doctor's instructions into a ready-to-use schedule. I built it for two people I care about: my dad and my friend Abhay.

Reminder apps are only useful if someone has the patience to set them up. Entering every medicine, dose and timing by hand is tedious, and one typo means a missed or wrong reminder. I wanted something where you type the instructions exactly as the doctor wrote them, and the app does the rest.

How it works. You type the prescription instructions, or upload a photo of the prescription. A local AI model reads them and builds the schedule. You review it in an editable table, fix anything wrong, and save. Then Dose Buddy reminds you on the laptop and on a phone.

Feature	What it does
Natural-language input	Understands text like "Amoxicillin 250mg every 8 hours for 5 days"
Photo input	Reads a prescription photo with a vision-capable model
Human confirmation	Shows an editable table; nothing is saved until the user approves
Today view	Lists today's doses with done and upcoming markers
Phone alarms	Exports a `.ics` calendar file with a repeating alarm per dose, which works offline
Desktop alerts	A background script shows a notification at each dose time

Safety note: Dose Buddy only sends reminders. It is not medical advice, and the schedule must always be checked against the original prescription.

Demo

The walkthrough shows:

Entering prescription instructions
The AI producing an editable schedule table
Saving the schedule and viewing today's doses
The reminder script firing an alert at the scheduled time

Code

lavishsheth / dose-buddy

💊 Dose Buddy

A medicine reminder built for one real person. Give it a prescription photo or plain text a local open model reads it, you confirm the result, and it sets reminders.

Everything runs on your own machine through Ollama. No cloud AI, no API key and no health data leaves the laptop.

Run it

# 1. Install Ollama, then pull an open model that can read images
ollama pull gemma3:4b

# 2. Install and start the app
pip install -r requirements.txt
streamlit run app.py

# 3. In a second terminal, start the reminder script
python reminder.py

How it works

Type the instructions or upload a photo.
The model returns JSON (medicine, dose, times, days).
You check and edit every row. Nothing is saved until you confirm.
Reminders: download an .ics file for phone alarms (works offline), and/or run reminder.py for desktop alerts.

Optional Telegram messages (needs internet):

…

View on GitHub

dose-buddy/
├── app.py            # Streamlit interface
├── core.py           # Prompt, JSON parsing, schedule logic, .ics export
├── reminder.py       # Background reminder alerts
├── requirements.txt
└── README.md

How I Built It

Open-source stack

Gemma 3 (4B): Google's open-weight model, which reads and structures the instructions
Ollama: runs the model locally on my laptop
Streamlit and Python: the interface and application logic

Architecture

Typed text or photo
        ↓
Gemma 3 via Ollama (runs locally)
        ↓
Structured JSON (medicine, dose, times, days, notes)
        ↓
Editable table, confirmed by the user
        ↓
Saved schedule
        ↓
.ics phone alarms  +  desktop alerts (reminder.py)

Design decisions

Structured output. The model must return a fixed JSON format at temperature 0, so the same input gives the same result. The parser also tolerates extra text around the JSON.
No guessing. The prompt tells the model to copy names and doses exactly as written and to return UNCLEAR when something can't be read. The app refuses to save any row marked UNCLEAR.
Human in the loop. Small models can misread doses, so the user always reviews and edits the table before saving.
Plain-language time rules. Phrases like "after dinner" or "every 8 hours" are mapped to clock times in one place, so they are easy to adjust.
Two reminder paths. The .ics file works on any phone without internet, and reminder.py covers the laptop.

Testing

I tested the parsing, scheduling and calendar-export logic with scripts covering time formats, malformed model output, course lengths and calendar rules. Then I ran the full app on my laptop with Ollama and recorded the demo. To check that alerts fire, I set a dose a couple of minutes ahead and watched reminder.py trigger it on time. I also made a clearly labelled sample prescription image for testing the photo path.

What I learned along the way

Setup has more steps than the code. The model has to be downloaded first, and Ollama has to be running before the app can use it. I added a status indicator in the sidebar so a missing connection is obvious.
A calendar file is not obvious to everyone. My first instinct was to "run" the downloaded .ics file. It is meant to be opened on a phone, where it imports the alarms. The app's reminders tab now explains this.
Small models need guardrails. Telling the model to say UNCLEAR instead of guessing, and forcing a human review, matters more than any prompt cleverness.

Limitations and next steps

Small local models can misread handwriting or blurry photos, so the confirmation step is essential.
reminder.py only works while the laptop is on.
Next: a "mark as taken" button, alerts for missed doses, and more languages.

How AI helped me build it

I wrote the code with help from Claude in a chat. The AI running inside the application is the open model, Gemma.

Handing it over

Dose Buddy is built for my dad and Abhay, and I'm putting it in their hands with this submission. Their feedback is the real test, because they are the ones who will decide whether it saves them effort. I'll update this post with what they say.

Why Does Open Innovation Matter?

Privacy. A medicine list is sensitive personal information. Because Gemma runs locally through Ollama, prescription text and photos never leave the laptop, and the AI step needs no internet connection. For something this personal, I didn't want to send it to someone else's servers.

Cost. There are no API keys, per-request fees or usage limits, so family and friends can use it every day without a bill.

Control. The model is a single setting in the sidebar, so it can be swapped for another open model, including a larger one for better handwriting. The behavior lives in one readable prompt I can edit directly. With a closed API, I couldn't control where the data goes, what it costs, or which model version I depend on.

Prize Categories

Best Use of Gemma: the core of the app is Gemma 3 running locally through Ollama.