DEV Community: Ibnu Syifa Takbir Adha

Ofrenda: a private Gemma remembrance builder that is not allowed to invent memories

Ibnu Syifa Takbir Adha — Tue, 27 Oct 2026 11:51:43 +0000

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

What I Built

I read "Ghost in the Machine" through the Día de los Muertos side of the prompt: the machine is not haunted, it is helping you remember. Ofrenda is a small command-line tool that builds a written remembrance for someone you miss. You give it facts (their name, favorite foods, songs, a story) in a JSON file. A local open-weight model writes a short, warm paragraph from those facts, and the tool prints a Markdown "ofrenda" with the paragraph plus the foods, songs and stories listed underneath, like items on an altar.

The interesting part is what the tool refuses to do. A language model asked to write about a dead grandmother will happily add a hometown, a year or a nickname that it made up, and those would be fabricated memories about a real person. So plain Python checks the paragraph against your facts and rejects any name, place or number that you did not provide, falling back to a simple, faithful sentence instead.

The example in the repo, "Abuela Rosa", is a made-up person for the demo. I did not build this for a real relative, so there is no "the moment it landed" story here and I won't invent one.

Demo

ollama pull gemma3
python3 ofrenda.py profile.json > ofrenda.md

With the model unavailable, which is the only case I could run, the fallback produces this:

# Ofrenda for Abuela Rosa

We remember Abuela Rosa, who loved tamales and hot chocolate and sang along to La Llorona.

## Foods
- tamales
- hot chocolate

## Songs
- La Llorona

## Stories
- she taught me to fold corn husks at the kitchen table

I have not run it against a real Gemma instance, so the quality of the generated paragraph is untested. The tests below use a scripted stand-in for the model.

Code

Stdlib-only Python, one file plus a test.

ofrenda.py:

#!/usr/bin/env python3
"""Ofrenda: a private, offline remembrance builder.

You give it facts about someone you miss (foods, songs, stories). A local open-weight
model (Gemma via Ollama) writes a short remembrance from those facts. Plain Python then
refuses anything the model INVENTED (names, places, years not in your facts) and falls
back to a plain, faithful text. A remembrance must never contain made-up memories.
Stdlib only.
"""
import json, re, sys, urllib.request

OLLAMA, MODEL = "http://localhost:11434/api/generate", "gemma3"

def ask_model(prompt):
    body = json.dumps({"model": MODEL, "prompt": prompt, "stream": False}).encode()
    req = urllib.request.Request(OLLAMA, body, {"Content-Type": "application/json"})
    with urllib.request.urlopen(req, timeout=300) as r:
        return json.loads(r.read())["response"].strip()

def facts_text(p):
    return " ".join([p["name"], p.get("relation", "")] + p.get("foods", []) + p.get("songs", []) + p.get("stories", []))

def words(s):
    return re.findall(r"[A-Za-zÀ-ÿ']+|\d+", s)

def invented(text, profile):
    """Names, places or numbers in `text` that do not appear in the profile facts."""
    known = {w.lower() for w in words(facts_text(profile))}
    out = []
    for sent in re.split(r"(?<=[.!?])\s+", text):
        toks = words(sent)
        for i, w in enumerate(toks):
            if w.isdigit() and w not in known:
                out.append(w)
            elif i > 0 and w[0].isupper() and w.lower() not in known and w != "I":
                out.append(w)               # capitalised mid-sentence = likely a name or place
    return sorted(set(out))

def prompt_for(p):
    return (f"Write a warm 3-sentence remembrance of {p['name']} ({p.get('relation','')}). "
            "Use ONLY these facts. Do not invent names, places, dates or events.\n"
            f"Favorite foods: {', '.join(p.get('foods', []))}\n"
            f"Songs: {', '.join(p.get('songs', []))}\n"
            f"Stories: {' | '.join(p.get('stories', []))}")

def fallback(p):
    bits = []
    if p.get("foods"): bits.append("loved " + " and ".join(p["foods"]))
    if p.get("songs"): bits.append("sang along to " + " and ".join(p["songs"]))
    return f"We remember {p['name']}, who " + (" and ".join(bits) if bits else "is in our hearts") + "."

def remembrance(p, ask=ask_model):
    try:
        text = ask(prompt_for(p))
    except Exception:
        return fallback(p), "model unavailable"
    bad = invented(text, p)
    return (fallback(p), f"rejected invented details: {bad}") if bad else (text, "ok")

def render(p, ask=ask_model):
    text, status = remembrance(p, ask)
    lines = [f"# Ofrenda for {p['name']}", "", text, ""]
    for title, key in (("Foods", "foods"), ("Songs", "songs"), ("Stories", "stories")):
        if p.get(key): lines += [f"## {title}"] + [f"- {x}" for x in p[key]] + [""]
    return "\n".join(lines), status

def main():
    p = json.load(open(sys.argv[1] if len(sys.argv) > 1 else "profile.json"))
    md, status = render(p)
    print(md); print(f"<!-- remembrance status: {status} -->", file=sys.stderr)

if __name__ == "__main__":
    main()

profile.json:

{"name": "Abuela Rosa", "relation": "grandmother",
 "foods": ["tamales", "hot chocolate"], "songs": ["La Llorona"],
 "stories": ["she taught me to fold corn husks at the kitchen table"]}

