DEV Community: Akhouri Anmol Kumar

I Built the World's Most Customizable Scientific Calculator (30+ Themes, Python + PyQt6)

Akhouri Anmol Kumar — Thu, 03 Sep 2026 09:55:44 +0000

The idea

Every OS ships a calculator. Every one of them looks the same, feels the same, and disappears from memory the moment you close it.

So I built ACALCU v3 — an Akhouri Systems product — a scientific calculator that's absurdly, unnecessarily customizable. Not because a calculator needs 30+ themes and per-button styling, but because it was a fun constraint to design around: how far can you push a "boring" utility app before it becomes something people actually enjoy using?

What it does

At its core, ACALCU is a standard scientific calculator: basic arithmetic, sin, cos, tan, log, √, π, percentages, and a running expression engine built on Python's math module.

On top of that core, it layers:

30+ built-in themes — Royal, Liquid Glass, Wild, Cyberpunk, Dracula, Nord, Solarized, Monokai, Windows 7 / Vista / 10, OneUI 8.0, Matrix, Rose Gold, Galaxy, Fire, Ice, Neon, Vintage, Sakura, Midnight, Forest, Candy, Terminal, Gold Dark, and more.
Per-button customization — right-click any button to change its color, font, or set a custom image/video as its background. Every button on the grid is independently styleable.
A live "Wild" theme — a small animated plant widget that visibly grows every time you run a calculation.
Calculation history — a scrollable dialog of your last 50 calculations.
Persistent config — every customization is saved to a local JSON file and reloaded on next launch.
Full keyboard support — number keys, operators, Enter/Escape, all mapped to the same input pipeline the buttons use.
Architecture

The whole thing is a single-file PyQt6 desktop app, structured around a few core pieces:

python
THEMES = {
"DEFAULT": { "app_bg": "#0a0a0a", "display_bg": "#111111", ... },
"ROYAL": { "app_bg": "#0a0800", "display_fg": "#ffd700", ... },
"LIQUID_GLASS": { "app_bg": "transparent", ... , "transparent": True },
# ...30+ more
}

Each theme is just a dict of colors, font, corner radius, and optional flags (transparent, wild). The Config class resolves the active theme plus any per-button overrides stored in customizations, and every widget re-derives its stylesheet from that at render time — so switching themes or recoloring a single button is just a style recompute, not a UI rebuild.

The calculation engine is intentionally simple:

python
funcs = {
"sin": lambda x: math.sin(math.radians(x)),
"cos": lambda x: math.cos(math.radians(x)),
"tan": lambda x: math.tan(math.radians(x)),
"log10": math.log10, "log": math.log,
"sqrt": math.sqrt, "pi": math.pi,
}

Tokens from button clicks or keyboard input get translated into a Python-evaluable expression string (with the trig functions pre-wrapped for degree input), evaluated, and pushed onto a history stack.

Per-button customization is handled by a ButtonCustomizer dialog — right-clicking a button opens a small QDialog where you can pick a color (QColorDialog), a font (QFontDialog), or attach an image/video via QFileDialog. Those overrides get merged into the button's stylesheet on top of the active theme, so you can have a Cyberpunk-themed calculator with one neon-pink = button that's actually a GIF.

What I'd do differently
The 1000+ line single file works for a personal project but I'd split themes, engine, and widgets into modules if this grows further.
Theme switching currently rebuilds the central widget — fine for a desktop app, but I'd profile this if I ever wanted smoother live-preview theme switching.
Video backgrounds on buttons are a fun gimmick but genuinely questionable UX — I kept it in anyway.
Try it
👉 https://github.com/Akhouri-Anmol-Kumar/ACALCU-v3
It's open source, built with Python 3 + PyQt6. Repo link in the comments — would genuinely love to see what themes people request or build themselves.

If you build desktop apps with PyQt/PySide, curious what your approach to theming systems like this looks like — drop it below.

ACALCU

"We Build what others forgot to fix"

I got tired of having 5 different image tools open, so I built one that does everything

Akhouri Anmol Kumar — Wed, 02 Sep 2026 10:14:03 +0000

Every time I needed to edit a screenshot, convert a HEIC file, compress an image for upload, — it was a different tool, a different tab, a different website with ads. So I built APIC (Advanced Image Processing Center) — one desktop app that handles the whole image workflow.

