About & Philosophy

The person behind FFmpeg Commander, why it exists, and the beliefs that shaped every decision in it.

Twenty years of data work teaches you something about systems — not just how they behave when things are going well, but how they accumulate. You build a tool to solve a specific problem, and then a year later that tool has become infrastructure, something other processes depend on, something you maintain rather than revisit. That's been the shape of most of it: data engineering, automation, the kind of statistical work that never quite looks the same from one year to the next. When the existing tools stop being adequate, you build something. That's a habit.

FFmpeg Commander started exactly that way — not as a product, not as a plan, but as an answer to a specific recurring friction.

Why I Built It

FFmpeg is one of the foundational pieces of video infrastructure on the planet — it runs inside products that hundreds of millions of people use every day without knowing it's there, processing media at a scale that is genuinely difficult to hold in your head. If you work with video seriously, you know it. If you don't, you've interacted with something it built. The difficulty with FFmpeg is the same difficulty that comes with any deep, capable system: using it well requires understanding it at a level most people don't have time to reach, and every task meant returning to the command line, searching documentation, reassembling commands that had been assembled a dozen times before in slightly different contexts. The tools that claimed to solve this were either unmaintained, or missing the features that actually mattered, or treating video work as a subscription problem — as if the need to convert a file should come with a monthly invoice.

So I built my own.

How It Started

The first version appeared on KodiakBrewing.com — a blog running since 2009, long enough that the internet it was built for has changed around it several times. It started there as a beta, a thing to tinker with in public rather than in isolation, shared informally with whoever found their way to it. The response was informative: people used it, found the edges of it, reported what was missing. That kind of data is worth more than planning. A separate home seemed warranted. That's how ffmpegcommander.com came to exist.

A Note on AI-Assisted Development

AI assistance was used in the development of this software. That's worth saying plainly, because the tendency to either conceal it or over-explain it both miss the point. The models available in 2026 have processed more code than any individual developer could read across a career — they surface edge cases that would otherwise appear at 2am, suggest implementations that compress hours into minutes, hold the context of a large codebase in a way that reduces the cost of being one person working on something complex. Refusing to use them on principle would be roughly as coherent as refusing to use a compiler.

What follows from that is still entirely human: the understanding of the problem, the product decisions, the judgment about what matters and what can wait, the stubborn insistence that a feature work the way it should rather than the way it was easy to build. Every feature in FFmpeg Commander exists because it was needed. The AI helped it get built — it didn't determine what got built, or why.

---

Local-First. Always.

FFmpeg Commander was built around a single structural constraint, one that was established before any feature was considered: your files never leave your machine. Not as a marketing tagline. As a foundational decision that closed off entire categories of architecture — and made the remaining choices considerably simpler.

There is no server. There is no upload step. There is no account to create, no API key to manage, no monthly plan that allocates you a certain number of cloud minutes before you have to pay more. When you process a video, it happens entirely on your own hardware — your CPU, your GPU, your disk. The result appears in the folder you chose. Nothing left the machine.

The rate of privacy incidents has been climbing steadily — not because the people running the servers are negligent, but because the surface area of a networked system is genuinely difficult to defend, and the consequences of a breach fall on users rather than on the operators of the service. The only reliable mitigation is to not participate in that exposure in the first place. FFmpeg Commander makes local processing the default — not the premium tier, not the enterprise option.

You Own What You Buy

Forty-five dollars, paid once. No subscription charge that recurs monthly whether or not you opened the application. No credit system that allocates you a fixed number of operations before asking for more. No price adjustment next quarter because the revenue model requires it.

The subscription model became standard in software because it is better for the company's financial forecasting — not because it is a better arrangement for the person paying. The software may not have changed meaningfully in two years. The payments continue. When you stop paying, access stops too, sometimes along with the files you created inside it. That asymmetry is not an accident. It is the design.

FFmpeg Commander doesn't work that way. You buy it once and it runs as long as your hardware can run it. Updates and support are included for the first year, with every release listed in the Changelog. After that, renewing is optional — you can keep running what you already have indefinitely. That is how software used to work, before subscription economics changed what developers built and for whom.

Design That Gets Out of Your Way

The instinct behind the interface comes from a particular era of computing — Solaris workstations, Mac OS 9, software that didn't explain itself while you tried to use it. Those interfaces understood their role: to execute instructions, not to perform sophistication while you waited. You don't have to have worked on that hardware to recognize what it got right.

Contemporary software has accumulated motion. Animations that communicate nothing, translucent panels composited over frosted glass, gradient elements that shift and breathe in the peripheral vision while you attempt to read a filename. It produces impressive product screenshots. In sustained use, it is noise that occupies attention without conveying information — a tax on focus that compounds across a working day.

FFmpeg Commander was built against that pattern. The interface is clean, dense, and functional. Controls occupy predictable positions. Labels describe what they do precisely. There are no loading indicators on operations that don't load, no onboarding modals, no congratulatory animation when a file exports successfully. You open the application, complete the work, close it.

110,000 Lines Later — Built by One Developer Who Uses It Daily

The work accumulated across hundreds of development sessions into over 110,000 lines of Python, 69 source files, and 18 Cython-compiled modules. It gets used in real production every day — which is a different kind of testing than a test suite, the kind where the consequence of a failure is your own time.

Every feature passed a simple criterion: is this something that gets used? Nothing was added to populate a feature comparison table. When something felt wrong to use, it was fixed, because the developer is also the daily user. The feedback loop is short.

The Tool Should Disappear

The best tools in any domain share a quality that is easy to describe and difficult to achieve: they become invisible in use. You think about the video you are making, not the software you are making it in. Every interface decision in FFmpeg Commander was evaluated against that standard — not whether a feature could be made more visually elaborate, but whether the complexity served the task.

That is why controls are labeled without abbreviation. That is why the log window shows exactly what's running, in real time. That is why the batch queue is a flat list — not a drag-and-drop Kanban board with status badges and priority tiers. The question was never how to make the interface more impressive. The question was whether it got out of the way.

That is the whole operation. One person, one product — the kind of scale that makes accountability simple.

---

FFmpeg Commander Video Toolbox — 2026