DEV Community: Piyush kumar

GhostWriter 👻: An Offline AI Horror Story Generator Powered by Open-Weight AI | Hacktoberfest 2026

Piyush kumar — Tue, 27 Oct 2026 20:21:21 +0000

👻 GhostWriter: An Offline AI Horror Story Generator

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

What I Built

Meet GhostWriter — a spooky AI-powered horror story generator that brings terrifying ideas to life without sending your prompts to a cloud AI service.

What happens when you combine Halloween, imagination, and open-weight AI running on your own computer?

You get a storyteller that lives inside your machine. 👻

With GhostWriter, users can choose a setting, a main character, a horror style, and a story length. The AI then generates an original story filled with suspense, mystery, and unexpected twists.

I interpreted the Ghost in the Machine theme as a literal ghost living inside a computer: an AI storyteller that can work locally, even when the internet disappears.

The goal was simple: make AI-powered creativity more private, accessible, and independent of cloud services.

✨ Key Features

👻 Generate original horror stories from custom prompts.
🏚️ Explore haunted mansions, abandoned hospitals, mysterious forests, and other eerie settings.
🕯️ Choose between psychological horror, supernatural stories, gothic horror, and suspense.
💻 Run inference locally using Ollama and a compatible open-weight model.
🔒 Keep prompts and saved stories on your own machine.
📖 Save, revisit, and download generated stories.
🌐 Generate stories offline after the initial setup and model download.

Demo

Video demo: https://drive.google.com/file/d/1HzSWYnSfsjJUEKCKJupVVdiNffK179iL/view?usp=sharing

The best way to experience GhostWriter is to give it a simple prompt:

A night guard working alone in an abandoned hospital discovers that one patient is still checking in every night, despite the hospital having been closed for twenty years.

Then watch the machine write the story.

Code

GitHub repository: https://github.com/piyushkr1155/GhostWriterAI

The project is built with Python and Streamlit, with Ollama handling local AI inference.

Check out the repository for the source code, installation instructions, project architecture, and contribution guidelines.

How I Built It

I wanted to build something practical that demonstrated the value of running AI locally rather than simply wrapping a hosted AI API.

Tech Stack

Python — application logic and story generation.
Streamlit — interactive user interface.
Ollama — local model runtime and inference API.
Open-weight language model — generates original horror stories.
JSON or SQLite — local storage for saved stories.
pytest — testing application logic and error handling.

How It Works

The user enters a story idea and selects their preferred horror style.
GhostWriter constructs a prompt from the user's choices.
The application sends that prompt to the local Ollama service.
The locally installed model generates the story.
The application displays the result and lets the user save or download it.

The important part is that story generation happens on the user's machine. After the required software and model have been installed, the application does not need a cloud AI API to generate stories.

Why Does Open Innovation Matter?

Open innovation is central to GhostWriter, not just an extra feature.

Privacy by design

Personal prompts and creative ideas can stay on the user's computer instead of being sent to a third-party AI provider.

Offline creativity

Once the dependencies and model are installed, GhostWriter can generate stories without an active internet connection. This makes the experience useful even when connectivity is unreliable.

Freedom to experiment

A local model can be replaced with another compatible model. Developers can compare outputs, adjust prompts, experiment with model settings, and customize the experience without being tied to one hosted API.

Lower barriers to entry

There is no per-request cloud inference charge in the local setup. Users can experiment without worrying about API usage bills, although hardware, electricity, and storage still have costs.

A more accessible AI ecosystem

Open-weight models and local tooling make it easier for developers to learn how AI applications work, inspect their architecture, and build alternatives that suit their needs.

For GhostWriter, the biggest advantage is independence. The story generator does not have to depend on a remote AI provider being available every time someone wants to create something.

My Agent Session

I used an AI coding agent to help build and refine the project. The development process involved structuring the application, integrating local inference, and testing the user experience.

The Spirit of It

Every Halloween, we tell stories about things we cannot explain.

GhostWriter gives those stories a new home: a computer that can create a new nightmare without needing to call the cloud.

The idea behind this project is that AI does not always need to be a distant service. Sometimes, the most interesting thing is what you can build right on your own machine.

The internet can go dark. The lights can go out.

But the ghost is still there. 👻

Prize Categories

Built with curiosity, local AI, and a little Halloween spirit. 🎃

Hacktoberfest #OpenSourceAI #Ollama #Python #LocalAI #GhostInTheMachine