What's inside

APIC is built around five modules, all in one window:

Edit — crop, adjust, and touch up images without opening a browser tab
Convert — switch between image formats in a couple of clicks
Compress — shrink file sizes for upload limits or storage, without a visible quality hit
Home — a clean landing screen that ties the workflow together

It also supports drag-and-drop straight onto the main window — drop one file and it opens in the editor, drop several and it routes you to the converter, which is the flow I actually wanted every time I used a tool like this before.

Why a desktop app instead of another web tool

Web-based image tools mean uploading your files to someone else's server, waiting on their upload/download cycle, and often hitting a paywall past the third free conversion. APIC runs locally — nothing leaves your machine, there's no queue, and it works offline.

Stack

Built with PyQt6 for the interface (dark theme, keyboard shortcuts for every major action), structured as separate mode modules so each part of the app — edit, convert, compress, search — is self-contained and easy to extend. Packaged as a standalone executable with PyInstaller.

Where it's headed

This is an early build. Batch processing across all four modules is next, along with more format support in Convert. If you work with images regularly and you're tired of the browser-tab shuffle, I'd genuinely like feedback on what's missing.

This is an Akhouri Systems product — same team behind ATLOCK, ACALCU, ANOTE.
Download it from website
👉 https://akhouri-anmol-kumar.github.io/Akhouri-systems/
Download it from GitHub repo
👉 https://github.com/Akhouri-Anmol-Kumar/APIC

"We build what others forgot to fix."

I built a real NTFS-level file locker in Python — no password needed to protect, and even I can't brute-force it

Akhouri Anmol Kumar — Tue, 01 Sep 2026 10:22:37 +0000

Most "file lock" apps on the market do one of two things: rename your file extension, or hide it in a folder. Both take about ten seconds to bypass with Windows Explorer's search bar. That bugged me enough to build something that actually works at the OS level.

This is ATLOCK v4.0 — a total security suite for Windows, built in Python, and it's the fourth rebuild of a project I started from scratch after realizing the earlier versions weren't actually secure.

What it does

ATLOCK has five modules:

Lockdown — a system-level screen lock with a countdown timer (10 min to 8 hrs), designed for "step away from the laptop" moments.
File Guard — this is the core feature. It locks files at the Windows NTFS ACL level, not with a password wrapper. It literally rewrites the file's access control list so it's denied to every user, including SYSTEM if configured that way. Windows itself refuses to open the file — there's no password to crack because the OS is doing the blocking, not the app.
Password Vault — an encrypted store for emails, UPI IDs, and PINs.
Intruder Ops — if someone gets your master password wrong, the app silently takes a photo on the first wrong attempt, and after repeated failures, records a 10-second video — saved straight to your gallery, no cloud, no third party.
Settings — capture toggles and gallery folder control.
The security decisions that actually matter

A few things I rebuilt from earlier versions because they weren't good enough:

The vault used to store secrets with basic XOR "encryption," which is not encryption. v4 replaced it with Fernet (AES-128-CBC + HMAC).
The master password is derived using PBKDF2-HMAC-SHA256 with 200,000 iterations and a random salt per vault — slow by design, so brute-forcing it is expensive.
Every failed intruder attempt gets masked before it's ever logged, so nothing sensitive sits in plaintext on disk.
Alert credentials are stored encrypted with a machine-bound key, so copying the config file elsewhere doesn't help an attacker.

None of this is exotic cryptography — it's standard, well-reviewed primitives used correctly, which honestly matters more than anything clever.

Stack

Built with customtkinter for the UI (dark/gold theme, shown below), cryptography for Fernet/PBKDF2, pywin32 for the NTFS ACL manipulation, and opencv-python for the intruder camera capture. Packaged into a standalone .exe with PyInstaller.

Why this exists

I'm 13, this is a solo project, zero funding, and it's already been through four full rebuilds because "good enough" kept turning out to not be good enough. Akhouri Systems — the company behind it — exists on the idea that a lot of everyday software stopped getting properly maintained, and small teams (or one very stubborn person) can still fix that.

If you're on Windows and want file security that doesn't rely on security-through-obscurity, give it a look:

👉 https://akhouri-anmol-kumar.github.io/Akhouri-systems/
👉 https://github.com/Akhouri-Anmol-Kumar/ATLOCK

