DEV Community: Gobala krishnan

Echoes After Midnight: An AI Ghost That Lives Inside Your Computer

Gobala krishnan — Tue, 27 Oct 2026 17:41:30 +0000

Echoes After Midnight: An AI Ghost That Lives Inside Your Computer

What if the computer you are investigating is also the thing hiding the truth?

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

What I Built

Echoes After Midnight is a concept for a local-first, AI-powered paranormal investigation game.

Imagine discovering an abandoned computer containing corrupted logs, forgotten notes, mysterious timestamps, and messages that should not exist. Something happened here. The machine remembers fragments of it, but those fragments do not tell the whole story.

Your mission is to investigate.

Unlike a traditional choose-your-own-adventure game, Echoes After Midnight is designed to let players question an AI character, inspect evidence, connect clues, and develop their own theories about a mysterious incident.

The AI takes on the role of the machine's digital presence. It will help players investigate the evidence, respond to questions, and gradually uncover the story behind the haunting.

The central idea is simple: what if the ghost wasn't in a haunted house, but inside a computer?

I interpreted the Ghost in the Machine theme as both a Halloween mystery and an exploration of how technology can preserve traces of the past.

Demo

🚧 Coming soon!

I'm working on the initial version of Echoes After Midnight. A live demo and project walkthrough will be shared as development progresses.

Code

💻 GitHub repository coming soon!

The source code, setup instructions, and implementation details will be published on GitHub once the initial version is ready.

How I Built It

The project is planned around a React and Vite frontend, a Python backend using FastAPI, and a local AI runtime using Ollama with a compatible open-weight language model.

The interface will use a retro terminal aesthetic, with phosphor-green text, dark backgrounds, subtle glitch effects, and atmospheric animations to create the feeling of exploring a forgotten machine.

The backend is intended to manage the investigation, evidence archive, and interactions with the local AI model.

Rather than relying on a hosted AI API, the goal is to run inference locally so that the core investigation can work without sending conversations to a remote AI provider.

The initial version will focus on one mystery, with a collection of fictional evidence files, clues, and multiple possible endings.

These are the planned technologies and features; implementation details will be updated to reflect the working project.

Why Does Open Innovation Matter?

For this project, open innovation is about more than choosing a different AI model. It is about giving developers and users greater control over how AI works and where their data goes.

1. Local-first AI

Running a compatible open-weight model locally can allow the investigation to continue without sending prompts to a remote AI service. After the model and dependencies are downloaded, the experience can potentially work offline.

2. Privacy and control

Investigation notes, conversations, and locally stored evidence can remain on the user's computer when the application is designed to keep processing and storage local.

3. Freedom to experiment

An open-weight model makes it possible to experiment with different model sizes, prompts, response styles, and behaviors without rebuilding the entire application around a proprietary API.

4. A project others can extend

Publishing the source code will allow other developers to explore the architecture, contribute new mysteries, improve the evidence system, and experiment with different compatible models.

A closed AI API could also generate compelling ghost stories. The difference is that this project aims to put local inference and user control at the center of the experience.

Local AI still uses hardware, memory, and electricity, but it can avoid per-request API charges and reduce dependence on a remote provider.

That trade-off is worth exploring.

The Spirit of It

Computers are full of remnants of the past: old messages, abandoned projects, forgotten photographs, and logs from programs that no longer exist.

Usually, we treat those remnants as files waiting to be deleted.

Echoes After Midnight asks a different question:

What if we could have one last conversation with the machine that remembers them?

The ghost in this story is fictional. But the underlying idea is real: open technology gives us more freedom to preserve, investigate, and reinterpret digital history without handing every piece of it to an external service.

Sometimes the most unsettling thing a computer can say is not something supernatural.

It is something you thought you had forgotten.

Built for the Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine.

🦥 LaterLobster: An AI That Does the Boring Bits While You Rest

Gobala krishnan — Wed, 21 Oct 2026 19:34:13 +0000

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

🦥 LaterLobster: An AI That Does the Boring Bits While You Rest

What I Built

Ever opened your laptop to finish one small task and somehow ended up spending an hour organizing files, rewriting notes, and figuring out what to do next?

Meet LaterLobster — a local-first AI assistant that turns digital procrastination into progress.

Instead of giving you another chatbot to talk to, LaterLobster works quietly in the background. Give it a folder of messy notes, unfinished task lists, meeting summaries, or downloaded documents, and it turns that clutter into small, actionable outcomes.

Its philosophy is simple: you shouldn't need to manage the AI. The AI should make managing life easier.

LaterLobster can:

🗂️ Tame the chaos: Analyze a folder of documents and suggest meaningful filenames, categories, and a cleaner structure.
🧩 Break down the overwhelming: Turn vague tasks like "finish my project" into small, achievable next steps.
📝 Rescue forgotten notes: Extract decisions, deadlines, and action items from meeting notes and text files.
🌙 Prepare a morning briefing: Generate a short "while you were away" report with the most useful things to tackle next.
🦥 Respect your pace: Process a few items at a time instead of demanding your attention with endless notifications.

