You don't have to trust us. That's the whole point.

A normal camera records everything. This one is built to refuse.

At the center of every Canary is a small piece of software the project calls the witness kernel. It's the gatekeeper every detection has to pass through before anything can be stored or sent. But it isn't a camera app that tries to be private — it's a constraint engine whose job is to make the invasive things impossible, not optional.

The one sentence that leaves is signed. Try to fake it.

When the kernel lets a claim out, it stamps it with a digital signature. Below is a real one — generated in your browser, this second, using the exact same method (Ed25519) the device uses. Watch it verify. Then rewrite the record by hand and watch the stamp catch you.

// build the same message the device signs, then sign + verify it
function canonical(c, hash) {
  return "securacv-canary-sig|v1|presence|" + id +
         "|occupants=" + c.occupants +
         "|range_m=" + c.range_m + "|" + hash;
}
sig = await crypto.subtle.sign("Ed25519", privKey, msg);
ok  = await crypto.subtle.verify("Ed25519", pubKey, sig, msg);

// firmware/projects/canary-display/src/trust.cpp
// rebuild the locked canonical, then verify the stamp
snprintf(canonical, sizeof(canonical),
         "%s|v%d|chain|%s|%lu|%s",
         SIG_PREFIX, SCHEMA_V, device_id, length, latest_hash_hex);

const bool ok = Ed25519::verify(sig, pubkey,
                    (const uint8_t*)canonical, n);

These aren't two demos — they're the same handshake. The browser above and the chip in the device build the byte-for-byte identical message before they sign or check it (securacv-canary-sig|v1|…). That's why a claim signed by a real Canary can be re-checked by anyone, anywhere, with no help from us — and why the moment you changed a number above, the stamp stopped matching.

Every record remembers the one before it. Break one, break the rest.

A single signed claim is good. A whole history you can't secretly edit is better. The kernel writes each event into a hash chain: every new record carries a fingerprint of the record before it. Change any past record — even one character — and every record after it stops adding up. Try it.

/// Hashes a log entry with the previous chain hash.
pub fn hash_entry(prev_hash: &[u8; 32], payload: &[u8]) -> [u8; 32] {
    let mut hasher = Sha256::new();
    hasher.update(prev_hash);  // ← the fold: last hash…
    hasher.update(payload);    // …mixed with this record
    hasher.finalize().into()
}

let prev_hash  = store.last_event_hash_or_checkpoint_head()?;
let entry_hash = hash_entry(&prev_hash, payload_json.as_bytes());
let signature  = sign_entry(keys, &entry_hash, DOMAIN_SEALED_LOG_ENTRY)?;
// the new record is now both chained AND signed — three lines.

That's the entire trick, and it's tiny. Because each hash is folded from the one before it, the records form a chain where the newest fingerprint silently vouches for the whole history behind it. The demo above runs the same SHA-256(previous + record) the kernel does — which is why editing an early block turns everything downstream red.

We emulate a lot. Here's exactly what's real.

Much of what we show you — in the Playground, the Lab, the Scenes — runs in a browser, so it's fair to ask what's genuine. The honest answer: the cryptography is completely real. What a web page can't have is the physical radar, the chip's actual secret key, or the sealed storage — so those parts are simulated. We never fake a green checkmark.

The emulator's own README says it plainly: it “talks to the firmware only through the same boundaries silicon would.” Where your browser can do the real math, it does — so a “verified ✓” in a demo is cryptographic truth, end to end, not decoration.

Three ways to check, from “click a button” to “audit the source.”

The whole promise of this page is that trust should be optional. Here's the ladder, from the easiest check to the most thorough — pick whichever rung matches how much you want to dig.