Let’s face it, there’s no shortage of FFmpeg wrappers out there. So many, in fact, that it’s hard to even keep track of them all. From open-source tools to commercial giants, hundreds of developers keep finding reasons to build new tools on top of FFmpeg. You’ve probably used one, or at some point hacked together a script just to make FFmpeg a bit more manageable. That says a lot: FFmpeg is incredibly powerful and supported by a remarkable, ever-growing community

Over my 20+ year career in broadcast and media tech, I’ve seen just about every kind of transcoding solution out there. From big-name enterprise software that costs more than a car to sleek cloud platforms that promise the world. I’ve tried them all. But no matter how fancy the feature set or how big the brand, I kept running into the same two problems:

1. The features I actually need are spread out across different tools.
2. And most of them are still way too complicated unless you’re already a workflow or video expert. Everyone else? They’re left behind.

When “just encode some proxies” isn’t simple

Mid last year, I joined a project where we needed to build a solid, easy-to-set-up transcoding pipeline that wasn’t overly complex.

The goal was straightforward: generate proxies from various camera cards, distribute the workload across four Mac Studios, and automatically check the files into the NLE using the project management system.

Sounds simple enough, right?

It didn’t take long to realize that most off-the-shelf tools, even the ones that looked great on paper, didn’t check all the boxes.

There were a few features we absolutely needed, and they just weren’t there:

• A simple interface or API to submit transcode jobs
• A way to automatically send notifications when a job finished
• Something that could run reliably across four machines without a mess of manual setup

Sure, we found a few transcoding tools that looked like they might work. Some even came close. But once we tried wiring them into a real workflow, the cracks started to show.

Some relied on AppleScript (which, sadly, doesn’t have a native HTTP client), forcing us to use curl just to send notifications. Others had no way of externalizing progress updates, which made building a responsive UX near impossible. And most didn’t play well across multiple machines, so every script and preset had to be manually copied to all four Macs.

At that point, it became clear: even with so many wrappers and commercial solutions out there, none of them offered a clean, scalable way to build a modern transcoding workflow.

That’s when I realized what we were missing wasn’t another transcoding tool. Vanilla FFmpeg is powerful, reliable, and more than capable. But using it the way we needed just wasn’t straightforward. To make it work in a real-world, scalable workflow, we had to build around it.

What we really needed was a clean, lightweight automation layer, something that took the pain out of using FFmpeg through command-line scripts, and added the features we kept wishing were there.

Once that clicked, I did what I always do when I’ve got a spark of an idea: I called my good friend Sev.

Sev and I had talked for years about building an open-source tool together, we just hadn’t found the right idea. But this time, it clicked for both of us. We weren’t trying to reinvent FFmpeg. We just wanted to make it easier to use in the kinds of real-world workflows people deal with every day.

We bounced around a few ideas and that’s how FFmate started.

From day one, we were clear on what we wanted to build: FFmate should strike the perfect balance between simplicity and power.

That meant:

• Not just another CLI wrapper
• Not just another FFmpeg GUI
• But something that offers a clean, REST-based interface and a powerful Web UI, both built from scratch to fit real workflows.

Here’s what FFmate offers right now:

• Web UI
  To monitor and manage tasks, watchfolders, and presets from the browser.
• Job queue with priorities
  Lets you control task order and make sure time-sensitive jobs go first.
• Watchfolder
  For workflows where dropping files into a folder is still the fastest way to get things moving.
• Presets
  We ship 20+ useful presets out of the box, or create your own and reuse them across tasks.
• Wildcards
  Use placeholders like {inputName}, {timestamp}, or {ext} in output paths — FFmate fills in the rest automatically.
• Batch processing
  Group multiple tasks and run them together. Perfect for bulk transcodes or large jobs with shared settings.
• REST API
  Abstracts away shell escapes, progress tracking, error parsing, and other FFmpeg quirks.
• Cross-platform support
  Runs on macOS, Windows, Linux, and Docker, there’s no platform lock-in.
• Webhooks
  Get notified on job completions, task changes, or watchfolder events, and yes, without writing AppleScript ever again 😂
• Pre- and post-processing hooks
  Run your own script before or after a job
• Built-in API docs
  Swagger/OpenAPI docs are included, just open your browser and try it out.
• Built-in metrics
  We added Prometheus-style metrics so we could actually understand what FFmate was doing. Super handy for advanced use cases or when you’re running things at scale.
• Config flags
  Set things like FFmpeg path, port, or log level with a few startup flags.

What’s next?

FFmate is still in its early days, but it’s already helped a bunch of people build better workflows with a lot less frustration. And we’re just getting started.

We’ve got plans to improve the out-of-the-box experience so your first transcode happens as quickly as possible. We’re also exploring ways to integrate LLMs to help make building FFmpeg commands, and debugging errors, a whole lot easier. We’ve also got plenty of ideas to make the watchfolders even better.

Sev and I have a long list of things we want to build. If any of this sounds interesting and you want to get involved, come hang out with us on Discord.

If you’re tired of hacky FFmpeg scripts or patching together half-solutions, FFmate might be exactly what you’ve been looking for.

Resources

• Docs: docs.ffmate.io
• GitHub: github.com/welovemedia/ffmate
• Postman Collection: FFmate API