🌿 HearWild — An AI That Listens to Birds, Then Gets Out of Your Way

Praveen Kumar — Wed, 07 Oct 2026 20:23:17 +0000

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

What I Built

Most AI products are designed to keep us on our screens.

HearWild is designed to do the opposite.

HearWild is an open-source AI nature companion that lets you record a bird sound, identifies the bird using local AI, tells you a little about what you heard, and encourages you to go back outside.

The idea is simple:

Listen. Discover. Learn. Go outside.

You don't need to take a photo or know what bird you're looking at. Just point your microphone toward the sound, record for a few seconds, and let the AI listen.

When a bird is confidently identified, it is automatically added to your Flock and you earn XP:

🐦 New bird → +100 XP
🔁 Bird you've already discovered → +25 XP
⭐ Discover more birds → level up

The important part is what happens next.

HearWild doesn't try to keep you inside the app.

Once you've discovered the bird, the goal is to put the screen down and keep exploring.

It's built for anyone who's curious about nature, especially people who don't know much about birds but want a reason to step outside and pay attention to what's around them.

Demo

🎥 Watch the HearWild demo

The MVP currently runs locally:

Record a bird sound
        ↓
BirdNET V3 identifies it
        ↓
See the bird + confidence
        ↓
Bird is added to your Flock
        ↓
Earn XP
        ↓
🌿 Keep Exploring

Code

The complete source code is available on GitHub:

👉 View HearWild on GitHub

How I Built It

The core of HearWild is BirdNET V3, running locally through its ONNX model.

I wanted the AI itself to be part of the open-source stack rather than simply calling a closed AI API.

🧠 The AI

HearWild uses:

BirdNET V3 → ONNX → local inference

The audio recorded by the browser is sent to a local FastAPI backend, converted to the required format using FFmpeg, and passed to BirdNET V3.

The model returns the predicted species and confidence.

I then use confidence-aware behaviour:

Confidence	HearWild's response
70%+	Confident identification → add to Flock + earn XP
20–69%	Possible identification → show result, but don't add
<20%	Unknown → don't pretend to know

That last part was important to me.

If the model isn't confident, HearWild doesn't pretend it knows the answer.

🏗️ Architecture

┌──────────────────────────┐
│       Vue 3 + Vite       │
│                          │
│  🎙️ Record bird sound    │
└────────────┬─────────────┘
             │
             ▼
┌──────────────────────────┐
│         FastAPI          │
│                          │
│     Audio processing     │
└────────────┬─────────────┘
             │
             ▼
┌──────────────────────────┐
│         FFmpeg           │
│      Audio conversion    │
└────────────┬─────────────┘
             │
             ▼
┌──────────────────────────┐
│     BirdNET V3 ONNX      │
│                          │
│  Local bird identification│
└────────────┬─────────────┘
             │
             ▼
┌──────────────────────────┐
│         SQLite           │
│                          │
│       🐦 My Flock        │
└──────────────────────────┘

The frontend is built with Vue 3 + Vite and the backend uses Python + FastAPI.

SQLite keeps track of the birds I've discovered, how many times I've heard them, and my XP progression.

For bird imagery and short descriptions, HearWild uses Wikimedia when available.

Why Does Open Innovation Matter?

This project could have been built by calling a commercial bird-identification API.

But that would have missed one of the most interesting parts of the challenge for me.

I wanted the AI itself to be something I could run and understand locally.

Using an open model made it possible to:

Run bird identification locally
Avoid sending bird recordings to a proprietary AI service
Experiment with the model directly
Control the inference pipeline
Build without depending on an AI API subscription
Keep the project reproducible for other developers

More importantly, it changed the way I thought about the product.

The AI doesn't need to become the destination.

It can simply be the bridge between technology and the real world.

That's what I like about open innovation here: the model becomes a building block that anyone can experiment with and build something completely different around.

🌿 What I Learned

The biggest lesson from building HearWild was that an AI project doesn't necessarily need to give users more to look at.

It can help them notice what's already around them.

Birdsong is happening all the time.

Most of us just don't stop to listen.

So instead of building another AI assistant that says:

"Here are 10 things you can do on your screen..."

I wanted to build one that says:

"You heard a bird. Now go find it."

That's HearWild.

Listen to the world. Discover what lives in it.

🔗 Project

🐙 GitHub — HearWild
🌿 Hacktoberfest Open-Source AI Challenge

Building MailMate: My First AI Assistant Experiment 🤖📬

Praveen Kumar — Tue, 06 Oct 2026 18:43:33 +0000

I’ve been thinking about a simple problem:

What if my email could do more than just sit in my inbox waiting for me?

That question led me to start building MailMate.

MailMate is a lightweight AI-powered email assistant that I'm experimenting with on a Raspberry Pi.

The idea is simple:

📩 Fetch emails

🧠 Process them using AI

📝 Generate useful summaries

✅ Identify potential tasks or actions

🔔 Send the important information to me through Telegram

The interesting part isn't just summarizing emails.

I want to explore how far we can take the idea of an assistant that can understand context, identify intent, and help turn information into action.

Why MailMate?

I receive plenty of emails that don't require immediate attention.

But mixed in with them are things like:

An important request
Something I need to follow up on
A meeting invitation
A deadline
A notification that requires an action
Information that I'll probably need later

The problem isn't necessarily finding these emails.

It's knowing what matters.

That's the problem I'm trying to solve.

Starting small

I'm deliberately not trying to build a full-blown autonomous AI agent from the beginning.

The current workflow is intentionally simple:

Gmail → AI processing → Summary & task detection → Telegram

I'm building this incrementally and learning along the way.

Some of the things I want to explore next are:

⏰ Scheduled email processing
📅 Calendar and task integration
🔔 Better notification handling
👤 Multiple email accounts
🧠 Better context and task detection
🤖 More autonomous workflows

What I want to learn

This project is also an excuse to explore some interesting questions:

How should an AI assistant decide what is important?

How do we prevent an assistant from becoming noisy?

How much autonomy should we actually give it?

What should it remember?

And most importantly — how do we make it genuinely useful rather than just another AI wrapper?

MailMate is my attempt to explore those questions through a real project.

I'm building it in public, so I'll be sharing the architecture, experiments, mistakes, and lessons along the way.

🔗 The project is open on GitHub:

github.com/praveen-pravi6B/MailMate

If you're interested in AI assistants, automation, Raspberry Pi projects, or building AI tools from scratch, I'd love to hear what you're working on too.

Build. Learn. Experiment. Repeat. 🚀

DEV Community: Praveen Kumar