DEV Community: Karishma Das

Hacktober-Fest-In-Peace: A Graveyard for My Dead Bookmarks, Written by a Local AI

Karishma Das — Sat, 31 Oct 2026 02:14:12 +0000

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

What I Built

I ran a list of 26 old links through a script, and it flagged 15 of them as dead. Then a small AI model on my own laptop wrote a tombstone for each one.

Hacktober-Fest-In-Peace is a Dead Link Cemetery. You give it your bookmarks (or any list of URLs), and it does four things:

Checks which links are dead.
Looks each one up in the Wayback Machine to find when it was first and last saved.
Reads what the old page said, and a local Gemma model writes a two-line epitaph from only those facts.
Builds a dark, spooky tombstones.html where every dead link has a gravestone: name, years, cause of death, and a "visit the ghost" link to the archived copy.

For the theme, I treated websites as things that live and die. Halloween has the graveyard, and Día de los Muertos has the remembering. A bookmark is a small promise that you'll come back to a page someday, and for most pages, nobody ever does. My tool goes back and says goodbye.

The idea came from a simple fact: every old bookmarks folder is a graveyard nobody has visited.

I ran it on a demo list of 26 old links (famous dead services plus 6 fake addresses I planted on purpose). It flagged 15 as dead and counted 11 as alive. All 6 planted fakes were caught.

Code

Karishma-Das / hacktober-fest-in-peace

Hacktober-Fest-In-Peace

Finds your dead bookmarks, digs up their old copies from the Wayback Machine, and lets a local Gemma model write an epitaph for each one.

How it works

Reads a bookmarks export or a list of URLs.
Checks which links are dead.
Looks up each dead link in the Wayback Machine.
A local model (Gemma via Ollama) writes a two-line epitaph.
Builds tombstones.html, a gallery of tombstones.

Run it

Install Python and Ollama, then run: ollama pull gemma3:4b
pip install requests
python cemetery.py demo_urls.txt --model gemma3:4b
Open tombstones.html

Privacy, honestly

The AI runs on your own machine. Link checking still contacts each site, and Wayback lookups send those URLs to archive.org.

Built for Hacktoberfest Week 5: Ghost in the Machine.

View on GitHub

One Python file, cemetery.py, plus a README and the demo list. The only dependency is requests.

How I Built It

Open pieces: Gemma (an open-weight model) running locally through Ollama, and the Wayback Machine's public archive. No paid API and no AI account.

The flow:

Bookmark export in, link check on every URL, dead ones go to the Wayback Machine for their first and last saved dates and the old page text.
Gemma gets only those facts and a strict prompt: use only what's below, never invent a name or a year, write two short lines. The cause of death comes from the program, not the model, so the model can't make up how a site died.
Results are saved in a small cache file, so if a run crashes halfway, rerunning picks up where it stopped.
The gallery is plain HTML and CSS with no framework, so it opens anywhere.

What went wrong:

The dead-or-alive check is not perfect. Deciding that a website is dead is harder than it sounds. Some live sites answer slowly or refuse scripts, and some dead brands redirect somewhere else and look alive. The script treats a clear "this page is gone" or "this domain doesn't exist" as the strongest evidence of death.

Why Does Open Innovation Matter?

The AI reads my browsing past on my own machine. A bookmarks file shows what you worried about at 2 AM. The text of old pages and the epitaph writing never go to an AI company. To be honest about the limits: checking links still contacts each website, and the Wayback lookups send those URLs to archive.org. The local part is the AI, not the whole pipeline.
It costs nothing to run, however many links I have. A paid API would make me think twice about running 1,000 dead links.
I can swap the model or change the voice (funny, tender, dramatic) by editing one line, without asking a company.
It works without an AI account, and it can't disappear because a service shut down. That fits a project about things that disappeared when companies shut down.

Prize Categories

Best Use of Gemma: Gemma runs locally through Ollama and writes every epitaph, grounded only in facts the program supplies.

Sloth Desk: Paste a Message You’re Avoiding, Get a Checklist (Local Gemma, No Cloud)

Karishma Das — Sun, 25 Oct 2026 07:22:47 +0000

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

What I Built

Sloth Desk is a one-page tool for the messages you keep putting off. Paste an email, a college notice, a landlord's text or a bill, and it gives you a short checklist: what it is, what you have to do, and every date, time, amount, file requirement and place, in order.

A real example: a 10-line placement-cell notice becomes five lines. Upload the resume as a PDF under 2 MB by 29 Oct, 5 pm. Attend the Infosys talk on 2 Nov, 10:30 am, in the main auditorium, with your college ID. The eligibility list goes up on 31 Oct. Nobody has to read the whole thing twice.

