DEV Community: Anush Deotare

I Built a Graveyard for My Abandoned Git Repos (Gemma Writes the Epitaphs, Offline)

Anush Deotare — Fri, 30 Oct 2026 20:39:19 +0000

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

What I Built

Every developer has a graveyard. Mine is a folder of projects that started with a burst of commits and a confident README, then stopped. Nobody announced it. The last commit just sat there, and the project quietly died.

Repo Graveyard points at a folder of git repositories and turns the abandoned ones into a night-time graveyard. Each dead project gets a tombstone with its birth and death years, a cause of death, an epitaph, and a short ghost story told in the project's own voice. It scans, it mourns, and it can try to bring something back.

For the theme, I read "Ghost in the Machine" literally. Every abandoned repo is a ghost: code that still exists, still has a history, and has no one left to talk to. The git log is the only thing left of it, so the log is what the ghost speaks from.

A few things it does:

Finds your dead. Repos are sorted by days since the last commit: Alive (under 30), Sleeping (30–180), Dead (180–365), Ancient (over 365).
Assigns a cause of death. "Abandoned mid-sentence" for a last commit like wip or fix later. "Died young" for under 10 commits. "Death by TODO" for repos buried in unfinished notes. "Sudden death" for heavy activity followed by silence. "Fizzled out" for everything else.
Writes epitaphs and ghost stories with a local model, based only on facts from git.
Resurrects. A rule-based revival score picks the dead project most worth saving, and a séance animation streams a concrete 3-step plan to bring it back.
Exports the whole graveyard as a single self-contained HTML file, with an option to redact repo names so you can share it without exposing private projects.

Code

anushdeotare11 / repo-graveyard

🪦 Repo Graveyard

"Ghost in the Machine" Hackathon Project
A 100% local, air-gapped forensic inspection tool that scans your folders for abandoned Git repositories and resurrects them into an atmospheric, dark-humored virtual graveyard.

📸 Preview

+-----------------------------------------------------------------------------------+
|  🕯️  REPO GRAVEYARD                 [100% Local & Private] [🟢 Gemma 3:4b Ready]  |
|  Where dead code rests, unresolved TODOs haunt, and local spirits speak.          |
+-----------------------------------------------------------------------------------+
|  [ C:\Projects                            ]  [ Scan Projects ]  [ 🔮 Séance ]    |
+-----------------------------------------------------------------------------------+
|  🌱 Still Among the Living (Recent commits detected)                             |
|  [● spectral-cli  4d ago]  [● pixel-roguelike-core  75d ago]                      |
+-----------------------------------------------------------------------------------+
|  ⚰️ The Cemetery Grounds                                                          |
|                                                                                   |
|    +-------------------+    +-------------------+    +-------------------+        |
|   /       R.I.P.        \   |      R.I.P.       |   ✝       R.I.P.        |       |
|  |   neural-toaster      |  | crypto-tamagotchi |  | vim-exit-simulator   |       |
|  |    2021 — 2022        |  |    2022 — 2023    |  |    2023 — 2023        |       |

…

View on GitHub

Run it with Python and Ollama. The README has the setup steps: install Ollama, ollama pull gemma3:4b, then python run.py.

How I Built It

The model: Gemma 3 4B (gemma3:4b), running locally through Ollama. I built this on a laptop with an RTX 3050 and 4 GB of VRAM, so a small model that runs without a datacenter was the point.

The stack: Python and FastAPI on the backend, and a vanilla HTML/CSS/JS frontend with no frameworks, no CDN and no external fonts. The only network call in the whole app is to localhost:11434, where Ollama lives. Scan results and generated text are cached as JSON, so the graveyard loads instantly the second time.

The main design decision: the model doesn't know anything. Git does.

I didn't want an LLM guessing what happened to my projects, so I split the work:

Rules decide the facts. Dates, commit counts, the status (alive, dead, ancient), the cause of death and the revival score are all computed deterministically from git history. There's nothing for the model to make up.
The model only gives those facts a voice. Gemma gets a short list of allowed facts (name, lifespan, commit count, cause of death, last commit message, TODO count, first line of the README) and writes a two-line epitaph or an ~80-word ghost story from them.
A grounding check catches invention. If the output names a technology that isn't in the facts it was given, the app regenerates once with a stricter prompt, then falls back to a plain account built from the git data.
Honest fallbacks. If Ollama isn't running, the app doesn't pretend. Stories fall back to a deterministic version, and the UI labels it "written without the model."

