DEV Community: Deepanshu Tanwar

👻 Ghost in the Terminal: What If a Forgotten Computer Could Talk?

Deepanshu Tanwar — Wed, 28 Oct 2026 11:49:00 +0000

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

👻 Ghost in the Terminal: What If a Forgotten Computer Could Talk?

Have you ever wondered what would happen if an old computer, left alone for years, suddenly started talking?

That idea inspired me to build Ghost in the Terminal, a small AI-powered project that brings a fictional forgotten machine to life.

I wanted to create something that was more than just another chatbot. I wanted the experience to feel a little mysterious, like opening an old terminal and discovering that something is still running inside it.

So I built a dark, terminal-inspired web app where you can talk to a ghost, generate forgotten memories, and summon mysterious messages.

And yes, you can try it yourself! 👻

What I Built

Ghost in the Terminal is an interactive AI experience built with Python and Streamlit, powered by the open-weight openai/gpt-oss-20b language model through Groq-hosted inference.

The app has three main features:

👻 Haunted Chat: Talk to a fictional computer ghost. Ask questions, start a conversation, or explore the mystery of an abandoned machine.
📜 Forgotten Memories: Generate spooky stories about forgotten computers, lost programs, mysterious memories, and machines left behind.
🔮 Random Séance: Summon a mysterious message with a single click.

I also created a dark interface to match the atmosphere of the project.

My interpretation of the Ghost in the Machine theme was simple: what if a machine could tell stories about the things it had supposedly forgotten?

The result is a small experiment that combines AI, imagination, and a little digital horror.

Demo

You can try the live application here:

👻 Launch Ghost in the Terminal

The app is deployed online, and I've tested the three main features.

Open it, start a conversation with the ghost, generate a forgotten memory, or try your luck with the Random Séance.

Just remember: the machine might have something to say. 🕯️

Code

The complete project source code is available on GitHub:

💻 View Ghost in the Terminal on GitHub

The repository includes the application code, dependencies, and setup instructions so other developers can explore the project and run their own version.

If you try it or have ideas for making it better, I'd love to hear your thoughts!

How I Built It

I built this project using tools that make experimenting with AI accessible without needing a powerful computer.

Here's the technology behind it:

Python: The main programming language used for the application logic.
Streamlit: Used to build the interactive web interface.
Groq Python SDK: Connects the application to the hosted inference service.
openai/gpt-oss-20b: The open-weight language model that generates the ghost's responses, stories, and mysterious messages.
Streamlit Community Cloud: Used to deploy the application so people can try it online.

One important detail is that the model does not run locally on my computer. The app sends prompts to Groq's hosted inference service, which generates the responses.

This made it possible to build and deploy an AI-powered experience without requiring a dedicated GPU.

The most interesting part was bringing the different features together into one experience. I wanted the app to feel like interacting with a character rather than simply entering prompts into a generic chatbot.

Why Does Open Innovation Matter?

For me, open innovation is about making it easier for more people to experiment, learn, build, and share.

You shouldn't need an expensive computer or a large development team to start exploring AI ideas.

Using an open-weight model gave me the opportunity to build a creative application around a model whose weights are publicly available under its applicable license. Python and Streamlit helped me turn that idea into something interactive, while hosted inference made it possible to run without powerful local hardware.

It also means other developers can inspect the application code, learn from the implementation, and experiment with their own ideas.

There are still limitations. The application needs an internet connection, depends on the inference provider's availability and usage limits, and doesn't run entirely offline. Open-weight models also have their own licenses and terms that developers need to understand.

But I think that's part of the point: accessible tools give people a starting point. What they create with those tools is up to them.

A small project can still be a meaningful way to learn, experiment, and share something with the community.

The Spirit of It 👻

The idea behind this project is that an abandoned machine might not be as silent as it appears.

Imagine sitting in a dark room, opening an old terminal, and typing a simple question.

Instead of an error message, a reply appears.

Maybe it's a forgotten memory. Maybe it's a story about a program that no longer exists. Or maybe it's just a language model doing what it does best.

I like the space between those possibilities. It gives a familiar piece of technology a little mystery and makes an ordinary interaction feel like the beginning of a story.

