The Problem That Started It All
A few years ago I found myself doing the same thing over and over: converting video and audio files on my Mac so they would play nicely in editors, browsers, or on devices that refused to cooperate with whatever codec I had thrown at them. I was tired of hunting for the right ffmpeg flags every time, so I did what any developer would do - I built a desktop app to handle it for me.
That first version was an Electron app. It worked. It solved my problem. But it also consumed an unreasonable amount of memory, shipped a bloated binary, and felt sluggish on a machine that should have breezed through simple media tasks. Every time I opened it I winced at the Activity Monitor numbers. Something had to change.
Honeymelon is that change.
What Honeymelon Actually Is
Honeymelon is a free, open-source media converter built exclusively for macOS on Apple Silicon. It wraps FFmpeg in a clean, native interface and makes one bet that pays off more often than you would expect: most conversions do not need re-encoding at all.
The core idea is called "remux-first." Before Honeymelon touches a single frame it probes your file, checks whether the existing streams are already compatible with the target container, and — if they are — simply repackages them without decoding or encoding. The result is a conversion that finishes in seconds instead of minutes, with zero quality loss.
When transcoding is genuinely required, Honeymelon leans on Apple VideoToolbox for hardware-accelerated H.264, HEVC, and ProRes encoding, and offers three quality tiers — Fast, Balanced, and High — so you can decide where you want to land on the speed-versus-quality spectrum.
Everything happens locally. There is no telemetry, no network traffic, no account to create. You drag files in, pick a preset, and get your output.
Why I Rebuilt From Scratch
The Electron version taught me two things. First, wrapping a full Chromium browser inside a desktop app carries a cost that is hard to justify for a utility that should feel lightweight. Second, user experience matters as much as functionality - if the tool feels heavy, people stop reaching for it even when it works.
I chose Tauri 2 with a Vue 3 frontend and a Rust backend for the rewrite. The difference was immediate:
- Application size dropped dramatically. The distributed DMG is a fraction of what the Electron build weighed.
- Memory usage fell to levels you would expect from a native macOS utility rather than a web browser pretending to be one.
- Startup time became nearly instant. The Rust backend initializes FFmpeg capability detection in the background while the UI renders.
- Responsiveness improved across the board. Tauri's IPC layer and Rust's async runtime handle concurrent FFmpeg processes without the overhead of a Node.js event loop marshalling everything through a single thread.
Choosing Rust for the backend was not just about performance. It brought real safety guarantees — no null pointer panics crashing your conversion mid-job, proper error propagation through typed Result values, and memory safety without a garbage collector pause interrupting progress events.
The Architecture: Probe, Plan, Execute
Under the hood, every conversion passes through three stages.
Stage 1 — Probe
Honeymelon invokes ffprobe to extract detailed metadata from the input file: codecs, container format, duration, resolution, frame rate, color primaries, transfer characteristics, and subtitle types. This data feeds directly into the planning stage.
Stage 2 — Plan
A pure TypeScript planning engine evaluates the probe results against the selected preset. It checks container compatibility rules - for example, MP4 only supports certain video and audio codecs - and decides stream by stream whether to copy or transcode. The planner emits a complete set of FFmpeg arguments and a human-readable summary of what it intends to do, along with any warnings.
The planning logic lives entirely on the frontend, which means it can run instantly without a round-trip to the Rust backend. You see the decision before you commit to it.
Stage 3 — Execute
The Rust backend spawns FFmpeg as a child process, parses its stderr output for progress metrics in a dedicated thread, and streams real-time updates - time processed, frames per second, encoding speed, estimated time remaining - back to the Vue UI through Tauri events.
Concurrency is managed carefully. You can run multiple jobs in parallel, but resource-intensive codecs like AV1 and ProRes automatically trigger exclusive mode, preventing other heavy jobs from starting until they complete. Output files are written to a temporary path first and atomically renamed on success, so a crash or cancellation never leaves behind a half-written file.
A Case Study in Trade-Offs
Building Honeymelon meant making deliberate trade-offs, and I think the decisions are worth examining.
Platform scope
Honeymelon targets macOS on Apple Silicon exclusively. No Windows, no Linux, no Intel Macs. This is a genuine constraint, and I understand it limits the audience. But it also means the app can lean fully into VideoToolbox hardware acceleration, declare native ARM64 architecture in its bundle metadata, and avoid the cross-platform compromises that dilute so many desktop tools. The result is an application that feels like it belongs on your Mac because it was built for nothing else.
LGPL compliance through process separation
FFmpeg is licensed under the LGPL. Rather than linking against its libraries — which would impose LGPL obligations on Honeymelon's own code — the app runs FFmpeg as a completely separate process. Communication happens exclusively through command-line arguments, standard streams, and the file system. No shared memory, no dynamic linking, no library calls. This keeps the licensing clean and lets Honeymelon ship under the GPL v3 without conflict.
Privacy as a default
There is no analytics SDK, no crash reporter phoning home, no update check pinging a server. I built this for myself first, and I do not want my media converter talking to the internet. That philosophy extends to every user. If you are working with sensitive footage or operating in an air-gapped environment, Honeymelon will never surprise you with an outbound connection.
Free software, full stop
Honeymelon is licensed under the GNU General Public License v3.0 or later. It is not "free tier with upsells." It is not "open core with a proprietary edition." It is free software in the fullest sense — free to use, free to study, free to modify, free to distribute.
I built this app to solve my own problem. Once it was working, the only honest thing to do was share it. Media conversion is a universal need. Charging for a wrapper around FFmpeg never sat right with me. I believe tools like this should benefit everyone, and profit was never the goal.
What I Learned
If there is a single takeaway from this project, it is this: the tools you choose determine the experience you can deliver.
Electron gave me rapid iteration and a familiar web stack, but it imposed a floor on resource consumption that no amount of optimization could lower. Tauri and Rust removed that floor. The same features — concurrent job management, real-time progress tracking, subtitle handling, color metadata preservation — now run in a package that feels native because it is native.
The second lesson is that simplicity is a feature. The remux-first strategy is not technically impressive. It is a straightforward check: does the source codec match the target? If yes, copy the stream. But that simple check saves users enormous amounts of time and preserves quality they would otherwise lose to unnecessary transcoding. The best engineering often looks obvious in retrospect.
The third lesson is personal. Building for yourself is a legitimate motivation. Not every project needs a market analysis or a competitive landscape. Sometimes you just need a tool that does one thing well and does not waste your time or your machine's resources doing it. If other people find it useful, that is a bonus — but the software justifies itself the moment it solves your problem.
Getting Started
Honeymelon is available now on GitHub under the GPL v3.
- Repository: github.com/honeymelon-app/honeymelon
- Download: Grab the latest signed DMG from the Releases page
- Requirements: macOS 13 or later on Apple Silicon (M1, M2, M3, M4)
To build from source:
git clone https://github.com/honeymelon-app/honeymelon.git
cd honeymelon
npm install
npm run tauri dev
Contributions are welcome. Whether it is a bug report, a new preset, a documentation fix, or a feature idea - the project is open and the issue tracker is waiting.
Final Thoughts
Honeymelon exists because I needed it. It is free because I believe it should be. And it is open source because the best tools get better when other people can see how they work, point out where they fall short, and help make them stronger.
If you convert media files on a Mac, give it a try. If you are a developer curious about Tauri, Rust, or Vue 3, dig into the source. And if you have feedback, I would genuinely like to hear it.
Top comments (0)