test_ofrenda.py (passes, using a fake model):

import json
import ofrenda as o
P = json.load(open("profile.json"))

good = "Abuela Rosa filled the kitchen with tamales and hot chocolate. I still hear La Llorona when I fold corn husks at the table."
assert o.invented(good, P) == []

# model invents a place and a year -> flagged
bad = "Abuela Rosa grew up in Guadalajara and made tamales every year since 1987."
assert o.invented(bad, P) == ["1987", "Guadalajara"]

# end to end: good text is kept, invented text is replaced by the faithful fallback
text, status = o.remembrance(P, ask=lambda p: good)
assert text == good and status == "ok"
text, status = o.remembrance(P, ask=lambda p: bad)
assert "Guadalajara" not in text and "1987" not in text and "tamales" in text and "rejected" in status

# model down -> fallback, never a crash
def boom(p): raise RuntimeError("down")
text, status = o.remembrance(P, ask=boom)
assert text.startswith("We remember Abuela Rosa") and status == "model unavailable"

md, _ = o.render(P, ask=lambda p: good)
assert md.startswith("# Ofrenda for Abuela Rosa") and "- La Llorona" in md
print("all tests passed")

How I Built It

Open-weight model: Gemma through Ollama's local HTTP API. The prompt tells it to use only the supplied facts, but I do not rely on it obeying.
Fabrication check: the paragraph is split into sentences. Any number that is not in your facts, and any capitalized word in mid-sentence that is not in your facts (a likely name or place), marks the whole paragraph as invented. It is then replaced by a plain sentence built directly from your facts.
Fail faithful: if the model is down, the tool does not crash; it prints the fallback and the list of facts.
Zero dependencies, and no network call except to your own Ollama on localhost.

Known limits, and they matter: this is a heuristic. It catches invented names, places and numbers, but not an invented event written in plain lowercase words ("she once won a baking contest"), and it can wrongly reject a harmless capitalized word such as a holiday name. A stricter version would ask the model for a list of claims and verify each one. I would not treat this as proof that nothing was made up, only as a guard against the most common kind of invention.

Why Does Open Innovation Matter?

Family stories are some of the most private data there is: names, photos, the way someone laughed. I would not want to paste my grandmother's recipes and stories into a service I do not control, or build something I love on an API that might change its terms or disappear. With an open-weight model running locally, the stories stay on the laptop, the tool works with the lights and the internet off, and the Markdown file it produces is mine to keep forever. Swapping the model is one string, and because the fabrication check lives in plain code, a small local model is good enough.

My Agent Session

Not included.

The Spirit of It

I have no real moment to show, since I have not used this with a real family's stories. The example profile is fictional. What I can point to is the design choice: for a remembrance, a boring true sentence is better than a beautiful false one.

Prize Categories

Best Use of Gemma: Gemma, served locally via Ollama, writes the remembrance at the core of the project.

LazyTidy: a local Gemma folder tidier that can't delete or overwrite anything

Ibnu Syifa Takbir Adha — Tue, 20 Oct 2026 16:16:03 +0000

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

What I Built

LazyTidy is a command-line tool for the clutter you keep promising to sort "later": a Downloads folder full of IMG_001.JPG, scan (3).pdf and notes.txt. Point it at a folder and a local open-weight model suggests a category folder and a clean name for every file. You look at the plan, add --apply, and walk away. It is lazy-friendly by design: one command, no per-file decisions.

The twist is that the model is never trusted with the disk. A model that can rename and move your files can also lose them, so the rules are enforced by plain Python around it: dry run by default, a fixed list of allowed folders, sanitized names, never overwrite, never delete, and an undo command.

Honest note: I have not run this on my own messy folder with a real model, so I have no "I saved N hours" number and won't invent one. What I can say is what the tests prove about safety, below.

Demo

ollama pull gemma3
python3 lazytidy.py ~/Downloads            # dry run: prints the plan only
python3 lazytidy.py ~/Downloads --apply    # moves the files
python3 lazytidy.py ~/Downloads --undo     # puts everything back

The dry run prints one line per file, in the shape scan (3).pdf -> invoices/acme-invoice-42.pdf. In my tests a scripted stand-in plays the model. I have not run it against a real Gemma instance, so how good the suggested names are is untested.

Code

Stdlib-only Python, one file plus tests.

lazytidy.py:

#!/usr/bin/env python3
"""LazyTidy: sort and rename a messy folder while you do nothing. Fully local.

A local open-weight model (Gemma via Ollama) suggests a category folder and a clean
filename for each file. Plain Python makes it safe: dry-run by default, whitelisted
folders, sanitized names, never overwrites, never deletes, and writes an undo log.
Stdlib only.
"""
import json, re, sys, urllib.request
from pathlib import Path

OLLAMA, MODEL = "http://localhost:11434/api/generate", "gemma3"
CATEGORIES = ["documents", "images", "invoices", "notes", "code", "other"]
UNDO_LOG = ".lazytidy-undo.json"

