DEV Community: Pankaj Garg

How I Built UNREACHABLE: The Emergency Route Intelligence Platform Cities Will Pay For

Pankaj Garg — Sun, 25 Oct 2026 19:15:15 +0000

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

What I Built

Commercial navigation platforms (Google Maps, Waze, Apple Maps) answer only one question: "What is the fastest route for an ordinary passenger car?"

In an emergency, this assumption is dangerous and often fatal. In dense urban quarters, historic wards, and rapidly growing urban fringes across India and the developing world:

A 16-tonne Type 1 Fire Tender (requiring $\ge 3.5\text{m}$ clearance) gets physically wedged in 2.2m-wide gullies or snagged by low-hanging electrical wire bundles.
An ALS Ambulance (requiring $\ge 3.0\text{m}$) meets unmapped bollards, narrow gate curfews, or construction trenches.
Up to 70% of municipal GIS and OpenStreetMap records lack road width tags (width=null), leading conventional mapping apps to assume roads are passable simply because a centerline vector exists.

UNREACHABLE is a deterministic emergency accessibility intelligence platform and side-hustle micro-SaaS built for municipal corporations, emergency dispatch centers (112/101/108), urban planning consultancies, and private industrial complexes.

The Side Hustle Product & Who Pays For It:

Municipal Urban Councils & Smart City Missions ($2,500 – $10,000 / ward audit):
- Uses the platform's Single Point of Failure (SPOF) Sensitivity Engine to rank choke points and identify which single road bottlenecks cut off the most homes.
- Generates automated Field Audit Work Orders (.csv export & print-ready clipboard checklists) prioritizing which unmeasured roads surveyors must measure first.
Emergency Dispatch Operations & Fire Brigades ($499 / station / month):
- Evaluates apparatus clearance across 3 emergency vehicle profiles before dispatch.
- Live route recalculation with dynamic in-memory incident obstruction overlays and Server-Sent Events (SSE) telemetry.
Simulation Bench for Capital Works:
- Urban engineers toggle hypothetical street interventions (e.g. wire bundle clearing, bollard removal) to preview the exact number of buildings "rescued" before committing municipal budget.

Demo

Video Walkthrough Demo: Watch the Video Demo on Google Drive
Local / Single-Command Interactive Console: Can be run locally via scripts/start_demo.sh or in dual mode (demo synthetic campus vs real 497-facility Punjab regional dataset).

Code

Garg-Pankaj29 / UNREACHABLE

AI-powered emergency accessibility mapping that identifies unreachable buildings, detects road bottlenecks, and helps emergency services plan feasible routes and prioritize safety improvements.

UNREACHABLE

An AI-powered, deterministic emergency accessibility intelligence platform designed for dense urban environments and Indian cities. Evaluates physical road geometry, bottleneck pinch-points, overhead utility wire bundles, and apparatus clearances before an emergency unfolds.

Concept

In dense urban environments—from historic core wards in Indian cities to rapidly densifying metropolitan settlements—emergency response times are frequently defeated not by highway traffic, but by the "last 500 meters":

Narrow residential gullies under 2.5 meters wide where heavy fire water tenders become physically wedged.
Low-hanging overhead electrical and telecommunication wire bundles snagging apparatus ladders.
Unmapped bollards, gate curfews, street market encroachments, and construction trenches.
Municipal GIS datasets that mark a building as "reachable" simply because a centerline road vector exists in OpenStreetMap or cadastre records.

UNREACHABLE changes how cities prepare for emergencies:

"Know the access. Find the constraint. Fix it before an emergency."

UNREACHABLE runs on local loopback (127.0.0.1). It ingests road corridor…

View on GitHub

Repository: https://github.com/Garg-Pankaj29/UNREACHABLE
Stack:
- Backend: Python 3.10+, FastAPI, Pydantic v2, SQLite spatial indexing, Server-Sent Events (SSE).
- Frontend: React 18, TypeScript 5, Vite, Tailwind CSS 3.4, Leaflet 1.9 vector mapping, Lucide Icons.
- AI / LLM: Local inference via LM Studio running open-weight Gemma 3 4B (OpenAI-compatible local endpoint).

How I Built It

1. The Core Architectural Philosophy: Deterministic Physics Decides, AI Explains

