Contact us 한국어|English
Back to Insights
Company News

DESILO FHE Library v2.0.0 Release Notes

Library TeamLibrary Team · DESILO
·

DESILO FHE Library v2.0.0 is now available (released 2026-10-15). Highlights:

2.0.0 is the first major release since April 2025. It introduces exciting new features that make FHE applications easier to develop and faster to run. This release is the result of six months of development and over 1,500 pull requests.

As a major release, 2.0.0 includes breaking changes that would not be introduced in a regular minor (feature) release. To migrate to 2.0, please refer to link in addition to these release notes.

Highlights

  • Unified CKKS and GL Backend: CKKS and GL now share the same data structures and computation backend. This allows future improvements to benefit both schemes simultaneously. Previously, most optimizations were applied only to CKKS operations.
  • Compact Representation Only: compact is now the default and only supported representation for CKKS. Support for compact in GL is under development and will be available soon.
  • Async GPU Mode by Default: async gpu mode is now the default and only supported option for NVIDIA GPUs. This change also significantly improves GL performance.
  • Evaluation Key: A new unified key, the Evaluation Key, can be used for all operations that require a key, except encryption and decryption. This greatly simplifies operations such as bootstrapping, which previously required three to four separate keys as arguments.

New Features

  • Multi-GPU Support: Engines in gpu mode with different device IDs can now coexist within the same process. This makes it easier to develop applications that use multiple GPUs.
  • Overlapping GPU Transfers and Computation: GPU data transfers and computations can now overlap when using two or more separate engines in gpu mode. If engine A attempts to access a data structure that engine B is still transferring to the GPU, engine A automatically waits for engine B's data transfer to complete before proceeding. No additional synchronization is required. Finer-grained synchronization will be introduced in the future.
  • Bootstrap Key Reuse: Bootstrap keys can now be used for roll, roll_many, and rotate, eliminating the need for separate roll or rotation keys and reducing memory requirements. Support for rotate_many will be added soon.
  • More Multiparty Levels: CKKS multiparty operations now support significantly more multiplicative levels.
  • GL Parallel Mode: GL now supports parallel mode, allowing multiple CPU threads to accelerate all operations.
  • GL Serialization: GL data structures can now be serialized and deserialized, making it easier to develop distributed applications.
  • GL CPU/GPU Data Transfers: GL now supports to_cpu and to_cuda, allowing data structures to move between CPU and GPU memory. This is particularly useful for applications where not all data structures can fit in GPU memory simultaneously.
  • GL Memory Size Properties: GL data structures now provide nbytes and serialized_nbytes properties. Representative sizes are available in link.
  • GL Public Key: GL now supports public keys, allowing messages to be encrypted without exposing the secret key.
  • GL Constant Arithmetic: GL now supports addition, subtraction, and multiplication between ciphertexts and constant values.
  • GL Polynomial Operations: make_power_basis and weighted_sum are now available for GL.
  • Public Security Parameters: The library's security parameters are now publicly documented. Please refer to link for details.

Optimizations

  • Faster Bootstrapping: Bootstrapping is approximately 15% faster.
  • Optimized Key Switching and Rescaling: Key switching and rescale operations have been optimized.
  • GL Performance Improvements: All GL operations have been rewritten and optimized to the same level as CKKS operations.
  • Faster Multiparty Operations: Multiparty operations are now up to twice as fast at a given level.
  • Reduced Key Memory Usage: Memory usage has been reduced by approximately 3% for all keys except secret keys, public keys, relinearization keys, and small bootstrap keys.
  • Faster Random Number Generation: Random number generation has been optimized. It is used internally during all key generation, encryption, and multiparty decryption operations.

Breaking Changes

This major release introduces several breaking changes. In general, the removed features and configurations offered limited practical value or saw little actual use, while significantly increasing maintenance and testing costs.

Serialization Format

  • New Serialization Format: The serialization format has been completely redesigned to accommodate the many new features and optimizations planned for future releases.
  • No Backward Compatibility: The new format is not backward-compatible with previous releases. The extensive changes made maintaining backward compatibility impractically complex. Breaking changes of this kind will not be introduced in regular minor (feature) releases.

Engine Construction

  • Keyword-Only Arguments: All arguments to the Engine constructor must now be passed as keyword arguments. This prevents accidentally passing values to the wrong parameters.
  • Renamed Arguments: use_bootstrap and use_multiparty have been renamed to bootstrap and multiparty, respectively.
  • Default Engine Configuration: Creating an engine without arguments is still supported. The default configuration is a CKKS engine with seven multiplicative levels.

