It came from images
The Effing origin story: how a production image-rendering framework, a frustrating SaaS detour, and a silly pun turned into an open-source video toolkit.
Effing turns code into images and video, with no browser in the rendering pipeline. That’s what it is today. But we didn’t set out to build that — we set out to put some badges on top of photos.
Images, lots of them
We’re Few, a five-person software company (hence the name). Our main product is Itemwise, a marketing platform for digital classifieds. Itemwise ingests all of a client’s items and, among other things, generates product catalogs from them. That’s hundreds of thousands of items, each with multiple images. It all started with the need to put overlays on those images.
Generating these one by one, ahead of time, was never going to work. So we built a rendering framework around a simple idea: serialize the props for an image into a compressed, signed segment of a URL, and generate the image when the URL is fetched. Creating a million image variations becomes creating a million URLs, which is cheap. The actual pixels get made on demand, in the cloud, scaling up as needed. That matters here, because a big catalog upload hitting the image endpoints looks a lot like a DDoS attack.
The detour
Then clients wanted video. And we wanted video to work just like images did: write web code, build URLs, scale on demand.
We tried the buy-don’t-build route first, generating JSON for a video-rendering SaaS. It worked, but three things kept grating. We couldn’t reuse any of our image-rendering code inside the videos — everything had to be rebuilt in the vendor’s primitives. The renders were expensive, on fixed plans with no real pay-as-you-go, which fit our spiky workloads badly. And we could only make whatever their JSON format could express, so every animation idea ran into the same wall.
After a few months of that, we caved and built our own.
FFS
The replacement started off as two pieces. Effies: declarative JSON compositions — segments, layers, transitions, audio — in which the visuals are just our own rendered images, referenced by URL. And FFS, the service that turns an effie into an MP4 with FFmpeg.
The name effie was honestly just because it’s kind of like a lottie, but rendered with FFmpeg. And FFS officially stands for FFmpeg Service, but it gets an extra dimension when you add a “Render it FFS” button. Things escalated until the whole project was called Effing, and at that point there was no going back.
FFmpeg alone took animations surprisingly far, but it has limits. So we added annies: animations rendered frame by frame, with the same code and the same URL scheme as static images, streamed as they’re generated. From there Effing grew into a family of packages for programmatic images, animations, and video — badges on photos included!
Also, spot the difference with the detour: yes, effies are declarative JSON too, but they only describe the composition — the images and annies inside are whatever you can generate in code. When an idea hits a wall, you can just move the wall.
What we accidentally built
Two realizations crept up on us along the way.
The first: the architecture we’d built works really well at scale. Everything is a URL, so everything is stateless, cacheable, and deduplicated — two videos that share a generated image only render it once. And there’s no headless browser anywhere: no hefty Chromium to babysit, just functions that produce pixels. So rendering millions of videos is no biggie, and neither is the bill.
The second came later: a system made of plain code, typed props, and simple JSON you can read turns out to be exactly what AI coding agents are good at. Point Claude Code or Codex at Effing and it can write the visuals, compose the effie, and walk the JSON to debug it. It’s so powerful that it quickly starts to feel like the only right way to make these videos.
The money shot
One thing hasn’t gotten easier though: serving the rendering functions and running FFS at scale is real infrastructure work. It happens to be work we know well now — we’ve been doing it for Itemwise for years — and that’s the model. Effing itself is MIT-licensed and open source, the whole pipeline, no catch. Effing Cloud is the hosted service that handles the tedious bits, and it’s how we plan to make money and keep the lights on.
If any of this sounds useful, the tutorial is a good place to start, and the examples are a good place to steal from. We built Effing because we needed it. If you do too: go make some effing videos.