In life-safety systems, probabilistic AI models must never make access or routing decisions. An LLM hallucinating that a 3.8-meter-wide fire truck can squeeze through a 2.1-meter alley can cost lives.

UNREACHABLE enforces an unshakeable boundary:

Routing & Feasibility are 100% Deterministic Python: Pure graph theory via a custom Modified Penalty Dijkstra algorithm, Great-Circle Haversine calculations, and vehicle clearance metrics evaluate whether an apparatus fits.
Open-Source AI (Gemma 3 4B): Translates complex mathematical routes, bottleneck IDs, clearance margins, and penalty scores into concise, plain-language tactical briefings for dispatchers and incident commanders.
Automated Numeric & Fact Guardrail Verifier: Before any AI-generated explanation reaches the user, it is intercepted and audited by ExplainService._validate_llm_response(). It cross-checks all extracted numbers against mathematical ground truth. If the model hallucinates a number or alters road IDs, the response is instantly rejected and safely served by a pre-validated deterministic template.

2. Dual Dataset Architecture

Synthetic Demo Mode (data/sample/): High-fidelity model of Chandigarh University (CU) Gharuan campus & surrounding rural-urban fringe (NH-05, Punjab) for instant testing.
Real Pilot Mode (data/real/): Full OpenStreetMap ingestion covering all 23 districts of Punjab & Chandigarh, indexing 497 emergency facilities (fire hubs, trauma centers, dispensaries) and over 41,300 road centerlines with 453,812 graph edges.

3. Dynamic In-Memory Obstructions & Real-Time SSE

When a road is blocked during an incident, an in-memory obstruction overlay updates the active graph without touching disk files.
Real-time Server-Sent Events (/api/stream) broadcast unit coordinates and dynamic detours to connected dispatchers with sub-second latency.

Why Does Open Innovation Matter?

Air-Gapped Disaster Resilience: During catastrophic monsoons, floods, or network blackouts, cloud APIs like proprietary closed models become unreachable. Open-source AI (Gemma 3 4B running locally via LM Studio or Ollama) enables the entire system to run 100% locally on an air-gapped laptop on 127.0.0.1 with zero external cloud dependencies.
Sovereignty over Sensitive Spatial Infrastructure: Municipalities, military bases, and fire brigades cannot leak security footprints, gate curfews, or road vulnerability data to closed third-party cloud servers. Open innovation keeps sensitive data local and private.
No Per-Token API Costs for Municipalities: Budget-constrained civic bodies cannot afford unpredictably billed proprietary tokens for 24/7 emergency dispatch engines. Open-weight models democratize emergency intelligence for developing cities.

My Agent Session

Developed and tested with local agentic pair-programming workflows, ensuring strict separation between deterministic routing physics and open-source generative briefings.

My First User

During development and field validation around the Kharar and Gharuan urban fringes (Punjab), we piloted the spatial engine against real-world choke points:

User Profile: A local logistics and private security coordinator managing transport access around high-density housing sectors and university feeder corridors.
Feedback: "Standard GPS constantly routed our supply trucks down internal village link roads where low electrical wiring and open drains forced drivers to reverse hundreds of meters. UNREACHABLE's clearance classification instantly exposed the two narrow pinch points responsible for 90% of our access blocks."
Outcome: Validated the commercial value of the Intervention Directory and the Field Audit Work Order export, proving civic administrators and private enclaves are willing to pay for bottleneck remediation reports.

Prize Categories

Open-Source AI Challenge Week 2: Side Hustle
Sponsor Tracks / Open Innovation Track (Deployable, Local-first Open-Weight AI with Strict Guardrails)

LedgerLeaf: Turn Messy Receipts into Structured Records with Local AI

Pankaj Garg — Sat, 17 Oct 2026 16:36:28 +0000

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

What I Built
LedgerLeaf is a private, local-first financial paperwork assistant designed for freelancers, independent contractors, and small business owners who drown in disorganized receipts and invoices each tax season.

Instead of sending confidential financial records, bank details, and client invoices to third-party cloud extraction APIs or paying recurring monthly subscription fees for SaaS document processors, LedgerLeaf performs end-to-end receipt extraction on your own device. It combines local open-weight vision/language models (via LM Studio or Ollama) with deterministic math verification guards. Every single extracted number visually highlights back to the exact source snippet on the uploaded invoice, and nothing enters your persistent ledger without your explicit human approval.