Feedback, bug reports, and brutal honesty are all welcome — that's genuinely how the last three rebuilds happened.

"We build what others forgot to fix." — Akhouri Systems

August 31, 2026: Where Akhouri Systems Stands Today

Akhouri Anmol Kumar — Mon, 31 Aug 2026 10:42:20 +0000

August 31, 2026: Where Akhouri Systems Stands Today

For those who don't know what Akhouri Systems is —

Akhouri Systems is a company currently run by Akhouri Anmol Kumar. We build apps aimed at fixing the problems that other apps have stopped caring about. In simple words: the big giants got lazy, so we're here to make them active again.

To some people — like my mother — Akhouri Systems is the biggest joke they've ever heard. To some people — like my father — I'm a nalayak beta (a "useless, worthless, good-for-nothing son" — look it up if you want the full weight of it), and Akhouri Systems is just my stupidity.

But I'm proud to say that outside of these people, 100+ strangers and individuals have shown genuine interest in the company. They motivated me. They suggested improvements. They gave me tips. They did the opposite of what I heard at home.

Where things stand, as of today

671 — reached in under 3 months, on a budget of ₹0
Supported by 100+ individuals, several of them well-known in their fields
Listed on almost all major startup and product directories
Indexed on Google
Recognized by The Better India
Global reach across Mexico, Mozambique, Pakistan, Bangladesh, the United States, Poland, Finland, Italy, Ukraine, Uzbekistan, Taiwan, the Philippines, and China
99+ smaller milestones I haven't even had time to write about

And here's the part people usually don't believe:

I am 13 years old.

Thirteen. Zero budget. Zero financial support. Zero emotional support. One laptop. That's the entire operation.

What this name means to me

Akhouri Systems might look small right now — and honestly, it is. I'm not going to pretend otherwise. But small doesn't mean weak. What's behind this name — the dedication, the spirit, the mental strength, the fire, the sheer stubbornness — is bigger than most people would guess just by looking at the numbers.

"Akhouri Systems" might read like just another company name to most people. To me, it's an identity. It's the thing I remind myself of every time a voice in my head — sometimes borrowed from someone else's voice — asks, "Are you really just a nalayak beta?"

And every time, I answer myself the same way: at 13, I'm running a company. Whoever taught someone that word, taught it to the wrong kid.

About today

I used to think August 31st would be the day I'd look forward to every year — my birthday, my happiest day. It wasn't. It was just another ordinary day. If anything, this was the day a "nalayak beta" was born, or so I was told.

But I still have something to prove. Not to the world — to the people who called me useless, directly, to my face. I have to prove it, even if the only way I can do that right now is by showing up and building, one day at a time.

Akhouri Systems needs connections. hope you all will join with akhouri systems.

I hope you'll be with Akhouri Systems as it grows.

🔗https://github.com/Akhouri-Anmol-Kumar
🔗https://akhouri-anmol-kumar.github.io/Akhouri-systems/

AKHOURI SYSTEMS

"We build what others forgot to fix."

EGO. That's What Akhouri Systems Is Really About.

Akhouri Anmol Kumar — Sun, 30 Aug 2026 05:14:40 +0000

I'm Akhouri Anmol Kumar. Founder and developer of Akhouri Systems.

And I need to say something that most people won't say out loud: this isn't just a software company built by a kid with a laptop and too many ideas. This is about EGO. The kind of ego that refuses to accept "that's impossible" as a final answer.

The Goal Nobody Believes In

I'm building Akhouri Systems to become the world's biggest software manufacturer — a direct competitor to Microsoft's default Windows apps. Not a clone. Not a tribute. A competitor.

Say that out loud to most people and you'll get a laugh, a pat on the back, or a "that's cute, kid." I've heard all three. Probably more times than I can count. Also my mother even said this is the biggest joke, Akhouri systems is the biggest joke.
my father who believes I am not serious, in fact till today 3months gone, akhouri systems crossed 670 downloads still he is not even supporting motivationally. While I need financial support from him but he says you're "NALAYAK BETA"(when I tried to force him to support me he said this 2 words)

Here's the thing — they might be right. The odds are brutal. I'm standing mostly alone, with no giant team, no massive funding, no safety net. Just code, conviction, and a stubborn refusal to quit.

