A stage in your browser. An actor (a persona from the cast) stands on a 3D set. You can make it speak, show it your face, give it lines from the console, hand its ear a recording or a text, and record a clip. You are both the director and a participant at once. That is why the HUD says you are irecto · and · articipan.

Nothing on the set is a stand-in. The camera picture is your camera's. A face on the set is your captured face. Every trace is drawn from real audio, and every measure comes from the code that computes it. When something has no real signal, it shows nothing and says so.

The set is drawn by three.js, served from this host. Behind it, a DeltaVerse substrate (the voice-scope field) draws the sound actually playing:

• your mic, or a file in the actor's ear;
• otherwise, the actor's voice while it plays through this host.

With no audio, the ground is not shown.

ovie	movie: the experience you are in (the set plus any clip you record)
irecto	director: you, directing the set. The console is the irecto console.
articipan	participant: also you, inside the scene
akeu	makeup: skin and hair for the actor (/akeu)
ode	model: the trained weights behind an actor. A browser cannot make one, so a forged .persona marks its ode as pending imprint.
romp	prompt: the actor's instruction (/prompt). Your scene direction is layered on top of it and is never written back into the persona.

Click the actor's eye (or 👁 eye, or /eye) for camera settings:

• turn the camera on or off, and choose which camera;
• resolution and frame rate, where the browser reports its capabilities;
• mirror on or off;
• the live feed itself;
• what the camera track reports, and the permission state.

Click its ear (or 👂 ear, or /ear) for mic settings:

• turn the mic on or off, and choose which microphone;
• echo cancellation, noise suppression and auto gain, where the browser supports them (each shows what the track actually reports back);
• a live trace of your mic;
• listening on, off or direct, and the permission state.

Opening either panel starts nothing; the camera and the mic start only from their own buttons. Changing a device restarts only that device.

The eye and the ear are found on the head actually drawn:

• the actor's own eye and ear shapes;
• the globe's eyes and ears;
• or, while your face is captured, its own landmarks. Your captured face has no ears, so the outermost points of the face beside them stand in.

The stock 3D head (gltf) has no ears, so use the 👂 button there.

Pressing ◉ mic asks your browser for the microphone. Once allowed, it does three things.

• Hears your level and pitch. These are measured in this page, on your machine. They drive the particles, the glow, the ring, the ground, your mouth trace and the mic monitor. Nothing is sent.
• Keeps a rolling recording of the last ~12 seconds, in memory only. It is used only if you press a capture button.
• Listens, where your browser has speech recognition (the Web Speech API). What you say appears in the console. Important: this page does not upload that audio, but the browser's recogniser may. In Chrome and Edge, the speech is sent to the browser maker's speech service to be transcribed. Safari may do it on the device. If your browser has no recogniser, the HUD says so, and the mic still works for level and pitch. Turn listening off at any time with /listen off. The mic keeps working without it.

Drop a file on the actor's ear, or on the 👂 button, or choose one with /drop.

Audio (anything your browser can decode: WAV, MP3, OGG, WebM, M4A):

• It is decoded and played in the page, through the same instruments as the mic. Your mouth trace and the ground draw its samples.
• You see its name, length, channels and the rate it was decoded at.
• It is not transcribed, because the browser's recogniser hears only the microphone.
• It stays in the page unless you press a vCLONE tool.

A .txt (up to 64 KB, read as plain text, never run) is read aloud the way the playdocs page reads a document:

• The whole text goes to this host's /docsplayer/render, along with this page's address, and is rendered in one voice.
• The reader shows it sentence by sentence and lights the sentence being spoken, timed from the render's own marks.
• If you have cloned a voice, it is read through /voicey in your clone instead, sentence by sentence, within /voicey's limits: 240 characters per request and 20 requests a minute. A sentence the host refuses is struck through and named, not skipped silently.

Pressing ▢ cam asks for the camera. Your actual camera picture goes into the monitor, onto a screen on the set, and into the eye settings. The page also measures what the camera delivers, from its own frames:

• A picture with no colour at all usually means the browser opened an infrared face-unlock sensor (dark grey noise). The page moves to your colour camera once, and says so. If it cannot (for example, another app is using it), it tells you why.
• A picture that is almost black means the lens shutter is closed, the lens is covered, or the room is dark.

/picture shows the numbers. The camera picker is in the eye settings.