Demo
LedgerLeaf runs locally on your machine with a leaf-inspired interactive review bench:

Interactive Interface: Dual-pane review workspace with live source-text pinning, field corrections, and duplicate detection.
Review Bench in Action:
Drop in receipts or invoices (.pdf, .png, .jpg, .webp, .txt).
The local open-weight model parses vendor, invoice number, date, currency, subtotal, tax, and total.
Deterministic guards verify subtotal + tax == total. Any mismatch or unverified field is flagged for quick correction.
One click commits verified records to a local SQLite database and exports clean, multi-currency RFC 4180 CSVs.
(To add your video demonstration here: paste your YouTube, Loom, or MP4 link directly below without extra spacing)

Garg-Pankaj29 / LedgerLeaf

LedgerLeaf is a private, local-first financial assistant that turns receipts and invoices into structured records using open-weight AI on your machine. Featuring source provenance, deterministic math guards, and human approval before committing to your SQLite ledger—zero cloud dependencies.

LedgerLeaf — Your finances. Your files. Your AI.

LedgerLeaf is a local-first, privacy-respecting financial document processing application that turns receipts, invoices, and paperwork into structured accounting records on your own machine. Every number points directly back to the line it came from in the original document, and nothing enters your approved ledger until you explicitly review and verify it.

1. Core Principles & Philosophy

Local-First & Private by Default: All text extraction, OCR, database storage, and AI inference run locally on 127.0.0.1. Uploaded files are stored in data/uploads/ outside the web directory. Documents never leave your computer unless you explicitly export CSV data or configure an external integration.
Deterministic Arithmetic Guards: Local models can misread numbers or make arithmetic mistakes. The AI model proposes structured values; deterministic validation rules cross-check math (subtotal + tax == total), dates, and required fields; and a human approves before anything enters…

View on GitHub

Code
The entire codebase is open-source under the MIT License:

Garg-Pankaj29 / LedgerLeaf

LedgerLeaf is a private, local-first financial assistant that turns receipts and invoices into structured records using open-weight AI on your machine. Featuring source provenance, deterministic math guards, and human approval before committing to your SQLite ledger—zero cloud dependencies.

LedgerLeaf — Your finances. Your files. Your AI.

1. Core Principles & Philosophy

Local-First & Private by Default: All text extraction, OCR, database storage, and AI inference run locally on 127.0.0.1. Uploaded files are stored in data/uploads/ outside the web directory. Documents never leave your computer unless you explicitly export CSV data or configure an external integration.
Deterministic Arithmetic Guards: Local models can misread numbers or make arithmetic mistakes. The AI model proposes structured values; deterministic validation rules cross-check math (subtotal + tax == total), dates, and required fields; and a human approves before anything enters…

View on GitHub

Tech Stack:

Backend: Python, FastAPI, SQLAlchemy, SQLite, Pydantic v2, PyMuPDF, Tesseract OCR.
Frontend: Vanilla modern JavaScript (ES modules), CSS custom property design system, and HTML5 Canvas.
Local AI Runtime: OpenAI-compatible local inference endpoints (LM Studio / Ollama).
How I Built It
LedgerLeaf is engineered around local-first principles to keep financial documents bounded strictly to 127.0.0.1:

Storage & Extraction Pipeline: Uploaded receipts are validated with MIME/magic-byte checks and hashed via SHA-256 for collision prevention. PyMuPDF extracts text streams, falling back to local OCR for scanned imagery.
Local Open-Weight Inference: The extracted raw text is fed to a locally hosted open-weight LLM (e.g., llama-3.2-1b-instruct or gemma-3-4b) through a local LM Studio server. The prompt enforces a strict JSON schema with field-level confidence ratings and character offsets.
Deterministic Math Guardrails: Small open-weight models can occasionally misread grainy receipt photos or hallucinate digits. LedgerLeaf protects against model drift by passing all outputs through deterministic mathematical validators (abs(subtotal + tax - total) < 0.01). If arithmetic fails or fields are missing, the UI raises visual warning chips.
Source Provenance: Every field maps directly back to the character range where it originated, allowing users to click any number and highlight its source on the original invoice.
Why Does Open Innovation Matter?
Financial documents contain sensitive metadata: personal addresses, tax IDs, client names, banking coordinates, and spending patterns. Closed-source, cloud-only AI APIs force solo operators to either risk their privacy or manually enter every single receipt line by line.