That was the feeling I wanted to capture with Ghost in the Terminal.

The project is still a small experiment, but it was exciting to take an idea from a concept to a working application that people can try online.

And who knows? Maybe the ghost has more stories to tell.

Prize Categories

I'm submitting Ghost in the Terminal to the Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine.

My project explores creative use of an open-weight language model to build an interactive AI experience.

Thanks to the organizers and everyone in the community making opportunities like this possible. Building this project has been a great way to experiment with AI and turn a spooky idea into something real.

If you've tried the app, let me know what you would ask a forgotten computer! 👻

🦥 I Built SlothBuddy AI on My Old Laptop — A Little Help With Everyday Tasks

Deepanshu Tanwar — Sun, 25 Oct 2026 15:21:52 +0000

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

What I Built

I built SlothBuddy AI, a simple tool that helps you organize your to-do list without feeling overwhelmed by it.

Sometimes, I have so many things to do that deciding where to start becomes a task of its own. That's the problem I wanted to work on.

With SlothBuddy, you enter your tasks, click a button, and let AI help organize them into three groups: Urgent, Important, and Can Wait. It also suggests a small first step to help you get going.

The idea behind it is pretty simple: you don't always need to work faster. Sometimes, you just need a clearer plan.

Demo

Give SlothBuddy a try!

👉 Live app: https://slothbuddy-gzoagvjdmx8yjsjwyje8av.streamlit.app/

Enter a few tasks and click Organize My Tasks to see it in action.

Code

💻GitHub repository:https://github.com/codelift338-dev/SlothBuddy

Feel free to check out the code!

How I Built It

I built this project using Python, Streamlit, and Hugging Face Inference Providers.

One thing that influenced how I built it was my hardware. I'm working with an older Dell laptop with a Pentium processor and 8 GB of RAM, so running a large AI model locally wasn't a realistic option for me.

Instead, I used a hosted AI model through Hugging Face. This let me build an AI-powered application without needing to download a huge model or upgrade my laptop.

Streamlit helped me turn the Python code into a simple web app, and I used GitHub to store and share the project. I also learned how to deploy the app and configure its dependencies so it could run online.

Getting everything working took a bit of troubleshooting, especially during deployment, but solving those issues was part of the learning experience.

Why Does Open Innovation Matter?

For me, open innovation means having the opportunity to build something useful with the tools and resources already available to you.

I don't have a powerful development machine, but that didn't stop me from experimenting with AI. Open-source tools and access to models through Hugging Face made this project possible for me.

I could focus on building something practical instead of worrying about expensive hardware or setting up a large model locally.

That's what I like about this ecosystem: you can start small, learn as you go, and keep improving your project.

SlothBuddy currently uses hosted inference, so it needs an internet connection. The tasks entered into the app are sent to the AI service for processing.

The Lazy Payoff

SlothBuddy is about making the first step easier.

Instead of spending time manually sorting a long to-do list, you can get an AI-generated plan in a few seconds. You still decide what matters most, but at least you have somewhere to start.

I haven't measured exactly how much time it saves, so I won't make up a number. For me, the useful part is turning a messy list into something that feels more manageable.

Because sometimes, being a little lazy just means finding a smarter way to get started. 🦥

This was a great learning experience for me, from building the first version to getting it deployed online. It's a small project, but I'm happy to have taken it from an idea to a working application.

Thanks for checking it out!

hf26challenge #Hacktoberfest #Python #AI #OpenSource

🌱 I Built an AI That Tells You to Stop Using AI

Deepanshu Tanwar — Tue, 06 Oct 2026 09:17:26 +0000

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

🌱 TouchGrass AI: An AI That Tells You to Stop Using AI

What if the best thing an AI could do was tell you to put your screen away?

That's the idea behind TouchGrass AI, a lightweight local AI-powered outdoor companion I built for Hacktoberfest 2026 Week 1.

The goal is simple:

Use AI for a few seconds. Get a mission. Put the screen away. Go outside.

No endless chatbot conversation. No account required. No cloud database.

Just a small push to spend some time in the real world.

What I Built

