DEV Community: Kehan Hasalawa

sloth-tidy: a local AI that tidies your messy folder (and lets you undo it)

Kehan Hasalawa — Sat, 24 Oct 2026 19:52:00 +0000

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

What I Built

My Downloads folder is a museum of good intentions: IMG_0509.png, final_FINAL_v3.md, a pile of WhatsApp Image 2026-09-23 at 9.12.19 PM.png, and an invoice I keep meaning to deal with. Sorting it by hand is exactly the kind of chore I put off forever.

sloth-tidy is a lazy, local, undoable file tidier. You point it at a folder. A small open-weight model running on my own laptop reads each file's name and the start of its contents, decides what the file is, gives it a clean name, and files it away:

Receipts/    invoice-7qecmbeg-0001.pdf, payment-receipt-0612-9321.pdf
Documents/   daily-notes.docx
Images/      whatsapp-image-2026-09-23.png, ...

The only effort left for me is one click to approve. It has a small browser UI (python3 sloth_tidy.py gui) and a CLI, including a watch mode that tidies a folder in the background every few minutes.

Because a lazy tool must not be a reckless one, it is built to be safe to be lazy with:

Dry run first. It shows the plan, grouped by category, and nothing moves until I say so. I can untick anything I disagree with.
Undo. Every run is logged, and one click puts every file back where it was.
It never overwrites. Name collisions get -1, -2 suffixes.
It is careful with a real Downloads folder. A file that is open in another program is skipped and reported (everything else still moves and stays undoable), and unfinished downloads (.crdownload, .part) and system files like desktop.ini are left alone.

Demo

The video shows the whole flow on a real folder of 13 files: a no-AI dry run, the real run with the model, reviewing the plan, moving the files, and Undo.

Code

Hasalawa / sloth-tidy

A lazy, local, undoable file tidier.

A small open-weight model running in Ollama reads each file's name and a short snippet,
picks a category and a clean file name, and moves it. Nothing leaves your machine.

▶ Watch the 2-minute demo

Built for the DEV Hacktoberfest Open-Source AI Challenge, Week 3: Slow and Steady Started and finished inside the challenge window (Oct 19 to Oct 25, 2026).

✨ Why you might like it

🧠 Reads, not just sorts	A rule engine only sees the extension. The model also sees the file's name and, for text files, its first lines, so an invoice can land in `Receipts/` with a readable name.
🔒 Private by construction	Files are read by a model on your own machine. No API key, no upload, works offline.
👀 Look before it moves	Dry run by default. You get a plan grouped by category and can

…

View on GitHub

One Python file, standard library only, plus tests and GitHub Actions CI. No pip install, no API key, no account.

How I Built It

The open pieces that make it work:

Ollama for local inference, with llama3.2:3b, an open-weight model, as the default. The --model flag (or the dropdown in the UI) swaps in any model you have pulled.
Ollama's structured outputs: the request carries a JSON schema where category is an enum, so the model has to pick from my list and return {category, new_name}. That is what makes a 3B model reliable enough for this job.

The pipeline is deliberately boring:

For each file, send the name, size and the first 600 characters (text-like files only) to Ollama's /api/chat.
Treat the model as an untrusted advisor. The suggested name is slugified (a model answering ../../evil produces a file called evil), unknown categories are thrown away, and the browser UI's server re-validates every move it is asked to make.
If Ollama is down, or the model returns junk for one file, that file falls back to simple extension rules. The tool degrades instead of breaking.
Every real run is written to a log inside the folder, which is what makes Undo possible.

I tested the logic and the local web UI's API against a fake Ollama server (20 tests, including path traversal, name collisions, garbage model output, Ollama being offline, locked files, unfinished downloads, Windows reserved names and tampered requests), so CI needs no GPU and no model. I also drove the UI in a real browser end to end.

I built this with the help of an AI assistant (Claude) for coding, testing and the demo editing, which the challenge allows.

Why Does Open Innovation Matter?