Face tracking (MediaPipe FaceLandmarker) runs in your browser. Its model is about 13 MB and is downloaded from this host's /vendor/mediapipe. While a face is seen, the head on the set is your face:

• the 478 landmarks from the current frame;
• joined by MediaPipe's own triangles (852 triangles over 468 points, checked);
• drawn as a translucent mesh with its edges.

No stock head is bent to look like you. When no face is seen, the actor's own head returns. No camera frame is sent anywhere.

◉ capture face (fCLONE) does three things, and keeps no image:

• it keeps one second of landmark points;
• it averages them into a faceprint and a mesh;
• it shows them with /fclone.

The capture stays in the page until you forge, and forging saves files to your own downloads.

The standalone faicey service on mindx.pythai.net is not publicly serving. Faces on this set run in the set, on your machine.

Drop a portrait on the actor's eye, choose one with /image, or analyse a still of your camera with /still. /image monalisa loads Leonardo's Mona Lisa (public domain, Wikimedia Commons) as a reference reading. Everything is computed in this browser from the 478 points MediaPipe finds; nothing is uploaded.

How a face is compared.

• The head is turned back to face the camera in 3-D, using MediaPipe's pose.
• The eyes are levelled, and the face is scaled by the distance between the eye centres.
• A faceprint is the position of 28 fixed landmarks: 10 152 234 454 33 133 362 263 70 105 107 336 334 300 168 6 1 2 98 327 61 291 0 17 172 397 136 365.
• Two faces are compared by the average distance between those points, in eye-distances.
• A face turned more than 20° is refused, with the reason given.

The threshold (0.04) is not calibrated on any population; no error rate is claimed. On six public-domain portraits:

• three photographs of Lincoln came out 0.027–0.037 apart;
• the Mona Lisa came out 0.047–0.059 from Lincoln.

That shows how weak 28 points of geometry are as identity evidence.

Recognition happens only between faces enrolled in this browser. Enrolling takes your explicit consent, and is wallet-signed when a wallet is present. Enrolled faces can be listed, exported and deleted (/recognize). Nobody who is not enrolled is recognised.

Symmetry (/symmetry): each left landmark is reflected across the fitted midline and compared with its right partner. It is reported per region as a percentage of the eye distance.

Beauty (φ) (/phi): by this set's definition, beauty is closeness to the golden ratio φ = 1.618033988749894848. φ is computed with integers, and F(91)/F(90) agrees with it to 18 places. The four ratios are:

• face length / face width;
• eye line→mouth / mouth→chin;
• mouth width / nose width;
• eye distance / eye width.

Each ratio is computed exactly from whole-pixel positions and printed to 18 places. Beside it are its uncertainty (±1 px per point), the number of digits that actually mean something (usually 1 or 2), and its nearest Fibonacci ratio. The score is beauty (φ) = 1 − ¼·Σ|rᵢ − φ|/φ.

One sentence on evidence: perceptual studies do not find φ in attractive faces. Pallett, Link & Lee, New "golden" ratios for facial beauty, Vision Research 50:149–154 (2010), doi:10.1016/j.visres.2009.11.003, found attractiveness peaked at the average face's proportions instead.

.depth is relative depth, extrapolated from contrast. A camera here has no depth sensor: /depth sensor checks for one, and the set says if it finds none.

• It assumes even skin, light from your direction, and that brightness follows the surface angle. Shading becomes slope, and slope is integrated into a height map.
• The map is then fitted to MediaPipe's own depth values. The page shows how well the two agree (r), its size and range, and its hash.
• It depends on lighting and is not in real units; flat lighting gives a flat map.

.color uses the actual pixels of the cheeks and forehead, lips, irises, brows, hair and background. Each is the median in OKLab, shown at each palette size:

• the 16 basic HTML colours;
• a 64-colour cube;
• xterm-256;
• the exact measured colour.

Each comes with its distance (ΔE). /wheel opens the picker: a hexagon colour map, plus RGB, RYB, CMY and OKLCh wheels. The golden angle 360°/φ² = 137.507764050037854646° is computed from the same integer φ. Lighting changes every colour.

.frequency (/freq actor | ear | mic | clone): pitch (F0), the strongest peaks and rough formant estimates of the actual audio. Each is computed exactly and printed to 18 places, and each shows its real accuracy beside it. Pitch varies frame to frame, peak frequencies are good to about a tenth of an FFT bin, and formants to ±150 Hz. So usually only a few of the 18 digits mean anything, and the page says how many.