def ask_model(name, snippet):
    prompt = (f"Organize this file. Name: {name}\nStart of content: {snippet!r}\n"
              f'Reply ONLY as JSON: {{"folder": one of {CATEGORIES}, '
              '"new_name": short descriptive filename WITHOUT extension, lowercase words separated by dashes}')
    body = json.dumps({"model": MODEL, "prompt": prompt, "stream": False, "format": "json"}).encode()
    req = urllib.request.Request(OLLAMA, body, {"Content-Type": "application/json"})
    with urllib.request.urlopen(req, timeout=300) as r:
        return json.loads(json.loads(r.read())["response"])

def clean_stem(s, fallback):
    if not isinstance(s, str): return fallback
    s = re.sub(r"[^a-z0-9]+", "-", str(s).lower()).strip("-")[:60]
    return s or fallback

def snippet_of(p, n=300):
    try: return p.read_text(errors="ignore")[:n]
    except Exception: return ""

def plan(folder, ask=ask_model):
    """Return list of (src, dst). Never touches the disk."""
    root, moves, taken = Path(folder), [], set()
    for p in sorted(root.iterdir()):
        if not p.is_file() or p.name.startswith("."): continue
        try: s = ask(p.name, snippet_of(p))
        except Exception: s = {}
        cat = s.get("folder") if s.get("folder") in CATEGORIES else "other"
        stem = clean_stem(s.get("new_name"), clean_stem(p.stem, "file"))
        dst, i = root / cat / (stem + p.suffix.lower()), 1
        while dst.exists() or dst in taken:           # never overwrite
            i += 1; dst = root / cat / f"{stem}-{i}{p.suffix.lower()}"
        taken.add(dst); moves.append((p, dst))
    return moves

def apply(moves, folder):
    done = []
    for src, dst in moves:
        dst.parent.mkdir(exist_ok=True)
        src.rename(dst); done.append([str(src), str(dst)])   # move only, never delete
    (Path(folder) / UNDO_LOG).write_text(json.dumps(done))
    return done

def undo(folder):
    log = Path(folder) / UNDO_LOG
    for src, dst in reversed(json.loads(log.read_text())):
        Path(dst).rename(src)
    log.unlink()

def main():
    a = sys.argv[1:]
    if not a: sys.exit("usage: lazytidy.py FOLDER [--apply | --undo]")
    folder = a[0]
    if "--undo" in a: undo(folder); print("undone"); return
    moves = plan(folder)
    for s, d in moves: print(f"{s.name}  ->  {d.relative_to(folder)}")
    if "--apply" in a: apply(moves, folder); print(f"moved {len(moves)} files. undo: --undo")
    else: print("dry run only. add --apply to move files.")

if __name__ == "__main__":
    main()

test_lazytidy.py (passes, using a fake model):

import tempfile
from pathlib import Path
import lazytidy as t

def make(d):
    (d/"IMG_001.JPG").write_text("jpgdata"); (d/"scan (3).pdf").write_text("Invoice 42 total 10")
    (d/"notes.txt").write_text("buy milk"); (d/"dupe.txt").write_text("another note")
    (d/".hidden").write_text("skip me"); (d/"sub").mkdir()

def fake(name, snip):
    return {"IMG_001.JPG": {"folder":"images","new_name":"Beach Day!!"},
            "scan (3).pdf": {"folder":"invoices","new_name":"acme-invoice-42"},
            "notes.txt": {"folder":"notes","new_name":"shopping"},
            "dupe.txt": {"folder":"notes","new_name":"shopping"}}[name]

with tempfile.TemporaryDirectory() as tmp:
    d = Path(tmp); make(d)
    moves = t.plan(d, ask=fake)
    assert not (d/"images").exists()                       # plan is a dry run
    names = {s.name: str(dst.relative_to(d)) for s, dst in moves}
    assert names["IMG_001.JPG"] == "images/beach-day.jpg"  # sanitized, ext lowercased
    # same target name for two files: both kept, one gets a -2 suffix (dupe.txt sorts first)
    assert {names["notes.txt"], names["dupe.txt"]} == {"notes/shopping.txt", "notes/shopping-2.txt"}
    assert ".hidden" not in names and "sub" not in names
    t.apply(moves, d)
    assert (d/"invoices"/"acme-invoice-42.pdf").read_text() == "Invoice 42 total 10"
    assert not (d/"notes.txt").exists()
    t.undo(d)
    assert (d/"notes.txt").read_text() == "buy milk" and (d/"IMG_001.JPG").exists()
    assert not (d/t.UNDO_LOG).exists()

with tempfile.TemporaryDirectory() as tmp:
    d = Path(tmp); make(d)
    evil = lambda n, s: {"folder": "../../etc", "new_name": "../../../passwd"}
    for s, dst in t.plan(d, ask=evil):
        assert dst.parent == d/"other", dst                 # bad folder -> 'other'
        assert ".." not in dst.name and "/" not in dst.name
    def boom(n, s): raise RuntimeError("model down")
    assert all(dst.parent == d/"other" for s, dst in t.plan(d, ask=boom))  # model failure is safe
    # model down: original names are kept (sanitized), not replaced by junk like "none"
    assert sorted(dst.name for s, dst in t.plan(d, ask=boom)) == ["dupe.txt", "img-001.jpg", "notes.txt", "scan-3.pdf"]
    # pre-existing destination is not overwritten
    (d/"other").mkdir(); (d/"other"/"notes.txt").write_text("KEEP")
    t.apply(t.plan(d, ask=boom), d)
    assert (d/"other"/"notes.txt").read_text() == "KEEP"