A file tidier is about the most privacy-sensitive thing you can point an AI at. It reads receipts, scans, notes and screenshots. With a closed API, "tidy my Downloads" means uploading my Downloads. With a local open-weight model, the path is: disk, my own RAM, disk. The files never leave the machine, and it works with the network unplugged.

Privacy by construction, not by policy. There is no server I have to trust.
No per-file cost. A cleanup touches many files, and a watch loop touches them again and again. Per-token pricing punishes exactly the lazy, repetitive automation this week's theme asks for. Locally, the cost is electricity.
I control the behaviour. The categories and the prompt are a few lines at the top of one file, and --model swaps the model. A bigger model for a big cleanup, a tiny one for a nightly watch. Nobody can deprecate or change it under me.
Structured output is a feature of the runtime I control, and it is what made a small model dependable enough to ship.

Where open did not win: being honest about the trade-off. The 3B model named my camera photos fairly generically (image-from-snippet.png, image-from-screenshot.png) because it only sees a filename and no pixels, and it took roughly a minute on my laptop's CPU for 13 files. A large hosted model would probably name things better and faster. For this job I accept that: the review step catches the weak names, and nothing private is uploaded.

The Lazy Payoff

On a real folder from my Downloads (13 files: a document, 10 images, an invoice and a receipt):

The no-AI dry run was instant. The model run took about a minute on my laptop CPU, and I did something else while it ran.
The model put the invoice and the receipt in Receipts/ with clean names. The 10 images went to Images/ with names that were readable but not always descriptive.
Total effort from me: paste a path, click Take a look, click Move. Undo restored all 13 files exactly, both times I tried it.

I have not measured how much time this saves over weeks, so I will not pretend to. The point is that the chore now costs me two clicks instead of an afternoon I would never schedule.

ReceiptSorter: receipts in, expense sheet out, with open models on your own laptop

Kehan Hasalawa — Wed, 14 Oct 2026 11:12:43 +0000

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

What I Built

ReceiptSorter turns a pile of receipts and invoices into a clean expense CSV. You drop in text files, PDFs or phone photos of receipts, and open-weight models running on your own computer read each one and pull out the vendor, date, total, currency and an expense category. You fix anything that looks off in an editable table, then download a CSV or a ZIP with the receipts renamed and sorted into category folders. A receipt-style tape on the side adds up the totals by category.

Who would pay for it: freelancers and one-person businesses who dread month-end bookkeeping, and the small accountants and bookkeepers who receive a messy bundle of receipt photos from clients every month. The invoices they handle name their clients and show what they charge, which is exactly the data many of them do not want to upload to a random cloud service. That makes "nothing leaves your laptop" a real selling point rather than a footnote.

The problem it solves: every month-end they lose hours renaming files, retyping totals into a spreadsheet and guessing categories. ReceiptSorter turns that into drag, check, download.

Demo

Run it yourself in under a minute (the sample receipts need no model at all):

git clone https://github.com/Hasalawa/receiptsorter
cd receiptsorter
python3 webapp.py        # opens http://127.0.0.1:8765, then click "Try sample receipts"

For the AI part, install Ollama and pull the models once:

ollama pull qwen2.5:7b-instruct   # text and PDF receipts
ollama pull qwen2.5vl:7b          # photos of receipts

There is also a CLI for folders of receipts:

$ python3 receiptsorter.py samples --out sorted --move-files
- cafe.txt: Cafe Ceylon | 2026-10-08 | 4100.0 LKR | Meals
- hosting.txt: Lanka Cloud Hosting (Pvt) Ltd | 2026-09-03 | 8500.0 LKR | Software
- keyboard.txt: Tech Mart Electronics | 2026-10-01 | 24990.0 LKR | Hardware
- taxi.txt: PickMe Rides | 2026-09-12 | 3250.0 LKR | Travel

Wrote sorted/receipts.csv (4 receipts)

Code

Hasalawa / receiptsorter

Local-first receipt & invoice sorter for freelancers. Drop in text, PDF or phone photos; open-weight models (via Ollama) extract vendor, date, total and category into a CSV, so client data never leaves your laptop.

ReceiptSorter

