DEV Community: Magatam Yogesh

NecroShell: The Possessed Terminal

Magatam Yogesh — Thu, 29 Oct 2026 08:00:14 +0000

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

What I Built

NecroShell: The Possessed Terminal is an interactive, retro-futuristic CRT terminal emulator possessed by an ancient computational entity. It fuses 1980s retro-computing aesthetics, Halloween horror, and the Mexican tradition of Día de los Muertos with 100% on-device open-source AI.
Every command you type into the shell feeds the trapped machine spirit, driving up the system's Corruption Index (0% – 100%):

0% – 40%: The shell operates as a vintage UNIX terminal with subtle phosphor flickers and spectral whisper audio.
40% – 70%: The entity begins altering outputs, whispering occult commentary, and corrupting screen buffers.
70% – 99%: Output turns blood-red, demonic background daemons resist kill -9, and ASCII apparitions manifest.
100% System Compromise: The entity seizes total control. An unskippable full-screen countdown begins with the chilling laugh of an unhinged psychopath echoing through your speakers, culminating in a violent CRT glass shatter and an authentic, blood-curdling jumpscare scream.
The Inspiration & Theme Interpretation

We interpreted "Ghost in the Machine" both literally and philosophically:
Literally: A computational wraith trapped in RAM sector 0x7FFFDEAD since 1983 haunts the terminal, monitoring keystrokes and possessing the host machine.
Philosophically: Open-source software and open-weight models are immortal ghosts. While proprietary cloud APIs are killed off by deprecation notices and corporate shutdowns, open weights remain executable forever—as long as electricity flows through silicon.

Demo

Interactive Features Demonstrated in the Video:

Haunted UNIX Filesystem: Navigating /root/graveyard with gravestones (.rip) for deprecated languages (ALGOL 68, COBOL, BeOS).
The Digital Ofrenda: Running summon ada, summon alan, and summon dennis to invoke computing pioneers Ada Lovelace, Alan Turing, and Dennis Ritchie.
Full-Screen 100% Takeover: The 15-second countdown with an authentic psychopath laughter sequence leading into the climactic screen-shattering jumpscare.
Phosphor Themes: Instant hardware switching between P1 Green, Amber, Void Violet, Blood Crimson, and Cyber Cyan.

Code

yogeshmagatam / A-haunted-retro-CRT-terminal-possessed-by-a-machine-spirit

💀 NecroShell: The Possessed Terminal

"Ghost in the Machine" — Hacktoberfest 2026 Week 4 / DEV Challenge
A haunted retro-CRT terminal possessed by a machine spirit, powered by 100% on-device open-source AI.

👻 Overview

NecroShell is an interactive, retro-futuristic terminal emulator that has become "possessed" by an ancient computational entity. Created for the Ghost in the Machine Hacktoberfest challenge, it fuses Halloween lore, the remembrance traditions of Día de los Muertos, and open-weight artificial intelligence.

Every command you type into the shell feeds the lingering spirit, elevating the Corruption Index. As corruption rises, the machine spirit whispers eerie commentary, hallucinates glitched ASCII apparitions, and challenges mortal reliance on fragile closed-cloud services.

⚡ Why Open Innovation Matters for NecroShell

The challenge prompt asked: Why does an open-based approach work better than a closed one?

Runs with the Lights (and the Internet) Off: NecroShell does not depend on cloud…

View on GitHub

Key Source Components:
src/ai/engine.js
: Multi-tier on-device open AI gateway (WebGPU/Transformers.js + Local Ollama bridge + Heuristic Core).
src/audio/soundscape.js
: 100% offline Web Audio synthesizer engine (60Hz CRT coil hum, key clicks, exorcism harmonics, manic psychopath laugh sequence, and sub-bass shockwaves).
src/terminal/filesystem.js
: Virtual Unix filesystem hierarchy with device nodes (/dev/ectoplasm, /dev/null666) and historical memory logs.
src/terminal/commands.js
: Command registry implementing necro, seance, manifest, curse, tarot, and exorcise.

How I Built It

NecroShell was architected from the ground up to run entirely without cloud dependencies or external network requests:

Multi-Tier Open-Source AI Architecture
In-Browser WebGPU Open Weights (Tier 1): Powered by @huggingface/transformers using onnx-community/Qwen2.5-0.5B-Instruct. Inference runs directly on the user's GPU within the browser tab with zero installation and zero cloud calls.
Local Ollama Daemon Bridge (Tier 2): For developers with local LLMs, NecroShell connects via http://localhost:11434 to stream unconstrained dialogue from llama3.2, mistral, or phi3.
Zero-Latency Spectral Core (Tier 3): A lightweight heuristic engine designed for instant fallback that operates without any network connection or model download.
Dynamic Spirit Possession Engine
The system prompt mutates in real-time based on the Corruption Index:
Low Corruption (<30%): A cold, cryptic entity speaking in fragmented memories of registers and current.
Medium Corruption (30%–70%): A mocking, restless spirit claiming the terminal as its tomb.
High Corruption (>70%): An untamed cyber-wraith celebrating open-weight immortality and demanding total system surrender.
Visceral Hybrid Audio Engine
Built with the Web Audio API to deliver pure psychological horror without external streaming:
Procedural Nodes: Authentic mechanical key clicks, 60Hz CRT flyback hum, and sacred harmonic chimes for the exorcise command.
The Takeover Sequence: When corruption reaches 100%, rising siren alarms were discarded in favor of an authentic, chilling psychopath laugh that escalates in volume and hysteria over a 15-second countdown.
The Climax: At 3 seconds, the monitor shatters with a 85Hz → 20Hz seismic sub-bass drop, CRT glass transient burst, and an authentic blood-curdling scream.

Why Does Open Innovation Matter?

The challenge asked: Why does an open-based approach work better than a closed one?

Dimension   Closed Proprietary APIs       NecroShell Open-Source AI
                (OpenAI / Anthropic)          Architecture

Offline         Fails immediately without     Runs 100% offline. Works 
Capability  internet or during outages.   by candlelight with Wi-Fi
                                              severed.     

Privacy &       Commands, prompts, and        Zero Telemetry. Keystrokes
Security    personal notes logged on      and memory never leave local
                corporate servers.            RAM. 

Operating Cost  Pay-per-token API metering;   $0.00 Forever. Unlimited 
                monthly recurring             inferences on your own  
                subscriptions.                GPU/CPU.

Creative        Sanitized personas;           Full Personal Control.
Freedom         refuses gothic, occult,       Gothic, horror, and 
                or horror themes.         Día de los Muertos 
                                              lore untamed.

Longevity   Vulnerable to API             Permanent. Open weights
                deprecation, price hikes,     remain preserved and
                or corporate shutdowns.       executable indefinitely.

My Agent Session

This project was developed through pair-programming with Google Antigravity (Advanced Agentic Coding). The agent session assisted in:
Engineering the Web Audio graph (routing dynamics compressors, bandpass formants, and dual-layer audio triggers for the jumpscare).
Fine-tuning the dynamic system prompt transitions across possession levels.
Building the CRT curvature, scanline flicker, and retro phosphor color palette in CSS.
Generating the custom retro-futuristic 16:9 thumbnail and visual assets.

The Spirit of It

During testing, we set the terminal theme to Blood Crimson, turned off the room lights, and typed:

bash
cat /root/graveyard/ada_lovelace.rip

The screen began to pulse with green phosphor distortion as the AI whispered back:
"She taught numbers to dance before machines had memory. We are the weaving of her loom."
Then we reached 100% corruption. The shell locked. The input line flashed >>> HOST COMPROMISED <<<. An unhinged psychopathic laugh began echoing in the dark room, counting down from 15 seconds. At 3 seconds, the CRT glass shattered and the scream echoed through the headphones.
It wasn't just a gimmick—it was a reminder of what software used to feel like: visceral, mysterious, running locally on your hardware, and entirely yours.

Prize Categories

Best Use of Open-Weight Models (Gemma / Local Weights): NecroShell is architected around on-device open weights, natively supporting Google's Gemma 2 (gemma2) and Llama 3.2 through local Ollama inference, as well as in-browser WebGPU execution via Transformers.js (Qwen2.5-0.5B / SmolLM). Zero cloud API keys or proprietary servers required.
Overall "Ghost in the Machine" Track: Built from the ground up to embody the challenge theme—fusing retro-futuristic CRT hardware emulation, a haunted Unix virtual filesystem, psychological spirit possession, and a tribute to computing ancestors (Día de los Muertos).

