Go Window: the best time to go outside

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

What I Built

I live in Hyderabad, and in October "should I go for a walk?" has a different answer depending on when you ask.

At 1 PM it feels like 35°C. At 7 AM, the hour every wellness app recommends, PM2.5 is sitting around 45 µg/m³. At 6 PM it's actually pleasant, and that's exactly when I'm in a meeting.

Weather apps answer "what's the weather?" None of them answer the question I actually have: "when, inside the hours I'm free, is it good enough to go outside?"

So I built Go Window.

You tell it when you're really free (say, weekdays 7:00–8:30 and 18:00–20:00). It looks three days ahead at open weather and air-quality forecasts, scores every hour against your limits, and gives you one answer: your next "go window". A local open-weight model (Gemma 3, running through Ollama on your laptop) explains each day in a sentence. A nudge reaches your phone when the window opens. Afterwards, one tap ("too hot", "air felt bad", "felt great") teaches it what those words mean to you.

What it does:

• Plans around your real day. It never suggests 3 PM if you're not free at 3 PM.
• Explains the misses. "07:00–08:30: PM2.5 47 µg/m³ (your limit 35)." If a clearly better slot sits just outside your free hours, it says so, in case you can move something.
• Never a dead end. In a hot, smoggy city, sometimes nothing fits all your limits. Instead of an empty screen, it offers the closest slot, marked best available, with exactly what's over: "PM2.5 30 (your limit 25)". You choose how much give there is (strict, a little over, more flexible).
• Check in by just saying it. Write "skipped it, got stuck in a meeting till 8" or "went to the lake but it got muggy" and Gemma turns it into structured feedback.
• Phone alerts via ntfy: a morning digest, a nudge 10 minutes before the window, and a one-tap "how was it?" afterwards.
• A park that fits the window, from OpenStreetMap, plus Add to calendar so the slot gets defended like a meeting.

The screen time is the point. The plan page is one card and three lines: ten seconds in the morning, one tap afterwards. Everything else happens outside.

Demo

 1. Plan page: the "next go window" card + "Next 3 days"

 2. A day opened: Gemma's note, the reasons other free slots don't work, the hour-by-hour strip

 3. A "best available" day (turn on "Sensitive" in Settings to see one in Hyderabad)

 4. My limits: the learning log 

Code

MasterFloppa / Go-Window

Go Window 🌿

The best time to go outside, inside the hours you are actually free.

Go Window looks at the next 3 days of weather and air quality, keeps only the slots you said you are free, and tells you when to step outside. A local open-weight model (Gemma, through Ollama) explains the plan in plain words. Every time you tell it how a walk felt, it learns your personal heat, humidity, air and rain limits.

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

What it does

• Plans around your real day. You set free hours (e.g. Mon–Fri 07:00–08:30 and 18:00–20:00). It only suggests time inside them.
• Never a dead end. If nothing fits all your limits (common in a hot, smoggy city), it offers the closest free slot within a tolerance you choose (Strict / Balanced / Relaxed), clearly marked with what is…

View on GitHub

With Ollama running and gemma3:4b pulled: npm install && npm start, then open http://127.0.0.1:8787.

How I Built It

flowchart LR
  UI[Browser UI - React] --> API[Local API - Node + Hono]
  API --> OM[Open-Meteo: weather + air quality]
  API --> OSM[OpenStreetMap: parks]
  API --> ENG[Scoring engine: every hour vs YOUR limits, inside free hours]
  ENG --> LLM[Ollama + Gemma 3 4B: narrate days, read check-ins]
  API --> LEARN[Learning: bounded limit changes + plain-English log]
  API --> NTFY[ntfy: scheduled phone alerts]

The model narrates; code decides. The app picks the good hours, the best window, the reason a slot fails and the park. Gemma gets one day's facts as short sentences and writes three lines: a headline, the why, and an idea. Every number it writes must appear in those facts; if one doesn't, it gets one retry, then that day falls back to template text.

Running a 4B model on a laptop CPU taught me four things:

1. Sentences beat JSON for small models. Given nested JSON, Gemma planned a walk for a day that was already over and turned the park's distance (walk_minutes: 3) into "walk for 3 minutes." One call per day, with facts written as sentences, fixed both.
2. Make the model quote you. Reading "muggy, and the smoke had me coughing", Gemma added too cold, which moved a limit by 7°C. Now every feeling needs a word-for-word quote from the note, and one check-in can only move a limit a little.
3. One job at a time. Parallel narrations timed each other out on Ollama, so now they queue and outdated ones are skipped.

Learning is lopsided on purpose: bad check-ins tighten a limit fast, good ones loosen it slowly, and a "best available" walk that felt fine pulls the limit toward what you handled. That mode came from my own first run: with "sensitive to air" on, Hyderabad never dropped below my 25 µg/m³ limit, so the app showed zero windows for three days. Now it offers the least-bad slot and says exactly what's over.

Also worth knowing:

• Alerts are scheduled on the ntfy server, so they still arrive if the laptop sleeps, and they're replaced or cancelled when the forecast changes.
• Open-Meteo counts forecast days from the UTC date, which emptied my third day just after midnight in India.

Stack: Node + Hono, React + Vite, Ollama with gemma3:4b, Open-Meteo, OpenStreetMap, ntfy.

Why Does Open Innovation Matter?

It runs on the laptop I already have. No CUDA here; Ollama runs Gemma 3 4B on the CPU at roughly 15 tokens per second, which works out to about 15 seconds to narrate a day. That would feel slow in a chat, but here it happens in the background while the page shows plain text, and it refreshes every 20 minutes.

My routine is private data. When I'm free, where I walk and how I felt add up to a detailed picture of someone's day. With a local model, none of that leaves the machine. The only things that go out are a location rounded to about 1 km (to Open-Meteo and OpenStreetMap) and the alert text (to an ntfy topic you can self-host).

Zero keys, zero cost. Open-Meteo, OpenStreetMap, ntfy and Ollama need no account and no API key. Anyone can clone it and run it tonight.

Open data stays the source of truth. The model can't make up a forecast, because it never produces one.

Prize Categories

• Best Use of Gemma: Gemma 3 4B (open weights, running locally via Ollama) is the language layer. It narrates each day under a numeric grounding check, and turns free-text check-ins into quote-verified signals that drive the learning loop.
• Best Use of GitHub Copilot: the app was built end to end with GitHub Copilot as a coding agent, from probing the data sources and building the scoring engine to tests, browser end-to-end runs and the UI redesign.