print("all tests passed")

How I Built It

Open-weight model: Gemma through Ollama's local HTTP API with format: "json". It sees only the file name and the first 300 characters of text, and it only suggests a folder and a name.
Guardrails in plain Python: folder must be on a whitelist (anything else, including a path-traversal attempt like ../../etc, becomes other); names are reduced to lowercase letters, digits and dashes; collisions get a -2 suffix; hidden files and sub-folders are skipped; moves are renames only, with an undo log written.
Fail safe: if the model is down or returns junk, files fall back to other/ with their original (sanitized) names. While testing the "model down" case I found my first version renamed everything to none.txt, because a missing name was turned into the text "none". I fixed it and added a test for it.
Zero dependencies, so it runs anywhere with Python.

Known limits: it reads text files only (images and PDFs are classified by name, not content), the undo log is overwritten by a second --apply, and undo does not remove the category folders it created. Those are the first things I would fix.

Why Does Open Innovation Matter?

A file tidier is exactly the kind of tool that sees everything: invoices, contracts, private notes. I would not hand the contents of my Downloads folder to a server I don't control just to rename files. With an open-weight model running locally, the first 300 characters of each file never leave the machine, the tool works offline, and it costs nothing per run, which matters for something you would run weekly. The model being swappable also means a small one is good enough here, because the safety comes from the code around it, not from trusting the model.

My Agent Session

Not included.

The Lazy Payoff

I can't claim a measured time saving, since I have not used it on a real folder yet. What I can claim is the part I tested: it will not overwrite a file, will not delete one, and can be undone.

Prize Categories

Best Use of Gemma: Gemma, served locally via Ollama, makes the naming and sorting suggestions at the core of the project.

ReceiptBox: a local Gemma receipt sorter for freelancers that refuses to guess

Ibnu Syifa Takbir Adha — Tue, 13 Oct 2026 14:19:16 +0000

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

What I Built

ReceiptBox is a small command-line tool for freelancers who dread tax season. Drop receipt and invoice text into a folder, run one command, and get an expenses.csv with date, vendor, category and total for each one. Anything it is not sure about goes into a "needs review" list instead of the spreadsheet.

Who would pay for it? Anyone who keeps a shoebox (or phone gallery) of receipts and hands them to an accountant once a year: freelancers, small shop owners, a friend running a side business. The honest pitch is not "AI reads receipts", which is common. It is "your clients' invoices never leave your laptop, and a wrong number never silently reaches your books."

Honest note: I have no first user and no revenue to report. I have not shown this to anyone, so there is no "did they pay" story. Treat it as a working prototype with tested logic, not a validated business.

Demo

ollama pull gemma3
python3 receiptbox.py receipts

Expected output shape:

1 accepted -> expenses.csv | 1 need review
  REVIEW hosting.txt: total not found in receipt text

That output comes from my test, where a scripted stand-in for the model reports a wrong total for one receipt. I have not run this against a real Gemma instance, so extraction accuracy on real receipts is untested, and it only reads plain .txt receipts (no OCR or PDFs yet).

Code

Stdlib-only Python, one file plus tests.

receiptbox.py:

#!/usr/bin/env python3
"""ReceiptBox: a local receipt sorter for freelancers. Nothing leaves your laptop.

A local open-weight model (Gemma via Ollama) reads each receipt's text and proposes
{vendor, date, total, currency, category}. Plain Python then validates every field,
checks the numbers against the receipt text, and sends anything doubtful to a
"needs review" pile instead of guessing. Stdlib only.
"""
import csv, json, re, sys, urllib.request
from datetime import date, datetime
from pathlib import Path

OLLAMA, MODEL = "http://localhost:11434/api/generate", "gemma3"
CATEGORIES = ["software", "travel", "meals", "equipment", "office", "other"]

def ask_model(text):
    prompt = ("Extract from this receipt. Reply ONLY as JSON: "
              '{"vendor": str, "date": "YYYY-MM-DD", "total": number, "currency": str, '
              f'"category": one of {CATEGORIES}}}\n\nRECEIPT:\n{text}')
    body = json.dumps({"model": MODEL, "prompt": prompt, "stream": False, "format": "json"}).encode()
    req = urllib.request.Request(OLLAMA, body, {"Content-Type": "application/json"})
    with urllib.request.urlopen(req, timeout=300) as r:
        return json.loads(json.loads(r.read())["response"])

def numbers_in(text):
    """All money-like numbers in the receipt text, as floats."""
    out = []
    for m in re.findall(r"\d[\d.,]*\d|\d", text):
        s = m
        if re.search(r"[.,]\d{2}$", s):
            s = re.sub(r"[.,](?=\d{3}\b)", "", s[:-3]) + "." + s[-2:]
        else:
            s = re.sub(r"[.,]", "", s)
        try: out.append(float(s))
        except ValueError: pass
    return out

