Walkguide Studio: Local Gemma Tours for Independent Guides

# devchallenge# hf26challenge# gemma# opensource
Walkguide Studio: Local Gemma Tours for Independent GuidesIsha Vishwakarma

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle ...

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

What I Built

  • Problem: Walking-tour guides know the stories behind their stops, but turning those stories into a self-guided product takes time: organizing notes, writing narration, checking facts, preparing audio, and packaging the route.
  • Solution: Walkguide Studio turns an operator’s route notes into a self-guided walking tour. The operator enters each stop’s name, coordinates, and facts. Gemma drafts narration from those notes, and Walkguide checks the narration for unsupported names and numbers.
  • Output: A map, transcripts, optional audio, and an offline tour ZIP.
  • Who it’s for: Independent walking-tour operators and small local museums that want a self-guided option without commissioning a custom app.
  • Who might pay: An operator could sell a tour ZIP or bundle it with an existing tour, booking, or visitor experience.
  • Current limitation: Walkguide creates and packages tours; it does not handle payments or host a storefront. I haven’t tested willingness to pay with an outside operator, so the customer and pricing assumptions still need validation.
  • Grounding: The operator’s notes are the source of truth. If narration includes unsupported details, Walkguide reports the rejection instead of packaging it as a finished tour.

Demo

Code

GitHub logo ishavishwakarma29 / WalkguideStudio

Walkguide Studio

Built during Hacktoberfest Week 2 for the DEV Open-Source AI Challenge: Side Hustle.

Demo

Watch the Walkguide demo

Click the thumbnail to watch the video.

Walkguide Studio helps an independent walking-tour operator turn their own stop notes into a self-guided tour package. The operator enters the route and their local knowledge once; Gemma, running on the operator's computer through Ollama, drafts a short narration for each stop. A grounding check rejects unsupported names and numbers. The result is a static tour with a route map, transcripts, optional audio, and an offline ZIP that the operator can share or sell through their existing channel.

The main product flow is built around open-weight AI: Studio requires a local Gemma model before it can create a package. There is no hosted model API in the path and no per-narration API charge. The original command line tools remain available for automation and for the separate…

View on GitHub

How I Built It

  • Language: Python 3.9+, using only the standard library.
  • Local AI: Gemma 3 (1B) runs on the operator’s computer through Ollama.
  • Narration: Gemma drafts each stop’s narration from the operator’s notes.
  • Validation: Walkguide checks generated names and numbers against those notes.
  • Packaging: The app creates a map, transcripts, optional audio, and a static ZIP that visitors can open offline.

To run the Studio:

ollama pull gemma3:1b
python studio.py
Enter fullscreen mode Exit fullscreen mode

A failure shaped the design: Gemma sometimes returned generic introductions or echoed a stop heading, causing the grounding check to reject its narration. I tightened the prompt, cleaned up echoed headings, and made the Studio show why the guard rejected a draft. Unsupported narration is still blocked rather than quietly packaged as a finished tour.

Why Does Open Innovation Matter?

  • Lower usage costs: Local Gemma avoids a hosted-model API charge for each narration. The operator still needs hardware capable of running the model.
  • Local processing: The Studio sends narration requests to Ollama on the operator’s computer rather than to a hosted model API.
  • Adaptability: Operators can inspect and modify the prompts and validation code for their neighborhood, language, and editorial standards.

Open-weight AI makes it practical to experiment with a specialized tour product without first building around a closed provider’s API and pricing. The trade-off is that operators need a capable computer and detailed source notes; incomplete notes may lead to rejected narration.

My Agent Session

Walkguide Studio: Full Build Journey from Specification to Demo
You

Build a stdlib-only Python 3.9+ project called "walkguide" (no pip dependencies; optional external tools:
Ollama for a local Gemma model, Piper for offline TTS). It has two products that share code:

A) WALK GUIDE: an offline-first audio guide that narrates places near you while you walk.
B) TOUR PACK: for small tour operators; turns their stop list + notes into an offline, narrated, self-guided
tour (a static folder: index.html + audio files).

