DEV Community

Amit Kumar Giri
Amit Kumar Giri

Posted on

WalkBacker: The Screen-Minimal Offline AI Expedition Companion (Built for 8GB RAM)

#devchallenge #hf26challenge

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

important links:

  1. video demo: https://drive.google.com/file/d/1Q9DcxFgvWjxu944TGvoQXwo7UzVjT9va/view?usp=sharing
  2. code repo: https://github.com/yellowamit/walkbacker-hacktober

What I Built

Most modern outdoor and trail apps ironically do the exact opposite of getting you into nature. They demand constant attention: staring at glowing blue GPS pins on a map, checking pace zones, waiting for cellular data in deep valleys, and doom-scrolling notifications while standing underneath a majestic autumn forest canopy.

WalkBacker flips this paradigm completely with the 60-Second Screen Rule.

WalkBacker is an offline-first, screen-minimal outdoor AI expedition agent and trail companion. It is engineered from the ground up to run smoothly on modest hardware (tested and capped under 1.0 GB RAM for 8GB laptops/phones), requiring zero internet connectivity and sending zero location data to commercial servers.

How It Works:

  1. 60 Seconds at the Trailhead: You input your available time (e.g. 20, 45, or 60 minutes), pick a nature vibe (Autumn Foliage & Canopy Hunt, Trailside Acoustic Birding, Urban Greenway, or Twilight Horizon), and hit Generate.
  2. Chain of Thought (CoT) Outdoor Reasoning: The local AI engine executes a 4-stage Chain of Thought reasoning sequence:
    • Stage 1 (Environmental & Solar Physics): Calculates solar elevation, civil twilight, and maximum safe walking radius based on local daylight without any external API calls.
    • Stage 2 (Tactile Touch-Grass Missions): Formulates three physical, sensory grounding challenges designed to break screen fixation (e.g., examining leaf venation, touching smooth beech bark vs furrowed oak bark, closing eyes for 60 seconds to isolate bird song).
    • Stage 3 (Navigation & Turnaround Math): Calculates the exact outbound turnaround time ($T_{\text{outbound}} = \frac{T_{\text{total}}}{2} \times 0.85$) and computes the reverse compass return heading.
    • Stage 4 (Screen-Minimization Protocol): Synthesizes a compact 30-second Pocket Field Card and speaks audio cues via native offline Web Speech synthesis.
  3. Pocket Mode & Safe WalkBack: You put your device into your pocket with earbuds in. At the turnaround deadline, a gentle two-tone chime and voice alert notify you to turn around. If you ever wander off-trail, the WalkBacker Compass points directly to your starting base with real-time distance and reverse azimuth.
  4. Offline Trail Lens: If you spot an unknown autumn leaf, mushroom bracket, or bird on the trail, WalkBacker's lightweight offline nature key identifies the species instantly—even in airplane mode.
  5. Open Standards Export: Generates 1-click GPX and GeoJSON files compatible with OsmAnd, Organic Maps, Garmin, and QGIS.

Demo

  • video demo: https://drive.google.com/file/d/1Q9DcxFgvWjxu944TGvoQXwo7UzVjT9va/view?usp=sharing
  • Local Web Interface: Running on http://127.0.0.1:8000
  • Outdoor High-Contrast Design: Optimized for harsh sunlight legibility, with an ultra-minimalist dark Pocket Mode overlay for maximum battery savings.
  • Audio Cue Engine: Hands-free offline voice guidance and turnaround chime so your eyes and hands remain on the trail.

Code

The project is structured cleanly into an open-source Python FastAPI backend and lightweight vanilla frontend:
code repo : https://github.com/yellowamit/walkbacker-hacktober

