DEV Community: Himanshu Bhirud

👻 NecroOS — Ghost in the Machine

Himanshu Bhirud — Sat, 31 Oct 2026 16:13:38 +0000

👻 NecroOS — Ghost in the Machine: Giving Forgotten Technologies a Voice

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

What I Built

NecroOS — Ghost in the Machine is an AI-powered haunted terminal that brings forgotten programming languages and technologies back to life through interactive conversations with digital machine spirits.

I interpreted the theme Ghost in the Machine as the idea that every technology leaves behind a digital memory. Programming languages, tools, and systems that once shaped the computing world may become outdated, but their contributions are never truly forgotten.

Inspired by the gothic cyberpunk aesthetic and the cultural tradition of Día de los Muertos (Day of the Dead), I created a digital experience where users can interact with the spirits of forgotten technologies.

The application features:

👻 Haunted Terminal: An interactive terminal where users communicate with digital ghosts.
💀 Forgotten Programming Language Spirits: Meet the digital spirits of COBOL, Turbo Pascal, Flash, ALGOL 68, and Assembly.
🕯️ Digital Ofrenda: A virtual memory altar inspired by Día de los Muertos, celebrating the history of computing.
🧠 AI-Powered Conversations: Generate contextual responses and interactions using a locally running Gemma model.
🔊 Atmospheric Audio: Procedural sound effects, ambient electronic drones, radio static, and keyboard sounds.

The central idea is simple:

What if forgotten technologies could speak again and tell their stories?

Demo

🔗 Live Demo: https://ghost-in-the-machine-delta.vercel.app

Explore the haunted terminal, interact with digital spirits, and experience the digital memory altar.

Note: Local AI features require Ollama and the Gemma 3:4B model to be running on the backend. If the deployed demo does not have access to a configured local AI backend, some interactions may use fallback responses.

Code

👨‍💻 GitHub Repository:

https://github.com/W47K3RJO1N/ghost-in-the-machine

The project is open source, and contributions, suggestions, and improvements are welcome!

How I Built It

I wanted to build something beyond a conventional chatbot. My goal was to create an immersive experience where open-source AI becomes part of the application's identity rather than just an additional feature.

AI Model

I used Gemma 3:4B, Google's open-weight AI model, through Ollama for local inference.

The model powers:

Contextual conversations with forgotten programming language spirits.
AI-generated messages and blessings for the digital ofrenda.
Creative responses that give each interaction a personality.
Interactive storytelling within the haunted terminal.

Technology Stack

Technology	Purpose
HTML5	Application structure
CSS3	Gothic cyberpunk interface
JavaScript	Frontend interactions
Node.js	Backend server
Ollama	Local AI inference
Gemma 3:4B	AI-generated content
Web Audio API	Procedural audio experience

How the AI Integration Works

The user interacts with a digital spirit through the terminal.
The frontend sends the interaction to the Node.js backend.
The backend communicates with Ollama.
Gemma 3:4B processes the context and generates a response.
The response is displayed in the haunted terminal.

I also implemented fallback responses so that the experience can continue when the local AI service is unavailable.

Local Setup

git clone https://github.com/W47K3RJO1N/ghost-in-the-machine.git

cd ghost-in-the-machine

ollama pull gemma3:4b

node server.mjs

Then open:

http://localhost:3000

Why Does Open Innovation Matter?

Open innovation made this project possible in a way that a closed AI API alone would not.

Using an open-weight model like Gemma 3:4B gave me the freedom to experiment with AI locally, customize the interaction experience, and build an application without depending on a paid hosted inference API.

Some of the biggest advantages were:

Accessibility: Experimenting with AI without requiring expensive API subscriptions.
Privacy: Local inference keeps AI processing on the user's machine.
Customization: Greater freedom to shape the model's role, prompts, and interactions.
Learning: Understanding how local AI inference connects with a real application.
Community: Open-source development makes it possible for others to explore, modify, and extend the project.

For me, open innovation is about making technology accessible enough that developers can experiment with ideas that might otherwise remain just ideas.

My Agent Session

I used AI-assisted development while building the application, experimenting with the architecture, interface, and local AI integration.

Agent Session: [Add your DevRelay session link here]

The Spirit of It

The most interesting part of this project was thinking about technologies that developers once depended on every day but rarely talk about anymore.

COBOL still powers important business systems. Assembly continues to represent the lowest levels of computing. Flash reminds us of an earlier, highly creative internet.

These technologies are not simply dead code. They are part of the foundation on which modern computing was built.

I wanted NecroOS to feel like entering a place where those forgotten technologies are still waiting to be heard.

The digital ofrenda represents remembrance, while the haunted terminal gives those memories a voice.

