Hello, Hackernoon!
This is the story of how we built MultiDrive — a high-speed disk management toolkit for Windows — here at Atola Technology. It began as a small idea and turned into a full-featured application. I’d like to show you what the process looked like from the inside — the challenges we faced and the decisions we had to make along the way.
Regardless of your experience in programming, this article will be an interesting adventure for you, so let’s get started!
Introduction
In 2025, as technology evolves faster than ever, with new frameworks, libraries, and powerful AI tools emerging every day — writing software has become easier, but building quality software is still a challenge. Many tech giants are ready to invest millions in hiring top talent to create products that are smooth and enjoyable to use. Yet, technical debt continues to grow, bugs keep slipping through, and never-ending hotfixes are the standard.
In my career as a software engineer, I had the chance to work at a product company that proved something important: to build a truly great product, you need to be involved, curious, and know that your ideas and contributions matter. That company is Atola Technology — a team that creates cutting-edge tools for digital forensics and data recovery, trusted by law enforcement, government agencies, and forensic labs in more than 90 countries.
Our team has created many trusted tools for disk imaging used by professionals around the world. But these are advanced and often expensive systems, not designed for everyday tasks like backing up a disk.
These days, most software tries to avoid hardware dependencies as much as possible. That became one of our key ideas when developing MultiDrive. The program takes up little disk space (~150 MB), doesn’t require any special hardware, and works right out of the box with no setup. It’s fast, intuitive, and user-friendly — this became the core philosophy of the project.
Market Overview
Before diving into what makes MultiDrive unique, it helps to see why a simple, reliable disk tool is needed in the first place.
Here’s a common scenario many users face:
- Clone your drive when upgrading your system (hello SSD!)
- Back up your entire drive to keep important files safe
- Securely erase your old drive before reselling it
If you take a close look at what was already available on the market, you’ll find the most popular alternatives on Windows include Macrium Reflect, Acronis, AOMEI, EaseUS, Carbon Copy Cloner on Mac, and Clonezilla on Linux.
None of them are easy to use and 100% free to provide clone, erase, backup / restore tasks for your drives. According to widespread feedback online, people need something that just works, without payments, subscriptions, ads, or artificial limitations.
MultiDrive sets itself apart by being truly free for core disk tasks, offering an ad-free experience, a modern UI, and parallel operations right out of the box.
Development
Early development started in spring 2022 with a team comprising five software engineers, including myself as the lead, six quality assurance engineers, and one product manager.
Our goal wasn’t just to build a functional prototype, we aimed for a Minimum Lovable Product. In today’s world, there are countless MVPs, and most of them look and feel the same. We wanted to stand out by delivering something that users would actually enjoy using from day one. That meant focusing on quality, performance, and clean design, even in the very first version.
Desktop Framework
One of the first and most important decisions we had to make was choosing a framework for our desktop app. Since our whole team works with C# / .NET, we looked for options that fit that ecosystem.
At first, WPF (Windows Presentation Foundation) seemed like the natural choice. It’s a powerful and flexible UI system with many built-in components and excellent documentation. But there was a problem — WPF only works on Windows and doesn’t support other platforms, so it didn’t fit our future cross-platform goals. We also thought about using MAUI. However, back in early 2022, MAUI was still in preview and didn’t officially support Linux yet.
Then I suggested Avalonia Framework — an open-source, cross-platform UI toolkit for .NET that runs on Windows, Linux, and macOS. I had used Avalonia before during my previous projects, so I was confident it could work well. Avalonia also has a strong community and keeps getting better every day. That’s why we chose it as the base for our app.
Additional Tools
For storing data, we chose LiteDB — a lightweight, embedded NoSQL database that fits perfectly into desktop apps. It stores data in a single local file, which makes it easy to manage and deploy. We use it to save task metadata like file paths, progress, timestamps, and statuses. This allows users to resume backups exactly where they left off and to browse their task history instantly, without any delays or complex setups.
To make sure everything works reliably across different setups, we wrote a lot of unit tests using NUnit. It helped us quickly catch bugs and keep the core logic solid as new features were added. For UI testing, we used FlaUI — a powerful tool for simulating real user actions like clicking buttons and navigating the app. This allowed us to automate full end-to-end scenarios and ensure that the user interface behaves as expected after each update.
For the command-line version of MultiDrive, we used Spectre.Console, that helps build rich, interactive CLI apps with great user experience. It allowed us to create a clean interface with colored output, tables, progress bars, prompts, and better error messages.
Architecture
After choosing the tech stack, we moved on to planning the architecture of our application. Our goal was to build a solid foundation for the app, so we could deliver updates quickly, adding new features and improving workflows with minimal effort.
MVVM Pattern
We followed the Model-View-ViewModel pattern, which splits the code into three parts: the Model for data and business logic, the View for UI layout and interaction, and the ViewModel as a bridge between them. MVVM is a widely used architectural pattern in .NET desktop development that makes maintenance, testing, and code reuse much simpler.
Avalonia makes it really easy to follow MVVM right from the start. You write your UI in XAML and simply bind controls to properties or commands in your ViewModel — something like Text="{Binding SelectedDiskName}" or Command="{Binding SaveCommand}". Under the hood, when a ViewModel property changes, Avalonia’s binding system automatically tells the UI to update, so you never have to write extra “update” code. This keeps your UI code neat, and lets designers tweak XAML layouts without touching the data logic.
Dependency Injection
To keep our architecture clean and flexible, we also added Dependency Injection early in the project. This means that instead of hardcoding dependencies directly in classes, we pass them in from the outside — usually through constructors. With DI, it becomes much easier to write unit tests, swap implementations (e.g. mock services for testing), and manage the app’s overall structure as it grows. Avalonia works well with popular .NET DI containers, so setting it up was straightforward.
Styling & Customization
Next, we immediately turned our focus to making the app look and feel great. We wanted to support both dark and light themes, use clean and modern components, and make everything easy to use and configure.
What I loved about working at Atola Technology is how productive our focus groups are. You can bring up an idea, discuss it quickly, and start implementing it — no long meetings or weeks of waiting. Most components were built from scratch so they’d fit together seamlessly design-wise and avoid the overhead (disk space, performance) of third-party libraries.
Avalonia Features
To add dynamic logic to XAML, we created many Markup Extensions — similar to directives in Angular or Tag Helpers in Blazor. These are powerful tools for extending the UI in a clean and flexible way.
Here’s how you can use this in XAML markup:
Another awesome feature of Avalonia is Style Selectors (CSS-like). They let you apply styles to UI elements based on their type, state, class, name, or position in the visual tree. This gives you a lot of control without writing code-behind.
Design Challenge
The hardest part of UI was building a smooth, animated graph to show real-time backup speed. It had to update frequently, show accurate values with proper averaging, and still look good — all without overloading the CPU or memory. We used the LiveCharts2 library as a base and put in a lot of custom work to fine-tune the smooth animation and data handling, making the graph both responsive and lightweight.
Raw Disk Access
Now we’re getting to the most important part — what actually happens behind the scenes of the user interface. At the core of our low-level disk interactions are direct WinAPI calls using P/Invoke.
This approach gives us fine-grained control over disks, from sending raw I/O commands to accessing device properties, all without relying on third-party wrappers. It also lets us work with disks at a level where we can manage partitions and read/write sectors.
We wanted full disk backups to be space-efficient, so we chose to store them as compressed ZIP files. It seemed like a simple solution — ZIP is widely supported and easy to work with. But early on, we ran into a problem: the standard Deflate compression method was too slow for large backups.
By default, Deflate runs in a single thread, which doesn’t take full advantage of modern multi-core processors. For big files, this became a serious bottleneck and backups took longer than we wanted. To fix this, we used minizip-ng and reworked the compression system to run in parallel. We split the data into chunks and compressed each chunk using separate threads. This allowed us to speed up the process significantly, without changing the final ZIP format.
Pause & Resume Challenge
Another challenge we faced was adding support for pause and resume during backups. We wanted users to have full control, to be able to stop a backup at any time and continue it later, even the next day, without starting over.
This might sound simple, but in practice, it meant carefully tracking progress, writing partial data safely, and making sure everything could pick up exactly where it left off. We had to design a system that was both reliable and fast, without adding unnecessary complexity for the user.
MultiDrive has many smart, hidden features that you will discover only during regular use. One of them is that it automatically scans for drives in the OS every 5 seconds. It’s not straightforward to implement since it must be aligned with the drives used in running tasks (no need to scan) or some other app pages with their required drive details. DeviceCacherService is one of the classes designed for that.
Testing
Once we had a working version of the app ready, we moved on to the testing phase. Our testing strategy involved multiple phases:
Internal Testing (6 months): Extensive testing across different hardware configurations, from legacy IDE HDDs to modern NVMe SSDs, various configurations, and different Windows desktop and server operating systems.
Closed Beta Program (2 month): We invited 48 selected users: tech professionals, system administrators, and data recovery specialists. This was very helpful as our testers used the software in real situations that we hadn’t thought of.
Key insights from beta testing:
- Users needed better visual feedback for long-running operations
- Bunch of UX issues were found and addressed
- Several I/O-related errors fixed due to wider variety of computers and drives
The beta program led to 7 major improvements and helped us identify and fix over 20 edge cases before a public release.
Key Features
Our main challenge was to find a balance between powerful functionality and ease of use. We have added the most necessary and commonly used features:
- Backup: Create backup of your entire drive or its part in either ZIP or RAW format. Ensure data integrity using hash.
- Clone: Create exact replicas of your drives. Ideal for upgrading to a better drive or creating bootable backups.
- Restore: Restore a full drive or its parts from RAW or ZIP backup file.
- Erase: Permanently wipe a full drive or its parts with a secure wiping method. Specify Hex pattern when needed.
- CLI: Automate disk operations with a powerful CLI. Perfect for system administrators and tech enthusiasts.
- Parallel Operations: Run multiple disk operations simultaneously to save time. Monitor progress from a single dashboard.
And if we ever introduce a Premium version in the future, rest assured that all the current functionality you rely on will stay free forever!
Release
MultiDrive was officially launched on April 14, 2025. On this unforgettable day, we finally took the leap.
We didn’t just launch a product. We launched a mission — to give people free tools to control their data. Whether you’re backing up precious memories, cloning drives in case of a server crash, or wiping old but sensitive files, MultiDrive is here to protect what matters most.
The app was warmly welcomed by the Avalonia Framework creators and added to the official showcase!
It didn’t take long to welcome our first 1,000 users — a clear sign that there was a real demand for a better solution. It all began with a simple idea — managing data should be easy, free, and safe. Since then, we’ve been building more than just software — we’ve been building trust.
About the Author
Oleg Dubovoi — a seasoned software engineer, open-source contributor, and IT content creator with hands-on experience in desktop development, cybersecurity, and real-time systems. Passionate about building clean, efficient software and sharing practical knowledge with the developer community.
Connect: LinkedIn | GitHub | Dev.to
