DEV Community: Debosman Dasgupta

🌿 WildLens: Your Offline AI Companion for Exploring Nature

Debosman Dasgupta — Sun, 11 Oct 2026 18:18:40 +0000

What if AI could help us spend less time staring at screens and more time discovering the world around us?

That question inspired me to come up with WildLens, an open-source, AI-powered nature companion designed to make exploring the outdoors more fun, educational, and accessible.

Instead of using AI to keep people glued to their phones, I want to build something that encourages them to put their phones down, step outside, and discover the little things they might otherwise overlook. 🌱

What I Built

WildLens is an AI-powered nature exploration companion that helps people identify and learn about the natural world around them.

Imagine walking through a park, hearing an unfamiliar bird call, or discovering a plant you've never seen before. Instead of spending several minutes searching the internet, WildLens helps you identify what you've found and learn something interesting about it.

Here's what I plan to build:

🐦 Bird Identification: Capture a bird's photograph or record its call to get a likely identification and learn about its characteristics.
🌿 Plant and Tree Recognition: Use an image to identify plants and trees, along with useful information about their habitat and features.
🐞 Insect Discovery: Explore the smaller inhabitants of your surroundings and learn about their role in the ecosystem.
🧠 Nature Facts: Get concise, easy-to-understand explanations about the species you encounter.
🎯 Nature Challenges: Complete small outdoor missions, such as spotting three different leaves, observing a bird without disturbing it, or finding different flower shapes.
📱 Offline Exploration: Make previously downloaded species information and supported identification features available without an internet connection.

WildLens is intended for nature enthusiasts, students, families, hikers, birdwatchers, and anyone who wants to reconnect with the world outside their screens.

The goal is simple: the phone helps you discover something, but the real experience happens outdoors.

Demo

The project is currently in the building/planning stage, and I plan to share a working demo as the implementation progresses.

The intended demo will show the complete experience:

Open WildLens and select a discovery mode.
Photograph a plant or record a bird call.
Get a predicted identification and relevant nature facts.
Save the discovery to a personal nature journal.
Receive a small outdoor challenge and continue exploring.

I'd also love to take WildLens outside and test it in a local park, documenting how it performs with real-world observations.

Demo link: To be added when the first working version is available.

Code

WildLens is intended to be an open-source project, with the code, setup instructions, model information, and contribution guidelines published on GitHub.

I want the project to be something other developers can experiment with, improve, and extend—not just another application that hides its AI implementation behind an API.

How I Built It

My approach is to build WildLens around open-source tools and open-weight AI models rather than making a closed, hosted AI API the core of the application.

Here's the planned architecture.

1. Open-weight AI for nature identification

For visual recognition, I'll explore an open-weight vision model that can identify likely plant, bird, or insect species from photographs. Depending on its performance and hardware requirements, I'll evaluate models such as a suitable vision-language model or a specialized image classifier.

For bird calls, I'll investigate a lightweight audio-classification model trained for bird-sound recognition.

These are separate ML tasks, so I'll select models suited to each rather than expecting one general-purpose language model to solve everything.

2. Local inference with Ollama

I'll explore Ollama for running a compatible open-weight language model locally.

The language model can turn identification results into useful, readable explanations, generate nature challenges, and answer questions about a discovery using trusted species information.

For example, after identifying a bird, WildLens could explain its typical habitat, diet, and interesting behavior in simple language.

The identification system and language model will have separate responsibilities. The language model should not invent a species identification when the vision or audio model is uncertain.

3. A practical technology stack

The initial implementation will use the following tools:

Frontend: React and Tailwind CSS for a responsive, mobile-friendly interface.
Backend: Python and FastAPI for model orchestration and application logic.
Vision AI: An appropriate open-weight vision model or lightweight image classifier.
Audio AI: An open-source bird-call classification model.
Local language model: Ollama with a compatible open-weight model for explanations and challenge generation.
Storage: SQLite for local discovery history and saved observations.
Nature knowledge: A curated species database, with appropriate open datasets and attribution.

I'll begin with image-based identification and the nature journal, then add audio recognition and improve offline functionality.