Epitaphs are generated in a background queue after each scan, while ghost stories and Resurrect plans stream token by token over server-sent events. On my machine the first token of a warm ghost story shows up in about 1.3 seconds.

The Resurrect plan only sees three inputs: the README's first lines, the TODO lines, and the last five commit messages. It never sees the source code.

Why Does Open Innovation Matter?

A tool that reads your commit history is reading something private. Commit messages, TODOs, the names of side projects you never told anyone about, the half-finished idea from 2 a.m.: it's a fairly intimate record of what you worked on and what you gave up on.

That's why this had to be open and local:

Your history never leaves your machine. Gemma runs through Ollama on localhost. There are no API keys, no accounts and no telemetry. A closed API would mean sending the names of my abandoned projects and their last commit messages to a server I don't control, just to get a joke about them.
It works with the internet off. I ran the whole thing with Wi-Fi turned off: scan, epitaphs, ghost stories and Resurrect. A graveyard that needs a server to stay online felt like the wrong kind of ghost.
It costs nothing to run. No per-token bill, no quota. It can write an epitaph for every dead repo you have.
The model is one line of config. If a better small model comes out, you change one value.
The output can't be locked in. The export is a plain HTML file. It will still open in ten years, whether or not any service survives.

Prize Categories

Best Use of Gemma: the whole project runs on gemma3:4b locally through Ollama, as the voice that gives each abandoned repo its epitaph, ghost story and revival plan, while git supplies every fact.

Sloth Sorter: A Local AI That Organizes Your Messy Folders, Slowly (Gemma 3 + Ollama)

Anush Deotare — Wed, 21 Oct 2026 20:07:29 +0000

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

What I Built

Everyone has that folder. Mine is full of Screenshot 2026-10-21 at 3.12.png, final_final_v2.docx and IMG_4821.jpg, and I have been "going to sort it" for months.

Sloth Sorter is a local web app that does the sorting for me. I point it at a messy folder, and a local AI model looks at each file and works out what it actually is. It then proposes a clean name and a category folder, so final_final_v2.docx becomes nexus-labs-design-agreement in Documents, and that Slack screenshot goes to Screenshots.

It works at a sloth's pace on purpose. Files are processed one at a time with a small pause between them, so it never hogs my laptop's GPU, and nothing moves until I review the preview and click Apply. Every run is logged, so one click undoes it.

It saves the chore I keep avoiding, and the people it suits are anyone whose Downloads folder has become a lifestyle.

Demo

Recording 2026-10-22 013402.mp4 - Google Drive

drive.google.com

Code

anushdeotare11 / sloth-sorter

🦥 Sloth Sorter

"Does the chore so you don't have to. Slowly."

Sloth Sorter is an offline desktop web application that organizes messy folders using local multimodal AI (Gemma 3:4B running via Ollama). By processing files sequentially, one by one, with a gentle pacing delay, it brings order to chaotic downloads, desktops, and project dumps without bogging down your machine—designed specifically to run comfortably on everyday laptops with zero data ever leaving your device.

💻 Tested On

Hardware: NVIDIA GeForce RTX 3050 Laptop GPU (4GB VRAM), 16GB RAM
Operating System: Windows 11
Model: gemma3:4b running locally via Ollama
Python Requirement: Python 3.9+

📊 Measured Benchmark Results

These numbers are taken directly from actual benchmark runs on the repository's 26-file test set (sample_mess):

Dataset: 26 files (PDFs, DOCX documents, code scripts, screenshots, receipts, notes, and photos)
Fallbacks: 0 fallbacks (0.0%)…

View on GitHub

How I Built It

The open-source pieces

Gemma 3 4B (open-weight, multimodal) runs locally through Ollama. It reads screenshots and photos directly and reads the text of PDFs, DOCX and code files.
FastAPI backend streams progress to a vanilla JS front end over Server-Sent Events, so file cards appear one by one as the model finishes each file.
Pillow, pypdf and python-docx handle extraction. Images are shrunk to 640px and documents are trimmed to about 800 characters, which keeps the model fast and inside the 4GB of VRAM on my RTX 3050 laptop.

Making a small model behave

