DEV Community: Jatin Vishwakarma

AFTERDARK: The Ghost in Your Terminal

Jatin Vishwakarma — Tue, 27 Oct 2026 18:50:38 +0000

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

Inspiration

What if your terminal remembered things you never asked it to remember?

Inspired by retro computing, analog horror, and the eerie atmosphere of abandoned machines, AFTERDARK explores what happens when an ordinary developer terminal becomes an interactive experience filled with fictional anomalies, mysterious messages, and unsettling stories.

For the Hacktoberfest Open-Source AI Challenge Week 4, Ghost in the Machine, I wanted to bring the feeling of an old computer that never truly went offline into a modern, browser-based experience.

What I Built

AFTERDARK transforms a familiar terminal interface into a cinematic, interactive horror experience.

Haunted Terminal: Explore a simulated command-line environment with command history and fictional system anomalies.
Ghost Companion: Discover mysterious messages and eerie terminal interactions.
Ghost Story Generator: Create fictional horror stories with customizable settings, intensity, and length.
Session Archives: Explore and revisit saved demo sessions.
Incident Reports: Turn fictional anomalies into atmospheric timelines and reports.
Immersive UI: Experience a minimalist retro-computing aesthetic with dark surfaces, warm amber accents, terminal green, and monospaced typography.

The terminal is simulated. It does not execute real shell commands or inspect the user's computer.

Demo

Code

Github Repository: https://github.com/coddingjatin/AFTERDARK-Week-4-Hacktoberfest-Challenge-/tree/main

How I Built It

AFTERDARK is implemented as a frontend-focused web experience using the project's existing web stack.

The intended technologies include React, TypeScript, Vite, and browser-based JavaScript interactions, depending on the final repository implementation.

The terminal simulator handles supported commands locally. Story generation and ghost interactions can use deterministic JavaScript templates, while optional browser storage can preserve session data.

This keeps the demo lightweight and avoids paid API calls, API keys, and cloud inference dependencies.

Challenges I Faced

One of the main design challenges was creating an experience that feels eerie without making the interface difficult to use.
The solution was to keep the terminal at the center, use restrained visual effects, and make the surrounding panels support the experience rather than overwhelm it.
Another consideration was keeping the application accessible without requiring API credentials, backend infrastructure, or a paid AI service.

Why Does Open Innovation Matter?

Open innovation makes it possible to experiment, build, and share without depending entirely on proprietary services or paid APIs.

AFTERDARK is currently a frontend-only demo that uses local JavaScript logic rather than an AI model. This keeps the experience lightweight, avoids paid inference APIs, and allows users to explore its interactive features without sharing session data with an AI provider.

Looking ahead, open-weight models and local inference could make the ghost more adaptive while giving developers greater control over model selection, privacy, and customization.

For me, open innovation is about more than access to technology. It is about having the freedom to understand it, modify it, and build something of your own.

The Spirit of It

here is something unsettling about an old computer that is still running when nobody remembers turning it on.

That feeling inspired AFTERDARK.

A familiar terminal becomes a place of unanswered questions. A simulated scan reveals unexplained anomalies. A simple command returns a message that feels as though it belongs to another session, another time.

I wanted to capture that small moment when a tool we use every day suddenly feels unfamiliar.

AFTERDARK turns the idea of a ghost in a machine into an interactive experience, where the mystery lives not in jump scares, but in the feeling that something is still there.

Session terminated. Memory retained.

What's Next

Potential improvements include integrating a locally running open-weight model, expanding the interactive story system, adding more terminal scenarios, and introducing richer session exploration.

The goal is to preserve the privacy-conscious, lightweight experience while exploring how open-source AI could make the ghost more adaptive and context-aware.

Submitted By: @jatin_vishwakarma

🐌 Slothful: A Little Less Doing. A Little More Living.

Jatin Vishwakarma — Wed, 21 Oct 2026 08:26:10 +0000

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

What if productivity wasn't about doing more, but about making life a little easier?

We all have those days.

Your to-do list keeps growing. Your notes are scattered everywhere. A task that should take an hour somehow takes an entire day to even get started.

Sometimes, the hardest part isn't doing the work.

It's figuring out where to begin.

That's the idea behind Slothful, my project for the Slow and Steady challenge.

What I Built

Slothful is a calm, AI-powered productivity companion designed to help people manage everyday responsibilities without feeling overwhelmed.

