This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass
What I Built
Last Light is an open-source AI walk ticket that tells you to put your phone away.
Most outdoor apps give you more things to look at. Last Light does the opposite. You choose a city (or use your own location), pick a walk length, describe the sky and ground, and it issues a short dusk-walk ticket:
- ⏰ A leave-by time and sunset direction ("Leave by 17:42. Walk west.")
- 🧭 A destination-free route suggestion and estimated distance
- 📈 A walk-quality score
- 👀 Four sensory prompts: look, listen, touch, notice
- 📵 One rule: "Phone in a pocket that is not your hand."
- ⏳ A Pocket Mode countdown, a printable ticket, optional voice narration, and a private field note stored only in your browser
It's for anyone who wants a simple reason to step outside at the end of the day. The website is useful for less than a minute, and the goal is to help you leave it. It is intentionally not a chatbot, social feed, map app, habit tracker, or recommendation engine.
Demo
🌅 Live app: https://touch-grass-beryl.vercel.app/
- Choose a city or use your door.
- Select a walk duration.
- Describe the sky and ground.
- Issue a ticket.
- Read it, print it, or start Pocket Mode.
- Put the phone away.
Code
Last Light
The screen is the shortest part.
A local-first dusk walk ticket that gets you outside, then gets out of the way
Last Light turns sunset geometry, local climate signals, and open-weight AI into a small printed-style brief: when to leave, which way to walk, four sensory prompts, and one rule — put the phone away.
Why it exists
Most outdoor apps increase screen time. Last Light is deliberately the opposite:
- Prepare on screen. Calculate the useful facts before leaving.
- Carry a ticket. Print it, read it aloud, or remember the four cues.
- Pocket the phone. Pocket Mode becomes a simple countdown.
- Notice the ordinary. There is no feed, streak, destination, or species database.
The best interface is the one you stop looking at.
What the experience feels like
- Choose a city or use your door.
- Set the walk length, date, temperature, ground, and sky.
- Receive a dusk ticket…
How I built it
1. Solar calculations without a weather API
Last Light calculates:
- Sunrise
- Sunset
- Golden hour
- Civil dusk
- Solar noon
- Sunset azimuth
- Day length
The calculation uses latitude, longitude, date, and time-zone offset.
That allows the app to create a practical instruction such as:
Leave by 17:42. Walk west.
The basic walk ticket does not require map tiles or a weather service.
2. A generated dusk-walk dataset
The scoring engine uses 1,400 generated dusk-walk rows.
The features include:
- Temperature
- Rain
- Wind
- Cloud cover
- Humidity
- Latitude
- Day of year
- Minutes until sunset
- Foliage season
- Urban surroundings
- Walk duration
The dataset is generated from a transparent recipe, which makes the model evaluation repeatable instead of presenting an unexplained number.
3. TabPFN with a Ridge baseline
TabPFN predicts the walk-quality score.
A Ridge regression model is trained alongside it as a baseline. The application reports held-out evaluation metrics so the score can be compared with a simpler model.
The full TabPFN backend is available for local and Render deployments.
Vercel uses the lightweight Ridge fallback because TabPFN's PyTorch dependencies exceed Vercel's serverless function size limit.
If TabPFN is unavailable, the app still issues a ticket instead of breaking.
4. Gemma and offline field recipes
When a compatible Gemma endpoint is available, Gemma writes the natural-language ticket.
The model receives structured facts and returns:
- A short title
- A one-sentence lead
- Four sensory cues
- A route
- A phone-away rule
The response is validated before it reaches the user.
When no model endpoint is available, deterministic offline field recipes generate the ticket.
This is an intentional product mode, not a broken fallback.
The application can therefore work:
- With local Ollama
- With a compatible hosted endpoint
- Without an AI endpoint
- Without a weather API
- Without storing field notes on a server
Why open innovation matters
Open innovation matters because this project is about reducing dependence on the screen.
A closed hosted AI service could generate attractive copy, but it would create several limitations:
- Location and conditions would need to leave the user's machine.
- The experience would depend on a network connection.
- The model could not be easily swapped or run locally.
- The fallback behavior would be harder to control.
- The project would be less inspectable.
With open-source and open-weight components, the important parts remain replaceable and understandable.
Someone can:
- Run Gemma locally with Ollama.
- Replace the language model.
- Inspect the prompt and validation rules.
- Run the scoring model on their own machine.
- Use the deterministic field recipes with no model at all.
- Change the behavior without waiting for a platform feature.
The open approach made it possible to design the experience around privacy, inspectability, and graceful degradation.
The most important design decision
The most important decision was to make the screen temporary.
Last Light does not try to maximize:
- Sessions
- Notifications
- Scroll time
- Daily streaks
- Recommendations
- Engagement
It gives the user enough information to leave meaningfully, then offers Pocket Mode as a low-information countdown.
The product succeeds when the user stops using it.
Privacy and safety
Location is used to issue a ticket.
Field notes are stored in the browser using localStorage. They are not sent to a database or used to build a profile.
The project does not require:
- A tracking account
- A social graph
- Map tiles
- A weather API
- A recommendation feed
The walk score is an experiment, not a safety guarantee.
Users should always use their own judgment about weather, lighting, traffic, accessibility, and personal safety.
What I learned
The easiest way to make an AI product useful is not always to add more conversation.
For this project, the better design was to constrain the model:
- Give it structured facts.
- Require a small JSON response.
- Validate the response.
- Keep an offline path.
- Make the final output printable.
- Make the interface disappear after the handoff.
The AI is useful before the walk. It should not become the activity.
Prize categories
Best Use of TabPFN — Prior Labs
Last Light uses TabPFN to score dusk-walk conditions from a generated dataset containing environmental, seasonal, solar, and duration features.
A Ridge model is included as a baseline so the TabPFN result can be compared with a simpler model.
Best Use of Gemma
Gemma can generate the natural-language walk ticket from structured facts.
The response is validated, and deterministic field recipes keep the experience available when no model endpoint is running.
What I would build next
The next version could add:
- An installable offline PWA
- Better accessibility and high-contrast themes
- User-created walking rituals
- A lightweight on-device audio model
- Transparent model evaluation charts
- User-controlled field-note export
- Safety-aware route constraints without turning the project into a map app
For now, Last Light has one clear job:
Help someone leave the screen before the last light leaves the sky.
Built for Hacktoberfest
This project is built for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass.
The screen prepares the walk. Then it gets out of the way. 🌿
Top comments (0)