Qendrim Beka

Reel

Reel keeps what happened in an app instead of pictures of its screen, so the demo above is the app itself, run again from a list of ten commands

A recording is a list of what happened

A screen recording of the Tabkin demo at 30 frames a second would be 600 pictures. Reel's recording of it is ten commands, such as setSplit, each with the millisecond it happened at. To play it, Reel starts the real app and hands it those commands at the right moments, which is why you can stop anywhere and the thing on screen still works.

Reel records commands and not pointer movement or key presses, so the pointer and the typing you see are drawn from the recorded commands and were never a recording of a real hand.

Tabkin and Relaymoth, the two products in the window, are invented for this page, and their data is synthetic, with no real people, receipts, endpoints or accounts behind it.

The figure compares 600 video frames with the ten recorded commands on one timeline, and needs JavaScript to draw.

Drag across the two lines to see what each holds at one moment, where the 600 frames are only arithmetic for 20 seconds at 30 a second, since no video of this demo exists, and the commands are the real recording this page plays

Any moment can be drawn, compared or copied

A moment of a video is a picture. A moment of a Reel recording is a whole state of the app, and that lets the player above do three things a video player cannot. Move a mouse along its timeline and it works out the state at each moment and runs the app on it, small, beside a list of what differs from the moment on screen. On a wide screen, Compare holds one moment and outlines in the app every value that has changed since. Take over makes the state on screen your own working copy.

Taking over is a copy and nothing more. Reel writes the state out as data, reads it back into a new session, and gives that session an empty log of its own. Your commands go to that log. The recording is never written to, and the figure lets you check that for yourself.

The figure runs the code behind Take over on the Tabkin recording, and needs JavaScript to draw.

This runs the same code as Take over, on the Tabkin recording, and each code beside a step is the first twelve characters of the SHA-256 of a state, worked out in your browser as you press

Seeking is a checkpoint and a short replay

Showing a moment means rebuilding its state. Replaying every command from the start takes longer as a recording grows, so Reel stores the state every 256 commands and replays from the nearest stored one. On a generated log of 20,000 commands that brings the wait at the 95th percentile from 1,130 ms to 23 ms. On the real 10 command recording on this page it gains nothing, at 3.5 ms with checkpoints and 3.1 ms without.

Generated log of 20,000 commands
23 ms at p95 from the nearest checkpoint21.2 to 25.5 across 5 runs, against 1,130 ms replaying from the start, 984 to 1,290
The real recording, 10 commands
3.5 ms at p95 from the nearest checkpointagainst 3.1 ms replaying from the start, so there is no gain
The 95th percentile of warm seeks to a coherent state, as the median of 5 runs with each run drawn as a dot and their range as a line, measured on 10 November 2026 on one Apple M5 Pro laptop in headless Chromium while other work held its load average between 7 and 21

Checked against a replay, and against a second model

A seek is right only if it gives the same state as playing from the start. That was compared at 5,332 positions across 4 logs and both scenes, with 0 mismatches. A comparison like that cannot see a bug in the reducer, because both sides share it, so the money is also checked against a separate model written with BigInt.

To find out whether the checks would notice anything at all, 14 bugs were written in on purpose. All 14 were caught, and 6 of the 6 reducer bugs were caught only by the separate model.

14 of 14 seeded failures were detected, including 6 of 6 seeded reducer bugs that the comparison against replay could not see.

Each square is one bug written in on purpose, with the check that caught it, from the correctness run of 10 November 2026

Limits

These are the things the numbers and this page do not show.

  1. The gain only appears on a generated stress log, because on the real 10 command recording here a seek takes 3.5 ms with checkpoints and 3.1 ms without.
  2. The first seek in a fresh page is slower, and on the stress log the slowest of four takes about 1.3 s.
  3. Timings come from one Apple M5 Pro laptop in headless Chromium, while other work pushed its load average from 7 to 21.
  4. The pointer and the typing show which control each command used, because where a hand really moved and which keys it pressed were never recorded.
  5. It records only scenes written for it, so it cannot record any website.
  6. No study has been run, so nobody outside this project has been measured using it.

Take the viewer with you

Export writes a folder of static files that needs no backend. Its poster page has no script, so an iframe of it costs one small page, one stylesheet and two fonts until someone presses play. The player and both scenes come to 115 KB of JavaScript and CSS with gzip.

Open the exported viewer, or read its transcript.

Keyboard

Press ? on the stage to see these there. Keys do nothing while you type in a field or use a control.

Space K
Play or pause
Left Right
Back or forward 5 seconds
[ ]
Previous or next chapter
T
Take over
C
Hold this moment and compare
?
Show or hide the keys