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

Paperwalk: An AI That Designs Your Walk, Then Gets Out of the Way 🌿

What I Built

Paperwalk is a walking experience designed by AI — but experienced away from the screen.

The idea is simple:

Instead of using AI to keep us staring at another screen, what if AI prepared something for us to take into the real world?

With Paperwalk, you choose a duration, environment, and optional goal. Local AI then creates a printable one-page walking card with observation prompts, small activities, questions, and a drawing prompt.

You print the card, leave your phone behind, and go for the walk.

When you come back, you can photograph your completed card and upload it to Paperwalk. Local Gemma vision interprets what you noticed and uses those observations to generate a new, adapted walking card.

The loop is:

Choose → Generate → Print → Walk → Observe → Return → Upload → Adapt

The screen is intentionally the shortest part of the experience.

Paperwalk is for anyone who wants a little structure and curiosity during a walk without turning the walk itself into another screen-based activity.

The core idea is:

AI designs the experience. Then it gets out of the way.

Demo

🎥 Video Demo

paperwalk_demo.mp4 - Google Drive

drive.google.com

The demo is a visual walkthrough of Paperwalk's core flow:

Home → Card #1 → I'm Back → Local AI interpretation → Adapted Card #2

The shown completed walking card is a sample input used to demonstrate the adaptation flow.

Screenshots

The application includes:

• A simple setup screen for creating a walk
• A printable A4 walking card
• A dedicated "I'm Back" flow for uploading the completed card
• Local AI interpretation
• A personalized second walking card

Code

GitHub repository:

Garg-Pankaj29 / Paperwalk

Use this: **“An offline-first AI walking experience that turns local observations into personalized printable walk cards.”**

Paperwalk

A local-first outdoor experience generator. Local open-weight AI creates a printable physical walking card, you leave your phone behind, walk outside, and return with a handwritten card that adapts your next journey.

---

Concept

Most modern AI products center the screen: they keep users typing, chatting, and scrolling. Paperwalk inverts this relationship:

"AI designs the experience, then gets out of the way."

A user opens Paperwalk on a laptop, sets how much time they have (20, 40, or 60 minutes), selects an environment (Park, Campus, or Neighborhood), and optionally inputs a personal goal.

A local Gemma model generates a tailored, one-page field card rendered directly as a printable A4 sheet. The user prints the card, leaves their phone at home, and heads outdoors with only a pen.

While walking, the user records physical observations, sketches a small discovery, circles sensory reflections, and notes future intentions. Upon returning, they upload a…

View on GitHub

The project is open source and contains the complete application, prompts, local AI integration, fallback logic, and setup instructions.

How I Built It

Paperwalk is built around Google's open-weight Gemma model, running locally through LM Studio.

Stack

• Python
• FastAPI
• Jinja2
• HTML/CSS/JavaScript
• Pydantic
• HTTPX
• LM Studio
• Google Gemma 3 4B
• Local JSON state storage

There is no cloud AI API in the core experience.

Card #1 — Generate a Walk

The user provides a few simple inputs such as:

• Duration
• Environment
• Optional goal

Those inputs are sent to the local Gemma model with a structured prompt.

Gemma returns structured JSON containing the walking mission, observation questions, drawing prompt, reflection prompt, and other activities.

Pydantic validates the response before it becomes a printable card.

The Physical Part

The generated card is designed as an A4 printable sheet.

The user takes the card outside, puts the phone away, and uses the physical sheet to record what they notice.

This is an important part of the design.

Paperwalk isn't trying to make the outdoor experience more interactive on a screen.

It is trying to make the screen unnecessary.

Card #2 — AI Learns From the Walk

After returning, the user photographs their completed card and uploads it.

The image is sent to the local Gemma vision model.

Gemma extracts structured observations such as:

• What the person noticed
• What surprised them
• What they almost missed
• What they drew
• Their reflection
• Possible interests or preferences

Those observations are then passed into another prompt that generates the next walking card.

So Card #2 isn't just another random activity.

It is based on what happened during the previous walk.

For example, if someone notices walls, cracks, textures, plants, or small details during their first walk, the next card can shift the activity toward those observations.

Local-First Architecture

The basic architecture is intentionally small:

text
              ┌──────────────────┐
              │   Paperwalk UI   │
              └────────┬─────────┘
                       │
                       ▼
              ┌──────────────────┐
              │     FastAPI      │
              └────────┬─────────┘
                       │
             ┌─────────┴─────────┐
             ▼                   ▼
      ┌─────────────┐     ┌─────────────┐
      │ Card Prompt │     │ Vision Prompt│
      └──────┬──────┘     └──────┬──────┘
             │                   │
             └─────────┬─────────┘
                       ▼
                ┌─────────────┐
                │ Local Gemma │
                │  via LM     │
                │   Studio    │
                └──────┬──────┘
                       │
                       ▼
              ┌──────────────────┐
              │ Adapted Card #2  │
              └──────────────────┘