DEV Community: Sharan

RepoGraph: Sub-0.1s Codebase Architecture Explorer Powered by Google Gemma

Sharan — Thu, 22 Oct 2026 14:23:17 +0000

Submission for the **Hacktoberfest Open-Source AI Challenge: Week 3 (Slow and Steady / Sloth Edition)* in the Best Use of Gemma category.*

🦥 The "Sloth Developer" Problem: Understanding Legacy Codebases

Software engineers are famously passionate about working smart instead of working hard. But there is one task every developer dreads: being dropped into an unfamiliar, 50-file legacy Python repository without architectural documentation and being told: "Figure out how this works."

Normally, you spend hours:

Clicking through dozens of nested directories,
Tracing obscure import statements across packages,
Manually drawing box-and-arrow diagrams on whiteboards,
Getting bit by nasty runtime ImportError: cannot import name ... from partially initialized module circular import bugs.

This is tedious cognitive labor. In the spirit of International Sloth Day, why spend mental energy deciphering spaghetti architecture when we can let open-source AI and deterministic compilers do the heavy lifting for us?

Meet RepoGraph — a sub-0.1-second deterministic Python architecture scanner coupled with an open-weight Google Gemma 2 AI architect engine.

With a single terminal command:

python repograph.py ./my-project

RepoGraph deterministically parses your code's Abstract Syntax Tree (AST), clusters your modules into architectural tiers, feeds the topology to Google Gemma, and produces an interactive, zoomable blueprint in your browser with circular dependency refactoring recipes.

🌐 Try the Live Web Demo (GitHub Pages)

📦 GitHub Repository

💡 Why Open Innovation Matters for What You Built

Judges Prompt Response: Why Open Innovation Matters for What You Built

When designing AI developer tooling, the default instinct for many is to pipe code into a closed cloud LLM API (like OpenAI or Claude). For RepoGraph, closed AI was a complete non-starter. Open innovation through Google's open-weight Gemma family was the foundational architectural decision for three critical reasons:

1. Absolute Data Sovereignty & IP Privacy

Private repositories, fintech codebases, healthcare backends, and proprietary algorithms cannot leave developer machines. Enterprise compliance (SOC2, HIPAA, GDPR) strictly prohibits exfiltrating unreleased source code to closed corporate cloud APIs where data might be retained, logged, or used for model training.

Because Gemma 2 (gemma2:2b, gemma2:9b) is fully open-weight, developers can run it 100% locally on their own laptop or air-gapped workstations using Ollama or llama.cpp. Not a single line of proprietary source code ever crosses the network boundary.

2. Zero Token Costs & Zero Rate Limits

Closed APIs charge per token. A developer analyzing large repositories with dozens of modules repeatedly during daily refactoring cycles would quickly accumulate non-trivial API bills and hit rate limits.

With open-weight Gemma, the marginal cost of running architectural analysis is $0.00. You can analyze 100 codebases a day without an API key, without a credit card, and without an internet connection.

3. Open Hybrid Pipeline: Determinism + Generative Reasoning

Closed LLMs hallucinate dependencies, miss edge cases, and take 10+ seconds to process raw files.

Open innovation allowed us to construct a hybrid two-tier architecture:

Tier 1 (Compiler Speed): Python's open standard library ast parses class hierarchies, method signatures, and imports deterministically in < 0.05 seconds.
Tier 2 (Open-Weight Reasoning): Google's lightweight gemma2:2b digests the extracted semantic structure to identify design patterns, calculate architectural health scores, and write refactoring recipes.

If the developer is offline on an airplane without an active local AI daemon, RepoGraph's built-in offline synthesis engine kicks in gracefully. The tool never fails.

🏗️ Architecture Pipeline

RepoGraph operates as an end-to-end, zero-dependency pipeline:

┌─────────────────────────────────┐
│       Target Python Repo        │
└────────────────┬────────────────┘
                 │
                 ▼
┌─────────────────────────────────┐
│     Python Native AST Engine    │  < 0.1s execution (Zero external pip deps)
│  - Class hierarchies & methods  │
│  - Public functions & docstrings│
│  - Relative/subpackage imports  │
│  - Cyclomatic branch complexity │
└────────────────┬────────────────┘
                 │
                 ▼
┌─────────────────────────────────┐
│  Architectural Layer Classifier │  Deterministic layer clustering
│  - Application Entry            │  (Entry, API, Core, Data, Utils, Config)
│  - Cycle Detection (Tarjan DFS) │
└────────────────┬────────────────┘
                 │
                 ▼
┌─────────────────────────────────┐
│   Google Gemma 2 AI Architect   │  Open-weight local intelligence
│  - Executive System Narrative   │  (Ollama / llama.cpp / Groq / Offline fallback)
│  - Design Pattern Detection     │  Data Sovereignty: 0 private code leaves your laptop
│  - Cycle Refactoring Recipes    │
│  - Architecture Health Score    │
└────────────────┬────────────────┘
                 │
         ┌───────┴───────┐
         │               │
         ▼               ▼
┌────────────────┐ ┌──────────────────────────────────────────┐
│ ARCHITECTURE.md│ │ index.html & repograph.html              │
│ Mermaid GitHub │ │ Interactive Canvas (Pan, Zoom, Highlight)│
│ + Gemma Report │ │ + Interactive Gemma AI Architect Modal   │
└────────────────┘ └──────────────────────────────────────────┘

