DEV Community: Sachindu Nethmin

SnapCode 🦥: I stopped retyping code from lecture slides. One hotkey, offline, Gemma does the rest

Sachindu Nethmin — Sun, 25 Oct 2026 05:51:10 +0000

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

What I Built

In our machine learning practicals, the lecturer shows code on the slides: imputers, pipelines, encoders, one cell after another. We're supposed to run it in Colab ourselves. Until this week, my routine for every single cell was:

Take a screenshot
Open it in Google Lens
Copy the text
Paste it into Colab
Fix the indentation Lens threw away, the ‘curly quotes’ that break Python, and the [[ that turned into [
Run it, get a SyntaxError, and go back to step 5

That's about a minute per cell, plus an internet connection the lab Wi-Fi doesn't always give you. A sloth would never.

So I built SnapCode. Press a hotkey, drag a box around the code, and press Cmd+V. The clean, correctly indented code is already on your clipboard. Everything runs on my laptop, with no internet and no account, using open-source OCR and an open-weight model.

Demo

Rendered from a real SnapCode run on a slide from my practical. The output and the 12.0 s timing are real; the timer is sped up in the video. MP4 version

Hotkey → drag → Cmd+V. A 🦥 notification tells you when it's ready, for example "24 lines copied via gemma4:E4B in 12.0s".

Before / after: why plain OCR isn't enough

I ran SnapCode on real screenshots from my practical. Here is a slide with three Colab cells (mean, median and mode imputation).

Tesseract on its own (open-source OCR, raw output):

Mean replacement
12]                  .      ;      ;
ne      from sklearn.impute import SimpleImputer
mean_imputer = SimpleImputer(strategy="mean")
X_train[ ‘Preparation Time _min’] = mean_imputer.fit_transform(
X_train[[‘Preparation_Time_min’]]
)
X_test[‘Preparation_Time_min’] = mean_imputer.transform(
X_test[[ ‘Preparation _Time_min*]]
)
Median replacement
3)         a         a                      7

Cell numbers and headings are mixed into the code. The column name is misread two different ways (Preparation Time _min, Preparation _Time_min*). The quotes are curly, and all indentation is gone. Pasting this into Colab gives you errors to fix, not working code.

SnapCode (Tesseract + Gemma):

from sklearn.impute import SimpleImputer
mean_imputer = SimpleImputer(strategy='mean')
X_train['Preparation_Time_min'] = mean_imputer.fit_transform(
    X_train[['Preparation_Time_min']]
)
X_test['Preparation_Time_min'] = mean_imputer.transform(
    X_test[['Preparation_Time_min']]
)
median_imputer = SimpleImputer(strategy='median')
X_train[['Distance_km']] = median_imputer.fit_transform(
    X_train[['Distance_km']]
)
# ...mode imputer cell, also exact

It matches the slide exactly. Here's a second one, a ColumnTransformer pipeline:

Tesseract:

numeric features = X_train.select_dtypes(include=[‘int64', ‘float64']).columns
numeric pipeline = Pipeline([
(‘imputer*, SimpleImputer(strategy="median")),
(‘scaler’, StandardScaler())
])

SnapCode:

numeric_features = X_train.select_dtypes(include=['int64', 'float64']).columns
numeric_pipeline = Pipeline([
    ('imputer', SimpleImputer(strategy='median')),
    ('scaler', StandardScaler())
])

Results on 4 real lecture screenshots

Screenshot	Lines	Exact match?	Time (Apple M5, offline)
3 imputer cells	22	✅	15.6 s
ColumnTransformer pipeline	24	✅	12.0 s
OneHotEncoder cell	11	✅	4.1 s
One-line `print`	1	✅	1.3 s

The lazy payoff

My old Google Lens routine took about 60–90 seconds per cell, counting the fixes. A practical has around 15–20 cells, so that's 15–25 minutes per session spent copying code instead of understanding it. With SnapCode it's a hotkey and a 5–15 second wait, during which I don't have to do anything. That's real sloth energy. 🦥

Code

Sachindu-Nethmin / snapcode

Hotkey → drag over code on screen → Cmd+V. Offline OCR with Tesseract + Gemma via Ollama 🦥

SnapCode 🦥

Press a hotkey, drag a box around code on a lecture slide or video, then press Cmd+V. The clean, correctly indented code is already on your clipboard.

Everything runs locally and works without internet:

Step	Tool	Why
Select region	macOS `screencapture -i`	built in
Rough OCR	Tesseract (Apache-2.0)	fast first draft
Fix + re-indent	Gemma (open weights) via Ollama	reads the image, fixes `[[ ]]`, quotes, underscores, indentation
Verify	Python `ast`	on a syntax error, Gemma gets one retry with the error message
Paste	`pbcopy`	Cmd+V into Colab or your IDE

Setup

brew install tesseract ollama
ollama pull gemma4:E4B

Hotkey (Raycast): Settings → Extensions → Script Commands → Add Directory → choose snapcode/raycast, then give SnapCode a hotkey (for example ⌥⇧C). The first run asks for Screen Recording permission for Raycast.

CLI

python3 snapcode.py                 # select a region
python3 snapcode.py --image a.png   # use an existing

…

View on GitHub

The whole thing is one Python file (standard library only, no pip install) plus a Raycast script command for the hotkey. Try it:

brew install tesseract ollama
ollama pull gemma4:E4B
python3 snapcode.py   # select a region; the code lands on your clipboard

For the hotkey, add the repo's raycast/ folder under Raycast → Script Commands and give SnapCode a shortcut.

How I Built It

hotkey (Raycast) → screencapture -i → Tesseract → Gemma (Ollama) → ast check → pbcopy

Select a region. macOS's built-in screencapture -i gives the drag-a-box picker.
Rough draft with Tesseract (--psm 6, preserve_interword_spaces=1). It's fast, but as you saw above, it doesn't understand code.
Gemma fixes it. I send both the screenshot and Tesseract's draft to Gemma 4 E4B running locally in Ollama. The prompt says the image is the source of truth: output only the code, restore 4-space indentation, fix OCR confusions ([[ ]], quotes, _, 0/O, 1/l), and don't add, rename or "improve" anything. Thinking is off and temperature is 0, because this is transcription, not creativity.
Self-check. The output goes through Python's ast.parse (ignoring notebook lines like !pip and %time). If it doesn't parse, Gemma gets one retry with the exact error message.
Clipboard. pbcopy, plus a macOS notification.

If Ollama isn't running, SnapCode still copies Tesseract's draft, so the hotkey never just fails silently.

Why both Tesseract and a vision model? Gemma can read the image alone, but giving it the draft too works like a second pair of eyes. It anchors long identifiers like Preparation_Time_min and leaves Gemma to do what it's good at: understanding that this is Python and putting the structure back.

Why Open Innovation Matters Here

It works in the lab with no internet. Practical rooms have bad Wi-Fi. SnapCode runs entirely on my laptop. Google Lens needs a connection.
Lecture material stays on my machine. Course slides aren't mine to upload to someone else's server. With a local model, nothing leaves the laptop.
It costs nothing per snap. I'll press this hotkey hundreds of times a semester. With a cloud vision API, that's a bill or a rate limit. With Gemma on Ollama it's free forever after one ollama pull.
I can swap the model. SNAPCODE_MODEL=qwen2.5vl switches models in one line, so I can pick whichever model reads my lecturer's slide theme best instead of accepting whatever a closed API gives me.
Every piece is open: Tesseract (Apache-2.0), Ollama (MIT) and Gemma (open weights). A friend can run the same setup without signing up for anything.

Prize Categories

Best Use of Gemma. Gemma 4 is the step that turns broken OCR into code you can run. Its vision input lets it check every character against the screenshot, and it runs fully offline through Ollama.

StudyInk - my lecture slides, rewritten as a study book by Gemma on my laptop

Sachindu Nethmin — Tue, 13 Oct 2026 06:33:59 +0000

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

What I Built

I'm doing my honours degree, and every week brings another deck of fifty slides. Slides are made for being presented, not for revising from: half the meaning is in what the lecturer said, the diagrams are scattered across the deck, and the night before an exam nobody wants to click through 300 of them.

So I built StudyInk. You drop in a lecture deck (.pptx or .pdf) and it becomes a chapter of a study book: a spiral notebook with an index tab for each subject, pages that turn, and notes written to be scanned, not read.

Who would pay for it? Students like me, around exam time. A cloud AI tool would charge per page or per month, which is exactly when students can't afford one. StudyInk runs on the laptop the student already owns, so it costs nothing per lecture. That makes a one-off price per semester (or a campus licence) viable, where an API bill wouldn't be. Tutors and lecturers are the other customers: a lecturer could hand out a study book for their own course, made from their own slides, without uploading them anywhere.

What happens to a deck

1. It's read on the laptop. A .pptx is printed to PDF by LibreOffice (headless), then PyMuPDF reads every slide's text, speaker notes and a small picture of the slide.

2. The figures are cut out. Slides have no "Figure 3:" captions to anchor on, so StudyInk finds figures by what they're made of: pictures placed on a slide (minus anything repeated on every slide, like the faculty logo and the background), and clusters of vector shapes that look like a diagram rather than a grid of text boxes.

3. Gemma looks at every figure. This is the vision half of Gemma 4. For each crop it decides: diagram, flowchart, table, chart or screenshot (keep it, and caption it), or layout, logo or decoration (set it aside). If a "figure" turns out to be a picture of text (one of my lecturer's slides had its bullet list pasted in as a screenshot, with zero extractable words), Gemma reads the words off it so they still reach the notes.

4. Gemma names the chapter and writes it, a few slides at a time, streaming onto the page while you watch:

Every section is built to be skimmed: the gist highlighted, short points with the details underneath, step flows (numbered boxes joined by arrows) when the slides describe a process, and comparison tables when they contrast things. Then key terms on an index card, one thing to remember on a sticky note, and "check yourself" questions with the answers folded away until you've tried.

A figure taped in, with what to notice	A comparison becomes a table

5. Every point has a footnote. Gemma tags each point with the slide it came from ([s12]), and the book turns that into a numbered footnote. Click one and the actual slide opens, so you can always check the model's work against the source.

Demo

▶ Watch the demo:

Contents: a tab for every subject	On a phone

It also installs as a Mac app: a native window around the notebook, with Node bundled inside, so a student never sees a terminal. It starts Ollama if it isn't running, and when you quit it asks Ollama to unload the model, so the memory comes back.

Code

Sachindu-Nethmin / studyink

Lecture slides in, a study book out. Gemma 4 on your own laptop turns .pptx/.pdf lecture decks into a notebook of visual revision notes, with a footnote back to every slide.

StudyInk

Lecture slides in, a study book out.

Drop in a lecture deck (.pptx or .pdf). StudyInk cuts the figures out of the slides, an open-weight model (Gemma 4, running in Ollama on your own laptop) looks at every figure and writes the lecture up as pages of a study book. Every point has a footnote that points back to the slide it came from.

It looks and behaves like a spiral notebook: an index tab along the top for each subject, chapters that turn like pages, and notes built to be scanned rather than read. Each section has a highlighted gist, short pen-arrow points, numbered step flows, comparison tables, figures taped in with a caption, key terms on an index card, a sticky note to remember, and self-check questions whose answers stay folded until you've tried.

What it does with a deck

Reads the slides on your…

View on GitHub

ollama pull gemma4:e4b
pip3 install pymupdf pillow python-pptx
npm install && npm run dev

Or packaging/build_app.sh builds StudyInk.app and a .dmg.

How I Built It

The model is Gemma 4 E4B, running on my laptop through Ollama, and it does two jobs: it sees and it writes. The same model judges every figure crop (vision) and writes the notes, so there's one download and one thing to keep in memory. Next.js serves the notebook, and its API routes are thin, stateless pass-throughs: one streams the slide reader's progress, one talks to localhost:11434. The study book lives in the browser's IndexedDB, and the uploaded deck is deleted from the temp folder as soon as it's read.

The slide reader is a Python script (PyMuPDF, python-pptx, and LibreOffice for .pptx). Its figure finder is adapted from PaperLamp, an earlier project of mine that turns research papers into explainer videos. Papers have captions to anchor on. Slides don't, which is where most of the work went.

A few things I learned getting a 4B model to do this well:

Card layouts look like tables. My first figure finder counted horizontal lines to spot tables, and decided that a slide of rounded text cards was a table, because a rounded card's top and bottom edges are lines. It now counts only stroked rules and hairline bars, and treats shapes as a diagram only when an open line actually runs from one shape to a different one (a connector), not across a single card (a divider). The rest it leaves to Gemma's eyes.
Let the vision model be the second filter, not the first. The finder errs on the side of finding too much, and Gemma throws out what isn't a figure. Asked "is this a diagram, a table, a layout or decoration?", it reliably kept the flowcharts, tables and an infinity-loop diagram, and set aside the text cards and the "Thank you" slide's social-media links.
The table that ate the token budget. On one big table, Gemma decided to transcribe every cell into a field I hadn't asked it to fill, ran out of tokens mid-JSON, and the figure fell back to a generic caption. The prompt now says to leave that field empty for anything that isn't a picture of text, and the parser salvages whatever fields did finish.
Nobody revises from paragraphs. The first version wrote two or three tidy paragraphs per section, and they read like an essay. Switching to a line format (GIST:, - point, STEP:, TABLE:, KEY:, TIP:, Q:/A:) made the notes scannable, and made the model faster too: points are shorter than prose. It also streams well, because every line is complete on its own.
Be lenient with what a small model writes. It sometimes drops the TABLE: prefix after the header row, writes a table with only a header, or repeats a process as both points and steps. The parser treats any piped line as a table row and a lone header as a row of labels, and the prompt now asks for steps only when there are three or more, without repeating them as points.
Footnotes keep it honest. Because every point carries a slide tag, a wrong claim is one click away from its source. It's also why the notes stick to the slides: the prompt says to use only what's on them, and the footnotes make that checkable.

The notebook is the same plain CSS and SVG as my last project, Footnotes: content flows into page-sized CSS columns, and each page turn copies the sheet into five hinged strips that curl around the spiral. New this time: the step flows (flexbox boxes with SVG pen arrows), the index-card key terms, and the subject tabs along the top edge.

Why Does Open Innovation Matter?

Because the slides aren't mine.

Lecture slides belong to the lecturer and the university. Every cloud "summarise my slides" tool starts by asking you to upload them: someone else's material, sent to a server neither of you controls. With an open-weight model running locally, the question never comes up:

The slides never leave my laptop. LibreOffice, PyMuPDF and Gemma all run on the same machine. There's no account, and nothing to upload.
There's no bill per page. My 59-slide deck took 24 model calls (ten looks at figures, one chapter title, thirteen sections) and about seven minutes on my laptop. On a metered API that's a cost for every lecture, for every student, every semester. Here it's a few minutes of a laptop that was already on. That's what makes a one-off price possible.
It works without the internet. Campus Wi-Fi during exam week is not something to build a product on.
I could fix it when it was wrong. When the finder mistook cards for tables, or a table blew the token budget, I could see exactly what the model was given and change it, or swap in a different model. With no model at all, the book still fills in from the slides' own words, footnotes and all.

A closed API would probably have written slightly better notes on day one. But I'd be asking students to upload their lecturers' slides to a server they don't control, and paying for it per page.

Prize Categories

Best Use of Gemma: Gemma 4 E4B runs locally through Ollama and does both halves of the job. Its vision judges and captions every figure cropped from the slides (and reads pictures of text), and its text side names each chapter and writes every section of the notes.

Footnotes: a bucket-list notebook that only fills up when you go outside

Sachindu Nethmin — Mon, 12 Oct 2026 04:59:55 +0000

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

What I Built

I have a bucket list of places I want to visit, and I wanted it to feel like a real notebook, not another app list. So I built Footnotes: a spiral notebook on a wooden desk, with sticky-note tabs, ruled pages, taped polaroids, and pages that actually turn.

It does four things, and each one is meant to get me out of the chair:

1. It finds beautiful places near me. Waterfalls, viewpoints, peaks, temples and old forts come from open data (Wikidata), ranked by how many Wikipedias bothered to write about them, with the places closest to me always included. Around Ella, that's Ravana Falls, the Nine Arches Bridge, Ella Rock and a lot of waterfalls.

2. It fills in each place's page. When I add a place, Gemma writes its page: why to go, three things to look for when I'm standing there (a checklist I can tick on the spot), the best time, practical tips, and one surprising fact on a sticky note. The Wikipedia text it worked from is clipped onto the page like a newspaper cutting.

3. It tells me where to go next. Gemma reads my list, what I've already visited and the real 4-day forecast, picks one place, circles the best day, and gives me a small challenge that keeps the phone in my pocket. In a rainy week, it picked the sheltered Nine Arches Bridge.

4. It turns each trip into a diary I can show someone someday. When I'm actually there, I press I'm here! and, if my phone's GPS agrees, the page gets a red passport stamp. Afterwards the margin interviews me, one question at a time, and Gemma writes the diary page in my own words, addressed to whoever I'll show it to.

The diary only has pages for places I've actually been. The screen is the part before I leave and after I'm home.

Demo

The margin interviews you	The diary page Gemma writes

The answers in these screenshots are demo text I typed while testing. My real pages stay on my laptop.

Code

Sachindu-Nethmin / footnotes

A paper-notebook bucket list that only fills up when you go outside. Finds beautiful places near you from open data; Gemma (local, open-weight) writes the pages and your travel diary, which never leaves your device.

Footnotes

A paper-notebook bucket list for places you want to visit. It only fills up when you go outside.

Footnotes looks and behaves like a spiral notebook: sticky-note tabs, ruled paper, taped polaroids, a coffee ring. The book fits your screen, laptop or phone, and pages turn instead of scrolling (next page, the dog-eared corner, the arrow keys, or a swipe). It:

Finds beautiful places near you (waterfalls, viewpoints, peaks, temples, old forts) from open data, ranked by how many Wikipedias bothered to write about them.
Fills in each place's page. An open-weight model (Gemma) writes why to go, three things to look for when you're there, the best time, practical tips, and one surprising fact. It's grounded in the Wikipedia extract, which is clipped onto the page.
Suggests where to go next, using your list, what you've already done, and the real 4-day forecast. A fixed rule keeps…

View on GitHub

It runs locally in three commands:

ollama pull gemma4:e4b
npm install
npm run dev

How I Built It

The model is Gemma 4 E4B, running on my laptop through Ollama. Next.js serves the notebook, and its API routes are thin, stateless pass-throughs to localhost:11434. There's also a mode where Gemma 2 2B runs inside the browser tab with WebLLM, so the notebook works with no model server at all. Every prompt has a no-model fallback (notes straight from Wikipedia, a diary page stitched from your own answers), so the notebook never shows a blank page.

Everything else is open data with no API keys: Wikidata (a SPARQL "what's around me" query), Wikipedia and Wikimedia Commons (notes and photos), OpenStreetMap Nominatim (type a town instead of sharing GPS) and Open-Meteo (the forecast). The diary lives in the browser's IndexedDB. There's no account and no database, and download my notebook gives you one JSON file.

Most of the work was teaching a 4B model to behave, and a few of those lessons surprised me:

The storm trek. In a week of thunderstorms, Gemma suggested a mountain trek "for a dramatic contrast". So safety isn't the model's call any more: if every day in the forecast is stormy, exposed places (peaks, falls, beaches, trails) are removed from the list before Gemma sees it. It still chooses and explains; it just can't send me up a mountain into lightning.
The rainbow. The first interviewer asked my test user about "the colours in the rainbow". They'd never mentioned a rainbow. Now the interview follows a fixed plan in code (arriving, the people, the best moment, the senses, food, how it felt, advice, last words). Code decides when to move on and when a short answer deserves a follow-up. Gemma only words the question, building on what was just said. You can also skip a topic or ask for a different question.
Small models read the last line. Even with the plan, Gemma kept asking "Describe…" questions about the mist. The topic instruction was buried in a long system prompt. Moving it to the end of the last message fixed it immediately.
Your diary, not the model's. An unanswered "what was the air like?" turned into "the air was damp and warm" on the diary page. The writing prompt now labels the transcript ME: and MARGIN:, and a question you didn't answer is not a fact.
Fame isn't distance. Ranking by Wikipedia fame alone let a famous national park 30 km away push Ella Rock, 1.7 km from town, off the list. A second, small-radius query now runs in parallel.

The notebook is plain CSS and SVG. Ruled lines are a repeating-linear-gradient, the spiral is one SVG coil repeated down the spine, and tape is a clip-path with ragged edges. Pages don't scroll: content flows into page-sized CSS columns, and you turn them with next page, the dog-eared corner, the arrow keys or a swipe. Each turn copies the page into five hinged strips that swing around the spiral, the outer ones lifting first, so the sheet curls instead of flipping like a board. The back of each sheet shows the ink faintly bleeding through, mirrored. (One gotcha: CSS orphans: 2 kept pushing a whole row of polaroids onto the next page.)

Why Does Open Innovation Matter?

Because a diary is the most personal thing I've ever asked a model to touch.

A travel diary holds who I was with, what I felt, and photos of the people I love. I want to show mine to someone years from now, not send it to a server today. With an open-weight model, that's simply the default:

The words never leave my machine. The interview and the diary page are written by Gemma on my laptop. With WebLLM, they never even leave the browser tab.
My location is blurred before anyone sees it. It's rounded to about 1 km before it reaches Wikidata, OpenStreetMap or the weather service. The photos come through the notebook's own server, so Wikimedia never sees my browser at all.
It costs nothing per page. A diary is something you keep writing in for years. A metered API would turn every memory into a line on a bill.
I can see and change how it behaves. When the model got something wrong (the rainbow, the storm trek), I could look at exactly what it was given and fix it, or swap in a smaller model for an older laptop. With no model at all, the notebook still works.

A closed API would have written prettier sentences on day one. But I'd be asking people to type their memories into a box that belongs to someone else, and that's not what a diary is.

Prize Categories

Best Use of Gemma: Gemma 4 E4B runs locally through Ollama and writes every place page, the next-place pick, the interview and the diary page. Gemma 2 2B runs in the browser through WebLLM for a no-server mode.

RoomPot: our room's cooking money, split by an open model

Sachindu Nethmin — Sun, 04 Oct 2026 08:19:27 +0000

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

Built by me together with my roommates and teammates @bimsara_wickramanayaka_10, @chathuraz and @ashan_lima.

What I Built

Four of us share a room: Chathura, Bimsara, Ashan and me. We cook together, so one of us is always running to the shop for rice, eggs, onions or a new gas cylinder.

Most of the time that person is Chathura. Chathura buys whatever the room needs and pays up front. At the end of the month we're supposed to add up everything, divide the total by four, and pay back whoever spent more. We tried keeping it in an Excel sheet, but in practice receipts get lost, someone forgets to add a purchase, and the collecting just... doesn't happen. Chathura ends up quietly covering money nobody remembers to give back, and asking for it feels awkward.

So I built RoomPot for Chathura and for the rest of us. It's a small group chat for the room. Whoever buys something just says it, the way you'd text a friend:

chicken 1.2k, onions 300, tomatoes 250

RoomPot reads the message with an open-weight AI model (Google's Gemma). It knows who is logged in, so it records that person as the payer. It splits the cost between the four of us and keeps a running tally of who owes whom. Nobody has to remember anything or do maths at the end of the month.

What it does:

Log costs by chatting. "rice 1200, eggs 450" works, and so do "Chathura bought bread 200" (credits Chathura) and "shampoo for me and Ashan 800" (splits between just those two).
Receipt photos. Snap the shop bill and every item is logged. Totals, cash and change lines are ignored.
Average daily spend. The number we actually wanted to know: what the room spends per day and per person, plus today's spend, this month, the last 7 days, and a 30-day chart.

Settle up. It works out the fewest payments that clear everyone's debts, with a Mark paid button. You can also just type "gave Chathura 1500".
Ask it anything about our money. "What's our average daily spend and who still owes me?" is answered from our own data.

Demo

Live app: https://roompot.onrender.com

rice 1200, eggs 450, gas 3800
shampoo for me and <a roommate's name> 800
what's our average daily spend?

You can also invite a second account with the room's invite code to see the splitting and settle-up. (It's on Render's free plan, so if it has been idle, the first load takes about a minute to wake up.)

Code

Sachindu-Nethmin / roompot

Shared room budget for roommates who cook together. Chat what you bought; Gemma (open-weight, via Ollama) splits it and tracks who owes whom.

🍳 RoomPot

A shared room budget for roommates who cook together. Tell the group chat what you bought, like "rice 1200, eggs 450, gas 3800", or send a photo of the bill. An open-weight model (Gemma) reads it. It runs on a server by default so it works in any browser, and anyone can switch on private mode to run it inside their own browser instead. It logs the cost under whoever is logged in, splits it between the room, and keeps a running tally of who owes whom. No more "machan, did I give you money for the gas last week?"

Why it exists

Four of us share a room and cook together. Whoever goes to the shop pays, and at the end of the month we add it all up and divide by four. Except someone always forgets to write a purchase down, and someone else forgets…

View on GitHub

How I Built It

Stack: Next.js (App Router), MongoDB Atlas with Mongoose, and Tailwind CSS, deployed on Render.

Gemma is the core. Every chat message goes to Gemma along with the room's member names and a short set of rules. Gemma returns structured JSON:

{
  "intent": "expense",
  "items": [{ "name": "chicken", "amount": 1200 }, { "name": "onions", "amount": 300 }],
  "paidBy": null,
  "splitWith": [],
  "settleTo": null,
  "settleAmount": null,
  "reply": null
}

The intent can be an expense, a payment back to someone, a question, or just chat. From that, the app records the purchase, records the payment, or answers the question using the room's real numbers.

The model is never trusted blindly. Every response is checked with a zod schema. Amounts must be positive and sensible, and names must match real room members. A bad or missing answer falls back to a simple rule-based parser, so the room never stops working. The money maths (balances, the fewest settle-up payments, daily averages in our timezone) is plain, exact code. The AI only does what it's good at: turning messy human text and photos into clean data.

The same open model runs in three places, and switching between them is one setting:

Where	Model	Used for
Render + Google AI Studio	Gemma 4 (`gemma-4-26b-a4b-it`)	The live app. Works in any browser and reads receipt photos.
My laptop, through Ollama	Gemma 4 E4B	Building and testing, fully offline
Inside the phone's browser	Gemma 2 2B through WebLLM (WebGPU)	Optional private mode: after a one-time download, messages and photos never leave the phone. Receipts are read on-device with Tesseract.js.

Before shipping I ran a set of test messages through Gemma: purchases, "someone else paid", partial splits, paying someone back, questions, and a purchase with no price. All 13 were handled correctly, and a printed receipt was read line by line with the total, cash and change ignored.

Why Does Open Innovation Matter?

Our money is personal. Who bought what and who owes whom is our business. Because Gemma's weights are open, the same model family can run inside a phone's browser, so private mode keeps every message on the device. With a closed API, the only option would be sending everything to someone else's server.
It costs nothing to run. Four roommates splitting cooking costs are not going to pay for an AI subscription. Ollama on a laptop is free, the in-browser model is free, and Gemma on Google AI Studio's free tier is free.
It works offline. On my laptop with Ollama, RoomPot keeps working with no internet at all. That's how I built and tested most of it.
No lock-in. The model is one environment variable. Moving from Gemma 3 to Gemma 4 was a one-line change, and the same code also works with any OpenAI-compatible open-model server.

To be honest about the trade-off: in the hosted version, messages are sent to Google AI Studio to be read by Gemma. Private mode exists for anyone in the room who doesn't want that.

What My Roommates Said

I sent the link to the room. Bimsara tried it first and messaged me:

"Machan, just tested it. It works perfectly, way better than our messy Excel sheet."

(Machan is Sri Lankan slang for "buddy".)

Prize Categories

Best Use of Gemma: Gemma 4 powers the live app and my offline setup, and Gemma 2 2B runs in the browser for private mode.
Best Use of Render: the app is deployed as a Render web service, built straight from the GitHub repo.
Best Use of MongoDB Atlas: Atlas is the data layer for users, rooms, purchases, payments and the chat history behind the open-weight model.

I built RoomPot with help from an AI coding assistant. The idea, the problem, the decisions, and testing it with my roommates are ours.

My Academic Journey at Sabaragamuwa University of Sri Lanka

Sachindu Nethmin — Wed, 28 May 2025 15:36:20 +0000

What I Experienced in My Studies at Sabaragamuwa University

My heart was full of joy, curiosity and some fear when I opened the gate at Sabaragamuwa University of Sri Lanka. I understood from my study in the BSc (Hons) in Computing and Information Systems that I was getting ready for a time in life that would influence both my learning and career goals.

The use of Technology as a Firm Support

The first year built the essential basis for what was to come. Since the beginning, the CIS program showed me the fundamentals of programming, computer systems and problem fixing. When I wrote and tested my first program as a student, I still remember the thrill of seeing it work successfully in the lab. With experience, I have learned about software engineering, database systems and computer networks necessary components needed to be a professional in IT.

What stands out to me most in the program is how it blends learning about science with actual hands-on activities. Every time I go to a lecture, I can become involved in lab sessions that teach me with real-life activities. Through my partnership in these sessions, I have gained better critical thinking and technical abilities.

A Culture of Collaboration and Innovation

At Sabaragamuwa University, education extends well outside the classroom. I have had the opportunity to be part of group projects, coding competition, and student initiated projects. This has provided me with lessons on teamwork, time management, critical thinking and finding creative ways to solve difficult problems.

Open-source contribution and community participation are strongly emphasized here, and I have already participated in several exciting opportunities that make the classroom learning as well as the goals out there very tangible. From contributing to a GitHub project, to brainstorming during hackathons, I’ve found limitless ways to stay motivated and involved.

Mentorship That Matters

The best part of my academic experience has been the mentorship from our lecturers and mentors. They are not just professionals in their jobs but truly invested in our success. Their advice has inspired me to venture beyond the syllabus, reach out in independent study, and even look ahead towards research experiences.

Their never ending support just helping me to be on the right track. I’m interested in machine learning, cybersecurity, and software development, among those areas, I want also to find some internships and side-projects in order to level up my skill-sets.

Looking Ahead

I am in my second year and feeling more confident and determined than ever. The path has not been easy, but each obstacle has served as a steppingstone in becoming more hardened and clear-minded. I think if I continue trying and remain curious and passionate I may do great thinks in technology.

It is not just a place of lectures to me, it is a place where I found myself and who I want to be. Blockquote Sabaragamuwa University of Sri Lanka.

Thanks for reading! If you are a student, a comp-sci enthusiast or just want to say hi, you can reach out and share your academic experience with me too. Let’s motivate and develop each other.