TouchGrass AI generates short outdoor missions based on the activity you choose and the amount of time you have.

You can choose activities such as walking, exploring, gardening, birdwatching, or nature photography.

🏠 The Home Screen

The user chooses an activity and how much time they have.

🌳 The AI-Generated Mission

For example, a 10-minute walking mission can give the user:

10-Minute Walking Mission

Go outside and spend 10 minutes exploring.

Notice three things you normally overlook.

Spend one quiet minute listening to your surroundings.

The important part is that the AI interaction is intentionally short.

The screen should be the shortest part of the experience.

⏱️ The Outdoor Session

The user can start the mission and put the screen away while spending time outside.

💭 Reflection

After completing the mission, the user can record what they noticed or experienced.

📖 Local History

Previous missions and reflections can be viewed locally.

I also tested the app outside myself, and I found it useful as a small push to spend time with nature.

The AI doesn't need to produce something complicated.

A simple activity and a specific amount of time can be enough to turn:

"I should go outside."

into:

"Okay, I'll spend the next 10 minutes outside."

Demo

🎥 Watch the full demo video:

https://drive.google.com/file/d/1A2MAGD9iCRS_q-vSq14IhM0CTXtGfRtZ/view?usp=sharing

The demo shows the complete flow:

Choose activity
↓
Choose available time
↓
Generate outdoor mission
↓
Start outdoor session
↓
Go outside 🌳
↓
Return
↓
Write reflection
↓
View local history

Code

The complete project is open source on GitHub:

https://github.com/codelift338-dev/touchgrass-ai

The repository contains:

Flask backend

Frontend

Requirements

README

Git configuration

The GGUF model itself isn't committed because the model file is hundreds of megabytes. It is downloaded separately and loaded locally by llama.cpp.

How I Built It

The most important design decision was making open-source/local AI the core of the application, rather than simply connecting a closed AI API.

The main technology stack is:

Qwen 2.5 0.5B Instruct — open-weight language model

GGUF quantization — lightweight model format

llama.cpp — local inference

Python

Flask

HTML/CSS/JavaScript

Browser localStorage — local reflections and history

The architecture looks like this:

User
│
▼
TouchGrass AI Web App
│
▼
Flask Backend
│
▼
llama.cpp
│
▼
Qwen 2.5 0.5B
│
▼
Outdoor Mission
│
▼
Go Outside 🌳
│
▼
Local Reflection

I built and tested the project on a fairly modest Windows computer:

8 GB RAM

Intel Pentium 2.16 GHz

Intel HD Graphics

Because the computer doesn't have a dedicated GPU, I chose a very small quantized model instead of trying to run a much larger local model.

That turned out to be a good fit.

TouchGrass AI doesn't need to write an essay or solve a complicated problem.

It just needs to give someone a useful reason to step outside.

Why Does Open Innovation Matter?

This is where local open-source AI made a real difference.

I could have built TouchGrass AI around a hosted AI API, but I wanted the application to be more independent and privacy-friendly.

🔒 Privacy

Outdoor reflections can be personal.

TouchGrass AI doesn't require an account or cloud database.

The reflection and mission history are stored locally in the browser.

💻 Local Control

The AI runs on the user's own computer through llama.cpp.

The application isn't dependent on a proprietary AI service for every generation.

💰 No Per-Request API Cost

Once the local model is downloaded, inference happens on the user's machine.

There isn't a cloud AI API charge for every outdoor mission.

🔄 Model Choice

Because the application uses a local GGUF model, the model can be replaced or upgraded without rebuilding the entire application around a closed provider.

🪶 Lightweight AI

Open-weight models made it possible for me to experiment with local AI even on modest hardware.

That was particularly important because I built this project on an 8 GB RAM machine with an Intel Pentium processor and integrated graphics.

The Part I Like Most

There is a funny contradiction at the heart of this project.

I'm using AI to tell people to stop using their screens.

But that's exactly the point.

I don't want TouchGrass AI to become another application that demands attention.

The ideal interaction is:

Open app
↓
Get mission
↓
Put screen away
↓
Go outside
↓
Experience something
↓
Come back
↓
Reflect

The AI should disappear as quickly as possible.

