DEV Community: Dhinesh Babu G

GHOST.exe: I Built an AI Horror Game Where Evidence Matters More Than AI

Dhinesh Babu G — Tue, 27 Oct 2026 05:10:33 +0000

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

👻 GHOST.exe — The Machine That Remembers

The system says it shut down. The logs say otherwise. Something remembers.

What if an abandoned computer system remembered something that never happened?

What if its records contradicted each other, and an AI investigator tried to explain the mystery?

Would you trust the machine?

I built GHOST.exe, an offline-first, AI-assisted horror investigation game, for Hacktoberfest 2026 Week 4: Ghost in the Machine.

What I Built

GHOST.exe turns a fictional abandoned computer system into an interactive mystery. Players investigate corrupted records, timestamps, memory fragments, and conflicting evidence to uncover what might have happened.

The central mystery begins with two conflicting records: a shutdown notice at 02:14 and another record indicating activity at 02:19.

Did the shutdown complete? Was the system still running? Or is something missing from the evidence?

Players discover artifacts, make investigation choices, and develop theories. The mystery unfolds through evidence rather than a simple chatbot conversation.

🧠 An AI Investigator That Cannot Decide the Truth

My biggest challenge was ensuring that the AI did not invent facts or confidently claim more than the evidence established.

An earlier version could overstate conclusions and reference clues the player had not discovered. That undermined the investigation: a mystery stops being meaningful if the AI can simply make up its answer.

I redesigned the investigator around one principle:

The AI can help interpret the mystery, but the evidence engine controls what the game can claim.

The improved design:

Gives the investigator only artifacts the player has discovered.
Maintains canonical facts, hypotheses, contradictions, and unresolved questions in the deterministic evidence engine.
Validates model-returned identifiers against the expected evidence classifications.
Rejects unsupported references and classifications.
Builds the displayed report from canonical source data instead of displaying unrestricted model-generated prose.
Preserves uncertainty when records conflict.

Structured output alone doesn't guarantee truth. A model can produce valid-looking data and still make unsupported claims. GHOST.exe separates model interpretation from the trusted evidence used to construct its report.

Demo

🎬 Watch GHOST.exe in action:

The demo shows my actual project in action.

🔗 GitHub repository: https://github.com/dhinesh-babu-7/GHOST.exe

Code

The project is open source:

👉 https://github.com/dhinesh-babu-7/GHOST.exe

The repository includes:

app.py — Streamlit application and interface
engine/ — investigation logic and evidence handling
ai/local_model.py — local AI integration and report validation
data/ — fictional story and artifact data
tests/ — automated regression tests
assets/ — project audio asset

The latest reported test run passed 23 tests, including regression coverage for unsupported facts, hidden artifact references, and incorrect contradiction classifications.

How I Built It

I built GHOST.exe using:

Python for the core application and investigation logic
Streamlit for the interactive interface
SQLite for persistent investigation state
Ollama for optional local language-model inference
Qwen2.5:3B as the local model I used during development
pytest for automated testing

The game is designed to remain playable without the local AI model, so the core investigation does not depend entirely on AI availability.

The architecture

The evidence engine owns the canonical classifications. The local model helps interpret the discovered evidence, but its response must satisfy validation rules before a report is displayed.

This separation makes it possible to have an AI-assisted mystery without letting generated prose silently rewrite the game's facts.

I also added regression tests for cases where the investigator might refer to hidden artifacts, make unsupported claims, or misclassify contradictions.

The result is not a claim that AI can never be wrong. It is a design that limits which generated outputs are allowed to influence the player's understanding of the mystery.

Why Does Open Innovation Matter?

Open innovation allowed me to build an AI-powered experience without making a proprietary cloud AI API the foundation of the project.

Open-source tools gave me the freedom to experiment with local inference, inspect the application architecture, and decide how the model interacts with the evidence engine.

Using a local model also made offline-first operation possible. The core mystery can still be investigated when the model is unavailable.

Just as importantly, an open repository lets other developers inspect the implementation, run the tests, challenge my design decisions, and suggest improvements.

For me, open innovation is not only about using free tools. It is about making the work accessible so that others can learn from it, question it, and build on it.

My Agent Session

I used an AI coding assistant during development to help debug the application, investigate test failures, and improve the evidence-grounding design.

I have not included a public DevRelay agent-session link in this submission. This section can be updated if I publish a shareable session.

The Spirit of It

The unsettling part of GHOST.exe isn't simply that a machine might be haunted.

It's that the machine can produce records that look convincing even when those records don't agree.

That idea influenced both the story and the engineering. I wanted the investigator to help the player explore possibilities without pretending that uncertainty had disappeared.