Sort freelancer receipts and invoices into a clean CSV and category folders, entirely on your own machine A local open-weight model (via Ollama) reads each receipt and extracts vendor, date, total, currency and expense category. No cloud API, no client data leaving your laptop.

Web app (easiest)

python3 webapp.py

Opens http://127.0.0.1:8765 in your browser. Drag receipts in (or click Try sample receipts), fix anything the model got wrong, then download the CSV or a ZIP sorted into category folders. The server only listens on your own computer and works offline.

Photos of receipts

Phone photos are read by a local vision model, so you don't need OCR software. Install one once:

ollama pull qwen2.5vl:7b

Photos can take up to a minute each on a laptop without a GPU. If no vision model is installed, the app falls back to Tesseract OCR when it is available…

View on GitHub

How I Built It

The open pieces are what make it work:

Ollama + qwen2.5:7b-instruct reads text and PDF receipts. I pass a JSON schema through Ollama's structured output (format), so the model has to return exactly the fields I need and a category from a fixed list. That removes the fragile "parse whatever the model said" step. Temperature is 0 so the same receipt gives the same answer.
Ollama + qwen2.5vl:7b, an open vision model, reads photos directly. Most real receipts are phone photos, and a vision model avoids the OCR step entirely. Big photos are rotated correctly and shrunk first (Pillow) so a laptop without a GPU stays usable.
Prompting that matters for receipts: the total is the final amount payable (the "TOTAL BILL" line), never the cash handed over or the change.
Three fallbacks so the tool never dead-ends: vision model, then Tesseract OCR if it is installed, then plain regex rules if Ollama is not running. When something is missing, the error says exactly what to install (for example ollama pull qwen2.5vl:7b), not just "failed".
A small local web UI: a standard-library Python server and one HTML file, with no frameworks and no CDN, so it works offline. It listens on 127.0.0.1 only and rejects requests with a foreign Host or Origin, so a random website cannot talk to it. Every cell in the results table is editable, and the totals and downloads update as you fix things.
Quality checks: 17 unit tests using a fake Ollama server (including the vision path and the "model not installed" message), a UI test in a real browser, and a GitHub Actions workflow that runs them on Python 3.10 and 3.12.

Why Does Open Innovation Matter?

The data stays on the machine. Receipts reveal clients, prices and spending habits. With a closed API I would have to send every image to someone else's server. With local open-weight models I can honestly say nothing leaves the laptop, and it keeps working with no internet.
The economics work for a side hustle. A hosted vision API charges per image, which punishes exactly the customer with a big monthly pile of receipts. Local inference costs nothing per receipt, so a flat price or a one-off setup service can have real margin.
I can swap and tune. The model is one flag (--model, --vision-model). If a bigger model, a smaller one or a model fine-tuned on local receipts (Sri Lankan vendors and LKR amounts, for example) works better, I change a string. I am not tied to someone else's pricing, rate limits or deprecation schedule.
Open pieces made the product, not just the backend. Ollama's structured output, an open vision model and plain Python were enough to build the whole thing, with nothing to sign up for.

What I have not verified yet

I tested the code paths thoroughly with sample receipts and a fake Ollama server, and ran a real receipt photo through the UI using the OCR fallback. I have not yet checked the vision model's accuracy on real receipts, and photos can take up to a minute each on a CPU-only laptop. Next steps are an accuracy check on real receipts, a per-vendor "learn my categories" setting, and batch speed-ups.

Wihanga Nada: an offline bird-call identifier for Sri Lanka

Kehan Hasalawa — Sat, 10 Oct 2026 13:38:01 +0000

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

What I Built

Wihanga Nada ("sounds of birds") is a bird-call identifier for Sri Lanka that works with no signal and no account. You tap Listen once, put the phone away, and look up. It listens in 6-second pieces, says the bird's name out loud, flags Sri Lankan endemics, and keeps a trip log you can export as CSV.

The goal was to make the screen the shortest part of the experience. If the app does its job, you spend the walk watching the canopy, not reading a phone. The best birding places here (Sinharaja, Horton Plains, Yala) are also the places with the worst mobile signal, so "works offline" is not a nice-to-have.