The model provides the suggestion. Nature provides the experience.

What's Next?

There are several things I could add:

Weather-aware outdoor missions

Seasonal activities

Local nature suggestions

More outdoor activity categories

Difficulty levels

Printable outdoor mission cards

Better offline-first support

Support for additional lightweight local models

But I want to keep the core idea simple.

The goal isn't to build another platform that keeps people staring at a screen.

The goal is to make the screen useful for a moment — and then help someone leave it behind.

🏆 Hacktoberfest 2026 — Week 1: Touch Grass

This project was built for Hacktoberfest 2026 Week 1: Touch Grass.

The challenge asks participants to build something with open-source AI at its core that encourages people to get outside.

TouchGrass AI is my attempt to do exactly that:

Build an AI that helps you spend less time with AI. 🌱

StudyMate: An AI Study Companion Built for a Friend 📚

Deepanshu Tanwar — Sat, 03 Oct 2026 21:34:38 +0000

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

What I Built

I built StudyMate, an AI-powered study companion for my college friend who studies Computer Science/Engineering and has trouble studying from long notes and preparing for exams.

The idea was simple: take long technical study notes and turn them into easier-to-use revision material.

StudyMate has four main features:

📝 Summarize — turns long notes into concise revision notes.

💡 Explain — explains difficult concepts in simpler language.

❓ Quiz Me — generates practice questions for exam preparation.

🃏 Flashcards — creates question-and-answer flashcards for revision.

I wanted to build something small and practical that could help my friend spend less time going through long notes and more time actually revising.

Demo

🌐 Live Demo: https://studymate-bhrreds3idz6bs3nqkrcga.streamlit.app/

🎥 Demo Video: https://drive.google.com/file/d/1S9J_Cp9t6Xkvg9uYXDQCVnh2_01c1L2a/view?usp=drive_link

The demo video shows all four StudyMate features working.

Code

💻 GitHub Repository: https://github.com/codelift338-dev/StudyMate

The repository contains the source code, README, and requirements needed to run the project.

How I Built It

StudyMate is built using:

Python

Streamlit

Hugging Face Inference

google/gemma-3-4b-it

The core flow is:

Study Notes
↓
StudyMate
↓
Task-specific prompt
↓
Gemma 3 4B
↓
Summary / Explanation / Quiz / Flashcards

Each feature uses a task-specific prompt designed for that particular study activity.

For example, the summarization feature asks the model to identify important concepts, definitions, and exam-relevant information. The quiz feature generates practice questions, while the flashcard feature converts important concepts into question-and-answer pairs.

I built and tested the application on a Dell Inspiron laptop with limited hardware. Instead of trying to run a modern language model locally, I used Hugging Face inference so that I could build the application around Gemma without requiring a powerful GPU.

Why Does Open Innovation Matter?

The core intelligence of StudyMate is based on an open-weight AI model rather than being designed specifically around a proprietary closed model.

Using an open-weight model gives the project flexibility. The model can potentially be swapped or experimented with as the application evolves without redesigning the entire application around one proprietary AI provider.

For this project, open AI also helped with the hardware limitations of my laptop. I could build an application around Gemma and use Hugging Face inference instead of requiring expensive local AI hardware.

The current version is not an offline application, because AI inference is performed through Hugging Face.

However, using an open-weight model gives me the opportunity to experiment with different models and deployment approaches in the future, including local inference with a suitable smaller model.

My Agent Session

DevRelay was used during the development setup, but I currently don't have a saved DevRelay agent session to embed.

The project source code and development work are available in the GitHub repository.

Prize Categories

Best Use of Gemma

StudyMate uses google/gemma-3-4b-it as the core AI model powering its summarization, explanation, quiz, and flashcard features.

🚀 Hello, World!

Deepanshu Tanwar — Thu, 01 Oct 2026 14:58:38 +0000

Excited to start my journey as a developer! 👨‍💻

I’ll be sharing what I learn, the projects I build, challenges I face, and everything in between.

Here’s to learning, building, and improving one line of code at a time. 💻✨

Developer #Coding #100DaysOfCode #LearningInPublic #TechJourney