HElib  1.3
Implementing Homomorphic Encryption
HElib Documentation

HElib is a software library that implements homomorphic encryption (HE). Currently available is an implementation of the Brakerski-Gentry-Vaikuntanathan (BGV) scheme, along with many optimizations to make homomorphic evaluation runs faster, focusing mostly on effective use of the Smart-Vercauteren ciphertext packing techniques and the Gentry-Halevi-Smart optimizations. Articles that describe some aspects of HElib include:

At its present state, this library is mostly meant for researchers working on HE and its uses. Also currently it is fairly low-level, and is best thought of as "assembly language for HE". That is, it provides low-level routines (set, add, multiply, shift, etc.), with as much access to optimizations as we can give. Hopefully in time we will be able to provide higher-level routines.

This library is written in C++ and uses the NTL mathematical library, over GMP. It is distributed under the terms of the Apache License, Version 2.0.

Building HElib

To build HElib, you will need to have GMP and NTL libraries installed. Many distributions come with GMP pre-installed. If not, you can install GMP as follows.

  1. Download GMP from http://www.gmplib.org
  2. Uncompress and cd into the directory gmp-XXX
  3. On the command line:
    sudo make install

This should install GMP into /usr/local. Once GMP is installed, you can install NTL as follows: (NOTE: you will needs NTL version 10.0.0 or higher)

  1. Download NTL from http://www.shoup.net/ntl/
  2. Uncompress and cd into the directory ntl-XXX/src
  3. On the command line:
    sudo make install

This should install NTL into /usr/local. Now that you have these libraries in place, you can cd to the HElib src directory to build HElib.

Right now, the "build system" for HElib is very rudimentary: no configure script and just a Makefile (with no make install). The Makefile will build the static library fhe.a in the HElib src directory, and then one can build applications programs based on fhe.a, also in the HElib src directory (or set the include and library parameters to include the right things). Hopefully, this build system will be improved in the future.

Before building HElib, you may want to look at the Makefile, and consider adjusting some of the defaults for CC and CFLAGS. The defaults should be OK on most systems, but you can see the suggested options, which are documented in the Makefile. On the command line in the HElib src directory:

make # this will compile and build the library fhe.a
make check # this will compile and runs a series of test programs.

If you want to build your own program based on HElib, the easiest way to do it is to write the program in a file called myprog.cpp and then run

make myprog_x

which will compile myprog.cpp and link in fhe.a and all required support libraries, and create the executable myprog_x.

Test Programs

Take a look at the programs Test_*.cpp for examples of using HElib. Those include:

For a list of command-line arguments that any of these programs accepts, run

Test_XYZ --help

Some comments

HElib uses some features of C++11. For gcc, depending on the version that you use, you may need to specify the flag '-std=c++11 -lstdc++' to be able to compile. There are several compilation flags that control some aspects of the library:


Tells HElib to not use the half size prime in the prime chain. By default, the modulus-chain in HElib consists of many "full-size primes" (of size n bits, typically n=50 or n=60 for 64-bit machines) and one "half-size prime" of n/2 bits. A level corresponds to n/2 bits in the size of the modulus, and dropping to a lower level is done either by dropping the half-size prime (if it is part of the current modulus) or by dropping a full-size prime and adding back the half-size prime (if it is not part of the current modulus). Specifying the flag NO_HALF_SIZE_PRIME makes all the primes the same size, with each prime corresponding to a level (so dropping to a lower level means dropping one of the primes).


tells HElib to enable generic multithreading capabilities; must be used with a thread-enabled NTL and the -pthread flag should be passed to gcc


tells HElib to use a multithreading strategy for bootstrapping; requires -DFHE_THREADS

Add some debugging printouts