FILES
- sources.py: haversine, bearing, compass(deg)->"north-east" etc. Fetch POIs from OpenStreetMap Overpass
(two endpoint fallbacks; query named historic / tourism(museum|artwork|attraction|viewpoint|gallery) /
leisure(park|garden|nature_reserve) / place_of_worship / natural(peak|water|spring|wood) plus trees with
species; "out center tags 80") and Wikipedia geosearch (generator=geosearch, extracts+coordinates, intro,
plaintext, 4 sentences). Convert OSM tags to plain English sentences ("It is a church.", "It dates from
1890."). Skip OSM places with fewer than 2 facts. Merge by case-insensitive name (Wikipedia wins, add up
to 3 OSM facts). Cache per 0.01-degree cell (~1.1 km, fetch radius 800 m around the cell centre) as JSON
files; only cache when BOTH sources succeeded. Support offline mode (cache only).
nearby(lat, lon, cache_dir, offline, max_dist) returns POIs with dist and bearing, sorted by distance.
- narrator.py: build a prompt (Place, Location, up to 8 "Fact:" lines) and call Ollama /api/chat
(stream false, temperature 0.4, num_predict 140, default model gemma3:1b). Accept a custom system prompt
and max sentence count. GROUNDING GUARD: reject output if any number is not in the source text (name +
location + facts), or if any capitalised word that is not the first word of a sentence is not in the
source (allow "I" and compass words). On rejection retry once at temperature 0.1, then fall back to a
deterministic template built from the facts. Strip markdown, trim to N sentences. Return (text, meta)
with meta = {source: "llm"|"template", attempts, rejected: [...], latency_s}. Never crash if Ollama is down.
- speak.py: make_speaker(piper_model) returns a blocking speak(text) using, in order: Piper (+ aplay/
afplay/paplay/ffplay), termux-tts-speak, macOS say, espeak-ng/espeak, Windows System.Speech; None if
nothing is found. synth(text, base_path, piper_model) writes <base>.wav (Piper, say -o ... --data-format=
LEI16@22050, or espeak -w), converts to .mp3 if ffmpeg exists, returns the path or None.
- app.py (walk loop; CLI via argparse): location sources: --lat/--lon (fixed, 3 ticks), --walk
"lat,lon;lat,lon" (interpolated every 20 m), --gpx file, --termux (termux-location JSON, retry every 5 s
on failure). Flags: --model, --ollama-host, --piper-model, --trigger 60 (m), --cooldown 15, --tick 2,
--offline, --prefetch (cache 3x3 cells then exit), --no-speak, --reset. Each tick: track heading from
movement >5 m, find unvisited POIs within the trigger distance, pick the best by richness (fact length,
+2 for Wikipedia) minus dist/40, describe position as "about 40 metres ahead of you / on your left /
behind you / on your right" (or a compass direction when heading is unknown), narrate, speak, persist
visited IDs, append to metrics.jsonl, honour the cooldown. Simulated walks use a virtual clock at
1.4 m/s; --termux uses the wall clock. Print a summary on exit (narrations, model vs template,
guard rejections, mean latency) and save walks/walk-<timestamp>.json + .html.
- summary.py: build_html(walk) makes a self-contained Strava-style HTML page: SVG route map (equirectangular
projection fitted to the box, start green, end red, numbered pins for narrated places), stats (distance,
time, pace, places, avg model latency, guard rejections), a narration timeline (elapsed time, place,
position, sentence, badge "model name" or "template fallback", guard blocks). Light/dark via
prefers-color-scheme, mobile responsive, no external resources. Also --demo (fictional sample data)
and summary.py walks/x.json.
- tourpack.py: input JSON {title, operator, stops:[{name, lat, lon, notes}]}. For each stop: split the
operator's notes into sentences (FIRST and highest priority), optionally add up to 3 OSM/Wikipedia facts
when the name clearly matches or a Wikipedia POI is within 40 m (--no-enrich disables), location text
"Stop i of N", narrate with a tour-guide system prompt (3-5 short spoken sentences, use ONLY the facts,
start by saying which stop this is), then synth audio. Output tours/<slug>/index.html, audio/, and
build_report.json (per-stop source, latency, rejections, audio yes/no). index.html is ONE static file with
the tour data embedded (escape "</"): SVG map with dashed route + numbered pins (current / played
states), tap-to-play stops with transcript text, an <audio> element, an "Auto-play when I arrive"
checkbox using navigator.geolocation.watchPosition (arrival radius 40 m, play each stop once, don't
interrupt playback, needs HTTPS), a blue "you" dot, and a fallback to speechSynthesis when a stop has
no audio file. Light/dark, mobile-first, no external resources.
- tests.py: plain-assert offline tests (guard accepts grounded text and rejects invented numbers/names,
template fallback works with no model, model-offline falls back, walk interpolation, where() phrasing,
offline cache round-trip).
- sample_tour.json (clearly FICTIONAL stops) and README.md (setup for Ollama/Piper/Termux, all commands).

RULES
- Stdlib only. Never crash on network failure: print a short notice and degrade gracefully.
- Every sentence spoken must pass the grounding guard or be replaced by the template.
- Do not invent facts about real places in any sample data; label samples as fictional.
- After writing, run tests.py, run python3 tourpack.py sample_tour.json --model "" --no-enrich, syntax-check
the player's JavaScript, and fix anything that fails. Report what you could not test (live network, Ollama,
real TTS, browser rendering).

Agent

walkguide is ready

The project is in outputs. It includes the walking guide, offline place cache, grounded narrator, optional speech adapters, self-contained walk summaries, static tour builder, tests, and setup instructions.

The sample tour was generated at index.html; its build report is build_report.json. Start with the README.

Verification: tests.py passed, the requested sample tour command completed, all Python modules compiled, and the tour player JavaScript passed node --check. The Windows python3 launcher was unavailable, so I ran the checks with the installed Python 3.13 python command. Live network lookups, Ollama, real TTS, and browser rendering were not tested.

