Free video tools

how they work

Free, browser-local, no upload

Every tool on this page runs in your browser: files are processed on your machine with WebAssembly and never uploaded to a server. That is the same philosophy as the studio itself. CoAnimator renders videos locally, and its free tools work the same way. There are no accounts, no queues and no watermarks on converter output; the device mockup's free export carries a small mark, with the clean full-quality version in the desktop app. When a job outgrows the browser (long videos, 4K, batches) the free desktop app picks it up with unlimited local exports.

Running locally changes what the tools can honestly promise. There is no compute bill to recover, so there is nothing to meter, no sign-up wall, and no watermark used as an upgrade lever. It also means your unreleased product footage never touches someone else's server, which matters more for a pre-launch demo than for a holiday video.

which one

What each tool is for

Five utilities, each built because it sits one step away from making a product video and because the browser can do the work without a server behind it.

the ladder

When the browser stops being enough

Browser processing has real limits. Everything happens in one tab's memory, so a long 4K file can exhaust it, batch jobs have nowhere to queue, and encoding is bounded by what browsers support natively, so the mockup maker exports WebM instead of MP4. Each tool states its limit before you commit a file, not after.

Past those limits the work belongs in the desktop app, which runs the same rendering pipeline without a tab around it: unlimited local exports, full-quality MP4, no watermark, on Windows and macOS. The tools here and the studio are the same idea at two sizes. Your machine does the work, so nobody has to meter it.

under the hood

What actually runs when you drop in a file

Nothing on this page touches a server. The heavy lifting comes from a handful of web platform capabilities that only became practical in the last few years, and each tool leans on a different one.

The GIF converter runs FFmpeg compiled to WebAssembly. It is the same encoder that sits behind most video tooling on the internet, executing inside the tab at close to native speed, so the conversion happens without a server and without a queue. The caption generator runs a Whisper speech-recognition model the same way, preferring WebGPU when your browser exposes it and falling back to WebAssembly when it does not. The gap between those two paths is large, so the tool reports both figures instead of one flattering number. The mockup maker composites frames onto a canvas and records the result with the browser’s own encoder, which is also why its output is WebM, the one format browsers can write natively without help.

The consequence people care about is that your file never moves. There is no upload step, no temporary copy on someone else’s disk, no retention policy to read, and no account to delete afterwards. For a product demo of something unreleased, that is a materially different proposition from a free web tool that processes your footage in a datacentre. Nothing here is metered or watermarked for the same reason. A watermark recovers a compute bill, and there is no compute bill when the compute is yours.

The honest limit is memory. Everything happens inside one tab, so a long 4K file can exhaust what the browser will allocate, and a batch has nowhere to queue. Each tool states that ceiling before you commit a file.

the workflow

How the five fit together

Individually each tool solves a small problem. In sequence they cover most of the path from “we should make a video” to something published, which is why these five exist and a general utility farm does not.

A typical run starts before anything is recorded. The cost calculator answers whether this is a job to outsource or to make in-house, and at what cadence, a decision easier to make with the arithmetic in front of you than after a quote arrives. The script generator then turns the idea into a timed beat sheet, which is the artefact everything downstream depends on: an editor, an agent and a stakeholder review all go better against a structure with time bands than against a paragraph of intent.

With a script settled, you record. The device mockup maker takes that raw capture and makes it presentable, framed and cropped to a deliberate shape so it reads as a product instead of a screenshot. The caption generator makes it survive a muted feed, which is where most of the audience is. And the GIF converter produces the version that goes where video cannot play: the README, the pull request, the docs page, the issue comment.

What the sequence exposes is where the real work sits. The framing, the captions and the GIF are each a minute of effort. The animation between the recordings (the titles, the transitions, the motion that makes a screen recording feel like a product video) is the part that takes a designer a week and an agency a quote. That is the gap CoAnimator fills, and these tools are deliberately the pieces either side of it.

the trade

Free tools with no catch, and why that is possible

Free browser tools normally have a business model attached, and it is usually one of three: a watermark you pay to remove, a credit meter that runs out, or an email address collected before the download. All three exist to recover the cost of the servers doing the work, which is a real cost and a fair thing to recover.

None of them apply here, because there are no servers doing the work. The conversion, the transcription and the compositing all happen on the machine that opened the page. That removes the compute bill, and with it the reason to meter anything. The GIF converter and the caption generator produce unwatermarked output because there is nothing to recover; the device mockup’s browser export carries a small mark only because its full-quality path genuinely lives in the desktop app.

In return, people who need these tools usually make product videos, and some of them will want the studio. That is the whole arrangement. No account, no email gate, no trial clock, and no version of the tool that quietly degrades until you pay.

It also means the tools do not expire. Because nothing runs on our infrastructure, there is no hosting cost that makes them worth switching off in a year, and no migration to a paid tier when priorities change. They work in the browser today and will keep working the same way, which is a less exciting promise than most free tools make and a more durable one.

privacy

Why local processing matters more for product footage

For a holiday clip, where a file gets processed is an abstract concern. For an unreleased product it is a concrete one, and it is the reason these tools were built this way.

A demo recording of something unshipped contains more than the feature you meant to show. It contains the interface, the naming, the roadmap implied by menu items that do not exist publicly yet, and frequently real customer data sitting in a test account. Uploading that to a free converter means it lands on infrastructure you have not evaluated, under a retention policy you have not read, in a jurisdiction you have not checked. Most such services are perfectly reputable. You cannot tell which from the upload button, and the question rarely gets asked because the tool feels too small to matter.

It matters more inside a company than out. Security review exists precisely to catch this, and a marketing team quietly running pre-launch footage through an unvetted web service is the kind of thing that turns into a policy afterwards. Tools that process locally sidestep the review entirely, because there is no third party to assess and no data leaving the machine to argue about.

You do not have to take that on trust either. Open the network tab while a conversion runs: the model and the WebAssembly binary download once, and after that nothing is sent. It is the same property the desktop studio has, for the same reason. Your machine does the work, so nobody else needs a copy of your footage.