The 13-Chapter Interactive Demo

Showing is better than telling. The H33 interactive demo walks through the entire cryptographic pipeline in 13 chapters, from raw biometric data to post-quantum attested verification. Each chapter demonstrates one stage, explains why it matters, and shows real cryptographic operations in real time. Every operation uses the same production engines powering the H33 API.

Chapter 1: Key Generation

The demo generates key pairs for all three PQ signature schemes from independent entropy sources. ML-DSA-87 public key: 2,592 bytes. FALCON-512: 897 bytes. SLH-DSA-SHA2-128f: 64 bytes. The total three-family bundle is displayed alongside classical Ed25519 for comparison, making the size difference immediately visible and concrete.

Chapter 2: BFV Parameter Selection

The FHE engine selects BFV parameters: polynomial degree N=4096, ciphertext modulus, plaintext modulus t=65537. The noise budget is the critical resource: every homomorphic operation consumes budget, and exhaustion means decryption failure. The demo displays the initial budget and tracks consumption through subsequent chapters.

Chapter 3: Biometric Enrollment

A 512-dimensional face feature vector is displayed in plaintext, then encrypted element-by-element using BFV. Each value transforms into a dramatically larger ciphertext representation. The encrypted template is stored on the server while plaintext is erased from the client, demonstrating the server never sees raw biometric data at any point.

Chapter 4: Encrypted Matching

A fresh biometric capture produces a new encrypted feature vector. The server computes the homomorphic inner product of encrypted enrollment and probe templates, producing an encrypted similarity score without any decryption step. The noise budget consumption from the multiplication operations is tracked and displayed.

Chapter 5: Result Decryption

The encrypted score returns to the client which decrypts using the private key that never left the device. The demo compares the decrypted score to plaintext computation, confirming identical results. Remaining noise budget is displayed showing the computation stayed within safe margins.

Chapter 6: STARK Proof Generation

The match result triggers STARK proof generation. The demo shows the algebraic intermediate representation being constructed, the execution trace being generated, and the FRI protocol producing the proof. Proof size is displayed alongside computation size showing succinctness.

Chapter 7: STARK Verification

The verifier checks the proof without seeing biometric data or match computation. FRI queries are checked, trace constraints verified, boundary conditions confirmed. Verification completes in microseconds demonstrating the asymmetry between proving and verification times.

Chapter 8: Three-Key Signing

The attestation payload is signed with all three PQ schemes. ML-DSA signature: 3,293 bytes. FALCON: 690 bytes. SLH-DSA: 17,088 bytes. Each signature is generated from the corresponding key pair created in Chapter 1, and the total bundle size approaches 55 KB before distillation.

Chapter 9: Signature Verification

All three signatures verify independently and in parallel. The strict AND policy is demonstrated: all three must pass. Any single failure causes complete attestation rejection. Timing for each verification is displayed showing the parallel execution advantage.

Chapter 10: H33-74 Distillation

The 55 KB bundle is distilled to 74 bytes. SHA3-256 produces the 32-byte on-chain commitment. The 42-byte Cachee component encodes scheme identifiers and metadata. The size reduction from 55 KB to 74 bytes is displayed as a visual comparison that makes the distillation ratio immediately tangible.

Chapter 11: On-Chain Anchoring

The 32-byte commitment is shown fitting into Bitcoin OP_RETURN, Ethereum calldata, and Solana instruction data, demonstrating chain-agnostic anchoring without modification. The same bytes work everywhere that can store 32 bytes of arbitrary data.

Chapter 12: Full Verification

Starting from 74 bytes, the complete verification path executes: expand from Cachee, verify SHA3-256 commitment, check all three signatures, validate STARK proof, confirm match result. Sub-millisecond total verification time demonstrates production readiness for real-time applications.

Chapter 13: Attestation Chaining

A second authentication produces a new attestation referencing the first via its H33-74 identifier. The chain is verified backwards confirming entire sequence integrity. This demonstrates how H33 builds verifiable audit trails: each event attested and linked to the previous, creating an unforgeable chronological record suitable for compliance and legal requirements.

The demo is available at h33.ai/demo and runs entirely in your browser with real cryptographic operations on the H33 backend. No sign-up required.

Understanding the Pipeline

The 13 chapters are not arbitrary divisions. They correspond to the actual stages of the H33 authentication pipeline as it runs in production. The demo makes visible what normally happens in microseconds behind an API call. Understanding each stage helps developers and architects make informed decisions about integration points, latency budgets, and security properties.

The key insight from watching the demo is the layered security model. FHE provides data privacy (the server never sees biometric data). STARKs provide computation correctness (the match was performed as claimed). Three-key signatures provide attestation authenticity (the attestation was produced by a legitimate H33 instance using three independent mathematical assumptions). H33-74 distillation provides efficiency (the full attestation fits in 74 bytes). Each layer addresses a different security concern, and together they provide comprehensive protection that no single technology could offer alone.