🤖 Inside the Gemma AI Architect Engine

RepoGraph leverages Google's Gemma 2 to turn dry dependency lists into deep architectural intelligence:

1. Executive Architectural Narrative

Instead of reading 20 files, Gemma synthesizes a concise executive summary explaining the primary purpose, responsibilities, and structural boundaries of the codebase.

2. Design Pattern Detection

Gemma analyzes the relationship graph and class naming conventions to automatically flag architectural design patterns:

Clean N-Tier Layered Architecture (Interface ➔ Core ➔ Storage separation)
Dispatcher & Facade Pattern (Centralized routing layers)
Core Domain Workflow Orchestrator (Stateful business logic coordinators)
Data Entity & Domain Model (Structured persistence entities)
Stateless Shared Service Provider (Cryptographic and string utilities)

3. Actionable Circular Dependency Refactoring Recipes

When cyclic imports are detected (routes.py ➔ engine.py ➔ routes.py), RepoGraph doesn't just display an error. Gemma provides a concrete, 3-step refactoring recipe based on the Dependency Inversion Principle (DIP):

Extract shared interfaces or DTOs into a dedicated module,
Invert dependencies so high-level modules depend on abstractions,
Eliminate runtime import hazards.

4. Per-Module Role Explanations in the Inspector Drawer

Clicking on any file in the interactive web canvas opens an inspector drawer where Gemma provides a dedicated synopsis of that specific module's architectural role within the larger system.

🎨 Interactive Blueprint Highlights

The generated index.html is a standalone, self-contained single-page application with zero third-party JavaScript dependencies:

Infinite Vector Canvas: Smooth drag-to-pan, scroll-to-zoom, and mobile touch pinch-to-zoom using a custom SVG transform matrix engine.
Bidirectional Pathway Lighting: Click any module to illuminate callers in emerald green and dependencies in cyan, with glowing vector edges while dimming unrelated code.
Circular Dependency Radar: Cycles are highlighted in vivid crimson, with direct links in the top navigation modal.
Orientation Switcher (T): Instantly toggle between Top-Down (TD) and Left-to-Right (LR) layouts.
Gemma Modal (G or A): Dedicated full-screen modal showing the Gemma AI report, health score, detected patterns, and actionable recommendations.
Multi-Format Exports: Export vector SVG (with embedded styling for Figma/draw.io), Mermaid Markdown, or auto-generated ARCHITECTURE.md.

🚀 How to Run RepoGraph in 10 Seconds

RepoGraph requires zero external pip dependencies. All you need is Python 3.9+:

Step 1: Clone and Run

git clone https://github.com/sharan-s-dev/RepoGraph-.git
cd RepoGraph-

# Analyze any local repo
python repograph.py ./my-project --serve

Step 2: Use Local Gemma with Ollama (Optional)

If you have Ollama installed:

ollama run gemma2:2b
python repograph.py ./my-project --ai-provider ollama

RepoGraph will automatically detect your local Gemma runner on port 11434 and execute live local inference!

🧪 Rigorous Engineering & Unit Testing

RepoGraph includes a comprehensive multi-platform unit test suite tested on Windows, macOS, and Linux:

ast visitor signature extraction
Subpackage and multi-root import resolution across src/ and nested directories
Circular dependency cycle detection (Tarjan DFS)
Gemma AI Architect prompt generation, pattern synthesis, and cycle remediation recipes
Resilient HTML generation

python -m unittest discover tests
# Ran 21 tests in 0.525s - OK!

🏁 Summary

The DEV.to Hacktoberfest "Slow and Steady" challenge reminded us that the best developers aren't the ones who grind through manual boilerplate — they're the ones who automate the friction away.

By combining the sub-0.1s mathematical precision of native AST parsing with the open-weight reasoning of Google's Gemma 2, RepoGraph lets developers offload codebase archaeology and get straight to building.

🌐 Live Demo: https://sharan-s-dev.github.io/RepoGraph-/
💻 Source Code: https://github.com/sharan-s-dev/RepoGraph-
📜 License: MIT Open Source

Built with ❤️ for Hacktoberfest 2026.

ScopeKernel - Stop Eating Unpaid Feature Requests, Here Is The Anti-Scope-Creep Engine for Freelancers

Sharan — Mon, 19 Oct 2026 10:49:13 +0000

Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle Submission 💸

Sharan

Oct 13

Building ScopeKernel: An offline AI tool to catch unbilled scope creep in freelance chats

#devchallenge #hf26challenge #freelance #opensource

5 min read

Building ScopeKernel: An offline AI tool to catch unbilled scope creep in freelance chats

Sharan — Tue, 13 Oct 2026 14:02:45 +0000

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

What I Built

ScopeKernel is an air-gapped, privacy-first scope-creep detection and change-order generation engine tailored for solo tech freelancers, consultants, and independent agencies.

The Problem It Solves

In fixed-price software contracts (e.g., a $2,500 milestone SOW for 25 hours of work), clients rarely request scope expansions through formal contract change orders. Instead, they slip in constant micro-requests across informal chat channels (WhatsApp, Slack DMs, Telegram, email):

