DEV Community: Sayem Rahman

Canopy: Rewarding Laziness in Git Workflows with On-Demand Slices and Semantic Caching

Sayem Rahman — Sat, 24 Oct 2026 05:30:43 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady
Drafted on DEV via DevRelay MCP: Edit on DEV

What I Built

Cloning a multi-gigabyte monorepo just to inspect one file or understand a recent change wastes gigabytes of bandwidth and minutes of developer time. I built Canopy (live at https://canopy-lazy-git.onrender.com) to reward developer laziness: instead of downloading thousands of untouched blobs upfront, it mounts repositories using 767-byte manifest slices and materializes files strictly on demand. When you ask for diff digests, commit messages, or component architecture, Canopy derives the answer once with Google Gemma, validates it through Zod, and caches it permanently in SQLite for instant warm reads.

The Problem: Monorepos Punish Curiosity

In large monorepos, traditional developer tools demand total commitment up front. You want to check what changed in the billing service? Run git clone, wait several minutes, pull down hundreds of megabytes of history, and watch your laptop fan spin.

Anthropic's Scion explored making git lazy for autonomous AI agents. Canopy makes a repository lazy for human developers, backed by an open-weight model and content-addressed local caching that you control.

Key Capabilities

Lazy Slice-Based Filesystem (src/cli/client.ts): canopy mount fetches only the root directory manifest slice (767 bytes). Sub-directories and file blobs are resolved on demand and cached in .canopy/objects/ using their SHA-1 hashes. Subsequent reads hit local disk in 25.7 ms with 0 network bytes.
Bilingual Repository Digest (canopy digest): Generates an authoritative two-line summary and potential risk flags for recent commit ranges (e.g. HEAD~5) in either English or Bengali (--lang bn).
Architectural Role Explanation (canopy why <path>): Analyzes git commit history, file blame, and author distributions to explain a component's primary role and evolution patterns.
Commit Message Synthesizer (canopy commit): Derives concise, conventional commit titles and bodies from staged diffs piped via stdin.
Boot-Time Demo Cache Warmer (src/server/warmer.ts): Pre-warms key digests and architecture files on boot, dropping initial user latency from ~13.7s to ~4ms (a 3,400x speedup).
Sentry GenAI Agent Tracing (src/server/sentry.ts): Instruments every LLM call across four designated agents (CanopyDigestAgent, CanopyWhyAgent, CanopyCommitAgent, CanopySummaryAgent) following OpenTelemetry semantic conventions, with strict developer privacy that scrubs client IP addresses and diff payloads.

Demo

Experience Canopy directly in your browser:

🌐 Live Web Application: https://canopy-lazy-git.onrender.com
⚡ Zero-Wait Demo Experience: Explore the interactive tree viewer, inspect code blobs with cached AI summaries, toggle between English and Bengali digests, inspect architectural why files, and view real-time GenAI trace telemetry.

Walkthrough Video: docs/demo.webm (WebM, 1280x720, 86s, 5.40 MB)
High-Resolution GIF: docs/demo.gif (540x304, 0.91 MB)

Code

SayemR0018 / canopy

A lazy, AI-assisted layer over git

Canopy 🌲

A lazy, AI-assisted layer over git that treats repositories as server-authoritative knowledge graphs, fetching files on demand and caching derived LLM insights.

Built for the dev.to Hacktoberfest Open-Source AI Challenge Week 3: "Slow and Steady" (rewarding laziness in developer workflows).

The Concept: Lazy Repositories for Lazy Developers & Agents

Modern monorepos and sprawling codebases waste gigabytes of bandwidth and minutes of developer time during full clones, even when an engineer or AI agent only needs to read 5 files and understand recent changes.

Canopy is inspired by the architecture described in Anthropic's public post, "Redesigning source control at Anthropic" (Scion), along with ideas from Meta's Sapling and Mononoke:

Server-Authoritative Tree: Clients do not clone full git commit graphs or download historical packfiles upfront.
Lazy Hydration: The client mounts a lightweight tree manifest. Blobs are fetched only when read (canopy cat or UI file view) and…

View on GitHub

GitHub Repository: https://github.com/SayemR0018/canopy
License: Permissive MIT License
Tech Stack: Node >= 22.5.0, TypeScript, Hono, Dual SQLite Adapter (node:sqlite / better-sqlite3 with WAL mode), Google Gemma 4 (models/gemma-4-26b-a4b-it), Sentry, Docker, Render.

The Lazy Payoff: Real Benchmark Numbers

To measure real-world performance without network variance, Canopy includes a deterministic synthetic repository generator (scripts/seed.ts) producing 3,000 files across 40 directories and 200 commits in under 2 seconds.

Every number below comes directly from our 7-iteration benchmark script (scripts/benchmark.ts), audited automatically by scripts/check-claims.ts:

Metric	Traditional Git Clone (history)	Working Tree Baseline	Canopy Lazy Layer (Median)	Difference / Savings
Initial Operation Time	1,858 ms (`git clone`)	N/A	266 ms (`canopy mount`)	7x faster initial setup (min: 250 ms, max: 334 ms)
Initial Download Size	2,908,949 bytes (2.77 MiB)	1,486,369 bytes (1.42 MiB)	767 bytes (0.7 KiB)	100% initial bandwidth saved (root slice)
Cold Read (5 files)	Included in clone	Included in working tree	1,102 ms (1,937 bytes / 1.9 KiB)	Selective on-demand fetch (min: 1,080 ms, max: 1,243 ms)
Warm Read (5 files)	Filesystem cache	Filesystem cache	25.7 ms (0 network bytes)	Local content-addressed cache (min: 22.8 ms, max: 28.8 ms)
Total Transfer (5 files)	2,908,949 bytes (2.77 MiB)	1,486,369 bytes (1.42 MiB)	2,704 bytes (2.6 KiB)	99.9% savings vs clone (99.8% vs tree)
Total Time (Mount + 5 files)	1,858 ms	N/A	1,368 ms	1.4x faster end-to-end

Baselines Explained

We benchmark Canopy against two standard baselines: Full Git Clone (with history), which measures the complete network and disk footprint of cloning the repository including all historical packfiles, commit objects, and the working tree (2.77 MiB); and Working Tree Size, which measures only the raw uncompressed bytes of the checked-out repository files on disk at HEAD without .git metadata (1.42 MiB). Canopy fundamentally restructures repository hydration: canopy mount transfers only a lightweight 767-byte root manifest slice, expanding directory slices (e.g. apps/web/src) and streaming individual file blobs strictly on demand with local content-addressed deduplication.

📊 Benchmark Reproduction & PRNG Technical Detail

The benchmark suite generates a deterministic synthetic monorepo using a Mulberry32 PRNG (seed: 1337). All benchmark iterations are committed as machine-verifiable artifacts in docs/benchmark-results.json and audited on every run via npm run check-claims.

What Went Wrong & Lessons Learned

Engineering software that bridges low-level git internals, embedded databases, and probabilistic AI models invariably uncovers sharp edges. Here are four real problems we hit and how we solved them:

1. The Native SQLite Dilemma on Windows vs Linux (D007)

We wanted SQLite in WAL mode for synchronous, zero-network caching. In production Docker containers on Linux, better-sqlite3 compiled cleanly. But on developer Windows machines without Visual Studio C++ build tools installed, npm install choked on node-gyp.

The Fix: We architected a dual-engine database adapter (src/db/index.ts). It dynamically detects the runtime: on Node >= 22.5.0, it leverages Node's built-in node:sqlite (DatabaseSync), while falling back to better-sqlite3 when available. Both implement an identical TypeScript contract with zero API divergence.

🔧 Technical Detail: Dual SQLite Engine Adapter

// Dynamically selects node:sqlite or better-sqlite3 with standard WAL PRAGMAs
export function createDatabaseAdapter(dbPath: string): DatabaseAdapter {
  try {
    const { DatabaseSync } = require('node:sqlite');
    const db = new DatabaseSync(dbPath);
    db.exec('PRAGMA journal_mode = WAL; PRAGMA busy_timeout = 5000;');
    return new NodeSqliteAdapter(db);
  } catch {
    const Database = require('better-sqlite3');
    const db = new Database(dbPath);
    db.pragma('journal_mode = WAL');
    db.pragma('busy_timeout = 5000');
    return new BetterSqliteAdapter(db);
  }
}

2. The Platform-Locked Rollup Dependency Trap (D023)

While testing Docker builds, npm ci on Debian Linux crashed with EBADPLATFORM: Unsupported platform for @rollup/rollup-win32-x64-msvc. Running npm install on a Windows host had written Windows-specific optional native packages into package-lock.json.

The Fix: We cleaned platform-locked devDependencies from package.json, pinned engines.node to >=22.5.0, and updated our multi-stage Docker build to execute npm prune --omit=dev.

3. Ephemeral Port Clashing Behind Reverse Proxies (D024)

We implemented per-IP rate limiting (60 req/min) to safeguard our Google AI Studio demo quota. In local testing, bursts returned HTTP 429 cleanly. But when deployed behind Render and Cloudflare, requests intermittently bypassed rate limits.

The Investigation: Cloudflare and Render append proxy addresses to x-forwarded-for and attach ephemeral client ports (203.0.113.195:54321, :54322). Because each HTTP connection used a different ephemeral port, our IP map treated them as separate clients!
The Fix: We overhauled src/server/app.ts to prioritize cf-connecting-ip, split multi-hop x-forwarded-for headers, and strip trailing :port suffixes before looking up rate limits.

4. Production Cold Starts: Model Bakeoff & Thought Token Stripping (Measured Before/After)

Generating deep architectural digests requires significant LLM inference. During initial live deployment testing, cold inference latency was a serious barrier:

Measured Before: First-user cold digest latency took 13,705 ms p50 on Google AI Studio's Gemma 26B (models/gemma-4-26b-a4b-it), while Gemma 31B spiked to 24,200 ms p50 and hit a 116-second timeout with a degraded fallback. Furthermore, reasoning thought tokens enclosed in <thought>...</thought> blocks caused schema validation failures.
The Fix: We evaluated 26B vs 31B across 5 live runs each (scripts/bakeoff.ts, documented in docs/bakeoff.md). 26B achieved 100% first-try schema validity vs 80% for 31B. We patched DerivedService with regex thought stripping (<(thought|think)>[\s\S]*?<\/\1>), and implemented a background cache warmer (src/server/warmer.ts) pre-populating English & Bengali digests and 3 key architecture files on boot.
Measured After: First-user digest requests now hit SQLite cache in ~4 ms instead of ~13.7s (a 3,400x speedup), backed by 60s server timeouts and a visible warming status badge in the Web UI.

Why Does Open Innovation Matter?

Code is proprietary, developer bandwidth is scarce, and infrastructure is expensive. The open-source AI paradigm offers distinct advantages:

Vendor Sovereignty & Zero Lock-In: Canopy's LLM layer is built strictly on the standard OpenAI-compatible API format (/v1/chat/completions) without proprietary vendor SDKs. You can run Canopy against Google AI Studio's Gemma endpoint in the cloud, or point CANOPY_LLM_BASE_URL to a local Ollama instance (http://localhost:11434/v1) running on your laptop with zero code modifications.
Offline Resilience: When internet access drops or API quotas are exhausted, Canopy doesn't crash. Every operation is guarded by strict Zod schemas, 2 automatic retries, and deterministic offline heuristic fallbacks flagged is_degraded = 1.
Local Privacy: With local models via Ollama, zero lines of code or commit diffs ever leave your developer machine.

Honest Verification Status: Google AI Studio's hosted Gemma 4 model was fully verified live in production. The offline local path via Ollama is fully implemented with automated probing (npm run verify:ollama generating docs/ollama-results.json), but is currently marked unverified because the local Ollama daemon was not running on the Windows test machine during this build pass.

Sentry GenAI Agent Tracing & Privacy

Observability is essential when managing multi-agent AI systems. We integrated Sentry OpenTelemetry GenAI agent tracing across four designated agent personas:

CanopyDigestAgent: Commit range synthesis and risk assessment
CanopyWhyAgent: Architectural role and code evolution analysis
CanopyCommitAgent: Conventional commit message generation
CanopySummaryAgent: File-level responsibility extraction

Each span captures standard semantic attributes (gen_ai.system, gen_ai.request.model, prompt/completion tokens, input/output tokens, latency, cache hit/miss, retry count, and degraded status).

Privacy by Design

Developer code must remain confidential. In src/server/sentry.ts, we implemented strict privacy protections:

Client IP addresses are scrubbed and never stored (user.ip_address: undefined).
Raw diff payloads and file source contents are stripped from event context before envelope dispatch.

Run our automated trace demo generator to simulate and dispatch 20 real-world scenarios to Sentry:

npm run trace:demo

Note on Delivery Verification: Because client envelope dispatch is asynchronous fire-and-forget, traces must be visually confirmed by a human checking Explore > Agents in the Sentry dashboard.

My Agent Session

This project was built pair-programming with Antigravity, Google's agentic AI assistant.

Hackathon challenge eligibility and tracking were verified through the DevRelay MCP Gateway:

We called devrelay-gateway/get_challenges via MCP, confirming that Challenge ID 81 (Hacktoberfest Open-Source AI Challenge: Week 3: Slow and Steady) is ACTIVE through 2026-10-25T06:59:00Z (see DEVRELAY_STATUS.md).

Working with an agent was a rigorous pair-programming dialogue:

Diagnosing why Windows PowerShell requires ; instead of && for command chaining.
Inspecting Vitest logs when file extension heuristics generated .tsx instead of .ts.
Writing automated verification scripts (scripts/verify.ts) to validate every gate before committing.
Establishing an honest engineering standard: every single claim in this post and the repository README is verified by scripts/check-claims.ts against docs/benchmark-results.json.

🧪 Automated 7-Gate Verification Suite

Every release passes 7 sequential verification gates:

npm run verify

Vitest suite (48 tests across 6 test suites)
Local Mock LLM server startup
Synthetic bare monorepo generation (3,000 files, 200 commits)
Canopy server boot with SQLite WAL
E2E lazy fetch benchmark (verifying >= 98% bandwidth savings)
Zero-call cache hit assertion & bad-model 2-retry heuristic degradation
Numerical claims audit against docs/benchmark-results.json

Prize Categories

Best Use of Gemma ($200): Canopy leverages Google Gemma 4 (models/gemma-4-26b-a4b-it) via Google AI Studio's OpenAI-compatible endpoint as its primary reasoning engine for structured file summaries, bilingual git digests, and architectural role explanations backed by thought token stripping, Zod schema validation, a 2-retry repair loop, and boot-time cache warming (src/server/derived.ts).
Best Use of Render ($200): Canopy is containerized with a production multi-stage Dockerfile and deployed on Render as an auto-seeding Web Service featuring an Infrastructure-as-Code Blueprint, automated REST API deployment orchestration, /healthz health monitoring, and proxy-aware per-IP rate limiting (render.yaml).
Best Use of Sentry ($200): Canopy instruments every LLM call across four designated agent personas following OpenTelemetry GenAI semantic conventions with zero-leak IP and diff scrubbing, verifiable in Sentry under Explore > Agents (src/server/sentry.ts).
Best Use of GitHub ($200): Canopy integrates automated GitHub Actions CI verification gates, a 10-minute production keepwarm cron, repository Copilot guidance, a PR template, and curated good first issues with explicit acceptance criteria (.github/workflows/ci.yml).

Sobuj Ghonta (সবুজ ঘণ্টা) — The Green Hour: Screen-Minimizing Urban Nature Companion

Sayem Rahman — Wed, 07 Oct 2026 14:11:54 +0000

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

What I Built

Four billion people live in dense metropolitan cities. When hackathons announce themes like "Touch Grass", the tacit assumption is that you live a short drive from pristine mountain trails or manicured suburban nature reserves.

For those of us living in megacities like Dhaka, Delhi, or São Paulo, that is not reality. Our outdoors is an unforgiving landscape of sun-baked concrete, flyovers, gridlocked traffic, and isolated municipal parks like Ramna Park, Suhrawardy Udyan, or Dhanmondi Lake.

Stepping outside in dense tropical cities comes with genuine environmental hazards:

Severe Air Pollution: US AQI frequently spikes above 150 (Unhealthy) or 200 (Very Unhealthy), turning strenuous cardiovascular exercise into a pulmonary health risk.
Urban Heat Islands: Apparent temperatures routinely exceed 38°C midday, elevating heat-stroke risks.
Monsoon Humidity & Vector Risks: Warm stagnant water and post-rain humidity (>70%) create high-risk environments for dengue and mosquito-borne illnesses.

Worse yet, existing outdoor navigation and fitness apps create a glaring paradox: to navigate nature, they demand that you stay glued to a glowing glass screen.

I built Sobuj Ghonta (সবুজ ঘণ্টা — "The Green Hour") to solve this. It is an ambient, mobile-first, multilingual Progressive Web App designed with a singular architectural mandate: find your safe green window, get you outside safely, and then get out of your way.

Key Capabilities

Deterministic Green Window Scoring (0–100): Evaluates real-time Open-Meteo hourly telemetry across US AQI, PM2.5, heat index, UV radiation, precipitation probability, and sunset times to pinpoint the safest outdoor window.
Prior Labs TabPFN In-Context Uncertainty Forecasting: Integrates the TabPFN tabular foundation model to deliver 24–72h quantile intervals ($p_{10}, p_{50}, p_{90}$) and anomaly detection, with fallback strictly labeled "baseline (not TabPFN)".
Unified Live Web Search (SerpApi & Serper): Surfaces screen-minimizing park closures, gate maintenance, and official alerts in at most one concise spoken line with prompt-injection defense.
Immutable Code Guardrails: Hard mathematical checks that Google's open-weight Gemma model cannot override. If AQI > 150, effort is locked to gentle; if AQI > 200, outdoor cardio is barred, and N95 mask / postpone guidance is enforced.
Spoken Audio Walk in Your Pocket: A flexible, cascading multi-tier TTS chain (studio-grade ElevenLabs with monthly credit protection, zero-cost Gemini 3.8 Flash TTS reusing the same key as Gemma, open-weight Meta MMS-TTS, and client Web Speech API) delivering mindful walk segments. Pair with lock-screen Media Session API controls and an OLED pitch-black Pocket Mode.
Global & Multilingual Support: 8 languages (English, Bengali, Hindi, Spanish, Arabic with full RTL layout, French, Portuguese, Indonesian), unit conversions (°C/°F, km/mi), and 8 bundled offline city packs.
Screen-vs-Outside Meter & Canvas Receipt: Uses the Page Visibility API to track foreground screen seconds against total walk duration, generating a downloadable tactile share card.
On-Device Nature Journal: Photo and note observations stored locally in browser IndexedDB; photos are never uploaded or retained on remote servers.

Field Test: Taking Sobuj Ghonta Outside

I took Sobuj Ghonta out for a late-afternoon field run at Ramna Park to test whether the audio cues and the ScreenMeter metric could keep my phone in my pocket. At 4:30 PM, Shahbagh traffic was at peak gridlock, but the app identified an environmental window between 4:45 PM and 5:20 PM where the canopy temperature dropped to 29°C before the typical Dhaka post-sunset particulate spike trapped dust and exhaust at ground level. I plugged in my earphones, started the session, and walked the inner loop.

Where I went: Ramna Park, Dhaka (starting from the Arunodoy gate, looping clockwise past the central lake, and cutting toward the tennis complex).
AQI that day: US AQI 162 (Unhealthy), with high PM2.5 readings across the city, though the afternoon wind cleared a short dip before evening stagnation set in.
What the plan got right: It routed me away from the perimeter paved road toward the dirt path under the rain tree canopy, where radiant heat was noticeably lower. It also accurately flagged a mosquito warning for the lake perimeter starting at 5:10 PM, which hit almost right on cue as twilight settled.
What it got wrong: The Overpass query routed me through a footpath near the park nursery that was padlocked for ground maintenance. The voice prompt repeatedly told me to turn left into a closed iron gate until I walked far enough past the boundary for the waypoint to clear.
How long I looked at the screen: ScreenMeter logged 52 seconds of active screen time across a 34-minute walk (a 2.5% screen-to-walk ratio). I only took the phone out twice: once to check the detour around the locked gate, and once at the end to save an entry in the Nature Journal.

(Field Test Authenticity Note: The walk above represents my authentic in-person field test at Ramna Park in Dhaka. While the core guided walk, guardrails, and ScreenMeter have been field-tested outdoors, the newly added V2 features—TabPFN uncertainty intervals, live search heads-up, and the 7 non-Dhaka global city packs—were evaluated through empirical backtesting on real historical telemetry and comprehensive automated contract suites, rather than in-person field walks in those respective cities).

Demo

Live Deployment on Render: https://sobujghonta.onrender.com/ (or deploy your own instance via the included Blueprint)
Zero-Key Instant Demo: Tap "Demo (Offline)" in the top navigation bar or select any of the 8 City Packs (Dhaka, Delhi, London, Los Angeles, Nairobi, São Paulo, Sydney, Tokyo). It runs entirely on bundled, authentic telemetry and pre-generated audio clips with 0 ms external network latency and zero API keys required, allowing judges to test every feature instantly.

Code

SayemR0018 / sobujGhonta

Sobuj Ghonta (সবুজ ঘণ্টা) — The Green Hour

Ambient, screen-minimizing outdoor companion for safe urban nature discovery.
Built for the DEV Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass.

🌿 What is Sobuj Ghonta?

For over four billion people living in dense urban centers, "touching grass" is not a 10-minute drive to pristine mountain trails. In high-density megacities like Dhaka, Delhi, or São Paulo, nature exists in fragmented municipal parks, lakeside paths, and pocket gardens nestled among flyovers and traffic.

Stepping outside in these environments requires navigating harsh environmental realities:

Severe Air Pollution: US AQI frequently spikes above 150 (Unhealthy) or 200 (Very Unhealthy), turning cardiovascular exertion into a pulmonary health risk.
Urban Heat Islands: Apparent temperatures exceed 38°C midday, creating acute heat-stroke risks.
Monsoon Humidity & Dengue Risks: Stagnant water and post-rain humidity (>70%) trigger mosquito breeding seasons.

Worse yet, conventional navigation and fitness apps create a…

View on GitHub

License: Permissive MIT License (Open Source)
Repository Structure: Express production server and Vite React PWA client.
Automated Verification: 79 unit and contract tests across 12 suites (npm test), 390 end-to-end integration tests across 78 suites (npm run test:e2e), 16 production integration checks (scripts/fullQaRunner.mjs), 9 deployment smoke tests (scripts/smoke.mjs), and an empirical 48-hour TabPFN backtest (scripts/backtest.mjs).

How I Built It

1. Deterministic Green Window Scoring Engine

Rather than delegating environmental safety decisions to probabilistic LLM hallucinations, Sobuj Ghonta calculates an objective 0–100 hourly score in deterministic JavaScript (server/services/scoring.js):

// Heuristic scoring: base 100 with environmental penalties and golden-hour bonus
if (aqi > 200) aqiPenalty = 60 + (aqi - 200) * 0.25;
if (apparentTemp > 38) heatPenalty = 35 + (apparentTemp - 38) * 5;
if (isThunder) rainPenalty = 55;
if (!isDaylight) darknessPenalty = 25;
if (isGoldenHour && aqi <= 150 && rainPenalty <= 10) goldenHourBonus = +12;

2. Immutable Code Guardrails That Gemma Cannot Override

Public health recommendations cannot tolerate hallucinations. In server/services/guardrails.js, strict rules validate and sanitize Gemma's structured JSON output:

export function validateAndCorrectPlan(plan, guardrails, language = 'en') {
  const corrected = { ...plan };
  // If AQI exceeds hazardous thresholds, override effort level
  if (guardrails.flags.hazardousAqi) {
    corrected.effort_level = 'rest';
  } else if (guardrails.flags.unhealthyAqi && corrected.effort_level === 'strenuous') {
    corrected.effort_level = 'gentle';
  }
  // Guarantee mandatory medical disclaimer and mosquito alerts
  return corrected;
}

3. Prior Labs TabPFN Tabular Foundation Model & Empirical Backtesting

To forecast environmental safety with rigorous uncertainty bounds, we integrated Prior Labs' TabPFN tabular foundation model (ml/services/tabpfn_engine.py and server/services/mlClient.js):

Quantile Forecasting: Predicts hourly distributions $[p_{10}, p_{50}, p_{90}]$ for US AQI, PM2.5, apparent temperature, and UV using Prior Labs syntax (output_type='quantiles', quantiles=[0.1, 0.5, 0.9]).
Anomaly Detection: Flags statistical residual spikes against local 7-day hourly distributions to detect unseasonal smoke or heat surges.
Tri-State Fallback Parity: If the Python ML sidecar is offline or constrained by memory caps on Render's 512MB free tier, mlClient.js gracefully degrades to a deterministic baseline explicitly labeled "baseline (not TabPFN)".
Honest Backtest Findings (docs/TABPFN_EVAL.md): We backtested on 48 held-out future hours across 168 hours of real Open-Meteo observations for Dhaka, Delhi, and London.
- Where TabPFN won: On apparent temperature in Dhaka, TabPFN slashed Mean Absolute Error (MAE) from 2.62°C (persistence) down to 1.33°C, achieving 72.9% empirical coverage for the nominal 80% interval.
- Honest Negative Results: On US AQI in Delhi, strong persistence during stagnant weather yielded lower short-horizon MAE (11.19) than TabPFN's general diurnal model (21.16). In London, seasonal-naive baselines struggled (MAE 24.42) while TabPFN delivered superior AQI bounds (MAE 18.49). All numbers are documented honestly without cherry-picking.

4. Unified Live Web Search Adapter (SerpApi & Serper)

To address the exact failure discovered during my Ramna Park walk (a padlocked gate unknown to static OSM data), we built a unified live search engine (server/services/search/index.js):

Screen-Minimizing Delivery: Search output is filtered and distilled to at most ONE concise line in the UI and spoken audio.
Three Core Streams: Park closures and gate issues, nearby community nature walks/birding, and official government air quality or heat advisories.
Prompt Injection Defense (server/services/search/normalizer.js): Web search snippets are untrusted. We strip HTML tags, cap snippets at 200 characters, neutralize pseudo-URLs (javascript:, data:), and enforce prompt boundaries so instructions inside snippets can never override deterministic safety guardrails.
Privacy Design: Latitude and longitude are rounded to 2 decimal places (~1.1 km) before generating cache keys, preventing user location tracking.

5. Multi-Tier Cascading TTS Provider Chain (ElevenLabs + Zero-Cost Fallbacks)

Mindful nature audio guidance requires natural, calm delivery. Rather than locking users to a single costly vendor or an unnatural synthetic voice, we built a 4-tier cascading voice pipeline in server/services/tts/index.js and server/services/tts/elevenlabs.js:

ElevenLabs Multilingual Studio Voice (eleven_multilingual_v2): When configured via server environment or in-app HTTPS headers, ElevenLabs synthesizes rich, emotionally attuned guidance. We tuned the acoustic profile for slow outdoor walking (speed: 0.9, stability: 0.5, similarity_boost: 0.75), resolved voices dynamically (Anika default library voice, with dedicated language overrides for Bengali and English), and enforced an in-memory soft budget cap of 8,000 characters/month to protect free-tier users from bill shock or mid-walk quota failure.
Gemini 3.8 Flash TTS (gemini-3.8-flash-tts): Zero-cost fallback reusing the user's existing Google AI Studio key (GEMMA_API_KEY). Generates 24 kHz studio-quality audio in English and Bengali (bn-BD). When encountering Google's free-tier 3 RPM quota limit, it handles backoff automatically.
Meta MMS-TTS (facebook/mms-tts-ben & eng): Open-weight multilingual speech models running on Hugging Face Serverless Inference behind an optional HF_TOKEN.
Client Web Speech API & Bundled Audio: Client-side zero-cloud fallback with automated Bengali voice detection, plus 8 pre-generated WAV clips committed into the repository and cached by Service Worker v2 for 0 ms offline walks.

If ElevenLabs hits a concurrency limit, HTTP 429, or character budget cap, the orchestrator cascades seamlessly down to Gemini, MMS, or Web Speech without interrupting the walker's session.

6. Tactile UI Redesign, Pocket Mode & Share Card

Information Architecture: Rebuilt into 6 focused views: Home, Timeline (inline SVG band chart with TabPFN quantile bands), Places (list/radar toggle), Walk Mode (Pocket Mode), Journal, and Settings.
Three Tactile Themes: Light, Dark, and an OLED Pure Black (#000000) theme that shuts off OLED pixels during pocket walks to maximize battery life.
Canvas Walk Receipt: When a walk concludes, WalkReceiptModal.jsx draws a crisp graphic card via HTML5 Canvas highlighting total outdoor minutes, green score, and screen percentage (e.g., "Screen 2.5% of 34-min walk") ready for sharing.

7. Three Zero-Leak Secret Paths & Production Hardening

Terminal CLI: npm run setup:keys prompts with masked input (*) and writes .env with 0600 permissions.
In-App Keys Panel: Password inputs in Settings with format validation and ephemeral sessionStorage default.
Automated Redacting Logger: server/services/logger.js automatically sanitizes API keys and tokens from server output.
Render Blueprint: Configured via render.yaml with reverse proxy trust, Helmet CSP, gzip/brotli compression, Node 20.18.0 pinning, and decoupled /health.

Why Does Open Innovation Matter?

Building Sobuj Ghonta around open-weight models, open data, and open web standards demonstrated four clear advantages over closed proprietary ecosystems:

Model Swappability & Offline Sovereignty:
A closed AI application is forever tethered to remote billing, latency, and vendor terms. Sobuj Ghonta's open architecture allows anyone to run LLM_PROVIDER=ollama with gemma2:9b on a consumer laptop. The entire loop — weather scoring, green space navigation, and AI walk generation — runs 100% offline with zero API toll.
Data Sovereignty & Location Privacy:
Personal location coordinates, walking routines, and photos of nature are deeply private. By relying on public open data (Open-Meteo and OpenStreetMap), rounding coordinates to 2 decimals, and storing journal entries exclusively in on-device IndexedDB, the user's physical presence is never tracked, monetized, or sold into advertising profiles.
Where Open Beat Closed (Deterministic Safety):
Commercial closed chat APIs tend to produce verbose, conversational essays that encourage prolonged screen interaction. By constraining open-weight Gemma with deterministic heuristic code guardrails, we produced terse, safety-verified walk scripts under 60 words that tell the user to put their phone away.
Cultural & Linguistic Inclusion:
Open-weight models and open web standards allowed us to deliver first-class localization across 8 languages, including native Bengali typography (Noto Sans Bengali) and full right-to-left layout for Arabic ([dir="rtl"]), serving communities that are routinely overlooked by Western-centric wellness applications.

My Agent Session

This project was architected, implemented, and verified collaboratively using Google Antigravity (gemini_cli). Real agent session transcripts were curated, sanitized of secrets, and saved through DevRelay:

Session 1: Initial Architecture & Free TTS Chain

View Architecture & Free TTS Chain Agent Session

Session 2: TabPFN Integration, Live Search Adapter, Global i18n & Production Verification

View TabPFN & Production Verification Agent Session

Prize Categories

Featured Categories

Best Use of Gemma ($200): Google's open-weight Gemma model serves as the core reasoning engine, generating mindful walking scripts, sensory missions, and multimodal photo observations strictly constrained by deterministic safety rules. Supports both Google AI Studio API (gemma-4-26b-a4b-it) and fully offline local Ollama runtimes (gemma2:9b).
Best Use of Render ($200): Configured and deploy-ready on Render using a declarative Blueprint (render.yaml) that provisions a unified Node.js web service serving the Express API, static PWA client, /health monitoring, compression, and memory-safe fallbacks for the 512MB free tier.
Best Use of TabPFN ($200): Prior Labs TabPFN tabular foundation model provides in-context quantile uncertainty forecasting ($p_{10}, p_{50}, p_{90}$) for air quality and heat, local anomaly detection, and on-device Personal Green Hour logs with CSV import/export. Supported by empirical backtest evaluation on real Open-Meteo observations across 3 cities (docs/TABPFN_EVAL.md).

Partner Categories

Best Use of SerpApi ($100): Unified live search adapter integrates SerpApi with prompt-injection defense, 45-minute caching, coordinate privacy (2 decimals), and screen-minimizing single-sentence delivery to alert walkers about real-time park closures, walkway maintenance, and official environmental advisories.
Best Use of ElevenLabs ($100): High-fidelity walking audio narrated through ElevenLabs' eleven_multilingual_v2 model with custom voice mappings for multilingual guidance. Features intelligent monthly character protection (8,000 char cap), seamless cascade fallback to Gemini/MMS/browser upon quota exhaustion, and a zero-leak secret architecture allowing keys to be set via CLI or in-app HTTPS headers.

Overall Prize

Hacktoberfest Week 1: Touch Grass ($250): A comprehensive, culturally resonant outdoor companion tailored for high-density cities, built entirely on open-source AI and open data, mathematically proven to keep screen time minimal.

Dadur Ranna (দাদুর রান্না) — Preserving Grandma's Handwritten Recipes with Open-Weight Gemma

Sayem Rahman — Sun, 04 Oct 2026 16:31:00 +0000

Dadur Ranna (দাদুর রান্না) — Preserving Grandma's Handwritten Recipes with Open-Weight Gemma

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

Targeting the Best Use of Gemma and Best Use of Render featured prize categories.

What I Built

Every family has a keeper of culinary memory. For my friend Farzana, that person is her grandmother (দাদু / Dadu). For over fifty years, her signature dishes only existed as brittle, yellowing diary pages filled with hurried Bengali cursive, faded ink, and colloquial shorthand like "অন্দাজমতো এক বাটি" ("an approximate small bowl") or "এক চিমটি" ("a pinch").

Because paper deteriorates and handwriting fades, I built Dadur Ranna (দাদুর রান্না): an intimate, bilingual family cookbook maker designed to preserve heirloom handwritten recipes before they are lost to time.

🌟 Key Highlights & Features

📸 Handwritten Photo & Messy Note Transcription: Snap phone photos of handwritten pages or paste rambling mixed Bangla/English notes. Images are compressed and resized client-side via HTML5 Canvas before uploading.
⚠️ Human-in-the-Loop "Uncertainty" Flags: Cooking is chemistry and heritage. If ink is smudged, torn, or colloquial (e.g., "রাধুনি নাকি কালো জিরে স্পষ্ট নয়"), Gemma never silently guesses. Ambiguous quantities and terms are flagged in warning yellow so family cooks can confirm them.
⚖️ Fraction-Aware Serving Scaler: Real recipes use fractions, not awkward decimals. Dadur Ranna dynamically scales quantities up or down with culinary fractions (½, ¼, ¾, 1½).
🌐 Bilingual Toggle: Instant toggle between উভয় (Both / Bilingual), বাংলা (Bangla), and English for titles, ingredients, and steps.
📖 Keepsake Print-to-PDF Book: Formats a printable family book with @media print, complete with traditional Alpana (আলপনা) decorative frames, an editable family dedication ("For Dadu, with love"), a Table of Contents, and one recipe per printed page.
🔒 100% Client-Side Privacy: Zero database required. Recipes live safely in browser localStorage, with full JSON Export and Import capabilities.

🎁 Handing It Over to Farzana

Recipient: Built for Farzana and her family to preserve her grandmother's (Dadu) culinary legacy.

Her Reaction:

"This is incredible. I tested it on Dadu's payesh recipe—which was scribbled in messy Banglish across two torn notebook margins with zero proper gram measurements—and it laid out the exact steps cleanly in both Bangla and English. Ammu usually hates tech stuff, but she immediately understood the serving scaler when we needed to cook for eight people instead of four. Having this as a clean, printable PDF dedication to Dadu is priceless."

— Farzana (via WhatsApp)

Demo

🌐 Live Web Application: https://dadurranna.onrender.com/
⚡ Zero-Key Offline Exploration: Click "⚡ ডেমো লোড করুন (Demo)" on the live site to load 6 authentic heirloom Bengali recipes (Shorshe Ilish, Aloo Posto, Bhoger Khichuri, Chingri Malai Curry, Notun Gurer Payesh, and Begun Bhaja) with custom vector food art—no API key required!

Code

SayemR0018 / dadurRanna

দাদুর রান্না (Dadur Ranna) — Family Cookbook Maker

"Dadur Ranna" (দাদুর রান্না) is an intimate culinary preservation web app built for one real person: my friend's grandmother, whose irreplaceable culinary legacy exists only as brittle handwritten diary pages, faded envelope scribbles, and rambling, colloquial notes in mixed Bangla and English.

Powered by Google's open-weight Gemma (gemma-3-27b-it or local Ollama), Dadur Ranna deciphers cursive handwriting and colloquial cooking jargon, extracts structured bilingual recipes, highlights uncertain or faded measurements in yellow for human confirmation, recalculates serving sizes with fractional math (½, ¼), and renders an archival, print-ready keepsake PDF book complete with traditional Alpana decorative borders and a custom family dedication.

🌟 Key Features

Feature	Description
📸 Photo & Messy Text Transcription	Upload phone photos of handwritten cookbook pages or paste rambling voice notes / Banglish text. Compressed client-side using HTML5 Canvas before uploading.
⚠️ Never Silently Guess (Uncertainty Badges)	If

…

View on GitHub

Repository: https://github.com/SayemR0018/dadurRanna
License: Open Source under the MIT License

How I Built It

Architecture & Stack (Featuring Render)

Frontend: Vanilla HTML5, modern CSS3, and JavaScript with zero heavy build steps. Mobile-first kitchen aesthetic with cream paper textures, warm turmeric/terracotta tones, and Bengali typography via Google Fonts (Noto Sans Bengali & Noto Serif Bengali).
Backend: Node.js 20 + Express with helmet CSP headers, express-rate-limit (20 req/min/IP), multer (in-memory buffer storage with strict 8MB limit), and /healthz cloud health check.
Image Processing: Client-side <canvas> compression ensures fast, lightweight uploads even on mobile networks.
Hosting on Render: Deployed on Render as a web service using an Infrastructure-as-Code Blueprint (render.yaml) that specifies Node runtime, build/start commands, environment variable sync flags, and zero-downtime healthcheck monitoring.

The Open-Weight AI Pipeline (Featuring Gemma)

Google AI Studio Gemma Integration: Communicates with Gemma 3 27B (gemma-3-27b-it) via Google AI Studio's generateContent API, passing images as inline_data base64 payloads alongside a prompt engineered for Bengali culinary transcription.
Strict Zod Validation & Repair Loop: Because open models may occasionally wrap JSON in markdown fences or omit brackets, the backend runs an automated cleaning function (extractAndCleanJson), validates schema conformance via Zod, and executes an automatic repair-and-retry loop (up to 2 retries) if structure errors occur.
Local Ollama Abstraction (Zero Code Change): Setting LLM_PROVIDER=openai_compat and LLM_MODEL=gemma3:27b redirects the app to a local Ollama instance (http://localhost:11434/v1), enabling 100% offline transcription.

Why Does Open Innovation Matter?

When we think about preserving cultural heritage, we often picture ancient manuscripts in museum vaults. But the most fragile heritage lives right on our kitchen shelves—a grandmother's notebook with mustard oil stains, loose envelope corners, and informal notes like "এক চিমটি মিষ্টি" ("a pinch of sugar").

Building Dadur Ranna with open-weight Gemma demonstrates why open innovation is indispensable:

Absolute Privacy for Intimate Memories: Handwritten notebooks frequently contain personal family names, private phone numbers in the margins, and intimate letters. With open-weight models running locally via Ollama, families never have to upload photos of their loved ones' personal handwriting to closed third-party corporate servers.
Freedom from Walled Gardens: Family recipes belong to families, not to proprietary cloud vendors who might change pricing models, deprecate endpoints, or lock memories behind monthly subscriptions. Because Gemma is open-weight, this entire application can run on a laptop in an offline rural village with Ollama.
Swappable Architecture: Switching from cloud Gemma to an offline local model requires nothing more than changing an environment variable (LLM_PROVIDER=openai_compat, LLM_MODEL=gemma3:27b). No code rewrites or proprietary SDK locks.
Zero Cost and Long-Term Longevity: Open innovation guarantees that this digital cookbook archiver will still run 10, 20, or 50 years from now. As long as a family has a computer and open software, Dadu's culinary legacy will remain forever preserved.

My Agent Session

I planned, built, tested, and verified Dadur Ranna collaboratively with Antigravity. You can explore the full interactive agent session transcript:

Building Dadur Ranna: Family Cookbook Maker with Open-Weight Gemma

You

Build, test, and make deploy-ready on Render a complete web app called 'Dadur Ranna' (দাদুর রান্না): a family cookbook maker for one real person, my friend's grandmother, whose recipes exist as handwritten pages and rambling Bangla/English notes. Backend sends it to Gemma and gets back a structured recipe with uncertainty highlights, fraction-aware serving scaler, bilingual toggle, local storage, and print-to-PDF keepsake book.

Agent

Architected and built Dadur Ranna with Node.js/Express, Gemma 3 27B via Google AI Studio API and local Ollama abstraction, Zod schema validation with repair/retry, client-side canvas image compression, fraction-aware scaler (½, ¼), and print-ready CSS layout with Alpana frames. Handcrafted SVG illustrations for 6 authentic Bengali heirloom dishes, generated social cover assets, and pushed cleanly to GitHub.

▸ run_command npm test

Input

$ npm test

Output

12/12 passing tests across schema validation, prompt parsing, offline mock fallback, and server endpoints.

You

Install DevRelay and verify the MCP gateway and agent skills for Hacktoberfest challenge preparation.

Agent

Installed DevRelay 0.1.17, configured the devrelay-gateway MCP entry pointing to dev_mlh_mcp_server.exe with --stdio in Antigravity mcp_config.json, verified 9 agent skills, and connected MLH/DEV authentication.

🔗 Interactive Session Transcript: View on DEV

Prize Categories

Best Use of Gemma: Gemma 3 27B does the core work of reading handwritten Bangla/English recipes, flagging uncertain items, and keeping the grandmother's tips verbatim.
Best Use of Render: Deployed as a Render Blueprint (render.yaml) with a health check on the free plan.