def check(rec, text, today=None):
    """Return a list of problems; empty list means the record is accepted."""
    today = today or date.today()
    problems = []
    if not str(rec.get("vendor", "")).strip():
        problems.append("missing vendor")
    try:
        d = datetime.strptime(str(rec.get("date")), "%Y-%m-%d").date()
        if d > today or d.year < today.year - 2: problems.append("implausible date")
    except ValueError:
        problems.append("bad date")
    try:
        total = float(rec.get("total"))
        if total <= 0: problems.append("non-positive total")
        elif not any(abs(total - n) < 0.005 for n in numbers_in(text)):
            problems.append("total not found in receipt text")  # catches hallucinated amounts
    except (TypeError, ValueError):
        problems.append("bad total")
    if rec.get("category") not in CATEGORIES:
        problems.append("unknown category")
    return problems

def sort_receipts(folder, ask=ask_model, today=None):
    ok, review = [], []
    for p in sorted(Path(folder).glob("*.txt")):
        text = p.read_text()
        try:
            rec = ask(text)
        except Exception as e:
            review.append((p.name, ["model error: %s" % e], {})); continue
        probs = check(rec, text, today)
        (review if probs else ok).append((p.name, probs, rec))
    return ok, review

def main():
    folder = sys.argv[1] if len(sys.argv) > 1 else "receipts"
    ok, review = sort_receipts(folder)
    with open("expenses.csv", "w", newline="") as f:
        w = csv.writer(f); w.writerow(["file", "date", "vendor", "category", "total", "currency"])
        for name, _, r in ok: w.writerow([name, r["date"], r["vendor"], r["category"], r["total"], r.get("currency", "")])
    print(f"{len(ok)} accepted -> expenses.csv | {len(review)} need review")
    for name, probs, _ in review: print(f"  REVIEW {name}: {', '.join(probs)}")

if __name__ == "__main__":
    main()

Example receipts used by the tests, receipts/cafe.txt:

KOPI TUKANG
2026-10-02
2x Latte      90.00
Total        90.00 THB

and receipts/hosting.txt:

Cloudhost Ltd. Invoice
Date: 2026-09-28
Annual plan USD 1,240.50

test_receiptbox.py (passes, using a fake model):

from datetime import date
import receiptbox as r
T = date(2026, 10, 13)
cafe = open("receipts/cafe.txt").read(); host = open("receipts/hosting.txt").read()
good = {"vendor":"Kopi Tukang","date":"2026-10-02","total":90.0,"currency":"THB","category":"meals"}
assert r.check(good, cafe, T) == []
# hallucinated amount is caught by cross-checking the receipt text
assert "total not found in receipt text" in r.check({**good, "total": 900.0}, cafe, T)
# thousands separator and decimals parse: 1,240.50 -> 1240.5
assert 1240.5 in r.numbers_in(host) and 90.0 in r.numbers_in(cafe)
assert r.check({"vendor":"Cloudhost","date":"2026-09-28","total":1240.5,"currency":"USD","category":"software"}, host, T) == []
assert "bad date" in r.check({**good, "date": "last tuesday"}, cafe, T)
assert "implausible date" in r.check({**good, "date": "2027-01-01"}, cafe, T)
assert "unknown category" in r.check({**good, "category": "yachts"}, cafe, T)
# end to end with a fake model: one good, one hallucinated -> routed to review
answers = iter([good, {"vendor":"Cloudhost","date":"2026-09-28","total":12405.0,"currency":"USD","category":"software"}])
ok, review = r.sort_receipts("receipts", ask=lambda t: next(answers), today=T)
assert len(ok) == 1 and len(review) == 1 and review[0][0] == "hosting.txt"
print("all tests passed")

How I Built It

Open-weight model: Gemma through Ollama's local HTTP API, with format: "json" so the output can be parsed. It only proposes fields.
Verify, don't trust: every proposed total must actually appear as a number in the receipt text. A model that misreads "1,240.50" as 12405 gets caught, and the receipt lands in the review pile. Dates must parse and be plausible, and categories must come from a fixed list.
Fail toward a human: if the model is down or returns junk, the file goes to review rather than being skipped or guessed.
Zero dependencies, so it installs anywhere Python runs.

Known limits: the check confirms a number exists in the receipt, not that it is the grand total (a subtotal would pass). Plain text only. Single currency per file. Those are the first things I would fix before charging anyone.

Why Does Open Innovation Matter?

For this particular side hustle, privacy is the product. A freelancer's invoices reveal their clients, rates and cash flow, and many of those clients would not be happy to learn the documents were uploaded to a third-party AI service. Running an open-weight model locally means the tool can honestly say nothing leaves the machine, works offline on a train, and has no per-receipt API bill eating into a business that earns a few dollars per customer. Because the model is a swappable string, a small model is enough, and the validation layer is what makes small models safe to rely on.

My First User

None yet, so I am leaving this honestly empty. If you are a freelancer who would try it on your own receipts, I would genuinely like to hear what breaks.

Prize Categories

Best Use of Gemma: Gemma, served locally via Ollama, does the extraction at the core of the project.

GrassTimer: a local Gemma nudge that finds your free gap and gets you outside before sunset

Ibnu Syifa Takbir Adha — Tue, 06 Oct 2026 17:54:05 +0000

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

What I Built