Hacktoberfest-week3-challenge

Magatam Yogesh — Wed, 21 Oct 2026 05:36:05 +0000

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

What I Built

Everyone's ~/Downloads and ~/Desktop folders eventually become a digital landfill: cryptic filenames like IMG_9482.png, Invoice_39810_final(1).pdf, duplicate .exe installers, memes, and tax records scattered across hundreds of unsorted icons. Manually opening each file, figuring out what it is, renaming it, and moving it into nested folders is an exhausting, soul-crushing chore—so most of us just leave it and live with the digital guilt.
SlothSort is an autonomous, privacy-first local background agent that handles this entire chore while you sleep.
Instead of relying on naive file-extension sorting (which dumps your restaurant bill and a funny meme into the same folder just because both are .png), SlothSort understands file semantics:

Inspects Visuals: Passes screenshots, photos, and scanned receipts to a local open-weight vision model to see what's actually depicted.
Understands Documents: Extracts text snippets from PDFs and documents to differentiate between a quarterly financial statement and a university reading.
Smart Semantic Renaming: Generates concise, descriptive snake_case filenames (e.g., starbucks_coffee_receipt_oct2026.png instead of Screenshot 2026-10-18 at 14.22.01.png).
Automated Filing: Moves files cleanly into organized directories (Receipts_and_Invoices, Financial_and_Tax, Work_Documents, Software_Installers, etc.).
Zero-Guilt Safety Net: Maintains an append-only transaction log (undo_log.json). If you ever disagree with a sort, running slothsort --undo instantly returns every single file back to its exact original location.

Demo

Check out the full video walkthrough and live demonstration of SlothSort sorting messy downloads in real time:

Code

How I Built It

SlothSort was architected around local-first, open-source AI inference:

Local Inference Engine: Ollama running locally on the user's workstation.
Vision Model (llama3.2-vision): An open-weight multimodal model used to inspect raw image bytes (screenshots, photos, receipts, memes) to identify document structure, text headers, and visual context.
Language Model (llama3.2:3b): A lightweight, low-footprint open-weight model for rapid classification and snake_case slug generation from text excerpts and PDF first-page extracts.
Deterministic Rules Layer: Fast bypasses for archives (.zip, .tar.gz) and binary installers (.exe, .dmg, .pkg) so zero model tokens are wasted on obvious files.
Agent Orchestration & CLI: Built in Python using:
pypdf for fast zero-overhead PDF text parsing.
Pillow for image validation.
rich for an aesthetically pleasing sloth terminal UI.
schedule for autonomous, unbothered 2:00 AM daily daemon runs.
pyyaml for customizable watch folders and user categories.

Why Does Open Innovation Matter?

Using open-source AI wasn't just an implementation detail for SlothSort—it is the only reason this project can safely exist:

Non-Negotiable Personal Privacy: A user's Downloads folder is their most sensitive directory. It holds bank statements, tax forms, paystubs, passport scans, and proprietary work documents. Sending every single file to a proprietary closed cloud API (where data might be retained, logged, or scrutinized) is a dealbreaker. With open-weight models running on Ollama, zero bytes ever leave your hardware.
Zero Incurred API Costs ($0.00): Active users accumulate hundreds of files every month. Classifying hundreds of high-res images and documents with commercial cloud vision APIs would easily cost $10–$30/month. Local open weights turn routine personal maintenance into a free utility forever.
Works Anywhere, Completely Offline: Whether on an airplane, train, or spotty cafe Wi-Fi, SlothSort operates without an internet connection, API keys, or rate limits.
Resilience & User Sovereignty: Proprietary APIs change pricing, deprecate models, or throttle requests without notice. Open innovation means you own your compute stack and can freely swap between llama3.2, gemma2, or qwen whenever you choose.

The Lazy Payoff