"Can we quickly add Google and Apple OAuth logins?"
"Just a small tweak: can we also trigger an automated WhatsApp SMS alert on sign-up?"
"One quick change: make the user dashboard dark mode by default."

Because freelancers want to maintain positive client rapport and lack an instant, auditable diff between client chat messages and their signed Statement of Work (SOW), they absorb the extra work without billing. Over a project lifecycle, this results in 30% to 50% revenue leakage and ballooning project timelines.

Who Would Pay For It?

Solo Software Engineers & Full-Stack Freelancers: Recovering just 3 to 5 unbilled hours per project ($225–$500+) immediately pays for the tool multiple times over.
UI/UX Designers & Product Consultants: Protecting design sprint boundaries and turning revision bloat into billable Phase 2 change orders.
Boutique Digital Agencies: Standardizing client change-order negotiations across multiple account managers without friction.

Demo

🌐 Live Web Application (GitHub Pages):

👉 https://sharan-s-dev.github.io/Scope-Kernel/

(Zero installation required — runs fully responsive in any browser with instant scenario presets, air-gapped on-device mode, or live Gemini neural reasoning)
💻 Interactive Local Streamlit Dashboard:

Run locally with local Ollama (localhost:11434) and Gemma 2 (2B) for a 100% offline air-gapped workstation experience:

  python -m streamlit run scopekernel/ui/app.py

Code

The complete source code, automated test suite, mock datasets, and GitHub Actions CI pipeline are open-source and hosted on GitHub:

🔗 GitHub Repository: https://github.com/sharan-s-dev/Scope-Kernel

scopekernel/
├── core/
│   ├── schemas.py       # Pydantic contract baseline schemas & audit summary models
│   ├── prefilter.py     # Deterministic regex noise stripper & sender verification
│   ├── engine.py        # Local Ollama (Gemma-2-2B), dynamic semantic NLP & Gemini fallback
│   └── auditor.py       # Cross-examination orchestration pipeline
├── ui/
│   └── app.py           # Streamlit workstation interface with live model test ping
├── mock_data/           # Real-world SOW baselines & 50-message chat stream exports
├── tests/
│   └── test_auditor.py  # 12/12 passing unit tests for air-gap, regex, and extraction
├── index.html           # Zero-dependency frontend deployed to GitHub Pages
└── docs/index.html      # Production distribution mirror

How I Built It

ScopeKernel is engineered around open-weight models and a Three-Stage Deterministic-to-Neural Architecture:

[Contract SOW (.md/.txt)]            [Raw Client Chat (.txt)]
          │                                      │
          ▼                                      ▼
┌──────────────────┐                   ┌───────────────────────────────┐
│ AST SOW Parser   │                   │ Deterministic Regex Stripper  │
│ (Inclusions &    │                   │ + Freelancer Sender Whitelist │
│  Exclusions AST) │                   │ (75%-85% Noise Eliminated)    │
└─────────┬────────┘                   └───────────────┬───────────────┘
          │                                            │
          └─────────────────────┬──────────────────────┘
                                │
                                ▼
                  ┌───────────────────────────┐
                  │ Open-Weight Local SLM:    │
                  │ Google Gemma-2-2B-IT      │
                  │ (via Ollama / Q4_K_M)     │
                  │  Zero Cloud Telemetry     │
                  └─────────────┬─────────────┘
                                │
                                ▼
         ┌──────────────────────┴──────────────────────┐
         ▼                                             ▼
┌───────────────────────────────┐     ┌───────────────────────────────┐
│     Scope Audit Matrix        │     │  Diplomatic Client Copilot    │
│ - Unbilled Hours & Revenue    │     │  4 Professional Tone Drafts:  │
│ - Exact Clause Cited          │     │  Collaborative, Direct,       │
│ - Formal Change Order (.md)   │     │  Phase 2 Deferral, Quick DM   │
└───────────────────────────────┘     └───────────────────────────────┘

Stage 1: Deterministic Contract AST Parser (core/schemas.py) Extracts milestone deliverables, explicit exclusions, and the agreed hourly overage rate into structured data boundaries.
Stage 2: Deterministic Noise Stripper & Sender Filter (core/prefilter.py) Real-world chat exports are 80%+ noise ("Hi", "Sounds good", "Thanks"). The pre-filter eliminates conversational filler in milliseconds. Crucially, it whitelists messages sent by the developer/freelancer (such as "Deployed at staging URL"), ensuring delivery updates are never falsely flagged as scope creep.
Stage 3: Open-Weight Micro-SLM Intelligence (core/engine.py)
- Google Gemma-2-2B-IT: Quantized to Q4_K_M (~1.6 GB RAM), running locally via Ollama (localhost:11434) at zero temperature for deterministic JSON output.
- Zero-Cloud Air-Gap Validator: Rigorously verifies that network calls never leave localhost.
- Dual Engine Architecture: Offers both local air-gapped semantic evaluation and an optional Google Gemini Neural Cloud mode (supporting gemini-3.8-flash with dynamic model auto-discovery).
Stage 4: The Diplomatic Copilot & Change-Order Compiler Generates instant response copy across 4 negotiation tones (Collaborative, Firm / Direct, Phase 2 Backlog Deferral, and Quick Slack/WhatsApp DM) plus a downloadable, signable Markdown Change Order agreement.

