**Concrete** is a fully homomorphic encryption (FHE) library that implements Zama's variant of TFHE. TFHE is based on Learning With Errors (LWE), a well studied cryptographic primitive believed to be secure even against quantum computers.

Concrete is currently released in alpha. The API is not stable and likely to change short term.

Concrete is an open source library. The code is available on Github.

In cryptography, a raw value is called a **message** (also sometimes called a **cleartext**), an encoded message is called a **plaintext** and an encrypted plaintext is called a **ciphertext**.

The idea of homomorphic encryption is that you can compute on ciphertexts while not knowing messages encrypted in them. A scheme is said to be *fully homomorphic*, meaning any program can be evaluated with it, if at least two of the following operations are supported ($x$is a plaintext and $E[x]$ is the corresponding ciphertext):

homomorphic univariate function evaluation: $f(E[x]) = E[f(x)]$

homomorphic addition: $E[x] + E[y] = E[x + y]$

homomorphic multiplication: $E[x] * E[y] = E[x * y]$

Zama's variant of TFHE is fully homomorphic and deals with approximate real numbers ($\mathbb{R}$) as messages. It implements homomorphic addition and function evaluation via **Programmable Bootstrapping**. You can read more about Zama's TFHE variant in the preliminary whitepaper.

Using FHE in a Rust program with Concrete consists in:

generating a secret key using secure parameters

encoding input messages into fixed-precision plaintexts

encrypting plaintexts using the secret key to produce ciphertexts

operating homomorphically on ciphertexts

decrypting the resulting ciphertexts into plaintexts using the secret key

decoding plaintexts to get the final output messages

Here is an example program that adds two ciphertexts:

use concrete::*;fn main() -> Result<(), CryptoAPIError> {// generate a secret keylet secret_key = LWESecretKey::new(&LWE128_630);// the two values to addlet m1 = 8.2;let m2 = 5.6;// Encode in [0, 10[ with 8 bits of precision and 1 bit of paddinglet encoder = Encoder::new(0., 10., 8, 1)?;// encrypt plaintextslet mut c1 = LWE::encode_encrypt(&secret_key, m1, &encoder)?;let c2 = LWE::encode_encrypt(&secret_key, m2, &encoder)?;// add the two ciphertexts homomorphically, and store in c1c1.add_with_padding_inplace(&c2)?;// decrypt and decode the resultlet m3 = c1.decrypt_decode(&secret_key)?;// print the result and compare to non-FHE additionprintln!("Real: {}, FHE: {}", m1 + m2, m3);Ok(())}

Concrete being a library, all functions are wrapped in a `Result`

to let you manage errors the way you see fit for your program.

This guide will walk you through using the Concrete library to build homomorphic programs, explaining the underlying key concepts as they are encountered.