🦥 SlothMate AI: Work Less, Let Your Local AI Handle the Boring Stuff | Hacktoberfest Week 3

Piyush kumar — Sun, 25 Oct 2026 09:19:23 +0000

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

🦥 SlothMate AI: Work Less, Let Your Local AI Handle the Boring Stuff

What if your computer could read your notes, organize your tasks, and prepare your daily briefing while you focus on something more important?

That's the idea behind SlothMate AI, an offline-first personal productivity assistant built around open-weight AI.

For this week's Slow and Steady challenge, I wanted to explore a simple question: Can we use local AI to reduce repetitive work without depending on a cloud AI service?

What I Built

SlothMate AI is a local-first assistant designed to take the boring work out of organizing information.

Imagine finishing a meeting, collecting several notes, and saving a few documents. Instead of opening every file, reading everything, and manually creating a to-do list, you can let SlothMate process the documents and prepare a consolidated briefing.

The goal is simple: spend less time organizing information and more time acting on it.

The planned core features include:

📂 Lazy Inbox: Process text files, Markdown documents, and PDFs.
🧠 Local AI Summaries: Generate concise summaries and extract important points.
✅ Automatic Task Extraction: Identify action items, priorities, and relevant deadlines.
☀️ Morning Briefing: Combine information from multiple documents into one report.
🦥 Sloth Mode: Start the processing workflow with one action.
🔒 Privacy First: Keep document processing local instead of sending private files to a hosted AI API.
📄 Local Export: Save useful briefings as Markdown files.

The intended users are students, developers, freelancers, and anyone who spends too much time reading documents and organizing tasks.

Demo

https://drive.google.com/file/d/1vCwilqu9i3AlFkFiGSqfb7f2LtVNS0cz/view?usp=sharing

The most useful demonstration is to process several sample documents, generate a consolidated briefing, and show the application working without an internet connection after setup.

Code

GitHub repository: https://github.com/piyushkr1155/SlothMathAI

The project is being designed with a modular architecture so that the AI service, document processors, task extraction, database, and interface can be maintained independently.

Contributions and suggestions are welcome!

How I Built It

The project uses Python and a local AI stack.

The planned technology stack includes:

Python for the application logic.
Ollama for running language models locally.
Qwen2.5 3B as the initial configurable open-weight model.
Streamlit for the interactive dashboard.
PyMuPDF for PDF text extraction.
SQLite for storing tasks and briefing history.
Pytest for testing the application.

The workflow is straightforward:

The user imports documents or places them in a local inbox.
Python extracts their contents.
The local model summarizes the content and identifies potential action items.
The application validates the generated results and combines them into a daily briefing.
Tasks and summaries are stored locally and displayed in the dashboard.

I chose a single local model with deterministic Python orchestration rather than building a complicated multi-agent system. For a productivity assistant, a straightforward and reliable workflow is more valuable than unnecessary complexity.

Why Does Open Innovation Matter?

For SlothMate AI, open innovation is not just about choosing a different AI provider. It is about giving users more control over their tools and information.

1. Privacy and local control

Personal notes and meeting documents can contain sensitive information. Running inference locally means the application does not need to send those documents to a third-party AI API.

2. Freedom to experiment

A compatible local model can be replaced with another model without rebuilding the entire application. Developers can experiment with model size, output quality, prompts, and processing strategies.

3. Offline capability

After the dependencies and model have been downloaded, the core workflow can operate without an internet connection. This makes the tool more useful in environments with unreliable connectivity.

4. No per-request cloud AI fees

Local inference avoids usage-based cloud AI API charges. It still consumes hardware resources and electricity, but users can process documents without paying a separate fee for every model request.

5. Transparent and customizable software

Because the application code is available for inspection and modification, developers can improve task extraction, add integrations, customize priorities, and adapt the application to their own workflows.

That is what makes open innovation valuable here: the user is not merely consuming an AI service. They can understand, modify, and control how the system works.

My Agent Session

I used an AI coding agent to help implement the application structure, connect the components, and work through development and testing.

The Lazy Payoff

The goal is to replace several repetitive steps with one workflow:

Before: Open documents → read them individually → identify important points → create tasks → organize deadlines → write a summary.

With SlothMate: Import documents → run Sloth Mode → review the consolidated briefing and tasks.

The actual time saved depends on document length, model speed, and the quality of the extracted information. The next step is to benchmark the workflow against manual document review using a fixed set of sample documents.