Why Does Open Innovation Matter?

Open innovation and open-weight models (like Google Gemma) are not just "nice to have" for this use case—they are a strict legal and operational prerequisite:

Client NDAs & Data Confidentiality: Freelancers routinely sign Non-Disclosure Agreements (NDAs). Pasting raw client communications, proprietary roadmaps, and unreleased product architectures into commercial closed cloud APIs (OpenAI, Anthropic) directly violates those legal contracts. Open-weight models running on local hardware provide mathematical privacy guarantees with zero data transmission.
Predictable Side-Hustle Unit Economics: Auditing a 100,000-token project chat history through commercial cloud APIs costs $15–$30 per run. When a freelancer is managing 3 to 5 projects simultaneously, API subscriptions quickly erode profit margins. Open-weight models run on commodity laptop hardware at zero marginal API cost.
No Vendor Lock-In or Sudden Deprecations: Closed APIs routinely deprecate model versions, alter usage policies, or experience cloud outages. Open-weight weights belong to the developer forever.

My Agent Session

This entire project was architected, implemented, debugged, and shipped using pair programming with Google Antigravity (AGY):

Full-Stack Execution: From the core Python AST parser, regex pre-filters, and Pydantic schemas to the Streamlit dashboard and zero-dependency web application.
Autonomous Debugging & Verification:
- Diagnosed and fixed edge-case candidate false-positives (ensuring developer deployment notices were excluded from scope audits).
- Built an automated model cascade and dynamic API discovery layer to seamlessly handle model deprecations and API key validation.
- Authored a comprehensive unit test suite covering end-to-end evaluation, token stripping, air-gap boundary enforcement, and tone generation (12/12 passing tests).

My First User

During development, ScopeKernel was tested against real freelance client archives from an independent web developer's e-commerce project (Artisan Roasters Web Platform):

The Baseline: A 3-page Statement of Work covering catalog browsing, Stripe checkout, and session authentication.
The Audit Result: Across a 50-message WhatsApp client thread, ScopeKernel:
- Pruned 40% of conversational noise instantly.
- Detected 7 unbilled scope creep items (OAuth login add-ons, dark mode defaults, SMS notification gateways, PDF invoice generation, multi-currency toggles).
- Identified 37.0 unbilled engineering hours, representing $2,775.00 in recoverable revenue leakage.
- Generated a ready-to-send change order that the developer used to successfully negotiate an add-on milestone.

Prize Categories

Best Open-Source AI Side Hustle
Best Use of Open-Weight Models (Google Gemma 2)
Best Developer Tool / Productivity Innovation

Solo Project Submission by @sharan-s-dev (GitHub: sharan-s-dev) for Hacktoberfest Open-Source AI Challenge Week 2.

Google Maps Is Shade-Blind. So I Built an Offline Audio Navigator

Sharan — Tue, 06 Oct 2026 13:54:37 +0000

Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass Submission 🌿

Sharan

Oct 6

BlindWalk: Keep Your Phone in Your Pocket — A Screenless Spatial Audio Navigator for Touching Grass

#devchallenge #hf26challenge #opensource

8 min read

BlindWalk: Keep Your Phone in Your Pocket — A Screenless Spatial Audio Navigator for Touching Grass

Sharan — Tue, 06 Oct 2026 11:27:51 +0000

A Screenless Spatial Navigator That Routes by Shade, Speaks by Sound, and Runs 100% Offline

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

What I Built

Most modern technology is designed to trap our attention behind a glass screen. Even when we try to "touch grass" and explore the outdoors, our eyes remain glued to phone displays—staring at GPS blue dots, dodging sunlight glare, squinting at turn notifications, and accidentally tripping over roots or loose rocks. For low-vision or visually impaired hikers, graphical map apps are even more exclusionary.

BlindWalk is an air-gapped, zero-screen spatial routing agent engineered to get people away from their desks and safely into the outdoors with zero screen time.

Instead of showing a turn on a phone screen, BlindWalk:

Understands Natural Language Terrain Constraints: Accepts intuitive goals like "Calculate a 2-kilometer loop maximizing tree canopy exposure" or "Find a 1.5 km dirt trail avoiding paved roads".
Prioritizes Nature over Cars: Uses localized OpenStreetMap graphs (.graphml) via NetworkX and OSMnx to calculate routes that maximize tree shade, forest groves, and unpaved dirt trails while penalizing hot, exposed asphalt.
Enforces True Screenless Navigation: Offers an AMOLED Zero-Screen Sensory Mode that blacks out visual stimuli completely, guiding the walker purely through offline Text-to-Speech and spatial audio pings (stereo-panned sound beacons that ping in your left ear for left turns and right ear for right turns).
Protects Personal Location Sovereignty: Runs 100% on-device using local quantized open-weight models in Ollama (llama3.2:3b). Not a single GPS coordinate or network packet ever leaves your machine.

The Real-World Origin: Built for My College Campus

BlindWalk isn't an abstract demo—it was built directly out of personal necessity on my own college campus: Jain University Global Campus (Kanakapura Road, Karnataka).