The twist? LaterLobster doesn't try to automate your entire life. It focuses on the little things that quietly drain your time and energy.

Less digital housekeeping. More time for actual work — or absolutely nothing, if that's your plan.

Demo

Will be added soon.

Code

Will be added soon.

How I Built It

LaterLobster is designed around open-weight AI and local inference, rather than making a proprietary cloud API the heart of the application.

The technology stack

Python for the processing pipeline and orchestration.
Ollama for running an open-weight language model locally.
Qwen or another compatible open-weight instruction model for summarization, task extraction, and planning.
Streamlit for a lightweight user interface.
SQLite for storing task status and local processing history.

The final model will be selected based on its license, hardware requirements, and performance on the target machine.

How it works

Drop: The user selects a folder or imports supported text files.
Understand: The local model extracts useful information, tasks, possible deadlines, and suggested categories.
Simplify: A planner groups related tasks and proposes small next steps.
Prepare: LaterLobster creates a concise briefing and suggests file organization changes.
Approve: The user reviews proposed changes before anything is renamed, moved, or archived.

The system is designed to process files incrementally, so a large backlog doesn't have to be handled in one expensive or lengthy operation.

A key design choice is to separate AI suggestions from actual file operations. The model proposes what should happen; ordinary application code validates the proposal and performs approved changes.

The initial version focuses on local text files and Markdown documents to keep the workflow lightweight and practical.

Why Does Open Innovation Matter?

For LaterLobster, privacy isn't an optional setting. It is part of the architecture.

Personal notes, project plans, meeting summaries, and unfinished tasks can contain information people don't want uploaded to an external service.

Running an open-weight model locally offers several advantages.

1. Your files stay on your machine

When configured for local inference, the text-processing workflow doesn't need to send document contents to a hosted AI API. That makes it better suited to private notes and personal workspaces.

2. No mandatory per-request AI bill

Once the software and model are installed, inference can run on compatible local hardware without a paid inference API. Users still need suitable hardware, storage, electricity, and time.

3. The model is replaceable

Different users have different hardware and quality requirements. An adapter-based design makes it possible to experiment with different compatible models without rebuilding the entire application.

4. The automation is inspectable

The project can expose its prompts, processing rules, file-operation logic, and tests. Contributors can improve the behavior instead of treating the AI as an opaque service.

5. Offline capability

After downloading the required model and dependencies, the core workflow can be designed to work without an internet connection. Users can analyze supported local files and generate briefings without relying on a cloud AI service.

A hosted model might be more capable on some tasks. But for this project, keeping personal files local, avoiding recurring inference fees, and retaining control over the model are meaningful advantages.

Open innovation makes the tool adaptable to the user instead of forcing the user to adapt to a service.

My Agent Session

Will be added soon.

The Lazy Payoff

The real measure of success isn't how many tokens LaterLobster generates. It's how much tedious work disappears from someone's day.

The project will be evaluated by comparing the time required to manually review and organize a small folder with the time required to review LaterLobster's suggestions.

The evaluation will measure:

Time spent processing a fixed set of sample files.
Number of useful action items extracted.
Number of incorrect or irrelevant suggestions.
Number of file changes accepted by the user.
Time required to review the final briefing.

The goal is to measure actual usefulness rather than inventing time-saving claims.

The ideal experience is wonderfully uneventful: close your laptop, let the lobster work through a few things, and return to a short list of useful next steps.

No productivity guilt. No endless notifications. Just a little less chaos.

Prize Categories

Will be added soon.

Final Thought

We keep building AI that asks us to do more: more prompting, more configuration, more conversations.

LaterLobster explores a different idea.

What if useful AI meant fewer things demanding our attention?

Sometimes the smartest assistant isn't the one that works the fastest.

It's the one that quietly makes tomorrow easier.

Stay slow. Make progress. Be a lobster. 🦥🦞

My First Post on DEV: Learning, Building, and Exploring Open Source 🚀

Gobala krishnan — Fri, 16 Oct 2026 02:58:24 +0000

Hey everyone! 👋

I'm Gobala Krishnan, a Software Engineer from India.

I work with technologies like React, Java, Spring Boot, PostgreSQL, and AWS. I enjoy building web applications, solving real-world problems, and learning how software works behind the scenes.

🚀 Why I'm Joining the DEV Community

I joined DEV to connect with developers, learn from their experiences, share what I learn, and improve my skills through practical projects and open-source contributions.

💻 What I'm Exploring

I'm interested in:

Full-stack web development
Java and Spring Boot
Artificial Intelligence and AI-powered applications
Open-source projects and Hacktoberfest
Learning new tools and improving my problem-solving skills

🎯 My Goal

My goal is to keep learning, build useful projects, contribute to open source, and share my technical journey with the community.

I believe every bug fixed, every project built, and every new concept learned helps us become better developers.

I'm excited to be part of this community!

What advice would you give someone who wants to become more active in open source? I'd love to hear your thoughts.

Happy coding! 💙