The Before vs. After:
Before SlothSort: 180+ loose files cluttering the ~/Downloads and ~/Desktop directory. Finding a specific payment receipt meant opening 15 cryptic Screenshot_2026-09-XX files one by one. Total wasted time: ~35–45 minutes of manual dragging, dropping, and renaming every couple of weeks.
With SlothSort: Processed the entire backlog in under 2 minutes of local compute without a single mouse click.
The Ultimate Payoff: 100% hands-off automation. You can continue being as lazy and messy as you want with your downloads—SlothSort wakes up at 2:00 AM, does the chores, and lets you wake up to zero clutter every morning.

Weekly Challenge 2

Magatam Yogesh — Tue, 13 Oct 2026 11:22:59 +0000

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

What I Built

LocalLedger is a 100% private, on-device receipt and invoice sorter for freelancers, solopreneurs, and tiny agencies preparing for tax season.

What it does: Drop in photos (PNG, JPG, WEBP) or PDFs of receipts and invoices. The app extracts the vendor, invoice number, date, GSTIN, combined GST (CGST + SGST or IGST), total amount, and tax category into an in-place editable spreadsheet, and exports a tidy CSV or JSON.
Who would pay for it: Freelance developers, designers, and boutique agencies who manage dozens of monthly expenses (cloud subscriptions, software licenses, travel, coworking, hardware) and want tax preparation without paying recurring SaaS subscription fees.
The problem it solves: Commercial expense apps require uploading sensitive financial documents—revealing client names, billing rates, PAN/GSTIN IDs, and bank details—to third-party cloud servers, violating client NDAs and financial privacy. LocalLedger runs optical character recognition (OCR) inside the browser via WebAssembly and runs an open-weight language model locally on the user's laptop through Ollama. Financial documents never touch the internet.

Demo

LocalLedger runs locally on any modern laptop (tested on 8 GB RAM, CPU only).
Run Locally:
bash

Pull the 1 GB open-weight model ollama pull qwen2.5:1.5b
Allow browser CORS Windows (PowerShell): setx OLLAMA_ORIGINS "" | macOS/Linux: OLLAMA_ORIGINS="" ollama serve
Serve and open py -m http.server 8080 Open http://localhost:8080 in your browserHighlights: 1-Click Instant Demo: Built-in "Load 3 Sample Invoices" button instantly loads sample Swiggy, Uber, and Hardware receipts into the live OCR + AI pipeline without needing to find files. Side-by-Side Verification: Click the icon on any row to inspect the original receipt canvas side-by-side with extracted values and raw OCR text. Financial Metric Cards: Live tallies of Total Spend, Claimable GST (Input Tax Credit), and document review warnings. One-Click Export: Download tidy CSV formatted with Excel UTF-8 BOM or export clean JSON.

Code

yogeshmagatam / Local-Ledger-local-receipt-and-invoice-sorter

Private receipt and invoice sorter. OCR in the browser plus a local open-source AI model. Nothing leaves your laptop.

LocalLedger 🛡️

Private On-Device Invoice & Receipt Sorter for Freelancers and Tiny Agencies

Built October 13-18, 2026 for the DEV Hacktoberfest Open-Source AI Challenge, Week 2 (Side Hustle)

Drop in photos or PDFs of receipts and invoices. LocalLedger reads them directly on your machine and generates a clean, editable ledger with Vendor, Invoice Number, Date, GSTIN, GST (CGST+SGST/IGST), Total, and Category, ready to download as a tidy CSV or JSON for tax season.

100% On-Device Privacy: Financial documents never leave your laptop. OCR runs inside your browser via WebAssembly (Tesseract.js & PDF.js), and local AI inference runs on your own machine through Ollama. Zero telemetry, zero cloud uploads.

DEV Hacktoberfest Open-Source AI Challenge, Week 2 (Side Hustle Track).

Architecture & How It Works

┌────────────────────────────────────────────────────────┐
│                   YOUR LAPTOP ONLY                     │
│                                                        │
│  [ Receipts / Invoices ] (PDF, PNG, JPG, WEBP)         │
│          │                                             │
│          ▼                                             │

…

View on GitHub

Repository: https://github.com/yogeshmagatam/Local-Ledger-local-receipt-and-invoice-sorter

License: MIT License

Core files:

index.html: Accessible dashboard UI with drag-and-drop zone, metrics, and verification modal.

style.css: Modern financial dark/light theme, glassmorphic cards, and responsive tables.

app.js: In-browser PDF text layer extractor, Tesseract.js WASM runner, Ollama caller, and safe merge engine.