Open innovation and open-weight models flip this trade-off:

True Zero-Data-Leakage: Financial data never crosses the network perimeter or trains external foundation models.
Zero Per-Token or Subscription Costs: Freelancers can run high-volume processing without incurring metered API bills or surprise vendor rate hikes.
Longevity & Independence: Because the app, models, database, and inference harness run completely on-device, the tool will continue working indefinitely without depending on external vendor uptime.
Prize Categories
Open-Source AI Challenge Week 2: Side Hustle
Local & Edge AI

Paperwalk: An AI That Designs Your Walk, Then Gets Out of the Way 🌿

Pankaj Garg — Wed, 07 Oct 2026 06:09:30 +0000

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

Paperwalk: An AI That Designs Your Walk, Then Gets Out of the Way 🌿

What I Built

Paperwalk is a walking experience designed by AI — but experienced away from the screen.

The idea is simple:

Instead of using AI to keep us staring at another screen, what if AI prepared something for us to take into the real world?

With Paperwalk, you choose a duration, environment, and optional goal. Local AI then creates a printable one-page walking card with observation prompts, small activities, questions, and a drawing prompt.

You print the card, leave your phone behind, and go for the walk.

When you come back, you can photograph your completed card and upload it to Paperwalk. Local Gemma vision interprets what you noticed and uses those observations to generate a new, adapted walking card.

The loop is:

Choose → Generate → Print → Walk → Observe → Return → Upload → Adapt

The screen is intentionally the shortest part of the experience.

Paperwalk is for anyone who wants a little structure and curiosity during a walk without turning the walk itself into another screen-based activity.

The core idea is:

AI designs the experience. Then it gets out of the way.

Demo

🎥 Video Demo

paperwalk_demo.mp4 - Google Drive

drive.google.com

The demo is a visual walkthrough of Paperwalk's core flow:

Home → Card #1 → I'm Back → Local AI interpretation → Adapted Card #2

The shown completed walking card is a sample input used to demonstrate the adaptation flow.

Screenshots

The application includes:

A simple setup screen for creating a walk
A printable A4 walking card
A dedicated "I'm Back" flow for uploading the completed card
Local AI interpretation
A personalized second walking card

Code

GitHub repository:

Garg-Pankaj29 / Paperwalk

Use this: “An offline-first AI walking experience that turns local observations into personalized printable walk cards.”

Paperwalk

A local-first outdoor experience generator. Local open-weight AI creates a printable physical walking card, you leave your phone behind, walk outside, and return with a handwritten card that adapts your next journey.

Concept

Most modern AI products center the screen: they keep users typing, chatting, and scrolling. Paperwalk inverts this relationship:

"AI designs the experience, then gets out of the way."

A user opens Paperwalk on a laptop, sets how much time they have (20, 40, or 60 minutes), selects an environment (Park, Campus, or Neighborhood), and optionally inputs a personal goal.

A local Gemma model generates a tailored, one-page field card rendered directly as a printable A4 sheet. The user prints the card, leaves their phone at home, and heads outdoors with only a pen.

While walking, the user records physical observations, sketches a small discovery, circles sensory reflections, and notes future intentions. Upon returning, they upload a…

View on GitHub

The project is open source and contains the complete application, prompts, local AI integration, fallback logic, and setup instructions.

How I Built It

Paperwalk is built around Google's open-weight Gemma model, running locally through LM Studio.

Stack

Python
FastAPI
Jinja2
HTML/CSS/JavaScript
Pydantic
HTTPX
LM Studio
Google Gemma 3 4B
Local JSON state storage

There is no cloud AI API in the core experience.

Card #1 — Generate a Walk

The user provides a few simple inputs such as:

Duration
Environment
Optional goal

Those inputs are sent to the local Gemma model with a structured prompt.

Gemma returns structured JSON containing the walking mission, observation questions, drawing prompt, reflection prompt, and other activities.

Pydantic validates the response before it becomes a printable card.

The Physical Part

The generated card is designed as an A4 printable sheet.

The user takes the card outside, puts the phone away, and uses the physical sheet to record what they notice.

This is an important part of the design.

Paperwalk isn't trying to make the outdoor experience more interactive on a screen.