The real measure of success is not how much AI the application uses. It is how much repetitive work it removes while keeping the user in control.

Final Thoughts

I like the idea behind Slow and Steady because useful AI does not always need to be flashy, autonomous, or complicated.

Sometimes, the best assistant is the one that quietly handles the repetitive work and leaves you with only the decisions that matter.

Build less busywork. Keep your data local. Be a little lazier. 🦥

Hacktoberfest #OpenSource #LocalAI #Ollama #Python #AI #Productivity

LocalBooks AI: Turning Invoices into Structured Data with Open-Source AI

Piyush kumar — Sun, 18 Oct 2026 08:12:49 +0000

LocalBooks AI: A Private, Local-First AI Bookkeeping Assistant for Freelancers

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

What I Built

LocalBooks AI is a privacy-first invoice and receipt organizer designed for freelancers, independent professionals, and small businesses.

Bookkeeping shouldn't require hours of manually entering invoice details into spreadsheets. Freelancers often deal with dozens of receipts, vendor invoices, tax amounts, and payment records. Sending these sensitive documents to cloud AI services can also raise privacy and confidentiality concerns.

LocalBooks AI aims to simplify this workflow by processing invoices and receipts locally, extracting important information, and organizing it into structured records.

Key features include:

-Invoice and receipt processing: Upload PDF, PNG, JPG, or JPEG documents.
-Local OCR:** Use Tesseract to extract text from supported documents.
-AI-powered normalization: Use a locally running Ollama model to convert extracted text into structured invoice data.
-Bookkeeping dashboard: Review invoice records, amounts, vendors, and categories.
-Data validation: Help identify missing fields, duplicate records, and arithmetic discrepancies.
-Local-first privacy: Keep document processing on the user's own computer rather than sending financial documents to a hosted AI API.

The target users are freelancers, consultants, small-business owners, and accounting professionals who want a simpler way to organize financial documents.

The potential business model is a paid desktop or self-hosted edition with features such as batch processing, Excel-compatible exports, recurring reports, and multi-business support.

Demo

**Demo video: https://drive.google.com/file/d/1JUPdqCOddvKLqo75byagzUb0fYAdH8r4/view?usp=sharing

Because local inference is a core feature, the application is designed to work without sending financial documents to a cloud AI provider. Initial installation and model downloads require internet access; offline operation depends on the required software and model already being installed.

Code

GitHub repository: https://github.com/piyushkr1155/LocalBooks_AI

The project uses a modular architecture so the interface, document-processing pipeline, and AI inference can be developed and tested independently.

How I Built It

I built LocalBooks AI around open-source tools and an open-weight language model rather than making a proprietary cloud AI API the core of the application.

Technology stack

-Next.js and TypeScript:Dashboard, upload interface, invoice review, and visualization.
-FastAPI:Backend API and document-processing workflow.
-Tesseract OCR:Local text extraction from scanned invoices and receipts.
-Ollama:Local model runtime for AI-powered extraction and normalization.
-Llama 3.2:The initial open-weight model choice for structured extraction experiments.
-SQLite:Local persistence for invoice records and bookkeeping data.

Document-processing workflow

1.The user uploads an invoice or receipt.
2.The backend validates the file and extracts its text using the appropriate PDF text-extraction or OCR method.
3.The extracted text is passed to the locally running Ollama model.
4.The model produces structured fields such as vendor name, invoice number, date, taxable value, tax amounts, and total.
5.Validation logic checks required fields and arithmetic consistency.
6.The user reviews the extracted values before relying on them for bookkeeping.

AI-extracted values are treated as suggestions that require review, not as automatically verified accounting or tax facts.

Why Does Open Innovation Matter?

For financial software, privacy is a product feature—not just a technical detail.

Invoices and receipts can contain client identities, addresses, transaction details, and other commercially sensitive information. A local-first architecture gives users more control over where those documents are processed.

Open-weight models and local inference make several things possible:

-Privacy and control: Financial documents can remain on the user's machine.
-Offline capability: Once dependencies and model weights are installed, core inference can run without an internet connection.
-Model flexibility: Developers can experiment with different models without redesigning the entire application.
-Lower recurring inference costs: Local inference avoids per-request charges from a hosted model API, although hardware, electricity, maintenance, and support still have costs.
-*Transparency and experimentation: Developers can inspect the workflow, write tests, change prompts, and improve extraction for their own document formats.

