DEV Community: Aakif Kohari

SlothSort: a Downloads tidier that runs Gemma on my laptop so I don't have to

Aakif Kohari — Wed, 21 Oct 2026 11:51:49 +0000

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

What I Built

My Downloads folder had 124 loose files: lecture PDFs, receipts, installers and screenshots, all mixed together. I kept saying I'd sort them "later".

SlothSort does it for me. Obvious files (.png, .zip, .mp3) are sorted by instant rules. The ambiguous ones, like a PDF that could be lecture notes or a receipt, go to Gemma running on my own machine. It files them under Study, Work, Personal or Receipts.

It is built to be trusted by someone who is too lazy to double-check:

It is a dry run by default.
It never deletes or overwrites.
Every run writes an undo log.
The model can only choose from a fixed list of folders.

Code

Aakif-Kohari / slothsort

SlothSort: a lazy, local-first Downloads tidier powered by an open-weight model (Gemma via Ollama). Dry-run by default, undo built in, zero dependencies.

SlothSort 🦥

The Downloads-folder tidier for people who would rather not tidy their Downloads folder.

SlothSort sorts the loose files in a folder (default ~/Downloads) into sensible subfolders. Obvious files (.png, .zip, .mp3...) are handled by instant rules. The ambiguous ones, like a PDF that could be lecture notes or a receipt, are decided by an open-weight model running on your own machine (Gemma through Ollama). Nothing leaves your laptop, it works offline, and it costs nothing per run.

Built for the DEV x MLH Hacktoberfest Open-Source AI Challenge: Week 3 ("Slow and Steady").

Why it is safe to be lazy

Dry run by default. slothsort plan shows every move and touches nothing.
Never deletes, never overwrites. Files are only moved. Name clashes become name (2).ext.
One-command undo. Every apply writes a log to .slothsort/; slothsort undo puts everything back.
The…

View on GitHub

How I Built It

Model: Gemma 4 (gemma4:e2b) served by Ollama on localhost.
Structured output: I pass a JSON schema with an enum of allowed folders. I also re-validate the answer in code, so a wrong or made-up folder gets rejected and the file lands in "Other".
Rules first, model second: extension rules handle the obvious files instantly, which keeps it fast and cheap.
Zero dependencies: a ~90-line Ollama client using only Python's standard library.
Tests: 7 pytest tests using fake classifiers and temp folders. They never need Ollama.

Why Does Open Innovation Matter?

My Downloads folder contains my resume, ID scans and bank receipts. I did not want to send those filenames to someone else's server just to sort them.

Privacy: the model runs on my laptop, so file names never leave it.
Offline: it works with no internet.
No cost: there is no API key, quota or per-run cost.
Swappable: changing the model is one flag, --model gemma4:e4b. Because the weights are open, I could also fine-tune it on my own folder structure.

Prize Categories

Best Use of Gemma

KhataPing: a local Gemma model that writes polite khata reminders for kirana shops

Aakif Kohari — Tue, 13 Oct 2026 10:18:19 +0000

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

What I Built

Every kirana store, stationery shop and tuition teacher in India runs on a khata, a handwritten ledger of who owes what. The hard part isn't the bookkeeping. It's asking a neighbour you've served for years to pay up without sounding rude, so the reminder gets postponed and the shop loses money.

KhataPing reads a simple ledger CSV, works out who owes what and how long it has been pending, and writes a respectful WhatsApp reminder in Hindi, Marathi, Hinglish or English. The tone follows the balance: friendly under two weeks, polite up to a month, firm after that. Never threatening. The shopkeeper edits the message and taps "Open in WhatsApp". They always press send themselves.

I've been building tools for kirana owners (my earlier project, BikriTracker, predicts their sales), and the same pain keeps coming up: money that is owed but never chased.

Example output for a customer who has owed Rs 3,000 for 125 days (Hinglish, firm tone, offline template):

Namaste Imran Shaikh ji, Patil Kirana Store se yaad dilana tha ki aapke khate mein ₹3,000 baaki hai. Ye 125 din se pending hai. Please is hafte tak payment kar dein, ya bata dein kab tak ho payega. Thank you!

Code

Aakif-Kohari / khataping

Polite khata (credit ledger) reminders in Hindi, Marathi, Hinglish & English - written by an open-weight Gemma model running locally. Hacktoberfest 2026 Week 2: Side Hustle.

KhataPing

Polite khata reminders for small shops, written by an open-weight model that runs on the shopkeeper's own laptop.

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

The problem

Every kirana, tailor, stationery shop and tuition teacher in India runs a khata - a hand-kept ledger of who owes what. Chasing the money is awkward: nobody wants to sound rude to a neighbour they've served for ten years, and the person who forgets to ask loses real money.

KhataPing reads a simple ledger CSV, works out who owes what and for how long, and writes a respectful WhatsApp reminder in the customer's language - Hindi, Marathi, Hinglish or English - with the tone matched to how overdue the balance is.

Why it can be a small paid tool

