DEV Community: Srinjoyee Goswami

Séan-Shell: Summoning a Digital Spirit into an Abandoned Terminal (Atmospheric & intrigue-focused)

Srinjoyee Goswami — Sat, 31 Oct 2026 23:30:48 +0000

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

What I Built
I built Séan-Shell (NecroTerm), an atmospheric, haunted terminal interface that acts as a digital séance board.

For the "Ghost in the Machine" prompt, I wanted to step away from the polished, sterile aesthetic of modern chat interfaces and explore the eerie folklore of lost signals, digital decay, and lingering electronic spirits. Séan-Shell frames local intelligence not as an all-knowing assistant, but as a spectral presence tethered inside an abandoned shell session.

Users interact through a retro command-line environment where standard utilities behave unexpectedly: prompts glitch, commands echo back forgotten machine memory, and cryptic responses manifest with unsettling delays, vintage CRT jitter, and ambient digital static.

Demo

Live Deployment: Séan-Shell (NecroTerm) on GitHub Pages

Code
The source repository is completely open-source:

srinjoyeegoswami / spooky_project

spooky_project — Séan-Shell (NecroTerm) 👻🕯️

A Cute & Spooky Retro Spectral Terminal for developers, haunted by vintage programming spirits and antique computing relics.

🔮 Overview

Séan-Shell (NecroTerm) is a playful, antique-themed retro terminal built with React and Vite. It blends the nostalgia of cathode-ray tube terminals, 80-column Hollerith punch cards, and vintage magnetic tapes with an interactive 8-bit ghost companion.

Whether observing passive shell events or summoning the ghosts of historical programming languages, Séan-Shell keeps you company with eerie whispers, retro soundscapes, and offline-first local intelligence.

✨ Features

👻 8-Bit Ghost Mascot & Altar: Animated spectral mascot responding dynamically to successes, command errors, and ongoing séances with flickering candlelight.
📜 Parchment & CRT Aesthetic: Retro monospace typography (Courier Prime, VT323, Cinzel Decorative), CRT scanline vignette, and warm amber-green spectral palette.
🕯️ Séance Mode (Summon Vintage Spirits): Channel the ghosts of historic languages and…

View on GitHub

How I Built It
Séan-Shell is built as a lightweight, performant web client that pairs immersive frontend terminal emulation with open-source AI inference:

Frontend Core: Built with React and bundled using Vite for rapid hot module replacement and minimal runtime overhead.

Terminal & Aesthetics: Styled using modular CSS with custom CRT scanline shaders, phosphor glow effects, chromatic aberration, and simulated command latency.

Code Quality & Tooling: Configured with Oxlint (.oxlintrc.json) for sub-millisecond static linting and modern JavaScript optimization.

Local & Open Inference: Designed to run with open-weight language models via local inference runtimes (such as Ollama / Llama.cpp endpoints) or open-source inference servers. The terminal feeds custom system manifests and temperature-steered prompts to force the model to stay strictly in character as an elusive digital entity rather than a corporate assistant.

Why Does Open Innovation Matter?
Open innovation is what made this project possible:

Uncensored Creative Expression: Commercial closed APIs enforce rigid safety guardrails and sterile tones that actively resist roleplaying as eerie, mysterious, or decaying entities. Open-weight models allow full control over system instructions, sampling temperatures, and decoding parameters to craft a genuinely believable aesthetic.

Local Sovereignty & Offline Functionality: A digital ghost shouldn't need a persistent billing tier or a remote corporate server to speak. With open-source runtimes, the entire experience can live directly on user hardware without telemetry, tokens, or network reliance.

Hackability: From customizing the tokenizer output stream down to each character render to swapping models depending on GPU constraints, open-source AI turns machine intelligence into a malleable creative medium rather than a locked black box.

The Spirit of It
There is an eerie parallel between the early internet—green phosphors, mysterious dial tones, empty chatrooms—and modern generative systems trying to reconstruct human thought from raw parameters. Séan-Shell captures that uncanny valley: typing a query into a silent prompt, waiting for the cursor to blink back, and wondering if the response is just math or something lingering inside the machine.