Instead of pushing you to squeeze more work into every hour, it helps you reduce mental clutter, organize your thoughts, and take one manageable step at a time.

Here's what Slothful is designed to do:

Brain Dump: Write everything on your mind and turn scattered thoughts into organized, actionable tasks.
Smart Task Manager: Organize responsibilities, priorities, due dates, and subtasks in one place.
Gentle Plan: Build a realistic daily plan based on your available time, priorities, and energy level.
Make It Easier: Break overwhelming tasks into tiny actions that are easier to start.
Quiet Inbox: Summarize notes, extract important takeaways, and turn useful information into tasks.
Local-First AI: Use compatible open-weight models through Ollama to process supported content on your own machine.

The feature I'm particularly excited about is Make It Easier.

Imagine having to prepare an entire project presentation.

Instead of staring at that task on your screen, Slothful can help turn it into smaller actions:

Open your project notes.
Write down three important points.
Create the title slide.
Add the problem statement.
Review what you've completed.
Suddenly, the task feels less intimidating.

You don't have to finish everything right now. You just need a place to start.

That's the philosophy behind Slothful.

Less mental clutter. Fewer unnecessary decisions. One small step at a time.

Code

🔗 GitHub Repository: https://github.com/coddingjatin/Slothful-Week-3-Hacktoberfest-Challenge

The project is being built with a warm, premium, minimalist design language, using warm ivory backgrounds, forest-green accents, soft sage details, and a distraction-free interface.

The goal is to make Slothful feel less like another productivity dashboard and more like a thoughtful digital companion.

How I Built It

Slothful is designed around a React and TypeScript frontend, with local persistence and a configurable AI integration.

The AI layer uses Ollama to run compatible open-weight language models locally.

The intended workflow is straightforward:

The user submits a brain dump or selects a task.
Slothful prepares a structured request for the configured model.
The model generates task suggestions, summaries, or smaller action steps.
The application validates the response.
The user reviews the result before saving it.

I'm also designing a fallback mode so the application remains useful when a local model isn't available.

The important distinction is that fallback behavior should never pretend to be real AI inference. Users should know whether they're using the configured model or the fallback.

The application is designed to support configurable models rather than depending entirely on a single closed AI API.

Why Does Open Innovation Matter?

For a productivity assistant, privacy matters.

Our notes, unfinished tasks, personal plans, and everyday responsibilities can contain information we don't necessarily want to send to an external service.

That's one reason I wanted to explore open-weight AI for Slothful.

With a compatible model running locally through Ollama, supported AI operations can be performed on the user's own machine rather than requiring every request to go through a third-party AI API.

But privacy is only one part of the story.

Open-weight models also provide flexibility.

Developers can experiment with different models, adapt prompts, change how tasks are structured, and choose an inference setup that fits their hardware and requirements.

There is also the potential to reduce recurring API expenses when inference runs locally, although local computation still requires hardware and electricity.

For me, the most interesting advantage is control.

The AI should adapt to the product and its users, rather than forcing the entire product to depend on one closed provider.

That's what makes open innovation valuable here.

It gives Slothful room to evolve while keeping local-first operation at the center of the design.

Actual privacy and offline behavior still depend on the model, endpoint, dependencies, and application configuration.

The Lazy Payoff

The biggest payoff I'm aiming for isn't making someone work twice as fast.

It's reducing the effort required to get started.

Think about the time spent deciding what to do first, breaking down a large assignment, reorganizing messy notes, or figuring out how to fit everything into a busy day.

Slothful is designed to reduce that friction.

Instead of spending another 15 minutes figuring out how to approach a task, you can get a starting point and focus on the actual work.

I haven't established a measured time-saving figure yet, so I won't claim a specific percentage or number of hours saved. That would need to be tested with real usage.

For now, the goal is simple: fewer decisions before the first step.

Because sometimes, the most useful productivity tool is the one that helps you stop overthinking and begin.

Submitted By: @jatin_vishwakarma

I Built an AI Invoice Assistant That Runs Locally (No API Keys, No Expiring Credits) 💸

Jatin Vishwakarma — Fri, 16 Oct 2026 06:57:22 +0000

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

What if you could use AI to manage your invoices without paying for every API request or uploading your financial documents to someone else's server?

