DEV Community: Dipanshu Vishwakarma

GhostShell 👻: A Haunted AI Terminal for Hacktoberfest 2026

Dipanshu Vishwakarma — Wed, 28 Oct 2026 14:21:29 +0000

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

What I Built

Meet GhostShell 👻, a spooky terminal companion designed to make working with shell commands more interesting and less confusing.

Have you ever found a command online and wondered what it actually does? Or worried about running a command that might delete files or change your system?

GhostShell is designed to help with that.

The idea is to create a haunted terminal experience where a ghost-like AI companion explains commands in simple language, highlights potential risks, and responds with spooky commentary.

Instead of just showing technical output, GhostShell makes command analysis feel like a conversation with a mysterious entity living inside your computer.

The goal is to combine a fun Halloween-inspired experience with a genuinely useful developer tool.

Demo

👻 Live Demo: https://ghostshell-fawn.vercel.app/

💻 GitHub Repository: https://github.com/unknowdeepanshu/GhostShell

Explore the interface and repository to see the project.

How I Built It

I built GhostShell around the idea of combining a haunted terminal interface with open-source AI.

The planned technology stack includes:

React + TypeScript for the user interface.
Tauri for the desktop application.
Tailwind CSS for styling.
Rust for desktop-side functionality and controlled system access.
Open-weight AI for generating command explanations and ghostly responses.
Local storage for keeping user preferences and command history on the device.

One important design decision is that GhostShell should analyze commands rather than execute them. The AI should not have unrestricted access to the user's terminal.

A separate rules-based analyzer can identify potentially dangerous command patterns, while AI can help explain unfamiliar syntax in beginner-friendly language.

The goal is to keep the application useful even when the AI model is unavailable.

The exact model, local inference setup, and implemented features should be documented in the repository as they are verified.

Why Does Open Innovation Matter?

For me, open innovation is about giving developers more control over the tools they use.

A closed AI API can be convenient, but it may require an internet connection, send prompts to an external service, and introduce usage costs.

With a suitable open-weight model and a properly implemented local runtime, GhostShell can work toward a different approach:

Privacy: command text can stay on the user's machine instead of being sent to a cloud AI provider.
Control: developers can experiment with compatible models and customize prompts and behavior.
Accessibility: users can explore AI-powered command explanations without depending on a paid API for every request.
Independence: after the required model files are downloaded, local inference may work without an internet connection.

These benefits depend on the actual implementation. Local processing, offline support, and model licensing must be verified rather than assumed.

I also like that open models make experimentation possible. I can learn how inference works, compare models, and improve the application without building everything around a single closed service.

The Spirit of It 👻

Halloween is a great excuse to build something unusual, but I wanted GhostShell to be more than a spooky visual experiment.

The terminal is already a place where small mistakes can have big consequences. A mysterious companion that explains commands before you use them is a fun way to make that experience less intimidating.

Imagine entering a potentially destructive command and having the ghost whisper:

“Careful, developer. Some things cannot be brought back from the dead.”

That is the spirit of GhostShell: a little mystery, a little humor, and a useful reminder to understand a command before running it.

What's Next?

Some improvements I want to explore include:

Better explanations for complex shell commands.
More reliable warnings for destructive operations.
Customizable ghost personalities.
A searchable local command journal.
A small local AI model optimized for modest hardware.
Improved offline support and privacy controls.

I'm building this as part of Hacktoberfest 2026, and I hope it can become a useful little companion for developers who enjoy experimenting with open-source AI.

If you like the idea, check out the repository, explore the project, and share your feedback!

GitHub: https://github.com/unknowdeepanshu/GhostShell

Live Demo: https://ghostshell-fawn.vercel.app/

Thanks for checking out GhostShell. Stay curious, understand your commands, and beware of the ghost in the machine. 👻

SellCraft AI: Local-First Product Listings for Independent Sellers

Dipanshu Vishwakarma — Fri, 16 Oct 2026 13:16:33 +0000

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

What I Built

SellCraft AI is a local-first product listing studio for independent sellers.

It turns confirmed product details into editable:

Titles
Descriptions
Features
Keywords and tags
Social captions
FAQs
Markdown, text, and CSV exports

It is designed for sellers who want help writing listings without sending product information to a paid cloud AI API.

SellCraft can help someone selling handmade goods, clothing, electronics, collectibles, or other products create a stronger first draft faster. The seller remains responsible for reviewing every claim before publishing.

