DEV Community: Yash Dharme

git-séance: I let the ghosts of deleted code speak at their own funeral

Yash Dharme — Wed, 28 Oct 2026 17:31:02 +0000

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

What I Built

Every repository is a graveyard.

Files are born in a commit like add new benchmarks (to match koa). People fix them, extend them and argue about them for years. Then one day someone writes chore: remove benchmarks directory, and they're gone: not from history, just from everyone's memory.

git-séance holds a séance for them. It's a small command-line tool that:

finds every file that ever died in a repository's history;
lets each ghost speak: who created it and when, what it used to do, how long it lived, who cared for it, and the exact commit that ended it;
builds an *ofrenda*, a GRAVEYARD.md memorial page for your repo's longest-lived departed code.

It's spooky, and it's also my take on Día de los Muertos: a small altar for the code that held the project up before anyone now on the team arrived.

Demo

I pointed it at the Express repository: 6,183 commits and 16 years of history.

$ git-seance --repo express

🪦  684 files rest in the history of express.

   The longest-lived:

   ⚰️  benchmarks/run                              15.7 years   ✝ 2026-01-17
   ⚰️  benchmarks/Makefile                         12.1 years   ✝ 2026-01-17
   ⚰️  benchmarks/middleware.js                    12.1 years   ✝ 2026-01-17
   ⚰️  Contributing.md                             11.1 years   ✝ 2025-06-09
   ⚰️  examples/multipart/index.js                 10.8 years   ✝ 2023-05-18
   ⚰️  test/mocha.opts                             10.2 years   ✝ 2022-02-21
   …

That listing takes about 0.3 seconds. Then you summon one:

$ git-seance summon lib/view/partial.js --repo express

👻  lib/view/partial.js

   I was partial.js. Tj Holowaychuk brought me into this world on 2011-02-03,
   with the words "moved files from lib/express/* to lib/". I used to resolve
   partial object names from the view path, resolving them into a human-readable
   name. I walked these halls for 8 months, and 2 commits passed through me. By
   the end I was 40 lines. Then, on 2011-10-07, Tj Holowaychuk wrote the words
   that ended me: "re-working view system".

   ── its last words ──
   │ …the file's final contents, straight out of git…

And this is part of the ofrenda it wrote for Express (git-seance ofrenda --n 6, about 35 seconds on a laptop CPU):

⚰️ Contributing.md

2014-05-12 – 2025-06-09 · 11.1 years

I was Contributing.md. Roman Shtylman brought me into this world on 2014-05-12, with the words "add Contributing.md". I used to guide newcomers through the process of contributing to the Express.js project, guiding them towards involvement while minimizing unnecessary hurdles. I walked these halls for 11.1 years, and 33 commits passed through me. By the end I was 246 lines. Then, on 2025-06-09, Sebastian Beltran wrote the words that ended me: "fix(docs): move documentation and charters to the discussions and .github … (#6427)". Tell Ulises Gascón, Blake Embrey and Douglas Christopher Wilson I remember them.

⚰️ test/mocha.opts

2011-12-20 – 2022-02-21 · 10.2 years

I was mocha.opts. Tj Holowaychuk brought me into this world on 2011-12-20, with the words "mocha.opts". [...] I walked these halls for 10.2 years, and 2 commits passed through me. By the end I was 3 lines. Then, on 2022-02-21, Douglas Christopher Wilson wrote the words that ended me: "tests: remove usage of should".

Every name, date, count and commit message in there is real, pulled straight from git.

Code

Yash11778 / git-seance

Summon the ghosts of deleted code from your git history, with an open-weight model (Gemma) running on your own machine.

👻 git-séance

Every repository is a graveyard. Files are born, worked on for years, and then one commit (chore: remove benchmarks directory) ends them. git-séance finds them lets each ghost tell its story, and builds an ofrenda, a memorial page, for your repo's departed code.

Built for the Hacktoberfest Open-Source AI Challenge, Week 4: Ghost in the Machine.

