This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass
What I Built
What if the best thing an AI could do was not keep you on your screen, but help you put it down?
That is the idea behind TrailMind AI.
TrailMind is an offline-first outdoor adventure companion that uses open-weight AI to turn ordinary outdoor time into small, meaningful adventures.
Instead of asking an AI to generate more content for you to consume, TrailMind asks a different question:
What can AI help you do in the real world?
You can tell TrailMind where you are, what kind of experience you want, and how much time you have. It can then turn that into an outdoor mission — such as a walk, exploration activity, nature observation challenge, or mindful outdoor experience.
The core loop is simple:
Plan → Go Outside → Observe → Record → Reflect
TrailMind includes:
- Outdoor adventure recommendations
- Walking and exploration route generation
- Nature observation challenges
- Offline adventure checklists
- Observation, photo, and note recording
- Nature Detective experiences
- Adventure Journals
- Outside Score
- Demo Mode for quickly exploring the application
- Offline fallback when an AI runtime is unavailable
The application is designed for students, developers, families, travelers, and anyone who wants technology to encourage real-world activity instead of replacing it.
TrailMind is deliberately designed around a different kind of AI experience:
The goal is not to keep you chatting with the AI. The goal is to give you a reason to stop chatting and go outside.
Demo
Live Application
The production application is deployed on Render with a separate frontend and FastAPI backend.
The easiest way to experience TrailMind is:
- Open the application.
- Choose Start an Adventure.
- Select an outdoor activity.
- Generate your adventure mission.
- Take the mission outside.
- Complete the observation and checklist activities.
- Record your observations.
- Finish the adventure.
- Generate your Adventure Journal.
- Check your Outside Score.
For judges and anyone exploring the project remotely, Demo Mode provides a quick way to experience the product without needing to physically visit a location.
The important part of the experience is what happens after the screen:
Open TrailMind → Get your mission → Put the phone away → Explore.
Code
The complete project is open source on GitHub:
TrailMind AI — GitHub Repository
The repository contains the complete frontend and backend implementation, AI provider architecture, offline fallback system, adventure workflows, journals, Nature Detective, tests, and deployment configuration.
The project is structured so that the AI layer can evolve without rebuilding the entire application around a single provider.
How I Built It
TrailMind is built as an offline-first web application with a provider-based AI architecture.
The main open-weight AI integration is Google Gemma, running locally through Ollama.
The architecture looks like this:
User
↓
TrailMind Frontend
↓
FastAPI Backend
↓
AI Provider Layer
├── Local Gemma + Ollama
├── Optional hosted AI provider
└── Offline Rule Engine
This separation was an important design decision.
Instead of making the entire product dependent on one proprietary AI API, the application treats AI as a replaceable capability.
Open-Weight Gemma
Gemma is used as the open-weight AI layer for generating outdoor adventure experiences.
With the local setup, users can run Gemma through Ollama and experiment with AI-powered adventure generation without requiring every interaction to be sent to a closed third-party service.
This also makes the project easier to experiment with because the model and AI provider can evolve independently from the rest of the application.
Offline-First Architecture
The outdoors is not always the best place for a reliable internet connection.
That created an interesting engineering requirement:
What happens if the AI is unavailable exactly when the user is outside?
Instead of making the application fail, TrailMind includes an Offline Rule Engine.
When a live AI runtime is unavailable, the application can still provide deterministic outdoor experiences and continue the core workflow.
Users can still:
- Create an adventure
- Follow an outdoor checklist
- Complete a mission
- Record observations
- Create journal entries
- Track their Outside Score
This means connectivity is not treated as a requirement for the core outdoor experience.
Technology Stack
Frontend
- React
- Vite
- TypeScript
- Tailwind CSS
- Progressive Web App capabilities
Backend
- Python
- FastAPI
- Pytest
AI
- Google Gemma
- Ollama
- Provider-based AI architecture
- Offline Rule Engine
Data
- Local/in-memory fallback
- Optional MongoDB Atlas integration
Deployment
- Render
Render Deployment
TrailMind's production frontend and FastAPI backend are deployed on Render.
Render is not simply mentioned as a deployment option — it is part of the actual production architecture of the project.
There is one important distinction I want to make clear.
The public Render environment cannot access the local Ollama runtime used during development. Therefore, the deployed application currently uses TrailMind's Offline Rule Engine when local Gemma inference is unavailable.
The local development setup can run Gemma through Ollama, while the production deployment remains functional through the offline fallback.
I chose to make this behavior explicit because transparency about AI infrastructure is important.
Why Does Open Innovation Matter?
The idea of TrailMind depends heavily on the possibilities created by open AI.
A traditional closed-API approach could certainly generate outdoor suggestions.
But open-weight AI enables something more interesting.
Privacy
Local inference gives users the possibility of processing their AI interactions on their own machine instead of sending every interaction to a third-party AI provider.
For an application involving personal routines, locations, observations, and journals, that can be meaningful.
Control
TrailMind does not have to be permanently tied to one AI provider.
The application can work with:
- Local Gemma
- Another compatible AI provider
- Or no live AI service at all
The outdoor experience itself remains intact.
Resilience
An application that depends entirely on a remote AI API can become unusable when connectivity disappears.
TrailMind takes the opposite approach.
The AI layer can disappear temporarily without taking the entire outdoor experience with it.
The user can still complete the core mission and record their experience.
Experimentation
Open-weight models make experimentation much more accessible.
Developers can run models locally, experiment with prompts, compare models, change the AI layer, and understand more about how the system behaves.
For TrailMind, open innovation is therefore not just about avoiding a proprietary API.
It enables a different product philosophy:
AI should be a facilitator of real-world experiences, not the destination.
Technical Highlights
AI Provider Architecture
TrailMind separates the application logic from the AI provider.
This makes it possible to experiment with different AI runtimes without rewriting the core application.
The architecture supports local open-weight AI while retaining a deterministic fallback.
Nature Detective
The Nature Detective feature is designed to make users pay attention to their surroundings.
Instead of simply telling someone where to go, TrailMind can turn the environment itself into part of the experience.
A normal walk can become an observation challenge.
Adventure Journal
After an adventure, TrailMind can turn the user's observations and experience into an Adventure Journal.
This creates a natural closing loop:
Explore → Observe → Reflect
The AI is therefore used not only before the outdoor experience, but also to help users reflect on what they actually experienced.
Outside Score
TrailMind also includes an Outside Score.
The intention is not to turn outdoor time into another addictive metric.
Instead, it provides a lightweight way to recognize completed outdoor activities and encourage continued participation in the real world.
Demo Mode
Because judges and users may not be physically near the same location, TrailMind includes Demo Mode.
This makes the complete product flow easier to evaluate while preserving the real-world purpose of the application.
Testing
Before deployment, I validated both the frontend and backend.
The frontend production build completed successfully with:
1592 modules transformed
Frontend automated tests:
2 test files passed — 6 tests passed
Backend automated tests:
11 tests passed
The deployed FastAPI backend also exposes a health endpoint for production verification.
The application was then tested through the deployed environment to verify the main user workflows.
What I Learned
The most interesting lesson from building TrailMind was that adding AI does not always mean making the AI do more.
Sometimes the better question is:
What should the AI help the user do next?
For many AI applications, the answer is:
"Ask another question."
For TrailMind, the answer is:
Go outside.
That changed the architecture of the project.
It influenced the offline-first approach, the provider-based AI layer, the adventure workflow, and even the way the interface is designed.
The AI is intentionally not the destination.
It is the starting point for a real-world activity.
Future Improvements
There are several directions I would like to explore next:
- Better local Gemma models for different devices
- More advanced local route generation
- Richer nature observation workflows
- Better offline maps
- Voice-guided outdoor missions
- More personalized adventure recommendations
- More accessibility features
- Community-created outdoor missions
- Support for additional open-weight models
- More advanced local AI capabilities
The long-term vision is to build a platform where AI helps people interact more with the physical world rather than spending more time inside a digital one.
Prize Categories
Render
TrailMind AI is deployed on Render using a separate production frontend and FastAPI backend.
Render is part of the actual deployment architecture of the project.
Gemma
TrailMind integrates Google's open-weight Gemma model through a local Ollama runtime.
Gemma forms the open-weight AI layer for generating outdoor adventure experiences, while the Offline Rule Engine keeps the application functional when local AI inference is unavailable.
Final Thoughts
We are building AI systems that can answer almost anything.
But perhaps one of the most useful things an AI can tell us is something much simpler:
You've been on the screen long enough. Go touch grass. 🌱
That is the idea behind TrailMind AI.
Not another AI that asks you to stay.
An AI that gives you a reason to leave.
Plan less. Explore more.
Project: TrailMind AI
Live Demo: Launch TrailMind AI
Challenge: Hacktoberfest Open-Source AI Challenge — Week 1: Touch Grass
Built with: React • FastAPI • Google Gemma • Ollama • Render
Top comments (0)