It is trying to make the screen unnecessary.

Card #2 — AI Learns From the Walk

After returning, the user photographs their completed card and uploads it.

The image is sent to the local Gemma vision model.

Gemma extracts structured observations such as:

What the person noticed
What surprised them
What they almost missed
What they drew
Their reflection
Possible interests or preferences

Those observations are then passed into another prompt that generates the next walking card.

So Card #2 isn't just another random activity.

It is based on what happened during the previous walk.

For example, if someone notices walls, cracks, textures, plants, or small details during their first walk, the next card can shift the activity toward those observations.

Local-First Architecture

The basic architecture is intentionally small:


text
              ┌──────────────────┐
              │   Paperwalk UI   │
              └────────┬─────────┘
                       │
                       ▼
              ┌──────────────────┐
              │     FastAPI      │
              └────────┬─────────┘
                       │
             ┌─────────┴─────────┐
             ▼                   ▼
      ┌─────────────┐     ┌─────────────┐
      │ Card Prompt │     │ Vision Prompt│
      └──────┬──────┘     └──────┬──────┘
             │                   │
             └─────────┬─────────┘
                       ▼
                ┌─────────────┐
                │ Local Gemma │
                │  via LM     │
                │   Studio    │
                └──────┬──────┘
                       │
                       ▼
              ┌──────────────────┐
              │ Adapted Card #2  │
              └──────────────────┘

ROGVEDA: Building an Offline-First, Privacy-Preserving Molecular Research Platform for a Friend

Pankaj Garg — Sun, 04 Oct 2026 18:30:00 +0000

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

What I Built

I built ROGVEDA for my friend Rohan, a graduate student researching medicinal chemistry and natural product drug leads.

Rohan was facing a painful dilemma common to academic and early-stage drug discovery researchers:

The Cloud Privacy Trap: He develops novel, patent-pending small molecules. Under institutional IP rules and non-disclosure agreements, he cannot upload unpublished chemical structures to closed cloud AI services without risking intellectual property leakage and patent forfeiture.
Workflow Fragmentation: To evaluate a single candidate molecule, he was jumping between several disconnected tools: a 2D drawing utility, desktop software for logP and polar surface area calculation, online servers for toxicity prediction, and manual spreadsheets to record modifications.

I built ROGVEDA to give Rohan a unified, 100% offline-first computational drug discovery workbench that runs entirely on his local machine. With ROGVEDA, he can:

Sketch 2D molecular structures or paste SMILES strings.
Compute 17+ deterministic physicochemical properties such as molecular weight, logP, TPSA, Lipinski Rule of 5 violations, and synthetic accessibility scores.
Run calibrated machine learning models across 6 bioactivity and safety targets including hERG cardiotoxicity, Tox21 mitochondrial toxicity, anti-inflammatory, anti-microbial, anti-cancer, and anti-oxidant potential.
Perform high-throughput batch screening on CSV libraries of up to 500 molecules with hardware-aware battery pacing.
Receive contextual biochemical trade-off insights powered by a locally hosted, open-weight language model without a single byte of chemical data leaving his device.

When I handed the working build over to Rohan, his feedback was direct:

"Being able to screen a series of newly designed derivatives right on my laptop in seconds—without worrying about confidentiality or cloud rate limits—cuts days of tedious manual lookups down to minutes."

Demo

Garg-Pankaj29 / Rogveda

ROGVEDA is an offline, AI-assisted molecular research sandbox that unifies structure analysis, ML property predictions, and local AI interpretation into a single workspace. Its core innovation is an iterative "Modify → Recalculate → Compare" loop for rapid, private compound design.

ROGVEDA

In-Silico Molecular Intelligence & Drug Discovery Screening Platform
One molecule. One workspace. One reproducible research loop.

1. Project Overview

ROGVEDA is an offline-first, privacy-preserving computational chemistry and early-stage drug discovery workbench.

The Problem It Solves

Early-stage medicinal chemistry and drug discovery workflows are heavily fragmented. Researchers, students, and small academic laboratories frequently juggle disconnected utilities:

Standalone drawing apps for 2D chemical sketching.
Cloud web servers for calculating molecular descriptors.
Cloud APIs for bioactivity and toxicity estimations.
External databases for similarity matching.
Manual spreadsheets and notes for tracking structural modifications.