It is for anyone who wants to put names to the sounds around them, from first-time walkers to people who already carry binoculars.

Demo

There is no deployed link, on purpose: the whole point is that it runs on your own machine without the internet. To try it in two minutes, with no TensorFlow and no model download:

pip install -r requirements-dev.txt
python run.py --demo
# open http://127.0.0.1:5000

Demo mode returns canned detections so you can see the interface. It does not listen to the audio. The real identifier is python run.py after installing requirements.txt and tensorflow.

Code

Hasalawa / wihanga-nada

Offline bird-call identifier for Sri Lanka. Runs BirdNET locally, flags endemic species, speaks names aloud so you can look up instead of at a screen. Optional local LLM field notes via Ollama. No internet, no account.

Wihanga Nada (විහඟ නාද)

An offline bird-call identifier for Sri Lanka. Tap Listen, put the phone away, look up. The app says the bird's name out loud, flags Sri Lankan endemics, and keeps a trip log. Everything runs on your own machine, with no internet and no account.

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

How it works

 browser (mic, speech)              your laptop / Raspberry Pi
 ┌──────────────────┐   6 s WAV    ┌──────────────────────────────────────┐
 │ record, resample │ ───────────▶ │ Flask                                │
 │ speak the name   │ ◀─────────── │  ├─ BirdNET 2.4 (TFLite, local)      │
 └──────────────────┘   detections │  ├─ endemics.json (verified facts)   │
                                   │  ├─ Ollama + small LLM (optional)    │
                                   │  └─ SQLite trip log (local file)     │
                                   └──────────────────────────────────────┘