GrassTimer is a small command-line tool with one job: make the screen the shortest part of your day. You give it your busy blocks for today and your location. It works out the free gaps between your commitments, calculates today's sunset, picks the longest gap that ends before dark, and then asks a local open-weight model to write a short, friendly nudge to go outside.

The split is deliberate. Code owns the facts (free time, sunset, durations). The model only writes the words. If the model invents a time that is not the start of the window or the sunset, the tool throws its text away and prints a plain, correct fallback instead. A nudge that sends you out at 19:15 when the sun set at 18:03 is worse than no nudge.

Honest note: I have not taken this outside and used it for a week, so I won't pretend to report how it went. It is a first version, tested on logic rather than in the field.

Demo

ollama pull gemma3
python3 grasstimer.py day.json

With the example day (busy 09:00-12:00 and 13:00-16:30, Bangkok, 7 Oct 2026), the tool finds three windows: 07:00-09:00, 12:00-13:00 and 16:30-18:03. It picks the longest, 16:30 to sunset at 18:03, and hands that to the model. I verified the planning logic with tests (below). I have not run it against a real Gemma instance, so the quality of the generated wording is untested.

Code

Stdlib-only Python, one file plus a test.

grasstimer.py:

#!/usr/bin/env python3
"""GrassTimer: finds the gaps in your day and nudges you outside before sunset.

Code does the facts (free gaps from an .ics-style list, sunset math).
A local open-weight model (Gemma via Ollama) only writes the nudge.
Stdlib only.
"""
import json, math, sys, urllib.request
from datetime import date, datetime, timedelta, timezone

OLLAMA, MODEL = "http://localhost:11434/api/generate", "gemma3"

def sunset(d, lat, lon, tz_hours):
    """Sunset as local datetime (NOAA-style approximation, ~1-2 min accuracy)."""
    n = d.timetuple().tm_yday
    g = 2 * math.pi / 365 * (n - 1)
    eqtime = 229.18 * (0.000075 + 0.001868*math.cos(g) - 0.032077*math.sin(g)
                       - 0.014615*math.cos(2*g) - 0.040849*math.sin(2*g))
    decl = (0.006918 - 0.399912*math.cos(g) + 0.070257*math.sin(g)
            - 0.006758*math.cos(2*g) + 0.000907*math.sin(2*g)
            - 0.002697*math.cos(3*g) + 0.00148*math.sin(3*g))
    la = math.radians(lat)
    ha = math.degrees(math.acos(math.cos(math.radians(90.833)) / (math.cos(la)*math.cos(decl))
                                - math.tan(la)*math.tan(decl)))
    minutes_utc = 720 - 4*(lon - ha) - eqtime
    base = datetime(d.year, d.month, d.day)
    return base + timedelta(minutes=minutes_utc + tz_hours*60)

def free_gaps(busy, day_start, day_end, min_minutes):
    """busy: list of (start, end) datetimes. Returns gaps >= min_minutes inside [day_start, day_end]."""
    gaps, cursor = [], day_start
    for s, e in sorted(busy):
        if s - cursor >= timedelta(minutes=min_minutes) and s <= day_end:
            gaps.append((cursor, min(s, day_end)))
        cursor = max(cursor, e)
    if day_end - cursor >= timedelta(minutes=min_minutes):
        gaps.append((cursor, day_end))
    return gaps

def pick_gap(gaps, min_minutes):
    return max(gaps, key=lambda g: g[1] - g[0]) if gaps else None

def ask_model(prompt):
    body = json.dumps({"model": MODEL, "prompt": prompt, "stream": False}).encode()
    req = urllib.request.Request(OLLAMA, body, {"Content-Type": "application/json"})
    with urllib.request.urlopen(req, timeout=300) as r:
        return json.loads(r.read())["response"].strip()

