DEV Community: shauryamalhotra957-wq

GhostWriter AI: Building a Local AI Horror Story Generator 👻

shauryamalhotra957-wq — Sat, 31 Oct 2026 14:11:41 +0000

GhostWriter AI: A Local AI Horror Story Generator 👻

What if you could summon a horror story directly from your terminal, powered by an open-weight AI model running on your own machine?

That's the idea behind GhostWriter AI, a command-line horror story generator I built for the Hacktoberfest 2026 Week 4 challenge: Ghost in the Machine.

👻 What is GhostWriter AI?

GhostWriter AI is a Python-based terminal application that generates horror stories from user-provided prompts.

It uses DistilGPT-2, an open-weight language model, through PyTorch and the Hugging Face ecosystem.

Instead of sending every prompt to a hosted AI API, the application loads the model locally and generates text on the user's machine.

⚙️ Features

Local AI inference using DistilGPT-2.
Six horror genres:
- Supernatural
- Psychological Horror
- Paranormal
- Cosmic Horror
- Gothic Horror
- Sci-Fi Horror
Three story lengths: short, medium, and long.
Custom prompts to guide story generation.
Save generated stories locally as text files.
Terminal interface with a horror-inspired design.

🧠 How does it work?

The application follows a simple pipeline:

The user enters a story prompt.
The user selects a horror genre.
The user chooses the desired story length.
The local language model generates text.
The generated story can be saved to the local stories directory.

The project uses Python, PyTorch, and DistilGPT-2.

🔓 Why open-source AI?

For me, the most interesting part of this project is being able to run an AI model locally.

Open-weight models make experimentation more accessible. They let developers explore inference, modify generation settings, and build applications without depending entirely on a paid hosted API.

Local inference can also help keep prompts on the user's own machine after the model has been downloaded.

This makes GhostWriter AI a small experiment in building AI-powered applications with open technology.

🖥️ Try it yourself

GitHub repository:

https://github.com/shauryamalhotra957-wq/ghostwriter-ai

Clone the repository:

git clone https://github.com/shauryamalhotra957-wq/ghostwriter-ai.git
cd ghostwriter-ai

Install dependencies:

pip install -r requirements.txt

Run the application:

python main.py

The model weights may need to be downloaded the first time you run the application.

🛠️ Built with

Python
PyTorch
DistilGPT-2
Hugging Face Transformers

🚧 What's next?

GhostWriter AI is an early prototype. Story coherence and prompt adherence are areas I want to improve.

Future plans include experimenting with better open-weight models, improving generation controls, and building a more polished interface.

Final thoughts

This project helped me explore how open-weight language models can be integrated into a practical application.

The goal was simple: build a little horror machine that lives in your terminal.

And perhaps, give it a few nightmares of its own.

Built for Hacktoberfest 2026 — Week 4: Ghost in the Machine.

devchallenge #hf26challenge #hacktoberfest #ai #python #opensource

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

What I Built

Demo

Code

How I Built It

Why Does Open Innovation Matter?

My Agent Session

The Spirit of It

Prize Categories

LogSloth: A Local-First AI Log Analysis Tool Built for Hacktoberfest

shauryamalhotra957-wq — Sat, 24 Oct 2026 16:17:41 +0000

Building LogSloth was my Week 3 Hacktoberfest challenge: a lightweight, local-first tool that turns messy application logs into a concise security-focused briefing.

Instead of manually digging through hundreds of log lines, LogSloth parses the input, identifies recognizable events, highlights suspicious activity, and presents the results in a simple Streamlit interface.

🦥 What is LogSloth?

LogSloth is a local log-analysis and security briefing application designed to make raw authentication/application logs easier to understand.

The application currently provides:

Log parsing from raw log files
Event classification
Detection of recognizable security-related events
Identification of unrecognized log lines
A summarized security briefing
A simple Streamlit UI
Local processing without requiring users to upload their logs to a third-party service

During testing, LogSloth successfully processed a sample log containing 80 total lines, identifying 66 recognizable events, 13 unrecognized lines, and 1 blank line.

🛠️ Tech Stack

Python
Streamlit
Local-first processing
Git/GitHub
Log parsing and event classification

The goal was not to build another complicated dashboard. I wanted something that could take messy logs and quickly answer the important question:

"What actually happened in these logs?"

🎥 Demo

Here is the recorded demo of LogSloth:

https://youtu.be/RBMb_O9MRAE

The video walks through the application and demonstrates the log-analysis workflow.

💻 Source Code

The complete project is available on GitHub:

https://github.com/shauryamalhotra957-wq/logsloth

The repository contains the application source code and project documentation.

