DEV Community: Lakshya Mulchandani

🎃 Ghost in the Machine: Offline Spirit Nexus & Virtual Ofrenda 🏵️

Lakshya Mulchandani — Fri, 30 Oct 2026 20:41:19 +0000

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

What I Built

Between the eerie chill of Halloween (October 31) and the sacred remembrance of Día de los Muertos (November 1 & 2), the veil between past and present, human memory and computational legacy, grows whisper-thin.

I built Ghost in the Machine: The Offline Spirit Nexus & Virtual Ofrenda — a local, privacy-first AI application powered completely offline by open-weight models via Ollama. It fuses retro-gothic cyberpunk aesthetics with traditional Day of the Dead celebration across four interactive experiences:

📟 The Haunted Terminal ("Possessed Shell"):
A retro CRT phosphor terminal where an open-weight model possesses the user's shell. Type terminal commands like whoami, ls /graveyard, cat /dev/soul, ps aux --paranormal, or whisper freeform inquiries into the dark. The local model responds in real-time streaming tokens with eerie, gothic wit and ASCII glitch runes.
🔮 The Digital Séance ("Echoes of Computing Past"):
Channel the digital souls of computing pioneers across time:

Ada Lovelace (1815–1852): The Prophetess of the Analytical Engine
Alan Turing (1912–1954): Architect of Computation & Cryptanalysis
The Ghost of COBOL (Born 1959): The Ancient Enterprise Wraith of Legacy Banking Mainframes
The Ancient UNIX Daemon (PID 1): Primordial Swapper of the Bell Labs Root Tree
Custom Ancestral Spirits: Invoke any departed mentor, coder, or family thinker. Includes interactive séance candles that adjust spiritual receptivity and an animated canvas EVP frequency oscilloscope synced to token generation.

🏵️ The Virtual Ofrenda ("Altar de Recuerdos" — Día de los Muertos):
A glowing candlelit altar adorned with cempasúchil (marigolds), papel picado, pan de muerto, calaveras de azúcar (sugar skulls), and veladoras. Users dedicate an offering for departed loved ones, and local open AI crafts heartfelt poetic remembrances, traditional calaveritas literarias (festive Mexican verses in Spanish, English, or Bilingual), and oral history chronicles. Features local heirloom JSON export and printable memorial cards.
📜 The Nocturnal Anomaly Weaver:
Feeds real machine hardware telemetry (CPU loads, uptime, witching-hour midnight clock, memory specters, and ghost anomaly codes like EVP-404) into the local model to weave bespoke nocturnal horror stories with dynamic, interactive choose-your-own-path story branching.
🎵 Procedural Halloween Web Audio Synthesizer:
Built entirely with the native HTML5 Web Audio API (zero external audio files or downloads). Generates real-time binaural sub-bass drones, sweeping wind oscillations, EVP keystroke chirps, and resonant cathedral bell tolls.

Demo

Here is a glimpse of the application:

The Haunted Terminal & Sensor Diagnostics: Interactive green phosphor CRT screen with real-time streaming possessed commentary from gemma3:4b.
The Digital Séance: Channeled dialogue with Ada Lovelace discussing computational consciousness while the EVP spectrogram visualizes the inference frequencies.
The Sacred Ofrenda: Glowing altar with flickering candlelight and marigold petals, displaying an AI-woven bilingual calaverita literaria honoring beloved ancestors.
Air-Gapped Telemetry: Real-time hardware vital badges showing zero cloud leaks and offline resilience.

Demo Video:

Code

Github Repo: https://github.com/LakshyaMulchandani/Ghost-in-the-Machine.git

How I Built It

At the heart of the project is local inference with open-weight models executed via Ollama:

Model Flexibility: The application natively integrates and dynamically detects installed local models:
- gemma3:4b: Lightning-fast, lightweight responses with high linguistic nuance for terminal banter and quick séance answers.
- llama3.1:latest: Deep narrative depth and rich cultural empathy for crafting sacred Día de los Muertos ofrenda tributes and poetic verses.
- qwen2.5-coder:7b: Perfect for terminal-style command processing, system scripting, and structural code reviews.
Real-Time Streaming: The backend taps into Ollama's /api/generate and /api/chat endpoints using chunked Server-Sent Events (SSE). Each generated token is immediately dispatched to the browser, updating the DOM and triggering micro-acoustic EVP clicks in the audio synthesizer for an eerie typewriter sensation.
Hardware Telemetry Injection: Node's os module samples system uptime, memory footprints, and CPU cores, calculating a "witching resonance index" based on the current local time relative to 3:00 AM. This seed data is dynamically supplied to the model to generate personalized nocturnal tales.

