Both companies build on fully homomorphic encryption. That's where the similarity ends. Zama is an FHE library company building toward blockchain confidentiality. H33 is a post-quantum security infrastructure company delivering FHE, ZK proofs, and post-quantum signatures as a production API. This comparison covers every dimension—12 categories, with honest assessments of where each company leads.
Table of Contents
FHE Engines
Zama
1 scheme: TFHE. Boolean gates and integer arithmetic on encrypted data. TFHE-rs is the core Rust library. Concrete compiles Python programs to TFHE circuits. Single approach for all workloads—general-purpose, gate-by-gate bootstrapping.
H33
4 engines: BFV-128, BFV-256, CKKS, FHE-IQ auto-router. BFV handles exact integer arithmetic and biometric matching. CKKS handles approximate float arithmetic and ML inference. FHE-IQ auto-selects the optimal engine in <500 nanoseconds based on workload, security tier, and hardware. Developer makes one API call—routing is automatic.
| Dimension | Zama | H33 |
|---|---|---|
| FHE schemes | TFHE (1) | BFV-128, BFV-256, CKKS, FHE-IQ (4) |
| Integer arithmetic | Yes (bootstrapped) | Yes (BFV, no bootstrapping needed) |
| Float arithmetic | Limited | CKKS (native approximate) |
| Auto-routing | None | FHE-IQ (<500ns decision) |
| Developer experience | Learn TFHE paradigm | One API call, engine selected automatically |
Performance
These are different workloads. Zama does general-purpose FHE computation. H33 does production authentication pipelines. But the performance gap is structural—and the numbers speak for themselves.
| Metric | Zama | H33 |
|---|---|---|
| Per-operation latency | 124ms (64-bit add, CPU) | 38.5µs per auth |
| Throughput | 189K bootstraps/sec (8× H100 GPUs) | 2.17M auth/sec (single Graviton4) |
| ZKP verification | 123–467ms | 0.059µs cached STARK |
| GPU required | Yes (H100 for competitive perf) | No |
| Hardware cost | ~$120K/yr (8× H100 cluster) | ~$2/hr spot (~$17K/yr) |
| Speed ratio | H33 is 3,200× faster per operation on CPU alone | |
Why the gap is structural
H33's Montgomery NTT, Harvey lazy reduction, NTT-domain fused inner products, and SIMD batching (32 users per ciphertext) are purpose-built optimizations that TFHE's gate-by-gate bootstrapping architecture cannot match. TFHE bootstraps after every operation. H33's BFV pipeline uses shallow circuits with no bootstrapping needed—the entire auth completes in a single forward pass.
Zero-Knowledge Proofs
Zama
ZKPoK only—Zero-Knowledge Proof of Knowledge. Proves that a ciphertext was correctly formed. Does not prove what was computed or whether policies were followed. Generation time: 6.9 seconds for a single FheUint64 encryption proof.
H33
Two STARK engines. Lookup STARKs for precomputable verification (0.059µs cached). AIR STARKs (Algebraic Intermediate Representation) for open-ended computation proofs. Both hash-based (SHA3-256), both post-quantum secure, no trusted setup.
| Capability | Zama | H33 |
|---|---|---|
| Proof type | ZKPoK (encryption correctness) | Lookup STARK + AIR STARK + STARK-IQ auto-router |
| Auto-routing | N/A (single proof type) | STARK-IQ selects Lookup vs AIR automatically per workload |
| Proof generation | 6.9 seconds | 0.059µs (cached lookup) |
| Post-quantum secure | No (Zama acknowledges this) | Yes (SHA3-256 hash-based) |
| Trusted setup | No | No |
| Proves computation correctness | No | Yes (AIR STARK) |
| Proves policy compliance | No | Yes |
Post-Quantum Signatures
Zama
None. Zero signature implementation. Relies on host blockchain's native signatures—Ed25519 for Solana, ECDSA for Ethereum. Both are quantum-vulnerable. Zama's FHE is lattice-based (inherently post-quantum), but their ZKP is not PQ-secure (they acknowledge this).
H33
Complete PQ signature stack. Dilithium (ML-DSA-65/87, FIPS 204). Kyber (ML-KEM-768/1024, FIPS 203). FALCON-512. SPHINCS+. H33-3-Key nests three independent signature families (Ed25519 + Dilithium + FALCON) with temporal binding. 291µs per Dilithium attestation.
| Signature | Zama | H33 |
|---|---|---|
| Dilithium (ML-DSA) | None | ML-DSA-65/87 (FIPS 204) |
| Kyber (ML-KEM) | None | ML-KEM-768/1024 (FIPS 203) |
| FALCON | None | FALCON-512 |
| SPHINCS+ | None | Yes |
| Nested hybrid | None | H33-3-Key (3 independent families) |
| Attestation latency | — | 291µs (Dilithium sign+verify) |
Blockchain & DeFi
Zama
fhEVM for Ethereum confidential smart contracts. Zama Protocol mainnet live. Confidential ERC20 transfers. ~20 TPS on CPU, targeting 500–1,000 TPS with GPU acceleration. $150M funded, with partnerships across Ledger, Fireblocks, and OpenZeppelin.
H33
10 Solana smart contracts spanning identity, authentication, DeFi, and document management. Soulbound biometric NFTs—FHE-encrypted biometrics bound to non-transferable tokens. Dilithium-verified on-chain transactions. 7-stage token economics with automated burn mechanism. Biometric SCIF DeFi wallet where the private key is protected by FHE—the wallet itself is post-quantum. Solana Shield: first post-quantum privacy layer for Solana.
| Dimension | Zama | H33 |
|---|---|---|
| Chain | Ethereum (fhEVM) | Solana |
| Primary use | Confidential transactions | Post-quantum identity + DeFi |
| Smart contracts | fhEVM library | 10 deployed contracts |
| TPS | ~20 CPU / ~500–1K GPU target | Solana-native throughput |
| User signatures | ECDSA (quantum-vulnerable) | Dilithium (quantum-proof) |
| Biometric wallet | None | SCIF DeFi wallet (FHE-protected key) |
ML on Encrypted Data
Zama
Concrete ML. Compile sklearn, PyTorch, and XGBoost models to FHE circuits. Encrypted LLM fine-tuning via LoRA. CIFAR10 classification: ~4 minutes per image at 88.7% accuracy. Strong tooling for data scientists who want to train on encrypted data.
H33
CKKS engine for encrypted float arithmetic—dot products, similarity search, ML inference. FHE-IQ auto-routes between BFV (exact) and CKKS (approximate) based on workload. AI-Blind: one API call, model processes encrypted data, never sees plaintext. Plus 3 native AI security agents—harvest detection (0.69µs), side-channel detection (1.14µs), crypto health monitoring (0.52µs).
| Capability | Zama | H33 |
|---|---|---|
| ML compiler | Concrete ML (Python → FHE) | No (API-first) |
| Framework support | sklearn, PyTorch, XGBoost | CKKS inference API |
| Encrypted inference | ~4 min/image (CIFAR10) | Sub-millisecond (biometric match) |
| Auto engine selection | No | FHE-IQ routes BFV/CKKS automatically |
| Security agents | None | 3 native agents (<1.2µs each) |
Biometrics
Zama
Research demo only. Single-user iris matching via FastAPI. Not production, not batched, not optimized.
H33
Production FHE biometric pipeline. 32 users per ciphertext via SIMD batching (4,096 slots ÷ 128 dimensions). Constant-time verification: ~967µs whether matching 1 or 32 users. Templates stored encrypted—256KB/user vs 32MB/user unoptimized (128× reduction). The server never sees the biometric. Ever.
| Metric | Zama | H33 |
|---|---|---|
| Status | Research demo | Production |
| Users per ciphertext | 1 | 32 (SIMD batched) |
| Verification latency | Seconds (unbatched) | ~967µs (constant-time) |
| Template size | Unoptimized | 256KB/user (128× reduction) |
| Server sees plaintext biometric | Yes (FastAPI demo) | Never |
Security Posture
| Certification / Capability | Zama | H33 |
|---|---|---|
| Side-channel protection | "Not yet implemented" (their README) | AI agent (1.14µs) |
| SOC 2 | None | In progress (100% via Drata) |
| HIPAA | None | Compliant |
| ISO 27001 | None | Pending |
| Standards body | None | HATS v1.0 (AI trustworthiness certification) |
| Security audit | Trail of Bits (blockchain only) | Full production audit |
Products
Zama 5 products
H33 38 products across 13 categories
Pricing
Zama
BSD-3-Clause-Clear license with mandatory patent licensing. Free for research only. Any commercial deployment requires negotiating a separate patent license with Zama's legal team—all Zama technologies are patented and the open-source license explicitly excludes commercial patent rights. On top of the license fee: blockchain protocol fees of $0.005–$1.00 per operation, plus self-hosted infrastructure costs of ~$15K/month per coprocessor operator. GPU acceleration (H100s) adds another ~$30K+/year per node.
H33
Self-service API. Credit-based pricing from $0.05/credit (free tier, 1,000 credits) down to $0.001/credit (Enterprise+, 3M credits/month). $0.001 per authentication at scale. BotShield free tier: 2,500 challenges/month, no card required.
| Dimension | Zama | H33 |
|---|---|---|
| Free tier | Research use (BSD-3-Clause-Clear) | 1,000 credits + BotShield 2,500/mo |
| Commercial license | Patent negotiation required | Self-service API key |
| Per-operation cost | $0.005–$1.00 (blockchain) | $0.001 per auth (at scale) |
| Infrastructure | ~$15K/mo per coprocessor (self-hosted) | Managed API (no infrastructure) |
| GPU costs | ~$120K/yr (8× H100) | $0 (CPU only) |
What Zama Used to Do Better
Honesty matters more than marketing. Here's where Zama led — and where they no longer do.
1. Python Compiler UX — Advantage eliminated
Zama's Concrete compiler was their strongest differentiator: write Python, decorate with @fhe.compiler, get an FHE circuit. Genuinely powerful for data scientists.
H33-Compile now does the same — but better. Write Python, decorate with @h33.compile, and H33 compiles it to an FHE circuit with 4-engine auto-routing via FHE-IQ. Concrete compiles to 1 backend (TFHE). H33-Compile routes to BFV-128, BFV-256, CKKS, or BFV-32 automatically. Mixed float + integer circuits auto-split across engines (Hybrid mode). Built in Rust. Open source (Apache 2.0).
2. Ethereum Ecosystem Depth
fhEVM has production mainnet, partnerships with Ledger, Fireblocks, and OpenZeppelin. If you're building confidential smart contracts specifically on Ethereum, Zama has deeper EVM integration. H33's blockchain play is Solana-native — 10 smart contracts, biometric SCIF wallet, Solana Shield. Different chain, different architecture, arguably more secure (FHE biometrics > ECDSA signing).
3. Team and Funding
$150M raised. ~200 people. ~50% PhDs. CTO invented Paillier encryption. That's real academic and financial firepower. H33 built 38 products with a fraction of those resources.
What H33 Does Better
- 3,200× faster on CPU, no GPU required. 38.5µs per auth vs 124ms per FHE operation. Single Graviton4 vs 8× H100 cluster.
- Complete PQ stack (FHE + ZK + Signatures + KEM) vs FHE only. Dilithium, Kyber, FALCON, SPHINCS+, and H33-3-Key nested hybrid signatures. Zama has zero post-quantum signatures.
- 38 products vs 5. 13 categories covering FHE, ZK, signatures, biometrics, key management, healthcare, fraud, device attestation, video, AI compliance, procurement, bot protection, and standards.
- Production biometrics vs research demo. 32 users per ciphertext, constant-time verification, 128× template size reduction. Server never sees the biometric.
- $0.001/auth vs $0.008–$0.80/operation. Self-service API key vs patent license negotiation. No GPU costs. No coprocessor infrastructure.
- 10 smart contracts + biometric SCIF wallet vs smart contract library. Soulbound biometric NFTs, Dilithium-verified transactions, 7-stage token economics, Solana Shield privacy layer.
- SOC 2 / HIPAA / HATS vs no compliance certifications. Production security audit, HIPAA compliant, SOC 2 in progress, HATS AI trustworthiness standard.
- Side-channel protection vs "not yet implemented." AI-powered side-channel detection in 1.14µs. Zama's own README acknowledges the gap.
- 2 STARK engines (Lookup + AIR) with auto-routing vs encryption-only ZKPoK. 0.059µs cached verification. Proves computation correctness, policy compliance, identity, and audit trails—not just encryption correctness.
- 4 FHE engines with auto-routing vs 1 scheme. BFV-128, BFV-256, CKKS, and FHE-IQ. Developer makes one call; the engine is selected in <500ns.
- Python FHE compiler with 4-engine routing. @h33.compile does everything @fhe.compiler does — plus automatic engine selection, hybrid circuit splitting, and SIMD vectorization. Concrete compiles to TFHE only.
Conclusion
Zama is building the FHE library for blockchain confidentiality. H33 is building the post-quantum security infrastructure for everything else.
If you need to make Ethereum transactions private, Zama is purpose-built for that. They have the team, the funding, the Ethereum partnerships, and a Python compiler that researchers love.
If you need production-grade encrypted authentication, biometrics, fraud detection, compliance, key management, device attestation, or any security operation that needs to survive quantum—H33 has 38 products, 4 FHE engines, 2 STARK engines, and a complete post-quantum signature stack, all in one API call.
The single-sentence summary
Zama encrypts computation on Ethereum.
H33 secures everything else against quantum.
3,200× faster. CPU only. $0.001 per auth.
See the Numbers Yourself
Get your free API key and benchmark H33's full pipeline. 1,000 free credits, no credit card required.
Get Free API Key