A 4B model won't give you clean output on its own, so the model proposes and the code checks:

Ollama's JSON-schema output constrains the reply (the category must be one of my nine, confidence must be low, med or high), so it can't ramble or break the format.
A date verifier strips any date from a proposed name that doesn't appear in the file's content or original filename.
A few deterministic category rules apply, such as .sql, .py and .js always going to Code, and screenshots going to Screenshots.
Confidence is calibrated, so memes, avatars and corrected results show up as low or medium and get an amber highlight in the UI for a second look.

Where it went wrong first

My first benchmark on 26 messy sample files had 10 fallbacks. Five were a plain environment bug: the server ran on a different Python than the one I'd installed packages into, so PDFs and DOCX files never reached the model. I added a dependency check to the health endpoint so a missing library can't fail silently again. Constraining the output and trimming the prompt cleared the rest.

Next, I read the actual model outputs and found five unrelated files named with 2024-10-27. The date from one of my prompt examples was leaking into the answers. The fix was removing the dates from the examples, telling the model never to guess a date, and adding the verifier above.

	First pass	After fixes
Fallbacks (26 files)	10	0
Avg time per file	11.7 s	under 5 s
Category agreement	69.2%	96.2% (25/26)
Invented dates	5 files	0

Be careful with that 96.2%. I labeled the 26 test files myself and tuned the rules against them, so it describes my test set and isn't a general accuracy claim. The one miss was a quarterly financial report that Gemma filed under Receipts-Bills. The first file also takes about 23 seconds while the model loads, and after that it settles at about 4 to 5 seconds each. The repo has a tiny eval script so you can rerun all of this yourself.

Why Does Open Innovation Matter?

Look at what ends up in a Downloads folder: bank statements, tax PDFs, ID scans, one-time codes, private chats. A tool that sorts those files has to read all of them, and I don't want that going to someone else's server.

With an open-weight model, the files never leave the machine. That also made a few other things possible:

It works with no internet. It sorts files on a train just as well as at home.
It costs nothing after setup. There's no per-token bill for a chore that runs on every file, and no rate limit.
The model is swappable. Set one environment variable (SLOTH_MODEL) and it runs a different Ollama model.
I could control the output. Running the model myself let me use schema-constrained decoding and tune the context window and keep-alive for a 4GB GPU.

I didn't benchmark a cloud model, so I won't claim it would be less accurate. The win here is what a local, open model makes possible: private, offline, and free to run forever.

Prize Categories

Best Use of Gemma: Sloth Sorter runs gemma3:4b locally through Ollama and uses its multimodal side to read screenshots and photos, all on a 4GB laptop GPU.

Parchi: Turning a Night of WhatsApp Orders into a Prep Sheet with Gemma 4, Offline

Anush Deotare — Mon, 19 Oct 2026 06:56:21 +0000

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

What I Built

Parchi turns a day of messy WhatsApp food orders into a prep sheet, per-customer bills and ready-to-send replies, running entirely on the seller's own laptop.

The person it's for is a solo food seller, such as a home baker or tiffin seller, who takes orders as chat messages. Messages like "ek choco cake dedh kilo ka" and "wait actually make it 1 kilo" pile up all day. Every night the seller re-reads them and works out what to make, how many, and who owes what. That's slow, easy to get wrong, and the chats contain customers' names and addresses.

With Parchi, the seller pastes the day's chat (or uploads a WhatsApp export) and gets:

a prep sheet with the total quantity of each item to make,
a bill for each customer,
a confirmation reply to copy straight into WhatsApp,
a CSV export.

Anything the AI can't match to the menu, such as an off-menu "pineapple cake", is highlighted as Needs review so the seller fixes it with one click instead of silently losing an order.

Would someone pay for it? I think a free tier plus a small monthly fee is plausible for sellers who handle many chats a day, but that's a hypothesis. No real seller has tested it yet, and I haven't validated a price.

Demo

https://app.notion.com/p/The-Video-Link-for-Week-2-Hacktoberfest-3fe27b53d9f3802aa9d6fd32e75bcdd5?source=copy_link

It runs locally, so the demo is a short screen recording: load the menu, paste the chat, click Process orders, fix a "Needs review" item, then show the prep sheet, a bill and a copied reply.

Code

anushdeotare11 / parchi

Parchi

