Living Holograms · Proof 1

The portal loop, running in your browser

Mote is a small hologram: a creature with a position, a mood, energy and a short memory. You are the caller. You see each lens only as its descriptions, you choose parameters, and a deterministic perform() writes the next tile. Every tile is hashed with SHA-256 and chained to the one before it. Between passes, a reflex compiled from the present runs at 20 Hz.

What to do

  1. Pick a lens. Fill the form. Press Run one pass.
  2. Tap or click the creature's field a few times, then run another pass.
  3. Press Replay. Then press Tamper and press Replay again.
  4. Turn on Auto and move the cadence slider.

What to watch

  • The slush panel: what the next pass will receive without anyone retelling it.
  • The reflex log: your pokes are counted, then carried into the next tile's slush_in.
  • The chain: each tile names derived_from, the lens particle, params_hash and the caller.

What it proves

  • A tile can be re-derived from its input frame, its params and its slush_in. Replay checks that byte for byte.
  • An edited tile fails replay even when the forger recomputes its hashes.
  • State can carry from pass to pass as data, and a fast reflex layer can run with no model and no network.

What it does not prove

  • That any choice was good. Replay checks structure, not wisdom.
  • Who the caller really was. Nothing here is signed.
  • Conformance with rapp/1. Frames here use a reduced envelope (kind, seq, prev, particle), not the full eleven-key frame, and the reflex log rides in the slush instead of its own frame.

Body: reflexes at 20 Hz

The routine below was compiled from the present object. It runs every 50 ms with a step budget. Poke the field: the creature flees for a moment, and the poke is logged. Nothing the reflex does persists until a pass records it.

ticks since last pass 0 pokes 0 steps per tick 0 / 4000 measured rate 0 Hz

Reflex routine (LisPy-style, compiled from the head)


    


    

      
Slush: what carries into the next pass

      
from_tile is the data_slush the last lens emitted. reflex is the live reflex log. env is a host fact. The pass stores all of it as slush_in.

      

      
Slush the last pass received

    

  


  

    

      
Mind: you are the caller

      
This is everything a caller sees of a lens: its description and its parameter descriptions. perform() is hidden from the caller. Its source is in this page if you want to read it.

      

      

      

      

        
        
        
        
      

      
      
Auto uses a scripted caller (auto-caller, kind process). It reads the present and the slush, then picks a lens and parameters. It is not a model.

    


    

      
The present (head object)

      

    

  






  
The chain, newest first

  

    
    
    
    
  

  
  
    

    


    
  
    How the hashes are made
    
  
    Values are serialized as canonical JSON: object keys sorted by UTF-16 code unit, no whitespace, strings escaped as in JSON, integers only. A hash is H(tag, value) = SHA-256(tag + "\n" + canonical(value)), written as hex. The payload's particle is H("rapp/1:particle", payload). The frame hash is H("rapp/1:wave", {kind, seq, prev, particle}). A lens particle is H("rapp/1:particle", {source}) over its declared metadata and its perform source. params_hash is H("rapp/1:particle", params). Hashing uses the browser's WebCrypto.