Performance Observations

One of the most striking aspects of the demo is the performance. The entire pipeline, from encrypted biometric matching through STARK proof generation, three-key signing, and H33-74 distillation, completes in approximately 42 microseconds per authentication on production hardware. This is faster than a human blink (which takes about 300 milliseconds), faster than a typical API response (which takes 50 to 200 milliseconds including network latency), and faster than the time it takes most traditional biometric systems to perform a plaintext match including their database lookup overhead.

The performance comes from three engineering decisions. First, BFV SIMD batching processes 32 authentications in a single ciphertext operation, amortizing the FHE overhead across the batch. Second, the STARK proof uses cached verification through the Cachee layer, reducing proof verification to a single hash lookup. Third, the three signature verifications run in parallel on separate CPU cores, so the total verification time is the maximum of the three individual times rather than the sum.

What the Demo Does Not Show

The demo focuses on a single authentication pipeline for clarity. In production, several additional components operate alongside the pipeline. The Cachee layer provides sub-microsecond cached lookups for previously verified attestations. The CMS admission sketch provides constant-memory duplicate detection. The key rotation system manages the lifecycle of the three PQ key families. The monitoring system tracks latency percentiles, error rates, and noise budget consumption across all active sessions.

These systems are essential for production operation but would complicate the demo without adding to the conceptual understanding. The demo's value is in making the cryptographic pipeline visible and comprehensible, showing that post-quantum FHE-based biometric authentication is not a theoretical possibility but a working system that can be observed and verified in real time.

From Demo to Production

The path from watching the demo to deploying in production involves three steps. First, obtain an API key from h33.ai/pricing. The free tier provides enough capacity for development and testing. Second, integrate the H33 SDK into your application. For React applications, the @h33/react-biometric package provides ready-to-use components. For other frameworks, the REST API and language-specific SDKs are available for Python, Go, Rust, and Node.js. Third, deploy and monitor. The H33 dashboard provides real-time visibility into authentication volume, latency, accuracy, and attestation status.

The demo proves the technology works. The API makes it accessible. The SDK makes it easy. The production infrastructure makes it reliable. See for yourself at h33.ai/demo.

Technical Architecture Behind the Demo

The demo's backend architecture mirrors the production H33 pipeline with some accommodations for interactive visualization. The BFV encryption engine runs as a WebAssembly module in the browser for the client-side operations (encryption, decryption) and as native Rust on the H33 backend for the server-side operations (homomorphic matching). The STARK prover runs on the backend with results streamed to the browser for visualization. The three-key signing operations each run on separate threads on the backend, with timing data sent to the browser for the parallel verification display.

The visualization layer uses Canvas-based rendering for the mathematical operations (showing polynomial coefficients, ciphertext elements, and proof components) and standard DOM rendering for the narrative text and interactive controls. The demo maintains a persistent WebSocket connection to the backend for real-time operation streaming, ensuring that the operations shown in the browser correspond to actual cryptographic operations happening on the server in real time.

All demo operations are logged and attested. Each chapter's output includes an H33-74 attestation that can be independently verified through the standard H33 verification endpoint. This means the demo itself is a proof of the system's capabilities: the attestations generated during the demo are real, verifiable artifacts produced by the same cryptographic engines that power the production API. You can verify them yourself through the verification endpoint documented at h33.ai/docs/api/verify.

The demo source code for the client-side components is available on GitHub at github.com/H33ai-postquantum/demo-client, allowing developers to inspect the integration patterns and adapt them for their own applications. The backend cryptographic engines are proprietary (they contain the H33 FHE optimizations and three-key signing logic), but the client-side SDK that communicates with them is open source and well documented.

Why a 13-Chapter Structure

The choice of 13 chapters is deliberate. Each chapter corresponds to exactly one operation in the H33 authentication pipeline: key generation, parameter selection, enrollment encryption, probe encryption and matching, result decryption, STARK proof generation, STARK proof verification, three-key signing, signature verification, H33-74 distillation, chain anchoring, full verification, and attestation chaining. Splitting these into separate chapters allows the viewer to understand each step independently before seeing how they compose into the complete pipeline.

This structure also makes the demo useful as a reference. Developers integrating the H33 API can return to specific chapters to understand the inputs and outputs of each pipeline stage. Architects evaluating the system can focus on the chapters most relevant to their concerns: security architects might focus on chapters 6 through 9 (proving and signing), while integration architects might focus on chapters 1 through 5 (encryption and matching) and chapters 12 through 13 (verification and chaining).

The 13-chapter structure also serves an educational purpose. Most organizations evaluating post-quantum cryptography have a general understanding of the concepts but lack visibility into how they compose into a working system. The demo bridges this gap by showing each concept in isolation and then demonstrating how they work together. By the end of chapter 13, the viewer has seen every component of a production post-quantum FHE-based authentication system in operation, from raw biometric data to verified attestation chain.