Matrix Multiplication and Sparse Encoding

  • CKKS Matrix Multiplication Removed: CKKS matrix multiplication is no longer supported. Without sparse encoding, matrix sizes became too large, making both runtime and memory requirements impractical.
  • Sparse Encoding Removed: Sparse encoding is no longer supported. Although it was introduced to reduce matrix sizes, reducing them too aggressively also decreased throughput.
  • Future Matrix Multiplication Support: Current research increasingly focuses on efficient packing techniques for CKKS matrix multiplication rather than sparse encoding. Although GL is now available, its required shapes may still be too large for smaller applications. We plan to provide example code or a library feature to make CKKS matrix multiplication easier to implement in the future.

Bootstrapping

  • 17-Level Bootstrapping Only: Bootstrapping to 17 levels is now the only supported configuration. Among the three regular bootstrap variants available in previous releases, this variant provides the most levels and the lowest error, with minimal performance degradation.
  • Lossy and Sign Bootstrapping Removed: Lossy bootstrapping is no longer supported because its error was too high for practical use. Sign bootstrapping has also been removed because no compelling use case was identified.
  • Deprecated mod_raise and Custom Secrets: mod_raise and secret keys with custom secret values are now deprecated. These features were originally intended to support custom bootstrapping operations, which are no longer possible with the modulus configuration used for 17-level bootstrapping.
  • Large Bootstrap Key Removed: The large bootstrap key is no longer available. GPU implementations have been optimized to the point where larger keys can actually slow down computation, even when they reduce the total number of operations. Support for larger bootstrap keys may be reintroduced in the future using different optimization techniques.
  • Custom Stage Counts Removed: Specifying bootstrap stage counts is no longer supported. This option was available only for 10-level bootstrapping.

Large CKKS Parameters

  • 32,768 Slots Removed: CKKS configurations with 32,768 slots are no longer supported. Their key sizes were too large for practical use, and encoding and decoding errors were excessive at low levels (approximately levels 0–5).
  • Alternative for Higher Levels: Applications requiring more than the 36 levels provided by the largest CKKS engine can use a bootstrap-enabled engine.

GL Shapes

  • Maximum Innermost Dimension of 256: Some GL keys are larger than others by a factor proportional to the innermost dimension. GL shapes with an innermost dimension greater than 256 are no longer supported because their memory requirements were impractically high.
  • New Batch Counts of 162 and 486: New batch counts of 162 and 486, based on Euler's totient function of powers of 3, are now supported. Additional batch counts based on powers of 5 and 7 are planned. For currently supported shapes, please refer to link.

Rotation and Roll

  • Distinct Shift Directions: roll and rotate now use different shift directions. roll shifts elements to the right, while rotate shifts them to the left. The term rotate is commonly used by FHE experts, whereas roll is more familiar to data scientists. Both directions are now supported to accommodate these conventions. For more details, please refer to link.
  • Migration from rotate to roll: To preserve the previous shift direction, replace existing rotate calls with roll calls. Code already using roll, which was introduced in version 1.15, should continue to work without changes.
  • Unified Roll Keys: Fixed roll keys and roll keys are now available for both CKKS and GL. They provide the same functionality as the fixed rotation keys and rotation keys from previous releases.
  • Fixed Roll Keys for GL: Fixed roll keys are newly available for GL, which previously did not support fixed rotation keys.
  • New axis Property: Fixed roll keys now provide an axis property for GL. For CKKS, this property is None.
  • Keyword-Only level Argument: The level parameter must now be passed as a keyword argument to avoid confusion between the three integer parameters: shift, axis, and level.

CUDA Support

  • CUDA 13.2 and 13.4 Only: Older CUDA versions are no longer supported. The library now supports only CUDA 13.2 and 13.4. This reduces build and maintenance costs, simplifies testing, and allows development to focus on newer CUDA toolchains.
  • CUDA 13.0 Compiler Bug: CUDA 13.0 contains a compiler bug that can silently produce incorrect results in kernels with nested thread divergence. The issue was introduced in CUDA 12.8 and fixed in CUDA 13.2.2, making CUDA 13.2 and 13.4 the preferred supported versions. Although this bug has not been reproduced in the library, CUDA 13.0 support is being dropped as a preventive measure.

Custom Parameters

  • Custom Parameters Removed: Manually specifying the logarithm of the coefficient count and the number of special primes is no longer supported. These options were rarely used and offered little practical benefit.

GL Hadamard Multiplication

  • Renamed multiply Method: hadamard_multiply has been renamed to multiply to align with CKKS semantics.
  • Renamed Relinearization Key: The Hadamard multiplication key has been renamed to the relinearization key.
  • Multiplication Without Relinearization: Hadamard multiplication (now simply multiply) can be performed without a relinearization key. The resulting ciphertext contains three polynomials instead of the usual two and can be decrypted directly without relinearization, saving computation time. Additional operations on three-polynomial ciphertexts will be introduced in future releases.

Full release notes: https://fhe.desilo.dev/latest/release_notes/