4. Designing for offline exploration

Offline support is one of the most important parts of WildLens.

My plan is to cache species information, save discoveries locally, and make supported models available on the device before users head outside.

A fully offline experience will depend on the selected model, device memory, and storage capacity. Rather than promising that every feature will work offline immediately, I'll build and test offline support feature by feature.

The ideal experience is to prepare before a walk and then explore without needing a constant internet connection.

5. Keeping the experience outdoors-first

I don't want WildLens to become an endless AI chat interface.

The application will prioritize quick identification results, short explanations, saved observations, and outdoor challenges. Once users have what they need, the interface should encourage them to put the phone away and continue observing their surroundings.

I'll also prioritize responsible wildlife observation: users should maintain a safe distance from animals, avoid disturbing habitats, and treat uncertain model predictions as suggestions rather than definitive scientific identifications.

Why Does Open Innovation Matter?

For WildLens, open innovation isn't just a technical preference. It's what makes the project's approach possible.

🔓 Freedom to experiment

Using open-weight models gives me the flexibility to evaluate different vision, audio, and language models, compare their performance, and replace individual components without redesigning the entire application.

If a lightweight bird classifier works better for bird calls than a general-purpose model, I can use it.

🔒 Privacy through local inference

Nature photographs and recordings can contain more information than users intend to share. Running supported inference locally can reduce the need to upload those observations to an external service.

My goal is to keep personal discovery history on the user's device and make external services optional wherever practical.

🌐 Access beyond a constant internet connection

A hosted AI API makes an application dependent on network availability, service policies, and API costs.

Local models can help WildLens support exploration in parks, gardens, and trails where connectivity is unreliable. Once the required models and reference data are available locally, supported features can work without contacting a remote inference service.

🛠️ A project the community can improve

Open-source development means other contributors can improve model integration, add regional species information, optimize inference, support more languages, and build additional exploration features.

For example, someone could contribute a better bird-call classifier or a curated database of plants found in their region.

💚 A different relationship with AI

Many AI applications compete for more screen time. WildLens is designed around the opposite idea.

AI should help people become more curious about the real world, not replace their experience of it.

That's where I believe open innovation can make a meaningful difference: giving developers the freedom to build technology that is useful, privacy-conscious, adaptable, and accessible.

My Agent Session

I'll share an agent session or development walkthrough once I have a meaningful implementation to demonstrate.

I'd like to document the process of integrating the open-weight models, handling uncertain predictions, and making offline inference practical.

Prize Categories

WildLens is being developed for the Touch Grass theme, with open-source AI at the center of the project.

I'll confirm the applicable partner prize categories against the challenge rules once the final model and tooling choices are established.

What's Next?

My next milestones are:

[ ] Set up the repository and initial application structure.
[ ] Integrate an open-weight vision model for image-based nature identification.
[ ] Build the species information and nature journal features.
[ ] Add locally generated explanations and outdoor challenges.
[ ] Investigate and integrate bird-call recognition.
[ ] Test offline inference on supported hardware.
[ ] Take WildLens outdoors and document the results.

I'm excited to build this, learn from the open-source AI ecosystem, and hopefully help more people notice the amazing things happening just outside their doors.

Let's build AI that helps us touch grass. 🌿

#Hacktoberfest #OpenSource #AI #MachineLearning #TouchGrass #Ollama #BuildInPublic

Hacktoberfest Weekend Challenge: Build for a Friend

Debosman Dasgupta — Sun, 04 Oct 2026 16:03:57 +0000

What I Built

🧠 MindFlare: A Daily Brain Exercise App for My Mother

I built MindFlare, a simple daily brain-exercise app for my mother.

As our parents get older, it's normal to notice occasional forgetfulness, remembering a number, recalling a word, or keeping track of something they just saw. I wanted to build something that could turn a few minutes of everyday mental exercise into something simple, enjoyable, and engaging.

Instead of making another complicated productivity or health app, I wanted MindFlare to feel like a small daily game.

The app provides short exercises covering:

🔢 Mental Math: addition, subtraction, multiplication and everyday calculations
🧠 Memory Recall: remember numbers, words and objects
🧩 Pattern Puzzles: identify number and visual patterns
🔤 Word Memory: remember and identify words
👀 Visual Memory: remember objects and their positions
🎯 Adaptive Difficulty: gradually adjusts the challenge based on performance

The goal isn't to diagnose, treat, or prevent any medical condition. It's simply a fun way to encourage memory practice, attention, mental calculation, and problem-solving for a few minutes each day.

The interface is intentionally simple, with large buttons, readable text, minimal distractions, and encouraging feedback.

The idea is:

5 minutes a day. A few puzzles. A little mental exercise. ❤️

Demo

🚀 Live Demo:

The application is deployed on Render.

Code

💻 GitHub Repository:

The complete source code, setup instructions, and Ollama integration are available in the repository.

How I Built It

MindFlare is built around open-source AI using Ollama.

Tech Stack

Frontend: HTML, CSS, JavaScript / React
Backend: Python + FastAPI
AI: Ollama + open-weight LLM
Database: SQLite
Deployment: Render
Version Control: Git + GitHub

The core application doesn't depend on AI for everything. The actual game logic and answer validation are handled by the application itself.

Ollama is used where generative AI actually adds value.

🤖 What Ollama Does

The AI can generate:

New math questions
Memory exercises
Pattern puzzles
Word-based challenges
Difficulty-appropriate questions
Encouraging feedback
Personalized challenges based on previous performance

For example, instead of repeatedly showing the same hardcoded questions, MindFlare can ask the local model to generate a new beginner-level arithmetic challenge.

The application can also use previous performance to determine whether the next set should be easier, similar, or slightly more challenging.

This gives the experience a more personalized feel without requiring a closed AI API for every question.

🧠 The Daily Challenge

One of the main features is the Today's 5-Minute Challenge.

A typical session might contain:

Memory → Math → Pattern → Word → Memory

At the end, the user gets a simple summary of their performance rather than a complicated analytics dashboard.

For example:

🎉 Today's Result

4 / 5 correct

Memory ⭐⭐⭐⭐

Math ⭐⭐⭐⭐⭐

Patterns ⭐⭐⭐⭐

Great job! See you tomorrow ❤️

The idea is to make the experience encouraging rather than competitive.

Why Does Open Innovation Matter?

This project is especially meaningful to me because I didn't want the AI component to simply be a black box API.

Using Ollama and an open-weight model gave me the opportunity to experiment with running an AI model through an open ecosystem and decide exactly where AI was useful in the application.

Open innovation makes experimentation much more accessible.

Instead of building around a proprietary API and sending every generated puzzle to a closed service, I could:

Experiment with different open-weight models
Run the model locally during development
Control the prompts and generation process
Customize the AI behavior for my specific use case
Build an application around an open AI stack
Learn how local inference actually fits into a real application

For a personal project like MindFlare, this matters because the app deals with a very personal use case.

The more control I have over the AI layer, the more comfortable I am experimenting with how the application handles the user's interactions and data.

Most importantly, open-source AI made this feel less like “calling an AI API” and more like actually building with AI.

My Agent Session

I used AI-assisted development during the project to help with things like application structure, debugging, prompt design, and iterating on the puzzle-generation workflow.

Agent Session:

Prize Categories

I'm submitting MindFlare for the applicable partner categories related to:

🤖 Open-source AI / AI
🧑‍💻 Developer Tools

- 🌐 Open Innovation

Why I Built This

This project started with a very simple thought:

I wanted to build something for someone I care about.

There are plenty of impressive AI applications that solve huge problems. But sometimes the most meaningful projects are much smaller.

For me, MindFlare isn't about building the world's most advanced brain-training platform.

It's about making something my mother can open every morning, spend five minutes on, smile when she gets an answer right, and hopefully come back to tomorrow.

And that's what Build for a Friend meant to me.

Technology doesn't always have to solve a huge problem. Sometimes it can simply make someone's everyday life a little better. ❤️