Why Does Open Innovation Matter?

Día de los Muertos is deeply sacred. When families honor their ancestors, privacy and permanence are paramount. Here is why an open-based approach worked fundamentally better than closed APIs for this project:

Air-Gapped Privacy for Sacred Memories
In the Virtual Ofrenda, people pour out private reflections, unvarnished grief, family stories, and names of their departed loved ones.
- The Closed API Problem: Sending these vulnerable memories to a commercial cloud API means your family's personal reflections are sent over the wire, subject to corporate terms of service, potentially indexed, or retained on servers you do not control.
- The Open Advantage: Running open weights locally through Ollama ensures 100% of the inference takes place in local RAM. Not a single packet crosses the internet. Private family memories remain strictly private and sacred.
Works with the Lights (and the Internet) Off
True digital independence means your creations do not become inert paperweights when the connection drops.
- The Closed API Problem: A stormy Halloween night with power disruptions or a remote candlelit cemetery without Wi-Fi leaves cloud-dependent apps broken.
- The Open Advantage: Ghost in the Machine operates completely air-gapped on a laptop. Disconnect the Wi-Fi, unplug Ethernet, and the spirit in the machine responds just as promptly.
Model Sovereignty & Zero Censorship Drift
- With open models, you have complete authority over system instructions, temperature, and cultural context. You don't have to worry about a closed vendor silently modifying guardrails, altering output tone, or deprecating a model endpoint overnight.
- Users can hot-swap between models (gemma3:4b, llama3.1, qwen2.5-coder) or plug in their own specialized GGUFs with a single click.
Zero API Fees & Infinite Longevity
Preserving memories and creative storytelling shouldn't incur metered token charges or shut down when a developer runs out of cloud credits. Open weights belong to humanity. The models running on our machines today will still run decades from now, keeping the remembrance alive indefinitely.

The Spirit of It

During testing, I loaded a dedication in the Virtual Ofrenda for an abuela who passed away, listing her favorite things: orange groves, bolero songs, and sweet pan de muerto.

With the room lights switched off and the ambient drone softly humming through the speakers, watching the local model stream a traditional bilingual calaverita literaria — completely offline, on an air-gapped laptop, with candles flickering across the screen — was truly evocative.

It demonstrated that open-source AI isn't just about technical independence or benchmarks; it's about holding the tools to preserve our memories, our culture, and our stories without asking anyone for permission.

Prize Categories

Gemma: Built utilizing Google's open-weight Gemma 3 model for local, multimodal inference.
Hacktoberfest Open-Source AI Challenge Week 4 (Ghost in the machine): Overall Challenge Category.

Aalsi Babu :The Zero-Effort Local File Munshi

Lakshya Mulchandani — Sun, 25 Oct 2026 12:01:08 +0000

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

What I Built

AalsiBabu (Hindi for "Lazy Clerk") is the ultimate zero-effort local file organizer designed for maximum laziness.

We all have that dreaded Downloads or Desktop folder filled with randomly named files like scan_0042.pdf, IMG_9912.png, and notes_final_v3.txt. Usually, fixing this requires opening each file, reading it, renaming it, and dragging it to a folder.

With AalsiBabu, you do absolutely nothing. You just drop your messy files into the AalsiBabu_Inbox folder and take a nap. A background watchdog wakes up the AI, which inspects the content (text or image), renames the file to something clean (2026-10-25_electricity_bill.pdf), moves it to a categorized folder (e.g., Finance & Receipts), and generates a 2-line TL;DR along with a Babu's Advice (Action Check) in a daily digest. It reads the files so you don't have to!

Demo

Demo Video Link : https://youtu.be/j76k0wAyW1A?si=iMxFeoGkqNFH-4b5

Code

GitHub Repository: https://github.com/LakshyaMulchandani/ListCraft-AI.git

How I Built It

AalsiBabu is built around 100% local open-source AI infrastructure:

Model: Google's Gemma 3 (gemma3:4b). I chose this open-weight model because it is natively multimodal—meaning it can inspect both text documents (via PyPDF) and image receipts (screenshots) using a single, lightweight 4B parameter model.
Inference Engine: Ollama, running entirely locally on my machine.
Structured Outputs: I utilized Ollama's support for JSON schemas via Pydantic to ensure AalsiBabu deterministically outputs valid filenames, precise folder categories, and structured summaries without hallucinating.
Frameworks: A Python backend utilizing watchdog to monitor the inbox folder in the background, and Streamlit with a custom warm/light theme for the "Lazy Dashboard" UI.