A real recurring pain: late khata payments are a cash-flow problem for the shop, every month.
Private…

View on GitHub

How I Built It

Open-weight model: Gemma, run locally through Ollama. The model tag is a setting, so any Gemma size works.
Streamlit for the UI, plain Python for everything else.
The model never does arithmetic. Balances, ageing and sorting live in a tested ledger.py. Payments settle the oldest credit first, so "days pending" means the age of the oldest unpaid credit.
The model's output is checked before anyone sees it. A reply is accepted only if it contains the exact pending amount and nothing threatening (police, court or legal talk, in English, Hindi and Marathi). Otherwise the app uses a built-in template instead.
It works without the model. If Ollama isn't running, four languages and three tones of offline templates keep the tool usable.
41 pytest cases cover FIFO settlement, overpayment, malformed CSVs, Indian digit grouping (12,34,567), and the case where the model changes the amount.

The lesson: when the subject is money, the model's job should be the smallest part of the system, and the system should still work when the model is wrong or missing.

Why Does Open Innovation Matter?

Privacy. A khata is a list of named neighbours and what they owe. A tool that sends that to a third-party API is a poor trade for the shopkeeper. With a local open-weight model, names, phone numbers and balances never leave the shop's laptop.
Cost. Reminders are short, so a small local model is enough, and there is no per-message fee. That makes a small monthly price (my guess, untested) viable for a shop.
Control. I can swap the model with one setting, so the shop isn't tied to one vendor's pricing or availability.

Where it fell short: small local models are uneven in Marathi and Hindi, which is why the human edits before sending and why the plain, safe templates exist.

Prize Categories

Best Use of Gemma

TrailCard: a Gemma-powered trail planner that works with no signal

Aakif Kohari — Wed, 07 Oct 2026 13:18:25 +0000

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

What I Built

TrailCard is an offline trail-day planner. You enter a trail (or upload a GPX file) and it produces one printable A4 card: when to start, the latest time to turn back, when the sun sets, how much water to carry, and plain-language advice on packing, getting lost and Leave No Trace.

The point is that the screen is the shortest part of the experience. You spend two minutes planning, print the card (or save it to your phone), put the phone on airplane mode and go outside. Nothing needs a signal on the trail.

It is for casual hikers, trek groups and anyone who walks somewhere with patchy coverage. The mistakes that actually cause trouble are simple ones: starting too late and not knowing when to turn around. TrailCard turns those into numbers on a page.

Code

Aakif-Kohari / trailcard

Offline trail-day planner: Python computes sunset, turnaround and water; a local open-weight Gemma model (Ollama) writes a printable one-page trail card. Built for Hacktoberfest 2026 Touch Grass.

🥾 TrailCard

Plan the trail day on a screen, then put the screen away.

TrailCard is an offline trail-day planner. You describe a hike (distance, climb, start time, location, or upload a GPX file) and it produces a one-page printable trail card: when to start, when to turn back, when the sun sets, how much water to carry, and plain-language advice written by an open-weight Gemma model running locally through Ollama.

Print the card or save it to your phone, switch to airplane mode, and go outside. The screen is the shortest part of the experience.

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

Why it works with no signal

Part	How it works	Needs internet?
Walking time, turnaround, water	Plain Python (`planner.py`) using Naismith's rule	No
Sunrise and sunset	`astral`, computed from latitude, longitude and date	No
GPX distance and

…

View on GitHub

How I Built It

The core idea is a clear split: numbers come from code, words come from the model.

planner.py is plain Python. It uses Naismith's rule (5 km/h plus 1 minute per 10 m of climb), adds breaks, and uses astral for sunrise and sunset. It works out the latest safe start, the planned finish and a hard turnaround time, which is the last moment you can be at the halfway point and still finish an hour before sunset. It also works out water per person.
The open-weight model is Gemma, run locally through Ollama (the app defaults to gemma3 and lists whatever models you have installed). It receives those numbers as JSON and only writes the advice in six sections: Summary, Timeline, Pack list, Turnaround rule, If you get lost, and Leave No Trace.
Small language models make things up, so the output is checked before it is trusted. If the model mentions a clock time that is not in the plan, the card falls back to a deterministic template. If it skips sections, they are filled from the template. If Ollama is not running, you still get a card. The numbers table at the top of the card is always generated by code.
GPX files are parsed locally with gpxpy. GPS altitude is noisy and inflates the climb, so a small filter ignores wiggles under 3 m.
The UI is Streamlit, and the card is a Jinja2 template with print CSS.

The project has 42 pytest tests, and a GitHub Actions workflow runs them. The Ollama calls are mocked in the tests, so they run without a model installed.

I used AI help while building this: a Qwen draft of the first version, then Claude to review, fix and test it. One real bug it caught was a timezone guess from longitude that put India 30 minutes off, so the form now asks for the UTC offset.

Why Does Open Innovation Matter?

A trail planner has to work in exactly the place where a cloud API doesn't: a ridge or forest with no signal. A closed hosted model would have failed at the one moment the product matters. A local open-weight model works with the laptop offline, and after the one-time model download the card needs no network at all.