$ git-seance --repo express
🪦  684 files rest in the history of express.

   The longest-lived:

   ⚰️  benchmarks/run                              15.7 years   ✝ 2026-01-17
   ⚰️  benchmarks/Makefile                         12.1 years   ✝ 2026-01-17
   ⚰️  Contributing.md                             11.1 years   ✝ 2025-06-09
   ⚰️  examples/multipart/index.js                 10.8 years   ✝ 2023-05-18
   ⚰️  test/mocha.opts                             10.2 years   ✝ 2022-02-21
   …

$ git-seance summon lib/view/partial.js --repo express

👻  lib/view/partial.js

   I was partial.js. Tj Holowaychuk brought me into this world on 2011-02-03,
   with the words "moved files from lib/express/* to lib/". I used to resolve
   partial object names from the view path, resolving them

…

View on GitHub

MIT licensed. About 280 lines of plain Node.js, no build step. Point it at any git repository you have locally:

git clone https://github.com/Yash11778/git-seance && cd git-seance && npm install
node bin/git-seance.mjs --repo /path/to/any/git/repo

How It Works

git log --diff-filter=D  ──► every deleted path (skipping any that were brought back)
git log --diff-filter=A  ──► when and by whom each one was born
git rev-list / shortlog  ──► how many commits touched it, who cared for it most
git show <death>^:<path> ──► its last words (the final contents)
                         ──► Gemma reads the last code ──► "I used to …"
                         ──► the ghost's speech: git facts + Gemma's one line

The lesson: a ghost may be eerie, but it may not lie

My first version gave Gemma a list of true facts about each file and asked it to write the whole eulogy. The voice was perfect and the history was invented. A file changed in exactly two commits became "a steady flow of updates". A file that was simply deleted "faded away slowly, shrinking with each line deleted". And when it didn't feel like using a fact, it dodged: "I was created on a specific date."

That's the one thing a tool about honouring the past can't do. So the work is split:

The code writes every fact into the speech (names, dates, lifespans, line counts, commit messages), so they're always true.
Gemma gets the one job only it can do: read the dead file's last code and say, in the ghost's voice, what it used to do.

const prompt = `Here is the last version of a deleted file called "${path}":
"""
${words.excerpt.slice(0, 1200)}
"""

In one short sentence, say what this file used to do, spoken by its ghost in first
person and past tense ("I used to ..."). Base it only on the code above: name the
concrete thing it did. Be a little eerie. Reply with the sentence only.`;

Grounded in the code, the lines are specific and right. lib/view/partial.js "used to resolve partial object names from the view path", and the old jQuery copy says "I was a jQuery JavaScript Library, version 1.3.2".

A smaller lesson: you can't tell a 1B model what not to say

Gemma loved the word "meticulously": four of the first six ghosts did something meticulously. I added "Do not use the words meticulously, diligently or carefully" to the prompt, and the very next ghost was still "diligently processing requests". Small models don't follow negative instructions well. So the filler words are now stripped in code after generation, a three-line regex, and it works every time.

Why Open Matters Here

A repository's history is its team's private memory: names, commit messages, and code that was deleted on purpose. A tool like this only makes sense if none of that leaves your machine, especially for a company's private repos.

Gemma 3 1B runs locally through Transformers.js and onnxruntime-node, on an ordinary laptop CPU. No code, names or commit messages are sent anywhere.
It works with the lights (and the internet) off. After a one-time ~860 MB download, it's fully offline.
It costs nothing, and it won't disappear. No API key and no hosted service that can be shut down. That feels right for a tool about remembering things that are gone.
The model is swappable. Set SEANCE_MODEL to summon with a bigger model.

What's Next

Summon deleted functions, not just whole files, by walking git log -p for definitions that vanished.
A "family tree" that follows renames, so a file's ancestors attend its funeral too.
git-seance haunt: a commit hook that writes a short epitaph whenever you delete a file.

Prize Categories

Best Use of Gemma. Gemma 3 1B is the only model in the project. It runs locally and reads every ghost's last code to say what it used to do.

Built with AI assistance (Claude Code) for scaffolding, testing and debugging. The demo uses the public Express repository's history; every ghost's facts come straight from its git log.

Sloth Sort: I let a local AI clean my Downloads folder so I never have to

Yash Dharme — Tue, 20 Oct 2026 12:18:45 +0000

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

What I Built

Everyone has a Downloads folder like this:

download.pdf            download (1).pdf        scan0003.pdf
Document.pdf            e-ticket_8F3K2.pdf      statement_092026.pdf
untitled.md             notes.txt               export.csv
Screenshot from 2026-10-02 21-14-07.png        project-final-FINAL.zip
code-1.105.0-amd64.deb  lecture-recording.mp4   …

Somewhere in there is the bill you need to pay, the internship offer you need to sign, and the flight ticket you'll be frantically searching for at the airport gate. Cleaning it up means opening every download (1).pdf to find out what it is. So nobody does.

Sloth Sort does it for you. It's a small command-line tool:

sloth-sort plan  ~/Downloads   # look at everything, decide, move nothing
sloth-sort apply ~/Downloads   # do exactly what you just reviewed
sloth-sort undo  ~/Downloads   # put it all back

The interesting part is that it reads your documents and gives them names a human would search for, using Gemma 3 1B running on your own machine.

Demo

This is real output from my test folder of 19 made-up files (the repo has a script that generates the same folder, so you can try it safely):

📁 Documents/Bank & Finance/
   statement_092026.pdf  →  2026-10 Riverbank Savings Account.pdf  ✨

📁 Documents/Bills & Receipts/
   download.pdf  →  2026-10 Sunrise Telecom Tax Invoice.pdf  ✨
   export.csv  →  2026-10 Groceries & Electricity Bills.csv  ✨

📁 Documents/Health/
   Document.pdf  →  Paracetamol Dosage.pdf  ✨

📁 Documents/Study/
   download (1).pdf  →  Normalization Database Management Systems.pdf  ✨
   untitled.md  →  Paging and Segmentation.md  ✨

📁 Documents/Travel/
   e-ticket_8F3K2.pdf  →  Pune to Bengaluru flight ticket.pdf  ✨
   notes.txt  →  Goa Trip Essentials.txt  ✨

📁 Documents/Work & Career/
   scan0003.pdf  →  Brightleaf Software Internship Offer.pdf  ✨

📁 Screenshots/2026-10/
   Screenshot from 2026-10-02 21-14-07.png
   Screenshot from 2026-10-11 09-02-55.png
…
19 files planned (9 read by Gemma ✨, the rest by type) in 19s. Nothing has moved yet.

Then apply moved all 19, and undo put every one of them back exactly where it was. I checked that by comparing a hash of the file list before and after.

The lazy payoff

