My submission for the Hacktoberfest Open-Source AI Challenge — Week 1: Touch Grass.
What I Built
I built Girora, a travel companion app that helps people plan trips, share their travel plans, and find others who might want to join them.
The idea came from a simple problem: planning a trip involves a lot of small decisions. You have to choose a destination, figure out the dates and budget, plan what to do, and sometimes find people who are interested in going with you. These things can end up scattered across different apps, websites, and conversations.
I wanted to bring the main parts of this process together in one place.
Girora is built around three things: planning a trip, sharing it with others, and discovering trips to join.
1. Generate a trip itinerary with AI
Sometimes you know you want to travel, but you don't know where to start with the planning. You might have a destination in mind, a limited budget, or only a few days available.
Girora includes an AI itinerary-generation feature that helps turn travel preferences into a suggested plan. The idea is to give users a starting point instead of making them plan every detail from scratch.
For the AI part, I used Gemma 3 1B through Ollama, running locally on my computer. This gave me a way to experiment with an open-weight model and connect its generated output to the application.
2. Create and publish a trip
Girora also lets users create trips with details such as the destination, dates, and budget.
The idea is that a trip shouldn't have to remain a private plan. Once created, it can be shared so other people can discover it and see whether it interests them.
3. Discover trips and request to join
This is the community part of the project.
Users can browse trips and express interest in joining one by sending a join request. Instead of everyone having to plan separately, Girora is intended to make it easier for people with similar travel interests to connect around a trip.
The current version demonstrates the trip discovery and join-request flows, but it doesn't yet have a shared backend. Trip data and join requests are stored in the browser's local storage, so they aren't shared across different users or devices yet.
I want to make this a proper multi-user feature in a future version.
Why the name and idea?
I wanted to build something where technology helps people do something outside the digital world.
A travel app can easily become another place where people spend time browsing. My goal with Girora is different: help someone get from an idea to a plan, then close the laptop and actually go explore.
That's what made the Touch Grass theme a good fit for this project.
Demo
🌐 Live website: https://girora.vercel.app
The recording shows the application running locally. It walks through the interface and demonstrates the trip-generation flow, creating a trip, exploring the trip features, and trying the join-request flow.
I wanted to include a recording because a few of the main features are easier to understand when you can see the actual application being used.
Current limitations
I also want to be clear about what is and isn't working in this version.
- The website is deployed on Vercel, and the trip discovery interface is available.
- The AI itinerary feature currently works with my local Ollama setup. The deployed website cannot reach the Ollama instance running on my computer, so hosted AI generation is still a work in progress.
- Trips and join requests are stored in browser local storage. They are not yet persisted in a shared database or synchronized between users.
These are limitations I plan to address rather than features I want to claim are already complete.
Code
💻 GitHub repository: https://github.com/umeshpawak/girora
The repository contains the application code. I wanted to keep the project available so other developers can explore how it is structured and how the AI feature fits into the application.
The main technologies I used are:
- Next.js for the web application.
- TypeScript for application code.
- Tailwind CSS for styling.
- Gemma 3 1B as the open-weight language model.
- Ollama to run the model locally.
How I Built It
I approached Girora by first working on the travel-planning interface and the main trip-related flows. Once the core experience was in place, I worked on connecting the AI itinerary feature to the application.
The application
I used Next.js and TypeScript for the application, with Tailwind CSS for the interface.
The main experience is organized around the things a traveler might want to do: plan an itinerary, create a trip, explore available trips, and express interest in joining one.
I also worked on the API side of itinerary generation, including validating generated output and handling errors. This matters because an AI response isn't automatically a valid itinerary just because the model returned text. The application still needs to deal with unexpected output and failures.
The AI model
For itinerary generation, I chose Gemma 3 1B and ran it through Ollama.
Rather than depending entirely on a remote AI API during development, I could run the model locally and experiment with prompts on my own machine. This made it easier to understand how the model's output connected to the rest of the application.
The model is only one part of the feature, though. The surrounding code has to pass the appropriate input, receive the response, validate it, and handle cases where generation fails.
Deployment
I deployed the Next.js application to Vercel and made the source code available on GitHub.
Deployment also showed me a difference between something working locally and something working for everyone online. My local AI setup depends on Ollama running on my computer. The hosted website cannot automatically access that local service, so the AI feature needs an inference service that the deployed application can reach.
That is one of the main technical problems I want to solve next.
Running Girora locally
If you'd like to explore the project, here's the basic setup.
You'll need Git, Node.js, npm, and Ollama installed.
Step 1: Clone the repository
git clone https://github.com/umeshpawak/girora.git
cd girora
Step 2: Install dependencies
npm install
Step 3: Download Gemma
ollama pull gemma3:1b
Make sure Ollama is running and that the model is available on your machine.
Step 4: Configure the application
Check the repository's environment configuration and create a .env.local file with any variables the application requires. Use the actual variable names documented in the code; don't commit private keys or secrets.
Step 5: Start the development server
npm run dev
Then open http://localhost:3000 in your browser.
The basic commands start the Next.js application, but the AI feature may require the correct environment configuration and a running Ollama service. If you run into issues, check the repository's configuration and error messages first.
Why Does Open Innovation Matter?
For me, using an open-weight model was a practical way to learn how AI can fit into an application beyond a simple API call.
Gemma and Ollama let me experiment with local inference on my own computer. I could work on the prompt, inspect the generated output, and make changes without making a hosted AI provider a requirement for every development test.
It also gave me more control over the development setup. I could experiment with the model locally and see how it behaved when connected to the itinerary-generation feature.
There are trade-offs, of course. Running a model locally depends on the available hardware, and local inference doesn't automatically make a feature available to users of a deployed website. A production version needs a reliable way to serve the model, handle requests, and manage the resources involved.
I experienced that limitation directly while deploying Girora. The local version and the hosted version don't have the same access to the AI service, and solving that gap is part of the next stage of development.
That's why I found this project useful: it gave me a practical reason to work with an open-weight model and understand both the benefits and the limitations.
My Agent Session
I haven't included a DevRelay agent session link in this submission. The demo video and GitHub repository are the resources I'm sharing to show the application and its implementation.
Prize Categories
Best Use of Gemma is the partner category that appears most relevant because Girora uses Gemma 3 1B for itinerary generation.
I'll only claim this category if the implementation meets the category's requirements. The main project submission is about building a useful outdoor travel-planning experience around open-weight AI.
What's Next?
Girora is still a work in progress, and I have several ideas for making it more useful.
1. Add a proper backend and database
The biggest next step is moving trip data away from browser local storage and into a real database. This would allow trips to be saved centrally and accessed from different devices.
2. Add user accounts
I want users to be able to sign up, log in, and manage their own trips. This would also make it possible to associate published trips and join requests with actual user accounts.
3. Complete the join-request workflow
The next version should let trip creators view incoming requests and accept or reject them. That would make the trip-sharing feature more useful than a browser-only demonstration.
4. Make AI generation work online
I want to set up an accessible AI inference service so the deployed application can generate itineraries without depending on Ollama running on my personal computer.
I'll also need to think about reliability, request handling, and the cost of serving the model.
5. Improve trip discovery
Over time, I'd like to make it easier to find trips based on destination, dates, budget, and interests. Notifications and other community features could also help people coordinate plans.
These are future plans, not features I'm claiming are already implemented. I want to build them step by step without losing sight of the original goal.
Final Thoughts
Building Girora has been a useful learning experience because it brings together frontend development, API integration, AI experimentation, and deployment.
It has also taught me that making an application work locally is only one part of building a useful product. Data persistence, multi-user functionality, and reliable deployment all matter when you want other people to use it.
For this challenge, I wanted to explore how open-weight AI could help with something practical: getting from a travel idea to a plan that someone can actually use.
Girora isn't finished yet, but the core idea is there, and I have a clearer idea of what needs to come next.
The goal is simple: less time stuck planning, more time exploring. 🌿
I'd love to hear what you'd add to make planning an outdoor trip with other people easier!
Top comments (0)