There’s a blog post by Fabio Sonnati called “FFmpeg, the swiss army knife of Internet Streaming.” Part I. Published July 2011. I had that link in my browser’s quick launches for years. Not bookmarked. Quick launches. The kind of link that’s always there, that you never click, but would notice immediately if it disappeared.
Sonnati wrote about FFmpeg the way someone writes about a tool they actually use. Not tutorials. Not documentation. Just a guy who understood that FFmpeg was holding up the entire internet video industry and nobody was talking about it. He called it one of the pillars of Internet Video. YouTube wouldn’t exist without it. Neither would Netflix. Neither would that weird catch-up TV platform I spent six years building in France.
In my French newsletter Streaming Radar, I did a piece on the invisible French engineers behind streaming (FFmpeg was created by Fabrice Bellard, a French polytechnicien, in 2000, and Sonnati is Italian but the FFmpeg ecosystem owes a lot to French contributors). Billions of people watch video every day on technology built by people nobody knows. Sonnati documented FFmpeg for 15 years on a WordPress blog. I documented the streaming industry for 70 editions of a newsletter. We never worked together. Same reflex.
Anyway, this isn’t really about Sonnati. It’s about what happens when you spend 25 years with a tool and one day turn it into a game.
Before FFmpeg, I was coding directly against APIs. QuickTime, Real Encoder. The kind of stuff where you talk to the codec and the codec talks back and sometimes it lies to you. And we didn’t have AI to read the fucking manual for us at the time. FFmpeg was still a shortcut then, not the center of the workflow.
The moment that changed was late 2007 or early 2008, I don’t remember exactly. I was at M6 Web (the digital arm of the M6 TV channel in France) and there was this show, Nouvelle Star (the French version of Pop Idol, basically). Vincent, who was on the M6 Mobile team at the time, comes to me and says: we signed a deal with Orange. Pre-roll ads on all mobile videos.
Great, I say. What’s the technical solution?
There is no technical solution, he says.
(This is a thing that happens more often than you’d think in media companies. Someone signs a deal, everyone celebrates, and then someone turns to the tech team and goes “so... how do we actually do this?”)
The mobile back then was WAP. If you don’t remember WAP, congratulations, you’re younger than me. WAP was phone internet before phones had real internet. Tiny screens, terrible bandwidth, everything felt like loading a webpage through a straw. The video format was 3GPP, a container designed by the Third Generation Partnership Project specifically for mobile networks. We’re talking H.263 video, AMR audio, resolutions like 176x144 (that’s QCIF, for the nerds keeping score). This was the state of mobile video in France in 2007. This is what Orange wanted pre-roll ads on. Videos that looked like someone described the original to a very bad artist and the artist painted it with a toothbrush.
The option was either to manually prepend each ad to each video in this absurd format (which took forever) or to find an automated way. Vincent came to me because I had built Videonum 2 at my previous company Manreo, an orchestrator that could automate video operations. I talked to Yann, who handled the video operations side. We figured: what if we just use FFmpeg to concatenate the Orange ad with each 3GPP video before pushing to production?
So I built it. It worked. And here’s the thing about FFmpeg: it’s free. Completely free. And we just used it to generate advertising revenue for a TV channel. That was the moment we realized just how much money a free tool could make.
(Not us personally. M6 made the money. We made the realization. Different things. Even the coffee wasn’t free at M6 Web.)
It kept working. FFmpeg ended up generating every pre-roll ad file for all M6 sites, then for Clubic, Jeuxvideo.fr, and the rest of the group after M6 acquired Cyréalis. The running joke internally was that the ad always played, but the content video after it sometimes didn’t. Everyone thought this was hilarious. I never laughed at that joke.
From there FFmpeg became a big part of what we did. At M6 Web, we had four FFmpeg servers in the basement of 46 rue Jacques Dulud in Neuilly. Four physical machines. That’s where we produced HLS before any hardware encoder supported it natively.
The story goes like this: summer 2010, Apple requires HLS for iPhone video apps. Nobody in France really knows how to produce HLS at scale. Cloud solutions don’t work yet (Zencoder doesn’t even have HLS support until November 2010). I find a patch on Git that adds HLS support to FFmpeg. We have four servers in the basement. We plug it in. And suddenly we’re producing HLS industrially.
Then we submit the M6 Replay app to the App Store. Apple rejects it. Reason: every HLS segment needs a complete audio track, and our first segment has a black screen with no audio. Our solution: submit with compliant m3u8 files, get approved, then switch to the real ones after publication. Sorry, Apple. I think the statute of limitations has passed on that one.
I could go on. Stéphane Reuille, a former baker who became allergic to flour and retrained as a developer (we called him “Papy” because in France a dev over 35 is considered ancient, like a shiny Charizard but with back pain), built Videonum 3 from scratch, our in-house FFmpeg orchestrator that handled all our web video formats and ran for years. The whole thing.
But this isn’t the M6 article. That one’s coming. This is about what came after.
At some point, and I genuinely don’t remember when, I wrote a guide to FFmpeg. Over 100 pages. Comprehensive. From beginner to expert. Encoding, transcoding, streaming, filters, hardware acceleration, the works.
Then I put it in a drawer.
I never gave it to anyone. Never sold it. Never published it. Not because I forgot. Because a big part of it is built on other people’s work. Ozer’s methodology, Sonnati’s approaches, and others. Selling or distributing something assembled from sources that aren’t mine wouldn’t be right. Same reason I never shared the FFmpeg skill I built for Claude. I am, with full self-awareness, the king of negative ROI. This one, though, was just ethics.
That skill I mentioned, the one I built for Claude: it’s a set of instructions that teaches the AI how to encode video properly, following best practices from people like Ozer and Sonnati. So I documented everything, shared nothing with humans, and gave my knowledge to a robot. At least the robot doesn’t need to worry about attribution.
25 years of FFmpeg. A 100-page guide nobody read. A skill file an AI uses daily. And then one morning I thought: what if this was a game?
ffmpuzzle is a daily Wordle for FFmpeg encoding parameters. You get a real-world scenario (”Twitch live stream via RTMP. H.264 is the only codec Twitch accepts, 720p30 at 3 Mbps for non-partners, AAC mono/stereo, FLV container as the RTMP transport format.”) and you guess the encoding parameters in 6 tries or less. Codec, bitrate or CRF, resolution, audio codec, container. Sometimes a 6th parameter for hard puzzles (preset, framerate, bitrate mode).
Green means correct. Orange means you’re in the right family (H.264 and H.265 are close, AAC and MP3 are close, MP4 and MOV are close). Red means wrong. Arrows tell you if your numeric guess was too high or too low.
I built it with Claude Code, which is Anthropic’s command-line tool for coding with AI. And here’s the detail I find unreasonably funny: ffmpuzzle was my first project built entirely with Claude Code’s /voice feature. I didn’t type the specs. I talked to my terminal. I dictated the proximity families. I spoke the streak system into existence.
The game’s aesthetic is a terminal. Green text on black background. “$ start” to begin. “$ share --brag” when you win. “$ share --shame” when you lose (it says “segfault” and “don’t ask”). A love letter to the command line, built by talking to a command line.
There’s also a Rust CLI. You can play in your actual terminal, which feels more honest somehow.
Now, a thing you should know about FFmpeg and Rust. FFmpeg is written in C. Not C++. C. ISO C11 and assembly language. Their FAQ explicitly says they refuse C++, Rust, Go, and pretty much every other language that isn’t C. Their exact position is that these languages are “too bloated” and “complicate the build.” They also refuse AI-generated code. Which is worth noting because I just told you I built ffmpuzzle by talking to an AI. FFmpeg is the kind of project that would look at my entire workflow and have a very short, very direct opinion about it.
And it’s not just language wars. FFmpeg has been having a rough couple of years. In January 2025, FFmpegKit got retired overnight, the mobile wrapper that thousands of Android and iOS apps depended on. Gone. The maintainer (one person) couldn’t keep up with upstream changes, and when MPEG LA got acquired by Via-LA in 2023, the patent licensing situation got murky enough that his lawyers told him to shut it down. Thousands of CI/CD pipelines broke. This is what happens when critical infrastructure depends on one volunteer.
Then in November 2025, the Google vs FFmpeg fight went public. Google’s AI agent Big Sleep found about 20 vulnerabilities in FFmpeg’s code and reported them with a 90-day disclosure deadline. No patches. No code. No funding. FFmpeg’s response: “stop jerking yourselves off, just submit a patch.” Mark Atwood, who was at Amazon, said publicly he had to keep explaining to his bosses that FFmpeg is not a vendor, there is no NDA, and they could kill three major Amazon product lines tomorrow with an email.
This is the project I’m celebrating with a game. Volunteers, no funding, fighting with Google on Twitter, still somehow holding up the entire internet video stack. Their official Twitter account once tweeted “Rust is so good you can get paid $20k to make it as fast as C.” Meanwhile, a 21-year-old is attempting a clean-room rewrite of FFmpeg in pure Rust, because apparently that’s what 21-year-olds do now.
And here I am, building a game that celebrates all of this, with a CLI written in Rust, built entirely by talking to an AI. The fact that none of these communities would fully approve of my choices is part of the charm.
The thing I obsessed over in the design is the contest system. The button is visible from your very first guess. Because the audience for this game is video engineers. They will tell you your CRF 23 should be a CRF 22, that your bitrate is unrealistic for that resolution. They will fight you.
Every puzzle is a real scenario. Not fabricated. Some I write from memory (the H.265 CRF 23 in MP4 is a case I’ve seen 200 times). Some are inspired by industry references, people like Jan Ozer whose book is literally called “Video Encoding by the Numbers: Eliminate the Guesswork from your Streaming Video.” I built a game that turns encoding back into guesswork. He would probably not approve. And some puzzles are entirely AI-generated, specifically to troll you.
The ProRes in MOV is a broadcast ingest workflow. The VP9 in WebM is YouTube’s default. The Twitch puzzle (H.264, 3M bitrate, 720p, AAC, FLV, 30fps) is what every game streamer configures in OBS without thinking about it.
I spent most of my career encoding video. In basements, in cloud pipelines, in orchestrators I built myself, through APIs that lied to me, with a tool I found on a blog post I kept in my quick launches for a decade. Now I make other people guess what I was doing down there.
One thing I should probably mention: I emailed the FFmpeg project to ask if I was allowed to make this game. They haven’t responded. Which tracks. They’re volunteers who barely have time to patch bugs found by Google’s trillion-dollar AI. A French fan asking permission to build a Wordle is probably not top priority. I know, deep down, that I am a creepy fan. During the Google controversy, I posted a message that just said “LEAVE FFMPEG ALONE.” I didn’t have a wig to make the video.
ffmpuzzle.com. It’s live, it’s in testing, it’s available in 10 languages. If you feel insulted in any of them: don’t send tomatoes, send me a message. And if you want to fight me about a CRF value, there’s a button for that.
This is Ludo Tries Things. Half experiments, half curiosity, zero guru energy. For streaming industry analysis, Streaming Radar is over here.