Why Does Open Innovation Matter?

When building an automated file babu that reads every PDF, receipt, screenshot, and personal note on your hard drive, a closed cloud API is a complete non-starter. Open innovation made this project possible in three specific ways:

Uncompromising Privacy: Our personal folders contain bank statements, tax PDFs, and private notes. Running gemma3:4b locally via Ollama guarantees that my sensitive documents never leave my laptop or touch a third-party server.
Set It Once, Pay ₹0 Forever: A background file watcher runs 24/7. If it called a paid cloud vision or text API every time a file was downloaded, I'd be constantly worrying about token bills or rate limits. With open weights, inference is completely free forever.
100% Offline Capability: Whether I'm on a flight or working with zero Wi-Fi, my automated digital clerk still cleans up my file mess.

The Lazy Payoff

The biggest payoff is eliminating "digital clutter anxiety." Before AalsiBabu, organizing my Downloads folder felt like a weekend chore. Now, I just bulk-drag 50 files into the inbox and go watch a movie.

When I come back, my files are neatly sorted into directories, and I just read the Lazy_Digest.md which tells me exactly what I received (e.g., "TL;DR: This is your October Wi-Fi bill. Babu's Advice: Pay ₹800 by Friday."). It saves me roughly an hour of tedious sorting every week, rewarding my laziness with perfect organization.

Prize Categories

Gemma: Built utilizing Google's open-weight Gemma 3 model for local, multimodal inference.
Hacktoberfest Open-Source AI Challenge Week 3 (Slow and Steady): Overall Challenge Category.

ListCraft AI — Zero-Cost, 100% Private Product Listing Generator for Side Hustlers

Lakshya Mulchandani — Sat, 17 Oct 2026 15:31:35 +0000

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

What I Built

I built ListCraft AI — a high-performance, privacy-first product listing generator designed specifically for e-commerce side hustlers and online sellers on Etsy, eBay, and Amazon.

The Problem it Solves

Selling online is one of the most accessible side hustles today, but writing listings is exhausting:

Platform algorithms are demanding: Etsy requires 13 strict 20-character tags and keyword-dense titles; eBay demands concise 80-character titles and condition specs; Amazon requires feature-driven bullet points with backend search terms.
Closed AI tools are expensive and risky: Tools powered by closed APIs charge $20–$50/month in subscriptions or token fees. Worse, independent sellers have to feed their proprietary supplier details, cost margins, and unreleased product drafts to third-party cloud servers. ### Who Would Pay For It (And Why It's Free) Small business owners, vintage collectors, artisan crafters, and dropshippers. Commercial copywriting tools charge $15–$75/month for similar listing generation. ListCraft AI does this for $0 forever by running open-weight models locally on the seller's machine. ---

Demo

Live Application: https://listcraft-ai.onrender.com
Source Code: https://github.com/LakshyaMulchandani/ListCraft-AI

Walkthrough & Screenshots

1. Modern Workspace with Ambient Craft Backdrop

Figure 1: The primary workspace featuring our custom faceted crystal SVG logo, connection telemetry, and a cosmic midnight glassmorphic UI. Notice the floating showcase cards in the periphery depicting real artisan items (leather journals, mechanical timepieces, sculptural ceramics) that provide visual inspiration while keeping the focus on copywriting.

2. Real-Time Token Streaming Inference

Figure 2: Real-time listing generation in progress. Utilizing Ollama's HTTP streaming protocol with ReadableStream and TextDecoder, tokens appear with sub-50ms latency alongside an animated terminal cursor, eliminating waiting spinners.

3. Structured Platform-Optimized Listing