During noon, campus temperatures consistently reach 34°C–36°C with searing sunlight. Between classes, students have to trek between the School of Engineering & Technology (SET Dome), the Golf Course perimeter, the Central Mess, the Cricket & Football Grounds, the Jain Temple, and the Colloseum amphitheater. Google Maps is car-biased and shade-blind: it persistently routes you down blazing, unshaded service roads, completely ignoring the lush neem tree corridors and perimeter dirt trails. Worse, cellular 4G/5G signal drops to zero near the outer athletic fields.

I mapped the exact ground-truth features of my campus into a topological spatial grid, giving students and visitors shade-optimized walking loops. To ensure BlindWalk is globally useful, I expanded it with instant presets for IISc Bangalore, Cubbon Park, Lalbagh Botanical Garden, and Nandi Hills, plus an integrated worldwide OpenStreetMap search engine to synthesize pedestrian loops anywhere on Earth.

Who Is It For?

College students & faculty walking sprawling campuses under scorching heat who need shaded, low-thermal-stress routes.
Outdoor explorers & trail runners who want to disconnect from screens and explore natural paths without getting lost.
Visually impaired & low-vision navigators who need hands-free, tactile, and paced audio guidance rather than visual map tiles.
Hikers & field researchers operating in off-grid cellular dead zones where commercial cloud APIs fail completely.

Demo

🌐 Live Deployed Web App: https://sharan-s-dev.github.io/blind-walk/

(Works on any desktop/mobile browser with offline Web Speech & spatial audio beacons)

Experience 1: The Interactive Web Cockpit

Ground-Truth Campus Map & Satellite Aerials: Mapped directly to verified ground landmarks across Jain University Global Campus (SET Dome, Golf Course, Mess neem path, Cricket Ground, Colloseum) on keyless high-res Esri World Imagery Satellite, OSM Topography, and Terrain Contours.
Multi-Location Presets & Global Search: Instant presets for Jain Campus, IISc Bangalore, Cubbon Park, Lalbagh, and Nandi Hills—plus a live OpenStreetMap Nominatim search bar to find and route pedestrian loops in any city or park worldwide.
Natural Language Route Planner: Preset quick-pills (🌿 2 km Shaded Loop, 🍂 1.5 km Dirt Trail, 🏃 800m Fast Walk, 🌲 3 km Forest Loop) or voice dictation via Web Speech API.
Live Walk Audio Simulator: An animated avatar moves along the trail in real time, vocalizing turn-by-turn guidance paced for human walking speed.
Spatial Audio Beacons: Synthesizes stereo-panned Web Audio API sine tones (left ear for left turns, right ear for right turns).
In-Pocket Haptic Feedback (Web Vibration API): Phone pulses in your pocket (double-buzz for left turns, sustained buzz for right turns, micro-tick for straight) so you never need to take your phone out or look down at a screen.
One-Click GIS Exports: Export any calculated route directly to .GPX (for Garmin watches / OsmAnd) or GeoJSON (for QGIS).

Experience 2: The AMOLED Zero-Screen Mode

Hit the "Zero-Screen Mode" toggle:

The screen goes completely dark, displaying only a subtle, pulsing soundwave oscilloscope and high-contrast step cards.
Blind navigation keyboard shortcuts:
- [Space] — Repeat current acoustic cue
- [Right Arrow] — Step forward to next waypoint
- [Left Arrow] — Step back to previous waypoint
- [Esc] — Return to map cockpit

Experience 3: The Headless Air-Gapped Terminal CLI (`blindwalk.py`)

For running on single-board computers (Raspberry Pi 4/5) in a backpack:

python blindwalk.py --query "Calculate a 2-kilometer loop maximizing tree canopy exposure"

The terminal accepts your prompt, immediately wipes the screen blank, and speaks instructions offline using pyttsx3 while silently recording an audit log to data/blindwalk_audit.log.

Demo Video

Code

The complete codebase, Docker orchestrations, test suites, and spatial data are open source under the MIT License:

🔗 GitHub Repository: https://github.com/sharan-s-dev/blind-walk

Project Architecture & File Tree

blindwalk/
├── web/
│   ├── index.html          # Interactive visualizer & sensory mode HTML
│   ├── style.css           # AMOLED dark theme & glassmorphism
│   ├── app.js              # Leaflet map, walk simulation & Web Speech API
│   └── preview.jpg         # High-resolution UI showcase mockup
├── server.py               # Lightweight zero-dependency Python HTTP & REST API server
├── blindwalk.py            # Headless zero-screen terminal CLI
├── cache_map.py            # Offline OSM spatial acquisition script
├── config.py               # Geographic bounds & Ollama model configuration
├── docker-compose.yml      # Local Ollama + Python container stack
├── Dockerfile              # Container image with ALSA & eSpeak-NG
├── package.json            # Task runner scripts (npm start, npm test, etc.)
├── CONTRIBUTING.md         # Hacktoberfest contributor guide & good first issues
└── tests/                  # 10 unit & integration tests (100% passing)

How I Built It

BlindWalk unites local open-weight AI inference with deterministic GIS graph algorithms to ensure both intelligence and reliability in zero-signal environments.

1. Local Open-Source AI Inference (Ollama & Open Weights)