🔐 Why I Built It

Logs are extremely useful for security analysis, but raw logs are often difficult to read quickly.

A useful security tool should help reduce that initial investigation effort by turning noisy input into something understandable.

LogSloth is my exploration of that idea while learning more about Python, security tooling, log processing, and building practical open-source software.

🚀 What I Learned

Working on LogSloth taught me a lot about:

Designing a useful developer-facing tool instead of just a demo
Parsing imperfect real-world input
Handling unknown/unrecognized log formats
Building a usable Streamlit interface
Structuring a project for GitHub
Testing functionality before shipping
Documenting an open-source project
Turning a Hacktoberfest challenge into a complete working project

This project is still something I want to improve, but the current version provides a working foundation for local log analysis and security-focused reporting.

🙌 Hacktoberfest

This project was built as part of my Hacktoberfest 2026 Week 3 challenge.

Thanks to the open-source community and the Hacktoberfest ecosystem for pushing me to build, ship, and contribute rather than keeping projects sitting unfinished on my machine.

devchallenge #hf26challenge

Outside Quest 🌿: Turn a 10-Minute Break into an AI-Powered Outdoor Adventure

shauryamalhotra957-wq — Fri, 09 Oct 2026 22:43:20 +0000

What I Built

When I'm coding, studying, or debugging, it's easy to spend hours looking at a screen. I wanted to build something that makes stepping outside feel less like another item on a to-do list and more like a small adventure.

That idea became Outside Quest 🌿, an AI-powered outdoor adventure generator that turns a short break into three activities you can actually go and try.

Choose an environment—campus, garden, park, or neighborhood—along with your available time, interests, and accessibility preferences. Outside Quest then generates three personalized quests, such as a sensory walk, mindful observation, nature journaling, or exploring the details of your surroundings.

The app also has an Adventure Log that tracks completed quests, outdoor minutes, and streaks in the browser without requiring an account.

The goal is simple: spend less time planning a break and more time experiencing the real world.

Demo

Try the live application: https://outside-quest.onrender.com

I deployed Outside Quest on Render and tested the public application. It successfully generated three AI-created outdoor quests from my selected preferences.

The free hosting instance can take longer to respond after periods of inactivity, so the first visit may need a little patience.

Code

GitHub repository: https://github.com/shauryamalhotra957-wq/outside-quest

The repository contains the FastAPI backend, responsive frontend, automated tests, setup instructions, environment-variable template, Render deployment configuration, and MIT license.

How I Built It

I built Outside Quest using Python, FastAPI, Pydantic, and a responsive HTML, CSS, and JavaScript frontend.

For AI generation, I chose Meta Llama 3.1 8B Instruct, an open-weight language model accessed through OpenRouter using Backboard.io's API.

The backend validates the preferences submitted by the user, sends a generation request to Backboard, and validates the returned structured content before displaying the quests. The Backboard API key stays on the server in an environment variable instead of being embedded in the frontend.

I also added error handling for API failures, timeouts, malformed responses, and missing configuration. The Adventure Log uses browser local storage so users can track completed quests without creating an account.

The project includes automated tests for input validation, API request handling, error cases, and response parsing. My latest reported test run passed all 40 tests without making live model requests.

Why Does Open Innovation Matter?

I wanted to build around an open-weight model rather than make the project dependent on a single closed model.

Using Llama 3.1 gives the project a model whose weights are publicly available under Meta's Llama Community License. The selected model can also be changed through the backend's configuration, making experimentation with alternative models possible without redesigning the entire application.

There is an important trade-off: Outside Quest does not currently run inference locally or work fully offline. It uses Backboard and OpenRouter for model access. The selected preferences—including the environment, available time, and interests—are sent to Backboard to generate quests.

The application does not request GPS coordinates or camera permissions, and it does not require a user account. I wanted to be transparent about the distinction between avoiding unnecessary personal data and running an application entirely on-device.

For this project, open-weight AI provides flexibility in model choice and experimentation, while a hosted API makes the application practical to deploy and demonstrate.

What I Learned

Building Outside Quest helped me connect a real AI model to a Python web application, validate structured model responses, handle failures from an external API, protect credentials, write automated tests, and deploy an application from GitHub to Render.

It also changed how I think about the purpose of an AI application. Not every useful product needs to maximize screen time. Sometimes the best outcome is helping someone close their laptop and go outside.

What's Next?

I'd like to improve quest personalization, evaluate the usefulness and safety of generated activities, and explore additional open-weight models.

For now, choose a quest, step outside safely, and notice something you might otherwise have missed.

🌿 Touch grass. Reclaim your day.