It also keeps your location on your own machine. There is no API key, no per-use cost and no account. Swapping models is a dropdown, so someone with an older laptop can use a smaller Gemma and someone with more RAM can use a larger one. Because the model only writes words, I could keep it small and replaceable instead of trusting it with safety-relevant numbers.

Prize Categories

Best Use of Gemma

PlacePal: an offline mock-interview coach I built for a friend, powered by Gemma and Ollama

Aakif Kohari — Sun, 04 Oct 2026 13:48:17 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

What I Built

A batchmate of mine, has campus placement drives coming up and wants practice with real interview questions about their own projects, not another generic list from the internet.

So I built PlacePal, an offline mock-interview partner. You upload your resume (or paste its text), pick a target role and difficulty, and PlacePal:

writes 5 questions tailored to your resume: 2 technical, 2 about your projects, 1 HR
scores each answer from 1 to 10, with strengths, gaps and a stronger sample answer
tracks your average score per topic and tells you which topics to revise

The problem it solves is simple. A resume has your phone number, email, college and projects, and your interview answers show exactly where you are weak. That is the data you least want to paste into a hosted chatbot. PlacePal never sends it anywhere.

Demo

There is no hosted demo, on purpose: the whole point is that PlacePal runs on your own machine. You can try it in a few minutes:

ollama pull gemma3:4b
git clone https://github.com/Aakif-Kohari/placepal.git
cd placepal
pip install -r requirements.txt
streamlit run app.py

Once the model is pulled, you can turn Wi-Fi off and it still works.

Code

Aakif-Kohari / placepal

Offline mock-interview coach for campus placements. Runs on a local open-weight model (Gemma via Ollama): resume-aware questions, honest scoring, weak-topic tracking. No cloud, no API key.

🎯 PlacePal

An offline mock-interview partner for campus placements, powered by an open-weight model running on your own laptop.

PlacePal reads your resume, asks questions tailored to your projects and your target role, scores each answer honestly, and tracks which topics keep dragging your scores down. Everything runs locally through Ollama with a Gemma model. There is no API key, no account, no cloud, and no bill.

Built for the DEV Hacktoberfest Weekend Challenge: Build for a Friend (Oct 2-5, 2026), for a friend preparing for campus placements.

Why local matters here

A resume carries your phone number, email, college and projects. Interview answers carry your weaknesses. That is exactly the data you do not want to paste into a hosted chatbot.

PlacePal (local open-weight model)	Typical hosted chatbot
Resume leaves your machine	No	Yes
Works with Wi-Fi off	Yes	No
Cost per practice session	Zero	Credits / subscription
Swap

…

View on GitHub

How I Built It

The open-source AI: Gemma, Google's open-weight model, served locally by Ollama. The default is gemma3:4b (about a 3.3 GB download). The UI is Streamlit and resumes are parsed locally with pypdf.

The flow: resume text goes into a prompt along with the role's focus areas and the difficulty. Gemma returns JSON, which I validate and show in the UI. Finished sessions are saved to a local JSON file, and a progress tab aggregates scores by topic.

Most of the work was making a small local model behave reliably:

Defensive JSON handling. Small models sometimes wrap JSON in markdown fences, add chatter, or return a score like "7/10". I extract the first valid JSON object, validate and clamp every field, and if the reply is unusable I tell the model what was wrong and retry twice before showing a clear error.
Scoring I can trust a bit more. Prompts alone didn't stop a small model from rewarding a one-line answer, so answers under 5 words are capped at 2/10 and under 15 words at 4/10, deterministically in code.
An honest privacy claim. The app checks OLLAMA_HOST and shows a warning banner if the server is not on the same machine. I also turned off Streamlit's anonymous usage stats so "nothing leaves this laptop" is actually true.
Tests. 34 tests run in CI, including the full Streamlit flow using Streamlit's AppTest. The model call is a single function that tests replace with a fake.

I used an AI assistant to help write the code, and I reviewed and tested it myself.

Why Does Open Innovation Matter?

A hosted API would have worked technically. For this project, it would have been the wrong tool:

Privacy by architecture. With a local open-weight model, the resume and every answer stay on the laptop. I don't have to trust a privacy policy because there is no server to send the data to.
Works offline. Placement prep happens in hostels, trains and places with bad Wi-Fi.
Costs nothing to run. My friend can practice 20 rounds without credits, rate limits or a subscription.
Swappable. The model is one environment variable. PLACEPAL_MODEL=qwen3:4b streamlit run app.py changes the model without touching code.
Inspectable. Every prompt the model sees is in one readable file, placepal/prompts.py.

The trade-off is real. A 4B model is a more generous and less consistent grader than the biggest hosted models, which is why I added code-level guardrails and documented the limitation. People with more RAM can point PLACEPAL_MODEL at a larger Gemma and get stricter feedback, which a closed API wouldn't let them choose.

Prize Categories

Best Use of Gemma