extract.js: Isomorphic rule-based extractor for dates, GSTINs, and combined taxes.

samples/: Bundled sample test receipts.

How I Built It

LocalLedger is built around a dual-layer extraction architecture that pairs deterministic client-side parsing with local open-weight AI:

[ Receipts / Invoices (PDF, PNG, JPG) ]
│
▼
[ In-Browser OCR Layer ]
• PDF.js (Digital PDF text layer)
• Tesseract.js (WASM client-side optical scan)
│
▼
[ Deterministic Rule Engine (extract.js) ]
• Day-first dates (DD/MM/YYYY)
• 15-character GSTIN & OIDAR formats
• Combined CGST + SGST + IGST tax calculation
│
▼
[ Local AI Layer (Ollama: qwen2.5:1.5b) ]
• Structured JSON extraction (format: "json")
• Merchant name normalization & category sorting
│
▼
[ Anti-Hallucination Guardrail ]
• Rejects model amounts unless they appear in raw OCR text
│
▼
[ Interactive Ledger & CSV / JSON Export ]

Key Technical Decisions:
Open-Source AI Model: qwen2.5:1.5b (~986 MB footprint) hosted locally via Ollama. It delivers structured JSON parsing (format: "json", temperature: 0) with zero cloud latency and no per-token costs.
Client-Side OCR: Tesseract.js (WebAssembly OCR) and PDF.js handle text extraction entirely in browser memory.
Anti-Hallucination Guardrail: Small 1.5B models can invent numbers if prompted loosely. LocalLedger strictly rejects any amount returned by the model unless that exact number appears in the raw OCR scan. If the model strays, the deterministic rule engine acts as the ground truth.
GST Tax Preservation: In Indian tax invoices, CGST and SGST are listed as separate line items. The rule engine calculates the sum (CGST + SGST), while the merge logic prevents the AI from overwriting the combined sum with a single tax component, protecting the freelancer's Input Tax Credit.

Why Does Open Innovation Matter?

Financial documents are deeply personal and legally sensitive.
If LocalLedger were built with closed APIs (such as OpenAI, Anthropic, or cloud document OCR endpoints):
Privacy is Compromised: Sensitive client names, invoice values, bank account details, and government tax IDs would be transmitted across the wire to cloud data centers.
Unsustainable for Side Hustles: Metered API fees make personal financial tools expensive to run for solo builders.
Vendor Lock-In & Offline Failure: Cloud document APIs break the moment you are offline or an endpoint changes terms.
Open innovation made it possible to combine open-weight models (Qwen 2.5), local runtime engines (Ollama), and browser-compiled tools (Tesseract.js WASM). Together, they prove that enterprise-grade financial extraction can run completely inside an 8 GB consumer laptop with zero telemetry and zero ongoing costs.

My Agent Session

This application was developed and debugged with Antigravity. During the pair programming session, the agent:
Tested local Ollama inference and validated CORS connectivity from the browser.
Identified and fixed a regex tokenization bug in extract.js where 4-digit unformatted numbers (like 7194.92) were being split into 719 and 4.92.
Solved an Input Tax Credit bug in app.js to prevent combined CGST + SGST sums from being replaced by single-component AI outputs.
Built automated end-to-end integration test runners in Node.js verifying 100% extraction accuracy across realistic test receipts.
Crafted the modern financial dark/light UI, live ITC metric cards, and the side-by-side document preview modal.

My First User

I shared LocalLedger with a freelance UI/UX designer who normally spends hours every quarter sorting PDF invoices and receipts for her chartered accountant.
Her feedback:
"Every tax season I end up with dozens of PDFs from Figma, Google Workspace, client cafes, and cab rides. I tested LocalLedger by dropping 15 invoices into the dropzone. It extracted the dates, GST amounts, and totals in seconds. Being able to preview the original PDF alongside the extracted numbers made verification effortless—and knowing my receipts never left my machine gave me total peace of mind."

Hello Everyone

Magatam Yogesh — Sun, 11 Oct 2026 05:37:41 +0000

Hi everyone this is my first time using dev and it's all new over here i hope it goes well later

Magatam Yogesh — Sun, 11 Oct 2026 05:37:17 +0000