Scripted, not filmed
A take is a JSONL file of ops that lives next to the code it films, reviewed and versioned like everything else.
kaviri films your web app from a script in your repo. It re-records in CI whenever the product changes, and fails the build when the take films nothing.
cargo install --git https://github.com/kaviridev/kaviri
Recorded by kaviri from an 18-line script, framed as a Mac. Nobody touched a mouse or chose a camera move.
One Rust binary that brings its own Chromium
Why kaviri
The UI moves and the video does not, because re-recording means a quiet room, an afternoon and the fourth take of the same mouse path. So the demo quietly lies about the product. kaviri makes the demo something your build produces.
A take is a JSONL file of ops that lives next to the code it films, reviewed and versioned like everything else.
Zooms and pans come from each op's timestamp and bounding box. You describe what happens, never where to point.
A take that films nothing, a selector that moved or a frozen page fails the job, with the line number in the log.
Presets for README, TikTok, square, landscape and phone, plus macOS, Windows, iPhone and Android frames.
A spoken voiceover, a music bed that ducks under it, and captions timed to the words, as SRT and VTT or burned in.
An MCP server lets Claude Code, Cursor or any agent explore your app, film a take and look at the result.
How it works
Navigate, type, click, wait. Every op records a timestamp and a bounding box, and the camera is derived from them.
The action installs ffmpeg and Chromium if the runner has none, records the take and uploads the MP4 as an artifact.
Same binary, same script, same video. Your pages never leave your machine.
{"op":"navigate","url":"http://127.0.0.1:8099/"}
{"op":"wait","selector":"#q","timeout_ms":30000}
{"op":"start_recording"}
{"op":"wait","ms":2200}
{"op":"mark","label":"start"}
{"op":"type","selector":"#q","text":"14 Rue Lafayette, Paris"}
{"op":"wait","ms":500}
{"op":"click","selector":"#go"}
{"op":"wait","selector":"li","timeout_ms":15000}
{"op":"wait","ms":1400}
{"op":"mark","label":"tracked"}
{"op":"type","selector":"#q","text":"Kigali Heights, KG 7 Ave"}
{"op":"wait","ms":500}
{"op":"click","selector":"#go"}
{"op":"wait","ms":1800}
{"op":"mark","label":"second"}
{"op":"wait","ms":1600}
{"op":"stop_recording"}
name: demo
on:
push:
branches: [main]
paths: [src/**, examples/**]
jobs:
record:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Serve the app
run: python3 -m http.server 8099 --directory examples &
- name: Record
uses: kaviridev/kaviri@v1
with:
script: examples/demo.jsonl
out: demo.mp4
preset: readme # tiktok, square, landscape, phone
artifact-name: demo
# build once
cargo install --git https://github.com/kaviridev/kaviri
# check it found Chromium and ffmpeg
kaviri doctor
# film it
kaviri record --script examples/demo.jsonl --out demo.mp4 --preset readme
# or hand it to your agent
claude mcp add kaviri -- kaviri mcp
The part that matters
A valid MP4 of a Chrome error page passes every duration check. So kaviri compares the first frame with the last. A script that navigates, clicks and types cannot produce the same picture twice.
$ ffmpeg -i demo.mp4 ... -lavfi psnr -f null - psnr_avg: inf the first and last frames are the same picture; the take filmed nothing Error: Process completed with exit code 1.
Phones, too
Add a frame op and the take is shot at an iPhone's viewport, scale and user agent, inside the bezel, with a tap dot where the finger lands. No simulator, no cable, no phone on a desk.
{"op":"frame","platform":"ios"}
Pricing
Everything that makes the video is open source, with no revenue threshold and no field-of-use limit. The hosted service is a convenience.
For your laptop and your own CI.
Free forever, Apache 2.0
The same recorder, with the parts you would otherwise build.
Usage per render minute
FAQ
If a Chromium can open it, yes: a localhost dev server, a staging deploy or production. kaviri drives its own browser over the DevTools protocol, so there is no screen recorder, no OS permission and no Wayland portal involved.
A screen recorder films what a person did once. kaviri films a script, so the same take is made again on every commit, with no display, no mouse and no quiet room. The zooms and pans come from the interactions in the script instead of an editing pass.
Start your app in the workflow, then add uses: kaviridev/kaviri@v1 with the path to your script. The action installs ffmpeg and a browser, builds kaviri, records the take and uploads the MP4 as an artifact. The CI guide has the whole workflow.
Yes. One frame op films the take at an iPhone or Android phone's viewport, scale and user agent, inside the device bezel, in 9:16. It is a phone-sized browser, not a native app recorder.
No. The recorder is the whole product and runs on your laptop or in your own CI. The hosted service saves you the CI minutes, the storage and the stable URL.
An H.264 MP4, captured at twice the resolution so text is sharp, with a drawn cursor, a backdrop and eased zooms. Presets size it for a README, TikTok, square, landscape or phone.
Yes. kaviri mcp is a Model Context Protocol server: an agent can open your app, look at what is on screen, film a take and check the poster frame. There is also a plain-text protocol for agents with a shell.
Apache 2.0, unconditionally. Fork it, ship it inside your own tool, sell the result. The only thing the licence holds back is the name.
It is ChiShona for "twice, a second time", said ka-VEE-ree. The demo is not re-recorded. It is made again.
Hosted beta
The hosted beta opens in December. Join the list for five short emails on getting the most out of the free recorder, then one when the beta is ready.