walkbacker-hacktober/
├── backend/
│   ├── main.py              # FastAPI server & static delivery
│   ├── agent/
│   │   ├── cot_reasoner.py  # 4-Stage Chain of Thought outdoor reasoner
│   │   ├── model_loader.py  # RAM-safety guardrails for 8GB devices
│   │   └── prompts.py       # CoT prompt templates & sensory vibe catalog
│   ├── nature/
│   │   ├── identifier.py    # Offline trait classifier & morphological matcher
│   │   └── taxonomy_db.py   # Curated autumn flora, fungi & songbird database
│   └── navigation/
│       ├── breadcrumb.py    # Haversine distance, dead reckoning & solar equations
│       └── gpx_exporter.py  # Open GPX / GeoJSON exporter
├── frontend/                # High-contrast, sunlight-readable UI
│   ├── index.html
│   ├── css/style.css
│   └── js/ (app.js, compass.js, audio_cue.js)
└── tests/test_walkbacker.py # 9/9 automated unit tests
Enter fullscreen mode Exit fullscreen mode

How I Built It

1. Open-Source AI Architecture

WalkBacker is powered by open-weight AI and local inference:

  • Primary Neural Engine: Integrates open-weight language models from Hugging Face (HuggingFaceTB/SmolLM2-135M-Instruct and Qwen/Qwen2.5-0.5B-Instruct), delivering structured agentic planning in under 400MB of RAM.
  • Local Edge Zero-RAM Reasoner: In situations where memory is constrained or battery is low, WalkBacker provides a high-speed deterministic CoT engine that calculates solar azimuth, twilight boundaries, and ecological missions in < 2 milliseconds with ~85 MB total process RAM.
  • Local Memory Guardrails: Built with psutil telemetry to enforce a strict memory budget, ensuring the system never exceeds 1.0 GB RAM and protecting 8GB devices from paging or swapping.

2. Multi-Stage Chain of Thought (CoT) Pipeline

Rather than generating an opaque blob of text, the reasoning process is transparently organized into 4 stages:

  1. <thought_environment>: Astronomical solar calculations and daylight boundaries.
  2. <thought_sensory>: Tactile grounding tasks that pull optic and auditory focus outward.
  3. <thought_navigation>: Outbound time buffers and reverse azimuth math.
  4. <thought_screen_minimization>: Distilling instructions into an instant 30-second Pocket Field Card.

3. Pure On-Device Mathematics

  • Solar Position: Computes solar elevation and sunset without external APIs using astronomical equation approximations.
  • WalkBack Vector: Uses spherical trigonometry (Haversine & Forward Azimuth equations) to determine continuous return vectors back to trailhead origin.

Why Does Open Innovation Matter?

This project directly answers why open innovation and open-weight models matter over closed proprietary APIs:

  1. Cellular Dead Zones (Trails Have No Wi-Fi): Real nature trails, dense mountain forests, and national parks are notorious cellular dead zones. A closed API (OpenAI, Gemini API, Claude) fails instantly when you leave cell towers behind. WalkBacker’s open-weight models and local inference engine run 100% offline on a laptop or smartphone in airplane mode.
  2. Absolute Privacy of Location & Walking Habits: Your exact GPS tracks, walking pace, and nature spots should never be harvested, logged, or monetized by advertising clouds. Open-source local AI ensures your coordinates never leave your device.
  3. Respect for Low-Spec Hardware (8GB RAM): Closed corporate AI ecosystems often assume infinite cloud compute or heavyweight 16GB+ developer machines. By selecting open-weight edge models (SmolLM2 / Qwen) and implementing aggressive memory guardrails, WalkBacker runs comfortably on everyday 8GB RAM laptops with ~85 MB of active process memory.
  4. Zero Cost & Democratized Access: Touching grass should be free. There are no API keys, no subscription tiers, and no rate limits. Anyone with basic hardware can download, modify, and explore the outdoors safely.

My Agent Session

This project was developed with paired agentic programming using a continuous Chain of Thought context ledger (docs/CHAIN_OF_THOUGHT.md), retaining context across architectural choices, memory optimizations, and testing phases.

Prize Categories

  • Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass

Top comments (0)