Demo

SellCraft runs locally:

npm ci
npm run dev

Open:

http://127.0.0.1:5173

The model can be downloaded from the Settings page or installed with:

npm run setup:model

After setup, generation works without an internet connection as long as the local SellCraft service remains running.

Code

Public repository: View SellCraft AI on GitHub

The project is organized around a small local Node service and a React frontend.

Important areas include:

App.tsx for the listing workflow and editor
listings for prompts and output normalization
model-manager for model setup and verification
model-store.ts for project-local model storage
engine.ts for local inference
storage for IndexedDB persistence
listing.ts for warnings and exports

The model files are stored inside the project’s models directory and are not committed to Git.

How I Built It

SellCraft uses the open-weight SmolLM2 360M Instruct model in quantized ONNX format.

The model runs locally through:

Transformers.js
ONNX Runtime
A Node.js worker thread
A loopback HTTP service
A React and Vite frontend

The application does not use Ollama, a cloud generation fallback, a global model cache, or a paid AI API.

The model is downloaded only when explicitly requested. Every model artifact has a pinned size and SHA-256 checksum. Invalid or incomplete files are rejected.

The application asks the model to generate one listing section at a time. This keeps the response format simple and allows individual sections to be regenerated without replacing the rest of the listing.

Generated output is normalized before it reaches the editor. For example, feature responses wrapped in JSON are converted into plain editable feature lines.

Measured Results

The project was tested on Windows with Node.js 24.14.0 and Google Chrome.

Model setup passed using the existing verified local files.
Unit tests: 15/15 passed.
End-to-end tests: 9/9 passed.
Production build passed.
Model load time: approximately 2.12 seconds.
Sample generation time: approximately 13.0–22.9 seconds per listing section set.
Section-only regeneration preserved unrelated listing sections.
Saved listings remained available with external network requests blocked.
Markdown, plain text, and CSV exports were tested.

The compact model is useful for creating first drafts, but it is not perfect. Real model evaluation showed that it can sometimes repeat text, produce prompt-like filler, omit FAQs, or invent unsupported compatibility and benefit claims.

SellCraft treats AI output as a draft rather than a source of truth. Sellers must verify every generated claim.

Offline Behavior

Initial installation and model setup require internet access.

After that:

Start the local service with npm run dev or npm start.
Keep the local service running.
Disconnect from the internet if desired.
Continue generating listings and opening saved products locally.

Saved listings are stored in browser IndexedDB. They are not synchronized or encrypted, so important work should also be exported.

Photos remain local references. The text model does not analyze or upload them.

Why Does Open Innovation Matter?

Open innovation made it possible to build a private, local workflow without depending on a paid AI provider.

Using an open-weight model means:

Product details stay on the seller’s device.
There is no per-request API fee.
The model can be inspected, replaced, or customized.
The application can continue working without internet after setup.
The project does not depend on a single commercial AI platform.

The trade-off is that local inference requires CPU, memory, disk space, and human review. A small open model can be practical, but it cannot replace seller knowledge or factual verification.

Final Thoughts

SellCraft AI is built around a simple idea: AI should help sellers get past the blank page without taking control of their product data.

The model writes the first draft. The seller decides what is true.

BirdLens AI: Identify Birds Locally, Explore Nature Offline

Dipanshu Vishwakarma — Sun, 11 Oct 2026 06:29:13 +0000

BirdLens AI — An Open-Source AI Bird Identification Companion

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

What I Built

I built BirdLens AI, a browser-based bird-identification companion for beginner birdwatchers, curious walkers, and anyone who wants to learn more about the wildlife around them.

My approach to “Touch Grass” is simple: use technology to support an outdoor experience, not replace it.

The intended flow is:

Go outside → Notice a bird → Take a photograph → Get a suggested identification → Return to observing.

BirdLens AI lets users:

Upload a bird photograph and identify it locally using an open-weight model.
Review the top five predictions rather than trusting a single answer.
Read sourced information about the suggested species.
Save photographs and results in a local discovery journal.
Track simple outdoor observation challenges.
Revisit saved discoveries and identify photographs offline after the required assets and model have been cached.

The journal turns individual sightings into a personal record of exploration. The challenges give users a reason to notice more of their surroundings.

The goal is to make the screen the shortest part of the experience.

Demo

Live project: Try BirdLens AI

Try It Yourself