That question inspired me to build InvoiceMate AI, a local-first AI assistant designed for freelancers, independent developers, consultants, and small business owners.

Because sometimes, the best AI tool isn't the one with the biggest model. It's the one you can actually afford to run.

What I Built

InvoiceMate AI helps automate one of the most repetitive tasks in running a small business: managing invoices and receipts.

Upload an invoice or receipt, extract its important details, review the results, and organize everything in one place.

The goal is to make everyday financial administration simpler without making users dependent on paid AI APIs.

Here's what I'm building into it:

Invoice and receipt text extraction using local OCR.
AI-powered extraction of vendor names, dates, totals, taxes, and expense categories.
An expense dashboard with spending summaries and trends.
A natural-language assistant for querying recorded expenses.
Searchable invoice records with filters.
CSV exports for further analysis.
Local storage and privacy-first document processing.

Who would actually use this?

A freelancer managing dozens of client invoices. An independent developer tracking project expenses. A small business owner tired of entering receipt details manually.

These are the people I want to build for.

Demo

Code

GitHub Repository: https://github.com/coddingjatin/InvoiceMate-AI-Week-2-Hacktoberfest-Challenge

The project is designed around a modular architecture, with a React and TypeScript frontend, a Python and FastAPI backend, SQLite for local storage, and local AI inference through Ollama.

I'd love to make this useful for people beyond my own machine, so contributions and feedback are welcome.

How I Built It

The central design decision was to make local AI a core part of the application rather than simply adding an AI API to a conventional expense tracker.

Here's the intended stack:

Ollama + an open-weight language model: Structured invoice extraction and natural-language understanding.
Tesseract OCR: Reading text from scanned receipts and image-based documents.
Python + FastAPI: Document processing, validation, and backend APIs.
SQLite: Persisting invoice and expense records locally.
React + TypeScript: Building the interactive dashboard and document review experience.
Pydantic: Validating extracted data before it is stored.

The workflow looks like this:

A user uploads a PDF or image.
Local OCR or PDF parsing extracts the text.
A locally running language model converts the text into structured fields.
Validation logic checks the output, while deterministic code handles financial calculations.
The user reviews the extracted information.
Verified records are stored locally and become available for search, analysis, and export.

The review step matters. Language models can misread amounts or dates, especially when documents are scanned poorly. I don't want an AI-generated number silently becoming a financial record.

And here's the part I'm most excited about:

No paid AI inference API. No expiring inference credits. No mandatory cloud AI dependency.

After the required dependencies and model have been downloaded, the core workflow is designed to run offline.

Why Does Open Innovation Matter?

For this project, open innovation isn't just about using a different model. It changes the economics and privacy assumptions behind the product.

1. The economics actually make sense.

If every invoice consumes paid API credits, the cost of running the product grows with usage.

Local inference removes mandatory per-request AI billing. Users still need hardware, storage, electricity, and maintenance, but they aren't forced to pay a cloud AI provider for every extraction.

2. Financial data deserves privacy.

Invoices can contain client information, addresses, transaction details, and other sensitive business records.

Running OCR and inference locally means these documents don't need to be sent to a third-party AI service. That gives users more control over where their information goes.

3. No dependence on expiring API credits.

I don't want a basic expense workflow to stop working because an API key expires, a free quota runs out, or a provider changes its pricing.

A locally installed model makes the core AI workflow independent of those external inference quotas.

4. Freedom to experiment.

Open-weight models let developers experiment with compatible models, prompts, extraction strategies, and domain-specific customization.

A small-business tool doesn't always need the most expensive general-purpose model. It needs a model that performs well enough for its specific task, with proper validation and human review.

5. Offline access becomes possible.

Once the model and dependencies are installed, the main workflow can operate without an internet connection.

That opens the door to users who prefer local tools, have unreliable connectivity, or simply don't want every document-processing task to depend on a remote service.

For me, that's the real value of open-source AI: making useful AI workflows more accessible, customizable, and independent.

Prize Categories

Best Use of Render
Best Use of GitHub Copilot
Best Use of SerpApi

Submitted By: @jatin_vishwakarma

What's Next?

The next step is getting InvoiceMate AI into the hands of an actual freelancer or small business owner.

I want to learn whether the extraction workflow genuinely saves time, which document formats cause problems, and whether users would pay for installation, customization, or ongoing support.