Every input is one record in a hash-chained log (ollywoo-event/1, the forge log's convention):

• a heard phrase, a typed line, a command, a dropped file, a camera still, a face capture, a colour pick.

Every response from the actor is one too. A response points to the input it answers.

Each record holds measures only:

• the face mesh, the faceprint, the φ readings, symmetry;
• the hashes of the depth, colour and frequency readings, and the voiceprint;
• never a picture or a recording.

Use /events verify to check the chain, /events download for the .event file, and /events jsonld for the provenance version (PROV-O). The chain stays in this page until you download it.

These are working concept prototypes.

.gesture (/gesture): with your camera on, MediaPipe's hand model (in this browser) finds 21 points on your hand. Simple stated rules name what the hand does: pinch, point, open, fist, and a swipe in four directions. Each gesture goes into DeltaVerse's own gesture channel and into the event chain, with the measurements it was decided from.

.airtype (/airtype): an on-screen keyboard.

• Point your index finger at a key, and pinch to type it. A hold-to-type option is /airtype dwell 700.
• /airtype touch lets you touch-type in the air instead. It follows DeltaVerse's finger map (engine/ngn/keyboard.gesture, which the page reads):
  • each finger owns its keyboard columns;
  • bending a finger presses its key;
  • your hand's height picks the row, against a home line set by holding both hands open for 1 s;
  • the thumb is the space bar.
  The thresholds are starting values, not tuned to anyone's hands.
• Every key is also a normal button you can click or tap.
• What you type goes into the console's terminal ($), and Enter runs it. That is the vterm, and /vterm shows it on the set.

.recognition (/recognition) shows what each sense last recognised: hand, air-typing, speech and face. Every recognition is also an input in the event chain.

These only use your camera if you turned it on, and send nothing anywhere. They still need checking with a real hand in front of a real camera.

◉ capture opens the booth. It works the way GNOME Cheese does (photo, burst and video modes, a big shutter, a countdown and flash, a gallery along the bottom), but it is built here.

The source is your camera, the set itself (a screenshot of the 3D set, its background and the readings), or both side by side.

The modes:

• Photo (/takeapic): uses the camera's own still where the browser offers one; otherwise it saves what the preview shows. It records which way it used, and the camera's actual resolution.
• Burst (/burst 4 500): several stills at a fixed interval.
• Video (/record, /stop): records what the preview shows. Your mic and the actor's voice are added only if you tick them.

The gallery keeps this session's captures in the browser; save or delete each one. Every capture joins the event chain, with its size, kind, duration and hash, but never its pixels. If the camera picture is unusable (infrared or black), the booth asks before shooting, and labels the result.

Effects (/effects, ✦ in the booth) are simple filters that change how the picture looks. None of them is an analysis:

• reduce to the 16 basic colours (or 64 or 256);
• false colour from brightness, which is not temperature;
• terminal green with scanlines;
• embossed shading;
• mirror or kaleidoscope;
• a golden-angle spiral of dots;
• your live face mesh;
• a glow that follows the actual sound level.

Each actor in the cast has a default set of effects (ollywoo/effects/<actor>.effects). You can change them and save your own to the playdocs wardrobe, in this browser. Captures record which effects they went through.

Each browser capability the set uses is listed against its specification, with the maturity checked on w3.org, in STANDARDS.md.

• Capabilities the browser lacks are detected, and the page says so.
• Speech recognition comes from a Community Group report, not a W3C Recommendation.
• The EyeDropper and depth tracks are offered only where the browser has them.

The mouths are an oscilloscope over a scrolling spectrogram of the actual audio. There are two:

• the actor's, which is also its mouth on the set while it speaks;
• yours, from the mic or the file in the ear.

A voice the page cannot hear (your system's built-in speech voice) draws nothing.

vCLONE (/vclone) works like this:

• It renders a line in your cloned voice, then measures that recording and your reference with voaice's forensic voiceprint (/voicey/measure).
• It checks each print by recomputing its hash from the response's own fields.
• It compares the two prints with voaice's own comparison: similarity and a verdict.
• It draws both recordings as spectrograms.

Both recordings leave the browser for that measurement, and only when you ask for it.

fCLONE (/fclone) draws your captured face as its own triangles, with the measures the capture produced:

• vertices, edges, faces and the Euler characteristic;
• symmetry and frontality;
• the faceprint, with its hash recomputed;
• the mesh's hash, and how long the capture took.

Only these, and only when you act:

• a line for the actor: its text, the persona and the voice go to /voicey (plus your clone reference id, if you made one);
• a dropped .txt: its text and this page's address go to /docsplayer/render (or its sentences to /voicey, when you read it in your cloned voice);
• ⊙ capture voice: a WAV of your recent audio goes to /voicey/measure;
• ⇧ clone my voice or /vclone file: a WAV goes to /voicey/ref;
• /vclone: your reference WAV and the clone's line go to /voicey/measure;
• listening: the browser's own recogniser may send speech to its maker (Chrome, Edge).

Camera frames, face landmarks, dropped images and audio, enrolled faceprints (this browser's storage), colour picks, the forge log and the event chain all stay in the page. Forging and clips download to your machine.

Yes. ⦿ both turns both on: the set listens and sees at once. Press it again to stop both. The HUD line under the actor's name always shows what is on:

• ● listening: the mic is open.
• ● seeing: the camera is open.

Stopping a sense releases the device, so your browser's recording light goes off.

Nothing on this page mints anything. The consent buttons record your word in a forge log (a hash-chained list of events, kept in the page). They then report whether a face or voice would be mintable under the rule.

A face is mintable only when all of these hold:

• there is a face measurement with that faceprint;
• the capture records that no image was kept;
• your latest face consent is for mint, names that same faceprint, and is not revoked.

With a wallet in the browser, consent is signed (EIP-191 personal_sign). Without one, it is recorded as an unsigned claim, not proof. ⊘ revoke records the withdrawal in the same log. A cloned voice is not mintable yet, because the cloning engine's licence is not recorded as cleared.

The actor's voice comes from one of four tiers, and the HUD names which one spoke:

• voaice: /voicey on this host. The actor's own lines are pre-rendered. Free text is capped at 240 characters and rate-limited.
• docsplayer: the host's document renderer (studio voices, and dropped text).
• client: eSpeak NG, running as WebAssembly on your machine. Nothing is sent.
• browser: your system's speech voices. The page receives no audio from them, so the mouth stays still and the HUD says no audio to measure. Some (for example Chrome's "Google …" voices) are online voices run by the browser maker.

• Live:
  • the set, and the cast from /ollywoo/personas.json;
  • the actor's voice through /voicey, with lip-sync from measured visemes when the server has them;
  • face tracking in your browser, and the captured face on the set;
  • fCLONE and vCLONE with their checks;
  • the forge log, consent and clip recording;
  • the ear's files, the mouths and the ground.
• Not here: the actor does not think on this page. It speaks its own lines and the lines you give it. /mind probes whether a reasoning endpoint is reachable and reports the answer. A trained ode is made by mindXtrain on a node, not in a browser.
• Clips record the 3D set and your mic (if it is on). They also record the actor's voice, but only if it had already spoken through an audio tier (voaice, docsplayer or client) before you started the clip. The ground and the mouth panel are not in the clip. Clips download to your machine and are never uploaded.

Press ⌨ console (or the ` key). The console has two modes:

• aiml: type a line and the actor says it.
• terminal: commands that direct the set. In aiml mode, start a line with / to run a command.

Useful commands:

• /help: every command.
• /cast, /persona <id>: list the actors, or pick one.
• /speak [line]: the actor speaks.
• /mic, /cam, /both, /listen on|off|direct: the senses.
• /eye, /ear: the settings.
• /drop [docs|actor]: give the ear a file.
• /vclone [file|measure], /fclone: the clone checks.
• /mouth on|off, /picture, /look: the mouths, and what the camera delivers and sees.
• /theme, /akeu: the actor's own head, and makeup.
• /wardrobe, /studio: personas and voices from the playdocs studio.
• /forge: make a .persona from what you captured.
• /substrate on|off: the ground.
• /faq: this page.

When the mic is listening, what you say lands in the console input as a draft. Press 🔊 to have the actor say it, or Enter to send it. With /listen direct, each phrase is sent straight away. Say "irecto" and then a command (for example "irecto cam" or "irecto theme") to run it by voice. While the actor is speaking, listening pauses, so the set does not hear itself.