Plan A: Legend. Plan B: Still a Legend.

So here's my actual bet, laid out with zero sugarcoating:

If I win — Akhouri Systems becomes a name people mention in the same breath as Microsoft, Apple, Google. A software giant that started from nothing.

If I don't — I will still push Akhouri Systems to a point where Microsoft itself looks at what we built and takes inspiration from it. Where our apps quietly influence how the giants build theirs.

Because here's the truth I hold onto on the hard days:

If Akhouri Systems fails — maybe one Akhouri Systems failed. But another will rise.

This isn't about one shot. It's about a mindset that doesn't die even if the company does.

Why I'm Telling You This

Because somewhere out there, someone else is sitting alone at 2 AM, staring at a terminal, wondering if their "impossible" dream is worth the grind. If that's you — this is your sign. Ego, used right, isn't arrogance. It's the fuel that keeps you writing code when nobody's watching and nobody believes.

I'm not asking you to believe in Akhouri Systems yet. I'm asking you to watch. Every commit, every release, every small win is public. Come see it for yourself:

👉 https://github.com/Akhouri-Anmol-Kumar

Star it, fork it, follow it, critique it — I'll take all of it. What I won't take is silence. Silence is the only real competitor I'm afraid of.

Final Word

Microsoft didn't start as Microsoft. Every giant started as one person's stubborn ego refusing to accept "no."

Mine says Akhouri Systems becomes the next name on that list — or dies trying, loud enough that the giants notice.

Let's build.

— Akhouri Anmol Kumar Founder & Developer, Akhouri Systems GitHub →
https://github.com/Akhouri-Anmol-Kumar

If this resonated, drop a comment. If you're building something alone against the odds too — I want to hear about it

AKHOURISYSTEMS

"we build what others forgot to fix"

I Built a Free, All-in-One Image Tool Because I Was Tired of Ad-Ridden Web Converters

Akhouri Anmol Kumar — Sat, 29 Aug 2026 05:16:48 +0000

The problem

If you've ever needed to quickly edit, convert, or compress an image, you know the drill: open a website, dodge three ads, upload your file, wait, download, and hope it didn't watermark your output or cap you at "3 free conversions per day."

I hit this wall one too many times while batch-processing images for a project, so I built APIC — Advanced Image Processing Center — a free, local-first desktop app that handles the whole workflow.

What it does
Edit — quick image adjustments, no bloated interface
Convert — switch between formats instantly
Compress — reduce file size while preserving quality
Search — locate images in your library fast
Batch Processing — apply operations across many files at once

Everything runs locally. No uploads, no cloud processing, no accounts.

The stack

APIC is built with Python 3 and PyQt6. A few architecture decisions worth mentioning:

Modular mode system — Home, Edit, Convert, Compress, and Search are each self-contained modules (modules/edit_mode.py, modules/convert_mode.py, etc.), swapped in and out via a QStackedWidget. This kept the codebase easy to extend — adding a new mode is mostly "build the widget, register it, add a nav button."

python
from modules.edit_mode import EditMode
from modules.convert_mode import ConvertMode
from modules.compress_mode import CompressMode
from modules.search_mode import SearchMode, AboutScreen

Custom sidebar navigation — a hand-built Sidebar class with active-state highlighting, rather than relying on Qt's default tab widgets, to get a more native, opinionated UI feel.

Global keyboard shortcuts and drag-and-drop — wired at the QMainWindow level so file handling feels consistent no matter which mode you're in.

Custom dark theme — a full stylesheet (themes/dark_theme.py) rather than default Qt styling, because default PyQt apps tend to look like they escaped from 2011.

Why PyQt6 over Electron

I wanted something that launches fast, feels native, and doesn't ship a bundled Chromium instance for what is fundamentally a desktop utility app. PyQt6 gave me native performance with enough flexibility to build a custom look without fighting the framework.

Try it

APIC is free, requires no sign-up, and doesn't send your images anywhere — everything happens on your machine.

📥 Download: https://github.com/Akhouri-Anmol-Kumar/APIC

I built this solo under my dev label, Akhouri Systems, and I'm actively iterating on it. If you're a Python/PyQt dev, I'd genuinely love feedback on the architecture — and if you just need a decent free image tool, I hope it saves you the four-tabs-of-ads experience I was dealing with.

