This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass
What if AI could help you spend less time looking at a screen and more time enjoying the world outside?
That question inspired Touch Grass API, a Java project that uses locally running AI to generate outdoor missions and encourage people to take a break from their screens.
Instead of using AI to keep people online for longer, I wanted to explore a different idea: using technology to help people disconnect.
What I Built
Touch Grass API generates outdoor missions with the help of an AI model running locally through Ollama.
Each mission includes a title, a motivational message, a suggested activity, an estimated duration, and a difficulty level. Users can generate new missions, browse their missions, and mark activities as completed through a web interface backed by a REST API.
The project is built for anyone who wants a simple way to break their screen-time routine, discover outdoor activities, and make more room for real-world experiences.
The main idea is simple: use AI to inspire action outside the screen, not another reason to stay in front of it.
Demo
🎥 Watch Touch Grass API in action:
The demonstration shows the application running locally, generating outdoor missions and managing them through its web interface.
The project currently runs locally and does not have a publicly hosted demo.
Code
💻 Explore the source code on GitHub:
The repository includes the source code, project documentation, and instructions for running the application locally.
How I Built It
I built Touch Grass API using Java 17 and Spring Boot, with a focus on backend development, clean separation of responsibilities, and practical integration with AI.
The main technologies are:
- Java 17 — application logic.
- Spring Boot — REST API and application infrastructure.
- Spring Data JPA — persistence.
- H2 Database — local database storage.
- Thymeleaf — web interface.
- Ollama + Qwen3 — local AI inference and mission generation.
- Maven — dependency management and builds.
One of my most important architectural decisions was using hexagonal architecture. I separated the domain, application use cases, and infrastructure adapters to keep the business rules independent of the technologies used to run the application.
For AI integration, I implemented an adapter that communicates with Ollama's local API. The application sends a request to the locally running model, receives the generated content, and uses it to create an outdoor mission.
This project gave me an opportunity to practice backend concepts such as REST endpoints, validation, persistence, exception handling, and automated testing while exploring how AI can be integrated into a Java application.
Why Does Open Innovation Matter?
Open innovation was essential to making this project possible.
By using Ollama with the Qwen3 model, I could experiment with AI inference on my own machine instead of depending on a hosted, closed AI API for every generation.
This approach offers several advantages:
- Local control: prompts can be processed locally rather than being sent to an external AI provider.
- Flexibility: I can experiment with different compatible models and adjust the application as the project evolves.
- Accessibility for experimentation: I could build and test the integration without needing a paid hosted AI API.
- Learning and transparency: working with open-weight models and open-source tooling gave me a more hands-on understanding of how AI fits into an application.
Local inference does have trade-offs. Performance depends on the available hardware, and downloading the model initially requires obtaining the model files. Running inference locally also does not automatically make every component of an application open source.
What mattered most to me was having the freedom to experiment, learn, and build around a model I could run locally.
That freedom helped me turn a small idea into a working application while keeping the AI component under my control.
More importantly, it gave me a chance to explore a different use of AI: encouraging people to spend less time online and more time in the real world.
Final Thoughts 🌿
Touch Grass API started as a project to practice Java backend development, but it became a way to explore how technology can support healthier habits.
I learned more about structuring a Spring Boot application, integrating local AI, and connecting a technical implementation to a real-world purpose.
There is still plenty of room to improve the project, but the core idea is already there: make technology a starting point for an outdoor experience rather than the destination itself.
Sometimes, the best thing an application can do is give you a reason to close your laptop and go outside.
What kind of outdoor mission would you like an AI to suggest for you?
Top comments (0)