A possible DEV Challenge angle is Hacktoberfest Week 2’s Side Hustle theme, whose listed deadline is October 19; the project would need open source AI to be central to its use to be a clear fit. I can draft a DEV post about the build if you’d like.

🌐 Community Wisdom

The DEV research was limited to two adjacent posts. One describes building a zero dependency Python CLI and its tradeoffs; the other stresses durable local storage and controlled retries for offline resilience. Neither directly evaluates this project’s geospatial or narration design.

Zero Dependencies, Zero Regressions: What It Took to Build CLI-KDG from Scratch

Source: Pravin Kumar

Tags: cli, python, softwareengineering, testing

The author describes replacing common CLI and testing packages with Python’s standard library, including explicit JSON persistence and dependency auditing. This supports the stdlib-only constraint, though the article covers a different tool.

🔗 Read Full Discussion

Designing an Offline-Resilient MQTT Buffer with SQLite

Source: Kaustubh Alandkar

Tags: mqtt, python, systemdesign

The author emphasizes persisting data before relying on a downstream service, and making retry behavior explicit. That reinforces treating cache writes and graceful network failure as core behavior; the post’s SQLite buffer is a different use case.

🔗 Read Full Discussion

You

how to record a demo for this

Agent

For a quick demo, record a screen capture of the sample tour. It works without network access, Ollama, or audio hardware.

  1. Open outputs/tours/the-imaginary-lantern-walk/index.html in a browser.
  2. Start recording your screen with the built-in recorder:
    • Windows: press Win + Alt + R (Xbox Game Bar).
    • macOS: press Shift + Command + 5, then choose Record.
  3. Show the tour map and stops, tap Play on a stop, and show the transcript and playback controls.
  4. To demonstrate arrival playback, check Auto-play when I arrive on an HTTPS-hosted copy and allow location access. The sample stops are fictional and far from your location, so that feature won’t trigger with the sample tour.
  5. Stop recording and save the video.

For a demo of the walking guide itself, run a simulated route with python app.py --walk "lat,lon;lat,lon" --offline --no-speak, using coordinates from a cached area. You can prefetch an area first with python app.py --lat LAT --lon LON --prefetch while online.

You

give complete path its not opening

Agent

The complete path to the sample tour is:

[local path]

Copy that into File Explorer’s address bar and press Enter.

You

i dont understand what i have to do in thiss and how is open source used

Agent

walkguide has two parts:

  • Tour Pack turns a tour operator’s list of stops and notes into a web page people can open and follow.
  • Walk Guide can find nearby places and narrate them while you walk.

The sample tour is fictional, so it’s just a demonstration. Open this file in a browser:

[local path]

You’ll see a map and three sample stops. Click Play to hear a stop if your browser supports speech synthesis; otherwise, read its transcript.

How open source is used: the project itself is code you can inspect and change. It also can use the open-weight Gemma model through Ollama to write narrations locally. That’s optional: without Ollama, it uses simple templates based on the supplied facts. The sample tour was built with the model turned off, so it demonstrates the template fallback—not Gemma.

To try Gemma, install Ollama, download the gemma3:1b model, start Ollama, then build a tour with:

python tourpack.py sample_tour.json --model gemma3:1b --no-enrich

The tour’s notes remain the narration’s facts; the model turns those facts into spoken sentences. The open-weight model runs on your computer rather than requiring a paid model API.

You

https://dev.to/devteam/join-the-hacktoberfest-open-source-ai-challenge-side-hustle-2550-in-prizes-across-18-winners-55ba?bb=264692 i am building it for this so build accordingly considering it should be worth winning

Agent

I reshaped Walkguide around one customer: independent tour operators who want to turn their own local knowledge into offline tours they can share or sell. The new local Studio guides them through entering stops and notes, using Gemma locally to draft grounded narration, previewing the tour, and downloading a ZIP for customers. Gemma is required in that Studio flow; the template fallback remains available in the CLI tools.

To try it: install Ollama, then in PowerShell run:

cd "[local path]"
ollama pull gemma3:1b
python studio.py

Studio opens at http://[REDACTED]:8765. Replace the clearly fictional sample stops with real operator notes and coordinates, then create, preview, and download the tour. Setup details are in the README.

Important for the challenge: the page says Week 2 submissions are due October 18 at 11:59 PM PDT—about 15½ hours from now in India—and that open-weight AI must be central. It also says writing quality carries the most weight and encourages showing a real user’s feedback. Challenge details

The checks passed: offline assertions, sample tour generation, Python compilation, and JavaScript syntax checks. Ollama isn’t installed on this computer, so I couldn’t verify a real Gemma narration. The sandbox also blocked local browser connections, so I couldn’t visually verify Studio running. Before submitting, run it with Gemma, record the real workflow, and—if possible—have one tour operator try it. Don’t present the fictional sample as a real tour or claim customer validation you haven’t done.

