WildQuest | Make room for outside.

WildQuest — Hacktoberfest Open-Source AI Challenge

This is a submission for the Hacktoberfest Open-Source AI Challenge
Week 1: Touch Grass.

What I Built

WildQuest turns everyday activity ideas into small, real-world
adventures. Tell it what you want to do---such as taking a walk,
stretching, or birdwatching---and it uses AI to generate exactly three
personalized quests.

Each quest includes clear instructions, an estimated time, a difficulty
level, points, XP, and relevant safety notes. Users can mark quests
complete or undo completion, making it easier to turn an intention to
get outside into a short, achievable challenge.

WildQuest is designed for anyone who wants a little extra motivation to
step away from their screen and do something in the real world. It adds
a lightweight game loop to everyday activities without requiring an
account.

WildQuest runs locally and can work offline after setup. The web app
and AI inference run on your own machine through Express and Ollama, so
generating quests does not require sending prompts to a hosted AI API.
An internet connection is needed initially to install dependencies and
download the Docker image/model. Once those are available locally, you
can use WildQuest without an internet connection.

Current limitation: Quest completion is self-reported. The app does
not independently verify that a quest was completed.

Demo

The app can be run locally by following the setup instructions below.

• Video demo: Add a demo video is available in GitHub repo.

Code

• GitHub repository: https://github.com/aLok-1105/WildQuest

The project serves the responsive web interface and JSON API from a
single Express application.

How I Built It

WildQuest is built with a lightweight web stack and local AI inference:

• Node.js and Express serve the web interface and the API.
• Ollama runs the language model locally.
• Gemma 3 270M (gemma3:270m) generates personalized activity sessions and quests on the local machine.
• Zod validates the generated response structure before it is returned to the client.
• HTML, CSS, and JavaScript power the responsive interface, quest display, completion controls, and reward totals.
• Docker Compose helps start the Ollama service and pull the configured model.

How it works

1. The user enters an activity prompt with any useful details, such as duration, pace, location, or difficulty.
2. The frontend sends the prompt to POST /task on the local Express server.
3. The Express server asks the local Ollama model to generate an activity session.
4. The server validates the response structure and returns the session as JSON.
5. The interface displays exactly three quests, including instructions, estimated time, difficulty, rewards, and safety notes.
6. Users can mark quests complete or undo completion. Earned points and XP are kept in browser sessionStorage for the current tab session.

Because both the application server and model inference run locally,
quest generation does not depend on a remote AI API. After the initial
installation and model download, WildQuest can generate quests
offline, provided the local services are running and the model is
installed.

Run it locally

Requirements: Node.js 18.11 or newer and Docker Desktop.

An internet connection is needed for the initial dependency installation
and for Docker/Ollama to download the required model. After setup, you
can run the app locally without internet access.

npm install
docker compose up -d
npm start

Open http://localhost:8000 in your browser. The web server expects
Ollama at http://localhost:11434.

The Docker Compose setup pulls gemma3:270m when the Ollama service
starts, if the model is not already available locally. By default, the
app uses gemma3:270m. Set the OLLAMA_MODEL environment variable to
use a different model that is already available in Ollama.

API example

Send a request to POST /task:

{
  "prompt": "Plan a relaxed 30-minute walk through a leafy park"
}

A successful response contains session details, exactly three quests, an
empty bonus_quests array, and total available points and XP. Each
quest includes completion criteria and reward values.

Invalid or empty prompts return 400. Ollama connection errors or
responses that do not match the expected structure return 502.

Why Does Open Innovation Matter?

Open innovation makes it possible to build an AI-powered experience
without relying entirely on a closed, hosted model API.

WildQuest uses Gemma 3 270M through Ollama, so inference can run locally
on the developer's machine. This gives developers a practical way to
experiment with an open-weight model, inspect and adapt the surrounding
application, and build a working prototype without requiring a
hosted-model API key.

Local inference also makes offline use possible after the initial
setup. Users can generate quests without sending their prompts to a
remote AI service or depending on an active internet connection, as long
as the app, Ollama, and the model are installed and running locally.

Using a small model makes local experimentation more approachable. The
trade-off is that output quality and reliability can vary, so WildQuest
validates the response structure and keeps quest completion
self-reported rather than claiming that the AI verifies real-world
activity.