A closed API could also provide excellent extraction quality, but it would introduce a different privacy and infrastructure trade-off. For this project, open innovation makes it practical to build a bookkeeping assistant that users can control, inspect, and run locally.

What I Learned

This project reinforced an important lesson: building an AI-powered product is not just about getting a model to generate a response.

The real challenge is turning unstructured documents into reliable, reviewable business records. OCR quality, structured output, numerical validation, error handling, and a clear user interface all matter.

For accounting-related workflows, the model should assist with extraction—not replace verification.

What's Next?

My next priorities are:

Improve extraction accuracy on real-world invoice layouts.
Add duplicate detection and confidence indicators.
Expand Excel and CSV export options.
Add automated tests for OCR, extraction, and tax arithmetic.
Improve the first-run setup experience for non-technical users.
Benchmark different open-weight models on the same invoice dataset.

The goal is to make LocalBooks AI useful enough that a freelancer or small business can save time on routine bookkeeping without giving up control of their financial data.

Conclusion

LocalBooks AI explores a practical use of open-source AI: helping small businesses organize their finances with local inference, flexible models, and a privacy-first workflow.

I built it for a simple reason: **small businesses deserve useful AI tools without having to send every financial document to someone else's server.

I'm looking forward to improving the project and learning from the open-source community.

Hacktoberfest #OpenSourceAI #LocalAI #Ollama #SideHustle

LocalLedger AI: Your Local AI Financial Assistant

Piyush kumar — Sun, 04 Oct 2026 19:12:09 +0000

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

What I Built

For this challenge, I wanted to build something that could actually be useful to someone I know instead of making another general-purpose AI chatbot.
The person I had in mind works with business transactions and often has to go through Excel files to understand where money is coming from and where it is being spent.
The problem is simple, but it takes a lot of time.
You have a spreadsheet with hundreds of transactions, and then you start asking questions like:
"Why did my expenses increase this month?"

"Where am I spending the most money?"

"Which transactions should I take a closer look at?"

So I built LocalLedger AI.
It is a small-business finance assistant where you can upload a CSV or Excel file and get useful financial insights from it.
It can show:

Total income
Total expenses
Net cash flow
Monthly trends
Expense categories
Large or unusual transactions
Month-to-month changes But the part I was most interested in building was "Ask My Business." Instead of manually going through the spreadsheet, you can simply ask: "Why did my expenses increase this month?"

The application analyzes the actual transaction data and explains what changed.

Demo

https://drive.google.com/file/d/1_2WqyBjR_yyFeZ21ZKznKt6t6KWZ3YKx/view?usp=drive_link

Code

https://github.com/piyushkr1155/Finance-Assistant

How I Built It

The project is built using:

Next.js + TypeScript for the frontend
Tailwind CSS for the interface
Recharts for charts
FastAPI for the backend
Python + Pandas for processing financial data
OpenPyXL for Excel files
Ollama for running the AI locally
An open-weight LLM for understanding and explaining the financial data The basic flow looks like this: Excel / CSV ↓ Next.js ↓ FastAPI ↓ Pandas ↓ Financial Analysis ↓ AI Context Builder ↓ Local Open-Weight LLM ↓ AI Explanation ↓ Dashboard One thing I was careful about was not letting the AI calculate everything itself.

Why Does Open Innovation Matter?

This was one of the most interesting parts of the project for me.
Financial data is sensitive.
If someone is uploading their business transactions to an AI assistant, they may not want that information automatically sent to an external AI service.
That's why I wanted the AI part of LocalLedger to run locally using an open-weight model through Ollama.
This means the project can use local AI without depending on a closed AI API for its main intelligence.
It also means developers can experiment with different models and improve the application without rebuilding the whole project.
For me, open innovation isn't just about using something because it's open source.
It actually fits the problem.
The more control the user has over where their financial data goes, the better.

My Agent Session

I used AI-assisted development throughout the project to help with planning the architecture, implementing features, debugging issues, writing tests, and improving the overall user experience.
I built LocalLedger AI step by step with the help of Antigravity, using AI assistance as part of the development workflow rather than simply generating a finished application in one go.

Prize Categories

I am submitting LocalLedger AI for the Overall Winner category.
The project uses Ollama with open-weight local models such as Llama 3.2 1B and Qwen 2.5 1.5B for local financial analysis and grounded natural-language explanations.
I am not claiming a partner category that requires a technology that is not actually used in the project.

New to community

Piyush kumar — Sat, 03 Oct 2026 05:31:09 +0000

Hello everyone....