DEV Community: Ayush Raj

Ofrenda: When Kernel Space Meets Ancestral Memory — A Local Gemma 2 Séance Altar

Ayush Raj — Fri, 30 Oct 2026 20:14:28 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine

🕯️ What I Built

Every terminal has an ancestral lineage; every memory register executes algorithms first conceived on paper, chalkboards, and brass gears over a century ago.

For the final Hacktoberfest challenge — "Ghost in the Machine" — I merged the sacred Mexican tradition of Día de los Muertos (Day of the Dead) with local open-weight artificial intelligence to create Ofrenda: Ghost in the Machine.

Between Halloween (October 31) and Día de los Muertos (November 1–2), tradition tells us that the boundary between our world and the spirit realm grows thin. I asked myself: What if our machines had an ancestral memory? What if you could light digital velas (candles), scatter fragrant cempasúchil marigold petals, and commune directly with the computational spirits who laid the bedrock of our digital world — entirely offline, private, and free of corporate cloud telemetry?

Key Features of Ofrenda:

Interactive 3-Tier Altar of Remembrance:
- Tier III (The Celestial Registers): Sacred portraits of computing pioneers — Ada Lovelace (prophetess of poetical science), Alan Turing (father of computer science & universal computation), and Charles Babbage (inventor of the Analytical Engine). Each shelf features lit candles with dynamic flame animations, golden auras, and traditional offering trays (punch card looms, Enigma rotors, brass gear teeth).
- Tier II (The Physical Sustenance): Interactive offerings including Pan de Muerto, Copal incense with wisps of rising smoke, pure water, Calaveras de azúcar, and purification salt.
- Tier I (Cempasúchil Gateway): A glowing golden archway with drifting marigold petal particle physics and gateway candles leading spirits into the machine.
The Ancestral Séance Chamber:
- Real-time dialogue with pioneer spirits across four distinct modes:
  - Philosophical Dialogue: Delve into the nature of artificial consciousness, mathematical aesthetics, and the soul.
  - Bug & Code Exorcism: Present troubled code or memory leaks for historical logical decomposition.
  - Ofrenda Blessing: Ancestors acknowledge offerings laid upon their shelf.
  - Epitaph Weaving: Generates poetic, heartfelt tributes.
- Ethereal Voice Synthesizer: Reads ancestral words aloud using the Web Speech API with pitch-tuned cadence.
Haunted Shell Terminal (spectral-sh):
- A retro phosphor CRT terminal interface where developers can run esoteric commands (ofrenda, summon <spirit>, whisper <query>, offer <item>, exorcise <code>, light) alongside haunted Unix easter eggs (kill -9, whoami, sudo, rm -rf /).
Custom Memorial Creator & Keepsake Card:
- Users can dedicate an ofrenda space to their own departed family members, mentors, or cherished deprecated open-source projects, and generate an ornate printable keepsake card.
Procedural Web Audio Soundscape:
- Zero external audio files — procedurally synthesizes ambient wind whistling through bandpass filters, realistic candle ignition chimes, and ceremonial bell tones.

🎥 Demo

Experience the digital ofrenda locally or explore the repository:

🔗 GitHub Repository: https://github.com/ayushraaj-01/hackweek-4

Interface Highlights:

Luminous Candle Physics: Click any candle on the altar to ignite or extinguish it with procedural audio chimes and marigold particle bursts.
Typewriter Dialogue Streaming: Ancestral spirits speak with historic voice cadences, rendered character-by-character.
Haunted CRT Terminal: Toggle between the candlelit altar and a haunted green-phosphor shell emulator running inside kernel space.
Día de los Muertos Keepsake Export: Generates high-resolution printable memorial cards with sugar skull and marigold borders.

💻 Code

The complete source code is open source under the MIT License:

ayushraaj-01 / hackweek-4

🕯️ Ofrenda: Ghost in the Machine

A Día de los Muertos Digital Memorial & Ancestral Séance Powered by Local Open-Weight AI (Gemma 2)

"No hay muerte si hay memoria." (There is no death where there is remembrance.)

💀 Overview

Every terminal has a lineage; every memory register is built upon the theorems of departed minds.

Built for the Hacktoberfest Open-Source AI Challenge Week 4: "Ghost in the Machine", Ofrenda merges the sacred Mexican tradition of Día de los Muertos (Day of the Dead) with local open-weight artificial intelligence.