Because technology evolves, but its history deserves to live on.

Prize Categories

🏆 Best Use of Gemma
🏆 Overall Prize

Final Message

NecroOS is my interpretation of Ghost in the Machine: a combination of open-weight AI, forgotten computing history, interactive storytelling, and a little bit of digital mystery.

Thank you to the Hacktoberfest community and everyone making open-source AI experimentation possible!

🕯️ The code may be forgotten. The machine never forgets.

👻 Welcome to NecroOS.

LazyFlow AI: You Relax, AI Handles the Busywork 🌿

Himanshu Bhirud — Fri, 23 Oct 2026 15:55:55 +0000

What I Built

Meet LazyFlow AI — a personal productivity assistant designed to make everyday digital work a little less exhausting.

We spend too much time doing repetitive tasks: reading lengthy documents, organizing messy files, and turning scattered notes into actionable plans. LazyFlow AI aims to take that busywork off your plate so you can focus on what actually matters.

With LazyFlow AI, you can:

📄 Summarize documents: Turn lengthy PDFs and text into concise summaries, key takeaways, and useful notes.

🗂️ Organize files: Generate smart filename suggestions, categorize files, and create an organized folder plan.

✅ Extract tasks: Convert unstructured notes into prioritized, editable action items.

⚙️ Manage automation: Track jobs, review results, and revisit previous work from one dashboard.

The idea is simple: instead of spending your time organizing work, let AI help organize it for you.

Less busywork. More breathing room. That's the LazyFlow way.

Demo

