DEV Community: Sumit Das

Puja Altas: An Open Map for Durga Puja Hopping

Sumit Das — Fri, 16 Oct 2026 05:57:57 +0000

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

What I Built

Pujo Atlas is a browser-based map and itinerary planner for finding Durga Puja pandals in Kolkata and across West Bengal. It brings together a Kolkata puja guide and a government puja directory, with a combined view for exploring both datasets.

Visitors can search by pandal, locality, place name, coordinates, or DIGIPIN; browse nearby results on a clustered map; and save pandals to a separate hopping list to plan a route. The goal is to make it easier for residents and visitors to discover pandals and plan a day of hopping without switching between spreadsheets, map searches, and handwritten lists.

The app is currently a free community-facing project. It has no paying users or revenue yet.

Demo

The Pujo Atlas Demo on GitHub Page:

codebysumit.github.io

Code

codebysumit / pujo-atlas

Pujo Atlas is a static, browser-based map and itinerary planner for Durga Puja pandals in Kolkata and West Bengal.

Pujo Atlas

Pujo Atlas is a static, browser-based map and itinerary planner for Durga Puja pandals in Kolkata and West Bengal

Run locally

The app fetches its JSON data, so serve this folder over HTTP instead of opening index.html directly. From the project folder, run:

python -m http.server 8000

Then open http://localhost:8000.

OpenStreetMap is the default map and works without an API key. The government directory is loaded on demand and is about 12 MB. Records outside the supported West Bengal map bounds are omitted from the map.

Datasets and privacy

The JSON files used by the app are in data/:

pujo_atlas_plan_city.json contains the Kolkata Puja Guide records. Its zone labels use the Kolkata Puja prefix, such as Kolkata Puja North.
pujo_atlas_plan_government.json contains the government directory. President names and contact numbers have been removed from the records.

The app does not show or search government-directory president…

View on GitHub

How I Built It

Pujo Atlas is a static web app built with HTML, CSS, and vanilla JavaScript. Leaflet renders the OpenStreetMap view, and Supercluster groups dense sets of pandal markers. The app loads local JSON datasets, filters and sorts results in the browser, and stores hopping lists in browser storage.

The location search accepts place names, latitude/longitude, and DIGIPIN codes. Place suggestions use Photon with OpenStreetMap data; coordinates and DIGIPIN can be resolved locally. A searched location can show nearby pandals within 15 km. An optional Google Maps provider is available when configured with a browser-restricted API key.

Open-source AI disclosure: This version does not use an open-weight model, an open-source AI agent framework, or local inference. Open-source AI is not currently at the core of this project, so this draft does not yet meet the challenge's central technical prompt. I would need to build and document a real AI feature before presenting Pujo Atlas as a qualifying entry; I am not claiming that AI was used here.

Why Does Open Innovation Matter?

This version demonstrates the value of open mapping tools and data: a small browser app can offer searchable maps and useful planning features without requiring a proprietary map platform for its default experience. The source and data formats also make the project easier for others to inspect, adapt, and extend.

Open-source AI has not made anything possible in this version because it has not been integrated yet. I would rather be clear about that gap than suggest that the existing search and mapping features are AI-powered.

Prize Categories

I’m entering Best Use of GitHub Copilot. I used Copilot during development to help build and refine Pujo Atlas. I did not use GitHub Actions to automate the project or Copilot to review contributor pull requests.

PlantDex: A Pokédex for Real Plants — Built with Local On-Device AI

Sumit Das — Fri, 09 Oct 2026 12:54:18 +0000

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

What I Built

PlantDex is an open-source, mobile-first web app that turns any nature walk into an interactive botanical field quest — a Pokédex for the real world.

Point your phone's camera at any wild plant, tree, flower, or weed:

🌿 The app identifies the specimen using a quantized on-device neural network running entirely on the server's CPU — no cloud calls, no third-party AI APIs.
📋 Assigns an official Dex number — e.g. #0001 Betula lenta (Sweet Birch) — and adds it to your personal botanical Pokédex.
📚 Fetches peer-reviewed botanical facts — taxonomy, family, habitat, medicinal/ecological notes — pulled from Wikipedia REST API and GBIF, cached in a local SQLite database.
📈 Tracks your field progress with discovery statistics, completion percentages, and locked silhouette teasers for unidentified species.