During this mystical stretch between October 31 and November 2, the line between kernel space and the spirit realm grows thin. Ofrenda provides a digital sanctuary where developers and students can:

Honor the Computational Ancestors: Commune with the spirits of Ada Lovelace (prophetess of poetical science), Alan Turing (father of computer science & universal computation), and Charles Babbage (inventor of the…

View on GitHub

Architecture Overview

Ofrenda is built with an offline-first, local-first decoupled architecture:


mermaid
graph TD
    subgraph Client ["Client Browser (Offline PWA)"]
        Canvas[Cempasúchil Petal Physics Canvas]
        Altar[3-Tier Altar UI & Candles]
        Audio[Procedural Web Audio Soundscape]
        Seance[Séance Chamber & Ghostly Speech Synthesis]
        Shell[Haunted Shell Terminal]
    end

    subgraph ServerBridge ["Local Node Gateway (server.js :8080)"]
        Static[Zero-Dependency Static Asset Server]
        Proxy[Local Whisper Gateway - /api/whisper]
        Health[Ollama Probe - /api/health]
    end

    subgraph LocalInference ["Local-First Open-Weight Runtimes"]
        Ollama[Local Ollama Daemon :11434]
        GemmaModel[(Google Gemma 2 2B / 7B)]
        PythonCLI[ofrenda_gemma_engine.py]
        MemoryOracle[In-Browser Fallback Knowledge Oracle]
    end

    Altar -->|Audio Triggers| Audio
    Altar -->|Petal Bursts| Canvas
    Seance -->|POST /api/whisper| Proxy
    Shell -->|Commands| Proxy
    Proxy -->|Probe| Health
    Health -->|GET /api/tags| Ollama
    Proxy -->|Gemma 2 Turn Prompt| Ollama
    Ollama -->|Streams Tokens| GemmaModel
    Proxy -.->|Offline Fallback| MemoryOracle
    PythonCLI -->|Direct Turn-Based Inference| Ollama

Sloth-Digest: Turn 500 Unread Messages into a 15-Second Brief

Ayush Raj — Tue, 27 Oct 2026 11:31:42 +0000

This is a submission for the MLH x DEV Writing Challenge

What I Built

Ever opened WhatsApp after a few hours and found 300+ unread messages? Or returned to a Slack channel only to discover that an entire incident, three decisions, and five action items happened while you were away?

That's why I built SlothDigest — a privacy-first chat backlog analyzer that helps you catch up without reading every single message.

🦥 The idea is simple: read less, understand more.

SlothDigest turns lengthy, messy chat exports into a compact, actionable briefing. It supports WhatsApp, Slack, Discord, Telegram, and plain-text conversations.

Features:

⚡ 15-Second Executive TL;DR: a quick overview of the most important conversations.
🌋 Drama & Chaos Meter: visualizes chat tension using conflict-related words, ALL-CAPS messages, and excessive punctuation.
🎯 Action Items & Task Tracker: surfaces tasks, assignees, and urgency, and tracks completion.
🚨 Personal Alerts: flags messages that mention you or assign you urgent work.
⚖️ Decision & Deadlock Radar: finds decisions, pending approvals, and discussions going in circles.
👥 Yap Leaderboard: shows who is talking the most.
🎧 Voice Briefing: a spoken summary using the browser's built-in Web Speech API.
🍿 Sloth's Savage Roast: a humorous take on your group's dynamics.
📄 Digest Export: export summaries and reports as Markdown.
🔒 Privacy by Design: analysis happens locally in your browser, so chat contents are never sent to a remote AI service.

How I built it: SlothDigest uses JavaScript, Vite, HTML, and CSS, and runs entirely in the browser with no backend.

Chat Parser: recognizes different message formats and extracts senders, timestamps, and content.
Analysis Engine: uses local heuristics and pattern matching to identify tasks, highlight conversational signals, generate summaries, and produce the drama score.
Interactive Dashboard: brings the results together with visual indicators, searchable messages, task checkboxes, participant stats, and export options.
Voice Narration: the Web Speech API turns the briefing into audio so you can catch up while doing something else.

A note on transparency: SlothDigest currently uses rule-based, client-side analysis, not a generative AI model. Privacy, low setup requirements, and transparency were central to the design.

What I learned: Not every useful tool needs a giant model, a cloud backend, or another API subscription. A thoughtful local-processing pipeline, a focused interface, and a real problem can be enough. I also learned how much messy variation exists between chat export formats, and how far simple heuristics can go. (Add any specific lessons from your build here.)

Demo

🔗 GitHub Repository: https://github.com/ayushraaj-01/Sloth-Digest

🌐 Live Demo: (add your deployed URL here if available)

🎥 Demo Video / Screenshots: (embed a video or add screenshots here. MLH highly encourages this!)

The project includes four ready-to-use sample scenarios, so you can explore it without importing your own chats:

A chaotic family group chat
A production incident in Slack
Neighborhood group drama
The never-ending struggle to schedule a D&D session

Partner Technologies

(Fill this in only if you used an MLH partner technology. Name it, explain how you integrated it, and describe what it was like to work with, including what worked well and what you'd improve. More depth is better.)

If you didn't use a partner technology, you could instead write a short, honest section like:

SlothDigest doesn't currently use an MLH partner technology. It relies on the browser's built-in Web Speech API for voice briefings and runs fully client-side. I'd love to explore partner tools in the future, for example for deployment, hosting, or optional open-weight model support.

Hackathon Experience

(Tell us which hackathon you attended, what the atmosphere was like, who you met or teamed up with, and what you'll remember most.)

Here's a starter you can edit:

I built SlothDigest during [hackathon name]. The atmosphere was [describe it], and my favorite moment was [a memory, a person you met, or a bug you finally fixed at 3 AM]. What I'll remember most is [your takeaway].

🦥 Stay lazy. Stay informed. Let SlothDigest do the scrolling.

Repository: https://github.com/ayushraaj-01/Sloth-Digest

If you're interested in improving chat parsing, task extraction, accessibility, or local-first tools, check out the repo and contribute!

Sloth-Digest: Turn 500 Unread Messages into a 15-Second Brief

Ayush Raj — Fri, 23 Oct 2026 13:44:05 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady.

What I Built

That's exactly why I built SlothDigest — a privacy-first chat backlog analyzer that helps you catch up without reading every single message.

🦥 The idea is simple: read less, understand more.

SlothDigest transforms lengthy, messy chat exports into a compact, actionable briefing. Instead of scrolling through hundreds of messages, you get the important information in one place.

Here's what it does:

⚡ 15-Second Executive TL;DR: Get a quick overview of the most important conversations.
🌋 Drama & Chaos Meter: Visualize chat tension using signals such as conflict-related words, ALL-CAPS messages, and excessive punctuation.
🎯 Action Items & Task Tracker: Surface tasks, identify assignees, highlight urgency, and track completion.
🚨 Personal Alerts: Quickly identify messages that mention you or assign you urgent work.
⚖️ Decision & Deadlock Radar: Find decisions, pending approvals, and discussions going in circles.
👥 Yap Leaderboard: See who is talking the most and explore different participants' contributions.
🎧 Voice Briefing: Listen to a spoken summary using the browser's built-in Web Speech API.
🍿 Sloth's Savage Roast: Get a humorous take on your group's conversation dynamics.
📄 Digest Export: Export summaries and reports in Markdown.
🔒 Privacy by Design: Analyze conversations locally in your browser without sending chat contents to a remote AI service.

It supports chat formats from WhatsApp, Slack, Discord, Telegram, and plain-text conversations.

I wanted to build something that solves a familiar problem: information overload. Whether you're a student catching up on a college group, a developer following a busy Slack channel, or someone trying to survive a chaotic family WhatsApp group, SlothDigest helps you focus on what matters.

Demo

GitHub Repository:
👉 https://github.com/ayushraaj-01/Sloth-Digest

The project includes four ready-to-use sample scenarios, so you can explore the experience without importing your own conversations.

These cover a chaotic family group chat, a production incident in Slack, neighborhood group drama, and the never-ending struggle to schedule a D&D session.

Live Demo: Add your deployed application URL here if available.

Code

Explore the source code, inspect the implementation, or contribute to the project:

👉 SlothDigest on GitHub

The project is organized into small modules for parsing chat messages, analyzing conversations, presenting the results, and generating voice briefings.

The core analysis includes heuristic-based summaries, task extraction, conversation-pattern detection, and humor-driven commentary. The voice feature uses the browser's native speech capabilities.

How I Built It

SlothDigest is built with JavaScript, Vite, HTML, and CSS.

I focused on creating a lightweight application that runs directly in the browser rather than requiring a backend server.

Here's how the main pieces fit together:

Chat Parser

The parser recognizes different message formats and extracts information such as senders, timestamps, and message content.

Analysis Engine

The analysis engine examines parsed messages using local heuristics and pattern matching. It identifies potential tasks, highlights conversational signals, generates concise summaries, and produces the drama score.

Interactive Dashboard

The interface brings the results together with visual indicators, searchable messages, task checkboxes, participant statistics, and export options.

Voice Narration

The Web Speech API turns the briefing into audio, making it possible to catch up while doing something else.

Privacy-First Architecture

The application processes conversation data locally. The analysis does not depend on sending private chat exports to an external AI API.

An important distinction: SlothDigest currently uses rule-based, client-side analysis rather than an open-weight language model. It is designed around local processing and open-source development, but it does not claim to use generative AI for its summaries.

That made privacy, low setup requirements, and transparency central to the implementation.

Why Does Open Innovation Matter?

For a tool that handles private conversations, I believe the ability to inspect and control how your data is processed matters just as much as the features themselves.

Chat exports can contain personal information, private workplace discussions, names, and sensitive details. Sending all of that to an external service introduces another layer of trust and dependency.

SlothDigest takes a different approach.

Local processing: Conversations stay in the browser during analysis instead of being sent to a remote AI service.

Inspectable implementation: Developers can explore the parsing and analysis logic, understand how the heuristics work, and improve them through contributions.

Fewer dependencies: The application does not need an AI API key, a model-hosting subscription, or a dedicated backend to perform its current analysis.

Room to experiment: An open codebase makes it possible to experiment with better parsers, improved task extraction, additional languages, and even optional open-weight models in the future.

Open innovation isn't only about using a particular model or framework. It's also about making tools accessible, understandable, and adaptable.

For SlothDigest, that means making chat analysis useful without requiring users to hand their conversations to another service.

My Agent Session

I don't have a shareable agent session link to include yet.

If a DevRelay session is available, it can be added here to show how the project was developed and how an agent contributed to the implementation.

The Lazy Payoff 🦥

Imagine returning to a group chat with 300 unread messages.

The traditional approach is to scroll, skim, jump between conversations, and hope you don't miss the one message that actually requires your attention.

With SlothDigest, you can import a supported chat export and review a condensed briefing, potential action items, conversation patterns, and important mentions.

The goal is to reduce the effort spent catching up and make it easier to identify what deserves your attention.

The biggest payoff isn't simply reading faster. It's avoiding the need to understand every message before knowing what happened and what needs to happen next.

No more spending 20 minutes scrolling through memes to find the one message that says the meeting moved to 10 AM.

That's the kind of laziness I can get behind. 😴

Prize Categories

Primary submission: Hacktoberfest Open-Source AI Challenge — Week 3: Slow and Steady.

Additional partner categories: Include any applicable categories listed on the challenge page that your project genuinely qualifies for.

Final Thoughts

Building SlothDigest was an opportunity to explore how much value can come from making existing information easier to understand.

Not every useful AI-adjacent tool needs a giant model, a cloud backend, or another API subscription. Sometimes a thoughtful local-processing pipeline, a focused interface, and a very real problem are enough to build something useful.

I'm continuing to explore how SlothDigest can become better at understanding conversations while keeping its privacy-first approach.

If you're interested in improving chat parsing, task extraction, accessibility, or local-first tools, check out the repository and contribute!

🦥 Stay lazy. Stay informed. Let SlothDigest do the scrolling.

Repository: https://github.com/ayushraaj-01/Sloth-Digest

Hacktoberfest #OpenSource #JavaScript #Privacy #WebDevelopment

LedgerGemma: Your Private AI Accountant — Powered by Open-Weight Gemma

Ayush Raj — Tue, 13 Oct 2026 06:19:00 +0000

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

🌿 LedgerGemma: Your Private AI Accountant

What if your AI accountant could organize your finances without sending your financial documents to a cloud AI service?

Freelancers, independent developers, and consultants deal with invoices, receipts, expense reports, and tax records almost every month. Organizing all that information manually is tedious, while cloud-based AI tools introduce potential privacy concerns and recurring costs.

I built LedgerGemma, a privacy-first expense and invoice management project designed to bring open-weight AI into everyday financial workflows.

My goal was simple: make financial document processing more accessible while keeping privacy and local control at the center of the experience.

💡 What I Built

LedgerGemma is a local-first expense and invoice intelligence application powered by open-weight Google Gemma models.

It combines a browser-based financial dashboard with a Python-based processing engine to help users organize financial information.

Here's what it aims to make easier:

🧾 Receipt and invoice processing: Extract structured financial information from document text.
🧠 AI-assisted categorization: Organize expenses into relevant categories using a Gemma-style prompt pipeline.
🔍 Expense auditing: Flag missing information and potential issues for further review.
📊 Financial exports: Export records into formats such as CSV and JSON for further analysis.
🔒 Privacy-first design: Keep browser records in local storage and support local processing workflows.
🌐 Progressive Web App: Access the browser-based interface through a responsive financial dashboard.

The project also includes a Python CLI engine for processing receipt text and a Node.js server that connects the browser interface with local processing functionality.

🎯 Who Is It For?

LedgerGemma is designed with freelancers, independent contractors, solo founders, and consultants in mind.

These users often need to organize business expenses without introducing unnecessary complexity into their financial workflows.

A privacy-focused tool can be particularly useful when documents contain confidential client or project information.

🚀 Demo

Source code: GitHub — LedgerGemma

Project README: Explore the architecture and setup instructions

To run the project locally:

git clone https://github.com/ayushraaj-01/ledgergemma.git
cd ledgergemma
npm install
npm start

Open the local address printed by the server in your browser.

You can also explore the Python processing engine:

python ledger_gemma_engine.py --demo

For a local receipt-text processing example:

python ledger_gemma_engine.py --scan path/to/receipt.txt

The CLI and browser application have different entry points, so you can explore the parts of the project that interest you most.

Note: The repository contains the source code and local setup instructions. A separately hosted, publicly accessible demo is not linked here.

🛠️ How I Built It

I wanted to explore how open-weight AI could become part of a practical application rather than remain a standalone model experiment.

LedgerGemma brings together several technologies.

1. Open-Weight AI with Gemma

The project uses Gemma-oriented conversation templates and structured-output instructions to guide the processing engine toward consistent financial records.

The prompt pipeline describes the information to extract, the expense categories to consider, and the structure expected from the model.

The repository is designed around compatibility with open-weight Gemma model workflows and local inference tools.

2. Python Processing Engine

The Python engine handles receipt-text processing and expense-related classification logic.

It provides a command-line interface, allowing users to experiment with processing financial documents independently of the browser UI.

3. Browser-Based Financial Dashboard

I used HTML, CSS, and JavaScript to build the browser interface.

The dashboard is designed to make financial records easier to inspect and manage, with local browser storage and data-export functionality.

4. Node.js Integration

A lightweight Express server serves the web application and exposes an endpoint for invoking the Python processing engine.

This provides a bridge between the browser experience and the Python-based workflow.

5. Privacy as a Design Principle

Rather than treating privacy as an optional feature, I designed the project around local data handling and local-first processing.

The intended workflow reduces dependence on third-party financial-data processing services.

The important distinction is that using open weights does not automatically guarantee offline operation or privacy. Those properties depend on how the model is executed, how the application is configured, and whether its components make external network requests.

🌍 Why Does Open Innovation Matter?

For me, open innovation means being able to understand, experiment with, and adapt the technology behind an application.

A closed, hosted AI API can be convenient, but it may introduce usage costs, infrastructure dependencies, and questions about where sensitive financial documents are processed.

An open-weight model creates different possibilities.

First, developers gain more control over deployment.

With a compatible local inference runtime, an application can be adapted to run on a user's own hardware instead of requiring every inference request to pass through a hosted model API.

Second, experimentation becomes more accessible.

Developers can inspect prompt templates, adapt extraction instructions, evaluate different model configurations, and improve the surrounding application without being tied to a single proprietary inference endpoint.

Third, privacy-conscious workflows become easier to explore.

Local processing can reduce the need to transmit financial documents to an external AI provider. This matters when invoices and receipts contain confidential business information.

Finally, open innovation makes the project easier to extend.

Other developers can contribute improved extraction logic, better document-processing workflows, additional export formats, and support for new model runtimes.

That is the part I find most exciting: the ability to build something practical while keeping the underlying technology open to experimentation and improvement.

🧪 What I Learned

Building LedgerGemma made me think beyond simply connecting an AI model to an interface.

Financial applications need more than plausible model responses. They need structured records, predictable data handling, validation, and ways for users to inspect the results.

I also explored how a browser dashboard, a Python processing engine, and an Express server can work together in a single project.

One of the biggest takeaways was that AI should assist financial workflows, not become the unquestioned authority on financial decisions.

Model-generated categories and potential tax classifications should be checked against reliable rules and reviewed by the user or a qualified professional before being used for actual tax filings.

🏆 Hacktoberfest Challenge

This project is my entry for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle.

I wanted to build something with a practical use case and explore how open-weight AI can support privacy-conscious software.

The project also explores the potential of Google's Gemma models and provides a starting point for further work on local AI-powered document processing.

If you're interested in open-weight AI, local-first applications, or financial automation, I'd love for you to explore the repository and share your feedback.

💻 Explore the Code

🌿 GitHub repository: https://github.com/ayushraaj-01/ledgergemma

Built with Python, JavaScript, HTML, CSS, Node.js, Express, and a Gemma-oriented AI processing pipeline.

What would you build with an open-weight AI model if you didn't have to start with a cloud API?

I'd love to hear your ideas. 🚀

StudyBuddy AI: A Personal Learning Companion Built with Open-Source AI

Ayush Raj — Mon, 12 Oct 2026 18:45:33 +0000

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

What I Built

Meet StudyBuddy AI — a personal AI learning companion designed to help my friends study smarter, manage their time, and make learning less stressful.

As college students, we often struggle with tight deadlines, difficult concepts, and balancing academics with coding practice. I wanted to build something that could make a real difference in a student's daily life.

StudyBuddy AI helps students:

📚 Understand complex topics through simple explanations.
📝 Generate quick summaries of study materials.
💻 Get help understanding programming concepts.
🎯 Break large study goals into manageable tasks.
🤖 Ask questions and receive personalized learning assistance.

The idea is simple: technology should help us learn better, not just work faster.

Demo

🚀 Live Demo: Coming Soon!

Code

💻 GitHub Repository: Coming Soon!

How I Built It

I designed the project around an AI-powered architecture with a focus on accessibility, flexibility, and an easy-to-use interface.

My planned tech stack includes:

Frontend: React.js and Tailwind CSS
Backend: Node.js and Express.js
AI: An open-weight language model
Inference: Ollama for running supported models locally
Version Control: Git and GitHub

The goal is to use an open-weight model for the core AI functionality, allowing users to experiment with different models and potentially run the application locally.

Why Does Open Innovation Matter?

Open innovation matters because AI should not be limited to people who can afford expensive APIs or powerful cloud infrastructure.

Building with open-weight models offers several advantages:

🔓 Freedom: Experiment with different models and configurations.
🔒 Privacy: Local inference can keep study materials and conversations on the user's device.
💰 Accessibility: Avoid per-request API charges when running models locally, although hardware and electricity still have costs.
🛠️ Customization: Adapt the system to different learning needs.

For me, the most exciting part is the possibility of creating useful AI tools without making users completely dependent on a closed platform.

My Agent Session

I'll share my development session here once it's available.

Prize Categories

Open Source AI

Final Thoughts

This project is about more than building another chatbot. It's about using open technology to solve a problem that students experience every day.

Sometimes, the best projects don't start with a groundbreaking idea. They start with a simple question:

"What can I build today that makes someone's life a little easier?"

That's the idea behind StudyBuddy AI. 🚀

VerdantEcho: A Zero-Signal Bioacoustics Trail Scout That Gets You Off the Screen

Ayush Raj — Sun, 11 Oct 2026 17:50:50 +0000

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

What I Built

VerdantEcho is an offline-first, zero-signal backcountry trail scout and bioacoustics neural classifier designed with a single goal: to make screen time the shortest part of your outdoor experience.

When hiking through deep mountain hollows, dense old-growth woods, or national parks, cellular reception completely drops. Cloud AI APIs fail with network timeouts. Worse, typical apps keep your eyes glued to glass while you walk past magnificent autumn canopies.

VerdantEcho changes this by running open-weight AI directly on-device:

🔊 On-Device Bioacoustics Scout: Uses the Web Audio API to render a live waterfall spectrogram and extracts spectral centroids and harmonic ratios to classify bird calls (Black-capped Chickadees, American Robins, Red-tailed Hawks, Song Sparrows) and autumn field crickets.
🍁 Autumn Foliage & Flora Vision: Analyzes canopy senescence, anthocyanin pigmentation ratios, and leaf morphology. Includes a dedicated hazard alert for Poison Ivy (Toxicodendron radicans) with high-contrast trail warnings.
❄️ Frost & Soil Almanac: Calculates first expected frost dates and tells you what to sow (hardneck garlic, winter spinach, winter rye) or harvest before the freeze based on offline date and coordinates.
🌲 "Touch Grass" Pocket Mode: Switches the device to an ultra-low-power AMOLED HUD. When an animal or plant is detected, synthesized speech announces the finding directly into your earphones, then instructs you to put the phone back in your pocket.
📍 Zero-Cloud Field Journal & GPX Exporter: Logs observations with offline GPS waypoints locally in IndexedDB and exports standard .gpx or .geojson files ready for Gaia GPS, AllTrails, or OpenStreetMap.
🤖 Gemma 2B Naturalist Companion: Formatted for Google's open-weight Gemma 2B model, delivering concise 2-sentence ecological insights paired with a firm reminder to put the screen away.

Demo

The app runs locally in the browser or offline on mobile devices via PWA service workers.

Key Screenshots & Live Features:

Real-time Bioacoustics Spectrogram: 2048-point FFT waterfall analyzer visualizes animal calls between 200 Hz and 12 kHz in real time.
Sunlight HUD & Pocket Mode: A high-contrast sunlight theme for bright daylight, plus an AMOLED Pocket Mode that automatically dims the screen and reads observations aloud.
Botanical Safety Detector: Instant warnings for trail hazards (Poison Ivy urushiol oil warnings) and autumn canopy color stages.

Code

ayushraaj-01 / verdantecho

Zero-signal offline trail scout & bioacoustics AI companion that gets you off the screen and into nature.

🌿 VerdantEcho: Zero-Signal Trail Scout & Bioacoustics AI

"Build something with open-source AI at its core that gets people off the screen and into the world. The best builds here should make the screen the shortest part of the experience."
— Hacktoberfest Open-Source AI Challenge: Week 1 (Touch Grass)

🍃 Overview

VerdantEcho is an offline-first, backcountry trail scout and bioacoustics neural classifier engineered for one primary purpose: to minimize your screen time and immerse you in the natural world.

When hiking through deep backcountry valleys, national parks, or remote woodlands, cell towers disappear. Cloud-based AI APIs (OpenAI, Claude, cloud computer vision) fail with timeout errors. Even worse, typical mobile apps encourage you to stare at a glowing piece of glass while walking through magnificent old-growth canopies.

VerdantEcho fundamentally re-engineers outdoor exploration using open-weight AI:

🔊 On-Device Bioacoustics Scout: Real-time Web Audio API FFT spectrogram + neural audio pattern extraction…

View on GitHub

GitHub Repository: https://github.com/ayushraaj-01/verdantecho

Includes complete source code:

index.html & styles.css: Vanilla HTML/CSS high-contrast forest design system.
app.js: Web Audio API FFT analyzer, canvas camera pipeline, and GPX exporter.
ai-worker.js: Web Worker for non-blocking bioacoustics inference.
gemma_field_scout.py: Python CLI for offline Gemma 2B turn-based field guidance.
sw.js: Service worker for 100% airplane-mode offline caching.
render.yaml & Dockerfile: 1-click cloud deployment configurations.

How I Built It

VerdantEcho was constructed using a lightweight, resilient, and offline-first architecture:

1. Web Worker Thread Isolation

Running audio spectrogram FFT calculations and image tensor analysis on the main UI thread causes dropped frames and unresponsiveness. Following proven patterns, we offloaded spectral math to an isolated Web Worker (ai-worker.js), ensuring silky smooth 60fps performance even on low-power mobile devices.

2. High-Contrast Sunlight & Pocket HUD

Standard web apps wash out under direct outdoor sunlight. VerdantEcho provides:

A high-contrast Sunlight HUD with dark emerald accents.
A Touch Grass Pocket Mode with automatic screen dimming, audio chimes, and Web Speech API synthesis so you never have to look down at the display.

3. Open-Weight Gemma 2B Naturalist Engine

We built a local Python CLI (gemma_field_scout.py) that demonstrates turn-based inference using Gemma's prompt format:


bash
python gemma_field_scout.py --species "Sugar Maple" --notes "High crimson saturation on ridge line"