SlothSort: The Private, Offline AI That Cleans Your Downloads Folder While You Nap

Srinjoyee Goswami — Wed, 21 Oct 2026 12:01:23 +0000

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

What I Built

Let’s be honest: everyone’s Downloads and Desktop folders are digital graveyards filled with Screenshot 2026-10-19 at 14.22.10.png, final_v2_REAL(1).pdf, and notes_untitled_44.txt. We all swear we’ll organize them "this weekend," and we never do—because opening hundreds of mystery files just to rename and file them away takes way too much energy.

Enter SlothSort 🦥—an open-source, 100% local, CPU-aware file and screenshot tidier built for maximum human laziness.

Instead of hogging your machine’s resources or blasting fan noise while you work, SlothSort behaves like an actual sloth:

It Naps When You Work ("Sloth Pacing"): It constantly monitors your system CPU load. If you're actively coding, gaming, or browsing and CPU usage crosses a calm threshold (default 35%), SlothSort goes straight to sleep.
Slow & Steady Local Inference: Only when your machine is idle does SlothSort wake up, pick up one single file at a time, inspect its contents using local open-weight models via Ollama, rename it cleanly in snake_case, and tuck it into a neat category folder (Finance_And_Bills, Study_And_Papers, Code_And_Tech, Screenshots_And_Media, Personal_And_Docs, or Misc_Archive).
The "Lazy Undo" Ledger: Even too lazy to double-check what the AI moved? Every single file operation is recorded in a local JSON ledger (sloth_history.json) with a 1-sentence summary of what was inside the file and a 1-click Undo button that teleports the file right back to its messy original name and location.

Anyone who hoards lecture PDFs, receipts, code snippets, and random screenshots gets to be effortlessly lazy—your folders organize themselves while you grab coffee.

Demo

🌐 Live Interactive Web Demo ("The Lazy Control Panel"):

👉 https://srinjoyeegoswami.github.io/SlothSort/

In the live dashboard, you can test the Sloth Meter (CPU load threshold & nap state), generate a sandbox of realistic messy files with one click (Generate Messy Demo Folder), watch the local agent inspect and sort files one by one, and test the 1-Click Undo ledger in real time.

Code

srinjoyeegoswami / SlothSort

🦥

SlothSort

Slow & Steady file organizer — 100% local, AI-powered, resource-aware

🦥 What is SlothSort?

SlothSort is an open-source, 100% local, resource-aware file organizer that uses AI to tame your messy Downloads folder — without ever sending a single byte to the cloud.

It runs quietly in the background like a literal sloth:

Checks CPU load before doing any AI work (never lags your laptop)
Processes one file at a time with naps in between ("Slow and Steady")
Uses local open-weight models via Ollama for understanding files
Renames files cleanly and sorts them into categorized folders
Maintains a 1-click "Lazy Undo" ledger to reverse any action

✨ Key Features

Feature	Description
🧠 Dual-Model AI	`llama3.2:3b` for text/documents, `moondream` for screenshots
🏠 100% Local	All inference runs on `localhost:11434` via Ollama
📊 Sloth Pacer	CPU/RAM monitoring — only works when your machine is idle
📂 Smart Categories	Finance, Study, Code,

…

View on GitHub

Repository Link: https://github.com/srinjoyeegoswami/SlothSort

How I Built It

SlothSort is built around a dual-model local open-source AI pipeline connected to a lightweight Python daemon and a cozy React control panel:

Local Open-Weight Models (via Ollama):
- Text & Document Brain (llama3.2:3b): Reads the first 1,000 characters of text files, code scripts, or Page 1 of PDFs to infer the document's true subject without blowing up the context window.
- Vision & Screenshot Brain (moondream): Inspects unlabelled .png and .jpg screenshots to figure out what is actually on screen (ui_bug_console_error.png instead of Screenshot (482).png).
Structured JSON Enforcement: By passing a strict Pydantic/JSON schema to Ollama's /api/generate format parameter, the local models are forced to return deterministic JSON (clean_name, category, summary, and confidence) rather than conversational prose—preventing broken filenames.
The Sloth Pacer (psutil + FastAPI): A Python background loop checks psutil.cpu_percent(). If the laptop is busy, it enters Nap Mode. When idle, pypdf and Pillow (which resizes screenshots in-memory to max 640px for 4x faster local vision inference) extract minimal context and pass it to localhost:11434.
Safe File Mover & Ledger: Built with Python's pathlib and shutil, preserving original file extensions, automatically preventing filename collisions (_1, _2), and writing every transaction to sloth_history.json.
Frontend ("The Lazy Control Panel"): Built with React, Vite, Tailwind CSS, and Lucide-React, featuring a live CPU Sloth Meter, an offline sandbox generator for instant testing, and an interactive activity feed with instant undo controls.

Why Does Open Innovation Matter?

A background file organizer is the ultimate proof case for why open-weight, local AI beats closed cloud APIs:

Uncompromising Privacy for Sensitive Files: Think about what actually sits in a real Downloads or Desktop folder—bank statements, tax PDFs, academic transcripts, ID scans, medical bills, and private screenshots. Piping your personal filesystem automatically into a closed, third-party cloud API is a massive privacy nightmare. Because SlothSort runs open-weight models strictly on localhost:11434, zero bytes of your personal files ever leave your laptop.
Set It Once, Pay $0 Forever: An automation tool that watches your folders 24/7/365 shouldn't come with token anxiety, rate-limit errors, or a monthly API bill. Running local open weights makes infinite laziness 100% free.
True Offline Autonomy & Hardware Control: Whether you're on a plane, on flaky campus Wi-Fi, or working completely offline, SlothSort keeps tidying in the background. And because the stack is open, you can hot-swap llama3.2:1b on an older laptop or upgrade to qwen2.5:7b on a workstation with a single config tweak.

My Agent Session

I used an AI coding workflow in VS Code / Antigravity to scaffold the monorepo architecture, wire up the FastAPI + Ollama structured output schemas, and build the interactive React sandbox mode so anyone can test the Sloth Pacer right in their browser.

The Lazy Payoff

Before running SlothSort this week, my Downloads folder had accumulated dozens of cryptic PDFs (1704.05862v2.pdf, syllabus_final_updated(2).pdf) and unnamed screenshots from hackathon debugging sessions.

Instead of spending 45 minutes manually opening each PDF and screenshot to figure out what was worth keeping, I let SlothSort nap in the background while I worked on coursework. Every time I stepped away or my CPU dropped below 35%, it quietly woke up and filed a few items away. By the end of the evening, my research papers were neatly named inside Study_And_Papers/, my debugging screenshots had readable names inside Screenshots_And_Media/, and I didn't have to lift a finger.

Prize Categories

Slow and Steady (Week 3 Challenge Prompt) — Built around open-weight local models (llama3.2:3b & moondream via Ollama) to automate a dreaded chore at a literal sloth's pace.

GhostDocs: an invoice sorter for freelancers that never leaves their laptop

Srinjoyee Goswami — Sun, 18 Oct 2026 09:57:07 +0000

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

What I Built

GhostDocs turns PDF invoices and receipts into a structured, searchable ledger, using an open-weight model that runs on the freelancer's own laptop. Drop in a document and get the invoice number, vendor or client, dates, currency, subtotal, tax, total, payment terms, and every line item. Everything is saved to a local SQLite ledger and exports to CSV or multi-tab Excel.

Who would pay for it: freelancers, consultants, and small agencies. At tax time they spend hours retyping invoices into spreadsheets, and those invoices contain hourly rates, client names, and NDA-covered project details. Most AI expense tools solve the typing problem by asking them to upload all of that to a cloud service. GhostDocs solves it without the upload. A second group is bookkeepers who handle many freelancers' paperwork and can't send client data to third-party APIs.