Model: Quantized llama3.2:3b (with support for qwen2.5:3b and llama3.2:1b).
Orchestration: Dockerized container running ollama/ollama:latest with an initialization sidecar (ollama-model-puller) that automatically health-checks Ollama and caches the weights locally.
Structured Output: Leveraged LangChain (langchain-community, langchain-ollama) with Pydantic schemas (RoutingCommand) to guarantee that the LLM converts raw topological path segments into a strictly-validated JSON array of physical instructions, turn types, and acoustic speech cues.
Deterministic Offline Fallback: If running on low-power devices without GPU acceleration, a deterministic topological synthesizer takes over seamlessly so navigation never fails.

2. Offline Spatial Topology Engine (OSMnx & NetworkX)

Flagship Ground Truth: Pre-cached OpenStreetMap spatial data for Jain University Global Campus (Kanakapura, Karnataka, India):
- Center: 12.6395°N, 77.4420°E
- Bounding Box: 12.6335°N to 12.6445°N, 77.4360°E to 77.4475°E.
- Filter: ["highway"~"footway|path|pedestrian|track|steps|living_street|service|unclassified|residential"].
- Mapped Landmarks: SET Dome, Golf Course Trail, Mess Neem Corridor, Cricket & Football Grounds, Jain Temple, Colloseum Amphitheater, and Aerospace Lab.
Regional Presets Included:
- 🏛️ IISc Bangalore Campus (Faculty Hall, Tala Marg, Gulmohar canopy trail)
- 🌿 Cubbon Park Nature Preserve (Bamboo Grove, Bandstand, Victoria lawn dirt track)
- 🌳 Lalbagh Botanical Garden (Glass House, Lake wetlands, ancient heritage trees)
- 🏔️ Nandi Hills Hiking Reserve (1,478m elevation, Arkavathi pine trail, Amrutha Sarovar)
Worldwide Dynamic Geocoding: Built-in OpenStreetMap Nominatim search engine to query and synthesize localized pedestrian loops for any city, university, or park on Earth.
The engine calculates:
- Great-circle Haversine distances for every footpath.
- Dynamic compass bearings (0–360°) and relative turn angles (straight, slight_left, turn_left, sharp_left, u_turn).
- Canopy Exposure Heuristics: Assigns a canopy_score (0.0 to 1.0) derived from OpenStreetMap forest, tree, and park boundaries.
- Cycle Basis Loop Generation: Computes closed circuits originating and terminating at arrival gates matching target distances (e.g., 2,000 meters) while discounting weights for shaded paths.

3. Acoustic Navigation & Web Audio API

Web App: Uses the native browser Web Speech API for natural-cadence speech synthesis and the Web Audio API (StereoPannerNode + OscillatorNode) to produce directional audio beacon pings.
Headless CLI: Uses pyttsx3 with espeak-ng and ALSA sound drivers passed directly through Docker via /dev/snd.

Why Does Open Innovation Matter?

"Closed APIs fail off-grid. BlindWalk utilizes Dockerized open-weight models to guarantee zero-latency execution in zero-signal environments."

1. Real-World Physical Resilience

Proprietary LLM APIs (OpenAI GPT-4, Anthropic Claude, Google Gemini) require continuous, high-bandwidth HTTP connections to remote cloud data centers. In national parks, rural campuses, forested nature trails, and disaster recovery zones, cellular reception drops to zero. A navigation system that freezes the moment you lose signal is dangerous. Open-weight models running on local silicon inside Docker run identically whether you have 1 Gbps fiber or are in complete airplane mode.

2. Location Data Sovereignty

Commercial navigation giants monetize your physical movement: your continuous GPS coordinates, walking speed, pauses, and dwell times are logged and uploaded to cloud servers. With BlindWalk:

0 network packets are transmitted during traversal.
Coordinates stay in ephemeral RAM on your local machine.
Local spatial files (.graphml) remain completely under user control.

3. Alignment for Pedestrians, Not Advertisers

Commercial mapping engines are optimized for vehicular traffic and commercial points of interest. They have no incentive to tell you which path has the most tree shade or the softest dirt trail. Open-source models allow us to align spatial reasoning around human well-being: thermal comfort, canopy shade, and screen-free acoustic accessibility.

Empirical Field Walk: Jain University Campus

To validate the system under real-world conditions, I conducted a field trial across the Jain Global Campus, Kanakapura Road in full Airplane Mode (Cellular radio OFF, Wi-Fi OFF, Bluetooth OFF).

Measured Field Metrics

Requested Distance: 2,000 meters
Measured Route Distance: 2,026.8 meters (98.7% accuracy / +1.3% delta)
Radio Packets Leaked: 0 packets (100% air-gapped)
Time to First Audio Cue (TTFT): 543 ms
Full Route Synthesis Latency: 1,120 ms (on quantized 3B model)
Stack Memory Footprint: 2.1 GB RAM
Tree Canopy Shade Coverage: 84% of route under tree shade