You

i get oolama is not recognized

Agent

It sounds like Ollama isn’t installed yet. On Windows, download and run the installer from Ollama’s official download page, then close and reopen PowerShell. The installer adds the ollama command; reopening PowerShell lets it find it. (Official Windows download)

Then run these commands one at a time:

ollama --version
ollama pull gemma3:1b
cd "[local path]"
python studio.py

If the first command still says “not recognized,” restart your computer and try it again.

You

its working now how to record demo

Agent

Here’s a simple demo flow:

  1. Open Walkguide Studio in your browser and make sure the green Ready status appears.
  2. Replace the fictional sample with a short tour you know is accurate. Keep 2–3 stops so the demo stays brief.
  3. Press Win + Alt + R to start recording.
  4. Click Create Gemma tour. Show the finished preview, play a stop, then show the Download tour ZIP link.
  5. Press Win + Alt + R again to stop. The MP4 should be in Videos → Captures. (Microsoft’s Game Bar recording instructions)

You can narrate: “I’m a small tour operator. I add my own notes, Gemma runs locally to turn them into a grounded audio guide, and I download a tour I can share with visitors.”

If Game Bar doesn’t start, press Win + G and enable recording, or open Snipping Tool and choose Record. (Microsoft’s recording options for Windows)

You

give me tour around banglore

Agent

I’ve set Studio’s default route to Bengaluru: Green Spaces & Granite. Restart Studio so the updated stops appear: in the PowerShell window running it, press Ctrl+C, then run:

cd "[local path]"
python studio.py

Refresh the Studio page. It will be prefilled with this short central Bengaluru route:

  1. Cubbon Park — established in 1870 by John Meade; its landscape was conceived by Richard Sankey. Government of Karnataka
  2. Vidhana Soudha — Karnataka’s Legislature and Secretariat; completed in 1956 and built largely with Bangalore granite. Karnataka Legislature
  3. Attara Kacheri — home of the Karnataka High Court, described by the district tourism site as a red brick and stone building in the Graeco-Roman style. Bengaluru Urban district

Wait for Gemma’s status to show Ready, then click Create Gemma tour. The pins are approximate outdoor viewpoints, and the map’s connecting line is not pedestrian turn-by-turn directions—check local access and walking paths before visiting.

I also saved the tour data in bengaluru_demo_tour.json and the source and coordinate notes. The JSON and Python checks passed.

You

Gemma did not produce any grounded narration. No tour ZIP was offered; revise the notes and try again. i am getting this

Agent

Your notes are fine. The saved report shows Gemma’s formatting—such as “Stop 1 of 3: Welcome…”—was tripping the grounding check.

I’ve updated the code to normalize that stop heading and tighten the prompt. Restart Studio so it loads the fix:

  1. In the PowerShell window running Studio, press Ctrl+C.
  2. Run python studio.py again.
  3. Refresh the Studio page, wait for Gemma to show Ready, and click Create Gemma tour again.

If it still fails, the updated error should include the guard blocks. The full report is at [local path].

The offline tests and the specific stop-heading guard check pass. I couldn’t call your local Ollama service from this sandbox, so please retry in your running Studio.

You

is it now safe to add on git with proper readme and stuff ? also https://youtu.be/NbL-dx2ZQpA embed this video in readme and also mention that its builr in hacktoberfest week2

Agent

The project files look safe to put in a public Git repository, and I updated the README with the demo video and the Hacktoberfest Week 2 credit. I also added a .gitignore to keep generated tours, local walk data, Python cache files, and speech model files out of Git.

One catch: this outputs folder is not currently a Git repository, so nothing has been added or committed yet. Open this folder in your terminal to start:

cd "[local path]"

If you want, I can help you connect it to a new GitHub repository next.

You

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

What I Built

<!-- What does it do, and who would pay for it? What problem does it solve for them? -->

Demo

<!-- Share a deployed link or a video demo. -->

Code

<!-- Show us the code! You can embed a GitHub repo directly into your post. -->

How I Built It

<!-- Which open-source AI did you use (open-weight models, agent harnesses, frameworks, local inference), and how is your project built around it? -->

Why Does Open Innovation Matter?

<!-- Why does open innovation matter for what you built? What did it make possible that a closed API wouldn't? -->

My Agent Session

<!-- Optional, but judges love it. Save your session with DevRelay and embed it with the agent_session tag (see the challenge page), or link to it. -->

My First User

<!-- Optional, but this is where bonus points live. Did someone use it? Who were they, what did they say, and did they pay? If not, remove this section. -->

Prize Categories

<!-- Which partner categories are you entering? List every one that applies, or remove this section. -->

<!-- Team Submissions: Please pick one member to publish the submission and credit teammates by listing their DEV usernames directly in the body of the post. -->

<!-- Thanks for participating! --> fill this template too for me

Agent

I saved the completed post as a DEV draft: Open and edit it on DEV.