It saves the "I'll read this later" effort, and the cost of missing a deadline buried in paragraph four. Anyone who gets long, wordy notices (students, tenants, freelancers, parents) gets to be a little lazier.

It runs entirely on your own computer. Nothing is uploaded anywhere.

Demo

Sloth Desk needs a local Ollama server, so there is no hosted link. Here it is running on two messages.

1. A college placement notice

2. A landlord's message (rent change, renewal deadline, water cut)

Code

Karishma-Das / sloth-desk

Sloth Desk

Paste a message you don't want to deal with (an email, a college notice, a landlord's text, a bill) and get a short checklist of what you need to know and do, with every date, time, amount, file requirement and place.

Runs fully on your own computer with a local open-weight model (Gemma 3 4B via Ollama). Nothing is uploaded anywhere.

How to run

Install Ollama and pull the model
```
ollama pull gemma3:4b
```
Download index.html from this repo.
In the folder with index.html, serve it (do not double-click it, browsers block it from reaching Ollama):
```
python -m http.server 8000
```
Open http://localhost:8000/index.html, paste a message, click Decode it.

If the page says it can't reach Ollama, either use step 3 as written, or set OLLAMA_ORIGINS=* and restart Ollama.

How it works

Calls Ollama's /api/chat with strict JSON output and temperature 0.
A worked example in the…

View on GitHub

It is a single index.html file with no build step, no backend and no API keys.

How I Built It

Model: Gemma 3 4B (open weights), run locally through Ollama.
App: one HTML file that calls Ollama's /api/chat on localhost, asks for strict JSON, and renders the checklist. You can also drag a .txt file onto the box.
Making a small model reliable:
- Temperature 0, so the same message gives the same answer.
- A worked example inside the prompt, so the model copies the format and style.
- Prompt rules that force every date, time, amount, size and place into the same sentence.
- A self-check in code: after the model answers, the page scans the original message for dates, times, amounts, sizes and file formats and checks each one made it into the output. If something was dropped, it retries once, naming exactly what was missed. If it is still missing, the page shows a red "Check the original for: …" line instead of giving you silent half-information.
Honest limits: in my testing, Sloth Desk caught roughly 95% of the details in messages. The rest are occasional misses or odd wording, mostly places, items to bring, and contacts, which the code check can't verify. It sometimes adds a filler line (for example a "Contact" line when the message has none). A larger model would likely do better, and the model dropdown lets you try one. Always check the original for anything that matters.
GitHub Copilot: [add one or two sentences on how you used Copilot while building.]

Why Does Open Innovation Matter?

The messages people avoid are the private ones: bills, school notices, landlord chats, legal letters. With a closed API, every one of them would leave your computer and need an API key and a bill. Because Gemma is open-weight and Ollama runs it locally, Sloth Desk works offline, costs nothing per message, and keeps the text on the machine it came from.

Open weights also let me change the model, rewrite the prompt freely and add my own verification layer. The dropdown picks up whatever models are installed, so anyone can run it with a model that fits their laptop.

The Lazy Payoff

[Only keep this if true. Example: "I used it on a real placement notice and a rental message this week. Reading each took ~50seconds; the checklist took about 30–60 seconds on a 4B model on my laptop and gave me the deadlines up front."]

Prize Categories

Best use of Gemma

FreelanceFlow: The AI Book-keeper

Karishma Das — Sat, 17 Oct 2026 18:11:42 +0000

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

What I Built

FreelanceFlow is an AI bookkeeper for freelancers that runs entirely on their own computer.

Freelancers, creators and tiny agencies handle their own money but have no finance team. Receipts are photos, invoices are PDFs, and everything piles up. Many pay an accountant mainly to organize paperwork. A cloud AI tool could do it, but uploading client invoices and bank data to a server you don't control is exactly what a careful freelancer avoids.

With FreelanceFlow, a freelancer drops in receipt images or PDFs. A local open-weight model reads them. My own validation rules flag anything doubtful. The freelancer fixes the table, downloads a clean CSV for their accountant, and sees a monthly forecast and unusual-spending alerts.

Who would pay: solo freelancers (designers, developers, writers, tutors) who want privacy and a low price. The target is a small monthly fee of about $5 to $10, far less than an accountant's hourly rate.

Demo

Project page: https://karishma-das.github.io/freelanceflow/

The app itself runs on the user's laptop (that is the privacy point), so the demo is a video plus a static project page.

Code

Karishma-Das / freelanceflow

FreelanceFlow

A privacy-first AI bookkeeper for freelancers. A local open-source vision model (Gemma 3 4B via Ollama) reads receipts, my own validation rules flag bad records, and the app exports a clean CSV, shows a forecast and flags unusual spending. Documents are read on your own computer.

What it does

Upload receipt images (PNG/JPG) or PDFs.
Gemma extracts amount, date, store name and category.
Validation rules flag records for human review.
Edit the table, then download a CSV.
Forecast next month's income and expenses.
Alerts for unusual spending.

