One ffmpeg command in. Parsed for real by the browser, then read, drawn, captioned and rewritten for where it is going.

Not until you run an AI lane. A pasted command, or a dropped shell script, is read with FileReader in your own tab and parsed there. The tokeniser, the region split, the filter graph, the map resolution, all thirty-two checks and all eight exports are free, offline and need no account. When you do run a lane, what is sent is the facts block the browser parsed plus the command text, cut on whole token boundaries if it is very long. An ffmpeg command routinely carries a live stream key, so the saved draft and the history mirror in this browser are keyed to your account and are deleted when you sign out — and the model is told to substitute a placeholder rather than repeat a credential back to you.

It parses it. First it tokenises the line the way a POSIX shell would: single quotes are literal, double quotes honour backslash escapes, a backslash-newline is a continuation and not an argument, a pasted $ prompt is stripped, and an unquoted semicolon, pipe or ampersand is recorded as the command-ending hazard it is. Then it walks the tokens with an explicit arity table that knows which options take a value — because getting one entry wrong shifts every following token by one and produces a confident, wrong answer, so an option it does not recognise is reported rather than guessed at silently. Each option is then assigned to the region it decorates: the globals, the input group it precedes, or the output group it precedes. That is what lets this app say -b:v in front of the first -i does nothing, which no regex over the string could establish.

It builds the graph. Chains split on semicolons and filters split on commas, both respecting single-quoted sections and backslash escapes. Pad labels are read off both ends of each filter, links inside a chain are inferred where labels are absent, and a stream reference like 0:v is resolved back to a real input — or flagged when it points at an input the command does not have. Then it asks the graph structural questions: is a label consumed twice, which needs a split because one pad can only feed one place; is a label defined twice; is a label consumed but never defined; is a labelled output pad left unmapped, which stops ffmpeg before the first frame. It also knows the pad counts of the filters whose arity is computed rather than fixed — split, concat, amix, hstack, xstack — so “this concat is wired with four inputs but n=3:v=1:a=1 needs six” is a fact about the graph rather than a guess about the string. The graph is drawn as a layered picture and can be downloaded as a Graphviz .dot file.

Read the command establishes what it actually does: every option group in order with what it does here and whether it is correct, suspect, redundant, ignored or deprecated; where every stream goes from input through filter to output; and what will dominate the wall-clock. Walk the filter graph reads the graph node by node, says what each filter contributes, notes what each label carries, and proposes the reorderings that make it cheaper or clearer. The subtitle path decides between burning in and muxing a soft track, works through what each player will actually show, and covers the double-escaping that makes a subtitles= filter fail to find its file. Rewrite it for delivery takes a target and produces the command to ship, with the diff against yours, the trade-offs and the checks. All four run over the same command and each result offers the next lane as a button.

Three ways. The browser parses first and sends its findings into the run, and the model must return one reconciliation entry per critical and high flag by id, so a defect it ignored is displayed as unaccounted for rather than quietly dropped. Every input, output, filter node, graph label, rule id and option flag it cites is checked against what the command contains, and one that does not exist is shown, marked, rather than trusted — and on the graph lane, any filter node the reading does not mention is listed, because a node nobody read is a node nobody checked. And every lane returns a runnable command, which goes straight back through the same reader before it is shown, so a rewrite that still trips a check says so under the rewrite rather than at 3am on a render farm.

No, and it is told not to guess. This page runs no ffmpeg and has never seen your media: it does not know the source resolution, duration, frame rate or bitrate unless your command states them. What CRF 23 means and what a preset trades are knowledge about encoders and are fair game; “about 40 MB” would be an invention. The same rule is why nothing here claims to have run anything.

It does not execute ffmpeg, probe your media, or fetch anything. It does not know which encoders your build has — a check on libfdk_aac is about the codec, not about whether your binary was compiled with it. It does not validate the arguments inside every filter, only the pad counts of the filters whose arity is knowable and the wiring between them, so a wrong drawtext expression will pass the browser's checks and has to be caught by the model or by running it. And it never rewrites your file: every command it produces is text for you to read and run yourself.

A worst-case amount is reserved before you run and only what the run actually uses is charged. The estimate is checked against your balance before the button enables: signed out, it says signing in comes first; under the model's minimum, it names the exact shortfall; and a reply cut short by a low balance says so rather than presenting itself as complete. The whole browser side is free and needs no account at all.