What if image editing, format conversion, compression, and image search didn't require juggling multiple websites and applications?
That question is part of what led me to build APIC — Advanced Image Processing Center, an image-processing desktop application developed under Akhouri Systems.
And no, this isn't another article that just says, “I built an app, please download it.”
Let's look at the actual application architecture, the UI design, the workflow decisions, and why I'd like developers to put APIC through its paces.
⚡ First, what is APIC?
APIC is a desktop application built with Python and PyQt6. Its goal is to bring several image-related workflows into a single desktop interface.
Instead of jumping between separate tools, APIC organizes its functionality into dedicated workspaces.
🧰 Meet the six workspaces
| Workspace | Purpose |
|---|---|
| 🏠 Home | Starting point for opening images and accessing workflows |
| ✏️ Edit | Image-editing workspace |
| 🔄 Convert | Image conversion workflow |
| 📦 Compress | Image compression workflow |
| 🔎 Search | Dedicated image-search workspace |
| ℹ️ About | Application information and product details |
The idea is simple: one application, separate workflows, consistent navigation.
You don't need to learn an entirely different interface every time you switch tasks.
🧠 Under the hood: How APIC is structured
Here's where things get interesting from a development perspective.
APIC isn't built as one enormous window with every feature crammed into it. Its main window coordinates separate screens and switches between them.
The application uses Python with PyQt6, including QMainWindow, QStackedWidget, layouts, buttons, signals, and slots.
The high-level structure looks like this:
APIC
│
├── Main Window
│ ├── Sidebar Navigation
│ ├── Stacked Content Area
│ └── Status Bar
│
├── Home Screen
├── Edit Mode
├── Convert Mode
├── Compress Mode
├── Search Mode
└── About Screen
The main window creates the individual screens and registers them in a dictionary. The QStackedWidget holds those screens, while the sidebar tells the application which screen to display.
For example, the navigation logic follows this pattern:
def _navigate(self, key: str):
if key not in self._screens:
return
self._current_mode = key
self.stack.setCurrentWidget(
self._screens[key]
)
self.sidebar.set_active(key)
Why is this useful?
- Separation of concerns: Each workspace has its own module.
- Centralized navigation: The main window controls screen switching.
- Maintainability: Changes to one workspace can often be isolated from the others.
- Consistent UI: The sidebar and status bar remain part of the main application shell.
This is a practical example of organizing a desktop application into manageable components rather than letting the main window become responsible for everything.
Of course, modularity alone doesn't guarantee good software. Each module still needs proper error handling, testing, and clear interfaces.
But it's a useful architectural foundation.
🔀 One interesting design decision: File routing
Opening an image sounds trivial until an application needs to decide what to do with one file versus several.
APIC handles these cases differently.
Open one image: The application records the file in its recent-file list, loads it into Edit Mode, and navigates to that workspace.
Open multiple images: The selected paths are added to Convert Mode, and the application switches to the converter.
Here's the simplified decision:
if len(paths) == 1:
self.home_screen.add_recent_file(paths[0])
self.edit_mode.load_image(paths[0])
self._navigate("edit")
else:
for path in paths:
self.convert_mode.add_file(path)
self._navigate("convert")
This is a small piece of code, but it demonstrates an important UX principle:
The application should respond to the user's workflow, not force the user to navigate manually after every action.
A developer building a media manager, document utility, or batch-processing application could apply the same pattern.
⌨️ Keyboard shortcuts aren't an afterthought
A desktop application should work well for mouse users and keyboard-oriented users.
APIC includes global shortcuts for opening files and navigating between workspaces.
| Shortcut | Action |
|---|---|
Ctrl + O |
Open images |
Ctrl + 1 |
Home |
Ctrl + 2 |
Edit |
Ctrl + 3 |
Convert |
Ctrl + 4 |
Compress |
Ctrl + 5 |
Search |
F1 |
About |
These shortcuts are implemented using PyQt6's QShortcut and QKeySequence.
For example:
shortcuts = {
"Ctrl+O": self._global_open,
"Ctrl+1": lambda: self._navigate("home"),
"Ctrl+2": lambda: self._navigate("edit"),
"Ctrl+3": lambda: self._navigate("convert"),
"Ctrl+4": lambda: self._navigate("compress"),
"Ctrl+5": lambda: self._navigate("search"),
"F1": lambda: self._navigate("about"),
}
Notice that navigation shortcuts reuse the same navigation function as the sidebar.
That means both input methods follow the same screen-switching logic instead of implementing separate navigation behavior.
It's a small detail, but small details accumulate into a more consistent application.
🖱️ Drag, drop, and supported formats
APIC also supports opening images through drag-and-drop.
The main window checks whether the incoming event contains URLs, accepts the proposed drop action, and extracts local file paths when the files are dropped.
The code filters the dropped files using their extensions.
The supported extensions include:
PNG · JPG · JPEG · WEBP · BMP · TIFF · TIF · GIF · ICO · HEIC · AVIF
The file dialog uses a corresponding image-file filter.
One technical distinction worth understanding: accepting a file extension doesn't automatically guarantee that every image encoded in that format can be decoded on every machine. Actual support depends on the image-loading and processing implementation and its available codecs.
That's precisely the kind of thing I'd like testers to investigate.
🎨 The interface matters, too
A utility can be technically functional and still be frustrating to use.
APIC uses a dedicated sidebar, a stacked content area, a dark-theme stylesheet, and a status bar. The sidebar separates navigation from the workspace itself, allowing the active task to occupy the main content area.
The application also connects status-message signals from its workspaces to the main window's status bar.
In practical terms, that gives individual workspaces a way to communicate status information without requiring each one to manage the main window's status bar independently.
The result is a desktop-oriented structure rather than a website wrapped inside an application window.
And yes, there's still room to improve it. That's why real-world feedback matters.
🧪 Here's where you come in: Test APIC
I don't want you to download APIC, open it once, and forget about it.
I want developers, students, designers, and people who work with images to actually try it.
If you decide to test APIC, here are a few useful experiments:
- Open a single image and inspect the Edit workflow.
- Select multiple images and inspect how the application routes them to Convert Mode.
- Try the keyboard shortcuts instead of clicking the sidebar.
- Test drag-and-drop with different supported image formats.
- Check how the application responds to invalid paths, unreadable files, or unusual image dimensions.
- Look for interface inconsistencies, unexpected behavior, and workflow friction.
- If you encounter a bug, report the steps needed to reproduce it.
Please don't assume that every feature is flawless just because it has a dedicated screen. The real question is how reliably each workflow behaves under actual use.
Useful bug reports are more valuable than vague feedback.
If something breaks, tell me what you did, what you expected, and what actually happened.
📥 Ready to try APIC?
You can get the application here:
👉 DOWNLOAD APIC — Advanced Image Processing Center
Want to inspect the project first?
Explore the APIC source repository on GitHub
Download the application, explore its workspaces, and see how it fits your workflow.
If you're a Python developer, I'd especially like to hear your thoughts on the PyQt6 architecture, navigation design, file handling, and areas that need improvement.
👨💻 A little about the developer
I'm Akhouri Anmol Kumar, founder of Akhouri Systems.
I build software with a focus on practical desktop utilities, straightforward workflows, and applications that people can actually use.
APIC is one of those projects: take a common category of work, organize it into a coherent interface, and keep improving it through real usage and feedback.
I'm still learning, building, testing, and refining.
And I believe independent software becomes more useful when developers invite people to examine it critically instead of treating every release as a finished masterpiece.
💬 Let's talk image-processing workflows
I have three questions for developers and people who work with images:
- Which image-processing tasks do you perform most often: editing, converting, compressing, or something else?
- What's one feature you wish more desktop image tools offered?
- If you try APIC, what's the first thing you'd improve?
Drop your thoughts in the comments. If you find a reproducible bug, please include the steps.
Try it. Explore it. Challenge it. Help me make it better.
If APIC proves useful in your workflow, a GitHub star or a share with another developer would also help the project reach more people.
Thanks for reading. 🚀
Top comments (2)
if you don't want to install APIC in your desktop then try more advanced version of APIC right in your browser
APIC Web: akhouri-anmol-kumar.github.io/APIC...
Some comments may only be visible to logged-in visitors. Sign in to view all comments.