Before publishing: replace the GitHub placeholder with your public repository URL. Your project folder isn’t a GitHub repository yet, so the draft says that plainly. I left out the optional “My First User” and “My Agent Session” sections because we don’t have real user feedback or a session link to include. The draft is marked as AI-assisted (some_ai).

The Week 2 deadline is October 19 at 12:29 PM IST. The draft has the required hf26challenge tag and lists “Best Use of Gemma.” Challenge details

Walkguide Studio: Local Gemma Tours for Independent Guides

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

What I Built

Walkguide Studio turns a local tour operator's own notes into a self-guided walking tour. The operator enters stops, coordinates, and facts; Gemma drafts short narration grounded in those notes. Walkguide checks the generated text for unsupported names and numbers, then packages a map, transcripts, optional audio, and an offline tour ZIP.

The intended customer is an independent walking-tour guide, museum, or neighborhood business that wants to offer a self-guided tour without commissioning a custom app or paying for a hosted AI call for every narration. They could sell or bundle the tour ZIP with their existing booking or visitor experience. Walkguide does not handle payments, and I have not yet validated willingness to pay with an operator—this is the customer problem I built toward.

Demo

Code

GitHub repository: [Add the public repository URL here before publishing.]

The project is currently in my local folder, so there is no public repository URL to share yet.

How I Built It

Walkguide is written in Python 3.9+ using the standard library. The Studio UI and local server are built into the project. It calls Gemma 3 (1B) through Ollama on the operator's computer; the app does not send tour notes to a hosted model API. The operator's notes are the grounding source. A validation step rejects narration that introduces unsupported names or numbers, and the generated tour is a static package that can be opened offline.

One failure shaped the implementation: Gemma sometimes returned generic introductions or echoed stop headings instead of starting with grounded narration. I tightened the prompt and normalized echoed headings, while keeping the grounding check as a hard stop. If the model still cannot produce grounded narration, the build reports the rejection instead of quietly presenting it as a successful tour.

Why Does Open Innovation Matter?

The local, open-weight model is part of the product's business case. A small tour operator can run narration generation on their own computer, keep their route notes in that local workflow, and avoid a hosted-model charge for each tour. They can also inspect and adapt the generation and validation code for local history, languages, and operating constraints. That makes it possible to experiment with a niche tour product without first committing customer data or the business model to a closed API provider.

Prize Categories

  • Best Use of Gemma
You

https://github.com/ishavishwakarma29/WalkguideStudio add this repo and also add the dev relay session also the points are not mentioned such that it describes problem and emphasises solution properly. writing carries most weight in judging

Agent

Updated the existing DEV draft with your GitHub repository, embedded a new DevRelay session, and rewrote the post to make the operator’s problem, Walkguide’s solution, and the unvalidated customer assumptions clearer.

Open the updated DEV draft. It remains unpublished for your review and is marked AI-assisted.

You

its not updated yet

Agent

I checked DEV’s saved draft: it does contain the GitHub link, the DevRelay session embed, and the revised sections. It’s still unpublished, so the public post won’t show those edits yet.

Open the draft editor and refresh the page. If you were looking at the public post, switch to the draft editor instead.

You

no when i copy and open this link it doesnt show

Agent

I found the issue: the link opens DEV’s sign-in page because you aren’t signed in there in this browser. The draft is saved, but you’ll need to sign into the DEV account Isha Vishwakarma (ishavishwakarma29) to see its editor.

The DEV sign-in page is open in the in-app browser. After signing in, open the draft editor again.

You

even in signed in tab in chrome its not showing

Agent

Sorry—I was too certain that signing into Chrome would make that link work. I can verify DevRelay saved the draft under ishavishwakarma29, but I can’t see which DEV account Chrome is signed into.

In Chrome, open your DEV dashboard, choose Drafts, and look for “Walkguide Studio: Local Gemma Tours for Independent Guides.” DEV says drafts are available from your dashboard. DEV Help: Writing, Editing and Scheduling

Check that your profile handle is ishavishwakarma29. If the draft still isn’t listed under that account, tell me what you see on the Drafts page—or share a screenshot—and I’ll help fix the mismatch.

You

got it now, write up is not nice, it should be point by point with bold etc to emphasize give me markdown here only

Agent

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

What I Built

The problem: A walking-tour guide may know the stories behind every stop, but turning that knowledge into a self-guided product takes extra work: shaping notes into short narrations, checking facts, preparing audio, and packaging everything for visitors.

The solution: Walkguide Studio turns an operator’s own route notes into a self-guided walking tour. The operator adds stops, coordinates, and facts. Gemma drafts the narration from those notes, and Walkguide checks it for unsupported names and numbers before packaging a map, transcripts, optional audio, and an offline ZIP.

Who could pay: Independent walking-tour operators and small local museums that want to offer a self-guided option without commissioning a custom app. They could sell or bundle a tour ZIP with an existing tour or visitor experience.

What’s built today: Walkguide creates and packages tours; it does not process payments or host a storefront. I haven’t yet tested willingness to pay with an outside operator, so the customer and pricing assumptions still need validation.