Open the app and choose Identify a bird.
Upload a clear photograph of a bird.
Wait for the model to load and run inference.
Review the suggested species, model score, and alternative predictions.
Save the result and explore My discoveries.

The first identification downloads the model. Later identifications can work offline once the production application and model have been successfully cached, provided the browser retains that storage.

New online species references may still need an internet connection.

Please observe birds from a respectful distance. An identification app is not a reason to approach or disturb wildlife.

Code

Public repository: View BirdLens AI on GitHub

Technology Stack

React and TypeScript — Interface and application logic
Vite — Development and production builds
Tailwind CSS — Styling
ONNX Runtime Web — Browser-based inference
IndexedDB — Local discovery journal
Service Worker and Cache Storage — Production offline support

There is no application backend, user account requirement, or paid AI inference API.

How I Built It

An Open-Weight Model Is the Core, Not an Extra Feature

BirdLens AI uses the chriamue/bird-species-classifier, an EfficientNet-B2 model with 525 output classes.

The publisher declares the model MIT-licensed. Its weights are loaded in ONNX format and executed through ONNX Runtime Web.

Without that model and the local inference runtime, the application's main identification feature would not work. Open AI is therefore central to the project.

Running Inference in the Browser

The inference pipeline works as follows:

Decode the uploaded photograph.
Resize and normalize it for the model.
Run the ONNX classifier using WebAssembly inside a worker.
Convert the output into ranked model probabilities.
Display the top five predictions.

Running inference in a worker keeps it separate from the main interface.

Photographs are not sent to a remote AI service for identification. The application does download model assets and may fetch online species references, but image inference happens on the user's device.

Showing Uncertainty Honestly

A model prediction is not a confirmed sighting.

BirdLens AI uses score and prediction-margin heuristics to mark uncertain results as tentative. It also shows alternative candidates so users can compare possibilities.

There are important limitations:

The model is a closed-set classifier, not a bird detector.
Unsupported species and non-bird images can produce misleading predictions.
Poor lighting, small subjects, and similar-looking species can confuse it.
Model probabilities are not calibrated identification confidence.

Scientifically important observations should be independently verified.

A Local Journal and Conditional Offline Support

Saved discoveries are stored in IndexedDB, including the photograph and identification results.

In production, a service worker caches application assets. The model is cached after loading, enabling subsequent offline identification.

This is not offline immediately. The application and model must first be loaded and cached. Clearing browser data or storage eviction can remove cached assets and saved discoveries.

Development with an AI Coding Assistant

I used an AI coding assistant to help develop the project. The finished application runs a real open-weight classifier locally rather than using mocked predictions or a hosted AI API.

Deploying on Vercel

Because BirdLens AI runs in the browser, I deployed it on Vercel without building a backend.

My deployment settings are:

Setting	Value
Framework preset	Vite
Build command	`npm run model:download && npm run build`
Output directory	`dist`
Install command	`npm ci`

The model-download step is essential.

The model weights are ignored by Git. During deployment, npm run model:download retrieves a pinned model revision and verifies its checksum before saving it to public/models/birds.onnx.

The build then includes that model in the deployment so the browser can load it for identification.

No backend environment variables or AI API keys are required.

Why Does Open Innovation Matter?

For BirdLens AI, openness makes privacy, offline use, and model control practical.

A hosted-only AI API would require sending photographs to a remote service and maintaining a connection for each identification. A redistributable model lets the user's browser perform that work locally.

That makes several things possible.

Keep Image Inference on the Device

Users do not need to upload their photographs to a third-party AI service to get a prediction.

Continue Without a Signal After Setup

Once the necessary application assets and model are cached, identification can work without an internet connection.

That is useful for a nature-focused application, where connectivity is not always available.

Avoid Per-Request AI Fees

Local inference does not require paid API calls or credentials. Hosting and initial downloads still consume resources, but each identification does not depend on a billable inference request.

Inspect and Improve the Implementation

Developers can review the labels, preprocessing, model revision, and output handling.

They can also evaluate a different model and adapt the application without depending on a closed provider's inference endpoint.

Open weights do not automatically make a model accurate. What they provide here is control over where inference happens and how the system can be inspected, tested, and changed.

That is the kind of open innovation I wanted to build around: a small tool that helps people understand the world outside without making them dependent on a remote AI service.

My Agent Session

I used an AI coding assistant during development, but I do not currently have a shareable DevRelay recording of the build session.

I am sharing the implementation through the source repository instead.