Library / SDK
spaceandtimefdn/blitzar avatar
spaceandtimefdn/blitzar

Blitzar: x86-64 Linux binaries, a CPU and a GPU backend, and four build systems in one repository

Zero-knowledge proof acceleration with GPUs for C++ and Rust

4,863 stars159 forksC++Apache-2.0

At a glance

What is it?
Blitzar is Space and Time's C++ library for accelerating zero-knowledge proof computation on CPU and Nvidia GPU, adopted from libsodium and zkcrypto. Its release pipeline runs Bazel, Nix, Cargo and semantic-release, and its three most recent releases moved by patch number alone.
Who is it for?
Blitzar fits a team building zero-knowledge proofs over elliptic curve groups who already has CUDA hardware and wants the inner product argument and multi-scalar multiplication primitives without writing the GPU code, which is exactly the gap the Space and Time cryptography team says they hit while building Proof of SQL. Three limits to check first.
Can I use it commercially?
Yes. Apache-2.0 is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository last received commits 122 days ago.
What is it written in?
Mainly C++, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • spaceandtimefdn/blitzar4,863 ★ · +1
Star history
Repository2026-09-232026-11-15
spaceandtimefdn/blitzar4.9k4.9k

1 Stars in the last 53 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

Built for one proof system, then opened to everyone

The origin story is narrow and worth knowing before reading the API. Blitzar was created by the core cryptography team at Space and Time to accelerate Proof of SQL, a zero-knowledge proof for SQL operations. After surveying options for a GPU acceleration framework, the team concluded that Proof of SQL needed something better and built this. The performance claim attached to that is specific: Proof of SQL can execute analytic queries on over a million rows in less than a second. Then the project was open-sourced, with the stated aim of giving the Web3 community a faster framework for GPU-accelerated proofs and inviting contributions to widen its scope. The file also asks for feature requests through the issue tracker and describes the project as community-first. In practice the library is a primitives layer, not a proof system: group operations, a multi-scalar multiplication, and an inner product argument, which is what a proof system of that shape needs from a hardware layer.

Adopted from libsodium and zkcrypto, then extended for CUDA

The cryptographic code is not original, and the file says so in one sentence with a typo worth repeating for accuracy: the library is adopted from code in the libsodium and zkcrypto projects, and it extends both projects' cryptographic functions to support CUDA so that they are usable on GPUs. Adopted rather than adapted, in the file itself. That provenance matters for two reasons. First, it tells you the group arithmetic comes from two well known implementations, and Blitzar's contribution is the acceleration layer and the bindings rather than new curve mathematics. Second, it tells you which upstream to watch for fixes. The curve list comes out of the same paragraph set: group operations on Curve-25519, Ristretto25519, bls12-381 G1, bn254 G1 and Grumpkin elements. Later, in the multi-scalar multiplication section, the same family is named again as Curve25519, bls12-381 G1, bn254-381 G1 and Grumpkin, with Ristretto25519 absent and bn254 written as bn254-381. Small naming drift, worth pinning down in your own code rather than guessing.

Prebuilt binaries exist for one platform, and the driver is the only dependency

Installation is described in three sentences with a clear division of labour. Prebuilt binaries are provided for glibc-based, x86-64 Linux distributions. Dependencies are statically linked and set to have internal linkage with export maps, which the file says is to ensure portability. And the only run-time dependency for using GPU acceleration is an up-to-date GPU driver. So there is no BLAS to install, no CUDA toolkit requirement at run time, and a binary that is meant to be dropped somewhere and called. Two consequences follow from the platform list. There is no macOS, Windows or ARM build, which pushes anyone on those platforms to a source build. And for most users the file recommends installing with cargo through the companion blitzar-rs crate instead of using this library directly, while users who want the C API download the shared library and header file from the GitHub release. So the C route is the direct one and the cargo route is the recommended one, and they are not the same artefact.

Two backends, one of which exists for testing

The computational backend table is the shortest and most useful part of the README, because it states exactly what hardware is in scope. There are two backends. The `cpu` backend is a serial implementation targeting x86 capable CPUs. The `gpu` backend is a parallel implementation targeting Nvidia CUDA capable GPUs. And the framing sentence above the table explains the asymmetry: the primary goal is GPU acceleration, and CPU support is provided for the sake of testing. That sentence settles several questions at once. A CPU run is not the optimised path, it is the reference implementation you check against. And the word in the table is Nvidia, with no mention of any other GPU vendor, which in practice means there is no ROCm or Metal path. The README's badge row links a CUDA downloads page, so the CUDA toolkit is part of the build even though the driver is all you need at run time.

Multi-scalar multiplication goes by two names and skips index zero

The first primitive is multi-scalar multiplication, which the file also calls generalized Pedersen commitments and multiexponentiation, and it explains why the names differ: when the group is written additively the operation is a multi-scalar multiplication, and when it is written multiplicatively it is a multiexponentiation. The mathematics is set out with the group elements and the scalars in the matching field:

math
P = a_1\cdot g_1+\cdots+ a_n\cdot g_n

Two details in that passage are practical rather than cosmetic. The elements and scalars are introduced from index zero, while the printed commitment starts at index one, so if you are implementing against the document you have to decide for yourself whether a term in index zero is included. And the implementation is not limited to a single multiplication: it computes several MSMs at once, they may be of different lengths, and the generators can either be built-in precomputed values or supplied by the caller. That last point is the one to check if you are porting a protocol with its own generator set.

The inner product argument is modified, and meant for a larger protocol