19 seconds to plan 19 files on a laptop CPU, with no GPU (after the model's one-time download).
9 documents read for me, and every one of them landed in the right folder with a name that says what it is.
One command to review, one to apply. The alternative is opening nine download (1).pdf-style files one by one. I'd guess that's 5–10 minutes of clicking for this folder. For a real Downloads folder with a few hundred files, it's the afternoon I've been putting off for two years.

Code

Yash11778 / sloth-sort

Tidy a messy Downloads folder with an open-weight model (Gemma) that runs on your own machine.

🦥 Sloth Sort

Tidy a messy Downloads folder with an open-weight model that runs on your own machine It reads your documents, files them into sensible folders with names you can actually search for, shows you the plan, and only moves things when you say so. One command undoes it all.

Built for the Hacktoberfest Open-Source AI Challenge, Week 3: Slow and Steady.

$ sloth-sort plan ~/Downloads

📁 Documents/Travel/
   e-ticket_8F3K2.pdf  →  Pune to Bengaluru flight ticket.pdf  ✨
📁 Documents/Work & Career/
   scan0003.pdf  →  Brightleaf Software Internship Offer.pdf  ✨
📁 Documents/Bills & Receipts/
   download.pdf  →  2026-10 Sunrise Telecom Tax Invoice.pdf  ✨
📁 Screenshots/2026-10/
   Screenshot from 2026-10-02 21-14-07.png
...
19 files planned (9 read by Gemma ✨, the rest by type) in 19s. Nothing has moved yet.

$ sloth-sort apply ~/Downloads     # do it
$ sloth-sort undo ~/Downloads      # changed your mind

How it works

Obvious files are sorted by…

View on GitHub

MIT licensed. About 500 lines of plain Node.js (ES modules), including the demo generator, with no build step.

git clone https://github.com/Yash11778/sloth-sort && cd sloth-sort && npm install
npm run demo                                 # makes a messy folder of made-up files
node bin/sloth-sort.mjs plan demo-downloads

How It Works

every file ──► hidden / half-downloaded / changed in the last 2 min?  ──► leave alone
           ──► image, video, installer, archive, code, font?          ──► sort by type (instant)
           ──► document ──► read the first ~1,500 characters (PDF, Word, text, CSV)
                        ──► clear keywords? ("PNR", "account statement", "prescription")
                               yes ─► that folder
                               no  ─► Gemma picks one of 8 folders
                        ──► Gemma writes a title, shaped for that folder
           ──► plan saved to disk ──► you review ──► apply ──► undo log

Lesson 1: the model is the last resort, not the first

Most of a Downloads folder doesn't need AI. A .png named Screenshot from … goes in Screenshots/<month>, and a .deb goes in Installers. So only documents ever reach the model. In the demo, that's 9 of 19 files.

Even for documents, my first version asked Gemma to pick one of eight folders, and it got three of nine wrong: the flight e-ticket went to Bills, the bank statement to Bills, and the internship offer letter to Other. A 1B model choosing among eight similar categories is guessing. But "PNR" or "boarding pass" in a document is not ambiguous, so clear keywords now decide first:

const RULES = [
  ['travel', /\b(pnr|boarding pass|e-?ticket|itinerary|flight|departure|…)\b/i],
  ['health', /\b(prescription|diagnosis|lab report|physician|…)/i],
  ['bank',   /\b(account statement|opening balance|ifsc|salary slip|…)\b/i],
  ['work',   /\b(offer letter|internship|resume|appointment letter|…)\b/i],
  // …
];

Gemma still decides anything the keywords don't recognise. After this change, all nine landed in the right folder.

Lesson 2: don't show a small model the old name, or any real-looking example

My first title prompt included the filename, and Gemma handed scan0003 and Document straight back. Then I removed the filename and added an example title, "Sunrise Telecom September Bill", and the prescription came back as "Sunrise Telecom Patient Care". A 1B model will happily copy whatever concrete text you put in front of it.

The fix was to give it only the document's contents, plus a shape rather than an example, chosen for the folder it's going to:

const SHAPE = {
  bills:  '"<company> <month> bill" or "<shop> order receipt"',
  travel: '"<airline> <from> to <to> ticket" or "<city> hotel booking"',
  work:   '"<company> offer letter" or "<name> resume"',
  // …
};

That's how e-ticket_8F3K2.pdf became "Pune to Bengaluru flight ticket" instead of "Airline November Bill airline", which is what it produced while every document got the same bill-shaped hint.

Lesson 3: a tool that moves your files has to be boring about safety

It plans first and moves nothing. The plan is written to disk, and apply does exactly that plan.
It only moves files, inside the one folder. Nothing is deleted or overwritten, and a name clash gets " (2)".
It refuses to escape. I edited a plan by hand to move a file to ../../escaped.txt, and apply refused: Refusing to touch ../../escaped.txt: outside ….
Half-finished downloads are left alone (.crdownload, .part, anything modified in the last 2 minutes).
undo restores everything and removes only the folders it created, and only if they're empty.

Why Open Matters Here

Your Downloads folder is the most private folder on your computer: bank statements, ID scans, offer letters, prescriptions, tickets with your PNR on them. A tool like this only makes sense if nothing leaves your machine. A hosted model would mean uploading all of it to sort it.

With an open-weight model, that isn't a trade-off:

It runs locally. Gemma 3 1B runs through Transformers.js and onnxruntime-node, on a normal laptop CPU.
It works offline. After a one-time ~860 MB download, it never touches the network.
It's free, forever. No API key and no per-file cost, so running it on 2,000 files costs the same as on 20.
The model is swappable. Set SLOTH_MODEL to try a bigger or newer ONNX model.

What's Next

A watch mode, so new downloads get filed as they arrive. Maximum sloth.
Images by content with a small open vision model: receipts, whiteboards and memes are all .jpg.
Hindi and Marathi documents, which need a bigger multilingual model.

Prize Categories

Best Use of Gemma. Gemma 3 1B is the only model in the project. It runs locally and does both the folder decisions the keywords can't make and every new file name.

Built with AI assistance (Claude Code) for scaffolding, testing and debugging. Every file in the demo is made up; no real documents were used.

Reply Desk: a review-reply assistant for small shops, where customers' words never leave the counter

Yash Dharme — Thu, 15 Oct 2026 17:03:30 +0000

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

What I Built

Reply Desk is a review-reply assistant for small businesses: the chai stall, the salon, the neighbourhood clinic, the coaching centre, the home baker.

These businesses live and die on Google and Zomato reviews. Replying to every review helps, and nobody behind the counter has time to do it. Worse, the reviews that actually matter ("found a hair in my food", "the staff was rude") get buried under twenty "nice chai!" ones.

Reply Desk does three things:

It puts urgent reviews first. Food-safety, health, money and staff-behaviour complaints are flagged "Today" and moved to the top, the moment you paste them.
It reads the mood of each review: positive, mixed or negative.
It drafts a reply in the owner's voice, signed with their name. Unhappy customers are pointed to the owner's own contact, like a WhatsApp number, instead of an argument in public.

You read it, tweak it, copy it, post it. If the mood is wrong, tap the right one and it redrafts.

All of this runs on an open-weight model, Gemma 3 1B, inside the browser tab. No account, no API key, no server, no upload.

Who would pay for it

A café owner who would never pay for "AI". They would pay ₹199–299 a month for "every review answered in two minutes, and you'll never miss a complaint again". The same goes for a small agency that manages listings for ten local shops.

The pricing only works because of the open model, which is a later section.

Demo

It's a static web app with no backend, so you run it on your own machine:

git clone https://github.com/Yash11778/reply-desk
cd reply-desk
npm install
npm run dev

Open the local URL, click "Fill in an example", then "Draft replies". With WebGPU it's quick. Without it, it falls back to the CPU and takes roughly 10–20 seconds a reply, but it works. The first run downloads the model once (~0.8–1 GB), and after that it's cached.

This is real, unedited output from a test run on a laptop with no GPU at all (CPU only, inside the browser), for a made-up café called "Chai Point Corner" run by "Priya":

Review: Found a hair in my poha. Disgusting. Want my money back.
Flag: Today: Something found in the food · Mood: negative
Reply: I sincerely apologize for the unpleasant experience you had with our poha. I'm truly sorry that your experience was so disappointing. Please contact me directly at 98765 43210 so we can discuss this further and make things right. I value your feedback and want to ensure you're satisfied.
Priya

Review: Waited 25 minutes for two sandwiches and the guy at the counter was rude when I asked.
Flag: Today: Staff behaviour · Mood: negative
Reply: Thank you for your feedback. I sincerely apologize for the delay and the experience you had with our staff. I want to assure you that I'll investigate this matter immediately. Please contact me directly at 98765 43210 so we can discuss this further.
Priya

Review: Nice ambience, friendly owner aunty. Sandwich was soggy though.
Mood: mixed
Reply: I'm sorry to hear you had a disappointing experience. Thank you for your feedback. I'll certainly take your comments about the sandwich and will investigate further to understand what went wrong.
Priya

They aren't Shakespeare, and they don't need to be. They're polite, specific, signed, and they never invent a discount or a fake phone number. That last part took work (see below). The third one is also a fair example of why the owner reads before posting: it skipped thanking her for the "friendly owner aunty" bit, and a human would add that back in five seconds.

Code

Yash11778 / reply-desk

Draft replies to customer reviews with an open-weigh model (Gemma) that runs in your browser. Nothing isuploaded.

Reply Desk

Paste your Google or Zomato reviews. An open-weight model running in your browser tab sorts them, flags the ones you must deal with today, and drafts a reply to each one in your own voice. Your customers' words never leave your computer.

Built for the Hacktoberfest Open-Source AI Challenge, Week 2: Side Hustle.

Who it's for

Small businesses that live on reviews: cafés, salons, clinics, coaching centres, home bakers. Replying to every review is good for them and nobody has time for it. The ones that matter most, like "found a hair in my food" or "staff was rude", get buried under "nice chai!".

How it works

Set up once: business name, what it is, your name, and where unhappy customers should reach you. It's saved in your browser.
Paste reviews, with a blank line between each.
Urgent first: a plain keyword check flags food-safety, health, money…

View on GitHub

MIT licensed. TypeScript and Vite, no framework, about 9 kB of app code plus the model runtime.

How It Works

paste reviews ──► split on blank lines
              ──► keyword check: urgent?  (instant, no model)
              ──► complaint words?  no ──► positive (no model)
                                    yes ─► Gemma: mixed or negative?
              ──► Gemma: draft a reply with the prompt for that mood
              ──► clean-up: strip chatter, placeholders, double sign-offs

The model runs in a Web Worker through Transformers.js, using onnx-community/gemma-3-1b-it-ONNX. That's 4-bit weights on WebGPU, and 8-bit on CPU.

Lesson 1: give a 1B model one job, not three

My first prompt asked Gemma to classify the mood, flag urgency and write the reply, in a fixed format. It ignored the format and wrote things like **First line: POSITIVE**. It also wrote this, for a real-looking complaint:

Please contact Priya directly at [Priya's Phone Number or Email]

Two changes fixed it:

One prompt per job. Classification is its own short prompt, and the reply is another.
One prompt per mood. "If the review is bad, apologise" made it apologise to happy customers. So the code picks the mood first, and each mood gets its own one-line instruction:

const TASK: Record<Mood, (b: Business) => string> = {
  positive: () => 'Thank them for their review.',
  mixed: () => "Thank them for the good part, and say plainly that you'll look at the thing they didn't like.",
  negative: (b) => `Apologise once, without excuses, and ask them to contact you on ${b.contact} so you can make it right.`,
};

The owner's real contact detail is passed in, and the prompt says "Do not invent phone numbers, emails, discounts or promises." A small clean-up pass then strips anything in [square brackets], "Okay, here's a reply:" preambles, markdown, and a doubled sign-off.

Lesson 2: don't use the model where a word list is better

Missing a food-safety complaint is the one mistake that really matters, so urgency is a plain keyword list, not the model: hair, cockroach, sick, food poisoning, stale, refund, rude, and so on. It's predictable and instant, and it lets the urgent cards appear at the top before the model has even loaded.

The same goes for clearly happy reviews. The CPU (8-bit) build liked to hedge and call "Best masala chai in the area!!" "mixed". Now a review with no complaint words at all (but, though, cold, slow, rude, not…) is positive without asking the model. Gemma only decides the hard case: mixed or negative.

Lesson 3: "runs in the browser" has fine print

Getting the no-GPU path working took three fixes, all found by running it rather than reading docs:

The 4-bit build crashed on CPU: Could not find an implementation for GatherBlockQuantized. onnxruntime-web's WASM backend doesn't have that kernel, so the CPU path loads the 8-bit build instead.
The 8-bit build then 404'd on model_int8.onnx_data. The model repo's config says its weights live in an external data file, which is true for the other builds but not for int8, which is one self-contained file. Passing use_external_data_format: { 'model_int8.onnx': 0, … } fixed it.
It ran on one CPU core. WASM threads need SharedArrayBuffer, which needs the page to be cross-origin isolated. Two headers in vite.config.ts (Cross-Origin-Opener-Policy: same-origin, Cross-Origin-Embedder-Policy: credentialless) let it use every core. credentialless matters here, because it keeps the Hugging Face CDN download working without that server sending extra headers.

Why Open Matters Here

It's what makes the business work.

Privacy is the product. Reviews carry customers' names, phone numbers, and complaints about named staff. "Your customers' words never leave this computer" is a promise I can actually keep, because there's no server to leave to.
Zero cost per reply. A hosted model charges per token, forever. Here the shop's own laptop does the work, so a ₹199/month price has no API bill eating it. A hosted model would also force me to meter usage, and "unlimited replies" is a much easier sell to a shop owner.
No lock-in. No API key to leak, no provider changing prices or deprecating the model under me. If a better small open model comes out, swapping it is one line (MODEL in worker.ts).
It still works offline once the model is cached, for example in a shop with patchy internet.

What's Next

Hindi, Marathi and Hinglish replies, since many reviews here are written that way. That needs a bigger or fine-tuned model.
Per-business tone examples: paste three replies you've written, and it matches them.
A weekly summary: "4 people mentioned slow service this week".

Prize Categories

Best Use of Gemma. Gemma 3 1B is the only model in the app. It runs on-device through Transformers.js and does both the mood reading and every reply.

Built with AI assistance (Claude Code) for scaffolding, testing and debugging. All sample reviews are invented for the demo.

Side Quest: an AI that sends you on a walk, and never learns where you are

Yash Dharme — Thu, 08 Oct 2026 16:57:56 +0000

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

What I Built

Side Quest turns the streets around you into a short scavenger hunt.

You tell it how long you have (15 to 60 minutes) and what kind of clues you like (playful, poetic, detective, or for kids). It finds a few interesting places within walking distance (a temple, a mural, an old bookshop, a pond) and plans a loop that fits your time. Then Gemma, running inside your browser, writes a riddle for each stop.

Then you put the phone away.

When you think you've found the place, you check in. The app shows you one small thing to notice before you move on: count the bells, find the oldest crack in the wall, listen for one sound that repeats. At the end, Gemma writes a three-line postcard about the walk. It is saved only on your device.

Most "AI + outdoors" apps keep you looking at the screen while you're outside. I wanted the opposite: the screen is on for about ten seconds per stop, and the rest of the time you're looking at the street.

Demo

Live app: https://hacktoberfest-26.vercel.app
Try it from your desk: https://hacktoberfest-26.vercel.app/?at=18.5195,73.8553&sim starts you at Shaniwar Wada in Pune and adds a Teleport button, so you can play a whole quest without walking.

You need a browser with WebGPU for the model: Chrome on Android 12+, or Chrome/Edge on Windows or macOS. The first run downloads Gemma once (~0.7 GB). Without WebGPU, the walk still works with simple built-in clues.

Code

Yash11778 / Hacktoberfest-26

Side Quest

A short walking scavenger hunt around wherever you're standing. The clues are written by Gemma, running entirely in your browser (WebGPU via WebLLM) Your location never leaves the phone.

Built for the Hacktoberfest Open-Source AI Challenge, Week 1: Touch Grass.

How it works

Pick how long you have (15–60 min) and a clue style (playful, poetic, detective, for kids).
The app finds interesting places nearby from OpenStreetMap and Wikipedia: parks, temples, murals, old trees, bookshops, historic buildings.
A small planner picks a loop of 2–4 varied stops that fits your time.
Gemma writes a riddle for each stop plus one small thing to notice when you get there.
Put the phone away. Check in when you think you've found it (it buzzes if the screen is on).
At the end, Gemma writes you a three-line postcard of the walk, saved only on your device.

Why

…

View on GitHub

MIT licensed. About 1,000 lines of TypeScript, no framework.

How It Works

your phone ──► snap location to a ~1 km grid square
           ──► OpenStreetMap + Wikipedia: "what's interesting in this square?"
           ──► planner: pick 2–4 varied stops that fit your time
           ──► Gemma (WebGPU, in a Web Worker): write a riddle per stop
           ──► walk · check in · notice something · next clue
           ──► Gemma: write a postcard of the walk → saved on the device

1. Finding places, with two free and keyless sources. OpenStreetMap (via the public Overpass API) gives the small stuff: parks, temples, murals, named bakeries, old trees. Wikipedia's geosearch API gives named landmarks with a line of description, which turns out to be great riddle material. Near Shaniwar Wada in Pune, one query returned 188 candidate places.

2. Planning the loop, deliberately without AI. A small randomised search tries 400 greedy loops and keeps the one with the most stops, the most variety (it heavily penalises a second temple in a row), and a total time closest to what you asked for. Walking speed is 70 m/min and streets get a 1.3× detour factor. A planner is the right tool here: it's deterministic and checkable, and a 1B model is bad at geometry.

3. Writing the clues, which is where the model earns its place. Each stop's OpenStreetMap tags and Wikipedia summary go to Gemma with one job: hint at the place without naming it, and suggest one thing to notice with your senses.

const prompt = `You write clues for a real-world walking scavenger hunt.

The walker must find this place: ${describe(place)}.

Write:
1. A riddle of at most two short sentences that hints at the place without saying its name.
   Use what someone would see, hear or smell there.
2. One small thing to notice once they arrive, using their senses. One sentence.

Tone: ${VOICE[vibe]}. No emoji. No hashtags.

Reply in exactly this format and nothing else:
CLUE: <riddle>
NOTICE: <thing to notice>`;

If the model's answer can't be parsed, or it gives the name away, a template clue takes over and the screen says so honestly.

Why Open Matters Here

This is the part I care about most.

A hosted model would need your live location for every clue. Here nothing about where you're standing ever reaches an AI provider, because the AI provider is your own GPU. Gemma runs in the browser through WebLLM on WebGPU, inside a Web Worker.

The only network requests are the map lookups, and even those never carry your exact position. The query box is snapped outward to a 0.01° grid (about 1.1 km) before it leaves the phone:

/**
 * A bounding box snapped outward to a 0.01° grid (~1.1 km). This is the only
 * thing about your location that ever leaves the phone: the map server learns
 * which grid squares you asked about, never the point you're standing on.
 */
export function snappedBbox(c: LatLng, radiusM: number) { … }

Everyone standing anywhere in the same square sends the identical request.

The rest follows from using open pieces:

It costs nothing to run. There are no API keys and no accounts. It's a static site plus one tiny cached relay function on Vercel's free tier. With a closed model API I'd be paying per riddle, or asking you for a key.
It works offline after the first run. The model weights are cached by the browser, and map results are cached per area for a week, so a second walk in the same neighbourhood works with no signal at all.
The model is swappable. You can pick Gemma 3 1B (~0.7 GB, sized for phones) or Gemma 2 2B (~1.4 GB, better clues on a laptop). Swapping is one line in MODELS.

What Went Wrong (and What I Changed)

The public Overpass server turns away browsers. It worked from my dev machine, then failed on the deployed site: overpass-api.de answers anonymous browser requests with 406 Not Acceptable and no CORS header, so the browser reports a CORS error that hides the real reason. The server wants clients to identify themselves, and a browser isn't allowed to set User-Agent. The fix is a ~50-line Vercel function, api/places.ts. It accepts only a grid-snapped box (anything off-grid or over ~9 km is rejected), sends the fixed query with an identifying User-Agent, falls back across four mirrors, and sets s-maxage=604800 so the CDN answers repeat boxes for a week without touching OpenStreetMap at all.
Even when it identified itself, Overpass was often overloaded, with 504 Gateway Timeout more often than not during testing. So OpenStreetMap and Wikipedia run in parallel, the relay starts its mirrors a few seconds apart and takes the first complete answer, and either source alone is enough to plan a walk.
Overpass sometimes "succeeds" with nothing. Under load it can give up mid-query and still answer 200 OK with an empty list and a remark saying it timed out. The app read that as "nothing here". Those answers are now treated as failures, and an empty area is only cached for an hour.
Wikipedia was silently dropping most results. The geosearch generator returned 47 pages, but only 10 had coordinates attached. prop=coordinates has its own limit (colimit) that defaults to 10. Adding colimit=max took the area from 1 usable landmark to dozens.
'gpu' in navigator is not enough. A browser can expose WebGPU and still have no usable adapter. Chrome on Linux does exactly that by default. The check now actually calls requestAdapter(), and if the model can't start, the walk still happens with built-in clues instead of an error screen.
Laptops don't really know where they are. Desktop browsers locate by Wi-Fi or IP and can be kilometres out. When a lookup comes back empty, the app now says how coarse your location is and offers a demo walk instead of a dead end.
Browsers pause GPS when the screen is off. I can only buzz you on arrival while the screen is on. Otherwise you tap I think I'm here. Honestly, that turned out to be part of the fun.

What's Next

Fine-tune a small Gemma on good riddles, since the 1B model's clues vary in quality.
A "share this quest" link, so friends can walk the same route without either of you sending your location anywhere.
Hindi and Marathi clues.

Prize Categories

Best Use of Gemma. Gemma is the only AI in the app. It runs entirely on-device via WebGPU and writes every clue and postcard.

Map data © OpenStreetMap contributors (ODbL). Wikipedia text CC BY-SA. Built with AI assistance (Claude Code) for the scaffolding and debugging.