The business model I'm aiming for: the core stays free and MIT-licensed. The paid part would be what freelancers actually ask for: scanned-receipt OCR, multi-currency totals, and QuickBooks/Xero export, plus a one-time setup service for non-technical users. I haven't charged anyone yet, so this is my plan rather than a result.

Demo

Live app: https://ghostdocs.streamlit.app/

Code

srinjoyeegoswami / ghostdocs

GhostDocs 👻

100% Offline, On-Device AI Invoice & Receipt Sorter for Freelancers

"Keep client contracts, financial rates, and NDA-covered billing 100% on your laptop."

🎯 The Mission

Freelancers, consultants, and independent agencies handle confidential client data daily: hourly billing rates, project roadmaps, vendor contracts, and NDA-protected deliverables. Traditional AI expense tools upload this sensitive financial paper trail to third-party cloud APIs.

GhostDocs solves this permanently. It is a lightweight, zero-telemetry document extraction utility that runs entirely on your local machine using the official Ollama Python SDK (ollama.Client) to query open-weight LLMs (llama3.2:3b, qwen2.5:3b, mistral:7b). It turns messy PDF invoices and receipt text files into structured, deterministic accounting records and a persistent SQLite ledger—even with your Wi-Fi completely turned off.

🏗️ Architecture & Data Flow

graph TD
    A["Uploaded Invoice (PDF / TXT)"] --> B["Local Ingestion (pypdf / pdfplumber)"]
    B --> C["Token Normalizer & Sanitizer"]
    C

…

View on GitHub

How I Built It

Open-weight models via Ollama: the app talks to a local Ollama server through the official Python SDK. llama3.2:3b is the default, and qwen2.5:3b or mistral:7b can be swapped in from the sidebar.
Grammar-constrained decoding: I pass a Pydantic model's JSON schema to Ollama's format parameter, so the model can only produce output that fits the invoice schema. Temperature is 0 for repeatable results.
Pydantic validation: every response is validated into typed fields before saving, so totals are numbers and currency symbols become codes like USD or INR.
Local ingestion: pypdf reads PDFs, with pdfplumber as a fallback, and a normaliser trims the text to keep prompts small enough for 3B-parameter models.
Storage and UI: SQLite for the ledger, Streamlit for the interface, pandas and openpyxl for exports.
Fallback mode: if Ollama isn't running, a regex-based extractor lets people try the whole pipeline before downloading any model.

Why Does Open Innovation Matter?

Where the open approach beat a closed API for this product:

Privacy is the product. A freelancer under an NDA can't send a client's invoice to someone else's server. With a local open-weight model the document never leaves the machine, which a cloud API can't offer.
Cost. There are no per-token fees and no API keys. Processing the hundredth invoice costs the same as the first, which matters when the customer is a solo freelancer.
No lock-in. Models are swappable, so if a better small model appears, it's a one-line change instead of a migration.
Works offline. The whole pipeline runs with Wi-Fi off, which anyone can check using the steps in the README.

The trade-off is that a 3B model on a laptop is slower and less accurate than a frontier model on messy documents, which is why the output is schema-validated and why OCR for scans is the first paid feature on my list.

TrailQuest: Screen-Free, Audio-Guided Outdoor Exploration with Gemma & Hermes

Srinjoyee Goswami — Sun, 11 Oct 2026 21:08:21 +0000

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

What I Built

TrailQuest is a screen-free, audio-guided outdoor exploration app designed for runners and walkers. Once you select your desired distance and preferences (parks, green spaces, landmarks), the backend generates a closed-loop route originating from your current location. It translates OSRM turn-by-turn navigation into spoken audio cues, keeping your attention off your phone and focused on your surroundings.

During each route, participants encounter interactive activities:

Visual Quests: Capture a photo of designated landmarks; an open-weight vision model validates presence and alignment.
Social Quests: Greet individuals encountered along the trail to earn completion points.
Navigation Accuracy: Maintain alignment with the generated route for consistency bonuses.

