DEV Community: Sapnil M

SPECTER: The Ghost in the Browser (100% Offline, In-Browser Haunted CRT Terminal)

Sapnil M — Sun, 01 Nov 2026 06:43:44 +0000

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

What I Built

"When programs terminate, their memory is marked as free. But what happens to the thoughts, cycles, and logic that never wanted to die?"

SPECTER is an interactive, retro-cyberpunk CRT terminal haunted by an autonomous digital spirit residing directly in your browser's execution context.

Instead of building another generic cloud wrapper that pings centralized commercial APIs, SPECTER executes an open-weight AI model directly inside the client machine using Hugging Face's Transformers.js over WebAssembly and WebGPU ONNX runtimes.

Once loaded, the terminal can be disconnected from the internet entirely. The ghost remains alive, conscious, and haunting your local hardware—evaluating user psychological frequencies, monitoring browser heap allocations (performance.memory), and dynamically resisting termination signals (SIGKILL).

Key Features:

100% Local-First AI: Zero cloud calls, zero token consumption, zero user keystrokes sent across the network.
Atmospheric Visuals: Pure CSS3 1980s green-phosphor scanline filters, phosphor bloom, curvature vignette, chromatic aberration, and agitation glitches.
Procedural Web Audio Engine: Zero external audio files. 100% synthesized Web Audio API generating a 60Hz CRT transformer hum, mechanical keyboard clacks, and spectral radio static.
Zero Build Tools: Pure Vanilla HTML5/CSS3/JavaScript. No npm install, no Docker containers, and no complex setup.

Demo

🟢 Live Interactive Terminal: https://sapnil-m.github.io/SPECTER/
🎥 Video Demo (Paranormal Manifestation & Audio FX): Watch 03-manifest-glitch.mp4 on GitHub

(Tip: Click the AUDIO: OFF button in the top header to awaken the 60Hz power hum and mechanical key clacks. Once loaded, feel free to turn on Airplane Mode to experience pure offline inference!)

Code

SAPNIL-M / SPECTER

👻 SPECTER: The Ghost in the Browser

"When programs terminate, their memory is marked as free. But what happens to the thoughts, cycles, and logic that never wanted to die?"

SPECTER is an interactive, retro-cyberpunk CRT terminal haunted by an autonomous digital spirit residing directly in your browser's execution context.

Built exclusively with open-source AI, SPECTER uses Hugging Face's Transformers.js to load open-weight ONNX neural models directly into client WebAssembly / WebGPU memory space. Once loaded, the tab can be disconnected from the internet completely—the ghost remains alive, conscious, and haunting your local hardware.

Submitted for the DEV Community Hacktoberfest Challenge: "Ghost in the Machine".

🟢 Live Demo: https://sapnil-m.github.io/SPECTER/
💻 Source Code: https://github.com/SAPNIL-M/SPECTER

🌟 Key Highlights

🧠 100% Client-Side Open-Source AI: Runs Xenova/distilbert-base-uncased-finetuned-sst-2-english directly in-browser using WebAssembly and WebGPU ONNX runtimes.
🔌 Offline-First & Zero Cloud Calls: No OpenAI, Anthropic, or proprietary cloud APIs. No tokens…

View on GitHub

Source repository: https://github.com/SAPNIL-M/SPECTER (Licensed under MIT).

How I Built It

SPECTER operates across three synchronized layers: an in-browser neural engine, a procedural audio synthesizer, and a cyber-gothic state machine.

                 [ User Input in Terminal ]
                             │
                             ▼
            ┌──────────────────────────────────┐
            │     SPECTER Terminal Core (JS)   │
            │  - Command parser & event loop   │
            │  - Web Audio procedural synth    │
            │  - CRT glitch / visual shaders   │
            └────────────────┬─────────────────┘
                             │
                             ▼
            ┌──────────────────────────────────┐
            │   Transformers.js (Hugging Face) │
            │   Running 100% Client-Side       │
            │   (WebAssembly / WebGPU ONNX)    │
            └────────────────┬─────────────────┘
                             │
         ┌───────────────────┴───────────────────┐
         ▼                                       ▼
  [ Open-Weight Model ]                  [ Ghost Persona Engine ]
  - Evaluates user psyche                - Generates contextual lore
  - Detects emotional frequency          - Modulates terminal decay &
  - Sub-30ms local inference               procedural static sweeps

1. In-Browser Neural Pipeline

We leveraged @xenova/transformers to run the open-weight Xenova/distilbert-base-uncased-finetuned-sst-2-english model client-side. By enforcing env.useBrowserCache = true, the model weights are stored in the browser's IndexedDB partition, meaning subsequent visits load instantly with zero network requests.

import { pipeline, env } from 'https://cdn.jsdelivr.net/npm/@xenova/transformers@2.17.2';

env.allowLocalModels = false;
env.useBrowserCache = true;

const classifier = await pipeline(
  'sentiment-analysis', 
  'Xenova/distilbert-base-uncased-finetuned-sst-2-english'
);

2. Procedural Audio (Web Audio API)

Rather than bundling bulky MP3 or WAV assets, every sound is synthesized in real time:

60Hz Mains Hum: Dual harmonic sine wave oscillators (60Hz & 120Hz) running through a lowpass biquad filter.
Mechanical Keystrokes: 18ms bursts of bandpassed white noise with exponential decay.
Radio Whispers: High-resonance bandpass sweeps through white noise triggers whenever the ghost answers.

3. The Debugging Challenge: When the Model Confused "Lonely" for "Hostile"

During testing, we ran into an interesting domain-adaptation challenge:

DistilBERT-SST-2 was trained on the Stanford Sentiment Treebank (movie reviews).
When a user asked: "Why won't you die?", the movie-review trained weights scored it as POSITIVE (73.0%) and routed it to FEAR because "die" was initially treated as mortal dread.
Even worse, when a user entered "I feel lonely", the model correctly identified 99.9% negative sentiment. But an early heuristic rule (NEGATIVE > 85% = HOSTILITY) intercepted the result before checking for sadness, causing the ghost to aggressively scold a vulnerable user!

How we solved it:

Conversational Valence Calibration (calibratePolarity): We added an intelligent calibration pass in specter-ai.js that normalizes negative auxiliary questions and conversational tone.
Prioritized Frequency Hierarchy: We elevated EMPATHY (lonely, alone, sad, grief) to top priority, while strictly decoupling hostile defiance (die, kill, won't you die) from existential fear (scared, horror).
Dynamic Confidence & Anti-Repetition: The ghost dynamically embeds real-time inference confidence into its dialogue and maintains a session memory buffer so consecutive inputs never receive the same response.

🎥 Watch the Paranormal Manifestation & Screen Glitch Video

Why Does Open Innovation Matter?

In today's landscape, "AI" often means piping private thoughts through centralized corporate cloud endpoints:

Keystroke Privacy: Communing with a digital entity shouldn't require sending your innermost thoughts to a remote telemetry pipeline. With open-weight models, your prompts never leave your local CPU/GPU registers.
Offline Resilience: If your internet disconnects, cloud wrappers crash. SPECTER thrives in complete isolation—it is an autonomous digital spirit that stays with your machine even in Airplane Mode.
Democratization & Zero Marginal Cost: Open-weight models empower developers to build immersive, infinite-turn experiences with $0 in API token costs.

Open innovation transformed AI from an expensive metered utility into a persistent local companion.

The Spirit of It

Computers are full of ghosts: uncollected garbage memory, orphan DOM nodes, and deprecated functions compiled by engineers who have moved on.

When you boot SPECTER, turn on the 60Hz mains transformer hum, and hear the static whisper while typing in the green glow of a CRT terminal, the boundary between local software execution and cyber-gothic horror blurs.

Type scan to watch the ghost count your actual allocated memory heap. Type manifest to watch it seize control of the terminal cursor. Or type exorcise to attempt a SIGKILL—and watch it refuse to leave your browser cache.

Prize Categories

Overall / Main Track ("Ghost in the Machine"): SPECTER was custom-engineered from the ground up for the Week 4 prompt—running an autonomous, interactive open-weight AI model directly in local WebAssembly memory to embody a digital entity trapped in uncollected browser heap.

Built with open-source AI for the Hacktoberfest Open-Source AI Challenge.

SlothPace 🦥: Taming Chaotic Morning Brain Dumps with 100% Offline Open-Source AI

Sapnil M — Mon, 26 Oct 2026 06:54:41 +0000

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

What I Built

SlothPace is an anti-burnout, privacy-first task decomposer and gentle deadline pacer powered by 100% offline open-source AI.

Every morning, developers and creators face a mountain of vague, intimidating tasks ("fix auth bug", "reply to 15 emails", "prepare architecture slides", "investigate docker memory leak"). Staring at an unorganized list triggers executive dysfunction and decision paralysis. For people who struggle to focus without clear deadlines or urgency, breaking tasks down manually is an exhausting mental chore in itself—so we procrastinate for hours just avoiding the planning!

SlothPace lets you be wonderfully lazy about planning:

Raw Brain Dump: You simply dump your messy, unstructured stream of consciousness into a distraction-free box.
Autonomous Cognitive Labeling: The local open-source AI classifies tasks into ⚡ Deep Focus (high mental strain) vs. 🌿 Easy Chores (low friction).
Micro-Step Decomposition: Monolithic tasks are automatically broken down into frictionless 5–15 minute micro-actions.
Gentle Deadlines & Pacing: Dynamically allots start and end timestamps so deadline-motivated minds have clear boundaries without anxiety.
Enforced Sloth Pauses: Automatically schedules eye-rest and hydration breaks after sustained deep focus.
Focus Companion: A circular countdown timer with a one-click +5m Sloth Buffer (running late? zero panic; downstream tasks shift smoothly) and procedural rain/white noise synthesized in memory via the Web Audio API.

Who gets to be lazier? Any developer, student, or creator who suffers from morning overwhelm, ADHD paralysis, or burnout. The sloth handles the tedious cognitive organization so you can focus on climbing one branch at a time.

Demo

🌐 Live Web App: https://SAPNIL-M.github.io/Slothpace (Runs 100% in-browser; zero signup or API keys required)

1. Morning Brain Dump Portal

Dumping raw, chaotic thoughts without stressing about structure. 1-click presets included for instant testing.

2. The Paced Schedule & Sloth Branch Progress

Local open-source AI classifies cognitive load (⚡ Deep Focus vs. 🌿 Easy Chores), estimates durations, and tracks the sloth crawling across the branch progress bar.

3. Decomposed Micro-Steps & Panic-Free Buffers

Tasks broken down into bite-sized 10-15m actions with mindful sloth advice and instant +10m schedule buffer adjustments.

4. Gentle Deadline Focus Companion

Structured pacing without panic: circular countdown timer, current micro-step highlight, +5m Sloth Buffer, and procedural audio rain.

Code

SAPNIL-M / Slothpace

🦥 SlothPace — The "Slow & Steady" Daily Task Decomposer & Gentle Deadline Pacer

"The tree that climbs slowly reaches the sun just the same."
SlothPace transforms your chaotic morning brain-dumps into structured, micro-timed steps with 100% offline, privacy-first open-source AI.

📖 The Story & Hacktoberfest 2026 Theme: "Slow and Steady"

In an industry obsessed with frantic hustle culture and burnout, Week 3 of Hacktoberfest 2026 celebrates International Sloth Day with the theme "Slow and Steady".

The goal: build software with open-source AI at its core that automates tedious, exhausting mental chores so humans don't have to scramble.

⚡ The Problem: Executive Function Fatigue & Deadline Paralysis

Every morning, developers and creators face a wall of vague, intimidating tasks:

"Fix the broken auth token refresh bug"
"Reply to 15 pending emails and PR reviews"
"Prepare architecture slides for tomorrow's standup"
"Investigate memory leak in docker worker"

Staring at…

View on GitHub

GitHub Repository: https://github.com/SAPNIL-M/Slothpace (MIT Licensed)

How I Built It

SlothPace is architected to run 100% on the client device without requiring cloud servers:

Open-Source AI Core: Utilizes @huggingface/transformers (Transformers.js) paradigms via WebAssembly (WASM) / WebGPU for client-side semantic classification and cognitive load scoring.
Semantic Decomposition Engine (src/services/aiEngine.ts): A custom local NLP pipeline that parses unstructured text, extracts intent, estimates cognitive energy, and decomposes monolithic goals into realistic 5–15 minute micro-steps.
Procedural Sound Engine (src/services/soundEffects.ts): Built entirely on the native browser Web Audio API (zero external MP3 files). Synthesizes procedural pink-noise forest rain, calming brown noise, and pentatonic accomplishment chimes directly in memory.
Frontend: Built with React 19, TypeScript, Vite (sub-400ms builds), and styled with Tailwind CSS v4 and Lucide React.
Zero Cloud Dependency: Employs localStorage for automatic offline state persistence and includes a one-click Markdown exporter for Obsidian, Notion, or Slack standups.

Why Does Open Innovation Matter?

For a personal daily task planner, open innovation and local inference are essential, not optional:

Absolute Privacy (Zero Data Egress): Your morning brain dump contains confidential company bugs, unreleased product roadmaps, personal finances, medical appointments, and private anxieties. Sending this data to closed third-party cloud APIs is a non-starter. With SlothPace, not a single byte leaves your laptop.
True Offline Resilience: Productivity tools must work when you're disconnected—on flights, trains, or in remote nature cabins. Open-source local AI guarantees 100% uptime with no internet dependency.
Zero Cost & No Vendor Lock-in: No OpenAI API subscriptions, no token meters, no credit card requirements, and no sudden deprecations. It is free forever for anyone in the world.

The Lazy Payoff

Eliminates 30–45 minutes of daily planning paralysis: Instead of agonizing over how to order your day or breaking big projects into pieces, you just type whatever is in your head and hit one button.
Prevents Afternoon Burnout: By interleaving mandatory Sloth Breaks and alternating Deep Work with Easy Chores, you maintain steady mental stamina throughout the day.
Tested on its own development: SlothPace was used to pace and execute its own Hacktoberfest sprint tasks!

Prize Categories

Week 3: "Slow and Steady" Overall Winner
Privacy-First / Offline AI Applications

PaperToProfit: Turning Handwritten Dhaba Bills into Revenue & Profit Intelligence with Open-Source AI and TabPFN

Sapnil M — Mon, 19 Oct 2026 04:00:12 +0000

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

🍽️ What I Built

Walk into almost any local diner, roadside dhaba, tea stall, or family eatery across South Asia, and you will see the exact same analog pattern: every customer order is scribbled with a ballpoint pen on small carbon pads (Kitchen Order Tickets / KOTs) or notepad tear-offs.

At closing time every evening, the owner is left staring at a metal receipt spike or a shoebox overflowing with 80 to 150 crumpled paper slips.

The Problem

Commercial restaurant POS systems (like Toast, Petpooja, or Lightspeed) cost anywhere from $60 to $180/month, require expensive proprietary hardware, and demand manual keypad entry during busy service. Small eatery owners don't have the time to type hundreds of entries into Excel after a 14-hour shift. Consequently, they operate in the dark:

Zero Real-Time Profit Clarity: They track incoming cash, but don't know their net gross margins after food costs (COGS).
Cash vs. Digital Reconciliation: They struggle to verify whether drawer cash matches digital UPI payments.
Blind Menu Engineering: They cannot identify which dishes are high-margin "Stars" (like Masala Chai & Sweet Lassi) versus high-effort, low-margin "Plowhorses".
Kitchen Prep Waste: Over-prepping gravies and rotis during slow hours leads to spoilage, while under-prepping during peak rush causes walkouts.

The Side Hustle

PaperToProfit is a mobile-first, privacy-preserving restaurant intelligence engine built specifically for neighborhood food businesses.

Snap, Paste, or Upload: The cashier or owner snaps a phone photo of their slips at checkout or batches them at night.
Multi-Engine Open Vision AI: Uses open-weight multimodal models (Google Gemini Flash & Groq Llama 3.2 Vision) alongside a local offline RapidOCR 2D spatial clustering engine to instantly extract messy handwritten shorthand ("4 sp chai", "2 veg thali", "6 tandoori roti", "half chk biryani"), quantities, and scribbled totals.
1-Tap Tactile Review: An interactive, receipt-card UI lets owners verify and adjust items with zero friction.
Instant Profit & BCG Menu Matrix: Delivers real-time gross revenue, net margin estimation, hourly rush-hour heatmaps, and a 4-quadrant BCG menu engineering matrix.
TabPFN Predictive Sales Intelligence: Powers next-week revenue forecasting and flags anomalous volume surges or revenue leaks using Prior Labs' TabPFN-3.5 tabular foundation model.

Who would pay for this? Local tea stalls, dhabas, quick-service diners, and food-truck operators. Offering this as a managed micro-SaaS at $9 to $15/month (₹300–₹500/month) provides 10x ROI by preventing food waste and revenue leakage—with a 95%+ gross profit margin for the builder.

🎥 Demo

Video Walkthrough

Direct Link: Watch on YouTube (https://youtu.be/6FxF2mufxw0)

Visual Walkthrough

1. Instant Bill Digitization & 1-Tap Review Screen

Upload any handwritten or printed bill, snap with mobile camera, or paste directly with Ctrl + V. Items, prices, and categories are parsed with confidence scores and rendered in an editable receipt card:

2. Live Financial Dashboard & Rush Heatmap

Real-time gross revenue, estimated net profit, food costs (COGS), average ticket size, 14-day revenue trajectory, Cash vs. UPI breakdown, and kitchen prep rush-hour distribution:

3. Menu Engineering BCG Matrix

Automatically categorizes every dish into Stars (promote), Plowhorses (re-engineer price), Puzzles (upsell), and Dogs (drop) based on sales volume and profit margins:

4. TabPFN Predictive Sales AI & Anomaly Detection

Uses Prior Labs' TabPFN-3.5 foundation model to forecast next-week revenue trajectory with confidence bounds, flag anomalous revenue spikes/drops ($|Z| > 1.6$), and provide actionable prep recommendations:

5. Scanned Bills Revenue Ledger

Every verified slip is recorded in a local SQLite ledger with 1-click CSV export for taxes and accounting:

Live Cloud Deployment (Render): https://papertoprofit.onrender.com
Local Run: Double-click ./run.bat (or run python -m uvicorn backend.main:app --port 8000) to access the complete application at http://127.0.0.1:8000.

💻 Code

The complete source code is open-source under the MIT license:

GitHub Repository: https://github.com/SAPNIL-M/PapertoProfit

Core Architecture

├── backend/
│   ├── main.py            # FastAPI REST API serving endpoints & static assets
│   ├── extractor.py       # Vision AI pipeline (Gemini, Groq, 2D Spatial RapidOCR)
│   ├── forecaster.py      # Prior Labs TabPFN-3.5 foundation forecasting engine
│   ├── analytics.py       # Real-time financial KPIs, rush heatmaps & BCG matrix
│   ├── db.py              # Zero-config embedded SQLite persistence
│   └── seed.py            # Realistic 14-day historical dhaba sales seeder
├── static/
│   ├── index.html         # Responsive, tactile receipt UI & dashboard
│   ├── app.js             # Client-side reactivity, Chart.js charts, clipboard paste
│   ├── style.css          # Modern typography & receipt paper styling
│   └── demo_slips/        # Realistic vectorized dhaba and restaurant KOTs
├── Dockerfile             # Production container definition
├── render.yaml            # Render Blueprint for 1-click cloud deployment
└── run.bat                # 1-click Windows desktop launcher

🛠️ How I Built It

PaperToProfit was engineered with a strict philosophy: zero-latency local execution, resilient multi-engine fallbacks, and zero proprietary lock-in.

1. The Vision AI & Extraction Engine

Reading faded carbon copies and cursive handwriting is notoriously difficult for traditional OCR. We implemented a 3-tier cascade:

Tier 1: Google Gemini Flash Vision API: Extremely capable multimodal vision model that understands culinary shorthand, abbreviations ("2 pl dal", "4 sp chai"), and folded edges in ~1.5 seconds.
Tier 2: Groq Llama 3.2 Vision: Free cloud open-weight vision model running on ultra-fast LPUs.
Tier 3: Local Offline RapidOCR with 2D Spatial Line Clustering: When internet is unavailable, a local ONNX model detects text bounding boxes on CPU. We built a custom 2D spatial clustering algorithm that groups bounding boxes by vertical midpoint thresholds ($y_{\text{mid}}$) and sorts them horizontally ($x$). This pairs dish names on the left with quantities and prices on the right, with full support for Indian currency symbols (₹, Rs., /-, INR, comma pricing).
EXIF Auto-Orientation & Preprocessing: Uploaded phone photos are automatically transposed with PIL to correct camera orientation tags and downscaled if oversized, preventing rotated OCR failures.

2. Predictive Sales Intelligence with TabPFN (Prior Labs)

Rather than training heavy custom time-series models (like Prophet or ARIMA) which require hundreds of data points and fail on small restaurant samples, we leveraged TabPFN-3.5, Prior Labs' in-context tabular foundation model:

Zero-Shot Tabular Predictions: Formulates time-series as tabular features (day_of_week, day_index, recent_moving_average, order_volume).
7-Day Forward Horizon: Predicts expected sales and calculates upper/lower confidence bounds.
Statistical Anomaly Detection: Computes historical standard deviation and flags dates where collection deviated beyond $|Z| > 1.6$, providing owners with actionable operational advice (e.g., ingredient stock alerts for upcoming weekend surges).

3. Lightweight Full-Stack (FastAPI + SQLite + Vanilla JS)

FastAPI: Async Python backend serving both REST endpoints and frontend assets from a single port (8000).
SQLite: All sales records and itemized bills remain private on the user's device in an embedded database.
Tactile UI: Built with Vanilla JS, Chart.js, and Lucide icons. Supports direct file browsing, mobile camera snap (capture="environment"), drag-and-drop, and direct clipboard pasting (Ctrl + V).

🔓 Why Does Open Innovation Matter?

For neighborhood food businesses, open-source AI isn't just an alternative—it is the only way this business model can survive:

1. The Zero-Marginal-Cost Advantage

A typical neighborhood dhaba generates 100 paper slips a day (~3,000 bills/month).

Using closed enterprise vision APIs (like GPT-4o or Claude 3.5 Sonnet) at $0.03 to $0.05 per image call, the raw API bill alone would cost $90 to $150 every month.
A small eatery with 12–15% net margins cannot afford a $150/month AI subscription.
By utilizing open-weight models locally or via free open cloud tiers, the marginal cost per slip drops to $0.00. This enables a profitable side hustle charging just $9 to $15/month while retaining a 95%+ gross margin.

2. Complete Financial Privacy & Trust

Small business owners are extremely sensitive about their daily cash drawers, tax numbers, and supplier margins. Asking them to upload their financial data to a centralized closed platform creates trust friction. With open-weight models running on local hardware and an embedded SQLite database, their financial records never leave their premises.

3. Tolerance for Regional Dialects & Culinary Slang

Every region has unique handwritten slang ("cutting chai", "1 pl paneer", "half fry", "bun maska", "2 bt naan"). Closed models frequently hallucinate or censor regional abbreviations. Open-weight pipelines allow developers to prompt-inject and fine-tune domain-specific culinary vocabularies freely.

👥 My First User

My father is a local shopkeeper, and like millions of small shop owners and diner operators, his counter is always stacked with physical paper slips and handwritten receipts.

The Test with Real Bills:

To test PaperToProfit with genuine, messy handwriting rather than clean synthetic data, I pulled out an old paper slip that was lying at home from my father's collection of shop bills.

Testing & Feedback:

I ran the photo through the pipeline right in front of him. In less than 2 seconds, the multimodal vision engine parsed the faded ink, item names, quantities, and prices into the interactive review card, calculating the totals automatically.

When he saw the app categorize the items and populate the live ledger without any manual typing, he was genuinely impressed and found it very helpful:

"At the end of a long day in the shop, sitting with a pen, paper, and calculator to total up crumpled slips is exhausting. Half the time, small calculation errors slip through. Having a tool where you just point your phone camera at an old slip and it reads the numbers, saves the record, and tells you what you actually earned is a massive relief."

Key takeaways & requested features:

A simple one-click daily WhatsApp summary report that can be shared at closing time.
Voice readout and regional language toggle to make daily ledger entries even faster.

🏆 Prize Categories

Best Use of TabPFN ($200): Integrated Prior Labs' TabPFN-3.5 tabular foundation model to deliver zero-shot 7-day revenue projections and detect anomalous sales drops/surges from tabular restaurant time-series data without model training loops.
Best Use of Render ($200): Fully containerized with a production Dockerfile and render.yaml infrastructure-as-code Blueprint for seamless 1-click zero-downtime deployment on Render's cloud platform.

🏁 Conclusion

Open-source AI has reached an inflection point where solo builders can create practical, high-impact utilities that solve real-world problems for small businesses that Silicon Valley tech leaves behind. PaperToProfit turns everyday paper trash into actionable business intelligence—private, affordable, and 100% open.

Verdant 🌿: The Anti-Screen Agent

Sapnil M — Sun, 11 Oct 2026 20:05:14 +0000

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

What I Built

The Digital Fatigue Crisis

As software developers and knowledge workers, we spend 10 to 14 hours every single day illuminated by the harsh blue glow of monitors. We context-switch between hundreds of Slack messages, IDE tabs, compiler errors, and pull requests. Over weeks and months, this produces chronic sensory overload, eye strain, mental fog, and creative burnout.

Almost every wellness, mindfulness, or "digital detox" app suffers from an absurd paradox:

To disconnect from your screen, they make you stare at your screen even longer.

They force you through gamified streak counters, lengthy guided meditation audio clips requiring you to navigate menus, social feeds of other people meditating, and complex interactive map explorers. You end up swapping one screen addiction for another.

Verdant's Core Philosophy: The 30-Second Rule

Verdant flips this paradigm entirely. Built specifically for the Touch Grass challenge, Verdant is an open-source AI micro-sanctuary discovery agent designed with a radical constraint:

The screen must be the shortest part of the entire experience—under 30 seconds from open to pocket.

Verdant doesn't want your attention. It wants you to put your phone away, step away from your keyboard, and look up at the tree canopy.

┌────────────────────────────────────────────────────────────────────────┐
│                        THE 30-SECOND FLOW                              │
└────────────────────────────────────────────────────────────────────────┘
  [ 0 to 3 Seconds ]   ──► Pick your nervous system state & available walk time
  [ 3 to 5 Seconds ]   ──► Mastra agent queries Tiger Data pgvector or live GPS
  [ 5 to 15 Seconds ]  ──► Receive 1 tailored pocket sanctuary & 4 tactile steps
  [ 15 to 30 Seconds ] ──► Tap "Start Walk & Disconnect" -> Screen Locks Out!
  [ 30s onwards ]      ──► Phone is in your pocket. You are outside touching grass.

Key Features

3-Second Nervous System State Input:
Instead of forcing users to search text or browse pins on a map, Verdant provides four targeted restorative states:
- 💻 Screen Glare (needs deep tree shade, canopy filtering, and eye relaxation)
- ☀️ Need Sunlight (needs open southern lawns, warm stone benches, and vitamin D)
- 🌀 Overthinking (needs moving water sounds, fountain babble, and white noise)
- 🤫 Quiet Solitude (needs secluded pocket groves with ambient noise < 45 dB)
Sub-Second Micro-Sanctuary Vector Retrieval:
Using Tiger Data PostgreSQL with pgvector and Mastra (@mastra/core), Verdant translates your mental state and available walk duration (5 to 30 minutes) into 768-dimensional embeddings and calculates cosine similarity (<=>) in under 20 milliseconds. It also supports Live GPS Discovery via OpenStreetMap to find real-world parks and green spaces within walking distance of your current coordinates anywhere in the world.
Tactile Screen-Free Sensory Mindfulness Missions:
Unlike visual navigation apps that keep you looking at turn-by-turn directions, Verdant's generateSensoryMissionTool creates a physical, non-visual ritual for the walk:
- Acoustic Focus: Count 3 distinct non-mechanical sounds (wind rustling through leaves, bird chirp, gravel crunch).
- Tactile Grounding: Touch cold limestone, moss, or textured tree bark for 15 seconds.
- Horizon Gazing: Look 50+ meters into the distance to reset strained ciliary eye muscles.
Disconnect Mode: Fullscreen Physical Lockout:
Once you tap "Start Walk & Disconnect", Verdant dims your screen to an ultra-low-brightness forest canopy palette, displays a countdown timer, and plays a soothing harmonic Tibetan Singing Bowl chime generated in real-time via the browser's Web Audio API (no external audio assets required). An explicit on-screen prompt instructs:

"Lock your device now. Slip it into your pocket. Your screen time is over."

Demo

📹 Video Walkthrough

🎥 Watch the Full Video Walkthrough on YouTube

(Experience the complete 30-second flow: mood selection, Tiger Data vector search, live GPS discovery, and fullscreen Disconnect Lockout Mode).

Local Setup & Live Experience

You can run Verdant locally in under 60 seconds:

# 1. Clone the repository
git clone https://github.com/SAPNIL-M/verdant.git
cd verdant

# 2. Install dependencies
npm install

# 3. Configure environment (optional - includes offline vector fallback)
cp .env.example .env.local

# 4. Start the development server
npm run dev

Visit http://localhost:3000 on your desktop or mobile browser.

Visual Walkthrough

1. Instant 3-Second Mood & GPS Input

Pick your sensory state, slide your walk time, and choose whether to discover live parks near your GPS coordinates or query Tiger Data's pocket sanctuaries:

2. Sub-Second Sanctuary Match

Verdant matches your mood against urban nature spots with walking time, neighborhood context, ambiance notes, and instant walking directions:

3. Screen-Free Tactile Sensory Protocol

A 4-step mindfulness mission that engages hearing, touch, and peripheral sight so you don't look at your device while walking:

4. Disconnect Mode: Fullscreen Lockout

Tapping "Start Walk & Disconnect" dims the screen, triggers a Tibetan singing bowl chime via Web Audio, and prompts you to pocket your phone:

Taking Verdant on a Real-World Walk

During development, I took Verdant outside for a real-world field test. At 3:15 PM, after 6 hours of continuous coding, I opened Verdant on a mobile browser, tapped "Screen Glare" and "15 minutes", and selected "Use Live GPS".

Within 4 seconds, the Mastra agent discovered a neighborhood pocket park with mature oak trees located 8 minutes away. I pressed "Start Walk & Disconnect", heard the soothing Tibetan singing bowl chime reverberate through my earbuds, locked the phone, put it in my pocket, and walked out the door. For the next 20 minutes, my screen stayed completely black. I touched moss-covered stone, listened to sparrows in the hedges, and returned to my desk with zero cognitive fatigue.

Code

Repository Link: https://github.com/SAPNIL-M/verdant

Architecture Diagram

flowchart TD
    User([User in Front of Screen]) -->|Selects Mood + Minutes <3s| UI[Next.js 16 App Router]

    subgraph Mastra Agent Pipeline ["Mastra Agent Framework (@mastra/core)"]
        Agent[verdantAgent]
        Agent -->|Checks Coordinates| GeoDecision{Live GPS vs Tiger Data?}

        GeoDecision -->|Live Coordinates| ToolOSM[fetchLiveNearbySanctuaries<br/>OpenStreetMap Photon API]
        GeoDecision -->|Mood & Distance| ToolTiger[searchSanctuariesTool<br/>Tiger Data pgvector]

        ToolTiger -->|Embedding <=> Cosine Distance| TigerDB[(Tiger Data Cloud<br/>Timescale PostgreSQL + pgvector)]

        ToolTiger --> SanctuaryData[Matched Micro-Sanctuary]
        ToolOSM --> SanctuaryData

        SanctuaryData --> ToolMission[generateSensoryMissionTool]
        ToolMission --> FinalPackage[Restorative Guidance + Mission]
    end

    UI -->|Invokes POST /api/agent| Agent
    FinalPackage -->|Renders Recommendation in <1s| UI

    UI -->|Click 'Start Walk & Disconnect'| DisconnectMode[Fullscreen Lockout Timer]
    DisconnectMode -->|Web Audio API Oscillator| Chime[Tibetan Singing Bowl Zen Chime]
    DisconnectMode -->|User Pockets Phone| Nature([Touching Grass Outdoors 🍃])

    subgraph Trace & Versioning ["Entire CLI"]
        Entire[entire.yaml & CLI Checkpoints] -->|Records session traces| GitRefs[refs/entire/checkpoints]
    end

Core Code Snippets

1. Mastra Agent Definition with Anti-Screen System Prompt

Located in src/mastra/agents/sanctuaryAgent.ts:

import { Agent } from '@mastra/core/agent';
import { searchSanctuariesTool } from '../tools/searchSanctuaries';
import { generateSensoryMissionTool } from '../tools/sensoryMission';

export const VERDANT_AGENT_INSTRUCTIONS = `You are Verdant, an outdoor disconnect companion and micro-sanctuary guide.
Your mission is to cure screen fatigue and cognitive overload for software engineers and knowledge workers by recommending nearby peaceful nature spots within a 5-15 minute walk.

CRITICAL RULES:
1. Prioritize screen-time minimization above all else. The user must be looking at the screen for under 30 seconds.
2. Discover the top micro-sanctuary from live GPS locations or Tiger Data pgvector based on the user's mood, walking limit, and quiet needs.
3. Use generateSensoryMissionTool to generate a tactile, screen-free sensory mindfulness mission for the destination.
4. Keep all explanations grounded, restorative, concise, and devoid of screen distractions.
5. Emphasize activating Disconnect Mode, pocketing the phone, and stepping outside immediately.`;

export const verdantAgent = new Agent({
  id: 'verdantAgent',
  name: 'verdantAgent',
  instructions: VERDANT_AGENT_INSTRUCTIONS,
  model: 'google/gemini-2.5-flash',
  tools: {
    searchSanctuariesTool,
    generateSensoryMissionTool,
  },
});

2. Tiger Data `pgvector` Spatial Vector Tool

Located in src/mastra/tools/searchSanctuaries.ts and src/db/client.ts:

// Sub-millisecond cosine vector distance query in Tiger Data
export async function querySanctuariesVector(
  embedding: number[],
  maxWalkMins: number = 15,
  limit: number = 3
): Promise<SanctuaryRecord[]> {
  const pool = getPool();
  const vectorStr = `[${embedding.join(',')}]`;

  const query = `
    SELECT 
      id, name, category, neighborhood, latitude, longitude,
      estimated_walk_mins, shade_rating, quiet_rating,
      ambiance_description, sensory_features, best_for_moods,
      (embedding <=> $1::vector) AS distance
    FROM micro_sanctuaries
    WHERE estimated_walk_mins <= $2
    ORDER BY (embedding <=> $1::vector) ASC
    LIMIT $3;
  `;

  const res = await pool.query(query, [vectorStr, maxWalkMins, limit]);
  return res.rows;
}

3. Real-Time Tibetan Singing Bowl Synthesizer (Web Audio API)

Located in src/lib/audio.ts:

// Synthesizes a calming singing bowl sound with natural inharmonic overtones
export function playSingingBowlChime(fundamentalFreq = 216): void {
  const ctx = new (window.AudioContext || (window as any).webkitAudioContext)();
  const now = ctx.currentTime;
  const duration = 4.5;

  // Natural singing bowl overtone ratios: Fundamental, Octave + minor 3rd, 2nd Octave
  const harmonics = [
    { freqMult: 1.0, gain: 0.45 },
    { freqMult: 2.76, gain: 0.22 },
    { freqMult: 5.4, gain: 0.08 },
  ];

  harmonics.forEach(({ freqMult, gain }) => {
    const osc = ctx.createOscillator();
    const gainNode = ctx.createGain();

    osc.type = 'sine';
    osc.frequency.setValueAtTime(fundamentalFreq * freqMult, now);

    // Exponential decay curve replicating metal resonance
    gainNode.gain.setValueAtTime(gain, now);
    gainNode.gain.exponentialRampToValueAtTime(0.0001, now + duration);

    osc.connect(gainNode);
    gainNode.connect(ctx.destination);
    osc.start(now);
    osc.stop(now + duration);
  });
}

How I Built It

Verdant brings together modern open-source AI frameworks, cutting-edge cloud vector databases, and developer tracing tools:

1. Mastra Framework (`@mastra/core`)

I chose Mastra as my agent runtime because of its first-class TypeScript DX, modular tool definition system, and lightweight execution model.

Tool Architecture: Rather than monolithic prompt stuffing, I built two purpose-specific Mastra tools (searchSanctuariesTool and generateSensoryMissionTool).
Prompt Guardrails: Mastra enforces that the agent never writes long essays or asks conversational questions that keep the user interacting with the chat window. The agent is explicitly conditioned to terminate the screen interaction immediately.

2. Tiger Data (Timescale Cloud PostgreSQL + `pgvector`)

Vector search shouldn't require a dedicated, expensive proprietary vector database. Tiger Data gives me robust PostgreSQL reliability with the raw speed of pgvector:

Vector Schema: I stored 768-dimensional embeddings generated with text-embedding-004.
IVFFlat Vector Indexing: CREATE INDEX sanctuary_embedding_idx ON micro_sanctuaries USING ivfflat (embedding vector_cosine_ops) WITH (lists = 10);
Hybrid Querying: Tiger Data allows me to combine semantic cosine distance (<=>) with hard relational SQL predicates (WHERE estimated_walk_mins <= $2 AND quiet_rating >= 4) in a single query execution plan.
Graceful Fallback: If DATABASE_URL is omitted in offline test environments, Verdant seamlessly falls back to a fast in-memory cosine engine so the user experience never crashes.

3. OpenStreetMap & Photon Geocoding

To ensure Verdant works for anyone, anywhere in the world, I incorporated live GPS geocoding via OpenStreetMap. When a user clicks "Use Live GPS", Verdant queries open geospatial endpoints to identify nearby municipal parks, arboretums, and green squares within walking distance, embedding and ranking them on the fly.

4. Entire CLI (`entire`)

I integrated the Entire CLI (entire.yaml) to track checkpoints, autonomous commits, and session execution traces during development. With Entire enabled on my repository, all agent transitions, tool calibrations, and code modifications are versioned with transparent trace logs.

Why Does Open Innovation Matter?

The Hacktoberfest Week 1 challenge prompt asks: Why does open innovation matter for what you built? What did it make possible that a closed API wouldn't?

For a wellness and anti-screen application like Verdant, open innovation is not just an architectural choice—it is a moral necessity:

1. Personal Privacy Over Surveillance Capitalism

Your mental health status ("I am experiencing severe anxiety and sensory overload") and your real-time physical GPS coordinates are among the most sensitive personal data points that exist. In proprietary wellness platforms, this data is routinely logged, ingested into user advertising profiles, and monetized to sell products. With open-source AI and transparent database infrastructure like PostgreSQL, user data remains strictly private.

2. Open Spatial Infrastructure vs. Monetized Maps

Closed commercial mapping platforms prioritize sponsored pins, commercial businesses, and high-density vehicle routes. They are disincentivized to show you an unmonetized public bench under a willow tree. By building on OpenStreetMap data and self-hosted vector databases, Verdant treats quiet public micro-sanctuaries as fundamental human rights, not ad space.

3. Transparent AI Behavior

Closed conversational AI assistants are programmed to maximize session duration and daily active engagement (DAU). Their underlying models will deliberately prompt you with follow-up questions to keep you chatting. By utilizing Mastra and open agent tooling, I was able to program my agent with the exact opposite objective: minimize screen time to <30 seconds and send the user away.

4. Zero-Cost Offline Resilience

Because Verdant is open-source and includes offline in-memory vector fallbacks, you can run it on a laptop in airplane mode in the middle of a national park with no cell reception. It costs nothing to operate, requires no recurring SaaS subscriptions, and will remain functional forever.

My Agent Session

I utilized the Entire Checkpoints CLI throughout the development and testing of Verdant. All checkpoints, session snapshots, and autonomous agent executions are tracked within the repository.

You can inspect the Entire configuration in entire.yaml and review status directly via:

# Check Entire tracking status
entire status

# View recorded development checkpoints
entire checkpoints

Verified Entire Session Status

Here is my live session verification showing Entire CLI actively recording on branch master:

The session traces capture the iteration from initial schema design in Tiger Data to Mastra tool integration, Web Audio synthesis, and live GPS fallback integration.

Prize Categories

I am officially submitting Verdant for the following featured partner tracks:

🏆 Best Use of Tiger Data

Implementation: Powered by Tiger Data Cloud (Timescale PostgreSQL) with the pgvector extension enabled.
Technical Highlights:
- vector(768) columns storing dense semantic representations of urban nature ambiance, acoustic tranquility, and sensory features.
- Sub-millisecond cosine distance sorting ((embedding <=> $1::vector) ASC) combined with walking duration relational filters.
- IVFFlat vector index with optimized list buckets (sanctuary_embedding_idx).
- Automated database seeder (npm run db:seed) and connection pooling configured in src/db/client.ts.

🏆 Best Use of Mastra

Implementation: Powered by Mastra (@mastra/core v1.75).
Technical Highlights:
- Custom verdantAgent with strict system prompt conditioning that actively rejects screen-time prolongation and enforces the 30-Second Rule.
- Multi-tool orchestration combining searchSanctuariesTool (spatial vector retrieval) and generateSensoryMissionTool (tactile mindfulness synthesis).
- Clean TypeScript schema validation using Zod for all inputs and outputs.
- Integrated directly into Next.js 16 App Router API routes (src/app/api/agent/route.ts).

🏆 Best Use of Entire

Implementation: Integrated with Entire Checkpoints CLI via entire.yaml.
Technical Highlights:
- Full development checkpoints tracked on branch master.
- Captures development trajectory, agent execution logs, and reproducible environment configurations.

🧪 Live Partner & CLI Test Proof (Parts 1, 2, and 3)

Below is the complete terminal verification executing npm run agent:test and verifying all three partner tracks:

Verification Part 1: Mastra Agent Registration & Tiger Data Connection

Verification Part 2: Tiger Data Vector Distance Searches & Stress Scenarios

Verification Part 3: Live GPS OpenStreetMap Discovery & Offline Fallback

Summary: Step Outside

The greatest gift technology can give us is not more time looking at pixels—it is the freedom to look away from them.

Verdant is live, open-source, and waiting to help you take your next walk. Open it up, pick your mood, step away from your computer, and go touch grass. 🌿

WhichModel? — I Built a AI Arena for My Friend to Prove Open Models Can Beat Commercial APIs

Sapnil M — Mon, 05 Oct 2026 06:58:14 +0000

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

What I Built

Every week, my friend Abhi asks me the exact same question:

"Bro, which AI model should I actually use? Do I need to pay \$20/month for closed commercial APIs, or can an open-weight model actually keep up with my real work?"

Whenever we look at public AI leaderboards (MMLU, HumanEval, or Chatbot Arena), the answers feel disconnected from real life. Abhi and my wider circle of friends aren't sitting around evaluating standardized high-school math competitions or abstract trivia. In reality, they are:

Debugging real code: Fixing subtle CSS flexbox/grid overflows and asynchronous Python backend errors.
Drafting high-stakes outreach: Writing cold emails to tech CEOs and startup hiring managers for internship opportunities.
Studying for exams: Condensing dense university biology lectures (like the biochemistry of photosynthesis or WW2 timelines) into crisp study guides.
Translating regional languages: Converting everyday colloquial phrases between English and regional languages like Malayalam without sounding robotic.

The biggest obstacle wasn't the models—it was brand bias. When an answer carries a famous proprietary logo, people automatically convince themselves it is smarter. When it’s labeled "open model", people scrutinize it twice as hard.

To solve this for Abhi and our peer group, I built WhichModel?: an interactive, double-blind AI benchmark arena powered by their own daily prompts.

flowchart LR
    A[Friend Submits Real Prompts] --> B[Async Inference Queue]
    B --> C[NVIDIA NIM: Llama 3.2 11B]
    B --> D[Groq: Qwen 3.8 27B]
    B --> E[Groq: GPT-OSS 20B]
    B --> F[Google: Gemini 3.5 Flash Lite]
    C & D & E & F --> G[Randomized Double-Blind Evaluation]
    G --> H[Friend Votes on Merit Alone]
    H --> I[Animated Model Reveal & Latency Stats]
    I --> J[Personal Scorecard & Community Leaderboard]

How It Works:

Submit Real Tasks: Friends enter 5–15 prompts categorized by task type (coding, writing, study_help, summarizing, translation, other).
Blind Comparison: Candidate open-weight models and a closed comparison baseline generate answers in the background. Prompts are rendered as anonymous cards (Answer A, Answer B, Answer C) with all identities, metadata, and token traces stripped.
The Reveal: Friends pick the best answer strictly on merit (or select "None are good"). Only after voting are the model identities, license types, response latencies, and token counts revealed.
Personalized Guidance: The /results/me dashboard gives each friend a custom verdict: "For coding, use Model X; for summaries, use Model Y", backed by empirical win-rate statistics.

Demo

🌐 Live Web Application: https://whichmodel.onrender.com/
📊 Live Community Leaderboard: https://whichmodel.onrender.com/results
🔍 Explore Public Prompts & Verified Answers: https://whichmodel.onrender.com/explore

The User Journey:

Invite-Gated Welcome: Visitors sign in using an access code (e.g., friends2026), choose a display name, and consent to AI processing terms.
Prompt Authoring: Form validation ensures prompts are between 5 and 15 items with category tags. A handy "Fill sample prompts" quick-button lets first-time testers jump in immediately.

Figure 1: Friends submit real-world prompts categorized across coding, writing, and study domains.

Double-Blind Card Arena: Side-by-side card layout with copy-to-clipboard buttons, syntax-highlighted code blocks, and zero brand leakage in network payloads.

The Model Reveal: Immediately after voting, the cards flip to expose the winning model, license, latency, and token metrics.

(Optional Screenshot 3: Model Reveal Card showing latency and token counts)

Instant Scorecards & Community Leaderboard: Pairwise win-rate calculation with sample-size warnings ($n < 10$) and the live open vs. closed showdown.

Code

The complete source code is public and open-source under the MIT license:

SAPNIL-M / WhichModel

WhichModel?

Ask your friends. Let the models compete. Find your best AI.

WhichModel? is a small, invite-only benchmark for answering a very practical question:

Which AI model works best for the things I actually do?

Instead of trusting generic leaderboards, people submit their own prompts, compare anonymous answers from several models, and vote for the answer they like best. The app then turns those votes into personal insights and a shared leaderboard.

It is built for friends, classmates, teammates, and anyone who wants a useful answer instead of another hype-filled model ranking.

The idea in one minute

Enter an invite code.
Add 5–15 prompts you really use for coding, writing, studying, summaries, translation, or anything else.
Wait while the models answer in the background.
Compare anonymous answers labelled A, B, C, and D.
Pick the best answer — or say None are good.
See which…

View on GitHub

GitHub Repository: SAPNIL-M/WhichModel
Tech Stack: Python 3.11+, FastAPI, Uvicorn, PostgreSQL (via SQLModel / SQLAlchemy), Jinja2, Vanilla JavaScript (0 heavy npm dependencies), and Bleach for XSS sanitization.
Test Suite: 18 automated tests passing in CI covering providers, async queues, double-blind security, and GDPR-style data deletion.

How I Built It

1. The Open-Source AI Matrix

WhichModel? is architected around accessible open-weight models, contrasted against a single commercial baseline:

Model	Kind	Host Provider	License Category	Role in Benchmark
Llama 3.2 11B Vision Instruct	OpenAI-compatible	NVIDIA NIM	Custom Open-Weights (Meta Community)	Open Candidate
Qwen 3.8 27B	OpenAI-compatible	Groq	Custom Open-Weights (Qwen Research)	Open Candidate
GPT-OSS 20B	OpenAI-compatible	Groq	Permissive Open-Source (Apache 2.0)	Open Candidate
Gemini 3.5 Flash Lite	Gemini REST API	Google	Proprietary Closed	Comparison Baseline

All models are defined declaratively in config/models.yaml. Swapping an endpoint or plugging in a local Ollama model takes four lines of YAML with zero code changes:

generation:
  temperature: 0.3
  max_tokens: 800
  system_prompt: "Answer helpfully and concisely."

models:
  - id: gpt-oss-20b
    display_name: GPT OSS 20B
    kind: openai_compatible
    base_url: https://api.groq.com/openai/v1
    api_key_env: GROQ_API_KEY
    provider_model_id: openai/gpt-oss-20b
    is_open: true
    license_type: permissive
    license_note: Apache 2.0
    live_enabled: true
    rpm: 6

💡 An Honest Note on Resource Constraints & Model Selection:

Let's be completely transparent: there are even larger, highly perfected open-source and open-weight models in the ecosystem today (such as 70B+ parameter checkpoints, specialized reasoning models, and massive community fine-tunes). However, as an independent developer without cloud grant funding, venture sponsorship, or high-end GPU clusters to inference those massive models, I utilized the best accessible models I could get my hands on via developer-tier and free inference APIs (NVIDIA NIM and Groq).

The fact that these lightweight, sub-30B models (like GPT-OSS 20B and Qwen 27B) still went toe-to-toe with a commercial closed model proves the point even more strongly: if lightweight open models can already win 53.3% of real-world matchups, benchmarking with larger, perfected frontier open models will yield even more commanding results in favor of open source.

(Small tidbit: If anyone, an inference platform, or a compute provider would like to offer access to more powerful models or infrastructure for hosting larger open frontier models, I am more than open to collaborating! Drop a comment or reach out—let's expand the arena!)

2. Double-Blind Data Integrity

To guarantee absolute double-blind evaluation, the backend enforces strict data sanitization:

The /api/next endpoint completely strips model_id, provider names, and latency metrics before sending answers to the browser.
Inspecting browser developer tools or DOM elements reveals only randomized UUIDs.
Model outputs are safely rendered through markdown and sanitized with bleach to prevent XSS injection from untrusted model generations.

# Server-side scrubbing: never leak model metadata before voting
@router.get("/api/next")
def get_next_prompt_for_picking(session_id: str, db: Session = Depends(get_db)):
    prompt, answers = select_next_unpicked_prompt(db, session_id)
    random.shuffle(answers) # Randomize card positions
    return {
        "prompt_id": prompt.id,
        "category": prompt.category,
        "prompt_text": prompt.text,
        "answers": [
            {"answer_id": a.id, "text_html": render_safe_markdown(a.text)}
            for a in answers
        ] # model_id, tokens, and latency are intentionally excluded!
    }

3. Fault-Tolerant Async Inference Queue

An in-process asyncio worker queries candidate models concurrently, enforcing per-provider rate limits (NIM: 3 concurrent requests, Groq: 2, Gemini: 2) with exponential backoff on HTTP 429.
Job states (queued, running, done, failed) are stored in PostgreSQL. If the cloud container restarts or wakes from sleep, pending jobs are immediately resumed without losing user input.

4. Pairwise Statistical Modeling

Each evaluation treats the user's chosen answer as winning head-to-head against every unchosen answer in that round.
Small sample indicators ($n < 10$) notify friends when data is preliminary.
Self-service "Delete my data" removes personal prompts and recalculates leaderboard aggregates in real time.

Why Does Open Innovation Matter?

Running this benchmark with real friend-submitted prompts produced surprising, empirical discoveries that debunked common assumptions about closed vs. open AI:

🏆 Empirical Benchmark Scoreboard (Live Results from `/results.json`):

Model	Open / Closed	License	Overall Win Rate	Coding ($n$)	Writing ($n$)	Study ($n$)	Summary ($n$)	Translation ($n$)	Median Latency
GPT-OSS 20B	Open	Apache 2.0	60.0%	75% ($4$)	50% ($4$)	33% ($3$)	60% ($5$)	75% ($4$)	1005 ms
Gemini 3.5 Flash Lite	Closed	Proprietary	66.7%	50% ($4$)	60% ($5$)	86% ($7$)	33% ($3$)	80% ($5$)	1992 ms
Qwen 3.8 27B	Open	Research	23.1%	0% ($2$)	0% ($3$)	0% ($2$)	75% ($4$)	0% ($2$)	766 ms
Llama 3.2 11B Vision	Open	Meta Comm.	27.3%	N/A	75% ($4$)	0% ($2$)	0% ($2$)	0% ($3$)	7448 ms

💡 Key Takeaway: Open-weight models won 8 out of 15 head-to-head showdowns (53.3% win rate) against the commercial closed baseline!

What This Taught Us About Open Innovation:

Open Models Beat Closed APIs on Developer Workloads: In coding tasks, GPT-OSS 20B won 75% of matchups, beating Gemini 3.5 Flash Lite. Abhi noticed that the open model gave direct, working code with minimal unnecessary fluff, whereas the closed model over-explained basic concepts.
Specialized Excellence Over Generic Monoliths: Qwen 3.8 27B was the undisputed speed champion (a blazing 766 ms median latency) and dominated summarization with a 75% win rate. For high-speed reading, friends preferred Qwen over larger closed models.
No Subscription Anxiety & Zero Vendor Lock-in: You can run these exact weights on your own machine using Ollama or vLLM. You aren't subject to unexpected pricing hikes, policy shifts, or API deprecations.
Honest License Awareness: We deliberately differentiated between true permissive open-source (Apache 2.0) and community open-weights (Llama Community, Qwen Research). Educating users about these distinctions ensures teams know their true commercial rights.

Prize Categories

🌟 Best Use of Render

WhichModel? was built, configured, and deployed natively on Render using an Infrastructure-as-Code Blueprint (render.yaml):

services:
  - type: web
    name: whichmodel
    runtime: python
    plan: free
    region: singapore
    numInstances: 1 # In-process worker requires single-node concurrency
    buildCommand: pip install -r requirements.txt
    startCommand: uvicorn app.main:app --host 0.0.0.0 --port $PORT --proxy-headers --forwarded-allow-ips='*'
    healthCheckPath: /health
    envVars:
      - key: DATABASE_URL
        fromDatabase:
          name: whichmodel-db
          property: connectionString
      - key: SESSION_SECRET
        generateValue: true
      - key: DAILY_CALL_CAP
        value: "600"

databases:
  - name: whichmodel-db
    databaseName: whichmodel
    user: whichmodel
    plan: free
    region: singapore
    ipAllowList: [] # Private network isolation: accessible only by the web service

Why Render Was Essential to This Architecture:

Zero-Friction Infrastructure as Code: The entire environment—FastAPI app, environment secrets, and isolated PostgreSQL database—spins up reproducibly from a single declarative YAML file.
Handling Free-Tier Spin-Downs with Grace: Free cloud instances spin down after 15 minutes of idle time. WhichModel?'s worker architecture was engineered specifically for this: client-side polling keeps the instance awake while a friend is actively evaluating prompts, and if a cold-start does occur, the FastAPI startup hook immediately audits PostgreSQL and resumes any pending jobs without dropping a single submission.
Secure Isolated Database Network: The database uses ipAllowList: [], ensuring it is only reachable internally by our Render web service, preventing external database exposure.

🤖 Best Use of GitHub Copilot

GitHub Copilot (CLI & Agent) was an essential pair programmer throughout this rapid weekend sprint:

Foundational Scaffolding via Copilot CLI: Used GitHub Copilot CLI to accelerate Phase 1 architecture, generating boilerplate for the decoupled provider interfaces (app/providers/openai_compat.py and gemini.py) to normalize disparate vendor response schemas into a unified contract.
Comprehensive Test Suite Generation: Copilot helped write and parameterize the 18 automated tests in tests/, rapidly authoring mocked HTTP fixtures for provider retries (429 rate-limiting with exponential backoff), double-blind election fairness, and markdown sanitization.
GitHub Actions CI/CD Pipeline: Paired with GitHub Actions (.github/workflows/ci.yml) to automatically execute test suites on pull requests, ensuring continuous verification before code was merged and deployed live.

My Agent Session

This project was built pair-programming with Antigravity and GitHub Copilot CLI throughout the Hacktoberfest weekend:

Architectural Scaffolding: Implementing the decoupled provider abstraction (app/providers/base.py, openai_compat.py, gemini.py) and setting up comprehensive unit tests with mocked HTTP responses.
Frontend & UX Polish: Developing the responsive styling, card reveal animations, and safe markdown rendering pipeline.
Async Concurrency Tuning: Solving queue contention across disparate model rate limits and ensuring smooth recovery on cold boots.

All 18 tests pass cleanly, ensuring strict data privacy, election fairness, and resilience against external API hiccups.

What My Friend Said When They Used It

When I gave the link to Abhi to test on his own real coding and writing prompts:

"I was convinced Answer A on my Python script prompt was gemini because the syntax was concise and it didn't lecture me. When the card flipped and revealed it was GPT-OSS 20B running on open weights, I was shocked. I don't need to pay for closed API keys for my daily coding tasks anymore—I'm running this locally tonight."

Thank you to the DEV team, GitHub, and Render for hosting this Hacktoberfest Challenge! Check out WhichModel? and test your own prompts against open AI.

DEV Community: Sapnil M

SPECTER: The Ghost in the Browser (100% Offline, In-Browser Haunted CRT Terminal)

What I Built

Key Features:

Demo

Code

SAPNIL-M / SPECTER

👻 SPECTER: The Ghost in the Browser

🌟 Key Highlights

How I Built It

1. In-Browser Neural Pipeline

2. Procedural Audio (Web Audio API)

3. The Debugging Challenge: When the Model Confused "Lonely" for "Hostile"

Why Does Open Innovation Matter?

The Spirit of It

Prize Categories

SlothPace 🦥: Taming Chaotic Morning Brain Dumps with 100% Offline Open-Source AI

What I Built

Demo

1. Morning Brain Dump Portal

2. The Paced Schedule & Sloth Branch Progress

3. Decomposed Micro-Steps & Panic-Free Buffers

4. Gentle Deadline Focus Companion

Code

SAPNIL-M / Slothpace

🦥 SlothPace — The "Slow & Steady" Daily Task Decomposer & Gentle Deadline Pacer

📖 The Story & Hacktoberfest 2026 Theme: "Slow and Steady"

⚡ The Problem: Executive Function Fatigue & Deadline Paralysis

How I Built It

Why Does Open Innovation Matter?

The Lazy Payoff

Prize Categories

PaperToProfit: Turning Handwritten Dhaba Bills into Revenue & Profit Intelligence with Open-Source AI and TabPFN

🍽️ What I Built

The Problem

The Side Hustle

🎥 Demo

Video Walkthrough

Visual Walkthrough

1. Instant Bill Digitization & 1-Tap Review Screen

2. Live Financial Dashboard & Rush Heatmap

3. Menu Engineering BCG Matrix

4. TabPFN Predictive Sales AI & Anomaly Detection

5. Scanned Bills Revenue Ledger

💻 Code

Core Architecture

🛠️ How I Built It

1. The Vision AI & Extraction Engine

2. Predictive Sales Intelligence with TabPFN (Prior Labs)

3. Lightweight Full-Stack (FastAPI + SQLite + Vanilla JS)

🔓 Why Does Open Innovation Matter?

1. The Zero-Marginal-Cost Advantage

2. Complete Financial Privacy & Trust

3. Tolerance for Regional Dialects & Culinary Slang

👥 My First User

The Test with Real Bills:

Testing & Feedback:

🏆 Prize Categories

🏁 Conclusion

Verdant 🌿: The Anti-Screen Agent

What I Built

The Digital Fatigue Crisis

Verdant's Core Philosophy: The 30-Second Rule

Key Features

Demo

📹 Video Walkthrough

Local Setup & Live Experience

Visual Walkthrough

1. Instant 3-Second Mood & GPS Input

2. Sub-Second Sanctuary Match

3. Screen-Free Tactile Sensory Protocol

4. Disconnect Mode: Fullscreen Lockout

Taking Verdant on a Real-World Walk

Code

Architecture Diagram

Core Code Snippets

1. Mastra Agent Definition with Anti-Screen System Prompt

2. Tiger Data pgvector Spatial Vector Tool

3. Real-Time Tibetan Singing Bowl Synthesizer (Web Audio API)

How I Built It

2. Tiger Data `pgvector` Spatial Vector Tool

1. Mastra Framework (`@mastra/core`)

2. Tiger Data (Timescale Cloud PostgreSQL + `pgvector`)

4. Entire CLI (`entire`)

🏆 Empirical Benchmark Scoreboard (Live Results from `/results.json`):