The best validation isn't another feature on the roadmap. It's watching someone use the product to solve a real problem.

That's what I want to focus on next.

GoLocal AI: An AI That Helps You Touch Grass, Literally

Jatin Vishwakarma — Fri, 09 Oct 2026 14:06:52 +0000

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

What I Built

What if we built an AI application whose ultimate goal was to make you stop using it?

We live in a world where almost every free moment turns into another scroll. We open our phones to take a short break, only to realize that an hour has disappeared. Meanwhile, the world outside our screens is full of little things we rarely notice: the sound of birds, a quiet street we've never explored, the shape of a leaf, or a sunset we were too busy scrolling to see.

I wanted to explore a different side of AI. Instead of building another tool that demands our attention, what if we used AI to help us take our attention back?

That idea became GoLocal AI, an open-source AI-powered outdoor companion that turns everyday walks into small, meaningful adventures.

The concept is simple: tell GoLocal AI how much time you have, choose the kind of activity you're interested in, and get a personalized outdoor mission designed around your preferences.

Maybe it's a 10-minute nature observation challenge. Maybe it's exploring a new route, discovering five things you have never noticed in your neighborhood, or taking a quiet walk without checking your phone.

The goal isn't to travel somewhere extraordinary. It's to experience ordinary places a little differently.

More Than Just Generating Outdoor Ideas

GoLocal AI is designed around the complete journey, not just the moment when AI generates a response.

Personalized Outdoor Missions: Turn your available time, activity preferences, and difficulty level into a real-world challenge.
Phone Down Mode: Once your mission is ready, step away from the screen and focus on the experience instead of the app.
Explore, Observe, Discover: Get prompts that encourage you to notice your surroundings, explore mindfully, and interact with the world around you.
Reflection Journal: After returning, capture what you experienced, what surprised you, and the little things you might otherwise forget.
A Calmer Digital Experience: Keep the interface focused on helping you get outside rather than encouraging endless engagement.

Demo

Code

GitHub Repository: https://github.com/coddingjatin/GoLocal-AI-Week-1-Hacktoberfest-Challenge

GoLocal AI is being built with the idea that meaningful AI experiences should be open to experimentation, customization, and community-driven improvement.

The project explores how open-weight AI can be used for something beyond productivity dashboards, chat interfaces, and content generation: helping people engage more deeply with their physical surroundings.

How I Built It

I approached GoLocal AI with one guiding principle: Build an experience that rewards people for leaving the app, not staying in it.

The application brings together a responsive, nature-inspired interface, personalized mission generation, a focused outdoor experience, and a reflection-based journal.

The planned technology stack includes React, TypeScript, Vite, and Tailwind CSS for the frontend. For AI-powered mission generation, Ollama with a compatible open-weight model such as Gemma can support local inference, with an optional Python FastAPI backend to manage AI requests.

The mission-generation flow can use structured inputs such as activity type, available duration, difficulty, and environment to create practical outdoor challenges. Rather than producing generic suggestions, the aim is to make each mission specific enough that a user can actually step outside and complete it.

After completing a mission, users can record their observations and reflections in an exploration journal. This creates a simple but intentional cycle:

Choose a mission → Step outside → Explore the real world → Reflect on the experience.

An important design consideration is that the experience should remain useful even when a local AI model is unavailable. A clearly identified demo mode can help users explore the interface, while keeping sample responses distinguishable from live AI-generated results.

The interesting engineering challenge isn't simply connecting an AI model to a frontend. It's designing the whole experience around a different measure of success: helping users turn a digital interaction into an offline activity.

The final technology and implementation details should reflect the features and integrations available in the submitted version.

Why Does Open Innovation Matter?

For me, open innovation is about giving developers the freedom to question the default way technology is built.

AI applications are often designed to keep users inside a platform. More prompts, more recommendations, more interactions. But what happens when we use the same underlying technology to encourage fewer interactions and more real-world experiences?

Open-weight models create room to experiment with that question.

They allow developers to explore different models, adapt prompts, run inference locally where supported, and build experiences without necessarily depending on a closed, hosted AI API for every interaction. Depending on the implementation, local inference can also offer greater control over where personal reflections are processed.

For a project like GoLocal AI, these possibilities are especially relevant. The application is intended to encourage people to step away from their screens, so a flexible and potentially local AI setup fits the broader philosophy of the project.