The app is designed specifically for the Touch Grass challenge theme: it actively rewards going outside and discovering the living world around you. The more you explore, the more your Dex fills up.

Who Is It For?

Hikers, trail runners, and urban explorers who want to put a name to the plants they pass every day.
Citizen science enthusiasts contributing local observations to botanical knowledge.
Families and teachers making nature walks educational and gamified.
Anyone who wants to spend more time outside and less time staring at a screen.

Code

codebysumit / plantdex

🌿 PlantDex — Pokédex for the Living World

"Step outside, point your lens at any wild leaf or bloom, and register it into your personal botanical Pokédex."

Built for the Hacktoberfest 2026 Open-Source AI Challenge, Theme: Touch Grass.

📖 Table of Contents

🌟 Overview & Project Goal

PlantDex is an open-source web application designed to motivate people to disconnect from screens, get outside, and explore biodiversity in their neighborhoods, urban parks, and wilderness trails.

Inspired by the tactile joy…

View on GitHub

Repository: https://github.com/codebysumit/plantdex

How I Built It

The AI Core: Google AIY Plants Classifier V1 (TFLite)

The identification engine is built around Google's AIY Plants Classifier V1 — a quantized TensorFlow Lite model (plants_v1.tflite, ~3.7 MB) trained on over 2,100 plant species using verified binomial taxonomic nomenclature from iNaturalist and GBIF. It runs entirely in CPU memory with no GPU required.

Model: Google AIY Plants V1 (Apache 2.0)
Size: ~3.7 MB (quantized INT8)
Classes: 2,102 botanical species
Runtime: tflite-runtime / ai-edge-litert
Memory footprint: < 90 MB on server

3-View Multi-Crop Inference

To squeeze maximum accuracy out of hand-held phone photos, every capture is processed with three inference passes:

Full Frame — downscaled to 224×224 RGB.
Center Square Crop — extracted from the middle region of the image.
Mirrored Center Crop — horizontally flipped center crop.

The three probability vectors are averaged, the artificial background class is zeroed out, and the final softmax produces the confidence score.

Confidence Decision Tiers

Tier	Threshold	Outcome
🟢 `CAUGHT`	≥ 50%	Auto-saved to Dex with catch animation
🟡 `MAYBE`	25% – 50%	Shows Top-3 candidates; user confirms
🔴 `NOT SURE`	< 25%	"Do you know this plant?" — custom entry or `Unknown N`

Tech Stack

Backend: Python 3.10 + Flask 3.0 + SQLite (zero heavy frameworks)
AI Runtime: tflite-runtime (Linux) / ai-edge-litert (Windows/macOS)
Frontend: Mobile-first PWA with vanilla JS, camera capture API, canvas downsampling
Background Jobs: Thread-safe sync_worker.py fetches Wikipedia/GBIF details asynchronously with exponential backoff
Hosting: Optimized for Render Free Tier (1 CPU core, 512 MB RAM, 1 Gunicorn worker, 4 threads)

Privacy by Design

EXIF metadata and GPS coordinates are stripped from every uploaded photo using Pillow before anything is stored. No location data ever leaves the server. Photos are only sent to Gemini Vision for "double-check" analysis if the user explicitly clicks the optional button.

Why Does Open Innovation Matter?

The standard playbook for an AI-powered app in 2026 is: wrap an API, call GPT-4o or Claude, ship it. That approach fails completely for a plant identification app meant to be used outside — and here's why:

1. No Signal in the Wild

When you're hiking through a forest ravine, you don't have 5G. A cloud-dependent AI is useless. PlantDex's local TFLite model runs entirely on the server's CPU with the SQLite botanical cache. A catch still registers when the network drops.

2. Frugality = Accessibility

The entire inference stack runs on less than 90 MB of RAM on a single-core CPU. This means:

Anyone can host it on a free Render instance — zero cloud AI costs.
Community botanical clubs, schools, and individuals can self-host their own Pokédex server.
The marginal cost per plant identification is exactly $0.

3. Privacy as a Feature, Not an Afterthought

A closed commercial API would receive your photos, GPS coordinates, and timestamp data. For an app that tracks where you walk and what you observe in your neighborhood, that's a serious privacy concern. The open-source stack lets us strip all metadata before it even hits our own database, let alone any third-party server.