A contradiction is not automatically proof of a cover-up. A timestamp is not a complete explanation. And a confident AI answer is not necessarily a correct one.

Sometimes, the most disturbing answer is the one the evidence cannot yet establish.

The machine remembers. The records disagree. The investigation isn't over.

Prize Categories

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

I will select and list any applicable partner prize categories according to the official challenge rules before publishing the final submission.

Thanks for checking out GHOST.exe! 👻

I'd love feedback on the evidence-grounding approach, the local-first architecture, and ideas for making the investigation more unsettling while keeping its logic consistent.

🔗 GitHub: https://github.com/dhinesh-babu-7/GHOST.exe

🎬 Demo: https://youtu.be/Lh93jFLQqG8

Hacktoberfest #OpenSource #AI #Python #Ollama #Streamlit #GhostInTheMachine

We Came to Hacktoberfest and Accidentally Became Workday's Marketing Team 💀😂

Dhinesh Babu G — Sat, 24 Oct 2026 17:13:07 +0000

POV: You attend a Hacktoberfest meetup and accidentally become Workday's unofficial marketing team. 😭

We don't work at Workday… we just work the logo. 😂🏢

📸 Three developers. One giant logo. Absolutely zero Workday code written.

Had an amazing time at Hacktoberfest Meetup Chennai × OS Community & Sapiens Campus on October 24, 2026! 🚀

Beyond this legendary photo, it was a great opportunity to meet fellow developers, connect with the open-source community, and share our passion for building things.

Huge thanks to everyone who organized the meetup and everyone who showed up and made it memorable! ❤️

Special appreciation to the communities behind Hacktoberfest and open source:

Major League Hacking (MLH)

Hacktoberfest and DEV Community

OS Community and Sapiens Campus

Workday

Important question: Should we apply for Workday internships using this photo as our unofficial portfolio? 💀😂

If you attended the meetup, drop a comment! And if you recognize the three unofficial Workday ambassadors, say hello. 👋

Let's get this photo more views than our first production bug. 🚀😂

hacktoberfest #opensource #devchallenge #webdev

LazyDesk AI: A Local AI File Organizer That Keeps Things Simple

Dhinesh Babu G — Fri, 23 Oct 2026 05:52:15 +0000

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

What I Built

Meet LazyDesk AI 🦥 — a simple, AI-powered file organizer designed to reduce the small, repetitive tasks that create digital clutter.

We all download files, save college notes, collect code snippets, and forget to organize them later. Eventually, finding one file becomes a task of its own.

LazyDesk AI helps by scanning a selected folder, suggesting a category for each file, and organizing files into category folders.

It supports categories such as:

📄 Documents
🖼️ Images
🎬 Videos
🎵 Audio
💻 Code
📊 Spreadsheets
📽️ Presentations
📦 Archives
📁 Other

The best part? The user stays in control. You can review and edit the suggested categories before confirming the organization. The app also avoids overwriting files when destination filenames already exist.

The goal isn't to automate everything blindly. It's to make an everyday task simpler while keeping the final decision with the user.

Demo

The project currently runs locally on my computer.

To try it, follow the setup instructions in the repository:

Run LazyDesk AI locally

The repository README includes an application screenshot. A deployed web demo is not currently available because the application uses a locally running Ollama model.

🎥 Watch the LazyDesk AI Demo: View on YouTube

The demo shows LazyDesk AI scanning sample files, suggesting categories using a local AI model, and organizing files into folders after user confirmation.

Code

🔗 GitHub repository: https://github.com/dhinesh-babu-7/LazyDesk-AI

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

Explore the source code, try the project, and share ideas for improvement!

How I Built It

I built LazyDesk AI using a small, practical technology stack:

Python — file handling and application logic.
Streamlit — the interactive user interface.
Ollama — local inference for the AI model.
Qwen 2.5 3B — an open-weight language model used for file-category suggestions.

The workflow is straightforward:

The user selects a folder.
The application scans files directly inside that folder.
The AI receives filenames and suggests categories.
The user reviews and edits the suggestions.
The user confirms the plan, and the application moves files into category folders.

I also added an extension-based fallback so that familiar file types can still be categorized if the local model is unavailable or returns an unexpected answer.

One important design decision was to keep file contents out of the AI prompt. The model receives filenames rather than the contents of documents, which helps limit what is shared with the inference process.

This is an early version, and there is still room to improve its classification accuracy, interface, and testing.

Why Does Open Innovation Matter?

Open innovation made this project possible with tools I could run and experiment with on my own computer.

Using an open-weight model through Ollama gave me a way to explore AI without building the application around a paid, hosted inference API.

It also helped me learn more about how AI fits into a real application: model responses need validation, fallback logic matters, and users should be able to review automated decisions.