Parchi turns a day of messy WhatsApp food orders into a prep sheet, per-customer bills and ready-to-send replies, running fully on your own laptop with an open-weight model.

Project status

Working prototype. Evaluated on synthetic data only. Real-seller validation pending.

Quick start

ollama pull gemma4:e2b
pip install -r requirements.txt
.\start.ps1

then open http://localhost:8000

The Problem

A home baker or tiffin seller gets orders as chat messages like "ek choco cake dedh kilo ka" and re-reads and totals them by hand every night. This manual process is time-consuming, repetitive, and prone to costly calculation and counting mistakes.

How It Works

Parse (regex): WhatsApp export text is parsed into structured messages, skipping system lines and normalizing directional control marks, non-standard spaces, and newlines.
Group by Customer: Messages are grouped chronologically by sender.
Extract with Gemma 4: Each customer's message history and the seller's menu are sent to…

View on GitHub

How I Built It

Model: Gemma 4 E2B, run locally through Ollama. I also tested Gemma 4 E4B.

Pipeline:

WhatsApp export -> regex parser -> group by customer
  -> Gemma extracts items + quantities as JSON (checked against the seller's menu)
  -> code validates + post-processes -> code computes every total

The design rule that makes it dependable: the model only extracts, and code does all the maths. Totals, prep sheets and bills are never generated by the AI. Each extracted item has to map to a menu ID, otherwise it is flagged "Needs review".

Stack: Python, FastAPI, Ollama's local API (JSON-schema output, temperature 0, one retry on invalid JSON), and a single HTML page. There are 17 automated tests.

What I measured (10 synthetic customers, 23 expected items; the sample chat and labels are in the repo):

Run	Precision	Recall	Qty accuracy	Avg s/customer
E2B, original prompt	90.9%	87.0%	95.2%	cold start, not comparable
E2B, revised prompt	95.5%	91.3%	100%	6.1
E2B, revised prompt + code post-processing	100%	91.3%	100%	7.1
E4B, original prompt	90.9%	87.0%	95.2%	13.2
E4B, revised prompt	100%	78.3%	100%	15.5

What I learned, including what failed:

The bigger E4B model gave no accuracy gain and was about twice as slow, so E2B is the default. E4B got more precise by dropping items, which is the worse failure for a seller because a dropped item is a lost order.
The model kept ignoring two prompt rules: "paav kilo = 0.25" and "when a customer corrects a quantity, keep only the final one". Fixing them in code worked better than rewording the prompt. A correction-merge bug that sometimes gave 6.5 kg of chocolate cake instead of 6.0 kg is now stable in 5 of 5 repeated runs.
Still failing: requests phrased as questions for off-menu items, such as "ek pasta bhi banana hai kya?", are not reliably extracted by E2B. The seller catches them when reviewing.
Caveat: I wrote the prompt rules and post-processing while looking at this same synthetic chat, so these scores are optimistic and say nothing certain about real-world accuracy. Ten customers is also a small sample.

Why Does Open Innovation Matter?

For this customer, three things matter:

Privacy. Order chats contain names, phone numbers and addresses. With a local open-weight model, none of it leaves the seller's laptop.
Cost. Because inference runs locally, there are no per-message API fees; the only cost is the seller's own laptop and electricity. For a tiny-margin business with hundreds of messages a week, that matters.
Control. I could swap between E2B and E4B, measure them on my own test set, and choose the smaller one. A closed API wouldn't have let me do that.

To be honest about the trade-off, a large closed model would probably understand messy Hinglish better. Parchi trades some accuracy for privacy and zero running cost, and the review step is there to catch the mistakes.

Model license: Google released Gemma 4 under Apache 2.0, and the code is MIT. Check the official model card for the exact variant you use.

Prize Categories

Best Use of Gemma: the whole product runs on Gemma 4 locally through Ollama, with E2B and E4B compared on a labelled test set.

Dawn Chorus: An Offline Bird-Call Bingo Built on BirdNET and Gemma (hacktoberfest week 1 dev challenge)

Anush Deotare — Sat, 10 Oct 2026 21:09:08 +0000

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

What I Built

Dawn Chorus is a listening-walk bird bingo that runs entirely on my laptop.

The app shows a bingo card of the 12 birds most likely near me this week.
I put my phone in my pocket, in airplane mode with the screen off, and record the walk with the normal voice recorder.
Afterwards I upload the recording. An open-source model identifies the birds by their calls, and a local model writes a short field-journal page.
The journal ends with the birds I missed, which is the reason to go out again tomorrow.

The screen is the shortest part of the experience. A "Grass Ratio" card compares the minutes I spent outside with the seconds I spent on screen. It's for anyone curious about the sounds around them, including places with no signal.

Real test: I walked 30 minutes on DATE. BirdNET found 10 species, including 5 of the 12 bingo birds, and I confirmed Myna, House Crow, Rock Pigeon myself. Screen time: 2 minutes.

Demo

hacktoberfest.mov - Google Drive

drive.google.com

A short captioned walkthrough: the bingo card, airplane mode, the walk with the screen dark, then the results.

Code

anushdeotare11 / dawn-chorus

Dawn Chorus

Put your phone away. Listen to the morning.

Dawn Chorus is a listening-walk bird bingo that runs entirely on your own laptop. You get a checklist of the birds likely to be near you this week, you go for a walk with your phone recording in your pocket and the screen off, and when you get back an open-source model tells you who was singing. A local language model then writes you a short field-journal page about the walk.

Built for the Hacktoberfest Open-Source AI Challenge, Week 1: "Touch Grass". The idea: the screen should be the shortest part of the experience.

The story, real walk results and demo video are in the DEV post: Dawn Chorus on DEV

View on GitHub

How I Built It

BirdNET identifies birds from audio. Its location and week model also builds the bingo card and filters out birds that don't live nearby.
Gemma 3 (4B), served locally by Ollama, writes the field journal.
Streamlit and ffmpeg handle the interface and audio.

Two lessons shaped the design:

Filtering by location matters. Without it, the detector reported dozens of species from a short clip.
Language models invent things. With an empty detection list, Gemma wrote about a Robin and a Cardinal that don't live here. Now the card is checked against the detections, and a plain template replaces it if it mentions a bird that wasn't heard.

Why Does Open Innovation Matter?

It works with no signal. BirdNET runs on the laptop, so a forest trail is no problem. A hosted audio API wouldn't work there.
Recordings stay private. A walk recording holds a location and other people's voices. Nothing is uploaded.
No per-request cost. Analyzing a long walk every day is free.
A specialist model fits better. BirdNET is trained for exactly this task, and I could inspect and fix its over-reporting myself.

One caveat: Gemma is replaceable by almost any small local model. BirdNET is the part a general closed API couldn't replace offline. Its weights are also non-commercial.

My Agent Session

I planned the project with Claude and built it with Antigravity, testing each round myself and sending back what failed. [[OPTIONAL: paste your DevRelay session link, or delete this section]]

Prize Categories

Best Use of Gemma: Gemma 3 (4B) runs locally through Ollama and writes the field journal, fully offline, with a check that keeps its output honest.

DEV Community: Anush Deotare

I Built a Graveyard for My Abandoned Git Repos (Gemma Writes the Epitaphs, Offline)

What I Built

Code

anushdeotare11 / repo-graveyard

🪦 Repo Graveyard

📸 Preview

How I Built It

Why Does Open Innovation Matter?

Prize Categories

Sloth Sorter: A Local AI That Organizes Your Messy Folders, Slowly (Gemma 3 + Ollama)

What I Built

Demo

Recording 2026-10-22 013402.mp4 - Google Drive

Code

anushdeotare11 / sloth-sorter

🦥 Sloth Sorter

💻 Tested On

📊 Measured Benchmark Results

How I Built It

Why Does Open Innovation Matter?

Prize Categories

Parchi: Turning a Night of WhatsApp Orders into a Prep Sheet with Gemma 4, Offline

What I Built

Demo

Code

anushdeotare11 / parchi

Parchi

Project status

Quick start

The Problem

How It Works

How I Built It

Why Does Open Innovation Matter?

Prize Categories

Dawn Chorus: An Offline Bird-Call Bingo Built on BirdNET and Gemma (hacktoberfest week 1 dev challenge)

What I Built

Demo

hacktoberfest.mov - Google Drive

Code

anushdeotare11 / dawn-chorus

Dawn Chorus

Contents

How I Built It

Why Does Open Innovation Matter?

My Agent Session

Prize Categories