This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass.
What I Built
Touch Grass is a nature companion designed to help people spend less time scrolling and more time experiencing the world around them.
We spend so much of our lives looking at screens that sometimes we need a little encouragement to step outside, breathe, explore, and reconnect with nature.
That's why I built Touch Grass, featuring Sprout, a friendly AI nature companion with a cozy, retro 16-bit pixel-art aesthetic.
The main four features which gives user a motive to step outside and enjoy nature โจ
- ๐ฟ Sprout AI Companion: A supportive, nature-oriented chatbot that encourages outdoor breaks and suggests simple activities.
- ๐ Running Companion: GPS-based outdoor activity tracking with route visualization and a post-run summary.
- ๐ Outdoor Activity Tracker: Track outdoor visits and build consistent nature habits.
- ๐ Nature Calendar: Explore nature-related information and plan outdoor experiences.
- ๐ฎ Retro Pixel-Art Interface: A playful green-themed experience that makes reconnecting with nature feel inviting rather than demanding.
The goal is to bring the healing power of nature to those isolated at home/college/school/office ... etc.
Demo
๐ Live Demo: https://touch-grass-dev-week-challenge-1.vercel.app/
The deployed website lets you explore the Touch Grass interface and its available features.
AI demo note: The public deployment uses the mock/offline fallback because my local Ollama server runs on my own computer and isn't publicly accessible. The actual Gemma-powered inference has been tested locally. This distinction is intentional: the public website does not pretend to be connected to a model it cannot reach.
Code
๐ป GitHub Repository: https://github.com/YUVA56-gomu/Touch-Grass-Dev-Week-Challenge-1-.git
The project combines a React and Vite frontend with a FastAPI backend, alongside a local AI inference setup.
Sceenshots
How I Built It
I wanted to explore how an open-weight language model could power a friendly, focused AI companion without requiring every conversation to depend on a paid, proprietary AI API.
The AI behind Sprout
I integrated Google Gemma 2 2B through Ollama for local inference.
The model powers Sprout's conversational experience. I designed its system instructions around a warm, energetic, supportive nature companion that encourages outdoor activities without shaming users or putting pressure on them.
The integration includes:
- Local inference: Gemma 2 2B runs through Ollama on my computer.
- Multi-turn conversations: Conversation history is supplied to the model so Sprout can respond with context.
- FastAPI integration: A backend provider connects the application to the local Ollama service.
- Explicit provider status: The interface can identify the active AI provider rather than silently pretending a fallback is the real model.
- Failure handling: The local provider reports unavailable-model and service errors instead of silently substituting a different AI provider.
The application stack
- Frontend: React, TypeScript, Vite
- Backend: Python, FastAPI
- AI inference: Gemma 2 2B with Ollama
- Maps and routes: Leaflet/OpenStreetMap, with route calculation support
- Local-first data: Browser storage for relevant activity data
- Deployment: Vercel for the public frontend
One important engineering lesson was that deploying a frontend doesn't automatically deploy its local AI model. A browser visiting the Vercel site cannot access Ollama running on my laptop through localhost.
For that reason, the public preview and the locally running Gemma-powered experience are clearly distinguished.
Why Does Open Innovation Matter?
Open innovation made it possible for me to experiment with a model I could run and test on my own hardware.
Using an open-weight model gave me more control over the inference environment, the system instructions, and the way the model integrates with my application.
It also helped me learn something important: AI should be a component we can understand, test, and replace โ not a black box that dictates our entire architecture.
For a project like Touch Grass, local inference opens up interesting possibilities for privacy-conscious and more accessible AI experiences. It lets developers experiment without making every prototype dependent on a proprietary hosted inference API.
There are still practical trade-offs. Local inference depends on the user's hardware, and a public deployment needs its own accessible inference service if it is to serve real AI responses to everyone. Maps and other online integrations can also require internet access.
Open innovation doesn't remove every limitation. It gives developers more opportunities to understand those limitations and build around them.
My Agent Session
I used an AI coding assistant during development to help investigate implementation details, integrate the AI provider, troubleshoot the production build, and prepare the deployment.
I haven't included a DevRelay session link because I don't have a verified shareable session URL to provide.
Final Thoughts
Touch Grass started with a simple question:
What if technology encouraged us to look up from our screens instead of giving us another reason to stare at them?
Sprout is my attempt to explore that idea โ one outdoor walk, one little nature discovery, and one less scroll at a time.
This project also gave me hands-on experience with local language-model inference, frontend/backend integration, failure handling, and deploying a real application.
Thanks for checking it out! ๐ฑ
I'd love to hear your feedback and suggestions for making Touch Grass more useful.
Top comments (0)