def nudge(gap, sunset_dt, ask=ask_model):
    s, e = gap
    mins = int((e - s).total_seconds() // 60)
    prompt = (f"Write a friendly 2-sentence nudge (no emojis) telling someone to go outside "
              f"from {s:%H:%M} for {mins} minutes; sunset is at {sunset_dt:%H:%M}. "
              f"Suggest one simple outdoor activity. Do not mention any other times.")
    text = ask(prompt)
    allowed = {f"{s:%H:%M}", f"{sunset_dt:%H:%M}"}
    import re
    if any(t not in allowed for t in re.findall(r"\b\d{1,2}:\d{2}\b", text)):
        text = f"Go outside at {s:%H:%M} for {mins} minutes. Sunset is at {sunset_dt:%H:%M}."
    return text

def main():
    cfg = json.load(open(sys.argv[1] if len(sys.argv) > 1 else "day.json"))
    d = date.fromisoformat(cfg["date"])
    ss = sunset(d, cfg["lat"], cfg["lon"], cfg["tz"])
    P = lambda t: datetime.fromisoformat(f"{cfg['date']}T{t}")
    busy = [(P(a), P(b)) for a, b in cfg["busy"]]
    gap = pick_gap(free_gaps(busy, P(cfg["wake"]), ss, cfg["min_minutes"]), cfg["min_minutes"])
    print(nudge(gap, ss) if gap else "No outdoor window before sunset today. Try tomorrow.")

if __name__ == "__main__":
    main()

day.json:

{"date":"2026-10-07","lat":13.75,"lon":100.5,"tz":7,"wake":"07:00","min_minutes":20,
 "busy":[["09:00","12:00"],["13:00","16:30"]]}

test_grasstimer.py (passes; uses a fake model):

import json
from datetime import date, datetime as dt
import grasstimer as g
# Reference: astral library gives 18:03:36 for Bangkok on 7 Oct 2026 (+/- 4 min tolerance)
ss = g.sunset(date(2026,10,7), 13.75, 100.5, 7)
assert abs((ss - dt(2026,10,7,18,3,36)).total_seconds()) <= 240, ss
busy = [(dt(2026,10,7,9),dt(2026,10,7,12)), (dt(2026,10,7,13),dt(2026,10,7,16,30))]
gaps = g.free_gaps(busy, dt(2026,10,7,7), ss, 20)
assert gaps[0] == (dt(2026,10,7,7), dt(2026,10,7,9))          # morning
assert gaps[-1][0] == dt(2026,10,7,16,30)                       # evening, ends at sunset
assert all((e-s).total_seconds() >= 1200 for s,e in gaps)       # 12-13 gap is 60 min -> kept
assert g.pick_gap([], 20) is None
gap = (dt(2026,10,7,16,30), ss)
# model hallucinates a time -> falls back to deterministic text
bad = g.nudge(gap, ss, ask=lambda p: "Walk at 19:15 to the park!")
assert "19:15" not in bad and "16:30" in bad
good = g.nudge(gap, ss, ask=lambda p: "Head out at 16:30 and stroll the park before sunset at 18:03.")
assert "stroll" in good or "18:0" in good
print("all tests passed")

How I Built It

Open-weight model: Gemma, served locally by Ollama over its HTTP API. It writes two sentences; that is all it does.
Deterministic core: a NOAA-style sunset approximation and an interval-gap finder, both plain Python. I checked the sunset function against the independent astral library for Bangkok on 7 October 2026 (18:03:36 vs my 18:03:59), and my first draft of the test used a wrong hand-remembered value (17:49), which the check caught.
Guardrail on the model: any clock time in the output that is not the window start or the sunset triggers the fallback sentence.
Zero dependencies, so it works on any laptop.

Known limits: sunset is an approximation (a couple of minutes), the busy list is typed by hand rather than read from a real calendar, and it does not check weather. Those are the obvious next steps.

Why Does Open Innovation Matter?

Your calendar says when you are busy, where you live and how you spend your day. That is not something I want to send to a server I don't control just to be told to go for a walk. A local open-weight model keeps the whole schedule on the laptop, works with no internet (handy right before you head out to somewhere with no signal), and costs nothing per nudge. Because the model is swappable by changing one string, a small model is good enough here, and the surrounding code keeps its mistakes harmless.

My Agent Session

Not included.

Prize Categories

Best Use of Gemma: Gemma, served locally via Ollama, writes the nudge at the core of the project.

SafePlate: a Gemma-powered meal planner that can't be talked into serving my friend shrimp

Ibnu Syifa Takbir Adha — Sat, 03 Oct 2026 06:33:18 +0000

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

What I Built

SafePlate is a tiny command-line meal planner for a friend with food allergies (in my example profile: peanut and shrimp, loves spicy food, rice and tofu, student budget). It asks a locally running open-weight model to plan a week of dinners, and then a plain-Python allergen checker vets every single meal before it reaches the plan.

The problem it solves is a very human one. Anyone who cooks for a friend with allergies knows the anxiety: "is there shrimp paste in that sambal?" Language models are great at creativity and bad at guarantees, so SafePlate splits the job: the model proposes, deterministic code disposes. If the model slips (for example suggests "sambal terasi", which hides shrimp paste), the meal is rejected, fed back to the model as "do not repeat", and retried. If no safe meal is found after three tries, the tool refuses to guess and prints NO SAFE MEAL FOUND - please plan this one by hand.

An honest note up front: I haven't handed this to a real person yet, so I won't invent a reaction. The friend profile in the repo is an example you edit (friend.json), and the tool is meant to be adapted to whoever you cook for.

Demo

There's no hosted demo, since the whole point is that it runs on your own machine. Run it like this:

ollama pull gemma3
python3 safeplate.py friend.json

I tested the planner and safety logic with a scripted stand-in for the model (see the test below), including the "model slips and mentions shrimp paste" case. I did not benchmark Gemma's real output quality, so treat meal quality as untested.

Code

Everything is stdlib-only Python, one file plus a test.

safeplate.py:

#!/usr/bin/env python3
"""SafePlate: a local, offline-friendly meal planner for a friend with food allergies.

The open-weight model (Gemma via Ollama) proposes meals. A plain-Python
allergen checker then vets every ingredient, so safety never depends on the model.
Stdlib only.
"""
import json, sys, urllib.request

OLLAMA = "http://localhost:11434/api/generate"
MODEL = "gemma3"  # any Ollama model works

# Allergen -> words that must never appear in an ingredient list.
ALLERGENS = {
    "peanut": ["peanut", "groundnut", "satay"],
    "tree nut": ["almond", "cashew", "walnut", "pecan", "pistachio", "hazelnut", "marzipan"],
    "shrimp": ["shrimp", "prawn", "terasi", "belacan", "krill"],
    "egg": ["egg", "mayonnaise", "meringue"],
    "milk": ["milk", "butter", "cheese", "cream", "yogurt", "ghee", "whey"],
    "gluten": ["wheat", "flour", "bread", "pasta", "noodle", "soy sauce", "barley"],
}

def banned_words(profile):
    words = []
    for a in profile["allergies"]:
        words += ALLERGENS.get(a, [a])
    return [w.lower() for w in words]

def ask_model(prompt, model=MODEL):
    body = json.dumps({"model": model, "prompt": prompt, "stream": False,
                       "format": "json"}).encode()
    req = urllib.request.Request(OLLAMA, body, {"Content-Type": "application/json"})
    with urllib.request.urlopen(req, timeout=300) as r:
        return json.loads(json.loads(r.read())["response"])

def build_prompt(profile, day, rejected):
    avoid = f"\nThese were rejected, do not repeat: {rejected}" if rejected else ""
    return (
        f"Plan one day of dinner for {profile['name']}. Allergies (STRICT, avoid even traces): "
        f"{', '.join(profile['allergies'])}. Likes: {', '.join(profile['likes'])}. "
        f"Budget: {profile['budget']}. Day: {day}.{avoid}\n"
        'Reply ONLY as JSON: {"meal": str, "ingredients": [str], "steps": [str]}'
    )

def violations(meal, profile):
    text = " ".join(meal.get("ingredients", [])).lower() + " " + meal.get("meal", "").lower()
    return sorted({w for w in banned_words(profile) if w in text})

def plan_week(profile, ask=ask_model, days=("Mon","Tue","Wed","Thu","Fri","Sat","Sun"), retries=3):
    plan, rejected = [], []
    for day in days:
        for _ in range(retries):
            meal = ask(build_prompt(profile, day, rejected))
            bad = violations(meal, profile)
            if not bad:
                plan.append((day, meal)); break
            rejected.append(f"{meal.get('meal')} (contains {bad})")
        else:
            plan.append((day, {"meal": "NO SAFE MEAL FOUND - please plan this one by hand",
                               "ingredients": [], "steps": []}))
    return plan

def main():
    path = sys.argv[1] if len(sys.argv) > 1 else "friend.json"
    profile = json.load(open(path))
    for day, m in plan_week(profile):
        print(f"\n{day}: {m['meal']}\n  buy: {', '.join(m['ingredients'])}")
        for i, s in enumerate(m["steps"], 1): print(f"  {i}. {s}")

if __name__ == "__main__":
    main()

friend.json:

{"name": "my roommate", "allergies": ["peanut", "shrimp"], "likes": ["spicy food", "rice", "tofu"], "budget": "student"}

test_safeplate.py (passes, using a fake model):

import json
import safeplate as s
P = json.loads(open("friend.json").read())
calls = []
def fake(prompt):
    calls.append(prompt)
    if len(calls) == 1:   # model slips up: shrimp paste hides in a sambal
        return {"meal": "Sambal rice", "ingredients": ["rice", "sambal terasi"], "steps": ["cook"]}
    return {"meal": "Tofu stir-fry", "ingredients": ["tofu", "rice", "chili"], "steps": ["fry"]}
plan = s.plan_week(P, ask=fake, days=("Mon",))
assert plan[0][1]["meal"] == "Tofu stir-fry"
assert "Sambal rice" in calls[1]            # rejected meal fed back to model
assert s.violations({"meal":"Pad thai","ingredients":["peanuts"]}, P) == ["peanut"]
always_bad = lambda p: {"meal":"x","ingredients":["prawn"],"steps":[]}
assert "NO SAFE MEAL" in s.plan_week(P, ask=always_bad, days=("Mon",))[0][1]["meal"]
print("all tests passed")

How I Built It

Open-weight model: Gemma (Google's open-weight model) served locally by Ollama. SafePlate talks to Ollama's local HTTP API with format: "json" so the output is machine-checkable.
Propose / verify loop: the model only suggests. A deterministic ingredient blocklist (with regional aliases like terasi and belacan for shrimp paste) decides what is allowed. Rejections are fed back into the next prompt, so the model learns what to avoid within the same run.
Fail closed: after three failed attempts the tool admits defeat instead of serving a risky meal.
Zero dependencies, so it runs on a cheap laptop.

Known limits: a blocklist is not medical advice and can miss hidden or cross-contaminated ingredients. Always read labels and check with the person you cook for.

Why Does Open Innovation Matter?

Health information is about as private as data gets, and an allergy profile is exactly what I would not want to ship to a server I don't control. With an open-weight model running through local inference, the friend's profile never leaves the laptop, it works with no internet, and it costs nothing per meal plan. I can also swap models by changing one string (MODEL = "gemma3"), which matters because smaller local models make more mistakes, and the verifier lets me use them anyway. With a closed API, I would be trusting both the vendor's uptime and its handling of sensitive data.

My Agent Session

Not included.

Prize Categories

Best Use of Gemma: Gemma, served locally via Ollama, is the planner at the core of the project.

Disclosure: I built this with help from an AI assistant (Claude) and reviewed the code and tests myself.