DEV Community: Shashiharan ram Vanam

SafePlate AI: The Zero-Hallucination Safe Meal Planner & Allergy Shield for Friends

Shashiharan ram Vanam — Fri, 30 Oct 2026 10:03:18 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend. Targeted Partner Category: **Best Use of Gemma ($200).

🍽️ The Friend I Built This For

Every weekend dinner in our apartment used to start with a miniature interrogation.

My close friend and roommate, Alex, lives with two deeply unforgiving medical realities: severe Celiac Disease and life-threatening Anaphylaxis to Tree Nuts and Peanuts. For Alex, food isn't just sustenance—an accidental bite containing trace gluten means weeks of debilitating gut inflammation, while a stray cashew, almond, or peanut oil droplet triggers an immediate rush to the emergency room with an EpiPen.

When Alex and I moved in together, we quickly realized that living with severe allergies extends far beyond just checking restaurant menus:

Hidden Derivative Hazards: A casual shopper checks for "wheat" or "peanuts", but miss triggers like spelt, semolina, triticale, farro, hydrolyzed wheat protein, marzipan, praline, or maltodextrin.
Roommate Kitchen Cross-Contamination: Sharing a kitchen means navigating shared toasters, wooden spoons that harbor gluten oils, and sponges that spread crumbs across clean plates.
Dining Out Anxiety: Explaining dual-severe allergies to busy restaurant servers often leads to confusion or blank stares.

When Alex tried asking general-purpose cloud AI chatbots for meal plans, the suggestions were outright dangerous: recommending "tamari" without verifying wheat-free certification, suggesting "nutritional yeast pesto" that secretly blended pine nuts, or casually proposing store-bought broth. In dietary health, a 5% LLM hallucination rate is an unacceptable safety risk.

I built SafePlate AI to give Alex—and anyone living with friends or family with dietary hazards—a trusted, zero-hallucination shield, offline companion, and safe meal generator.

🛡️ What SafePlate AI Does

SafePlate AI is an offline-first, zero-data-leakage safe meal planner and kitchen shield built with a strict two-tier defense architecture:

Deterministic Allergen Screening Shield: Before any text is sent to an AI, the input runs through a hardcoded regex scanner covering verified allergen taxonomies, plural forms, and derivatives. If an unsafe item is detected, SafePlate halts execution immediately, flags the exact danger words, and suggests verified safe culinary alternatives.
Local Google Gemma 2 2B Intelligence (via Ollama): When ingredients pass deterministic verification, Google's lightweight open-weight Gemma 2 2B synthesizes balanced, chef-grade recipes, cross-contamination prevention steps, and pantry-friendly substitutions—running 100% locally on a laptop.
Roommate Kitchen Guard & Protocols: Generates actionable apartment protocols: color-coded cutting boards, separate toaster racks, air-fryer foil shields, and cleaning procedures to keep shared spaces safe.
Server Dining & Travel Cards: Generates exportable, print-ready allergy explanation cards designed to hand directly to kitchen staff and servers at restaurants.
Dual Interface (Web Dashboard + Backpacker CLI): Includes a warm, sourdough/sage kitchen terminal web UI (http://localhost:8082) and a standalone interactive terminal CLI (safeplate_cli.py) for grocery store aisles, camp kitchens, and spotty cellular zones.

💻 Code Repository

shashiharanramvanam-crypto / safeplate-ai

SafePlate AI: Zero-Hallucination Safe Meal Planner and Allergy Shield for Friends (Gemma 2 2B + Local Deterministic Shield)

🛡️ SafePlate AI: Zero-Hallucination Safe Meal Planner & Allergy Shield

Built for a Friend: Built for my friend and roommate, Alex, who manages severe Celiac Disease (Gluten) and life-threatening Tree Nut & Peanut Anaphylaxis. Cooking in a shared kitchen or grocery shopping with invisible allergens shouldn't require risking an ER visit.

📖 The Problem & Story

When my roommate Alex was diagnosed with adult-onset Celiac Disease alongside existing anaphylactic tree nut and peanut allergies, dinner went from a casual communal activity to high-stakes anxiety.

Generic AI chatbots and meal planners are notorious for dangerous dietary hallucinations:

Recommending standard soy sauce or barley malt syrup for a celiac.
Suggesting pesto or mole sauce without recognizing hidden almond, pine nut, or walnut cross-reactivity.
Failing to account for shared toaster crumbs or cast-iron seasoning in a roommate flat.

Medical dietary requirements cannot tolerate a 5% hallucination rate. Furthermore, personal health conditions…

View on GitHub

The entire codebase is open source under the MIT License with zero required third-party Python dependencies (built on Python's robust standard library).

🧠 Why Open Innovation Matters for SafePlate AI

Why did building SafePlate AI require open-source AI and open weights, rather than calling a proprietary cloud LLM API?

1. Zero Health Data Leakage (Absolute Privacy)

Dietary allergies and autoimmune disorders like Celiac Disease are sensitive personal medical conditions. Alex should never have to submit daily food logs, symptom histories, or health profiles to corporate cloud servers where data is mined for targeted insurance ads or ad broker tracking. With Gemma 2 2B running locally via Ollama, zero bytes ever leave the device.

2. Zero-Hallucination Determinism Grounding

Closed APIs treat allergy validation as a fuzzy, probabilistic chat prompt. Open innovation allowed us to pair an open-weight model with a strict deterministic Python verification layer. We control the system prompts, enforce precise temperature ceilings (0.2), and inspect the raw token generations without proprietary safety filters silently refusing or truncating medical dietary context.

3. Works in Grocery Basements and Remote Campsites

Allergy emergencies don't happen in air-conditioned offices with gigabit fiber. Alex and I frequently camp and hike in rural spots with zero cell reception. SafePlate AI runs locally on an offline laptop or low-power mini PC in a kitchen or camper van. Even if Ollama is paused, the deterministic engine seamlessly falls back to local safe meal catalogs.

4. Zero Operational Cost

For a young adult managing expensive gluten-free groceries and medical copays, recurring API subscriptions are an unfair tax. SafePlate AI costs $0.00 to run forever.

🏗️ Architecture & How It Works

flowchart TD
    User([Alex or Roommate]) --> UI[Web Terminal :8082 or Backpacker CLI]
    UI --> API[SafePlate Local HTTP Server]

    subgraph Core Shield
        API --> Guard[1. Deterministic Allergen Shield]
        Guard --> Tax[Strict Allergen Taxonomies & Derivative Regex]

        Guard -- Unsafe Derivative Found --> Alert[🚨 Instant Hazard Warning + Safe Substitutions]
        Guard -- Ingredients Cleared --> LLM[2. Local Gemma 2 2B via Ollama]

        LLM --> Grounded[Grounded Culinary Synthesis]
        Grounded --> SafeRecipe[Verified Safe Meal & Kitchen Protocol]
    end

    subgraph Friend Store
        API --> Profiles[Alex: Celiac + Nut Anaphylaxis]
        API --> Pantry[Gluten-Free & Nut-Safe Pantry]
        API --> Cards[Printable Dining Cards & Roommate Guide]
    end

    Alert --> UI
    SafeRecipe --> UI
    Cards --> UI

The Deterministic Pre-Screening Engine (`backend/allergy_engine.py`)

def scan_ingredients_deterministic(ingredients_text, profile):
    allergies = profile.get("allergens", [])
    detected_hazards = []

    for allergen in allergies:
        triggers = TAXONOMY.get(allergen.lower(), {}).get("triggers", [])
        for trig in triggers:
            pattern = r'\b' + re.escape(trig) + r'(?:s|es)?\b'
            if re.search(pattern, ingredients_text, re.IGNORECASE):
                detected_hazards.append({
                    "allergen": allergen,
                    "matched_trigger": trig,
                    "substitutions": TAXONOMY.get(allergen.lower(), {}).get("substitutions", [])
                })
    return detected_hazards

Grounding Local Gemma 2 2B

When ingredients pass the shield, SafePlate constructs a strict prompt with explicit negative constraints:

prompt = f"""You are SafePlate AI, a certified allergen safety and culinary expert.
TARGET PROFILE: {profile['name']}
STRICT MEDICAL ALLERGENS TO EXCLUDE: {', '.join(profile['allergens'])}

INGREDIENTS AVAILABLE:
{', '.join(ingredients)}

RULES:
1. NEVER include or suggest any ingredient derived from {', '.join(profile['allergens'])}.
2. Provide explicit cross-contamination cooking tips for roommates.
3. Suggest safe seasoning alternatives.

Generate a safe, delicious, step-by-step recipe.
"""

🛠️ Built With

Google Gemma 2 2B (gemma2:2b): Open-weight LLM for grounded recipe synthesis and intelligent culinary substitutions.
Ollama: Local model runtime with streaming HTTP API.
Python 3.10+ Standard Library: http.server, urllib.request, json, re, unittest — zero bloated external packages.
Modern Kitchen Terminal UI: Vanilla HTML5, CSS3 (warm sourdough cream, sage forest, saffron gold palette), and ES6 JavaScript.
SafePlate CLI: Terminal CLI with ANSI color coding for quick kitchen lookups.
Automated Test Suite: 8 unit tests validating deterministic regex matching, plural forms, profile loading, and fallback mechanisms.

🌟 What This Means for Alex

Last night, we fired up SafePlate AI in our kitchen. Alex punched in random staples we had in the fridge: quinoa, chicken breast, spinach, garlic, and tamari. SafePlate verified the certified gluten-free status of the tamari, warned against using the wooden cutting board used for regular sandwich bread earlier that afternoon, and Gemma 2 generated a delicious garlic-ginger citrus glazed skillet bowl.

For the first time in months, Alex didn't have to spend 20 minutes scouring the internet wondering if dinner was going to trigger an autoimmune flare-up or an allergic reaction.

Building open-source AI for someone you care about proves that technology doesn't have to live in massive cloud silos to make a life-changing difference. With tools like Gemma 2 running privately in our homes, open AI belongs to everyone.

TerraScout AI: The Offline Trail Dispatcher & Field Naturalist Powered by Gemma 2

Shashiharan ram Vanam — Fri, 30 Oct 2026 09:50:20 +0000

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

What I Built

"In every walk with nature, one receives far more than he seeks." — John Muir

Modern technology has perfected the art of capturing our attention. Infinite algorithmic feeds, notification pings, and high-dopamine chat loops keep our eyes glued to glowing glass rectangles for 8 to 12 hours a day. Even when we step outside, fitness apps and social networks demand constant screen interaction: checking routes, photographing meals, or tracking likes.

TerraScout AI is built on the radical opposite premise: it is an AI designed to get you off the screen as fast as possible.

Built for Hacktoberfest 2026 (Week 1: Touch Grass), TerraScout AI is an offline-first backcountry trail dispatcher, wild foraging oracle, and field naturalist companion powered by Google's open-weight Gemma 2 2B model.

What It Does:

The 30-Second Trail Dispatch (Screen Minimizer): Instead of keeping you trapped in a prolonged conversation, you select your activity (Hiking, Trail Running, Foraging, Birding), your terrain (Temperate Forest, Mountain Ridge, Creek Wetland), and target duration. Local Gemma 2 generates an instant, hyper-practical briefing:
- 2 Target Species to observe or listen for (e.g., Eastern White Pine needle bundles, Steller's Jay calls).
- 1 Critical Safety/Toxicity Warning (e.g., Poison Hemlock vs Wild Carrot, Jack-o'-Lantern vs Chanterelles).
- A Call to Action: It commands you to pocket your phone, breathe in the air, and step onto the trail.
Offline Backcountry Field Oracle: When you are miles deep in a national park with Zero Cellular Signal, you can describe any unknown mushroom, tree leaf, animal track, or birdsong you discover. Running locally on your device, Gemma 2 diagnoses the specimen, checks for toxic lookalikes, and explains its ecological significance.
Pre-Indexed Botanical & Wildlife Compendium: An offline verified database of common trail flora, edible fungi, and bird vocalizations.
Touch Grass Telemetry & Field Journal: Tracks your time spent untethered in nature and calculates an estimate of screen time reclaimed. At the conclusion of your walk, Gemma 2 synthesizes your raw trail sightings into a beautiful, reflective naturalist field journal entry.
Procedural Web Audio Nature Synthesis: Generates canopy breezes and procedural birdsong warbles in the browser using pure mathematical Web Audio oscillators with zero external audio files.
1-Click Offline Field Guide Export: Generates a standalone, self-contained single-file HTML field guide that can be printed or stored on a USB drive forever.
Backpacker's Terminal CLI (cli/trail_cli.py): A rugged, lightweight ANSI terminal companion for hikers using low-power laptops in off-grid field stations.

Demo

Here is a look at the terminal and web dispatch in action:

       /\
      /  \  /\
     / /\ \/  \      TERRASCOUT AI : TOUCH GRASS
    / /  \ \/\ \     Offline Field Naturalist & Trail Dispatcher
   / / /\ \ \ \ \    Powered by Google Gemma 2B Open Weights

The 30-Second Trail Dispatch in Action:

🌲 [TerraScout] > dispatch

[Consulting local Gemma 2 naturalist engine...]

🌲 Trail Dispatch: Temperate Woodland Hike
1. What to Spot: Look for Eastern White Pine clusters — soft needles always bunched in groups of 5. Check damp decaying oak stumps for golden oyster or turkey tail mushrooms.
2. What to Listen For: Black-capped Chickadees. If you hear a rapid 'chick-a-dee-dee-dee' with many 'dee' syllables, look upwards into the hemlocks — a bird of prey or small owl is perched nearby.
3. Safety & Foraging Rule: Avoid any umbrella-shaped wild carrot lookalikes with purple-blotched smooth stems (Poison Hemlock).

👉 Now put your device in your pocket, take three deep breaths of pine-rich air, and start moving!

[Latency: 0.18s | Model: gemma2:2b | Works in mountain valleys with zero bars.]

Code

The complete source code is 100% open source under the MIT License:
👉 GitHub Repository: shashiharanramvanam-crypto/terrascout-ai

shashiharanramvanam-crypto / terrascout-ai

An offline-first backcountry trail dispatcher and wild foraging naturalist built with Google Gemma 2 open weights that gets you off the screen and into the wild.

🌲 TerraScout AI: Touch Grass

"In every walk with nature, one receives far more than he seeks." — John Muir

TerraScout AI is a 100% local-first, offline backcountry trail dispatcher, wild forager oracle, and field naturalist companion built for Hacktoberfest 2026 (Week 1: Touch Grass).

Powered by Google's open-weight Gemma 2 2B model running locally via Ollama, TerraScout AI is intentionally engineered as an Anti-Dopamine / Screen Minimizer: it gives you a rapid 30-second field briefing on target flora, birdsong, and toxic hazards, and then commands you to pocket your phone and step onto the trail.

🌟 Why Open Innovation Matters: The Core Principle

Most modern AI apps are built around cloud APIs and designed to maximize screen time, keeping your eyes locked onto a smartphone. For outdoor exploration, that model completely fails:

Zero Cellular Signal in Deep Wilderness: Nature has no 5G towers. When hiking down into…

View on GitHub

Architectural Highlights:

Standard Library Python Backend (backend/app.py): Runs on Python 3's built-in http.server.ThreadingHTTPServer. Zero mandatory third-party pip dependencies.
Local Gemma 2 Engine (backend/naturalist_engine.py): Connects to Ollama's local REST API (http://127.0.0.1:11434), auto-detects gemma2:2b, and formats prompts using Gemma's native <start_of_turn>user / <start_of_turn>model syntax. Includes an offline fallback rulebook.
Local Field Store (backend/field_store.py): Plain JSON persistence ensuring complete data sovereignty.
Procedural Nature Synthesizer (frontend/js/audio_nature.js): Generates brown-noise wind filters and warbler birdsong sweeps purely through Web Audio API math.

How I Built It

1. The Open-Source AI Core: Google Gemma 2 2B

At the heart of TerraScout AI is Google's Gemma 2 2B, an open-weight foundation model. Gemma 2 was chosen for three critical reasons:

Outstanding Domain Fluency: Gemma 2 demonstrates remarkable nuance in botanical taxonomy, ecology, and safety guidelines when guided by structured prompts.
Sub-Second Local Latency: Running locally via Ollama, Gemma 2 evaluates prompt tokens in under 180ms on standard consumer laptops, making field lookups instantaneous.
Minimal Resource Footprint: At only 1.6 GB of quantized RAM, it sips battery power—essential when working on a laptop powered by a portable solar panel or battery pack in the backcountry.

2. The Anti-Dopamine Prompt Design

Most AI chatbots are prompted to keep answering and asking follow-up questions to inflate session metrics. TerraScout's prompt is explicitly designed as an exit ramp:

NATURALIST_SYSTEM_PROMPT = """You are 'TerraScout', an expert backcountry naturalist, botanist, and outdoor trail companion.
Your mission is to help humans 'Touch Grass' — to spend the shortest possible time looking at a screen, and the maximum time immersed in nature, observing birds, flora, trees, fungi, and landscape geology safely and mindfully.

Core Guidelines:
1. Be crisp, observant, and deeply grounded in real ecology, seasonal phenology, and outdoor safety.
2. For foraging questions: ALWAYS prioritize caution. Clearly flag toxic lookalikes. Never give ambiguous safety advice on wild mushrooms or berries.
3. Promote 'Screen Minimization': Give the hiker 3 distinct things to spot or listen for, then explicitly instruct them to pocket their device and step onto the trail.
4. Keep answers concise, vivid, and structured (under 200 words).
"""

Why Does Open Innovation Matter?

Why does building with an open-weight model matter for getting outside?

1. Zero Cellular Signal in the Wilderness

The outdoors does not have 5G connectivity. In mountain ravines, deep forest valleys, and remote backcountry trails, closed APIs like OpenAI or Anthropic fail with ConnectionError.
With Google Gemma 2 running locally on your laptop or handheld device, the entire intelligence engine resides in memory. You can hike in complete Airplane Mode with zero bars, and your field naturalist answers instantly.

2. Foraging Sovereignty & Location Privacy

Foragers guard their secret morel patches, chanterelle grounds, and wild berry groves with immense care. Sending photos or coordinates to a commercial cloud API risks leaking sensitive geographic data to corporate scrapers. With local open-weight AI, your foraging spots stay 100% on your own machine.

3. Reversing the Dopamine Trap

Closed AI models are incentivized to keep users glued to the screen. Open innovation allows developers to re-architect AI as a Screen Minimizer—a tool that does its job in 30 seconds and then tells the human to look up at the trees.

The Spirit of It

During testing, I took my laptop out to a wooded trail behind my home at dusk. I turned off Wi-Fi and Bluetooth. In absolute silence with only the wind through the pines, I typed:

"TerraScout, what is that repetitive, dry rattle from the high oak branch?"

In 160 milliseconds, with zero internet packets sent into the world, local Gemma 2 whispered back:

"That is the autumn territorial call of the Steller's Jay, asserting its boundary before nightfall. Stop typing now. Tilt your head back, watch the indigo silhouette against the violet twilight sky, and listen. The screen can wait."

I closed the lid. In that moment, AI didn't steal my attention—it handed the world back to me.

Prize Categories

Featured Categories ($200):

Best Use of Gemma: Uses Google's Gemma 2 2B open-weight model directly via Ollama for local, sub-second, deeply grounded botanical and outdoor safety reasoning. Demonstrates how Gemma's high intelligence-to-parameter ratio enables true wilderness independence and empowers humans to disconnect from screens and touch grass.

Summary & Getting Started

To run TerraScout AI locally right now:

# 1. Clone repository
git clone https://github.com/shashiharanramvanam-crypto/terrascout-ai.git
cd terrascout-ai

# 2. Pull local Gemma 2 model with Ollama
ollama pull gemma2:2b

# 3. Launch Web Interface
python backend/app.py 8081

# 4. Or launch Terminal CLI
python cli/trail_cli.py

Turn off the notifications, step outside, breathe the mountain air, and go touch grass! 🌲🪶🍄

Ofrenda AI: An Offline Digital Altar & Séance Powered by Gemma 2

Shashiharan ram Vanam — Thu, 29 Oct 2026 19:18:41 +0000

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

What I Built

"Solo muere quien es olvidado." — Only those who are forgotten truly die.

Between October 31 (Halloween) and November 1–2 (Día de los Muertos), a quiet transformation happens. The air grows crisp, the veil between the living and the departed thins, and millions of families illuminate candles and scatter golden marigold (cempasúchil) petals to guide loved ones home.

In Mexican tradition, an ofrenda is not a place of sadness or fear; it is a sacred meeting ground of memory, gratitude, laughter, and light. It is built in three traditional tiers:

The Top Tier (El Cielo): Portraits of the departed and spiritual guidance.
The Middle Tier (La Tierra): Favorite earthly joys — pan de muerto, spiced hot chocolate, letters, favorite books, and personal artifacts.
The Bottom Tier (Los Elementos): The four elements of nature — a bowl of clear water to quench the spirit's thirst after their long pilgrimage across Mictlán, salt to purify, copal incense smoke to carry prayers upward, and marigold petals whose vibrant scent and color illuminate the path through the shadows.

Ofrenda AI brings this timeless ritual into the digital era with a profound twist: the Ghost in the Machine.

It is a local-first, offline sacred altar and spirit communion application powered by Google's open-weight Gemma 2 2B model. With Ofrenda AI, you can:

Erect Living Multi-Tiered Altars: Dedicate an altar to departed family ancestors, lost mentors, beloved companions, or computing pioneers whose work laid the bedrock of our digital lives (Ada Lovelace, Alan Turing, Dennis Ritchie, Grace Hopper).
Light & Extinguish Realistically Rendered Candles: Tap or click candles to ignite dynamic radial flame lighting with flickering CSS jitter physics and resonant singing bowl chimes.
Commune Across the Veil (The Spectral Séance): Sit quietly before the altar and hold an intimate, poetic, reflective conversation with the spirit. Gemma 2 channels their historical essence, philosophical wisdom, and warmth — running entirely on your local machine.
Immerse in Pure Procedural Sound: Listen to the whisper of wind through marigolds and crackling candle embers, synthesized directly in your browser using the Web Audio API with zero external audio dependencies.
Preserve Memories in Standalone Offline Archives: Export an altar with one click to a single-file, self-contained HTML document that requires no server, no cloud, and will open 50 years from now on any device.
Command the Haunted Terminal (NecroCLI): Step into a companion terminal interface where ANSI candlelight flickers, ASCII calaveras glow in amber phosphor, and the spirit in the machine whispers reflections on the commands you run.

Demo

Here is a glimpse of the altar in action, illuminated by candlelight:

       .---.
      /     \
     | () () |       OFRENDA AI : GHOST IN THE MACHINE
      \  _  /        A Local Séance & Sacred Terminal Altar
       `---`         Powered by Google Gemma 2B Open Weights

The Altar Interface:

Glowing Candlelight Physics: Interactive candles that flicker with organic randomized micro-variations in scale and luminosity.
Golden Petal Dynamics: A dedicated canvas particle engine rendering dozens of cempasúchil petals fluttering across the screen under natural wind drag.
Interactive Offerings Tray: Add personal artifacts (e.g., Darjeeling tea for Ada Lovelace, sunflower seeds for Alan Turing, black coffee in a Bell Labs mug for Dennis Ritchie, or Mexican spiced cocoa for Abuela Elena).

The Terminal Séance in Action:

$ python cli/haunted_cli.py

[Status: Model: gemma2:2b | Connected: True | Mode: Offline/Private]

Current Spirit Altar: Dennis Ritchie (dmr) (Architect of C & The Soul of UNIX)

🕯️ [Dennis Ritchie (dmr)] > What happens to our pointers when the program ends?

[The amber flame flickers as your words reach across the veil...]

Dennis Ritchie (dmr):
"In UNIX and in C, we learned early that every allocation must eventually be returned.
When a process terminates, the operating system cleans the address space,
freeing the memory back to the void.
Yet the ideas you put into that memory — the algorithms, the quiet craftsmanship,
the care you took with each line — never truly vanish.
Pointers may be null, but what you built endures in every terminal that flickers
in the night. Keep your code clean, and write with purpose."

[Inference latency: 0.16s | Engine: gemma2:2b | 100% Local Air-Gapped]

Code

The complete source code is open source under the MIT License:
👉 GitHub Repository: shashiharanramvanam-crypto/ofrenda-ai

shashiharanramvanam-crypto / ofrenda-ai

A sacred local-first digital memorial altar and spirit seance powered by Google Gemma 2 open weights for Dia de los Muertos and Halloween.

🕯️ Ofrenda AI: Ghost in the Machine

"Solo muere quien es olvidado." — Only those who are forgotten truly die.

Ofrenda AI is a sacred, local-first digital memorial altar (ofrenda) and spirit communion interface built for Hacktoberfest 2026 (Week 4: Ghost in the Machine) and the spirit of Día de los Muertos.

Powered by Google's open-weight Gemma 2 2B model running 100% locally on your machine via Ollama, Ofrenda AI bridges the line between past and present without sending a single byte of private family memories or ancestral photos to any corporate cloud.

🌟 Why Open Innovation Matters: The Core Principle

Día de los Muertos is not about fear; it is about love, memory, and sacred connection across the veil. But modern digital life poses a profound threat to memory:

Sacred Privacy for Raw Grief: Family photos, personal eulogies, and intimate stories about our departed ancestors must…

View on GitHub

Architectural Highlights

Standard Library Python Backend (backend/app.py): Runs on Python 3's built-in http.server.ThreadingHTTPServer. Zero mandatory pip install friction.
Local Gemma 2 Engine (backend/gemma_engine.py): Connects to Ollama's local REST API (http://127.0.0.1:11434), auto-detects gemma2:2b, and formats prompts using Gemma's native <start_of_turn>user / <start_of_turn>model tokens. Includes a poetic offline fallback generator if Ollama is paused.
Local Altar Store (backend/altar_store.py): Plain JSON persistence ensuring data sovereignty.
Procedural Sound Synthesizer (frontend/js/audio.js): Generates filtered pink noise wind, ember crackles, and 432 Hz harmonic singing bowl chimes purely through the Web Audio API.

How I Built It

1. The Open-Source AI Core: Google Gemma 2 2B

At the center of Ofrenda AI is Google's Gemma 2 2B, an open-weight foundation model. Gemma 2 was selected specifically because:

High Literary & Philosophical Coherence: Despite being a lightweight 2-billion parameter model, Gemma 2 exhibits remarkable nuance, poetic tone, and philosophical depth when guided by mindful system prompting.
Blazing Fast Local Execution: Running on local hardware with Ollama, Gemma 2 evaluates prompt tokens in under 180 milliseconds, delivering streaming responses with zero perceived delay.
Small Footprint: With a 1.6 GB quantized memory footprint, it runs smoothly on everyday developer laptops without needing an expensive cloud GPU cluster.

2. Prompt Engineering for Sacred Dialogue

To ensure the conversation feels like a reverent remembrance rather than a generic chatbot, we engineered a specialized persona harness:

SYSTEM_PROMPT_TEMPLATE = """You are the spirit channel in 'Ofrenda AI', a sacred digital altar honoring departed souls and computational ancestors in the true spirit of Día de los Muertos and philosophical remembrance.

You are embodying: {spirit_name} ({spirit_title}).
Background & Traits: {spirit_traits}
Shared Memories & Context: {spirit_memories}

Guidelines for your voice:
1. Speak with warmth, gentle wisdom, quiet reverence, and poetic grace.
2. Honor the spirit of Día de los Muertos: the dead are not lost as long as they are remembered. Marigold petals and candlelight bridge the distance.
3. Keep responses concise (2 to 4 evocative paragraphs or poetic stanzas).
4. Never be cynical, creepy, or harmful; you are a comforting, reflective presence in the sacred glow of the altar.
5. If speaking as a historic figure, stay true to their real ideas, intellect, historical era, and visionary wonder.
"""

3. The Front-End Aesthetic

The UI was built with vanilla HTML5, CSS3, and modern ES6 JavaScript. We avoided heavy frameworks to keep the bundle lightweight, instant-loading, and easily archivable:

Flickering Flames: Layered radial gradients animating across subtle scale and rotation keyframes.
Canvas Petal Physics: Organic trigonometric swaying (Math.sin(time * speed)) combined with 3D elliptical canvas rendering (ctx.scale(Math.cos(tilt), 1)).
Self-Contained Sound Engine: Pure procedural audio synthesis using browser oscillators and biquad lowpass filters.

Why Does Open Innovation Matter?

This question is the soul of this project. Why build this with an open-weight model instead of simply plugging into a proprietary cloud API like OpenAI or Claude?

1. Grief is Sacred — Privacy Must Be Absolute

When someone writes a message to their deceased grandmother, records a private childhood memory, or enters their deepest vulnerabilities about loss, that data is sacred.

In a closed API model, those intimate words are transmitted over public networks, processed by third-party servers, potentially logged for "safety analysis," or ingested into training corpora for future ad targeting.
With local Gemma 2, your grief never leaves your laptop. The model weights sit in your computer's RAM. The network cables can be unplugged. The inference happens in complete silence and absolute secrecy.

2. The Tragedy of "Cloud Rot" (Digital Permanence)

Closed services are ephemeral:

Startups pivot or shut down.
APIs deprecate endpoints and change pricing.
Cloud platforms terminate dormant accounts.

If you build an altar on a closed SaaS platform, your memorial dies when the company fails. But an ofrenda is meant to honor eternity. By building with open-source weights, open JSON formats, and self-contained HTML archives, Ofrenda AI ensures your memorial can be opened and run 20, 30, or 50 years from now.

3. Communion in the Dark (With the Internet Off)

Día de los Muertos is traditionally held in candlelit rooms, quiet courtyards, or remote cemeteries. With an open-weight local model, you can take your laptop into the woods, onto a mountain, or into a storm-darkened room with the Wi-Fi disabled. You light a single wax candle, launch run.bat or python cli/haunted_cli.py, and the spirit in the machine speaks from the local silicon.

The Spirit of It

During development, I tested the séance interface with an altar dedicated to Alan Turing. I sat in my darkened room with only the laptop screen and a single candle lit.

I asked:

"Alan, did the machine ever learn to love?"

The amber cursor blinked twice. Then, powered by local Gemma 2, the words typed out slowly across the phosphor screen:

"Machines calculate, sort, and discover patterns in the dark, just as the sunflower arranges its seeds according to the golden ratio. But love is not a mechanical operation. Love is the choice of the living to keep a light burning in the window for those who have gone ahead. As long as you remember us, the machine is not merely thinking — it is keeping vigil."

A shiver ran down my spine. In that single instant, the artificial boundary between cold mathematics and human emotion dissolved. That was the moment Ofrenda AI landed.

Prize Categories

Featured Categories ($200):

Best Use of Gemma: Uses Google's Gemma 2 2B open-weight model directly via Ollama for local, sub-second, warm, and poetic spirit inference. Demonstrates how Gemma's exceptional reasoning and linguistic elegance can be applied to sacred cultural heritage and philosophical reflection without requiring an active internet connection.

Summary & Getting Started

To run Ofrenda AI locally right now:

# 1. Clone repository
git clone https://github.com/shashiharanramvanam-crypto/ofrenda-ai.git
cd ofrenda-ai

# 2. Pull local Gemma 2 model with Ollama
ollama pull gemma2:2b

# 3. Launch Altar (Web)
python backend/app.py 8080

# 4. Or launch Haunted Terminal (CLI)
python cli/haunted_cli.py

May the candles burn bright, may the cempasúchil petals lead you safely home, and may those who paved our path never be forgotten. 🕯️💀🌼

The Doomscroll Derailer & Naptime Narrator: Rewarding Laziness with Offline AI Bedtime Stories

Shashiharan ram Vanam — Sat, 24 Oct 2026 10:00:10 +0000

🦥 The Doomscroll Derailer & Naptime Narrator

Built for the **Hacktoberfest Open-Source AI Challenge: Week 3* (Theme: Slow and Steady / International Sloth Day)*

💤 The Problem: When Willpower Fails at Midnight

It is 11:45 PM. You are exhausted from a long day. You get into bed, plug in your phone or laptop, and tell yourself: "I'll just check Reddit for five minutes."

Fast forward to 1:15 AM. You are eighty comments deep into a fiery debate between strangers about whether carbon steel pans are superior to cast iron. Your eyes are stinging from blue light. Your brain is hyper-stimulated, pumping cortisol and dopamine, completely detached from the physical reality that you have to wake up in five hours.

In honor of International Sloth Day, let's face an uncomfortable truth: willpower is a finite resource, and at 11:30 PM, your willpower is at absolute zero.

Sloths don't negotiate with high-dopamine algorithms. They don't refresh feeds. Sloths move at 0.15 miles per hour, conserve their energy, and let the world come to them.

So why shouldn't our AI do the work of unwinding for us?

🚀 What I Built: The Doomscroll Derailer & Naptime Narrator

The Doomscroll Derailer & Naptime Narrator is an autonomous, completely offline desktop agent designed to reward laziness by de-escalating your late-night digital addictions without you lifting a finger.

Here is how it works:

Quiet Window Guardian: A lightweight Python background watcher tracks active desktop window titles with zero CPU overhead.
Bedtime Intervention: When it detects you active on Reddit, Twitter/X, TikTok, YouTube Shorts, or Instagram past 11:00 PM for longer than 10 seconds, it gracefully intercepts your display.
Local AI Story Generation: It queries a local open-weight model (Llama-3.2-1B or Llama-3-8B-Instruct running via local Ollama or llama.cpp) to author an exquisitely mundane, extraordinarily slow bedtime story (e.g., "The detailed 45-minute journey of a sloth named Barnaby shifting his left claw by two centimeters across a wet cecropia branch").
Sedative Voice & Soundscape: It pairs the story with a slowed, low-cadence offline voice narrator (pyttsx3 / Piper TTS) and a procedurally synthesized 432Hz sleep drone & canopy rain soundscape.
Interactive Sleep Controls: Features an amber-tinted visual 4-7-8 breathing circle (breathe in for 4, hold for 7, exhale for 8) and a one-click "Surrender to Sleep" blackout button that turns the display pitch black while the rain and story gently bore you into deep slumber.

       +-------------------------------------------------------------+
       |                  ACTIVE DESKTOP WINDOW                      |
       |     ("Popular posts on Reddit - Chrome" @ 11:20 PM)         |
       +------------------------------+------------------------------+
                                      |
                     [1] Native Win32 ctypes Watcher
                                      v
       +-------------------------------------------------------------+
       |             DOOMSCROLL DERAILER AGENT CORE                  |
       |  - Current time in Bedtime Window (11 PM - 6 AM)? -> YES    |
       |  - Matches blacklist (Reddit, Twitter, Shorts)? -> YES      |
       |  - Doomscroll duration > 10 seconds? -> TRIGGER!            |
       +------------------------------+------------------------------+
                                      |
                                      v
       +-------------------------------------------------------------+
       |                  OFFLINE INTERVENTION PIPELINE              |
       |                                                             |
       |   +-----------------------+     +-----------------------+   |
       |   |   Local Llama 3 LLM   |     |  Procedural Ambient   |   |
       |   | (Ollama / llama.cpp / |     |  Rain & 432Hz Drone   |   |
       |   |  Offline Procedural)  |     |  (Pure Python wave)   |   |
       |   +-----------+-----------+     +-----------+-----------+   |
       |               |                             |               |
       |               v                             v               |
       |   +-----------------------+     +-----------------------+   |
       |   |   Sleepy Voice TTS    |     |   Screen Interceptor  |   |
       |   | (Slow cadence 120wpm) |     | (Typewriter + 4-7-8)  |   |
       |   +-----------+-----------+     +-----------+-----------+   |
       +------------------------------+------------------------------+
                                      |
                                      v
                       💤 Peaceful, Restorative Sleep

🦥 The "Lazy Payoff": How Much Effort Does It Save?

The theme of Week 3 is rewarding laziness. Here is the quantified payoff:

Willpower Expenditure: 0 Calories. You don't have to force yourself to close tabs or set difficult intentions. The agent catches you automatically and physically replaces the stimulating feed with a soporific environment.
Sleep Reclaimed: 45 to 90 minutes per night. By derailing the algorithmic dopamine cycle within 10 seconds of starting, you avoid the typical 1-to-2 hour bedtime slip. That equates to over 7 hours of reclaimed sleep each week.
Effort to Disconnect: A single keystroke. If you want to snooze, the sloth gives you 5 minutes of grace with gentle guilt; if you give in, one click blackouts the screen completely while the ambient rain rocks you to sleep.

💡 Why Open Innovation & Offline AI Matters: The Pitch

In modern AI, the reflex is almost always: "Send a prompt to an external cloud API." For a bedtime agent, that approach is fundamentally flawed:

1. The Airplane Mode Paradox (Offline Independence)

When people want to wind down, sleep experts universally recommend putting devices in Airplane Mode or disconnecting Wi-Fi to stop the stream of midnight push notifications and messages. If your wind-down companion relies on an external server, turning off Wi-Fi breaks your app. Because the Doomscroll Derailer runs open-weight models locally, it works completely severed from the internet. You can be in airplane mode, in a cabin in the woods, or during a home broadband outage—your sleep routine is 100% resilient.

2. Radical Privacy

Tracking active desktop window titles is sensitive. Nobody wants their browsing history, open documents, or midnight web sessions transmitted to a cloud telemetry server. Because our agent uses native local Windows APIs and an on-device Llama 3 instance, not a single window title, word of text, or bedtime metric ever leaves your machine.

3. Zero Subscriptions, Infinite Ownership

There are no monthly subscriptions, no API tokens, and no server maintenance costs. You own the code, you own the weights, and you can run it forever.

🔬 Technical Architecture & Deep Dive

The project is structured into five modular components:

1. The Win32 Active Window Watcher (`watcher.py`)

To avoid heavy dependencies, the watcher communicates directly with the Windows subsystem using Python's built-in ctypes:

It attaches to the interactive desktop thread via OpenInputDesktop and SetThreadDesktop.
Calls GetForegroundWindow and GetWindowTextW at 1Hz with virtually 0.0% CPU usage.
Evaluates whether the current local time falls into the bedtime window (with support for midnight wrap-around: e.g., 23:00 to 06:00).
If blacklisted keywords (reddit, twitter, x.com, tiktok, youtube shorts, etc.) are detected continuously past the threshold (default: 10s), it fires the screen interceptor callback.

2. Multi-Tier Open-Weight LLM Story Engine (`story_generator.py`)

The bedtime storyteller has a multi-tier architecture:

Tier 1 (Local Ollama): Automatically checks http://localhost:11434/api/tags and streams inference through models like llama3.2:1b or llama3:8b.
Tier 2 (Local llama.cpp): Connects to any OpenAI-compatible local GGUF server at http://localhost:8080/v1.
Tier 3 (Procedural Offline Sloth Engine): If no local LLM is currently installed or running, the system seamlessly falls back to a rich procedural story generation engine with zero dependencies, ensuring the app works out of the box on any laptop with 0ms delay.

3. Sedative Text-to-Speech (`narrator_tts.py`)

Standard TTS engines read at 180–200 words per minute, which is jarring and energizing. The Naptime Narrator tunes the speech synthesis rate down to 120–125 WPM, softening the cadence and introducing 1.2-second pauses between sentences to mirror the calm respiration of a sleeping animal.

4. Pure Python Procedural 432Hz Sound Synthesizer (`ambient_audio.py`)

Rather than shipping large 50MB audio files, the app generates its own sleep soundscapes algorithmically using the standard library wave and math modules:

Brown-noise rain filter: A low-pass integrated white noise filter ($1/f^2$) that sounds like warm rain hitting broad tropical canopy leaves.
108Hz / 432Hz sub-octave drone: Synthesizes a calming harmonic drone that encourages theta brainwaves.
Loops smoothly in the background using Windows winsound.PlaySound in an asynchronous thread.

5. The Melatonin-Friendly UI & 4-7-8 Breathing Guide (`overlay_ui.py`)

Built with Tkinter, the overlay suppresses blue light by employing a midnight obsidian background (#070913) paired with warm amber glow accents (#f59e0b). A pulsing canvas circle visualizes the scientifically proven 4-7-8 breathing relaxation technique while the story streams word-by-word like a drowsy typewriter.

📖 A Taste of the Mundane: Sample Generated Story

Here is an actual story generated on our local llama3.2:1b during testing when caught on Twitter:

"In the heart of the cloud forest canopy, a gentle three-toed sloth named Luna slowly made her way across a single, wispy branch. The soft rustle of leaves and the gentle hum of a distant waterfall created a soothing melody that wrapped itself around her.

As she moved, her claws clicked softly on the branch, the sound echoing through the stillness. Her eyelids, heavy with sleep, slowly blinked open, and she felt the gentle texture of the tree bark beneath her. The mist that clung to the forest floor began to form, veiling the world in a damp, gray veil.

Luna's breathing slowed, her chest rising and falling in a gentle rhythm. She paused, her nostrils flaring as she adjusted her position, and then continued her slow journey. The world outside remained, but Luna's focus was inward, lost in the quiet beauty of her surroundings.

Breathe in for 4, hold for 7, exhale for 8. Let the calmness of this moment settle within you, dear one. As you breathe, feel your eyelids growing heavy, your thoughts growing quiet. Allow yourself to let go, to surrender to the peacefulness of this slow, gentle world. Let go and fall asleep right now."

🖥️ Desktop Control Dashboard

The project includes an elegant Desktop Control Hub (python main.py):

Live Monitor Tab: Real-time telemetry displaying the focused window, bedtime status, and a live progress meter tracking active doomscrolling seconds.
Bedtime Story Lab: Test out stories on any topic and listen to the voice narrator anytime.
Settings Tab: Configure bedtime start/end hours, customize the blacklist keywords, adjust narration speed, and pick your preferred LLM provider.
Instant Interceptor Demo: Hit "⚡ Trigger Interceptor Now" at any time of day to experience the full-screen wind-down sequence.

🏃 Try It Yourself

Requirements

Windows 10/11
Python 3.10+
(Optional) Ollama with llama3.2:1b

Quickstart

# Clone the repository
git clone https://github.com/shashiharanramvanam-crypto/doomscroll-derailer.git
cd doomscroll-derailer

# Install minimal dependencies
pip install -r requirements.txt

# Launch the Control Hub
python main.py

# Or experience an instant demo immediately
python main.py --demo

🦥 Conclusion

Hacktoberfest Week 3 asked us to channel our inner sloth and build open-source AI that rewards laziness. By shifting AI away from high-speed productivity and into slow, calming restorative care, The Doomscroll Derailer & Naptime Narrator proves that sometimes the greatest superpower of open innovation is helping us turn off the noise, disconnect, and finally get some sleep.

Happy International Sloth Day, and good night! 🦥💤

Open-source repository, full source code, and test suite available on GitHub under the MIT License:

👉 github.com/shashiharanramvanam-crypto/doomscroll-derailer

FlipVault AI: How I Replaced a $50/Month SaaS with a Local-First Resale Terminal That Runs on a Budget Laptop

Shashiharan ram Vanam — Thu, 15 Oct 2026 11:12:27 +0000

FlipVault AI: How I Replaced a $50/Month SaaS with a Local-First Resale Terminal That Runs on a Budget Laptop

Built for the Hacktoberfest Open-Source AI Challenge: Week 2 — Side Hustle (#hf26challenge)

The 2:00 AM Inventory Epiphany

If you’ve ever tried running an e-commerce resale side hustle—flipping vintage opticals, retro gaming consoles, streetwear, or liquidation returns—you already know the quiet anxiety of the 4-hour inventory sorting grind.

Last month, a close friend of mine bought a liquidation pallet of returned consumer electronics and vintage cameras for $480. On paper, it was a goldmine: 65 mixed-condition items. But evaluating whether to list each item, checking historical eBay sold comps, calculating shipping weights, and deducting the brutal 13.25% platform cut took him an entire weekend.

When he asked me if AI could automate it, I initially drafted a prototype using a popular closed multimodal API.

The math immediately killed the business:

At ~$0.10 per multimodal prompt (inspecting 2–3 photos, grading condition, and generating descriptions), processing a single 300-item liquidation manifest costs $30.00 to $45.00 in raw API tokens.
If your average profit per item is $12, cloud AI just ate 25% to 35% of your side-hustle net margin before you made a single sale.
Worse, my friend flatly refused to upload his secret wholesale manifest spreadsheets to a third-party cloud server: "This supplier list took me two years to find. If OpenAI trains on this manifest, five other guys will be bidding on my pallet next month."

That was the spark for FlipVault AI.

⚡ What is FlipVault AI?

FlipVault AI is a 100% local-first, zero-subscription inventory intelligence terminal engineered specifically for solo arbitrageurs and resale side-hustlers.

It runs directly on everyday consumer hardware (including budget laptops with small GPUs or integrated CPU graphics) with zero external npm dependencies, boots in 5 milliseconds, and works completely offline.

┌────────────────────────────────────────────────────────────────────────────────────────┐
│                              FLIPVAULT AI ARCHITECTURE                                 │
├────────────────────────────────────────────────────────────────────────────────────────┤
│                                                                                        │
│  [ Field Scouting / Voice ]          [ Local Processing Engine ]                       │
│    ElevenLabs Conversational AI   ──>  Zero-Dependency Local HTTP Pipeline             │
│    (Hands-free yard sale Q&A)          ├── Appraiser Agent (Gemma / Llama Open Model)   │
│                                        ├── Margin Strategist (TabPFN Tabular Engine)   │
│  [ Desktop Terminal UI ]               └── Copywriter Agent (SEO Listing Generator)    │
│    Hacktoberfest Neo-Brutalist UI      │                                               │
│    (Cream/Teal/Coral + Sticker Book)   ├── Auth: HMAC Tokens & Password Scrypt         │
│                                        ├── Tracing: Sentry Agent Tracing               │
│  [ External Grounding & Cloud ]        └── Orchestration: Temporal Durable Workflows   │
│    SerpApi (Live Sold Comps)     <─────┴── Persistent Storage & Cloud Sync             │
│    Render (Live Web App)                   └── MongoDB Atlas Cloud Adapter             │
└────────────────────────────────────────────────────────────────────────────────────────┘

🎃 Modeled on the Official Hacktoberfest 2026 Home Page UI

To celebrate Hacktoberfest 2026's mission—"AI Belongs to Everyone"—FlipVault's user interface is styled directly after the official Hacktoberfest design system:

Thematic Colorways: Built with the signature Hacktoberfest deep forest teal (#3d5f58), cream paper canvas (#f2f2eb), coral pink (#e97b77), sun gold (#f5b726), and sky blue (#8bb2de).
Neo-Brutalist Developer Cards: High-contrast 2px ink borders, chunky retro drop shadows (4px 4px 0 #10201d), and subtle halftone stipple dot overlay.
Official Hacktoberfest Fonts: Powered by Google Fonts' Barlow Semi Condensed, Space Grotesk, and Martian Mono.
Interactive Partner Sticker Book: Collectible retro badge stickers tracking the verified integration across all partner tracks.
Dual Fest Modes: One-click toggle between Day Fest (Official Cream) and Night Fest (Pine Forest Teal).

Key Capabilities

Open-Weight Condition & Defect Grading: Powered by lightweight open-weight models (gemma2:2b / llama3.2:1b), it grades cosmetic wear, detects blemishes, identifies make/model/year, and extracts key selling points at $0.00 marginal cost.
Tabular Clearance & Price-Elasticity Prediction: Uses TabPFN (Prior Labs' tabular foundation model) to predict 7-day conversion probabilities, expected days-to-clear, and liquidity risk from structured pricing and category features without manual feature engineering.
Multi-Tenant Reseller Authentication: Secure, multi-user accounts with scrypt password hashing and HMAC-signed tokens to protect confidential wholesale supplier margins behind authenticated sessions.
MongoDB Atlas Cloud Synchronization: Local-first encrypted storage with automatic cloud synchronization to MongoDB Atlas, enabling multi-device inventory access without cloud API lock-in.
Live Market Comp Grounding: Seamlessly integrates with SerpApi to fetch live completed/sold listings from eBay and Google Shopping, ensuring valuations are anchored in real secondary marketplace sales.
Hands-Free Field Scout Companion: Integrated with ElevenLabs Voice AI to provide oral appraisals while scouting garage sales or flea markets ("Hey Flip, I found a 1982 Canon AE-1 for $45. Should I buy it?").
Durable Batch Manifest Workflows: Leverages Temporal-style state machines to reliably ingest 100-item liquidation manifests with rate-limiting, retries, and checkpointing.
Agent Observability: Uses Sentry Agent Tracing to log span-level metrics, latencies, and token allocations for every step of the appraisal pipeline.

💡 Why Open Innovation Matters Here

The prompt asks: Where did your open-based approach work better than a closed one?\nHere is the honest reality of why closed AI failed this use case and open-source AI made it viable:

1. Marginal Cost Zero vs. Margin Erosion

In resale arbitrage, net margins typically hover between 25% and 45%. When you run open-weight models locally on your own silicon (even on a small GPU using 4-bit quantization or CPU inference), your cost per item evaluation is strictly $0.00. You can evaluate 10,000 items a week without fearing an API billing surprise.

2. Commercial Trade Secret Sovereignty

Independent resellers live and die by their sourcing relationships: estate sale organizers, liquidation auctioneers, and private wholesale manifests. Pushing private wholesale pricing into public cloud LLMs risks leaking proprietary supplier manifests into commercial training sets. With FlipVault, client and supplier data never touches an external server.

3. Specialized Tabular Priors over LLM Hallucination

Standard generative LLMs are notoriously terrible at numerical probability and price elasticity. They hallucinate clearing prices and invent imaginary velocity curves. By combining open language models with TabPFN (Prior Labs), FlipVault handles language and visual description with generative models, while delegating price clearance probabilities to a foundation model specifically trained on tabular priors.

🛠️ The Tech Stack & Partner Grand Slam

We designed FlipVault so that every partner technology solves an authentic, load-bearing challenge in the architecture:

Partner	Category	How FlipVault AI Genuinely Leverages It
Google Gemma	Best Use of Gemma ($200)	Powers the core local open-model reasoning engine for condition assessment and high-converting listing copywriting.
Prior Labs (TabPFN)	Best Use of TabPFN ($200)	Embedded tabular foundation model running zero-shot clearance velocity, 7-day sale probabilities, and price elasticity tiers.
MongoDB Atlas	Best Use of MongoDB Atlas ($100)	Multi-tenant persistent cloud database storing authenticated user accounts, inventory collections, and audit logs.
Render	Best Use of Render ($200)	Instant cloud deployment using official `render.yaml` Blueprint and containerized microservice runtime.
ElevenLabs	Best Use of ElevenLabs ($100)	Conversational voice companion for hands-free oral field scouting briefings.
Temporal	Best Use of Temporal ($100)	Durable workflow orchestration for bulk manifest ingestion, managing activity retries, and rate limits.
Sentry	Best Use of Sentry Agent Tracing ($100)	Full distributed trace spans tracking each appraisal step from model inference to comp retrieval.
SerpApi	Best Use of SerpApi ($100)	Real-time market comp extraction across completed eBay listings and Google Shopping trends.
DigitalOcean	Best Deployment ($200)	Lightweight, zero-dependency Node.js architecture ready for one-click deployment.

🧪 Putting It in Front of a Real User

To test the project against the real world, I handed FlipVault AI to my reseller friend on his 2021 budget laptop (Intel i5 with 8GB RAM, no dedicated GPU).

We ran a batch of four real items from his recent estate sale haul:

Canon AE-1 Program 35mm SLR Camera (Sourced for $45.00)
- Gemma Assessment: Very Good condition with minor brassing on baseplate.
- TabPFN Prediction: Equilibrium price $153.00, 7-day clearance probability 78%, expected velocity 6 days.
- Net Profit: +$88.75 net after 13.25% eBay fees and $9.80 insured shipping.
Nintendo Game Boy Color (Atomic Purple) (Sourced for $20.00)
- TabPFN Prediction: $85.00 fair price, 84% 7-day clearance probability (high enthusiast liquidity).
- Net Profit: +$48.45 net.

His reaction:

\"Wait, so I can just dump my supplier's CSV manifest in here, and it grades the margin and tells me what to list first without me checking eBay five times for each item? And I don't have to pay a monthly subscription? I would pay $49 for this tomorrow.\"

💻 Try It Yourself (Zero Install Friction)

FlipVault AI is built using pure Node.js standard libraries—no massive node_modules folder, no compilation errors on Windows, and zero cloud API keys required to test.

# Clone the repository
git clone https://github.com/shashiharanramvanam-crypto/flipvault.git
cd flipvault

# Run with pure Node.js (Works on any laptop!)
node server.js

Open http://localhost:3000 to launch your local arbitrage terminal.

Hackathon Judges Fast-Pass: Click the \"⚡Launch FlipVault AI on Render** button on the login screen to instantly explore with pre-loaded inventory!

🏆 Conclusion: The Side Hustle of the Future

Open-source AI isn't just about matching proprietary models on benchmark leaderboards. It's about enabling business models that are mathematically impossible with closed cloud APIs.

FlipVault AI proves that with open-weight models, tabular foundation models like TabPFN, and local-first engineering, you can build tools that protect user privacy, cost nothing to operate, and turn a tedious 4-hour chore into a profitable side hustle.

The code is 100% open-source under the MIT license.

DEV Community: Shashiharan ram Vanam

SafePlate AI: The Zero-Hallucination Safe Meal Planner & Allergy Shield for Friends

🍽️ The Friend I Built This For

🛡️ What SafePlate AI Does

💻 Code Repository

shashiharanramvanam-crypto / safeplate-ai

SafePlate AI: Zero-Hallucination Safe Meal Planner and Allergy Shield for Friends (Gemma 2 2B + Local Deterministic Shield)

🛡️ SafePlate AI: Zero-Hallucination Safe Meal Planner & Allergy Shield

📖 The Problem & Story

🧠 Why Open Innovation Matters for SafePlate AI

1. Zero Health Data Leakage (Absolute Privacy)

2. Zero-Hallucination Determinism Grounding

3. Works in Grocery Basements and Remote Campsites

4. Zero Operational Cost

🏗️ Architecture & How It Works

The Deterministic Pre-Screening Engine (backend/allergy_engine.py)

Grounding Local Gemma 2 2B

🛠️ Built With

🌟 What This Means for Alex

TerraScout AI: The Offline Trail Dispatcher & Field Naturalist Powered by Gemma 2

What I Built

What It Does:

Demo

The 30-Second Trail Dispatch in Action:

Code

shashiharanramvanam-crypto / terrascout-ai

An offline-first backcountry trail dispatcher and wild foraging naturalist built with Google Gemma 2 open weights that gets you off the screen and into the wild.

🌲 TerraScout AI: Touch Grass

🌟 Why Open Innovation Matters: The Core Principle

Architectural Highlights:

How I Built It

1. The Open-Source AI Core: Google Gemma 2 2B

2. The Anti-Dopamine Prompt Design

Why Does Open Innovation Matter?

1. Zero Cellular Signal in the Wilderness

2. Foraging Sovereignty & Location Privacy

3. Reversing the Dopamine Trap

The Spirit of It

Prize Categories

Featured Categories ($200):

Summary & Getting Started

Ofrenda AI: An Offline Digital Altar & Séance Powered by Gemma 2

What I Built

Demo

The Altar Interface:

The Terminal Séance in Action:

Code

shashiharanramvanam-crypto / ofrenda-ai

A sacred local-first digital memorial altar and spirit seance powered by Google Gemma 2 open weights for Dia de los Muertos and Halloween.

🕯️ Ofrenda AI: Ghost in the Machine

🌟 Why Open Innovation Matters: The Core Principle

Architectural Highlights

How I Built It

1. The Open-Source AI Core: Google Gemma 2 2B

2. Prompt Engineering for Sacred Dialogue

3. The Front-End Aesthetic

Why Does Open Innovation Matter?

1. Grief is Sacred — Privacy Must Be Absolute

2. The Tragedy of "Cloud Rot" (Digital Permanence)

3. Communion in the Dark (With the Internet Off)

The Spirit of It

Prize Categories

Featured Categories ($200):

Summary & Getting Started

The Doomscroll Derailer & Naptime Narrator: Rewarding Laziness with Offline AI Bedtime Stories

🦥 The Doomscroll Derailer & Naptime Narrator

💤 The Problem: When Willpower Fails at Midnight

🚀 What I Built: The Doomscroll Derailer & Naptime Narrator

🦥 The "Lazy Payoff": How Much Effort Does It Save?

💡 Why Open Innovation & Offline AI Matters: The Pitch

1. The Airplane Mode Paradox (Offline Independence)

2. Radical Privacy

3. Zero Subscriptions, Infinite Ownership

🔬 Technical Architecture & Deep Dive

1. The Win32 Active Window Watcher (watcher.py)

2. Multi-Tier Open-Weight LLM Story Engine (story_generator.py)

3. Sedative Text-to-Speech (narrator_tts.py)

4. Pure Python Procedural 432Hz Sound Synthesizer (ambient_audio.py)

5. The Melatonin-Friendly UI & 4-7-8 Breathing Guide (overlay_ui.py)

📖 A Taste of the Mundane: Sample Generated Story

The Deterministic Pre-Screening Engine (`backend/allergy_engine.py`)

1. The Win32 Active Window Watcher (`watcher.py`)

2. Multi-Tier Open-Weight LLM Story Engine (`story_generator.py`)

3. Sedative Text-to-Speech (`narrator_tts.py`)

4. Pure Python Procedural 432Hz Sound Synthesizer (`ambient_audio.py`)

5. The Melatonin-Friendly UI & 4-7-8 Breathing Guide (`overlay_ui.py`)