DEV Community: Drishya Singhal

Most fitness apps focus on steps, calories, and workout statistics. NatureFit takes a different approach: it combines nature exploration with physical activity, turning an ordinary walk into a series of outdoor quests.

The idea is simple: use technology to make people want to spend more time away from technology.

🌐 Live application: https://drishya-code.github.io/NatureFit/

💻 GitHub repository: https://github.com/Drishya-code/NatureFit

What I Built

NatureFit is an AI-powered outdoor fitness Progressive Web App (PWA) that turns nature exploration into movement-based quests.

Users choose their activity, available time, fitness level, difficulty, and surroundings. NatureFit then generates a quest or provides an offline alternative, combining nature-based tasks with physical movement.

For example, a trail quest might ask you to photograph a trail marker, continue walking, and capture a scenic viewpoint before earning Outdoor XP.

1. Start with a simple idea: go outside 🌿

The home screen introduces the core experience: explore nature, move your body, capture evidence of discoveries, and earn XP. It also provides direct access to progress, weekly missions, the nature collection, achievements, and step tracking.

The aim is to make starting an outdoor activity easy while keeping the app itself simple. Users can begin a quest or check their progress without navigating through a complicated fitness dashboard.

2. Create a quest that fits your day 🧭

NatureFit lets users choose how they want to move, how long they want to stay outside, their experience level, and the environment they plan to explore.

Activities include walking, running, hiking, cycling, and mixed movement. Users can also select relaxed, moderate, or challenging quest difficulty.

This flexibility makes outdoor activity more approachable. A short neighbourhood walk can be a valid quest just as a longer trail adventure can be.

3. Turn an ordinary walk into a quest 🥾

Once a quest is generated, NatureFit presents its tasks in a structured sequence. Each task combines a nature-related objective with a movement activity and an XP reward.

The quests encourage users to observe their surroundings instead of simply following a workout counter. When AI generation is unavailable, the app can offer a curated offline quest rather than leaving the user stuck.

4. Complete tasks and provide evidence 📸

NatureFit distinguishes between nature observations and movement activities. Photo-based tasks ask users to capture evidence, while movement tasks require the user to confirm that they performed the activity.

The app does not pretend that a photo proves a person completed a workout or that a button press independently verifies physical activity. Movement is self-reported, and location checks should not be treated as tamper-proof.

This is an intentional design choice: progress should be engaging without making claims the application cannot substantiate.

5. Build consistency, not just a one-day streak 🔥

Completing an individual quest is only the beginning. NatureFit also includes a personal outdoor journey dashboard that brings together XP, streaks, discoveries, completed quests, and activity history.

The latest version extends this experience with a 12-week consistency heatmap, weekly missions, a nature discovery collection, and eight explorer achievements. It also includes browser-based step tracking with a manual fallback.

The idea is to reward returning to the outdoors regularly, not just completing one impressive session.

Key Features

AI-generated quests: Generate structured nature and movement challenges using a configurable open-weight model.
Offline quest library: Access curated alternatives when AI generation or connectivity is unavailable.
Evidence-based tasks: Require photos for photo-based objectives and clearly identify self-reported movement.
Outdoor XP and streaks: Earn rewards for completing tasks and quests.
12-week consistency dashboard: Review activity patterns and build a sustainable outdoor habit.
Weekly missions: Work toward recurring objectives with XP rewards.
Nature discovery collection: Keep track of discoveries and revisit your progress.
Eight explorer achievements: Unlock milestones as you continue exploring.
Adaptive quest difficulty: Choose relaxed, moderate, or challenging activities.
Step tracking: Use supported browser motion sensors or the manual fallback.
PWA support: Access the application through a browser and install it on supported devices.
Local-first progress: Keep quest progress and activity history on the device without requiring an account.

Demo

🌐 Try NatureFit: https://drishya-code.github.io/NatureFit/

Open the application on your phone or laptop and create an outdoor quest. Explore the progress dashboard, weekly missions, nature collection, achievements, and step tracking.

The app shell and curated quests can work offline after the necessary assets have been cached. AI-generated quests depend on a working AI endpoint unless a locally accessible inference service is configured.

Code

💻 GitHub repository: https://github.com/Drishya-code/NatureFit

The repository contains the application source code, AI integration, PWA configuration, quest library, and automated tests.

The latest upgrade was deployed to GitHub Pages, and the reported test run passed 153 out of 153 checks across application logic, AI handling, end-to-end journeys, offline behaviour, accessibility, and edge cases.

How I Built It

NatureFit uses React 19, Vite, JavaScript, CSS, LocalStorage, and Workbox-powered PWA functionality.

The central engineering decision was to keep the experience useful even when AI generation is unavailable. AI improves quest variety, but the core activity loop should not depend on every model request succeeding.

1. Open-weight AI for quest generation

NatureFit supports an OpenAI-compatible chat-completions endpoint and configurable open-weight models. Its documented example configuration uses Google's Gemma 2 9B instruction-tuned model through OpenRouter, with support for a compatible local inference endpoint such as Ollama.

The model is prompted to produce structured quest data containing nature and movement tasks. The application validates responses before using them and applies rules intended to avoid harmful interactions with plants and wildlife.

2. An offline-first fallback

AI requests can fail because of connectivity problems, missing configuration, or an unavailable endpoint.

Instead of making quest creation entirely dependent on a successful model response, NatureFit provides a curated quest library. The interface distinguishes offline quests from AI-generated quests rather than presenting a fallback as if it came from a model.

The PWA caches the application shell so that previously loaded assets can support subsequent offline use.

