Anmol

Posted on Oct 10 Edited on Oct 11

GroundTruth: An Open-Source AI Quest Platform That Rewards Real-World Exploration

#devchallenge #hf26challenge #ai #gemma

Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass Submission 🌿

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

What I Built

We have apps to track our steps, apps to track our calories, apps to track our productivity, and even apps that remind us to take breaks from using apps.

There's something slightly ironic about that.

We spend so much time looking at screens, even when we're trying to build healthier habits.

But what if an app didn't just tell you to go outside? What if it gave you an actual reason to do it?

That's the idea behind GroundTruth.

GroundTruth is an open, local-first outdoor quest platform that turns everyday exploration into real-world challenges, photo-based submissions, and measurable progress.

The world is the game. Your actions are the achievements.

Instead of simply counting steps or tracking activity, GroundTruth gives users small outdoor quests that encourage them to observe and explore their surroundings.

Some examples:

Sky reflection: Photograph the sky reflected in a puddle or window.
Notice tiny textures: Find an interesting texture on a public path, rock, or tree bark.
Cloud imagination: Look at the clouds and photograph an unusual shape from a safe location.

You don't need a mountain, a hiking trail, or an entire weekend to participate. Sometimes, all you need is five minutes and a reason to notice something you usually walk past.

How it works

Choose your moment: Select a time slot such as morning, evening, or night.
Discover a quest: Browse outdoor challenges with instructions, difficulty levels, estimated time, and proof requirements.
Go outside: Complete the actual task in the real world.
Submit evidence: Upload a photograph of your completed challenge.
Earn XP: Approved submissions earn experience points and contribute to levels, streaks, and badges.
Explore together: Compare weekly XP through regional leaderboards covering country, state, and city.

The important part is that the actual challenge happens outside the application. The phone is there to introduce the quest and record the accomplishment, not to become the activity itself.

GroundTruth is designed for people who want to explore their surroundings, build outdoor habits, and make everyday experiences a little more interesting.

Demo

The field journal introduces the experience with one simple invitation: "A little less screen. A little more world."

The Explore section lets users discover quests based on their selected time slot.

Quest examples include Sky Reflection, Notice Tiny Textures, and Cloud Imagination.

The leaderboard adds a friendly competitive element by ranking users according to approved weekly quest XP.

Code

GitHub Repository: https://github.com/AnmolCanCodes/groundtruth

The project is open source. Feel free to explore the implementation, inspect the architecture, and experiment with it.

How I Built It

I wanted GroundTruth to have a straightforward architecture where the core application logic and AI functionality remain independent.

Technology stack

Component	Technology
Frontend	React + Vite
Backend	Python + FastAPI
Database	SQLite
ORM	SQLAlchemy
Authentication	JWT
AI integration	Hugging Face InferenceClient
Open-weight model	Google Gemma 7B Instruct

Architecture

The application follows this general flow:

              React + Vite
                   |
                   v
                FastAPI
                   |
          +--------+--------+
          |                 |
          v                 v
    Core Application     AI Service
          |                 |
          v                 v
     SQLAlchemy        Hugging Face
          |             InferenceClient
          v                 |
        SQLite              v
                         Gemma 7B

Why I separated AI from the reward system

This was one of my important engineering decisions.

I didn't want an LLM to have unrestricted authority over user rewards.

In GroundTruth, Python handles the deterministic application logic:

Quest progression.
Submission processing.
XP calculations and rewards.
Level progression.
Date-based streak tracking.
Badge unlocking.
Weekly regional leaderboard calculations.

AI works as an assistant layer rather than the authority controlling the entire application.

Using Gemma

GroundTruth integrates Google's open-weight Gemma 7B Instruct model through Hugging Face's InferenceClient.

I use Gemma for text personalization, with the goal of adapting quest descriptions to individual preferences without changing the underlying challenge requirements.

The application also supports optional AI-assisted image relevance assessment. This is configurable rather than mandatory, and basic upload validation is handled separately by the backend.

I wanted to keep the AI service replaceable so that changing the model or inference configuration wouldn't require rewriting the application's core logic.

The result is an application where AI adds flexibility without becoming a dependency for every operation.

Why Does Open Innovation Matter?

For GroundTruth, open innovation is not just about using an open-weight model because it's available.

It's about having control over how AI fits into the application.

I didn't want the entire experience to depend on a single proprietary AI provider or a closed ecosystem.

Here's why open technology matters for this project.

1. Model flexibility

Using Gemma gives developers an open-weight model that can be integrated into a self-hosted application.

The AI layer is separated from the core backend, making it easier to experiment with different compatible models and inference configurations.

2. Data ownership and self-hosting

GroundTruth uses SQLite and local file storage for its self-hosted setup.

Developers can run their own instance and maintain control over their application data instead of depending entirely on a centrally operated platform.

3. Less vendor dependency

The personalization layer doesn't need to be permanently tied to one closed AI provider.

Developers can explore different models and deployment approaches as their requirements evolve.

4. AI where it actually makes sense

I also believe that not every application decision needs an LLM.

GroundTruth uses AI for assistance and personalization, while important operations such as reward calculations and progression remain deterministic.

This makes the application more predictable and easier to reason about.

For me, open innovation means having the freedom to make those architectural decisions rather than accepting a closed provider's limitations.

And most importantly, it lets me experiment with AI in a way that encourages people to spend more time in the real world, not more time interacting with an AI interface.

Prize Categories

Gemma:

GroundTruth uses Google's open-weight Gemma 7B Instruct through Hugging Face's InferenceClient to personalize outdoor quest descriptions based on user preferences, while preserving the original challenge requirements.

I chose Gemma because I wanted an AI layer that could be experimented with and configured independently of the core application. AI assists with personalization, while Python handles quest validation, XP, badges, and leaderboard calculations deterministically.

The idea is simple: use open-weight AI to make real-world exploration more personal, not to make another screen more addictive.

That's why I'm submitting GroundTruth for the Best Use of Gemma category.

A little less screen. A little more world. 🌿

Thanks for checking out GroundTruth. I'd love to hear what outdoor quest you'd add to it!

DEV Community