The Home of Privacy-Preserving Compute
Discover, compare, deploy, and contribute state-of-the-art components for privacy-preserving systems.
Across the full stack — from complete privacy applications to foundational computational kernels.
Private inference · Key switching · NTT · MSM · Polynomial multiplication
The state of the art is becoming increasingly difficult to navigate — but impossible to ignore.
Privacy-preserving systems depend on many layers of computation, where a single improvement can materially change performance, cost, or what is practical to build.
New approaches are appearing continuously, increasingly accelerated by AI — across papers, repositories, libraries, hardware projects, and internal systems.
Finding, reproducing, comparing, and integrating the right approach still requires substantial engineering work.
each mark is a paper, an implementation or a hardware optimization someone would have to reproduce by hand
The bottleneck is shifting from creating implementations to understanding which ones actually matter.
A common representation for computational problems and their implementations.
A Kernel defines the computational interface. A Specification constrains its parameter space, assumptions, and semantics. Points instantiate concrete cases within that space, while implementations declare which Points they support.
kernel polymul<type T: Numeric, N: u32>(
%a: tensor<N x T>,
%b: tensor<N x T>,
) -> %c: tensor<N x T>spec negacyclic 1.0.0 {
kernel polymul<
N: u32,
W: u32,
L: u32 = (W + 31) / 32,
q: tensor<L x u32> (N, W),
>(
%a: tensor<N x L x u32>,
%b: tensor<N x L x u32>,
) -> %c: tensor<N x L x u32>
}This representation makes applicability explicit and provides a common basis for comparing heterogeneous implementations under equivalent conditions.
Compare implementations where it actually matters.
Implementation performance is context-dependent, varying with parameters, hardware, and optimization objective. FHERMA provides a common basis for evaluating implementations under the same Specification and across supported execution environments.
Turn an implementation into a callable service.
Deploy a supported implementation on the hardware you need and access it through a stable API.
FHERMA handles the execution environment, packaging, and runtime configuration required to run the Kernel. The result is a directly callable implementation, without reproducing the original software or hardware setup.
Deploy implementation →{
"input": "<ciphertext>",
"model": "fraud-detection-v1"
}
→ ciphertextPush the state of the art.
Build a high-performance GPU implementation of negacyclic polynomial multiplication using NVIDIA cuPQC as the arithmetic foundation. The target computation is multiplication in $$ R_q = \mathbb{Z}_q[X]/(X^N + 1) $$ for a fixed benchmark point representative of the large-integer arithmetic used in RLWE-based homomorphic encryption. ## Benchmark point - **N** = 65,536 — number of coefficients / ring dimension - **W** = 1,792 — coefficient width in bits - **L** = 56 — `u32` limbs per coefficient - **q** — a 1,792-bit prime with `q ≡ 1 (mod 2N)` - input and output — coefficient form - coefficient layout — 56 little-endian `u32` limbs Participants receive two polynomials `a` and `b` and must compute their exact product $$ c = a \cdot b \pmod{X^N + 1,\ q}. $$ The data layout is directly compatible with NVIDIA cuPQC BigInt. The challenge is defined around the underlying computation rather than a specific FHE library, so the resulting implementation is usable independently of any FHE stack. ## Specification The exact arithmetic semantics, parameter derivation, input/output representation and correctness requirements are defined by [`polynomial-multiplication/negacyclic@1.0.0`](/kernels/polynomial-multiplication/specifications/negacyclic). Every submission is evaluated against the same specification and benchmark point. ## Correctness Correctness is exact. For every test input the result must equal $$ a(X)b(X) \bmod (X^N + 1,\ q) $$ coefficient by coefficient, with each output coefficient represented canonically in `[0, q)` in the layout defined by the specification. No numerical tolerance is permitted. A submission that fails validation receives no benchmark score. The official verifier and testing rules are the specification's test bundle. ## Ranking The leaderboard contains only submissions that pass the official correctness verifier, ranked by **median wall-clock time for one complete multiplication at the challenge benchmark point**. The fastest qualifying implementation at the close of the challenge wins. A participant may submit multiple versions during the challenge; unless otherwise specified, the best valid result is used for ranking. ## Reward **$5,000**, awarded to the fastest qualifying implementation at the close of the challenge. Private implementations may participate — publishing source code is not required unless stated elsewhere in the challenge rules. ## How to participate 1. Create an **implementation** of the specification `polynomial-multiplication/negacyclic@1.0.0`. 2. Declare the **coverage** it supports, and make sure it includes this challenge's benchmark point (**N = 65,536, W = 1,792**). 3. Submit it. FHERMA tests and measures the implementation automatically against the specification's testing bundle, on the reference machine — you do not submit any benchmark numbers. 4. If it passes correctness at the benchmark point, its measured time appears on the leaderboard; an implementation that fails the tests receives no score. That is the whole loop: declare where your implementation works, and any implementation whose coverage includes the point is tested and ranked automatically. ## Resources - [Polynomial Multiplication kernel](/kernels/polynomial-multiplication) - [Negacyclic specification](/kernels/polynomial-multiplication/specifications/negacyclic) - [NVIDIA cuPQC — BigInt documentation](https://docs.nvidia.com/cuda/cupqc/libraries/cupqc_bigint/cupqc_bigint_usage.html) - [Homomorphic Encryption Security Guidelines (CiC), Table 5.2](https://cic.iacr.org/p/1/4/26/pdf)
Classify encrypted CIFAR-10 images — 32×32 colour images in ten classes — without decryption, under CKKS. A solution must reach 85% accuracy on a held-out subset of CIFAR-10 to qualify; qualifying solutions are ranked by runtime.
Sort an encrypted real array into non-decreasing order under CKKS. A correct sort qualifies; qualifying solutions are ranked by runtime.
Build on FHERMA.
Add a new kernel. Define a specification. Publish an implementation. Bring support for new hardware.
Contributions immediately become part of the same searchable, testable and comparable ecosystem.