The design principle: Grounding is a gate. If the narration includes unsupported details, Walkguide reports the failure instead of offering an ungrounded tour ZIP as ready.

Demo

Code

WalkguideStudio on GitHub

How I Built It

  • Language: Python 3.9+, using only the standard library.
  • Local AI: Gemma 3 (1B) runs through Ollama on the operator’s computer.
  • Grounding: The operator’s notes are the source for each stop’s narration. A validation step checks generated names and numbers against those notes.
  • Output: Walkguide packages a map and transcripts into a static tour ZIP that visitors can open offline. Audio is optional.

To run the Studio:

ollama pull gemma3:1b
python studio.py

A failure shaped the design: Gemma sometimes returned generic introductions or repeated a stop heading, causing the grounding check to reject the narration. I tightened the prompt, cleaned up echoed headings, and made the Studio show the guard’s reasons. The check still blocks unsupported narration instead of quietly weakening the factual standard.

Why Does Open Innovation Matter?

  • Lower per-tour AI costs: Local inference avoids a hosted-model API charge for every narration. The operator still needs hardware capable of running Gemma.
  • More control over tour notes: The Studio sends narration requests to Ollama running locally; it does not send those notes to a hosted model API.
  • Room to adapt: Operators can inspect and modify the project’s prompts and validation code for their neighborhood, language, and editorial standards.

Open-weight AI makes it practical to experiment with a small, specialized tour product without building around a closed model provider’s API and pricing. The trade-off is that operators need a capable computer and good source notes; incomplete notes may lead to rejected narration.

My Agent Session

{% agent_session building-walkguide-studio-with-local-gemma-uf8pxg %}

Prize Categories

  • Best Use of Gemma
You

in markdown here

