# Open-source demo video tools, scored by license and install reality

July 18, 2026 · Demo Tools & Alternatives · 7 min read · https://aidemo.top/blog/open-source-demo-video-tools/

> Not everything on GitHub is open source. Cap, vhs, Remotion, Revideo, editly, and aidemo, scored on OSI compliance, install friction, and what the pixels are.

**Key takeaways**

- Remotion is source-available, not open source: a for-profit with 4+ employees needs a paid Company License (from $25/seat/mo or $0.01/render, $100/mo minimum).
- Cap is AGPLv3 (capture crates MIT) and OSI-open; the copyleft touches modified Cap code you host, not the videos you record with the shipped app.
- vhs, Revideo, editly, and aidemo are all MIT, the most permissive mainstream license, so embedding, forking, and commercial use carry no headcount math.
- editly's install breaks on current Node: its pinned headless-gl native module fails to compile (open issue #332, a C++ error on Homebrew Node 22).
- Score three axes: OSI compliance, install friction (native compiles vs system tools), and what the pixels are (real capture, synthetic composition, or terminal).

## Source-available is not open source, and the difference is billable

"Open source" is the most abused word in demo tooling. Remotion, the most popular way to make videos from code, publishes every line on GitHub and lets you read it, fork it, and run it. It is also, by its own admission, not open source: "Remotion is source-available software, but it is not open-source software according to the Open Source Initiative's Open Source Definition" ([Remotion, July 2026](https://www.remotion.dev/docs/license/faq)). That is not pedantry. The Open Source Definition is a ten-clause test, and clause 6 says a license "may not restrict the program from being used in a business" ([Open Source Initiative, OSD 1.9](https://opensource.org/osd)). Remotion's license does exactly that: a for-profit organization with four or more people needs a paid Company License, while individuals and companies of up to three employees use it free ([Remotion License, July 2026](https://github.com/remotion-dev/remotion/blob/main/LICENSE.md)).

So the first thing to check before you build a pipeline on an "open" tool is whether open means OSI-open or just visible-on-GitHub. The bill is real. Remotion's company plans start at $25 per seat per month for creators, or usage pricing at $0.01 per render with a $100 monthly minimum for automated systems, with an enterprise tier from $500 per month ([Remotion Pro, July 2026](https://www.remotion.pro/license)). That is a fair deal for a tool this capable. It is a nasty surprise if you adopted it believing MIT-style freedom and then crossed the fourth hire.

This piece scores the genuinely relevant tools on three axes you can verify against their own repos in five minutes: whether the license clears the OSI definition, how hard the install fights you, and what the pixels actually are. The [four-mechanism map of AI demo generators](/blog/ai-demo-video-generators) sorts the whole market by buyer job; this is the open-source slice of it, read at the license file and the command line.

## The scoreboard: license, install, and what the pixels are

Three columns, three independent questions. The license column is a yes/no against the OSD. The install column is where good intentions meet a C++ compiler. The pixels column is the sleeper: it decides whether a tool can show your product at all.

| Tool | What the pixels are | License | OSI open source? | Install leans on |
|---|---|---|---|---|
| Cap | real screen capture | AGPLv3 (some crates MIT) | Yes | prebuilt app, or Rust + Node + Docker to build |
| vhs | rendered terminal | MIT | Yes | ttyd + ffmpeg on PATH |
| Remotion | synthetic composition (React) | Remotion License | No (source-available) | npm; license gate at 4+ staff |
| Revideo | synthetic composition (TS) | MIT | Yes | npm + a headless browser |
| editly | composed clips and titles | MIT | Yes | ffmpeg + a native headless-gl build |
| aidemo (ours) | real-UI browser replay | MIT | Yes | Node + system Chrome + system ffmpeg |

The pixels column separates tools that look interchangeable in a feature list. A recorder like Cap and a real-UI replay both capture the running software; whatever is on screen is the actual product. vhs captures a rendered terminal, which is the right and only choice for a CLI and useless for a web app. Remotion and Revideo draw frames from code you write, so they show your product only if you rebuild its interface in React or TypeScript first, which is a second implementation to maintain. editly composes media you already have, clips and stills and titles, and captures nothing itself. If the job is to prove a feature works on your live UI, only the first group is even in the running, whatever the license says.

## Reading each license against the OSI clauses

Only one tool here fails the definition, and it fails on purpose. Remotion discriminates by who you are, a for-profit of four or more, which trips clause 6's "used in a business" example and clause 5's bar on discriminating against a group of persons ([Open Source Initiative, OSD 1.9](https://opensource.org/osd)). Its license also forbids relicensing a derivative of Remotion ([Remotion License, July 2026](https://github.com/remotion-dev/remotion/blob/main/LICENSE.md)). None of that makes Remotion a bad tool; it makes it commercial software with the source open for reading, and you budget for it as such. Revideo, an MIT-licensed engine that borrows Remotion's ideas, is the permissive counterpart if code-drawn video is what you actually want ([Revideo, July 2026](https://github.com/redotvideo/revideo)).

The recorders split on copyleft. Cap is AGPLv3, with its capture crates (the `cap-camera*` and `scap-*` families) carved out under MIT ([Cap, July 2026](https://github.com/CapSoftware/Cap)). AGPLv3 is OSI-approved, so Cap is unambiguously open source, but copyleft has a reach worth understanding before you build on it. The videos you record with Cap are your own output, not a derivative of Cap's source, so the license never touches them. What AGPL governs is Cap's code: modify it, then run that modified version as a network service, and you owe your users the modified source. For the large majority of teams who just record with the shipped app, that clause never fires. If you were planning to fork Cap into a hosted product, read it closely. Cap's per-platform grid and pricing live in the [Screen Studio alternatives](/blog/screen-studio-alternatives) map; here the point is only the license.

Everything else is MIT, the most permissive of the mainstream licenses: vhs ([Charm, July 2026](https://github.com/charmbracelet/vhs)), editly ([editly, July 2026](https://github.com/mifi/editly)), Revideo, and aidemo, which we build and disclose as ours. MIT lets you embed, modify, relicense, and ship commercially with nothing owed but a copyright notice. If license certainty is your top constraint, the MIT group removes the question entirely, and there is no headcount at which the terms change.

## Where the install actually breaks

A license you can read is worthless if `npm install` never finishes. Install friction on this list comes in two flavors, and they hit at opposite ends of the table.

The technical flavor is native compilation. editly is the cautionary case: it composes clips through ffmpeg and OpenGL, and its GPU layer is headless-gl, a native module that has to build against your Node headers. On current Node it does not. An open issue reports the source install failing on Homebrew's Node 22 with the C++ error `no template named 'is_lvalue_reference_v' in namespace 'std'`, because the pinned `gl` dependency predates the compiler ([editly issue #332, July 2026](https://github.com/mifi/editly/issues/332)). On Linux the same module wants build-essential, libxi-dev, libglu1-mesa-dev and friends on the box before it will link. editly is MIT and genuinely useful, but it assumes a toolchain, and containers make that worse, not better. Cap sits at a milder version of the same spot: the shipped desktop app installs like any download, but building from source wants Rust 1.88 or newer, pnpm, Node 20+, and Docker for its local services ([Cap, July 2026](https://github.com/CapSoftware/Cap)) — native, because fast screen capture has to be.

The gentler installs lean on tools you already have. vhs needs two binaries on your PATH, ttyd and ffmpeg, then runs as a single Go binary you fetch from Homebrew, Nix, Scoop, or a release download ([Charm, July 2026](https://github.com/charmbracelet/vhs)). Remotion and Revideo are npm and React toolchains that render each frame by driving a headless browser their tooling fetches for you; the friction for Remotion is legal, not technical, and for Revideo it is negligible ([Revideo, July 2026](https://github.com/redotvideo/revideo)). aidemo, ours, is deliberately at the low-friction end: Node 20+, your system Chrome, and system ffmpeg plus ffprobe on PATH, with no Playwright browser download and no native modules to compile, at around seven runtime dependencies total ([aidemo, July 2026](https://github.com/tandryukha/aidemo)). The trade you make for that is real, and stated below.

## Pick by the constraint that binds you

None of these wins in the abstract; each wins under a constraint. Name yours and the list collapses to one or two rows.

| Your hard constraint | Reach for | Why |
|---|---|---|
| Must be OSI-open, no license math | any MIT tool, or Cap (AGPLv3) | Remotion is the only one that bills by headcount |
| The demo is a terminal or CLI | vhs | purpose-built; terminal pixels as a tape file |
| A web UI kept current in CI | aidemo (ours) | real-UI replay, re-renders from a committed spec |
| A human-driven screen recording | Cap | real capture, produced polish, cross-platform |
| Code-drawn motion graphics | Revideo (MIT) or Remotion (paid at scale) | synthetic frames; no product capture at all |
| Install must not touch a compiler | vhs or aidemo | binaries and system tools, no node-gyp |

Two honest notes on our own entry. aidemo captures a browser and only a browser, so native desktop and mobile windows are out of scope, and there is no drag-on-a-timeline editor: you, or a coding agent, author a storyboard file and re-render, which is the [demos-as-code](/blog/demos-as-code) bet and not everyone's taste. For the deeper, feature-by-feature comparison of the code-driven engines specifically, that is the job of [video-as-code tools](/blog/video-as-code-tools). And if the reason you went shopping for open source is that a rented tool's output goes stale the day the UI changes, the fix is not a cheaper recorder but a [pipeline that re-renders in CI](/blog/demo-videos-in-ci) from a spec you keep in the repo. Open source solves ownership and cost; it does not, by itself, solve staleness.

## Sources

- [Open Source Initiative — The Open Source Definition](https://opensource.org/osd)
- [Remotion — License FAQ (source-available, not open source)](https://www.remotion.dev/docs/license/faq)
- [Remotion — LICENSE.md (company license terms)](https://github.com/remotion-dev/remotion/blob/main/LICENSE.md)
- [Remotion Pro — company license pricing](https://www.remotion.pro/license)
- [Cap — GitHub repository (AGPLv3 + MIT crates)](https://github.com/CapSoftware/Cap)
- [Charm vhs — GitHub repository (MIT, terminal)](https://github.com/charmbracelet/vhs)
- [editly — GitHub repository (MIT, native deps)](https://github.com/mifi/editly)
- [editly — issue #332, source install fails on Node 22 gl build](https://github.com/mifi/editly/issues/332)
- [Revideo — GitHub repository (MIT)](https://github.com/redotvideo/revideo)
- [aidemo — GitHub repository (our engine, disclosed as ours)](https://github.com/tandryukha/aidemo)

## FAQ

### Is Remotion open source?

No. Remotion's own FAQ states it is source-available software, not open source under the Open Source Initiative's definition. The code is on GitHub and free for individuals, non-profits, and for-profit companies of up to three employees, but a for-profit organization with four or more people must buy a Company License. That fails the OSD's rule against restricting business use, so it is commercial software with readable source, not open source.

### Which of these tools installs without a native compile step?

vhs and aidemo. vhs is a single Go binary that only needs ttyd and ffmpeg already on your PATH, and aidemo runs on Node with your system Chrome and system ffmpeg, downloading no browser and compiling no native modules. editly is the opposite case: its headless-gl dependency is a native module that currently fails to build on recent Node versions without a full C++ toolchain and OpenGL system libraries.

### Does Cap's AGPLv3 license restrict videos I record with it?

No. The videos you record are your own output and are not a derivative work of Cap's source code, so the AGPLv3 does not attach to them. The copyleft applies to Cap's own code: if you modify Cap and then run that modified version as a hosted network service, you must make the modified source available to its users. Recording with the shipped app and keeping your videos never triggers that obligation.