The frontiers of programmable cryptography

Fully homomorphic encryption (FHE) lets an untrusted machine run arbitrary programs over encrypted data and return an encrypted result. The server learns nothing, not even the answer. Secure multi-party computation (MPC) and garbled circuits (GC) distribute that trust instead: several parties jointly compute a function over their private inputs without revealing them to each other.

The obstacle has never been possibility; it's been cost. FHE in particular pays its privacy tax in bootstrapping, the noise-refresh operation that keeps ciphertexts computable. Our answer is Torq, a Rust TFHE engine whose novel bootstrapping runs in under a millisecond on Apple Silicon, at 128-bit, post-quantum security. That performance previously required GPU acceleration; Torq delivers it on commodity CPUs.

• TFHE-family schemes and fast bootstrapping
• CPU-native performance engineering for Apple Silicon (M2/M3/M4)
• MPC and garbled-circuit protocols for multi-party trust models

A SNARK, a succinct non-interactive argument of knowledge, is a short proof that a computation was executed correctly, checkable in milliseconds regardless of how long the computation took. The zero-knowledge variant, zkSNARKs, proves correctness while keeping the inputs private. Together they invert the economics of trust: instead of re-running work or trusting the operator, you verify a proof.

Proving is still orders of magnitude more expensive than the computation being proven, which is why prover performance is the central open problem of the field. We research novel proving systems: new arithmetizations, commitment schemes, and folding/recursion techniques aimed squarely at closing that gap.

• SNARK and zkSNARK constructions and their concrete efficiency
• Novel proving systems: arithmetization, recursion, and hardware-aware provers
• Proof systems as infrastructure: rollups, light clients, verifiable services

As AI systems make decisions that matter, "trust the API" stops being an acceptable answer. Verifiable inference gives cryptographic evidence that a specific model, with specific weights, actually produced a given output: no silent model swaps, no undisclosed quantization, no tampering.

Doing this for modern LLMs is a scale problem: billions of parameters per forward pass make naive proof generation absurdly slow. This is where our two other pillars converge: proving systems tuned for the linear algebra of transformers, and encrypted compute for keeping prompts and weights private. Our goal is verifiable inference fast enough to sit in a production serving path, not a research demo.

• Proof systems specialized for transformer inference workloads
• Combining FHE and proofs: private and verifiable model serving
• Latency budgets compatible with real inference APIs