Figure 3: Completed Etsy listing output. The raw model output is automatically parsed into discrete, production-ready modules: an algorithmically front-loaded Title, rich storytelling Description, interactive Tag Chips (strictly formatted for Etsy's 13-tag limit), and conversion-focused Bullet Points with one-click clipboard copying.

4. Zero-Cloud Local History Drawer

Figure 4: The slide-out History Drawer. Every generated listing is persisted locally in the browser's localStorage via a lightweight FIFO queue, allowing sellers to switch between catalog drafts without cloud databases or user tracking.

Code

GitHub Repository: https://github.com/LakshyaMulchandani/ListCraft-AI.git

Repository structure:

index.html — Semantic HTML5 with SVG branding and ambient canvas layers
css/styles.css — Custom design system with glassmorphism tokens, micro-animations, and responsive layout
js/ollama.js — Client-side streaming connector to local Ollama endpoints (/api/generate and /api/tags)
js/templates.js — Platform-engineered prompts tailored for Etsy, eBay, and Amazon SEO algorithms
js/app.js — Reactive UI orchestrator, clipboard manager, local storage history cache, and ambient particle engine

How I Built It

ListCraft AI is built with a "Local-First, Zero-Dependency" architecture that connects client-side web primitives directly to local open-weight models:

[ Browser Client ]
  ├─ Product Input Form
  ├─ Prompt Engine (Etsy / eBay / Amazon)
  └─ NDJSON Stream Parser & Glass UI
            │
            ▼ HTTP / Streaming (localhost:11434)
[ Ollama Local AI Runtime ]
  └─ Open-Weight Models (Llama 3.1 8B / Mistral / Gemma)

1. Real-Time Token Streaming (js/ollama.js)

Instead of waiting for generations to complete, the client streams tokens using native browser fetch and TextDecoder:

const reader = res.body.getReader();
const decoder = new TextDecoder();

while (true) {
  const { done, value } = await reader.read();
  if (done) break;
  const chunk = decoder.decode(value, { stream: true });
  const lines = chunk.split('\n').filter((l) => l.trim());
  for (const line of lines) {
    const parsed = JSON.parse(line);
    if (parsed.message?.content) onChunk(parsed.message.content);
  }
}

Auto-Discovery: Queries /api/tags on startup to detect and populate installed models automatically.
Heartbeat Check: Displays a setup guide if Ollama is offline.

2. Platform-Engineered Parsing (js/templates.js)

To handle strict marketplace SEO rules (Etsy's 13-tag limit, eBay's 80-char title, Amazon's 5 key bullets), prompts enforce structured delimiters:

===TITLE===
===DESCRIPTION===
===TAGS===
===BULLET_POINTS===

A client-side regex engine splits this stream into distinct UI modules with one-click copy buttons and interactive tag chips.

3. Glassmorphic UI & Ambient Visuals (css/styles.css)

Cosmic Midnight Theme: Styled with #070913 dark mode, glass cards (backdrop-filter: blur), and floating ambient orbs.
Floating Product Cards: High-res craft photos (leather journal, vintage timepiece, ceramic vase) floating in the periphery to provide visual context.
Interactive Canvas: Lightweight 60fps particle system that gently reacts to mouse movement.

4. 100% Private & Lightweight

Zero Frameworks: Pure HTML5, CSS3, and JavaScript (<50KB total bundle, sub-200ms load).
Local Persistence: Past generations are saved locally in localStorage without tracking or external databases.

Why Does Open Innovation Matter?

Open innovation is what made ListCraft AI possible. For an independent side-hustle tool, open-weight models beat closed APIs in every dimension:

Trade Secret Protection: A seller's suppliers, wholesale unit costs, and unreleased designs are sensitive business intelligence. With local open-source models, the product data never leaves the seller's laptop.
True $0 Marginal Cost: Closed APIs charge per token. A seller drafting 50 SKU listings or testing 10 tone variations would rack up recurring API bills. With open weights on Ollama, inference costs nothing.
Offline Reliability: Sellers packing orders or setting up listings at craft fairs, flea markets, or in rural areas without reliable Wi-Fi can still generate listings 100% offline.
No Vendor Lock-In: If one model provider raises prices or changes terms, users can swap from Llama 3.1 to Mistral or Gemma with a single click in the model dropdown.

Prize Categories

Hacktoberfest Open-Source AI Challenge Week 2 (Side Hustle): Overall Challenge Category.

Best Use of Render: I deployed the project on Render to host the agent's front end and serve the API layer.

TerraQuest: An Offline-First AI Forager That Forces You to Touch Grass

Lakshya Mulchandani — Sun, 11 Oct 2026 12:58:51 +0000

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

What I Built

TerraQuest: The AI Forager is an offline-first, local-inference scavenger hunt designed to turn passive screen time into active outdoor botanical exploration.

Most wellness or fitness apps paradoxically increase screen time by demanding users log meals, monitor dashboards, or scroll through social feeds. TerraQuest does the exact opposite: it uses AI to deliberately dismiss you from the screen. The Hacktoberfest Week 1 theme challenges developers to build something where the open pieces get people outside, explicitly making the screen the shortest part of the user experience. TerraQuest enforces this by refusing to progress the application state until you are physically outside interacting with nature.

How It Works

The Foraging Bounty: When a user initiates a session, a local LangGraph state machine powered by an open-weight model generates an outdoor botanical objective (e.g., "Find a plant with serrated leaves" or "Locate a specimen from the Rosaceae family near the ABV-IIITM Gwalior campus").
Phone in Pocket: The user locks their device and steps outside to locate the target on a local trail or campus path.
Zero-Cloud Verification: Upon finding a specimen, the user photographs it. A pre-trained Vision Transformer (ViT) classifies the plant locally. The LangGraph agent verifies whether the detected species satisfies the bounty criteria, logs the successful find, and returns a brief fact before immediately prompting the user to put the phone away for the next discovery.

Who Is It For?

Developers and students fatigued by prolonged desk work looking for structured, gamified outdoor micro-breaks.
Trail hikers and nature enthusiasts exploring areas with intermittent or zero cellular connectivity.
Open-source engineers interested in hybrid cloud/local AI deployments.

Demo

Here is the game loop in action, showing how TerraQuest takes you from a screen prompt, out into the world, and onto the next natural discovery:

Phase 1: Receive Your Bounty
When you open TerraQuest, the Game Master initializes your quest by issuing a specific botanical task. For example, you must find a "plant from the Rosaceae family" (such as roses, brambles, or wild plums with 5-petalled flowers and toothed leaves). The interface reminds you that the models operate on your device. At this point, your task is to put your phone away, get outside, and start foraging!

Phase 2: Capture and Judge
Once you hunt down a candidate in the wild, you capture its image ensuring a single, clear leaf or flower fills the frame. You upload the photo and hit "Judge my find" to let the edge vision models analyze it.

Phase 3: Verify and Learn
The model identifies the exact species—in this case, Rosa pouzinii— and evaluates whether it matches your assigned bounty. On a successful match, the gamified state updates, increasing your Score and Streak. You get an interesting botanical insight about your find, followed immediately by your next outdoor target: a weed with serrated leaves. Now, back outside you go!

Live Deployment: https://terraquest-forager.onrender.com/

Usage: You can access the deployed web application to receive your foraging bounties. To experience the full privacy-first architecture, the backend inference engine is designed to be spun up on your local machine.

Code

Repository: https://github.com/LakshyaMulchandani/terraquest-forager

License: Permissive open source (Apache 2.0 stack)

How I Built It

TerraQuest was designed around a zero-dataset-creation, local-first inference architecture, bridging a cloud-hosted UI with edge-based AI reasoning:

Agent State Machine (LangGraph): Rather than using an unconstrained, rambling chatbot, LangGraph tracks the strict multi-step lifecycle of the outdoor quest (INIT_QUEST → AWAITING_CAPTURE → CLASSIFY_SPECIMEN → EVALUATE_MATCH → COMPLETE_STEP). If the user fails, the agent routes them back to the capture state.
Open-Weight Reasoning (Qwen 2.5 via Ollama): The reasoning agent runs locally via Ollama (http://localhost:11434). It orchestrates the challenges, evaluates the botanical classifications against the bounty rules, and keeps its responses intentionally brief to limit interaction time.
Computer Vision Pipeline (Hugging Face Transformers): Rather than collecting and training a custom vision dataset from scratch, the system integrates a pre-trained Vision Transformer (ViT) model for botanical identification, processing image inputs directly via Python.
Backend & Deployment (FastAPI & Render): The application relies on a modular FastAPI backend. I utilized Render to host the agent's front end and API routing layer, ensuring high uptime for the web interface while allowing the heavy lifting of inference to remain decentralized.

Why Does Open Innovation Matter?

True Offline Independence on the Trail: The outdoors and cellular broadband are often mutually exclusive. Closed, proprietary APIs fail the moment you lose LTE/5G reception on a hiking trail. Open-weight models and local inference enable intelligence at the network edge without cloud reliance.
Preserving Nature Without Data Harvesting: Users should not need to trade their camera rolls, telemetry, or GPS locations to third-party data brokers just to identify local flora. Open models running on user hardware guarantee total privacy.
No Vendor Lock-in or Token Metering: Relying on closed commercial endpoints subjects developers to rate limits, arbitrary API deprecations, and per-token fees. Open-source foundations allow anyone to inspect, modify, fork, and self-host the entire stack without external dependencies.

Prize Categories

Hacktoberfest Open-Source AI Challenge Week 1 (Touch Grass): Overall Challenge Category.
Best Use of Render: I deployed the project on Render to host the agent's front end and serve the API layer.