Video tooling is powerful and unteachable. We think that is a design problem.
FFmpeg can do almost anything to a video file. Learning it means reading a man page the length of a novel, pasting a command from a forum, and finding out ten minutes later whether it did what you hoped. The knowledge exists — it is just locked behind a syntax you cannot see into.
BeemMeUp makes the pipeline visible. A command is a graph; a graph is a command. Change either one and the other follows, then press run and watch the file come out. Every lesson points at the same tools you would use for real work, because reading about a filter graph and building one are not the same skill.
How we build it
Every diagram is the working tool, not a picture of one. If a lesson claims a flag does something, you can change it on the spot and see whether that is true.
Graph to command and command to graph. People arrive with a command they pasted from somewhere; the fastest way to teach it is to show them what it is made of.
Encoding happens in your browser or on your machine. There is no upload step, no processing queue, and nothing to delete afterwards.
Courses, labs, tools and the desktop app cost nothing. Charging people to learn the thing they are already struggling with is the wrong business.
What is inside
Six tools, one file format between them. Pick one to jump to its details.
Every flag is a node. The canvas compiles to a real ffmpeg command as you edit, and pasting a command rebuilds the graph. Press run and the encode happens in your tab. Open the Studio →
Edit either one and the other follows, including labelled filter pads and multiple outputs.
Missing encoders, container mismatches and unreachable nodes are flagged on the canvas.
Real encodes on ffmpeg.wasm with progress, logs and a playable result. Stand-ins are generated for missing inputs.
Sixty steps with a timeline you can scrub. One drag is one step.
wasm in the tab, the local bridge, or the desktop app with hardware encoders.
Hover any flag for what it does, linked to the FFmpeg documentation.
Drop a file and see what it is made of: boxes, streams, frames, packets, and the command that most likely produced it. Nothing is uploaded. Open Analyze →
moov, trak, stbl and the rest, with sizes and offsets, parsed in the browser.
Keyframe spacing, timestamps and per-packet sizes on a timeline.
Variant ladders, codecs strings and segment timing for master and media playlists.
Truncated moov, missing keyframes, broken sample tables and timestamp gaps, with the likely cause.
Five courses where every diagram is the working tool. Reading about a filter graph and building one are not the same skill, so lessons open in the Studio with their inputs preloaded. Browse the courses →
FFMPEG, HLS, MPEG-DASH, WebRTC and Media Pipelines, each with a module quiz.
Flash cards, quizzes and command challenges with a source on every card.
Earned by running the commands, with a verification link and printable version.
Every lesson graph is an embedded Studio you can edit and run.
Players and protocols you can steer by hand. The DASH Lab drives dash.js against public test streams; the WebRTC Lab pairs two real peer connections in one page. Open the DASH Lab →
Force a rendition, cap the buffer, throttle bandwidth and watch ABR react.
Offer, answer and ICE candidates between two real RTCPeerConnections, no signalling server.
Every control names the section of the spec it touches.
Every upload and render in one place, reusable as the input of the next pipeline. Files stay in your browser, or on your disk with the desktop app. Open the library →
Inputs and outputs side by side with format, duration and size.
Send any result straight into the next Studio graph.
Nothing leaves your machine. There is no processing queue and nothing to delete.
MCP server
Give your agent the same tools. Connect Claude Desktop, Claude Code or Cursor and ask it to visualise a filter chain, lint a command or inspect a manifest. Every client gets only the scopes you grant. Set up the MCP →
Filter chains rendered as graphs, commands checked for the mistakes Analyze knows about.
HLS and DASH manifests read from a URL or a pasted file.
A write scope, flagged on the consent screen and revocable per client.
OAuth-style authorisation with toggleable scopes; manage clients in Account.
Nothing is simulated
When a lesson shows an encode, it is FFmpeg compiled to WebAssembly running in your tab. When the WebRTC lab pairs two peers, they are two real RTCPeerConnection objects exchanging real ICE candidates. The DASH Lab drives dash.js against public test streams.
That constraint is the whole product. A mock would be easier to build and worth nothing: the surprising parts of video are exactly the parts a mock smooths over.
Who ends up here
Different reasons, same problem: the documentation assumes you already know.
You know the concepts and need a faster way to draft commands, check a ladder, or work out why one file plays and its twin does not.
Video landed on your plate. You need enough working knowledge to ship, without a month of reading specifications.
A course that ends in a portfolio of pipelines you actually built, and a certificate that means you ran the commands.
Live demos that never need a local install, and lessons you can point a room at during a workshop.
Get in touch
Feature requests, a lesson that is wrong, a file that breaks the inspector, student and educator Pro — all of it goes to the same inbox and gets read.