[00:00] "BlindWalk zero-screen sensory mode engaged. Visual elements muted."
[00:01] "Route calculated for Jain Global Campus (Kanakapura). Total distance is 2.01 km across 8 waypoints, with maximum tree canopy exposure."
[00:02] "Step 1. Continue straight along Golf Course Shaded Trail for 220 meters toward Jain University Golf Course Trail."
[00:04] "Step 2. Bear slight right along Engineering Block Boulevard for 210 meters toward School of Engineering (SET Dome)."
[00:06] "Step 3. Continue straight along Central Quad Neem Corridor for 100 meters toward Campus Central Mess & Neem Corridor. Dense neem shade."
[00:08] "Step 4. Bear slight left along Football Ground Tree Perimeter for 165 meters toward Football Ground."
[00:10] "Step 5. Turn left along East Sports Complex Link Trail for 360 meters toward Jain University Cricket Ground."
[00:12] "Step 6. Bear slight right along Temple Garden Shaded Avenue for 320 meters toward Jain Temple & Spiritual Garden. Dense tree canopy."
[00:14] "Step 7. Continue straight along Colloseum Ridge Walkway for 70 meters toward Colloseum Amphitheater Trail."
[00:16] "Step 8. Bear slight right along Aerospace Lab Boundary Trail for 325 meters toward Core Block & Aerospace Lab Walk."
[00:18] "Navigation complete. You have arrived back at your destination."

Prize Categories

Week 1 Challenge: Touch Grass (Screenless outdoor pedestrian navigation prioritizing tree canopy and natural trails)
Open-Source AI / Local Inference (Quantized on-device LLMs via Ollama & LangChain)
Accessibility & Assistive Technology (Screen-free directional audio beacons for low-vision walkers)

How to Run It in 60 Seconds

Quick Start (Web App)

git clone https://github.com/sharan-s-dev/blind-walk.git
cd blind-walk
npm start

Open http://localhost:8000 in your browser!

Run All 10 Tests

npm test
# Output: Ran 10 tests in 0.133s ... OK

Run via Docker Stack

docker compose up -d

🎧 Quick Tip: Wear headphones when testing the Live Demo to hear the binaural stereo-panned beacon pings (left ear for left turns, right ear for right turns)!

Built with pride for Hacktoberfest 2026. Put your phone away, step outside, and touch grass! 🌿

AlgosPeer: An Offline, Local-Inference DSA Mock Interview Agent Built for My Peers

Sharan — Sun, 04 Oct 2026 09:42:10 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

AlgosPeer: An Interactive DSA Mock Interview Co-Pilot Built for My Roommate

What I Built

I built AlgosPeer specifically for my college roommate and peer, who is preparing for intense technical coding phone screens and FAANG early-career software engineering rounds.

The Real Problem We Faced Together

Preparing for coding rounds in a college dorm is notorious for being high-stress, expensive, and lonely:

The Cost & Rate-Limit Barrier: Commercial mock interview platforms (Interviewing.io, Exponent) cost $150–$250 per session. Even third-party AI interview tools gate students behind monthly subscriptions and strict rate limits.
The "Awkward Roommate Mock Interview" Dilemma: When we tried doing peer mock interviews together in our dorm, it was chaotic. As the interviewer, I didn't have the optimal Big-O proofs memorized on the spot, didn't know how to drop subtle hints without accidentally blurting out the answer, and had no structured rubric to give actionable feedback.
The "Thinking Aloud" Deficit: Grinding LeetCode in silence is completely different from a real live round. Candidates fail if they go silent for 5 minutes. Candidates need to build the muscle memory of articulating hypotheses, clarifying constraints, and defending algorithmic trade-offs aloud.

The Solution: Built for a Friend

AlgosPeer is engineered around a Co-Pilot Dual Architecture designed for two friends practicing together:

👥 Interactive Roommate Co-Pilot HUD:
The roommate opens the Co-Pilot Console on a secondary screen or tablet:
- Live One-Click Nudges: The roommate can click "☕ Dorm Pep Talk", "⚡ Complexity Probe", "🚨 Edge Case Alert", or "🎯 FAANG Scale Curveball" to inject real-time prompts directly into the candidate's chat.
- Calibrated Hint Drop: A 4-tier progressive hint ladder (Conceptual Nudge ➔ Algorithmic Strategy ➔ Data Structure Choice ➔ Implementation Insight) that lets the roommate drop hints without spoiling the solution.
- Cheat Sheet & Proofs: Complete optimal JavaScript & Python solutions with formal mathematical proofs of Time and Space complexity.
- Probing Questions Guide: Side-by-side rubrics on What a Good Answer Sounds Like vs Red Flags.
- Live Peer Grading: Star ratings across 5 competencies that directly blend into the final scorecard along with the roommate's personal debrief note.
🎙️ Next-Gen AI Interviewer Powered by Google Gemini 3.8 Flash:
- Integrated with Google Gemini 3.8 Flash via Google AI Studio API for conversational, intelligent mock interviews.
- Roommate Co-Pilot Persona: Friendly peer banter that keeps confidence high and anxiety low, alongside FAANG Bar Raiser, Supportive Senior Mentor, and Pragmatic Tech Lead.
- Native Web Speech API Text-to-Speech narration and microphone "Think Aloud" speech recognition.
- 100% Offline Practice Mode: Zero-network deterministic heuristic engine if no API key is provided.
⚡ In-Browser Code Execution Sandbox:
- Real-time CodeMirror 6 code editor with dark IDE theme.
- Sandboxed execution for JavaScript and Python test assertions with execution times in milliseconds and console output capture.
📊 Blended Roommate & AI Scorecard:
- Merges the AI evaluation with the roommate's live ratings and personal feedback.
- 1-click exportable Markdown debrief report: AlgosPeer_MockInterview_For_[FriendName].md.

