lambdaworks

lambdaworks

From the heights of these towers of fields, forty centuries of mathematics look down on us.

This library provides an efficient implementation of cryptographic primitives used to build proving systems. Along with it, many backends for proving systems are shipped, and compatibility with different frontends is supported.

• Transforming the Future with Zero-Knowledge Proofs, Fully Homomorphic Encryption and new Distributed Systems algorithms
• Lambda Crypto Doctrine

[![Telegram Chat][tg-badge]][tg-url] [tg-badge]: https://img.shields.io/endpoint?url=https%3A%2F%2Ftg.sumanjay.workers.dev%2Flambdaworks%2F&logo=telegram&label=chat&color=neon [tg-url]: https://t.me/lambdaworks

Examples - mini apps

Below is a list of examples to understand lambdaworks and learn what you can build with the tools provided. Most are educational examples and must not be used in production.

Cryptographic Signatures

• ECDSA signatures (secp256k1)
• BLS signatures
• Schnorr signatures
• FROST threshold signatures
• XMSS post-quantum signatures

Proof Systems & SNARKs

• BabySNARK
• Pinocchio
• Using Circom with lambdaworks's Groth16
• Proving Miden

Cryptographic Primitives

• Merkle Tree CLI

• Shamir's secret sharing

• Reed-Solomon Codes

• Naive RSA

• Pohlig-Hellman algorithm

• You can use Circom to generate circuits and use lambdaworks's capabilities to prove the execution with Groth16.

• You can use the Stark prover to define an algebraic intermediate representation (AIR) and prove the execution of a program

Why we built lambdaworks

Zero-Knowledge and Validity Proofs have attracted significant attention over the last few years. We strongly believe in this potential, which is why we decided to start working in this challenging ecosystem where math, cryptography, and distributed systems meet. The main barrier at the beginning was not cryptography or math, but the lack of good, performant, developer-friendly libraries. There are some exceptions, though, like gnark or Halo 2. Some have nice APIs and are easy to work with, but they are not written in Rust; others are written in Rust but have poor programming and engineering practices. Most of them don't support CUDA, Metal, WebGPU, or distributed FFT calculations using schedulers like Dask.

So, we decided to build our library with performance in mind, providing clear documentation and a developer-focused approach. Our core team is a group of passionate people from diverse backgrounds and strengths; we believe the whole is greater than the sum of its parts. We don't want to be a compilation of every research result in the ZK space. We want this to be a library that can be used in production, not just in academic research. We want to offer developers the main building blocks and proof systems so that they can build their applications on top of this library.

Documentation

Quick Start

Add lambdaworks to your project:

[dependencies]
lambdaworks-math = "0.13.0"
lambdaworks-crypto = "0.13.0"

Field arithmetic

use lambdaworks_math::field::{
    element::FieldElement,
    fields::fft_friendly::stark_252_prime_field::Stark252PrimeField,
};

// Create field elements
type FE = FieldElement;

let a = FE::from(5u64);
let b = FE::from(3u64);

// Arithmetic operations
let sum = &a + &b;           // 8
let product = &a * &b;       // 15
let square = a.square();     // 25
let inverse = b.inv().unwrap();
assert_eq!(&b * &inverse, FE::one());

Elliptic curve operations

use lambdaworks_math::elliptic_curve::{
    short_weierstrass::curves::bls12_381::curve::BLS12381Curve,
    traits::IsEllipticCurve,
};

// Get the generator point
let g = BLS12381Curve::generator();

// Scalar multiplication
let g2 = g.operate_with_self(2u64);
let g3 = g.operate_with(&g2);

// Convert to affine coordinates
let g3_affine = g3.to_affine();

Polynomial operations

use lambdaworks_math::{
    field::element::FieldElement,
    field::fields::u64_prime_field::U64PrimeField,
    polynomial::Polynomial,
};

type F = U64PrimeField;
type FE = FieldElement;

// Create polynomial: p(x) = 1 + 2x + 3x²
let p = Polynomial::new(&[FE::from(1), FE::from(2), FE::from(3)]);

// Evaluate at a point
let result = p.evaluate(&FE::from(2)); // 1 + 4 + 12 = 17

// Interpolate from points
let poly = Polynomial::interpolate(
    &[FE::from(0), FE::from(1), FE::from(2)],
    &[FE::from(1), FE::from(2), FE::from(5)], // values of some quadratic
).unwrap();

For more examples, see the examples directory and the math crate documentation.

Main crates

• Math
• Crypto primitives
• STARK Prover
• Plonk Prover
• Groth 16

Crypto

• Elliptic curves
• Multiscalar multiplication
• Hashes

Performance Features

• x86-64 Assembly Optimizations: Hand-tuned assembly for field arithmetic on supported platforms
• GPU Acceleration: CUDA backend for Merkle tree construction and FFT operations
• Metal Backend: Apple Silicon GPU acceleration for FFT and field operations
• Sparse Polynomials: Memory-efficient representation for polynomials with few non-zero coefficients
• Optimized FFT: Circle FFT and NTT implementations with field-specific optimizations

Most of the math and crypto crates support no-std without allocation with no-default-features. A few functions and modules require the alloc feature.

Both Math and Crypto support wasm with the target wasm32-unknown-unknown. To see an example of how to use this to deploy a verifier in a browser, check the Cairo Prover wasm-pack verifier.

Exercises and Challenges

• lambdaworks exercises and challenges
• Roadmap for Sparkling Water Bootcamp

Citing lambdaworks

If you use lambdaworks libraries in your research projects, please cite them using the following template:

@software{lambdaworks,
  author={lambdaworks contributors},
  title={lambdaworks},
  url={https://github.com/lambdaclass/lambdaworks},
  year={2023}
}

List of features

Disclaimer: This list contains cryptographic primitives and mathematical structures that we want to support in lambdaworks. It can be expanded later to include new primitives. If you find a mistake or notice an update in another library, please let us know.

List of symbols:

• :heavy_check_mark: means the feature is currently supported.
• ️ means that the feature is partially implemented or is under active construction.
• :x: means that the feature is not currently supported.