For a student developer, being able to experiment locally, inspect the code, and share the project publicly makes learning more accessible.

Open innovation isn't just about using free tools. It's about having the freedom to learn, modify, experiment, and build on existing work.

The Lazy Payoff

LazyDesk AI focuses on reducing the effort involved in sorting files manually.

I haven't measured a reliable time saving yet, so I won't claim a specific number. The current version demonstrates the workflow, and the next step is to test it with a larger collection of files and compare the time taken against manual organization.

I'd also like to make it useful for students who regularly download lecture notes, assignments, datasets, and programming files.

The idea behind “Slow and Steady” is simple: start with one repetitive task, make it safer and easier, and improve it step by step.

Prize Categories

I'm entering the overall Hacktoberfest Open-Source AI Challenge: Week 3 competition. LazyDesk AI uses local inference with Ollama and the open-weight Qwen 2.5 3B model. I'm not claiming a partner-specific prize category.

LazyDesk AI explores local AI inference and practical automation using open-weight models.

I'll select the applicable prize categories from the official challenge page before submitting.

Built with Python, Streamlit, Ollama, and Qwen 2.5 3B.

Less file chaos. More time for what matters. 🦥

hacktoberfest #devchallenge #opensource #ai #python

OpenStudy AI: A Study Companion Built with AI 📚

Dhinesh Babu G — Fri, 16 Oct 2026 08:56:00 +0000

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

What I Built

OpenStudy AI — Your AI-Powered Study Companion 📚

OpenStudy AI is a web-based study assistant designed to help students understand difficult concepts, prepare for exams, and revise topics.

Students can choose how they want a topic explained instead of receiving only one style of answer.

Current features:

Simple Explanation: Understand concepts in beginner-friendly language.
Exam Answer: Generate structured, exam-oriented responses.
Step-by-Step: Break a problem into manageable steps.
Quick Summary: Create concise revision notes.
AI Question Answering: Ask study questions and receive AI-generated responses.

Who could pay for it?

School students, college students, and independent learners who need affordable academic support could benefit from OpenStudy AI. In the future, it could offer personalized revision plans, quizzes, and other premium learning tools.

This is currently a student-built prototype. I am looking for feedback from real users to improve it.

Demo

🎥 Demo Video: [Watch OpenStudy AI in action]https://youtu.be/CcKaaNCAkCg

💻 GitHub Repository: https://github.com/dhinesh-babu-7/OpenStudy-AI

Live demo: The application currently runs locally and is not yet publicly deployed.

Code

The source code for OpenStudy AI is available on GitHub:

https://github.com/dhinesh-babu-7/OpenStudy-AI

The project uses a React and Vite frontend with a Node.js and Express backend.

How I Built It

I built OpenStudy AI using:

React + Vite for the frontend.
Node.js + Express for the backend.
OpenRouter to access a hosted AI model.
Git and GitHub for version control and source-code hosting.

When a student submits a question and selects a study mode, the frontend sends the request to the backend. The backend communicates with the configured AI model and returns the generated answer.

I built this project to learn how to integrate AI into a practical web application while keeping API credentials on the server rather than exposing them in the frontend.

AI model: NVIDIA Nemotron 3 Super, accessed through OpenRouter using nvidia/nemotron-3-super-120b-a12b:free.

The model is open-weight and is released under the NVIDIA Nemotron Open Model License. I chose it to make the AI component of OpenStudy AI more transparent and to explore the use of open models in affordable educational tools.

The application currently uses hosted inference through OpenRouter; it does not run the model locally. The free endpoint may have usage limits, and I will need to review the model license and provider terms as the project develops.

Model information: https://openrouter.ai/nvidia/nemotron-3-super-120b-a12b:free

Why Does Open Innovation Matter?

Open innovation gives student developers opportunities to experiment, learn, and build useful tools without needing to train a large AI model from scratch.

For OpenStudy AI, accessible development tools and AI infrastructure helped me turn an idea into a working prototype. Open-source frameworks also made it possible to build and connect the frontend, backend, and AI integration.

My next goal is to explore model customization, compare open models, and investigate the possibility of local inference.

I believe useful learning tools should become more accessible to students. By building and improving projects in public, developers can share what they learn and benefit from feedback from the wider community.

My next goals are to explore:

AI-generated quizzes and revision flashcards.
Personalized study plans.
Asking questions about uploaded study notes.
Feedback from students who try the application.
An open-weight AI model that fits the project's needs.

OpenStudy AI is my first step toward building a practical study companion that students can use in their everyday learning.

devchallenge #hf26challenge #Hacktoberfest #OpenSource #AI #WebDev