Results (measured)

Test set: 7 real receipts of mixed quality (kept private, not in this repo).

Field	Correct
Amount	6/7
Date	4/4 (receipts where the answer key has a date)
Store name	3/3 (receipts where the answer key has a store name)

Average time per receipt: 179.5 seconds on a laptop CPU (no API cost)
Flagged for review: 6 of 7
6…

View on GitHub

How I Built It

Open pieces: Gemma 3 (4B, open-weight) running locally through Ollama, with Python, Pydantic, PyMuPDF, pandas, Streamlit and pytest.

Pipeline:

Upload PNG, JPG or PDF. PDF pages are converted to images with PyMuPDF.
Read. Gemma returns structured fields (amount, category, store, date), forced into a Pydantic schema.
Check. Rules I wrote myself flag missing dates and store names, zero or negative amounts, future or very old dates, unknown categories, and tax larger than the total.
Export. The user edits the table in Streamlit and downloads a CSV.
Plan. A forecast tab and an alert for any expense more than 3x its category median.

Measured results on 7 real receipts of mixed quality (clear, wrinkled, faded, blurry, and a photo of a hand holding a pile of receipts). The receipts are private and not in the repo.

Field	Correct
Amount	6/7
Date	4/4 (receipts where the answer key has a date)
Store name	3/3 (receipts where the answer key has a store name)
Flagged for review	6 of 7
Time per receipt	about 180 seconds on a laptop CPU

The most useful lesson. My first version asked the model for the date directly and got 0 out of 4, because the small model kept answering "null". So I split the job: the model reads the text on the receipt, and plain Python code finds and converts the date. Dates went to 4 out of 4. With a small local model, let the model read and let normal code parse and check.

What failed:

One amount was read as -354.83 instead of 54.83. My "amount must be positive" rule flagged it.
An unreadable receipt still got an amount and a made-up store name. Validation flagged it only for a missing date, so it does not catch a confidently wrong store name yet.
Store names were missed on three receipts.
My first answer key was wrong: I had typed a store's slogan as its name. The model was right, so I fixed the key.
It is slow, about 3 minutes per receipt on a CPU. The app can load saved results for demos.

Forecast, honestly. The forecast tab uses a 3-month average as its baseline, with TabPFN wired in as the model to try first. I did not get TabPFN's local license login working in time, so every forecast in my demo used the average fallback, tested on a synthetic 18-month history, not real data. The code reports which method actually ran.

Why Does Open Innovation Matter?

Privacy. Gemma reads each document on the user's machine, so receipts never reach a server. For a bookkeeping tool, that is the main selling point.
Cost. There is no per-document API fee, so a cheap subscription can still work as a side hustle. Cost per document in my tests was zero.
No lock-in. The model name is a single line in the code. If a better open model appears, I swap it, and I am not tied to someone else's pricing.
Works offline. The sensitive step, extraction, needs no internet.

I did not benchmark against a closed API, so I won't claim it is more accurate. My claim is narrower: for this job, privacy and cost matter as much as accuracy, and open models let me keep both.

Prize Categories

Best Use of Gemma: Gemma 3 4B runs locally through Ollama and does all the document reading.

Porchlight: a local AI outdoor coach that fits your body and your day

Karishma Das — Mon, 12 Oct 2026 05:25:38 +0000

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

What I Built

Porchlight is a small outdoor coach that runs on your own computer. You answer a few questions once: how far you can comfortably go from home, whether stairs are a problem, whether heat bothers you, and what you have at home (a window, balcony, doorstep or yard). After that, each time you run it you say how many minutes you have and how your energy is, and it gives you one small mission. For example: stand on the balcony, close your eyes and listen for three sounds.

I built it because the usual "go outside" ideas assume you can hike, jog or get to a trail. Porchlight is for people who can't do that: older adults, people with limited mobility or low vision, people who struggle in the heat, or anyone who just has five minutes and a doorstep.

The mission shows up in the terminal and as a page with large text that you can read or print, so the screen part stays short. Then you put the laptop down and go.

The Porchlight demo site.

Demo

Video: the real app running on my laptop, followed by the demo site.

https://www.youtube.com/watch?v=047kle42H9M

Demo site: https://karishma-das.github.io/porchlight/

The site is only a demo. The real app runs locally with a local model. The "Try the guard" part of the site uses hand-written sample suggestions, not a live AI.

Here is a real run of the app on my laptop (I shortened the file path on the "Large-print card" line):

$ python porchlight.py

=== Porchlight (local model: gemma3:4b) ===
How many minutes do you have? [10]: 15
Is your energy low today? (y/n) [n]: n
Is it hot outside right now? (y/n) [n]: n

