TrailGemma - An Offline Nature Companion That Tells You to Put It Down

Joe George — Thu, 08 Oct 2026 14:06:00 +0000

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

What I Built

Most apps that claim to be for the outdoors quietly keep you staring at a screen. You open a hiking app and spend ten minutes planning. You pull out your phone every five minutes to check a map. You reach the summit and immediately start reviewing the route stats instead of looking around.

TrailGemma works the other way. The design goal was blunt: screen time under 60 seconds, then get out of the way.

It is a nature companion for hikers, trail runners, and backyard gardeners built around three things. First, a spoken field briefing — you tap one button, hear a 60-second narrated summary of your trail conditions and canopy status, and pocket your phone. Second, a frost and planting planner that gives you a specific garden action for today rather than a generic frost date chart. Third, a bird acoustic guide that tells you which species are likely vocalizing right now based on your elevation, time of day, and canopy density — so you know what to listen for after you stop looking at the screen.

The people this is for: trail runners who want route intel without pulling up seventeen apps, gardeners who want to know tonight whether to cover their peppers, birders who want to spend more time listening and less time searching databases.

Demo

The app runs locally on http://localhost:8000. Start with:

git clone https://github.com/joegeorge022/trailgemma
cd trailgemma
pip install fastapi uvicorn tabpfn torch pandas numpy httpx
ollama pull gemma2:2b
./scripts/run_demo.sh

The full pipeline in practice:

Select a trail on the map.
Tap Generate Field Briefing. TabPFN reads the trail's elevation, canopy composition, and accumulated chilling hours. Gemma 2 turns those numbers into a spoken paragraph. ElevenLabs (or native on-device speech if you're offline) reads it aloud.
Pocket the phone. Listen to the briefing. Walk.

A real output from the Sugarloaf Ridge trail at 580m elevation, 60% sugar maple canopy, 185 chilling hours accumulated:

"You're stepping into peak canopy — 78% vibrancy. The sugar maples above 500 meters are flaming scarlet right now, the birches lower down have gone gold. Watch for the white-throated sparrow rustling through fallen leaves at the trail edges, and listen for the pileated woodpecker's resonant drumming in the mature hemlocks to the north. There's a hard freeze coming within two days at this elevation, so if you have tender crops at home, harvest them tonight. Now pocket the phone."

TabPFN generated the numbers. Gemma 2 wrote the words. ElevenLabs read them aloud. The whole thing took under eight seconds to generate and runs entirely on a MacBook Pro with no internet required.

Code

trailgemma/
├── backend/
│   ├── app.py                  # FastAPI: routes and orchestration
│   ├── tabpfn_engine.py        # Prior Labs TabPFN inference engine
│   ├── gemma_client.py         # Gemma 2 via Ollama (local open-weight)
│   ├── elevenlabs_engine.py    # Audio synthesis, with offline fallback
│   ├── trails_data.py          # Trail GPS, canopy data, flora catalogs
│   └── datasets/               # Frost, foliage, and bird training contexts
├── frontend/
│   ├── index.html
│   ├── css/style.css
│   └── js/
│       ├── app.js              # Map, tabs, garden planner, pocket mode
│       ├── tabpfn_ui.js        # Probability distribution visualizers
│       └── audio_guide.js      # Audio tour player with waveform visualizer
└── scripts/
    └── run_demo.sh

The three main technical interactions:

TabPFN running frost risk classification:

from tabpfn import TabPFNClassifier

clf = TabPFNClassifier(device="cpu")
clf.fit(X_microclimate_train, y_frost_risk)

# Point prediction for a specific backyard
probs = clf.predict_proba(X_query)[0]
# → [p_safe: 0.05, p_light_frost: 0.20, p_hard_freeze: 0.75]

Gemma 2 generating the trail script:

async def generate_trail_audio_script(trail_name, foliage_data, bird_data, frost_data):
    prompt = f"""
    Write a 45-second spoken briefing for a hiker at {trail_name}.
    Canopy: {foliage_data['stage_name']}, {foliage_data['vibrancy_index']}% vibrancy.
    Likely birds: {[b['name'] for b in bird_data['top_species']]}.
    Night low: {frost_data['inputs']['avg_night_temp_c']}°C.
    End by telling them to pocket the phone.
    """
    return await ollama_client.generate(model="gemma2:2b", prompt=prompt)

FastAPI composing the full pipeline:

@app.post("/api/briefing/generate")
async def generate_briefing(req: BriefingRequest):
    foliage = tabpfn_engine.predict_foliage(...)
    birds   = tabpfn_engine.predict_birds(...)
    frost   = tabpfn_engine.predict_frost(...)
    script  = await gemma_client.generate_trail_audio_script(...)
    audio   = await audio_engine.generate_speech(script)
    return { "script": script, "audio": audio, "tabpfn_foliage": foliage }

How I Built It

The stack is three open models doing different jobs.

Prior Labs TabPFN handles the structured predictions. I needed to predict frost probability, foliage peak timing, and bird occurrence likelihood from tabular inputs: elevation, slope aspect, temperature, canopy composition, chilling hours. This is exactly the problem TabPFN was designed for. It performs Bayesian in-context learning on tabular data without hyperparameter tuning, training loops, or preprocessing pipelines. I fed it physics-informed synthetic datasets — frost pocket modeling from terrain physics, chilling degree accumulation curves, forest bird phenology by elevation band — and got calibrated probability distributions in under 150 milliseconds on CPU. A traditional ML approach would have required thousands of labeled samples, cross-validation, and manual feature engineering. TabPFN needed 180 rows and no tuning.

Google Gemma 2 (2B) handles language. The TabPFN outputs are numbers: a frost probability curve, a foliage vibrancy score, a ranked list of bird species. Gemma 2 translates them into spoken prose that a hiker can absorb in 45 seconds while putting on their pack. It runs locally via Ollama on Apple Silicon at reasonable latency. I used a system prompt that frames the model as a wilderness naturalist speaking directly to someone about to leave the trailhead — which keeps the output sensory and concrete rather than encyclopedic.

ElevenLabs converts the script to audio. When the API key is available, it uses a warm documentary voice. When the app is offline — which it often is on trails — it falls back to the browser's native speech synthesis API. The audio guide works with no network at all.

The frontend is a vanilla HTML/CSS/JS progressive web app with a service worker for offline caching. I deliberately avoided any framework. The app needs to load fast on a spotty connection at a trailhead parking lot, and there is no reason a nature companion needs a JavaScript build chain.

The garden planner uses the same TabPFN frost engine but exposes the inputs directly: elevation, slope aspect (south-facing slopes hold more solar heat), distance to water (lakes buffer night temperatures), canopy cover. This is the kind of microclimate reasoning that generic zip-code frost calendars completely ignore. A valley garden 200 feet below a south-facing hillside can freeze two full weeks earlier. TabPFN models that interaction from four numbers.

Why Does Open Innovation Matter?

The clearest reason: the app stops working if you replace any open component with a closed API.

When you're four miles into a national forest, you have no cell signal. OpenAI's API is unusable. Gemma 2 running on your device via Ollama is completely unaffected. The frost planner works because TabPFN runs on your CPU. The audio guide works because the Web Speech API runs in your browser. The trail map works because OpenStreetMap tiles are cached by the service worker. A closed-API version of this app would be a brick the moment you lost signal — which is precisely when you need it.

The privacy argument follows naturally. A garden planner that knows your exact GPS coordinates, your planting schedule, and your microclimate parameters is building a detailed picture of where you live and what you grow. With local inference, that data never leaves your machine. There is no server log. There is no training data opt-out to manage.

The cost argument matters for exploration. This app runs at zero marginal cost per query, indefinitely. I can simulate a thousand frost scenarios to model how a new raised bed will behave through October. I can generate a briefing for every trail in a county before a weekend trip and compare them. With a pay-per-token API, that kind of open-ended exploration becomes self-limiting.

But the most technically interesting reason is about what TabPFN specifically makes possible that closed LLMs cannot. Ask any frontier language model to predict frost risk from elevation, slope aspect, and temperature data and it will confidently hallucinate a number. TabPFN is a foundation model purpose-built for tabular prediction — it produces calibrated uncertainty distributions, not confident guesses. The combination of a language model for prose and a tabular foundation model for structured environmental reasoning is more capable than either alone. Open licensing made it possible to combine them without negotiating API contracts or worrying about which company owns what.

Prize Categories

Best Use of Gemma — Google Gemma 2 (gemma2:2b) runs locally via Ollama as the naturalist field guide writer and Q&A engine. No cloud dependency, no API key required.

Best Use of TabPFN — Prior Labs TabPFN v9.1 (TabPFNClassifier and TabPFNRegressor) runs three distinct prediction tasks: frost microclimate risk classification, canopy phenology stage regression, and bird occurrence probability ranking.

Best Use of ElevenLabs — Converts Gemma's trail scripts to spoken audio for hands-free hiking, with a graceful offline fallback to on-device Web Speech API when the API is unavailable.