3. Consistency and progression

The activity record model brings together quests, discoveries, walking, missions, and achievements. This gives the application a consistent foundation for presenting activity history and progress.

The consistency dashboard, weekly missions, explorer achievements, and difficulty settings build on the core quest loop to encourage repeat use without making every visit dependent on AI generation.

4. Honest evidence and testing

NatureFit does not claim to automatically verify exercise repetitions, identify the contents of every photo, or provide tamper-proof GPS verification.

Photo tasks require photo evidence, movement tasks are self-reported, and the step-tracking feature relies on browser capabilities or manual input rather than claiming access to system-wide health data.

The latest reported test run passed 153 out of 153 checks, covering logic, AI handling, end-to-end flows, PWA offline behaviour, accessibility, and edge cases.

Why Does Open Innovation Matter?

Open innovation makes it possible to inspect, adapt, and experiment with the technologies behind an application rather than relying entirely on a closed proprietary service.

For NatureFit, configurable open-weight AI provides flexibility in model selection and inference. Developers can experiment with compatible hosted endpoints or local inference, while the offline quest library preserves the basic experience when AI is unavailable.

The local-first approach also keeps activity history on the user's device instead of requiring a central account-based service.

Most importantly, the project explores a practical use of AI beyond generating text for its own sake: helping people discover activities that encourage them to step outside.

Open development gives other developers the opportunity to extend the quest library, improve safety rules, experiment with models, and build new ways to connect digital tools with real-world activity.

NatureFit is not a claim that AI can replace being outdoors. It is an experiment in using software to make going outdoors more engaging.

Prize Categories

Best Use of Gemma

NatureFit's documented configuration supports Google's Gemma 2 9B instruction-tuned model for AI-powered outdoor quest generation through an OpenAI-compatible endpoint.

The model can generate structured nature and movement tasks, while response validation and a curated offline quest library help keep the application usable when AI generation is unavailable.

Technology: Gemma 2 9B through a compatible inference endpoint.

Find My Thingy: A Local-First AI Memory Assistant Powered by Gemma 3 4B

Drishya Singhal — Sun, 04 Oct 2026 19:42:23 +0000

Find My Thingy: A Local-First AI Memory Assistant Powered by Gemma 3 4B

Have you ever remembered saving something important in a document, but couldn't remember which file it was in?

Maybe it was a piece of code, a project note, an explanation, or an idea you wrote down weeks ago.

Searching through multiple files just to find one small detail can be frustrating.

That's the problem behind Find My Thingy.

What is Find My Thingy?

Find My Thingy is a local-first personal memory assistant that helps you find information stored in your documents using natural-language questions.

Instead of manually opening files and searching for keywords, you can add your documents to the application and ask questions about their contents.

The application retrieves relevant passages and uses a locally running AI model to generate an answer with source citations.

The idea is simple: your information stays on your device, and you can ask questions about it whenever you need it.

How does it work?

The workflow has four main steps:

Add documents: Import PDFs, TXT files, and Markdown notes.
Extract and index: The application extracts text, divides it into chunks, and creates embeddings.
Retrieve relevant information: When you ask a question, the system searches for relevant document passages.
Generate an answer: Gemma 3 4B, running through Ollama, generates an answer grounded in the retrieved information.

Source citations help you trace an answer back to the document it came from.

Tech Stack

Here are the technologies used to build the project:

Frontend: React, Vite, TypeScript, Tailwind CSS
Backend: Python, FastAPI
Database: SQLite
Vector database: ChromaDB
Embeddings: Sentence Transformers (all-MiniLM-L6-v2)
Local AI: Gemma 3 4B through Ollama
PDF processing: PyMuPDF

Why local-first?

I wanted the application to work without depending on a hosted AI API for everyday document retrieval and question answering.

Running Gemma locally through Ollama means the application can process questions on the user's own machine once the required models and dependencies are installed.

There is an initial setup requirement: the application needs its dependencies and models downloaded before it can operate fully offline.

Key features

Import PDFs, TXT files, and Markdown documents.
Search document contents using natural-language questions.
Generate answers grounded in retrieved passages.
Display source citations.
Store personal memories separately from document content.
Use a locally running language model.
Manage documents and saved memories through a dashboard.

Challenges during development

Building a local AI application involves more than connecting a model to a chat interface.

Some of the important challenges include:

Extracting useful text from different document formats.
Creating meaningful chunks for retrieval.
Avoiding answers when the available context does not support them.
Connecting the frontend, backend, vector database, and local model.
Managing model availability and local dependencies.
Making the setup process understandable for Windows users.

One important lesson was that a convincing AI response is not enough. The application also needs to show where the information came from and avoid making unsupported claims.

Current limitations

This is still a work in progress. Some limitations include:

Scanned PDFs are not currently processed using OCR.
Indexing is synchronous.
Chat history is session-only.
Memory extraction is best-effort.
The application is designed for a trusted local device rather than multi-user deployment.

What's next?

Some areas I would like to improve:

Better semantic retrieval for personal memories.
More robust document processing.
A smoother one-click Windows installation and launch experience.
Improved retrieval evaluation and testing.
Better support for larger document libraries.

Try it out

GitHub Repository: https://github.com/Drishya-code/Find-My-Thingy

The repository contains the source code and setup instructions.

If you explore the project, I'd especially appreciate feedback on the retrieval quality, local setup experience, and ways to make the assistant more useful.

The goal of Find My Thingy is straightforward: stop searching through everything you saved and start asking for what you remember.

Thanks for reading!