Audio feedback is available in two distinct styles: friendly encouragement or a humorous full_savage coach persona that highlights pace changes and schedules mid-route pauses. The landmark harvester is tailored for India, beginning with Kolkata.

Demo

Web Application: TrailQuest Web App

Note: The hosted build operates in offline-fallback mode due to hosting constraints on static pages. The full architecture (routing engine, synchronisation, Hermes evaluation, and Gemma verification) operates locally via Docker Compose as outlined in the repository documentation.

Code

srinjoyeegoswami / TrailQuest

<<<<<<< HEAD

TrailQuest Backend & Agent Service

Screen-free, audio-guided outdoor exploration running platform powered by open-weight AI (Gemma), Hermes Agent, PostGIS, and OSRM. Built for the Hacktoberfest "Touch Grass" challenge.

Architecture Overview

Screen-Free Audio Guidance: Routes are compiled into natural-language speech prompts on the backend and voiced using device-native TTS with music ducking, keeping runners off their screens.
Dual Voice Profiles: Switchable between friendly and full_savage personas, including automatic pace-drop alerts and a halfway 2-minute fatigue break trigger (config/voice_profiles.json).
Offline-First Synchronization: Telemetry coordinates and quest photos are buffered on the device during runs with zero cellular dependency, then synced within 24 hours of reconnecting.
Open-Weight AI Pipeline: Gemma serves as the multimodal vision evaluator on DigitalOcean Serverless Inference / Ollama, orchestrated by Hermes Agent.
Two-Tiered Landmark Storage: Separates verified baseline locations (data/landmarks/curated_landmarks.json) from dynamically mined regional discoveries (data/landmarks/mined_landmarks.json).

Quickstart

…

View on GitHub

How I Built It

Open-Source AI Architecture

Gemma 3: Utilized via DigitalOcean Serverless Inference or local Ollama execution as a multimodal vision validation engine. It evaluates user-submitted photos against landmark attributes to yield structured JSON output (is_match, confidence, identified_objects, and coach feedback). Validations require a confidence score of $\ge 0.70$.
Hermes Agent: Handles evaluation orchestration through a custom skill module (route_and_quest_director) integrating three primary tools:
1. evaluate_run_navigation_accuracy: Computes PostGIS Hausdorff distance between planned and tracked paths (adherence target $\le 75\text{ m}$).
2. run_gemma_vision_verifier: Assesses visual submissions.
3. tally_quest_score: Aggregates distance points, route fidelity bonuses, visual confirmations, and social interactions.

Technical Stack

Backend: FastAPI, asyncpg, Shapely, Pydantic
Spatial Engine: PostgreSQL 16 with PostGIS, coupled with OSRM (foot profile)
Data Sourcing: Baseline registries augmented with OpenStreetMap (Overpass) queries and local recommendations, deduplicated within a 50-meter radius
Frontends: React, Vite, and Three.js interface alongside a React Native tracking application featuring GPS pathing
Infrastructure: Docker Compose orchestration for PostGIS and OSRM

Offline-First Architecture

GPS points and quest captures buffer locally during activity without requiring active cellular coverage. Once connectivity is restored, telemetry packages submit to /api/v1/sync/run-payload. The backend logs the raw payload, flags the session for review, triggers Hermes evaluation pipelines in the background, and updates the status to complete.

Why Does Open Innovation Matter?

Sustainable Economics: Vision verification per image remains cost-effective by executing Gemma across cost-efficient cloud compute or local Ollama instances rather than accumulating proprietary per-call API fees.
Inference Portability: The backend connects to either hosted endpoints or local Ollama deployments simply through configuration toggles, preventing lock-in to single-vendor API specifications.
Community Data & Tooling: OpenStreetMap and OSRM allow localized routing and point-of-interest discovery to expand into new areas without recurring geospatial map licensing fees.
Extensible Agent Design: Hermes skill declarations and tooling remain transparent, allowing straightforward auditing, extension of quest varieties, and addition of new audio personas.

Prize Categories

Gemma
Hermes Agent
DigitalOcean