# Recordings The recordings, in one place: each kind of board on its own screen, the admin panel in a browser, and a section at the end saying what kind of capture every badge on the site means. Nothing here is a mock-up. Five boards rather than nine, because the fleet is five user interfaces and not nine. The four Sticks draw the same screens on the same panel with the same two buttons, and the two Core touch boards draw the same screens as each other on the same panel, so one of each stands for its family here. “The devices”, on the Overview page, is where they differ. On this page 1. [Per board](https://kleidos.dev/#fleet-clips) 2. [Admin panel](https://kleidos.dev/#panel-walk) 3. [How they were made](https://kleidos.dev/#provenance) ## Every flow, board by board Each board that has been filmed has a tab of its own, and behind it every recording made on that board, running the same demonstration vault. Five have been filmed: the Plus S3, the CoreInk, the CoreS3 SE, the Cardputer and the T-Deck. The other four are not here: the Plus2, the Plus 1.1 and the Plus SE draw the same 135 × 240 interface as the Plus S3, and the Core2 the same touch interface as the CoreS3 SE. The badge on every figure says how its frames were taken. ### M5StickC Plus S3 ESP32-S3 Two buttons 5 recordings  [Live from the device](https://kleidos.dev/#provenance) **Waking up and unlocking** The Plus S3 wakes on its locked screen. A button is held four times, the timing arc sweeping to a different digit on each hold; the device derives the key at the work factor a production build uses, and the unlocked vault lists its six demonstration services. A recording of the device's own screen: the board sent every frame down its USB cable as it drew it, while a script worked its controls, so the clip runs at the speed the device really runs at.  [Live from the device](https://kleidos.dev/#provenance) **The settings tree** The settings tree opened from the vault with one long press: the first five of its nine groups, the six rows of the interaction group, and the speed of the PIN dial stepped up, stepped back and saved. A recording of the device's own screen: the board sent every frame down its USB cable as it drew it, while a script worked its controls, so the clip runs at the speed the device really runs at.  [Live from the device](https://kleidos.dev/#provenance) **A credential, opened** On the Plus S3 the vault list is walked down two rows and one entry opens on its card: the username, the masked password, and a live one-time code with its countdown. The action bar steps from typing to revealing, and the password stays visible for three seconds under a warning before the device masks it again on its own. A recording of the device's own screen: the board sent every frame down its USB cable as it drew it, while a script worked its controls, so the clip runs at the speed the device really runs at.  [Live from the device](https://kleidos.dev/#provenance) **A one-time code** The vault list flips to its 2FA page with one long press, and two demonstration codes stand there, each with the ring that shows how long it has left. They are real codes, computed on the device for the moment the clip was recorded. A recording of the device's own screen: the board sent every frame down its USB cable as it drew it, while a script worked its controls, so the clip runs at the speed the device really runs at.  [Live from the device](https://kleidos.dev/#provenance) **Typing over Bluetooth** A demonstration entry is open. The chooser asks what to type (the pair, the username, or the password), the device advertises and waits for a computer, and the cancelled session shuts Bluetooth down again. A recording of the device's own screen: the board sent every frame down its USB cable as it drew it, while a script worked its controls, so the clip runs at the speed the device really runs at. ### M5Stack CoreInk ESP32 Wheel 3 recordings  [Live from the device](https://kleidos.dev/#provenance) **One-bit electronic paper** The same demonstration vault drawn in one bit on electronic paper: the list with its dithered service marks, the wheel stepping down to an entry, the card's pager walking its sections, and the password unmasked under a held key. A recording of the device's own screen: the board sent every frame down its USB cable as it drew it, while a script worked its controls, so the clip runs at the speed the device really runs at.  [Live from the device](https://kleidos.dev/#provenance) **A one-time code** The vault steps from its passwords to its 2FA page, and two demonstration codes are drawn in one bit, each with the ring that shows how long it has left. They are real codes, computed on the device for the moment the clip was recorded. A recording of the device's own screen: the board sent every frame down its USB cable as it drew it, while a script worked its controls, so the clip runs at the speed the device really runs at.  [Live from the device](https://kleidos.dev/#provenance) **The code that opens the panel** The CoreInk's own screen while it serves the admin panel: the vault, then the admin card with the join code drawn on electronic paper and the name to open in a browser, then the vault again with the radio down. Nothing moves in between: the card is a screen the device holds for as long as it serves. I served the panel over a debug link for this recording, so the network behind the code is a placeholder. A recording of the device's own screen: the board sent every frame down its USB cable as it drew it, while a script worked its controls, so the clip runs at the speed the device really runs at. ### M5Stack CoreS3 SE ESP32-S3 Touch screen 5 recordings  [Live from the device](https://kleidos.dev/#provenance) **Scrolling and opening by touch** On the touch model a finger drags the vault list down to the last of the six demonstration services, and two taps open it: the account is shown, the password still masked. A recording of the device's own screen: the board sent every frame down its USB cable as it drew it, while a script worked its controls, so the clip runs at the speed the device really runs at.  [Live from the device](https://kleidos.dev/#provenance) **Typing with no keys** The on-screen keyboard on a touch board that has no keys: the device-name field opened from the settings tree, five characters erased one key at a time, the same five typed back, and the name saved. A recording of the device's own screen: the board wrote every frame to its own memory card as it drew it, with its radios off, while a script worked its controls, and the file was fetched afterwards. Nothing was read while it recorded, so the clip runs at the speed the device really runs at and every frame sits where the board's own clock put it.  [Live from the device](https://kleidos.dev/#provenance) **A one-time code** The vault steps from its passwords to its 2FA page with one hold, and two demonstration codes stand there, each with the ring that shows how long it has left. They are real codes, computed on the device for the moment the clip was recorded. A recording of the device's own screen: the board wrote every frame to its own memory card as it drew it, with its radios off, while a script worked its controls, and the file was fetched afterwards. Nothing was read while it recorded, so the clip runs at the speed the device really runs at and every frame sits where the board's own clock put it.  [Live from the device](https://kleidos.dev/#provenance) **Codes renewing themselves** Two one-time codes reaching the end of their window: the rings close over the last five seconds, both codes change at once, and the rings open again on the next window. Nothing is pressed in this clip. The codes are real, computed on the device for the moment the clip was recorded. A recording of the device's own screen: the board wrote every frame to its own memory card as it drew it, with its radios off, while a script worked its controls, and the file was fetched afterwards. Nothing was read while it recorded, so the clip runs at the speed the device really runs at and every frame sits where the board's own clock put it.  [Live from the device](https://kleidos.dev/#provenance) **The code that opens the panel** The device's own screen while it serves the admin panel: the vault, then the card with the join code and the name to open in a browser, then the vault again with the radio down. Nothing moves in between: the card is a screen the device holds for as long as it serves. I served the panel over a debug link for this recording, so the network behind the code is a placeholder. A recording of the device's own screen: the board sent every frame down its USB cable as it drew it, while a script worked its controls, so the clip runs at the speed the device really runs at. ### M5Cardputer ADV ESP32-S3 Keyboard 1 recording  [Live from the device](https://kleidos.dev/#provenance) **A one-time code** The Cardputer's vault steps from its passwords to its 2FA page, and both of its 2FA entries stand there, each with the ring that shows how long it has left. They are real codes, computed on the device for the moment the clip was recorded. A recording of the device's own screen: the board wrote every frame to its own memory card as it drew it, with its radios off, while a script worked its controls, and the file was fetched afterwards. Nothing was read while it recorded, so the clip runs at the speed the device really runs at and every frame sits where the board's own clock put it. ### LilyGO T-Deck Plus ESP32-S3 Keyboard 3 recordings  [Live from the device](https://kleidos.dev/#provenance) **Searching by typing** The unlocked vault on the keyboard board: three typed letters narrow six demonstration entries to one, a key opens it, and another unmasks its password briefly before the device hides it again. A recording of the device's own screen: the board sent every frame down its USB cable as it drew it, while a script worked its controls, so the clip runs at the speed the device really runs at.  [Live from the device](https://kleidos.dev/#provenance) **A one-time code** The vault steps from its passwords to its 2FA page, and two demonstration codes stand there, each with the ring that shows how long it has left. They are real codes, computed on the device for the moment the clip was recorded. A recording of the device's own screen: the board sent every frame down its USB cable as it drew it, while a script worked its controls, so the clip runs at the speed the device really runs at.  [Live from the device](https://kleidos.dev/#provenance) **The code that opens the panel** The T-Deck's own screen while it serves the admin panel: the vault, then the card with the join code and the name to open in a browser, then the vault again with the radio down. Nothing moves in between: the card is a screen the device holds for as long as it serves the panel. I served the panel over a debug link for this recording, so the network behind the code is a placeholder. A recording of the device's own screen: the board sent every frame down its USB cable as it drew it, while a script worked its controls, so the clip runs at the speed the device really runs at. ## A walk through the admin panel In development What the panel looks like while it is in use: the dashboard, a credential being edited, the security page, and the same panel on a phone. What it is and what it refuses are in “The admin panel”, on the Overview page.  [Panel in a browser](https://kleidos.dev/#provenance) **One walk through the panel.** A walk through the panel in a desktop browser: the dashboard, the six demonstration entries, one of them open with its password hidden, the authenticator, the security page and the backup page. A recording of the panel's own page in a browser, over a demo vault served from a computer rather than from a board.  [Panel in a browser](https://kleidos.dev/#provenance) The vault in the panel: the same six demo entries the device shows.  [Panel in a browser](https://kleidos.dev/#provenance) The security page: the unlock secret, the timers, and the three destructive actions.  [Panel in a browser](https://kleidos.dev/#provenance) The same panel on a phone. I opened the panel's own page (the bytes the firmware serves) in a browser against a demo vault served from my computer instead of from a board, and recorded that. So the clip and the three captures above are the page itself over demonstration data, not a session on a board. ## How I made these recordings Every screen on this site came out of the thing it shows. I have mocked nothing up, reconstructed nothing and animated no idea, and each figure carries a badge saying which of the kinds below it is. **Live from the device** Every frame is one the board drew, taken as it drew it, while a script of mine worked its buttons, keys or touch screen. The clip runs at the speed the device runs at, key derivation and screen redraws included. None of these clips came over Wi-Fi. Most came down the board's own USB cable, frame by frame as the board drew them; the rest the board wrote to its own memory card, and I fetched the file afterwards. The sentence under each clip says which of the two it was. **Device screen** One frame I took straight off the device's own screen, shown at its own pixels rather than smoothed. **Panel in a browser** The admin panel's own page (the bytes the firmware serves), which I opened in a browser against a demonstration vault served from my computer instead of from a board. It is the page, not a session on a board. **Drawing with device screens** Each board drawn to scale from the case I measured, carrying a capture of its own screen. Every vault in these recordings is a demonstration vault: I made up the entries, the accounts and the passwords for the camera, on development builds, and no secret of mine or anybody else's appears in them. Each published image and clip has a row in the repository recording its hash and the file it was made from, and the build refuses a figure whose row does not say how it was made.