Hacktoberfest #BuildForAFriend #OpenSource #Ollama #AI #MachineLearning #Python #OpenInnovation #DevCommunity

Indian Elections Assistant: Empowering the Next Generation of Voters

Debosman Dasgupta — Sat, 02 May 2026 06:26:02 +0000

In a country as vast and diverse as India, democracy thrives on participation. Yet, for many young voters stepping into the electoral process for the first time, the system can feel overwhelming—full of procedures, terminology, and responsibilities that aren’t always easy to understand. That’s where Indian Elections Assistant comes in.

🌱 Why This App Matters

India is home to the world’s largest democracy, but awareness about how elections work is often limited, especially among first-time voters. Questions like:

How do I register to vote?
What is the role of the Election Commission?
How does voting actually happen on election day?

are surprisingly common.

The Indian Elections Assistant is designed to bridge this gap—turning confusion into clarity and curiosity into informed participation.

📱 What is Indian Elections Assistant?

Indian Elections Assistant is an educational app built specifically to guide young voters through every step of India’s electoral process. It simplifies complex concepts into easy-to-understand explanations, making civic education accessible, interactive, and engaging.

Whether you're preparing to vote for the first time or just want to understand how democracy functions behind the scenes, this app acts like a personal guide.

🚀 Key Features

Step-by-Step Voting Guide

The app walks users through the entire voting journey—from voter registration to casting their vote—ensuring no step feels intimidating.

Simplified Electoral Concepts

Terms like constituencies, EVMs, Model Code of Conduct, and NOTA are explained in a clear and relatable way.

Interactive Learning Experience

Instead of static content, the app uses structured guidance and intuitive flows to make learning feel natural and engaging.

Focused on First-Time Voters

The content is tailored specifically for young citizens who may not have prior exposure to civic processes.

🧠 The Idea Behind It

The motivation behind Indian Elections Assistant is simple:
An informed voter is a powerful voter.

By making electoral knowledge easily accessible, the app aims to:

Increase voter confidence
Encourage participation in elections
Promote responsible and informed decision-making
💡 Built with Purpose

Behind the scenes, the app leverages modern technologies and thoughtful design to ensure a smooth user experience. While the technical implementation includes standard development practices (like ignoring unnecessary build and dependency files for cleaner deployments ), the real focus remains on delivering value to the user.

🌍 Impact and Vision

India’s youth population is massive—and with that comes immense potential. If even a fraction of first-time voters become more informed and engaged, the ripple effect on democracy could be profound.

Indian Elections Assistant isn’t just an app—it’s a step toward:

Strengthening democratic participation
Building civic awareness
Empowering the next generation
✨ Final Thoughts

Voting is more than just a right—it’s a responsibility. But responsibility should never come with confusion.

With Indian Elections Assistant, young voters now have a reliable companion to guide them through one of the most important civic duties in the country.

Because democracy works best when everyone understands their role in it.

🗳️ Building Electify — A Digital Guide for Young Voters in India

Debosman Dasgupta — Mon, 27 Apr 2026 16:35:10 +0000

In a country as diverse and democratic as India, voting is not just a right — it’s a responsibility. Yet, for many first-time and young voters, understanding the electoral process can often feel confusing and overwhelming.

That’s what inspired me to build Electify — an interactive web application designed to simplify and explain the electoral process in India in a clean, engaging, and beginner-friendly way.

From voter registration to election day and result declaration, Electify aims to guide young citizens through every stage of democracy.

In this blog, I’ll share:

The idea behind Electify
The technologies used
How I deployed the project on Google Cloud Run
Challenges faced during deployment
Key lessons learned along the way

🌟 What is Electify?

Electify is an interactive election guide web app created to help young and first-time voters understand how elections work in India.

The application presents the electoral journey in a simple and visually engaging timeline format, covering stages such as:

Voter registration
Election preparation
Voting process
Counting and results
Transition of governance

The goal was to make civic awareness:
✅ Easy to understand
✅ Accessible to everyone
✅ Visually engaging
✅ Mobile-friendly

At its core, Electify combines technology with civic education.

🎯 Why I Built This Project

Many young voters:

Don’t know how to register
Are unaware of election procedures
Find official information too complex
Lack awareness about the importance of participation in democracy

I wanted to create something minimalistic yet informative — a platform that explains the electoral process in a modern and interactive way.

Electify is my attempt to bridge the gap between technology and civic awareness.

🛠️ Tech Stack Used

Frontend

HTML5
CSS3
JavaScript

Backend

Python Flask

Deployment & DevOps

Docker
Google Cloud Build
Google Cloud Run

💡 Key Features of Electify

📱 Responsive User Interface

The application is optimized for both desktop and mobile users.

🗓️ Timeline-Based Learning

The electoral process is broken into easy-to-follow stages.

⚡ Interactive Experience

Users can explore different election phases dynamically.

☁️ Cloud Deployment

The app is deployed on Google Cloud Run for scalability and reliability.

📦 Containerizing the Application with Docker

To make deployment smoother and production-ready, I containerized the project using Docker.

Dockerfile

```dockerfile id="hyjlwm"
FROM python:3.11-slim

WORKDIR /app

COPY requirements.txt .

RUN pip install --no-cache-dir -r requirements.txt

COPY . .

ENV PORT=8080

EXPOSE 8080

CMD ["gunicorn", "--bind", "0.0.0.0:8080", "app:app"]




This setup ensured:

* Lightweight deployment
* Faster builds
* Consistent runtime environment
* Better scalability on Cloud Run

---

# ☁️ Deploying Electify on Google Cloud Run

I used Google Cloud Run because it provides:

* Serverless infrastructure
* Automatic scaling
* HTTPS support
* Container-based deployment
* Cost efficiency

## Step 1 — Build the Docker Image



```bash id="6g6e7k"
gcloud builds submit --tag gcr.io/PROJECT_ID/electify

Step 2 — Deploy the Application

```bash id="r00uj7"
gcloud run deploy electify \
--image gcr.io/PROJECT_ID/electify \
--platform managed \
--allow-unauthenticated \
--region asia-south1




Within minutes, Electify was live on the internet 🚀

---

# 🧩 Challenges Faced During Deployment

Like every real-world project, deployment came with its own challenges.

### ❌ Missing Dockerfile

Initially, Cloud Build failed because the Dockerfile wasn’t in the correct project directory.

### ❌ Wrong Build Context

At one point, Google Cloud Build detected “0 items” because the deployment command was executed from the wrong folder.

### ❌ Port Configuration Issues

Cloud Run requires applications to bind to the `PORT` environment variable dynamically.

I fixed this in Flask using:



```python id="o7rq2k"
port = int(os.environ.get('PORT', 8080))
app.run(host='0.0.0.0', port=port)

These debugging experiences taught me a lot about cloud-native deployment workflows.

📚 What I Learned

Building and deploying Electify helped me gain practical experience in:

Full-stack web development
Docker containerization
Google Cloud deployment
Cloud-native application hosting
Debugging production deployment issues
Designing user-focused interfaces

Most importantly, I learned how technology can be used to spread awareness and simplify important civic processes.

🚀 Future Improvements

I plan to expand Electify further by adding:

Election Commission API integration
Real-time election updates
Regional language support
AI-powered voter assistance
Interactive quizzes and learning modules
Accessibility improvements

The long-term vision is to make Electify a complete digital civic awareness platform for young Indian voters.

🇮🇳 Final Thoughts

India is the world’s largest democracy, and informed voters are its greatest strength.

Electify may be a small project, but it represents a larger idea — using technology to educate, empower, and encourage participation in democracy.

Building this project was not just a technical experience, but also a meaningful one.

It reminded me that technology is most impactful when it solves real-world problems and creates awareness among people.

💬 Conclusion

Electify combines:

Web development
Cloud computing
Civic awareness
Interactive design

into one meaningful project.

From designing the UI to deploying it on Google Cloud Run, the entire journey was a valuable learning experience that strengthened both my development and deployment skills.

I’m excited to continue improving the platform and exploring how technology can contribute positively to society.

Thanks for reading! 🚀🗳️