The starting point is familiar
MCopy is a personal Windows tool built around a familiar entry point: right-click, copy, and paste. The project asks how that interaction can lead into a queue-aware copy process with a dedicated progress view and controls, without asking the user to adopt a terminal workflow.
The goal is not to replace the gesture. It is to keep the gesture small while making the work behind it easier to follow. A GPUI window presents progress and the available actions while the copy orchestration runs separately from the interface.
The boundaries carry the complexity
The project separates four concerns: shell integration, clipboard state, copy orchestration, and UI. That split keeps Windows-facing behavior out of the progress view and keeps interface redraws out of the copy logic. It also gives pause, resume, and cancel requests a clear path through the system.
- A GPUI progress window designed to keep UI updates separate from queued copy work.
- Cooperative pause, resume, and cancel controls that take effect at safe points in the operation.
- A clean separation between shell integration, clipboard state, copy orchestration, and UI.
Control is part of the state model
Pause, resume, and cancel are not treated as buttons that directly interrupt arbitrary work. They are control requests observed by the copy process at safe points. The interface can therefore reflect a requested or changed state without owning the file operation itself.
This also makes the queue easier to reason about. Clipboard input, queue order, progress reporting, and user controls each have a distinct responsibility. The structure matters more than adding another command to the window.
Why Rust and GPUI
Queue-aware copying has to represent ownership and state changes clearly while file work and interface updates happen on separate paths. Rust provides the systems-programming foundation for that separation. GPUI provides the progress window and a place to render state without mixing view code into the copy orchestration.
The project does not use transfer size or speed as its proof point. Its focus is the shape of the workflow: a familiar shell action, an explicit queue, visible progress, and controls that cooperate with the operation.
What the work demonstrates
MCopy demonstrates how interaction design and systems structure can support the same goal. The visible action remains familiar; the internal boundaries make that simplicity possible. It is the same principle I use in interface work: reduce what the user has to learn, then make the underlying states explicit in the implementation.