4. Open Science and Reproducible Taxonomy

The AIY Plants model labels correspond directly to GBIF-verified binomial nomenclature — the same scientific naming standard used in peer-reviewed literature. Every identification is traceable and auditable. There are no black-box API responses that can change without notice.

5. The Graceful Unknown

Closed AI systems often just return an error or a wrong answer with false confidence. PlantDex's three-tier confidence system means the app always does something useful, even when the model isn't sure — routing you through a user-naming workflow that enriches the community database for every future user.

Open innovation didn't just make this possible — it made it honest.

Prize Categories

🌿 Hacktoberfest Open-Source AI Challenge — Touch Grass (primary)
🤖 Open-Source AI / Local Inference track — 100% open-weight model, no closed APIs required for core functionality
🔒 Privacy-respecting AI — EXIF/GPS stripping, no third-party data leakage

EchoNote AI: I Built an Offline Lecture Notes App for My Friend

Sumit Das — Sun, 04 Oct 2026 06:01:54 +0000

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

What I Built

I built EchoNote AI for my friend Anshumita Ray.

Anshumita records her college professor's lecture on her phone during class. She does this because she cannot catch everything in real time. Sometimes a side conversation distracts her. Sometimes she forgets an important word, or misses a whole part of the lesson. Later, she has to listen to hours of audio again just to write her notes.

EchoNote AI fixes this. She uploads her recording or records live in the browser. The app writes the full transcript, then makes a clean summary with key definitions and exam questions. If she forgot something, she can ask the AI a question about the lecture and get an answer based only on what the professor said.

It runs fully on a normal laptop. No API keys. No internet after setup. Her notes are stored in an encrypted local database on her own device.

Demo

Code

codebysumit / echonote-ai

hf26-dev-challenge-1

🎙️ EchoNote AI

Your audio. Transcribed. Understood. Remembered.

100% Local CPU · No API Keys · AES-256 Encrypted · Offline-First

Watch Demo · Features · Setup · Deploy

🧠 What is EchoNote AI?

EchoNote AI is a professional, Claude & NotebookLM-inspired audio intelligence studio that converts any recording into structured, encrypted notes — all running entirely on your own laptop CPU, with zero API keys and zero internet dependency after setup.

Designed for college students, school kids, teachers, working professionals, recipe keepers, and voice note creators.

Upload a lecture. EchoNote AI transcribes it, detects what it is, writes you a tailored summary with exam questions, and lets you chat with Gemma AI about its content — forever stored privately in your encrypted local database.

🎬 Demo

Watch EchoNote AI in action:

▶️ Watch on YouTube

✨ Features

Feature	Details
⚡ Auto GPU / CPU Detection	Automatically uses the best

…

View on GitHub

How I Built It

Every important part is open source:

faster-whisper turns speech into text. It supports 99 languages and handles mixed language lectures, which is common in our classrooms.
Gemma 3 1B (GGUF, Q4) writes summaries, exam questions, and answers chat questions. It runs through llama-cpp-python and needs only about 800 MB of RAM.
FastAPI powers the backend.
SQLite with Fernet encryption keeps transcripts, summaries, and chats private.
HTML, CSS, and JavaScript make a simple three column studio screen.

The app checks the hardware when it starts. It uses an NVIDIA GPU or Apple Metal if they exist, and falls back to CPU on any laptop with 4 GB RAM. I picked the small 1B model on purpose, because a student laptop must be able to run it.

It also detects the type of audio. A college lecture gets exam questions. A meeting gets action items. A recipe gets ingredients and steps.

Why Does Open Innovation Matter?

Here is the thing. A closed API would have failed Anshumita in three ways.

Cost. A student cannot pay for every hour of lecture audio.
Privacy. Her professor's lectures and her own voice notes should stay on her device, not on someone else's server.
Access. The app works offline, so bad internet does not stop her from studying.

Open weight models made all three possible. I chose a model small enough for her laptop, ran it myself, and changed how it writes notes for each type of audio. With a closed API I could not have done that for free.

Prize Categories

Best Use of Gemma. EchoNote AI runs Gemma 3 1B locally on CPU. It writes all summaries and exam questions, and it powers the chatbot that answers from the lecture transcript.