DEV Community: Hexafox

GrassRoots: A Local Gemma Agent That Tells Developers to Touch Grass

Hexafox — Sun, 11 Oct 2026 13:24:28 +0000

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

The problem: our best ideas happen indoors

A developer can spend an entire day inside a code editor, surrounded by notifications, dashboards, and "just one more task." I wanted to build a small intervention that does the opposite of most productivity software: it makes the screen moment shorter and sends the person away from it.

That became GrassRoots, a lightweight Windows desktop assistant that uses a local open-weight model to suggest the next small action—preferably one that happens outside.

What I built

GrassRoots is a Tkinter app with a deliberately simple loop:

Click Run AI Check-In Now.
The app checks the current time.
During outdoor break windows, it asks Gemma for a short, creative outdoor micro-task and plays an alert.
During workspace hours, it asks for a quick ergonomics or hydration reminder.
During quiet hours, it stays dormant.

The important part is that the generated suggestion is short enough to act on immediately. Not a 20-step wellness plan—just something like taking a short walk, looking for three different leaves, or stepping outside for fresh air.

Why Gemma runs locally

The app sends prompts to Gemma 2B through Ollama on localhost. There is no hosted AI API in the loop, no account token, and no routine habit data sent to a server.

That choice matters for this project. A screen-time and wellbeing assistant should not need to upload a person's schedule or daily routine just to generate a sentence. Local inference also keeps the experiment affordable, inspectable, and easy to modify: swap the model, change the prompts, or adjust the time windows in a small Python file.

This is my entry for the Best Use of Gemma category.

How it works

The core request is intentionally ordinary Python:

OLLAMA_URL = "http://localhost:11434/api/generate"
MODEL_NAME = "gemma:2b"

# The app chooses "outdoor" or "indoor" from the current hour.
# Gemma then returns one short, actionable suggestion.

The interface uses only Python's standard library: Tkinter for the window, urllib for the local HTTP request, datetime for the time-aware behavior, and winsound for Windows notifications. If Ollama is unavailable, the app uses a safe fallback reminder instead of failing silently.

The current version is intentionally small and transparent. The check-in is user-triggered, so the user stays in control rather than being trapped in an aggressive notification loop.

Try it yourself

Requirements:

Windows with Python 3
Ollama installed
The Gemma model available locally:

ollama run gemma:2b

Then clone the project and run:

python touch_grass.py

The complete source, README, and screenshots are available in the GrassRoots folder on GitHub.

Why open innovation matters here

A closed API could generate the same sentence, but it would change the trust model. With an open-weight model running locally, the user can inspect the prompts, see exactly where inference happens, run the project without a cloud subscription, and adapt it for a different routine or model.

For a wellbeing tool, that is not just a technical preference. Privacy is part of the user experience. The most helpful AI intervention may be the one that quietly runs on a laptop and then gets out of the way.

What I would build next

The next iteration could add a real background scheduler, configurable local routines, accessibility options, and an optional offline activity log. I would also like to test whether shorter prompts and different break windows lead to more real-world follow-through—not more time spent staring at the app.

For now, GrassRoots has one job: make the next break easier to take.

What is your favorite low-friction way to get away from the screen—and which open model are you experimenting with this Hacktoberfest?

Language Map: Helping a Friend Learn French Through the Languages He Already Knows

Hexafox — Mon, 05 Oct 2026 00:30:50 +0000

Language Map: Helping a Friend Learn French Through the Languages He Already Knows

Priyansh had already spent time learning Spanish with Duolingo and wanted to move toward French. The problem was that a new course path treats him like a complete beginner. It does not show which patterns transfer from languages he has already seen, or where French actually differs.

So I built Language Map for him: a small local-first language-learning prototype that compares languages instead of hiding their relationships.

What it does

Language Map currently has three focused views:

Words: enter a word and compare English, Latin, French, Portuguese, Spanish, and Italian with translations, root clues, prefixes, suffixes, and etymology context.
Phrases: enter a short sentence and see how translations differ in vocabulary and sentence structure.
Across time: rewrite a short formal passage into current internet language as a playful bonus feature.

The interface is intentionally simple. It is meant to help a learner ask, “What do I already know, and what changed here?” rather than restart an entire curriculum.

Why Gemma and local inference mattered

The app uses the open-weight Gemma model through a local Ollama server. Prompts and learner text stay on the user's machine, the model can be replaced, and the prototype does not require a paid hosted language API.

That choice also made experimentation practical. I could shape structured JSON responses for word and phrase comparisons, test the interface quickly, and keep the project usable on a laptop without building a cloud service first.

The model is not treated as an authority. Historical etymology is easy for a language model to get confidently wrong, so the app supplies a small reviewed and paraphrased dataset with source links. Gemma explains that evidence, while the UI presents the result as a clue rather than a proven fact.

What I learned

The most important design decision was narrowing the scope. A full language course would have been too large and too easy to fake as a demo. A focused comparison tool made the friend story concrete and made the prototype testable.

I also learned that “similar-looking” is not the same as “same origin.” The project therefore separates model-generated comparisons from the smaller evidence-backed etymology dataset and documents the limitation clearly.

Try it

The app runs locally with FastAPI, Ollama, and the gemma4:e2b model. A GPU is strongly preferred for a responsive interactive experience; CPU-only runs are supported but can be noticeably slower, especially for phrase comparisons and longer requests. The repository includes smoke tests for the page routes and input validation.

Limitations and next steps

This is a prototype, not a complete language-learning product. It currently depends on a local Ollama model, the curated etymology dataset is intentionally small, and model explanations still need human checking. Next I would expand the evidence-backed dataset, improve sentence alignment, and test the tool with Priyansh directly.

I built this for the Hacktoberfest 2026 Build for a Friend challenge because Priyansh's real learning history shaped the feature choices. The goal was not to replace a course; it was to make the knowledge he already has useful when he starts the next language.

AI assistance was used during development and in preparing this write-up.

First Hacktoberfest

Hexafox — Sat, 03 Oct 2026 12:38:53 +0000

my first time here on the hacktoberfest or any serious online coding event tbh... pretty excited... LET'S GO!!!