From WhatsApp Script to Barebones Framework: The Image Denoiser Journey

How two friends turned late‑night chats into a denoising app

It started with two hobbyist photographers, trading noisy RAW files back and forth over WhatsApp. Every low‑light shot came with that familiar grain — the kind that makes a magical moment look messy. One night, the conversation shifted:

“What if we could actually denoise these ourselves?”

That single message kicked off a journey. Code snippets pasted into chats became a rough Python script. The script grew into a framework. And the framework, though still barebones, is now a beta app with the potential to evolve into something much bigger.

We never treated this like a milestone project. It was a hobby effort, something we worked on in leisure — a way to destress, detangle, and enjoy tinkering with code while solving a problem we cared about.

The Beginning: One File, Three Filters, Infinite Patience

The first version was barebones. Edit config.ini, run python denoiserBatch.py, wait, check results. Every tweak meant restarting. It felt like tinkering in a garage—powerful for us, but inaccessible for anyone else.

And yet, every WhatsApp ping brought new ideas: “What if we add another filter?” or “Could we batch process a folder?” The script slowly grew, line by line, message by message.

The Turning Point: When We Wanted More

Then came the WhatsApp message that changed everything: “I need to see what is happening while it runs.”

Running the script over the command line gave us live print messages — a comforting stream of progress. But once we built the GUI, that feedback disappeared. Suddenly, the app felt silent, even though it was working.

Trade‑off: Accessibility improved, but transparency was lost. Solution: We added real‑time status labels, progress bars, and auto‑opening logs. The GUI became more than sliders and buttons — it became a window into the process.

The AI Revolution: Filters Meet Neural Networks

The WhatsApp thread shifted from filters to something deeper: tensors. At first, we considered building our own lightweight tensor operations. But surprisingly, that approach caused significant size bumps and complexity.

Trade‑off: Custom tensors looked lean on paper, but in practice they bloated the framework. PyTorch, while heavier in dependencies, actually kept things more consistent and opened the door to state‑of‑the‑art models. In the end, after testing both methods, we integrated SCUNet and NAFNet, neural networks trained on millions of noisy images.

That decision unlocked superior denoising, but also introduced new challenges: model downloads, dimension constraints, GPU acceleration. Solution: Auto‑padding for any image size, fallback to classical filters if AI failed, and clear error messages. By embracing PyTorch, we gained access to cutting‑edge denoising while keeping the app resilient.

Further we ran into known issues where PyTorch AI models have architectural constraints which was solved by Auto‑padding. Auto-padding exists specifically to make PyTorch AI models work with real-world images that have arbitrary dimensions. Without auto-padding, ~50% of images would fail. With auto-padding, 100% of images work for any image size. We fallback to classical filters if AI failed, and provide clear error messages. By embracing PyTorch, we gained access to cutting‑edge denoising while keeping the app resilient.

WhatsApp Highlights

Our WhatsApp thread became the heartbeat of development. Here are a few of the messages that pushed the app forward:

• “I need to see what is happening while it runs.” → led to progress bars and live logs in the GUI.
• “Tensor would be awesome, need to find out more…” → sparked debates about tensors vs PyTorch, eventually leading to SCUNet/NAFNet integration.
• “Fallback works now.” → confirmed resilience when AI failed, switching seamlessly to classical filters.
• “Only want faces denoised.” → inspired the mask editor for selective processing.

Each of these small pings carried big consequences. The app grew not from grand plans, but from late‑night messages and quick fixes that snowballed into features.

Self‑Testing: Frustrations Become Features

Because we were our own first users, every frustration showed up immediately. Testing the app on our own noisy photos became the feedback loop.

The Polish: Barebones but Solid

Polish didn’t come in one big push — it arrived piece by piece.

Early version iteration showing basic usage

We added comparison windows, cancel buttons, and fallbacks as natural extensions of our own frustrations while testing. None of these were drawn‑out struggles; they were incremental wins that steadily layered into the framework.

This wasn’t about deadlines or deliverables. It was about enjoying the process, experimenting freely, and letting the app evolve at its own pace. Right now, the app is functional but barebones — the framework is there, the essentials work, and it’s usable in beta. But it’s not “production‑ready” yet. It’s a foundation waiting for the next leap.

Lessons Learned (So Far, in Beta)

1. Self‑testing is powerful. Every bug we hit became the seed for a new feature.
2. Dogfooding works. Using the app ourselves exposed trade‑offs we couldn’t ignore.
3. Error handling is a feature. Failures became opportunities to build resilience.
4. Iterative refinement beats big leaps. Each WhatsApp message nudged the app forward.
5. Leisure builds longevity. Treating this as a hobby project kept it fun, sustainable, and stress‑free.

What’s Next

The journey isn’t over. Since this is a hobby project, the “next big things” are more like dream features we’d love to play with:

• A GUI uplift to make it smoother and more modern
• Conversion into an iOS or Android app so mobile photographers can denoise on the go
• Real‑time previews before processing (this ones going to be tricky)
• Batch comparison mode
• Custom AI training
• Cloud processing for lightweight devices

These aren’t deadlines or milestones. They’re experiments waiting for the right weekend, the right mood, or the right late‑night WhatsApp ping.

The final home screen GUI that we settled on.

Mask Editor Preview

Comparison window shows before and after, has scroll bars and zoom in / out buttons and a reset button

Try It Yourself (Beta Invitation)

The app is open source (CC BY‑NC 4.0) and still in beta. Right now, it’s mostly us — two friends testing on our own noisy photos, refining features as we go. But we’d love for others to try it, break it, and tell us what works (and what doesn’t).

Getting started is simple: Install Python → run install_dependencies.bat → launch run_gui.bat. Five minutes from download to denoising.

GitHub: [https://github.com/Siddhesh-Pandit/deNoiser]

💡 Two friends, a WhatsApp chat, and a noisy photo. That’s how it started. Today, it’s a barebones framework built in leisure — proof that great tools can grow out of hobby projects, one test at a time.