Bug reports, feature requests, and brutal code reviews all welcome in the comments 🙏

APIC

"We Build What Others Forgot To Fix"

What Does “Protection” Mean in the Digital World? 🔒

Akhouri Anmol Kumar — Fri, 28 Aug 2026 05:30:31 +0000

Raksha Bandhan is about protecting the people who matter to us.

But our digital lives contain things worth protecting too:

🔑 Passwords
📁 Personal files
💻 Our devices
🔒 Our privacy

That's one of the ideas behind ATLOCK v4, the Windows security suite I've been building.

This Raksha Bandhan, I wanted to connect something deeply personal with something increasingly important:

physical protection → digital protection.

ATLOCK v4 brings together local password protection, NTFS/ACL-based file protection, system lockdown, intrusion-response features, and security notifications in a portable Windows application.

Protect what matters — wherever it exists.

🚀 Try ATLOCK v4: [https://github.com/Akhouri-Anmol-Kumar/ATLOCK]

Happy Raksha Bandhan! 🪢❤️

ATLOCK

"We Build What Others Forgot To Fix"

APIC — The Desktop Image Toolkit I Wish Existed Before I Built It

Akhouri Anmol Kumar — Thu, 27 Aug 2026 04:42:37 +0000

🖼️ Meet APIC — Advanced Image Processing Center

Tired of opening five different tools just to edit, convert, compress, and organize your images? So was I. That's why I built APIC — a single, fast, dark-themed desktop app that handles your entire image workflow without leaving one window.

No cloud uploads. No subscriptions. No watching your photos get compressed on someone else's server. Just a native app that works.

⚡ Why APIC?

Most image tools make you pick one lane: an editor or a converter or a compressor. APIC puts all of it behind one clean sidebar, so your workflow stays in one place:

✎ Edit — quick, no-fuss image editing
⇄ Convert — jump between PNG, JPG, WEBP, BMP, TIFF, GIF, ICO, HEIC, AVIF and more
⬇ Compress — shrink file sizes without wrecking quality
⌕ Search — find and manage your images fast
Batch Processing — do it once, apply it to a whole folder

Drag a single image in and APIC jumps straight to editing. Drop in a batch of files and it routes you straight to conversion. It's built to guess what you're trying to do — so you don't have to click around looking for the right mode.

🎨 Built for Focus

APIC ships with a clean, minimal dark UI designed to stay out of your way — no clutter, no ads, no "upgrade to pro" popups blocking your canvas. Just your images and the tools to work on them.

Home → Edit → Convert → Compress → Search

One sidebar. Five modes. Zero context-switching.

🛠️ Under the Hood

APIC is built with:

Python + PyQt6 for a native, responsive desktop experience
A modular architecture — each mode (edit_mode, convert_mode, compress_mode, search_mode) is its own self-contained unit
Full drag-and-drop support at the app level
Support for a wide range of formats: PNG · JPG · JPEG · WEBP · BMP · TIFF · GIF · ICO · HEIC · AVIF
Packaged as a single-file executable via PyInstaller — download and run, no installs, no dependencies to fight with
📦 Who Is This For?
Developers who need a quick local image converter without spinning up a script every time
Designers who want fast compression before shipping assets
Anyone who's sick of uploading personal photos to random "free online converter" sites
🚀 What's Next

This is v1.0.0 — the core workflow (Edit → Convert → Compress → Search) is live and stable, with batch processing baked in from day one. Roadmap items on the table: more export presets, plugin support, and expanded batch automation.

👨‍💻 About the Developer

APIC is An Akhouri Systems Product, built by Akhouri Anmol Kumar, an Indian software developer.

If you try it out, I'd genuinely love to hear what you think — bugs, feature requests, or just "this saved me time" are all welcome. Drop a comment below or reach out!

If you found this useful, a ❤️ or 🦄 helps more devs discover APIC. Thanks for reading!

🖼️ I Built APIC Around One Question: “Why Is This Still So Many Steps?”

Akhouri Anmol Kumar — Wed, 26 Aug 2026 05:05:39 +0000

Some software problems are technically difficult.

Others are just annoying.

Image processing often falls into the second category.

You want to convert an image.

Open a tool.

You want to compress it.

Find another.

You need to edit something.

Open another application.

Eventually, a 20-second task becomes a 5-minute workflow.

That frustration is what led me to build APIC — Advanced Image Processing Center.

One workspace for the boring stuff

APIC is a Windows desktop application focused on everyday image workflows:

🖼️ Image editing
🔄 Format conversion
📦 Image compression
🔍 Image search
🖱️ Drag & Drop
⌨️ Keyboard shortcuts
🌙 Modern dark interface

It supports formats including PNG, JPG, JPEG, WEBP, BMP, TIFF, GIF, ICO, HEIC and AVIF.

The interesting part isn't the buttons

The challenge wasn't creating another “Convert” button.

It was making the application understand what the user is trying to do.

For example, a single image can naturally lead into an editing workflow, while multiple images can indicate a batch-processing workflow.

That led me toward a more modular architecture where the major workflows remain separated instead of becoming one enormous application component.

🔒 Why local processing?

For many everyday image tasks, sending an image to a remote server isn't necessary.

APIC is designed around local processing, so the computer you're using performs the work.

That makes the workflow useful even when you don't want your images going through another service.

🎯 What APIC is actually trying to achieve

I'm not trying to compete with professional graphics suites.

The goal is much narrower:

Make everyday image processing less annoying.

If a task takes three different applications today, I'd rather make it one.

If it takes ten clicks, I'd rather make it five.

If there's unnecessary friction, remove it.

That's the product philosophy behind APIC.

🚀 Give it a real test

I've released a ready-to-run Windows build.

Download APIC:
https://github.com/Akhouri-Anmol-Kumar/APIC/releases/download/APIC/APIC.zip

Download → Extract → Run.

Don't just open it and look around.

Give it an actual image task you normally hate doing.

Then tell me whether APIC made it easier—or where it failed.

That's the feedback I'm looking for.

APIC

"We Build What Others Forgot To Fix"

🧩 The Problem Wasn't Image Editing. It Was Everything Around It.

Akhouri Anmol Kumar — Tue, 25 Aug 2026 04:59:43 +0000

Here's a stupidly familiar workflow:

Someone sends you an image.

You download it.

Then you realize it's the wrong format.

So you open a converter.

Then the file is too large.

So you open a compressor.

Then you notice the image needs a few adjustments.

Now you're opening an editor.

Then you need to resize it.

Another tool.

At some point you're sitting there thinking:

“Bro… I'm just trying to process one image.” 💀

That annoyance is what eventually turned into APIC.

🛠️ I Didn't Start With “Let's Build An Image Editor”

I started with a much more boring question:

How many tools do I actually need to touch to finish one image?

The answer was… annoyingly high.

So instead of building another giant editor trying to compete with professional creative software, I went in the opposite direction.

Take the repetitive image operations.

Put them together.

Make the workflow stupidly straightforward.

That's APIC.

🧠 Think Of APIC As An Image Workbench

Not a Photoshop replacement.

Not a website full of random online utilities.

More like a workbench sitting on your Windows machine.

You bring an image in.

Then you decide what needs to happen to it.

             IMAGE
               │
      ┌────────┴────────┐
      ↓                 ↓
   MODIFY              PREPARE
      │                 │
 ┌────┼────┐        ┌───┴────┐
 ↓    ↓    ↓        ↓        ↓

EDIT FILTER RESIZE CONVERT COMPRESS
│ │ │ │ │
└────┴────┴────────┴────────┘
↓
OUTPUT

The interesting part isn't any individual button.

It's the distance between the buttons.

🐕 Here's What That Looks Like In Reality

I took a normal image.

Nothing special.

Then started messing with it.

Brightness.

↓

Contrast.

↓

Shadows / highlights.

↓

Filter.

↓

Resize.

And suddenly the image is ready for whatever comes next.

No:

“Wait, which website did I use for this last time?”

No:

“Where's that converter?”

No:

“Which compressor doesn't destroy the image?”

Just the same application sitting there.

🔐 THEN I ASKED ANOTHER QUESTION
Why should a simple image operation require uploading the image somewhere?

That's where APIC's local workflow matters.

Your image is your data.

For the local processing workflow:

YOUR IMAGE
│
↓
APIC
│
↓
YOUR OUTPUT

Not:

YOUR IMAGE
↓
UPLOAD
↓
SERVER
↓
PROCESS
↓
DOWNLOAD

That distinction matters — especially when the image isn't something you want casually uploading to a random service.

⚙️ UNDER THE HOOD, THE PRODUCT ISN'T TRYING TO BE EVERYTHING

That's intentional.

I don't want APIC to become:

“The Ultimate AI Blockchain Quantum Image Superplatform™” 😭

I'd rather it become really good at the boring stuff people repeatedly need.

That's a much more interesting engineering problem.

How fast can the workflow be?

How clean can the UI stay?

How predictable should the output be?

How many unnecessary steps can disappear?

Those are the things I'm interested in.

🖥️ AND YES — IT'S A REAL WINDOWS APP

The demo below isn't a Figma prototype.

It's not a landing-page animation.

It's the actual APIC application running on Windows.

You can see the workflow happen in real time:

Open → Process → Modify → Convert → Output

And that's honestly the part I'm most proud of.

Because software stops being an idea the moment somebody can actually use it.

🚧 APIC ISN'T “FINISHED”

And I'm not going to pretend it is.

There are still things I want to improve.

Better workflows.

More processing options.

Performance improvements.

UI refinements.

More automation.

Maybe some completely different ideas later.

But that's the fun part.

APIC is being built in public, one version at a time.

🇮🇳 BUILT BY AKHOURI SYSTEMS

APIC is an Akhouri Systems project.

The goal isn't to make the loudest image-processing application on the internet.

It's to make one that quietly becomes the application you open when you think:

“I just need to fix this image.”

And then you're done.

🎥 Here's APIC.

No concept art.

No fake UI.

Just the actual application.

👇

APIC — Advanced Image Processing Center

🌐 https://github.com/Akhouri-Anmol-Kumar/APIC

💭 Now I'm curious:

What's the one annoying image task you still use a completely separate tool for?

Maybe that's the next thing APIC should solve. 👀

I built a full image editor that never uploads your photo — here's how the on-device AI parts actually work

Akhouri Anmol Kumar — Mon, 24 Aug 2026 04:14:07 +0000

Most background-removal and object-removal tools online work the same way: you upload an image, a server runs a model on it, you download the result. Convenient, but your photo left your device and you have no idea what happened to that copy afterward.

I wanted to see how far I could push the "everything stays client-side" constraint for a full image editor — background removal, object removal, filters, format conversion, compression — using only what a browser can do natively: Canvas, WebAssembly, and an on-device ML model. This is APIC-Web, and here's what I learned building the two hardest parts.

Background removal: category masks vs. confidence masks

The obvious approach is MediaPipe's ImageSegmenter with outputCategoryMask: true — it hands you a hard 0/1 label per pixel (background or foreground). It works, but the output has a visible jagged, stair-stepped edge around hair and shoulders. There's no way to fix that after the fact with a blur, because the information needed to know how much a boundary pixel belongs to the foreground is already gone — it got rounded to a hard integer.

The fix is outputConfidenceMasks: true instead, which returns a float 0–1 probability per pixel before it gets thresholded. That single change unlocks a proper edge pipeline:

js
// 1. Smoothstep contrast — push clear foreground/background toward pure
// opaque/transparent while keeping the ~0.5 transition band soft
const s = v * v * (3 - 2 * v);

// 2. Erode ~1px inward — kills background-colour fringing around hair
// (a min-filter over a 3x3 neighbourhood)

// 3. Feather with a small separable box blur — turns the eroded edge
// into something smooth instead of jagged

Net effect: same underlying model, dramatically better-looking edges, because you're working with the mask's actual uncertainty instead of throwing it away too early.

One gotcha worth flagging for anyone doing the same thing: not every segmentation model outputs the same number of confidence channels. Some give you background, foreground, others give you a single foreground-probability channel. Don't hardcode confidenceMasks[1] — check the array length and handle both, and wrap model creation so a GPU delegate failure falls back to CPU instead of just dying.

Object removal without a generative model

Photo editors with "magic eraser" features (Photoshop's Generative Fill, Galaxy AI's object eraser) use trained diffusion models. That's not something you can ship for free in a static HTML page — no server, no GPU inference budget.

What is achievable client-side is exemplar-based texture synthesis — essentially the pre-AI generation of content-aware fill. The idea:

Take the painted (masked) region plus a padded area of real surrounding pixels
Break the hole into small blocks (8×8) and process them boundary-inward — the block with the most already-resolved neighbours goes first
For each block, search the surrounding valid texture for the patch that minimizes SSD against the parts of the target block that are already known
Copy those real pixels in — not an average, not a blur, an actual texture copy — which is what keeps the result sharp instead of smeared
js
for (let py = 0; py < bhei; py++) {
for (let px = 0; px < bwid; px++) {
const tIdx = (ty0 + py) * ww + (tx0 + px);
if (!validSrc[tIdx]) continue; // only compare known-good texture
const cIdx = (cy + py) * ww + (cx + px);
const dr = wd[tIdx*4] - wd[cIdx*4];
// ...accumulate squared error across candidate positions
}
}

The subtle bug I hit here: after background removal, transparent pixels still have leftover garbage RGB values sitting under alpha: 0 — they're just not painted, so a naive "is this pixel painted?" check treats them as valid source texture. The fix was splitting the concept into two separate arrays: isPainted (defines the hole) and validSrc (opaque and unpainted — the only pixels safe to copy from). Mixing those two concepts up is exactly how you get a random smear of background color pasted into your subject.

Performance-wise, brute-force patch search is O(hole_pixels × search_area), which gets ugly fast on a large image. Restricting the search to a padded bounding box around the mask (not the whole image) and adaptively adjusting the candidate sampling stride based on hole size keeps this bounded — typical fills run in well under a second.

Takeaways
If your segmentation output has visible jagged edges, you're probably throwing away confidence information too early — switch to soft masks and add erosion + feather.
You don't need a trained model to get decent object removal; exemplar-based patch matching gets you most of the way for everyday use cases (skin, sky, fabric, walls), it's just an older, well-understood technique.
When you're compositing filled/generated pixels back into a photo that's already been alpha-masked, be explicit about what counts as "safe to sample from" — transparency and "not edited" are not the same thing, and conflating them is a real bug, not a hypothetical one.

APIC-Web is live and free if you want to see the result:
https://akhouri-anmol-kumar.github.io/APIC-web/
Feedback — especially edge cases that break it — genuinely welcome.

APIC

"We Build What Others Forgot To Fix"

I Wanted to Process One Image. Somehow I Ended Up Building APIC.

Akhouri Anmol Kumar — Sun, 23 Aug 2026 14:40:08 +0000

It started with a stupidly simple problem.

I had an image.

I needed to process it.

That's it.

But somehow the workflow became:

Open tool → convert → find another tool → compress → open another tool → edit → close everything.

At some point I thought:

Why am I using a toolbox just to process one image?

So I built my own.

Meet APIC 🖼️

APIC — Advanced Image Processing Center is a Windows desktop application built around one idea:

Give me the image. I'll handle the boring stuff.

Instead of jumping between applications, APIC puts common image workflows into one workspace.

The boring stuff APIC handles

🖼️ Edit
🔄 Convert
📦 Compress
🔍 Search
🖱️ Drag & Drop
⌨️ Keyboard workflows

It supports formats including PNG, JPG, JPEG, WEBP, BMP, TIFF, GIF, ICO, HEIC and AVIF.

But the features weren't actually the hardest part.

The real problem was architecture.

Adding another button is easy.

Adding another workflow without breaking three existing workflows?

Not so easy. 😅

That's why APIC evolved into a modular application where different parts of the system handle different responsibilities.

The result is a desktop tool that can keep growing without every new feature becoming a potential disaster.

🔒 Why local?

Because an image-processing application doesn't always need your images going somewhere else.

APIC is designed around local processing, keeping the workflow on your machine.

No uploading an image just to perform a basic operation.

⚡ The end goal

I don't want APIC to become another gigantic piece of software with 500 buttons nobody uses.

I want it to do something much simpler:

Take the annoying image task out of your way.

Open APIC.

Drop your image.

Do the thing.

Move on.

🧪 Want to test that idea?

I've released the current Windows build.

Download APIC:
https://github.com/Akhouri-Anmol-Kumar/APIC/releases/download/APIC/APIC.zip

Extract it and run it.

Then give it your most annoying image-processing task.

If APIC handles it well, tell me what you did.

If it doesn't, tell me what broke.

Both answers are useful. 👇

APIC

"We Build What Others Forgot To Fix"