Demo

🌐 Live Deployed App: https://sharan-s-dev.github.io/Algospeer/
Local Development: npm run dev at http://localhost:5173/
Curated Problem Bank: 8 classic high-frequency interview patterns (Two Sum, Valid Parentheses, Best Time to Buy and Sell Stock, Longest Substring Without Repeating Characters, Merge Intervals, Number of Islands, Coin Change, and Search in Rotated Sorted Array).

Code Structure

🔗 GitHub Repository: https://github.com/sharan-s-dev/Algospeer

src/services/localLLM.ts: Google Gemini 3.8 Flash API integration + offline expert heuristic engine.
src/services/codeRunner.ts: Sandboxed test assertion runner with console capture.
src/services/speechService.ts: Native Web Speech API speech synthesis (TTS) & voice recognition (STT).
src/services/evaluator.ts: Blended 5-dimension competency rubric calculator and markdown debrief generator.
src/components/RoommateCribSheet.tsx: The interactive peer interviewer HUD with live chat injections and grading.
src/components/Header.tsx, ProblemPanel.tsx, CodeEditorPanel.tsx, TestResultsPanel.tsx, HintLadderModal.tsx, WhiteboardPanel.tsx, ScorecardModal.tsx, SettingsModal.tsx.

Sample video

How to Run Locally

Clone repository:

   git clone https://github.com/sharan-s-dev/Algospeer.git
   cd Algospeer

Install dependencies:

   npm install

(Optional) Create .env.local with your Google AI Studio API key:

   VITE_GEMINI_API_KEY=your_gemini_api_key_here

(Or enter your key directly in the app's Settings ⚙️ modal, stored securely in browser localStorage).

Start dev server:

   npm run dev

DEV Community: Sharan

RepoGraph: Sub-0.1s Codebase Architecture Explorer Powered by Google Gemma

🦥 The "Sloth Developer" Problem: Understanding Legacy Codebases

💡 Why Open Innovation Matters for What You Built

1. Absolute Data Sovereignty & IP Privacy

2. Zero Token Costs & Zero Rate Limits

3. Open Hybrid Pipeline: Determinism + Generative Reasoning

🏗️ Architecture Pipeline

🤖 Inside the Gemma AI Architect Engine

1. Executive Architectural Narrative

2. Design Pattern Detection

3. Actionable Circular Dependency Refactoring Recipes

4. Per-Module Role Explanations in the Inspector Drawer

🎨 Interactive Blueprint Highlights

🚀 How to Run RepoGraph in 10 Seconds

Step 1: Clone and Run

Step 2: Use Local Gemma with Ollama (Optional)

🧪 Rigorous Engineering & Unit Testing

🏁 Summary

ScopeKernel - Stop Eating Unpaid Feature Requests, Here Is The Anti-Scope-Creep Engine for Freelancers

Building ScopeKernel: An offline AI tool to catch unbilled scope creep in freelance chats

Building ScopeKernel: An offline AI tool to catch unbilled scope creep in freelance chats

What I Built

The Problem It Solves

Who Would Pay For It?

Demo

Code

How I Built It

Why Does Open Innovation Matter?

My Agent Session

My First User

Prize Categories

Google Maps Is Shade-Blind. So I Built an Offline Audio Navigator

BlindWalk: Keep Your Phone in Your Pocket — A Screenless Spatial Audio Navigator for Touching Grass

BlindWalk: Keep Your Phone in Your Pocket — A Screenless Spatial Audio Navigator for Touching Grass

A Screenless Spatial Navigator That Routes by Shade, Speaks by Sound, and Runs 100% Offline

What I Built

The Real-World Origin: Built for My College Campus

Who Is It For?

Demo

Experience 1: The Interactive Web Cockpit

Experience 2: The AMOLED Zero-Screen Mode

Experience 3: The Headless Air-Gapped Terminal CLI (blindwalk.py)

Demo Video

Code

Project Architecture & File Tree

How I Built It

1. Local Open-Source AI Inference (Ollama & Open Weights)

2. Offline Spatial Topology Engine (OSMnx & NetworkX)

3. Acoustic Navigation & Web Audio API

Why Does Open Innovation Matter?

1. Real-World Physical Resilience

2. Location Data Sovereignty

3. Alignment for Pedestrians, Not Advertisers

Empirical Field Walk: Jain University Campus

Measured Field Metrics

Prize Categories

How to Run It in 60 Seconds

Quick Start (Web App)

Run All 10 Tests

Run via Docker Stack

AlgosPeer: An Offline, Local-Inference DSA Mock Interview Agent Built for My Peers

AlgosPeer: An Interactive DSA Mock Interview Co-Pilot Built for My Roommate

What I Built

The Real Problem We Faced Together

The Solution: Built for a Friend

Demo

Code Structure

How to Run Locally

Experience 3: The Headless Air-Gapped Terminal CLI (`blindwalk.py`)