🚀 Live Demo: [https://lazy-ai-roan.vercel.app/]

🎥 Demo Video: [Add your demo video link here, if available]

The application is designed to provide a usable demo experience even when a real AI provider hasn't been configured.

Code

💻 GitHub Repository: [https://github.com/W47K3RJO1N/Lazy-ai]

Built with a focus on readable code, modular AI integration, and a foundation that other developers can extend.

How I Built It

I built LazyFlow AI around the idea that AI should do more than answer questions — it should help complete useful workflows.

Tech stack

Next.js + TypeScript: Application architecture and server-side API routes.

Tailwind CSS + shadcn/ui: Responsive, consistent, and accessible interface components.

Lucide React: Clean, lightweight icons.

Framer Motion: Subtle animations and interaction polish.

Zod: Validation of user inputs and structured AI responses.

Open-weight language models: A planned integration path for models such as Qwen or Gemma through a compatible inference endpoint.

Vercel: Hosting and deployment.

How the workflow operates

The user submits a document, a collection of file metadata, or unstructured notes.

LazyFlow validates the input and selects the appropriate workflow.

The application processes the input using the configured AI provider or its clearly labelled demo mode.

Results are displayed in a structured interface for review and editing.

The user can copy, export, or save useful results.

I designed the application with a modular AI layer so that different compatible models can be integrated without rebuilding the entire product.

The initial web architecture is designed for Vercel deployment. Running inference fully offline would require a local inference service or companion application rather than relying solely on Vercel's hosted environment.

Why Does Open Innovation Matter?

Open innovation makes projects like LazyFlow AI more adaptable and accessible.

Using open-source frameworks and open-weight models gives developers greater flexibility over how AI capabilities are integrated, where inference runs, and how the product evolves.

For a productivity assistant that may handle private notes and documents, these choices matter.

An open-weight model can potentially run on infrastructure controlled by the user or developer. This can reduce dependence on proprietary model APIs and help avoid per-request model charges when self-hosting is practical.

Open-source tools also make it easier for other developers to inspect the architecture, improve individual workflows, contribute features, and adapt the project to their own needs.

Of course, open weights do not automatically mean unrestricted licensing, and local inference alone does not guarantee complete privacy. Model licenses, data handling, and deployment choices still matter.

My goal is to make useful automation more approachable, customizable, and transparent.

My Agent Session

🤖 Agent Session: [Add your DevRelay session link here, if available]

I used an AI-assisted development workflow to help design and implement the application. The session can document the decisions, iterations, debugging, and improvements made along the way.

The Lazy Payoff

The real payoff isn't simply generating text faster. It's reducing the friction between having work to do and knowing what to do next.

Imagine starting your day with:

A long document already condensed into useful takeaways.

A proposed structure for your messy files.

A prioritized task list extracted from yesterday's notes.

Instead of starting from scratch, you start with something you can review and act on.

I'm building LazyFlow AI to make these workflows simpler and less repetitive. The next step is to measure the time saved through real usage rather than relying on guesses.

🌿 NatureQuest AI: Turn Screen Time into Green Time

Himanshu Bhirud — Sun, 11 Oct 2026 06:57:30 +0000

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

What I Built

Modern life is dominated by screens, notifications, and endless indoor scrolling. NatureQuest AI is an open-source, full-stack wellness and exploration platform designed to get people off their desks and into the real world.

It turns outdoor exploration into an interactive adventure by:

AI Outdoor Quest Generator: Creates context-aware, bite-sized outdoor quests (5–60 minutes) tailored to user surroundings (parks, gardens, neighborhood sidewalks, backyards) and activities (walking, birdwatching, mindful sensory observation, nature photography, litter cleanups).
AI Nature Vision & Explorer: An instant field identification tool. Snap or upload a photo of a leaf, wildflower, mushroom, or bird during a walk to identify its scientific name, ecological importance, and fun facts.
Field Nature Journal: A personal digital herbarium and field notebook to log outdoor observations, thoughts, and photos.
Gamified Habits: Level up with outdoor XP, maintain daily streaks, view weekly outdoor activity charts, and unlock achievement badges.
Who it's for: Remote workers battling screen fatigue, nature enthusiasts, families, and anyone who needs a fun, positive nudge to step outside, breathe fresh air, and cultivate a daily nature habit.

Demo

🌐 Live Application: https://naturequest-ai.vercel.app/
💻 Backend API & Swagger Docs: Available locally and containerized via Docker Compose.

Code

The entire project is 100% open-source under the MIT License on GitHub:

W47K3RJO1N / naturequest-ai

NatureQuest AI 🌿 — Touch Grass Daily

An open-source, full-stack AI-powered outdoor adventure web application built for the "Touch Grass" theme.

NatureQuest AI turns screen fatigue into mindful nature habits. It generates personalized outdoor micro-quests using Google Gemini, identifies plants and wildlife through multimodal AI vision, records observations in a personal Nature Journal, and gamifies outdoor consistency with levels, badges, and streaks.

🌟 Key Features

AI Quest Generator:
- Tailored outdoor challenges based on duration (5 to 60 mins), difficulty, activity (Walking, Plant Observation, Bird Watching, Photography, Mindfulness, Litter Cleanup), and setting (Park, Garden, Backyard, Neighborhood).
- Generates actionable tasks, safety reminders, and XP rewards.
- Powered by official Google Gen AI SDK with structured Pydantic validation and curated offline fallback quests.
- Zero-footprint Leave No Trace ethics (never encourages foraging toxic species, trespassing, or disturbing habitats).
Nature Explorer & Flora Identification:
- Upload or snap photos of plants, leaves…

View on GitHub

Tech Stack:

Frontend: Next.js 14 (App Router), React, Tailwind CSS, Lucide Icons, Recharts
Backend: FastAPI (Python 3.10+), SQLAlchemy, Pydantic v2, PostgreSQL / SQLite
AI Engine: Google Gen AI SDK (google-genai), Gemini 2.5 Flash / multimodal vision

How I Built It

Structured Micro-Quest Generation: The backend prompts the model using structured Pydantic schema validation (QuestStructuredOutput). It injects environmental parameters, duration, Leave No Trace safety ethics, and localized constraints to produce actionable steps, safety warnings, and XP allocations without hallucinated or hazardous activities (e.g., forbidding ingestion of wild mushrooms/plants).
Multimodal Field Vision: In the Nature Explorer module, images are processed with multimodal vision to extract taxonomic details (common & scientific names, category, confidence score, and environmental roles).
Resilient Offline Fallback Architecture: To ensure privacy, offline accessibility on remote trails, and zero-downtime evaluation, NatureQuest AI features an integrated fallback engine. If connectivity or API keys are unavailable, it smoothly defaults to curated naturalist micro-quests and built-in ecological records.
Full-Stack Monorepo: Dockerized with Docker Compose for seamless single-command local development.

Why Does Open Innovation Matter?

When building tools meant to reconnect humanity with the natural world, open innovation is vital:

Transparency & Safety: Outdoor applications must adhere strictly to environmental safety and "Leave No Trace" ethics. Open-source code allows naturalists, educators, and the community to audit prompt behavior and ensure the AI never recommends harmful foraging, trespassing, or disturbing fragile wildlife habitats.
Community-Driven Biodiversity: Nature belongs to everyone. Open models and open code empower global contributors to adapt the app for regional ecosystems, indigenous plant knowledge, and local parks without relying on a closed, black-box ecosystem.
Data Privacy & Portability: Users exploring their neighborhoods shouldn't have their location habits locked into closed proprietary silos. With NatureQuest AI, users can self-host, run local offline fallbacks, and export their field journal data whenever they choose.

My Agent Session

During the development of NatureQuest AI, I used an AI pair-programming agent to accelerate our full-stack architecture and outdoor-first mechanics:

Prompt Engineering & Structured Schemas: Iterated on Pydantic validation schemas with Google GenAI SDK to guarantee consistent JSON outputs for quests and botany classification.
Fail-Safe Offline Design: Designed and implemented the fallback naturalist engine to ensure users without active internet on trails or valid API keys still get rich, curated micro-quests.
Gamification Mechanics: Formulated and balanced the non-linear XP curve (Level N = 100 * (N - 1)^1.5 XP) along with automated test suites verifying anti-duplication reward checks.
Leave No Trace Safety Constraints: Crafted negative safety constraints in the agent prompt harness to explicitly prevent dangerous wild plant ingestion, toxic mushroom foraging, or habitat disruption.

StudyPulsepro - Ai Learning Platform using Focus modes

Himanshu Bhirud — Sat, 03 Oct 2026 14:27:06 +0000

StudyPulse PRO — Ultimate AI Learning Companion & Focus Studio 🚀

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

What I Built

I built StudyPulse PRO, an all-in-one gamified learning platform and interactive focus suite designed specifically for my best friend Alex, a computer science student who frequently struggles with exam anxiety, study fatigue, and keeping track of revision intervals across dense technical subjects.

The Problem It Solves

Alex constantly cycled between burnout and last-minute cramming:

Focus Drain: Distractions during long study sessions and forgetting to take structured rest breaks.
Passive Revision: Re-reading notes instead of practicing Active Recall and Spaced Repetition.
Isolation & Lack of Motivation: Studying alone late at night without immediate feedback or encouragement.

How StudyPulse PRO Helps

⏱️ Adaptive Pomodoro Focus Engine: Ambient soundscapes, customizable focus/rest cycles, synthwave/cyberpunk themes, and audio cues to keep focus locked.
🎴 Smart Flashcard Studio: Interactive 3D flip cards with active recall rating ('Need Review' vs 'Mastered') and auto-generating practice decks.
🎯 Interactive AI Study Buddy Widget: Companion assistant featuring customizable animated avatars (Owl 🦉, Bot 🤖, Cat 🐱, Panda 🐼), instant active-recall quizzes, speech output (Web Speech API), and automated workflow shortcuts.
🏆 Gamified XP & Level Progress System: Daily study streaks, XP rewards for completing sessions and quizzes, plus collectible achievement badges.
📊 Analytics & Heatmap Dashboard: Visual tracking of weekly focus time, deck mastery rates, and productivity metrics.

Demo

🌐 Live Web Application: https://dev-hack-app.vercel.app/
📹 Video Demo / Screenshots: Check out the interactive preview of the Study Buddy and Pomodoro focus timer below!

Code

You can explore the full open-source repository on GitHub:

# Clone the repository
git clone https://github.com/W47K3RJO1N/Dev-hack-app.git

# Install dependencies
npm install

# Start local dev server
npm run dev

How I Built It

StudyPulse PRO was built using a high-performance modern web stack:

Frontend Framework: React 19 + TypeScript + Vite 8 for lighting-fast HMR and build speeds.
Styling & Theme Engine: Tailwind CSS v4 + Framer Motion for smooth glassmorphism UI transitions and custom dynamic themes (Cyberpunk, Midnight Blue, Emerald Focus).
Interactive Audio & Speech: Web Audio API synth tones for notifications and Web Speech API (SpeechSynthesis) for vocal AI feedback from the companion avatar.
AI & Open-Source Infrastructure: Designed around an open-weights modular companion framework. It leverages client-side lightweight rule execution & structured prompt synthesis for instant active recall testing, quiz generation, and motivational coaching without API latency.

Why Does Open Innovation Matter?

Open innovation and open-weight models democratize access to personalized education toolkits.

By building StudyPulse PRO with open technology:

Privacy-First Learning: Student data, notes, and study logs stay entirely local in the browser without sending sensitive study habits to closed proprietary AI servers.
Offline-Capable Accessibility: Students in low-bandwidth areas can leverage the focus tools, flashcards, active-recall engine, and companion feedback without relying on an expensive cloud subscription or internet access.
Community Customization: Open innovation allows students and teachers worldwide to fork the repository, add custom flashcard algorithms (like SM-2 spaced repetition), and introduce tailored study avatars for different age groups.

My Agent Session

(Optional) My entire development, UI design, and pair-programming session was assisted by Google DeepMind's Antigravity AI Agent.

Prize Categories

🏆 Build for a Friend Challenge
🤖 Best Use of Open AI & Innovation

Intro

Himanshu Bhirud — Fri, 02 Oct 2026 17:33:05 +0000

I am new to this dev community and am happy to be the part of this community