The second primitive is the inner product argument, described as a modified implementation of the argument used by Bulletproofs and Halo2. Given generators, a Pedersen commitment, a scalar and two vectors, the prover establishes two relations at once: the commitment matches the linear combination of generators with the first vector, and the scalar equals the inner product of the two vectors. The file is explicit about the assumption behind it, which is that the generators, the second vector and the scalar are known to both prover and verifier, and equally explicit about the scope, saying this version can be used in the context of a broader protocol. That is the sentence to sit with if you are evaluating Blitzar for a proof system. It is the inner product layer, not a complete proof. For Rust, the overview describes a sys-crate and bindings that make commitment computations usable from Rust.

Bazel, Nix, Cargo and semantic-release share one repository

The root listing explains how the library is built and released, and there are four build systems in it. Bazel has its own configuration files, `.bazelrc`, `.bazelversion`, `MODULE.bazel`, `MODULE.bazel.lock` and a `WORKSPACE` file, plus a `bazel/` directory, so both the module registry and the legacy workspace mechanism are present. Nix is there as `flake.nix`, `flake.lock` and a `nix/` directory. Cargo is there as `.cargo/` and `rust/`. And the release pipeline is npm based, through `package.json` with `semantic-release`. The manifest is named `blitzar_sxt` with a version of `0.0.0-development`, because semantic-release writes the real version. The release configuration pins the branches to `main`, sets the conventional commits preset, and adds one rule of its own, mapping commits of type `build` to a patch release, plus three note keywords for breaking changes. The build itself is invoked from the release tooling:

json
"prepareCmd": "bash ./ci/build.sh libblitzar-linux-x86_64.so ${nextRelease.version} --with-release"

and the published assets are the headers, the shared objects and the archives, matched as `dist/*.h`, `dist/*.so*`, `dist/*.zip` and `dist/*.tar.gz`.

Version 1.115.3 moved by patch number for a year

The release numbers explain themselves once the configuration is read. The three releases shown are v1.115.0 from 2025-04-14, v1.115.1 from 2025-06-18 and v1.115.3 from 2026-06-16, so the minor component is frozen at 115 across fourteen months while only the patch number moves, and v1.115.2 is not among the three most recent. That is consistent with a repository whose releases come from conventional commits with only a patch rule for build changes and no routine minor bumps. The practical consequence is that the version number tells you almost nothing about what changed, so the commit history or the release notes are the only useful inputs. The rest of the tree is conventional and worth a note for a first-time reader: `benchmark/` for measurements, `example/` with four runnable examples named `cbindings1`, `exponentiation1`, `field_arithmetic` and `multiproduct1`, `third_party/` for vendored code, `sxt/` for the project's own namespace prefix, `app/` and `tools/`, and `STYLE.md` with `.clang-format` and a contributing guide.

Editorial conclusion

Blitzar fits a team building zero-knowledge proofs over elliptic curve groups who already has CUDA hardware and wants the inner product argument and multi-scalar multiplication primitives without writing the GPU code, which is exactly the gap the Space and Time cryptography team says they hit while building Proof of SQL. Three limits to check first. Prebuilt binaries are for glibc-based x86-64 Linux only, so anything else is a source build through Bazel or Nix. GPU acceleration means an Nvidia CUDA capable GPU, since the backend table names no other vendor and the CPU backend exists for testing. And Rust is a redirect: this repository carries the sys-crate and bindings, but the file tells Rust users to take the crate from the companion blitzar-rs repository instead. Apache-2.0, with the newest release v1.115.3 from 2026-06-16.

Frequently asked questions

What is Blitzar?

Blitzar is a C++ library for accelerating cryptographic zero-knowledge proof algorithms on CPU and GPU, created by the cryptography team at Space and Time to accelerate Proof of SQL. Its group arithmetic is adopted from libsodium and zkcrypto, extended to support CUDA so it runs on GPUs.

Which curves does Blitzar support?

The overview names group operations on Curve-25519, Ristretto25519, bls12-381 G1, bn254 G1 and Grumpkin. The multi-scalar multiplication section names the same family as Curve25519, bls12-381 G1, bn254-381 G1 and Grumpkin, dropping Ristretto25519 and writing bn254 as bn254-381.

How do I install Blitzar?

For most users the file recommends cargo through the blitzar-rs crate. Users of the C API download the shared library and header file from the GitHub release. Prebuilt binaries cover glibc-based x86-64 Linux, with dependencies statically linked, and the only run-time dependency for GPU acceleration is an up-to-date GPU driver.

Does Blitzar support AMD GPUs or macOS?

Neither is listed. The backend table names two backends, `cpu` as a serial implementation for x86 capable CPUs and `gpu` as a parallel implementation for Nvidia CUDA capable GPUs, with CPU support provided for the sake of testing, and prebuilt binaries are stated to be for glibc-based x86-64 Linux distributions.

Should Rust users depend on this Blitzar repository?

The README says this repository contains the C++ implementation along with cbindings and a Rust sys-crate, but that Rust users should use the crate from the companion blitzar-rs repository instead.

Official sources

  1. License: Apache-2.0
  2. Project website
  3. README
  4. Releases
  5. spaceandtimefdn/blitzar on GitHub
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/spaceandtimefdn-blitzar.svg)](https://hysenlabs.com/projects/spaceandtimefdn-blitzar)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/spaceandtimefdn-blitzar.svg)](https://hysenlabs.com/projects/spaceandtimefdn-blitzar)

Was this useful?