This fragmentation creates severe context switching, eliminates reproducibility, and forces researchers to upload proprietary or unpublished molecular structures to third-party cloud servers.

Why ROGVEDA Exists

ROGVEDA unifies the complete molecular exploration cycle into a single, local-first desktop application $$\text{Input (Draw / SMILES)} \longrightarrow \text{Compute Descriptors} \longrightarrow \text{Predict Multi-Endpoint Activity} \longrightarrow \text{Similarity Search} \longrightarrow \text{Optimize & Mutate} \longrightarrow \text{Track &…

View on GitHub

Application Walkthrough

Interactive 2D Sketching and 3D Conformer Modeling
Real-time chemical canvas powered by embedded Ketcher and client-side RDKit WebAssembly, paired with interactive 3D WebGL ball-and-stick rendering via 3Dmol.js.
Calibrated Bioactivity and Toxicity Prediction
Instant multi-target inference with probability calibration bars explicitly communicating confidence distance from the decision boundary.
High-Throughput Batch Screening
Screening multi-molecule CSV libraries with row-level error isolation, property filtering, and one-click PDF and CSV report exports.

Code

The entire codebase is open-source under the MIT license:

Garg-Pankaj29 / Rogveda

ROGVEDA is an offline, AI-assisted molecular research sandbox that unifies structure analysis, ML property predictions, and local AI interpretation into a single workspace. Its core innovation is an iterative "Modify → Recalculate → Compare" loop for rapid, private compound design.

ROGVEDA

In-Silico Molecular Intelligence & Drug Discovery Screening Platform
One molecule. One workspace. One reproducible research loop.

1. Project Overview

ROGVEDA is an offline-first, privacy-preserving computational chemistry and early-stage drug discovery workbench.

The Problem It Solves

Early-stage medicinal chemistry and drug discovery workflows are heavily fragmented. Researchers, students, and small academic laboratories frequently juggle disconnected utilities:

Standalone drawing apps for 2D chemical sketching.
Cloud web servers for calculating molecular descriptors.
Cloud APIs for bioactivity and toxicity estimations.
External databases for similarity matching.
Manual spreadsheets and notes for tracking structural modifications.

This fragmentation creates severe context switching, eliminates reproducibility, and forces researchers to upload proprietary or unpublished molecular structures to third-party cloud servers.

Why ROGVEDA Exists

View on GitHub

Core Stack:

Frontend: React 19, Vite, Tailwind CSS, WebAssembly (@rdkit/rdkit), 3Dmol.js
Backend: Python 3.12, FastAPI, RDKit C++ binaries
Machine Learning: Scikit-Learn calibrated Random Forest ensembles trained on 230,000+ compounds from ChEMBL 37 and Tox21
Local AI: LM Studio / llama.cpp local REST connector

How I Built It

ROGVEDA is built entirely around an open-source AI and cheminformatics stack designed for strict local execution:

Local Open-Weight LLM Integration
Instead of sending chemical graphs to proprietary cloud APIs, ROGVEDA hooks into a locally running open-weight model (such as Llama-3.2-1B-Instruct or Qwen2.5-3B-Instruct served via LM Studio or llama.cpp). The backend constructs strict prompts embedding deterministic RDKit calculations and machine learning confidence intervals, asking the local model to generate structured summaries, highlight pharmacophore trade-offs, and suggest bioisosteric modifications. If the language model server is turned off, the core chemistry pipeline still functions without interruption.
Calibrated Machine Learning Engine
We trained Random Forest ensembles across 6 pharmacology and toxicology targets using 230,000+ compounds from ChEMBL 37 and the NIH Tox21 dataset:
Compounds are featurized using 2048-bit Morgan Fingerprints.
Datasets are partitioned using 80/20 Bemis-Murcko Scaffold Splits to reflect true out-of-distribution prospective generalization.
Predictions use CalibratedClassifierCV with sigmoid calibration, producing true confidence probabilities rather than raw heuristic scores.
Hybrid Client-Server Cheminformatics
Client-Side: RDKit compiled to WebAssembly runs inside the browser to validate chemical valences and render vector SVG thumbnails instantly on every change with zero network latency.
Server-Side: Python FastAPI calculates 3D energy-minimized conformers using the ETKDGv3 distance-geometry algorithm and MMFF94 force field optimization, returning standard SDF blocks to the frontend WebGL viewer.

Why Does Open Innovation Matter?

For chemistry and life sciences, open innovation is not merely a philosophical preference—it is a functional necessity:

Zero-Leakage Privacy for Scientific IP: Closed APIs require transmitting molecular representations to cloud servers. For researchers working toward provisional patents, that constitutes public disclosure or third-party risk. Running open-weight models locally ensures no proprietary chemical telemetry ever touches an external network.
100% Offline Capability: Field researchers, university laboratories with intermittent campus Wi-Fi, and air-gapped institutional environments can run the entire platform with zero internet connectivity.
Zero Operational Cost: Academic researchers and students cannot afford recurring token bills or enterprise subscriptions. Open-source models and libraries allow unlimited screening at zero API cost.
Deterministic Reproducibility: Closed cloud models update and change behavior without warning, altering conclusions and breaking academic provenance. Open-weight models and version-pinned machine learning models ensure experiments run today produce identical results years from now.

Prize Categories

Hacktoberfest Weekend Challenge: Build for a Friend

DEV Community: Pankaj Garg

How I Built UNREACHABLE: The Emergency Route Intelligence Platform Cities Will Pay For

What I Built

The Side Hustle Product & Who Pays For It:

Demo

Code

Garg-Pankaj29 / UNREACHABLE

AI-powered emergency accessibility mapping that identifies unreachable buildings, detects road bottlenecks, and helps emergency services plan feasible routes and prioritize safety improvements.

UNREACHABLE

Concept

How I Built It

1. The Core Architectural Philosophy: Deterministic Physics Decides, AI Explains

2. Dual Dataset Architecture

3. Dynamic In-Memory Obstructions & Real-Time SSE

Why Does Open Innovation Matter?

My Agent Session

My First User

Prize Categories

LedgerLeaf: Turn Messy Receipts into Structured Records with Local AI

Garg-Pankaj29 / LedgerLeaf

LedgerLeaf is a private, local-first financial assistant that turns receipts and invoices into structured records using open-weight AI on your machine. Featuring source provenance, deterministic math guards, and human approval before committing to your SQLite ledger—zero cloud dependencies.

LedgerLeaf — Your finances. Your files. Your AI.

1. Core Principles & Philosophy

Garg-Pankaj29 / LedgerLeaf

LedgerLeaf is a private, local-first financial assistant that turns receipts and invoices into structured records using open-weight AI on your machine. Featuring source provenance, deterministic math guards, and human approval before committing to your SQLite ledger—zero cloud dependencies.

LedgerLeaf — Your finances. Your files. Your AI.

1. Core Principles & Philosophy

Paperwalk: An AI That Designs Your Walk, Then Gets Out of the Way 🌿

Paperwalk: An AI That Designs Your Walk, Then Gets Out of the Way 🌿

What I Built

Demo

🎥 Video Demo

paperwalk_demo.mp4 - Google Drive

Screenshots

Code

Garg-Pankaj29 / Paperwalk

Use this: **“An offline-first AI walking experience that turns local observations into personalized printable walk cards.”**

Paperwalk

Concept

How I Built It

Stack

Card #1 — Generate a Walk

The Physical Part

Card #2 — AI Learns From the Walk

Local-First Architecture

ROGVEDA: Building an Offline-First, Privacy-Preserving Molecular Research Platform for a Friend

What I Built

Demo

Garg-Pankaj29 / Rogveda

ROGVEDA is an offline, AI-assisted molecular research sandbox that unifies structure analysis, ML property predictions, and local AI interpretation into a single workspace. Its core innovation is an iterative "Modify → Recalculate → Compare" loop for rapid, private compound design.

ROGVEDA

1. Project Overview

The Problem It Solves

Why ROGVEDA Exists

Application Walkthrough

Code

Garg-Pankaj29 / Rogveda

ROGVEDA is an offline, AI-assisted molecular research sandbox that unifies structure analysis, ML property predictions, and local AI interpretation into a single workspace. Its core innovation is an iterative "Modify → Recalculate → Compare" loop for rapid, private compound design.

ROGVEDA

1. Project Overview

The Problem It Solves

Why ROGVEDA Exists

How I Built It

Why Does Open Innovation Matter?

Prize Categories

Use this: “An offline-first AI walking experience that turns local observations into personalized printable walk cards.”