Thinking, locally...

Doorstep Reflection  [doorstep, ~15 min]
  1. Stand on your doorstep, feeling the ground beneath your feet.
  2. Close your eyes and listen to the sounds around you – birds, traffic, the wind.
  3. Take a few deep breaths, noticing the rhythm of your own body and the quiet of the moment.

Large-print card: porchlight_card.html

Go outside. Press Enter when you're back...
One line: how did it go?: I had 15 minutes free and felt normal, so Porchlight suggested "Doorstep Reflection." I went outside and stood near my house for 15 minutes. I heard birds singing, leaves moving in the wind, and cars passing by. At first, it felt a little strange to stand quietly, but soon I felt peaceful and enjoyed the sounds around me.
Saved your note.

Code

Karishma-Das / porchlight

Porchlight: touch grass at your own pace

Most "go outside" apps assume you can hike, jog or walk a mile. Porchlight is for everyone else: older adults, people with limited mobility or low vision, people recovering from illness, or anyone with five minutes and a doorstep.

It runs an open-weight model (Gemma via Ollama) entirely on your own computer. No cloud API, no API keys, no accounts, no pip install.

How it works

Answer a few questions once (how far you can go, stairs, heat, vision, what you have at home). They are saved only in a local file.
Each day, say how much time and energy you have.
The local model suggests a tiny outdoor mission (a balcony, a doorstep, a window, or a short walk).
The model suggests, the code decides. Every suggestion is checked against your hard limits (distance, stairs, heat, time, no strenuous words)…

View on GitHub

To run it you need Python 3 and Ollama. No pip installs and no API keys:

ollama pull gemma3:4b
python porchlight.py

The main files are porchlight.py (the app and the guard), card.py (the page), test_guard.py (a test for the guard) and index.html (the demo site).

How I Built It

The model is Gemma (gemma3:4b), running locally through Ollama. The app is plain Python using only the standard library, and it talks to Ollama's local HTTP API.

The idea I built around is that the model suggests and the code decides:

The model is asked to reply with a small JSON object: a title, a place, minutes, distance, whether it needs stairs, sun or shade, and exactly three steps.
A validate function checks that reply against the person's limits: the places they have, their minutes, their distance, stairs, direct sun on a hot day, and a short blocklist of words like run, climb, hike and barefoot.
If a reply breaks a rule, it is rejected and the model is asked again, with the reason included. After three failed tries, the app uses a built-in safe mission instead.
card.py writes the page as one offline HTML file. The default look is purple, and there is a high-contrast, large-text mode for low vision.
The profile and the history are plain JSON files on your computer, and they are kept out of the repo.

How I tested it

In my real runs with my own profile (150 m, no stairs, 15 minutes), Gemma followed the rules every time, so the guard never had to reject anything. To check that the guard works anyway, test_guard.py runs six hand-written suggestions through the same validate function for three made-up test profiles. No model is used. The result was 6 accepted and 12 rejected, and the same suggestion can pass for one profile and fail for another. For example, a doorstep breathing mission is fine for someone who can walk 150 m, but it is rejected for someone who can't leave home. The guard on the demo site is a JavaScript copy of the same rules. The test profiles are not real users.

Taking it outside

I did two missions outside. The first was "Doorstep Reflection" (the run above): I stood near my house for 15 minutes and heard birds, leaves and cars. It felt strange for the first few minutes, then it felt peaceful. The second was "Balcony Breathing": I spent about 15 minutes on my balcony, looked at the view and took slow, deep breaths. I felt relaxed afterwards. That is one person's two outings, not a test of any health benefit.

What went wrong

In my first run, the model told me to stand barefoot on the doorstep. That can be unsafe for some people (hot or rough ground), and the guard let it through because it wasn't a rule yet. I added "barefoot" to the blocklist.
In the balcony run, step 2 told me to close my eyes and focus on the colours I could see, and step 3 just said to repeat for 15 minutes. The guard accepted it, because it checks safety limits and not whether the instructions make sense. I haven't built a second check for that.
The model is slow on my laptop, especially on the first run.
Porchlight doesn't assess anyone's health and isn't medical advice.

Why Does Open Innovation Matter?

What someone can physically manage is personal information. With an open-weight model running through Ollama, that profile and the history stay in two local files on the person's own computer. There is no account, no API key and no server holding it. A closed API would have meant sending someone's limits to a server they don't control.

It also costs nothing to run. Because I ran the model myself and could read its raw reply, I was able to wrap it in a guard and send a rejected answer back with the reason. The model can be swapped with one setting (PL_MODEL), though I only used gemma3:4b. It will work without internet once the model is downloaded.

The trade-off is that a small local model is slower and sometimes gives odd suggestions, which is why the guard exists.

Prize Categories

Best Use of Gemma