BirdNET 2.4 does the actual identification. The model ships inside the birdnetlib pip package, so after pip install it needs no network. GPS (or central Sri Lanka…

View on GitHub

How I Built It

BirdNET 2.4 (through the birdnetlib package) does the identification. The model files ship inside the pip package, so after install it needs no network. I pass GPS (or central Sri Lanka as a fallback) and the date, and BirdNET narrows its candidates to species that can occur there.
A small local LLM through Ollama (default gemma3:1b, swappable with one environment variable) writes the field notes. Small models make things up, so it never answers from memory: it only gets facts from my own endemics.json and is told to add nothing else. If Ollama isn't running, the app falls back to a static note built from the same facts, so it never depends on the LLM. Birds that aren't in my verified list are never sent to the model at all.
Flask and a plain web page. The page records the microphone, switches off the browser's voice processing (echo cancellation and noise suppression smear bird calls), encodes WAV chunks, and speaks the results with the browser's built-in speech synthesis. A screen wake lock and a dim "pocket mode" keep it listening while you walk.
SQLite for the trip log, with de-duplication so one bird singing for a minute is one sighting, not ten.
I built it with Claude as my coding assistant.

What I checked: BirdNET's own label file (to see which Sri Lankan endemics it can actually name), that the real BirdNET path runs end to end on synthetic audio at both 44.1 and 48 kHz (in well under a second per chunk on my test machine), that the HTTP and HTTPS servers respond, and 14 automated tests.

Limits, stated plainly:

BirdNET 2.4 covers only 15 of the 28 endemics in my seed list. Hill-country specialists such as the Yellow-eared Bulbul, Dull-blue Flycatcher and Sri Lanka Bush Warbler, and the Serendib Scops-Owl, are not in the model, so the app cannot name them yet. A small script (tools/check_coverage.py) reports this gap instead of hiding it.
I have not yet measured identification accuracy on real recordings in the field. My end-to-end run used synthetic silence and noise, which checks the plumbing, not whether it names birds correctly.
Mobile browsers pause the microphone when the screen locks. The wake lock and pocket mode work around it, but a native app would do better.
tflite-runtime has no wheels for Python 3.13 and birdnetlib needs audioop-lts there, so the README documents the install path that worked.

Why Does Open Innovation Matter?

No signal, no problem. A closed audio-ID API needs a connection, and the best birding spots here have none. Open weights run on the laptop in the bag.
Data stays with the person. Recordings and sightings never leave the machine. That matters when a sighting log can reveal where a rare, poachable bird lives.
I can swap pieces. The LLM is one environment variable. The identifier sits behind a tiny interface, so another model can replace BirdNET.
The gaps are fixable. With a closed API, a missing species is a feature request. Here, the 13 endemics BirdNET misses are an open to-do: birdnetlib supports custom classifiers, so a community can train on openly licensed recordings and add them. I haven't done that yet, so I list it as the next step, not a feature.
It costs nothing to run. No API key and no per-call fee.

One honest caveat: the BirdNET model files are CC BY-NC-SA 4.0. They are open weights, but non-commercial. That suits a community hiking tool and not a paid product, and anyone building on this should know it.

Matara Garden: an offline weekly garden checklist, with Gemma on my laptop

Kehan Hasalawa — Thu, 08 Oct 2026 22:45:49 +0000

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

What I Built

Matara Garden is a weekly checklist for home gardeners in Matara, Sri Lanka. You open it once, see what is ready to harvest, what suits sowing this month and what the rain means for your beds, then put the phone down and go do those things. Ticking them off is the only screen time left.

It has three lists:

Harvest: crops in your garden log that will be ready within a week.
Sow and plant: crops that suit this month's rain. Ticking one adds it to your garden with today's date, so the app can tell you when it is ready.
Care: jobs matched to the month's rainfall, like clearing drains, staking climbers or mulching in a dry week. These reset every week.

The header has a small rain gauge, because in Matara the rain decides everything. October is "very wet" in my data, so the app tells you to clear the drains and keep rain-sensitive crops back instead of telling you to water.

At the top there is a short note from Gemma, in English or Sinhala, that sums up the week.

It is for anyone with a few beds, grow bags or a kitchen garden in the southern wet zone who keeps asking "what should I actually do this week?" and doesn't want another app account.

Demo

The app on a laptop, with a few jobs already ticked off (the screenshots use an example garden log):

The same page on a phone, which is where it gets used:

"My garden" is where you log what is growing. Each crop shows how far it is from harvest:

Taking It Outside

An app like this only works if the screen stays short, so I tried it the way it is meant to be used. The video above shows it: I open the checklist on my phone, read what this week needs, go and do those jobs in the garden, and tick each one when it is actually finished.

The phone talks to the laptop over home Wi-Fi (python server.py --host 0.0.0.0), so the phone needs no mobile data and the laptop needs no internet. Ticks are saved the moment I tap, so there is no save button to remember.

Code

Hasalawa / matara-garden

Offline weekly garden checklist for Matara, Sri Lanka. Tick off what to harvest, sow and care for, with a weekly note from local Gemma via Ollama.

Matara Garden

A weekly garden checklist for home gardeners in Matara, Sri Lanka. Open it, see what to harvest, sow and look after this week, and tick things off as you do them outside. The screen is the shortest part of the day.

It runs on your own laptop, offline. A small rule-based crop calendar decides what needs doing (so dates and crops are never made up), and a local open-weight model, Gemma through Ollama, writes the short weekly note at the top.

Run it

Install Python (tick "Add python.exe to PATH") and Ollama.
Download the model once: ollama pull gemma3
In this folder run: python server.py (on Windows you can also double-click start.bat)

Your browser opens at http://localhost:8000. To open it on your phone, run python server.py --host 0.0.0.0 and visit http://<your-laptop-ip>:8000 on the same Wi-Fi.

No packages to install: the app uses only Python's standard…

View on GitHub

To run it:

ollama pull gemma3
python server.py

It uses only Python's standard library, so there is nothing to pip install. On Windows you can double-click start.bat.

How I Built It

The stack is Python's standard library, Ollama, Gemma 3, one HTML page and two JSON files. No pip, no npm, no build step.

The design came out of a mistake. My first version gave Gemma the crop data and asked it to write the whole checklist. It worked offline, but I wouldn't trust the output in a garden. It opened with "Okay, here's your Matara garden checklist", wrapped headings in markdown asterisks, and told me to stake brinjal and chili plants that were not in my garden, because it blended tip lines from the data into its advice. A small model with loose grounding will do that.

So I split the job in two:

Rules decide what to do. crops.json holds sowing months, days to harvest and rain tolerance for each crop, plus a rain level for each month. Plain Python combines it with garden.json to build the three lists. Dates and crops can't be invented, because the model never produces them.
Gemma only writes the note. It gets a short JSON of this week's facts and writes two or three sentences. The prompt forbids new facts, and a cleanup step strips any intro line and markdown. If Ollama isn't running, the checklist still works and the note says why it is off.

The rest is deliberately small. A local server built on http.server exposes a tiny JSON API, and one HTML page talks to it. Ticks are saved into garden.json through the server, so progress survives a restart and isn't locked inside one browser. The server rejects non-JSON posts and unknown Host headers, so another website open in your browser can't poke at your garden.

There are 23 unit tests, and a GitHub Actions workflow runs them on Python 3.9, 3.11 and 3.13. It also builds the checklist for all 12 months and starts the server to check it serves the page. None of it needs Ollama.

I pair-programmed this with Claude. Most of the code was written together, and I ran, read and tested it myself.

Two limits to be upfront about. First, crops.json is starter data written from general knowledge, not an agricultural reference. The app says so in its footer, and the README asks gardeners to check sowing windows with their local Agrarian Service Centre. Second, the Sinhala note is a one-line change to the prompt, but small models are usually less fluent in Sinhala than in English, so treat that note as a draft and have a Sinhala reader check it.

Why Does Open Innovation Matter?

The garden is where the signal is worst. Gemma runs through Ollama on the laptop, so the whole app works with Wi-Fi off. A hosted API would turn it into a page that fails exactly where it is needed.

My garden is nobody else's data. Where I live, what I planted and when stay in a JSON file on my machine. There is no account, no API key and no billing page.

It costs nothing to run. A weekly note for a home garden is not something I want to pay per call for, or manage a key for.

I can change anything. The model is one --model flag. The Sinhala note is a single line in the prompt. crops.json is a plain file, so a gardener in Galle or Kandy can copy the project, change the rainfall levels and the sowing months, and have a planner for their own district. That is hard to do with a service you only reach through someone else's API.

It also showed me the limits. A small local model is not a frontier model, and my first version proved it. Because the whole pipeline was in front of me, I could see exactly where the model went wrong and decide it should only do the part it is good at: friendly wording on top of facts that code has already checked.

Prize Categories

Best Use of Gemma: Gemma 3 runs locally through Ollama and writes the weekly note in English or Sinhala, while rule-based code keeps it grounded.

AI English Practice Buddy – Built for a Friend with Gemma & Ollama (Offline)

Kehan Hasalawa — Sun, 04 Oct 2026 18:20:07 +0000

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

What I Built

I built AI English Buddy for a friend of mine who is currently improving their English. Grammar is the hard part: they often write a sentence that feels right but isn't, and a corrected version alone doesn't help because they still don't know why it was wrong.

I wanted something they could use any time, without paying for a subscription or worrying about someone reading their mistakes. So the app takes any sentence they type and gives back the corrected version, a short explanation in simple words, a more natural way to say it, and one new example using the same rule.

Grammar check: tells them if the sentence is correct and gives the fixed version
Explain my mistake: a short explanation in simple words
Better version: a more natural, fluent way to say the same thing
Example: a fresh sentence using the same grammar rule

You:   I am go to university yesterday.

Buddy: ❌ Your sentence needs correction.
       ✅ I went to university yesterday.
       💡 "Yesterday" talks about the past, so use "went", not "go".

Demo

I shared the app with my friend and asked for honest feedback. Here is what they said:

"Great work! This is a really nice and useful project for learning English. I especially like how it doesn't just correct the sentence, but also explains the mistake and gives a better version and an example. The interface is simple and easy to understand.

I also really like the idea of running it locally with Gemma via Ollama, because it keeps the user's sentences private and doesn't require a subscription."

They also suggested what to add next: vocabulary suggestions, pronunciation practice, and a history of previous corrections.

What's Next

My friend's feedback gave me a clear list to build on:

Correction history: save previous sentences and fixes so they can review their common mistakes
Vocabulary suggestions: suggest richer words for the same idea
Pronunciation practice: let them hear and practice the corrected sentence

Code

Hasalawa / ai-english-practice-buddy

An AI English practice buddy built for a friend learning English. Type a sentence and get a correction, a simple explanation, a more natural version, and an example. Runs privately with Google's open-weight Gemma model via Ollama, using a Flask backend and plain HTML/CSS/JS frontend.

AI English Practice Buddy

An AI-powered English practice tool built for my friend, who is improving their English.

Features

Grammar check – type a sentence, get the corrected version
Explain my mistake – a short, simple explanation of why
Better version – a more natural way to say it, plus an example sentence

AI

Uses the open-weight Gemma model (gemma3:1b) running locally through Ollama. Why open models? Sentences stay on your laptop (privacy), there is no API cost, and you can swap the model with one env var.

Tech stack

HTML · CSS · JavaScript · Python (Flask) · Ollama · Gemma

Run it

# 1. Install Ollama (https://ollama.com) and pull the model
ollama pull gemma3:1b

# 2. Install and start the app
pip install -r requirements.txt
python app.py

Open http://localhost:5000

Optional env vars: OLLAMA_MODEL (default gemma3:1b), OLLAMA_URL.

How it works

Browser -> POST /check

…

View on GitHub

How I Built It

The AI at the core is Gemma (gemma3:1b), Google's open-weight model, running locally through Ollama. Nothing is sent to an external AI API.

Browser -> POST /check -> Flask -> Ollama -> Gemma -> JSON -> Browser

Frontend: a single page in plain HTML, CSS and JavaScript. No framework, no login, no database.
Backend: a small Flask app with one endpoint, POST /check. It validates the input (non-empty, max 500 characters) and calls Ollama's chat API.
Prompting: a system prompt makes Gemma act as a patient English teacher and reply only as JSON with is_correct, corrected, explanation, example and better. Ollama's format: "json" option plus a low temperature (0.2) keeps the output consistent, so the UI can render each part separately.
Error handling: if Ollama isn't running, the app says so instead of crashing (503). If the model returns something unparseable, the user gets a friendly retry message (502).
Tests and CI: pytest tests cover the endpoint, with the Ollama call mocked. A GitHub Actions workflow runs the linter (ruff) and the tests on every push, so CI doesn't need a model at all.

The biggest challenge was that a 1B model is small, and a small model can easily ignore formatting instructions. My UI needs the correction, the explanation, the example and the better version as separate pieces, so a free-form reply wouldn't work. I solved this in three ways: asking Ollama for JSON output, keeping the temperature low (0.2) so the answers stay stable, and writing the backend so that a broken or unparseable reply gives the user a friendly "please try again" message instead of crashing the page. Because the model can't run in CI, my tests mock the Ollama call, so they check that the app handles good and bad replies, but not how good the grammar advice is. For that, the real test is my friend using it.

Why Does Open Innovation Matter?

This is the part that made me choose an open model instead of a hosted API:

Privacy: practice sentences are personal, and sometimes embarrassing. With a local model they never leave my friend's laptop.
Works offline, costs nothing: no API key, no per-request bill, no internet needed once the model is downloaded. That matters for a learner who just wants to practice anywhere.
Swappable: the model is one environment variable (OLLAMA_MODEL). If a bigger Gemma, or a different open model, handles grammar better, it's a one-line change and no code rewrite.
Tunable for one person: because I control the prompt and the model, I can shape the "teacher" around exactly what this friend struggles with, instead of settling for a generic product.

A closed API could probably give better corrections out of the box, but it couldn't have given me all of the above for a tool built for one friend.

Prize Categories

Best Use of Gemma: the whole app is built around Gemma 3 running locally via Ollama.