Open innovation also makes the idea easier for other developers to explore and extend. Someone could experiment with accessibility-focused missions, nature-learning challenges, walking activities for different age groups, or community-created outdoor adventures.

The project is a small exploration of a much bigger question:

Can we build AI that helps people live better offline, rather than simply do more online?

I believe that's a direction worth exploring.

Prize Categories

Best Use of GitHub Copilot
Best Use of Gemma

Submitted By: @jatin_vishwakarma

Final Thoughts

GoLocal AI started with a simple thought: we have built incredible technology to connect us to the world, but sometimes we need a little help reconnecting with the world right in front of us.

A short walk doesn't need to become a productivity goal. Exploring your neighborhood doesn't need a complicated plan. And spending time outdoors doesn't need another app fighting for your attention.

Sometimes, all you need is a small idea that gets you through the door.

If GoLocal AI can help someone notice a beautiful sunset, discover a new walking route, put their phone away for a while, or appreciate a place they have passed a hundred times before, then it has done something meaningful.

Less scrolling. More exploring. More living.

GoLocal AI: Get out of the algorithm. Get into the real world.

BuddyOS: An AI Copilot for the Friend Who Always Has Too Much Going On.

Jatin Vishwakarma — Fri, 02 Oct 2026 06:27:51 +0000

What I Built

I built BuddyOS for a friend who somehow manages to have five deadlines, three projects, a hackathon, two meetings, and still asks:

"Bhai, deadline kab hai?"

I wanted to build something small, but genuinely useful for one person.

BuddyOS turns the messy information my friend deals with every day into a simple, actionable plan.

They can give it:

Assignment PDFs
Hackathon problem statements
Screenshots containing deadlines
Meeting notes
Random text reminders
Project requirements
Personal to-do lists

BuddyOS extracts the important information, identifies deadlines and priorities, breaks larger tasks into smaller actions, and builds a realistic plan for what they should work on next.

Instead of another chatbot saying "How can I help?", BuddyOS tries to answer a much more useful question:

"What should you actually do next?"

The project was built around one real person, one real problem, and one goal:

Make their chaotic workload a little easier to manage.

And yes, I actually gave it to my friend to try.

Their first reaction was basically:

"Okay... this is actually useful."

That was the moment this stopped feeling like just another hackathon project.

Demo

How I Built It

The main idea behind BuddyOS was simple:

The AI should be part of the product, not just a chatbot sitting next to it.

The application uses an open-weight model running through local inference to understand the user's documents and notes.

The pipeline looks roughly like this:

Why Does Open Innovation Matter?

This project is personal, which is exactly why privacy matters.

My friend's assignments, project documents, schedules and personal notes are not things I wanted to blindly send to a third-party AI service just to generate a to-do list.

With a local open-weight model,**BuddyOS **can process that information on the user's own machine.

That changes what I can build.

I can:

Run the model without an internet connection
Keep personal documents local
Experiment with different models
Change the agent's behaviour
Inspect the workflow
Customize the system for one specific person's needs
Build without every interaction becoming another API call

That's what open innovation made possible here.

Prize Categories

Best Use of Gemma: Gemma is the open-weight model powering the core understanding and planning workflow.
Best Use of GitHub Copilot: Used during development to accelerate implementation, debugging and iteration.
**Best Use of Sentry Agent Tracing: **Used to inspect agent behaviour, latency and failures during development.

Submitted by: @jatin_vishwakarma

My Submission

Jatin Vishwakarma — Fri, 27 Dec 2024 17:14:01 +0000

This is a submission for Frontend Challenge - December Edition, Glam Up My Markup: Winter Solstice

What I Built

I have Created just a basic and simple page in that i had created a different different components that are integrated in a single page with images and all, This is my first time participation in this Challenge. Actually i was facing the issue while creating this don't know why..😅😓 But just created a simple page

Demo

Journey

Building this project was an exciting experience:

I started by diving into the theme, researching the winter solstice's scientific and cultural aspects.
I started designing the pages.
Add a finishing touch just to keep it simple using HTML, CSS, and JavaScript.

Submission

This Submission was Created by : @jatin_vishwakarma While creating this project, I learned a lot about designing and creating a engaging web pages while exploring the fascinating theme of the winter solstice.

Github Link: https://github.com/coddingjatin/Dev-Frontend