Agent 
*This is a submission for the [Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle](https://dev.to/challenges/hacktoberfest-week2-2026-10-12)*

## What I Built

**The problem:** A walking-tour guide may know the stories behind every stop, but turning that knowledge into a self-guided product takes extra work: shaping notes into short narrations, checking facts, preparing audio, and packaging everything for visitors.

**The solution:** Walkguide Studio turns an operator’s own route notes into a self-guided walking tour. The operator adds stops, coordinates, and facts. **Gemma drafts the narration from those notes**, and Walkguide checks it for unsupported names and numbers before packaging a map, transcripts, optional audio, and an offline ZIP.

**Who could pay:** Independent walking-tour operators and small local museums that want to offer a self-guided option without commissioning a custom app. They could sell or bundle a tour ZIP with an existing tour or visitor experience.

**What’s built today:** Walkguide creates and packages tours; **it does not process payments or host a storefront**. I haven’t yet tested willingness to pay with an outside operator, so the customer and pricing assumptions still need validation.

**The design principle:** Grounding is a gate. If the narration includes unsupported details, Walkguide reports the failure instead of offering an ungrounded tour ZIP as ready.

## Demo

[![Watch the Walkguide demo](https://img.youtube.com/vi/NbL-dx2ZQpA/hqdefault.jpg)](https://youtu.be/NbL-dx2ZQpA)

## Code

[WalkguideStudio on GitHub](https://github.com/ishavishwakarma29/WalkguideStudio)

## How I Built It

- **Language:** Python 3.9+, using only the standard library.
- **Local AI:** Gemma 3 (1B) runs through Ollama on the operator’s computer.
- **Grounding:** The operator’s notes are the source for each stop’s narration. A validation step checks generated names and numbers against those notes.
- **Output:** Walkguide packages a map and transcripts into a static tour ZIP that visitors can open offline. Audio is optional.

To run the Studio:

```powershell
ollama pull gemma3:1b
python studio.py

A failure shaped the design: Gemma sometimes returned generic introductions or repeated a stop heading, causing the grounding check to reject the narration. I tightened the prompt, cleaned up echoed headings, and made the Studio show the guard’s reasons. The check still blocks unsupported narration instead of quietly weakening the factual standard.

Why Does Open Innovation Matter?

  • Lower per-tour AI costs: Local inference avoids a hosted-model API charge for every narration. The operator still needs hardware capable of running Gemma.
  • More control over tour notes: The Studio sends narration requests to Ollama running locally; it does not send those notes to a hosted model API.
  • Room to adapt: Operators can inspect and modify the project’s prompts and validation code for their neighborhood, language, and editorial standards.

Open-weight AI makes it practical to experiment with a small, specialized tour product without building around a closed model provider’s API and pricing. The trade-off is that operators need a capable computer and good source notes; incomplete notes may lead to rejected narration.

My Agent Session

{% agent_session building-walkguide-studio-with-local-gemma-uf8pxg %}

Prize Categories

  • Best Use of Gemma ```
You

markdown is incomplete

Agent 
*This is a submission for the [Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle](https://dev.to/challenges/hacktoberfest-week2-2026-10-12)*

# Walkguide Studio: Local Gemma Tours for Independent Guides

## What I Built

**The problem:** Walking-tour guides often have the local knowledge already. Turning it into a polished self-guided tour takes additional work: organizing notes into short narrations, checking facts, preparing audio, and packaging the route for visitors.

**The solution:** Walkguide Studio turns a tour operator’s route notes into a self-guided walking tour. The operator provides each stop’s name, coordinates, and facts. **Gemma drafts narration from those notes**, and Walkguide checks the generated text for unsupported names and numbers before creating a map, transcripts, optional audio, and an offline ZIP.

**Who it’s for:** Independent walking-tour operators and small local museums that want to offer a self-guided option without commissioning a custom app.

**Who might pay:** An operator could sell the tour ZIP or bundle it with an existing tour, booking, or visitor experience. Walkguide creates and packages tours; **it does not process payments or host a storefront**. I haven’t yet tested willingness to pay with an outside operator, so this is a customer and pricing hypothesis that still needs validation.

**What makes the solution useful:** The operator’s notes remain the source of truth. If narration includes unsupported details, Walkguide reports the rejection instead of packaging it as a finished tour.

## Demo

[![Watch the Walkguide demo](https://img.youtube.com/vi/NbL-dx2ZQpA/hqdefault.jpg)](https://youtu.be/NbL-dx2ZQpA)

## Code

[View WalkguideStudio on GitHub](https://github.com/ishavishwakarma29/WalkguideStudio)

## How I Built It

Walkguide is written in **Python 3.9+ using only the standard library**. The local Studio interface collects the route and notes, then Ollama runs **Gemma 3 (1B)** on the operator’s computer to draft narration.

The main flow is:

1. **Enter the route:** Add stop names, coordinates, and source notes.
2. **Draft narration:** Gemma generates concise narration using the provided notes.
3. **Check grounding:** Walkguide checks generated names and numbers against the notes.
4. **Package the tour:** The app creates a map, transcripts, optional audio, and a static ZIP that visitors can open offline.

To start the Studio:

```powershell
ollama pull gemma3:1b
python studio.py

A failure shaped the design: Gemma sometimes returned generic introductions or echoed a stop heading, causing the grounding check to reject the narration. I tightened the prompt, cleaned up echoed headings, and made the Studio show why the guard rejected a draft. Unsupported narration is still blocked rather than quietly packaged as a finished tour.

Why Does Open Innovation Matter?

  • Avoid per-generation hosted-model charges: Gemma runs locally through Ollama, so the operator does not need a hosted model API for each narration. They still need hardware capable of running the model.
  • Keep the model workflow local: The Studio sends narration requests to the local Ollama service rather than a hosted model API.
  • Adapt the tool to local needs: Operators can inspect and modify the prompts and validation code for their neighborhood, language, and editorial standards.

Open-weight AI makes it practical to experiment with a specialized tour product without first building around a closed provider’s API and pricing. The trade-off is that operators need a capable computer and sufficiently detailed source notes; incomplete notes may lead to rejected narration.

My Agent Session

{% agent_session building-walkguide-studio-with-local-gemma-uf8pxg %}

Prize Categories

  • Best Use of Gemma ````
You

its still half markdown half normal text

Agent

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

Walkguide Studio: Local Gemma Tours for Independent Guides

What I Built

  • Problem: Walking-tour guides already know the stories behind their stops, but turning that knowledge into a self-guided product takes extra work: organizing notes, writing concise narration, checking facts, preparing audio, and packaging the route for visitors.
  • Solution: Walkguide Studio turns an operator’s route notes into a self-guided walking tour. The operator enters each stop’s name, coordinates, and facts. Gemma drafts narration from those notes, and Walkguide checks the generated text for unsupported names and numbers.
  • What the operator gets: A map, transcripts, optional audio, and an offline tour ZIP.
  • Who it’s for: Independent walking-tour operators and small local museums that want a self-guided option without commissioning a custom app.
  • Who might pay: An operator could sell the tour ZIP or bundle it with an existing tour, booking, or visitor experience.
  • Current limitation: Walkguide creates and packages tours; it does not process payments or host a storefront. I haven’t tested willingness to pay with an outside operator, so the customer and pricing assumptions still need validation.
  • Grounding: The operator’s notes remain the source of truth. If narration includes unsupported details, Walkguide reports the rejection instead of packaging it as a finished tour.

Demo

Code

View WalkguideStudio on GitHub

How I Built It

  • Language: Python 3.9+, using only the standard library.
  • Local model: Gemma 3 (1B), run on the operator’s computer through Ollama.
  • Narration source: The operator’s notes for each tour stop.
  • Validation: Walkguide checks generated names and numbers against those notes.
  • Output: A map, transcripts, optional audio, and a static ZIP visitors can open offline.

To run the Studio:

ollama pull gemma3:1b
python studio.py

A failure shaped the design: Gemma sometimes returned generic introductions or echoed a stop heading, causing the grounding check to reject its narration. I tightened the prompt, cleaned up echoed headings, and made the Studio show why the guard rejected a draft. Unsupported narration is still blocked rather than quietly packaged as a finished tour.

Why Does Open Innovation Matter?

  • Lower usage costs: Local Gemma avoids a hosted-model API charge for each narration. The operator still needs hardware capable of running the model.
  • Local processing: The Studio sends narration requests to Ollama on the operator’s computer rather than to a hosted model API.
  • Adaptability: Operators can inspect and modify the prompts and validation code for their neighborhood, language, and editorial standards.

Open-weight AI makes it practical to experiment with a specialized tour product without first building around a closed provider’s API and pricing. The trade-off is that operators need a capable computer and detailed source notes; incomplete notes may lead to rejected narration.

My Agent Session

{% agent_session building-walkguide-studio-with-local-gemma-uf8pxg %}

Prize Categories

  • Best Use of Gemma
You

still same problem

Agent 
*This is a submission for the [Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle](https://dev.to/challenges/hacktoberfest-week2-2026-10-12)*

# Walkguide Studio: Local Gemma Tours for Independent Guides

## What I Built

- **Problem:** Walking-tour guides know the stories behind their stops, but turning those stories into a self-guided product takes time: organizing notes, writing narration, checking facts, preparing audio, and packaging the route.
- **Solution:** Walkguide Studio turns an operator’s route notes into a self-guided walking tour. The operator enters each stop’s name, coordinates, and facts. **Gemma drafts narration from those notes**, and Walkguide checks the narration for unsupported names and numbers.
- **Output:** A map, transcripts, optional audio, and an offline tour ZIP.
- **Who it’s for:** Independent walking-tour operators and small local museums that want a self-guided option without commissioning a custom app.
- **Who might pay:** An operator could sell a tour ZIP or bundle it with an existing tour, booking, or visitor experience.
- **Current limitation:** Walkguide creates and packages tours; it does not handle payments or host a storefront. I haven’t tested willingness to pay with an outside operator, so the customer and pricing assumptions still need validation.
- **Grounding:** The operator’s notes are the source of truth. If narration includes unsupported details, Walkguide reports the rejection instead of packaging it as a finished tour.

## Demo

[![Watch the Walkguide demo](https://img.youtube.com/vi/NbL-dx2ZQpA/hqdefault.jpg)](https://youtu.be/NbL-dx2ZQpA)

## Code

[View WalkguideStudio on GitHub](https://github.com/ishavishwakarma29/WalkguideStudio)

## How I Built It

- **Language:** Python 3.9+, using only the standard library.
- **Local AI:** Gemma 3 (1B) runs on the operator’s computer through Ollama.
- **Narration:** Gemma drafts each stop’s narration from the operator’s notes.
- **Validation:** Walkguide checks generated names and numbers against those notes.
- **Packaging:** The app creates a map, transcripts, optional audio, and a static ZIP that visitors can open offline.

To run the Studio:

    ollama pull gemma3:1b
    python studio.py

**A failure shaped the design:** Gemma sometimes returned generic introductions or echoed a stop heading, causing the grounding check to reject its narration. I tightened the prompt, cleaned up echoed headings, and made the Studio show why the guard rejected a draft. **Unsupported narration is still blocked** rather than quietly packaged as a finished tour.

## Why Does Open Innovation Matter?

- **Lower usage costs:** Local Gemma avoids a hosted-model API charge for each narration. The operator still needs hardware capable of running the model.
- **Local processing:** The Studio sends narration requests to Ollama on the operator’s computer rather than to a hosted model API.
- **Adaptability:** Operators can inspect and modify the prompts and validation code for their neighborhood, language, and editorial standards.

**Open-weight AI makes it practical to experiment with a specialized tour product** without first building around a closed provider’s API and pricing. The trade-off is that operators need a capable computer and detailed source notes; incomplete notes may lead to rejected narration.

## My Agent Session

{% agent_session building-walkguide-studio-with-local-gemma-uf8pxg %}

## Prize Categories

- **Best Use of Gemma**
You

priz =e categories also need detail

Agent 
## Prize Categories

- **Best Use of Gemma:** Gemma 3 (1B) is the core narration model in Walkguide Studio. It runs locally through Ollama and turns an operator’s notes for each stop into concise tour narration. Walkguide then checks names and numbers against those notes and rejects unsupported narration. Gemma is central to generating the tour content, not an optional add-on.
- **Other partner categories:** None. Walkguide does not currently integrate the other challenge partners’ technologies.
You

the dev relay session is incomplete it should be from start

You

The saved DevRelay session is incomplete; it should cover the project from the start.

44 of 44 messages

My First User

  • Yet to offer to local tour guides

Prize Categories

  • Best Use of Gemma: Gemma 3 (1B) is the core narration model in Walkguide Studio. It runs locally through Ollama and turns an operator’s notes for each stop into concise tour narration. Walkguide then checks names and numbers against those notes and rejects unsupported narration. Gemma is central to generating the tour content, not an optional add-on.