UltrafastSecp256k1 — open-source C++20 library: 4.88M ECDSA signs/sec on a single GPU, zero dependencies, 12+ platforms (CUDA/Metal/OpenCL/WASM/ESP32/STM32)

Hey everyone,

I've been working on an open-source secp256k1 elliptic curve library focused on

raw throughput across heterogeneous hardware. Sharing it here for feedback.

## What is it?

A zero-dependency C++20 secp256k1 library with GPU acceleration (CUDA, OpenCL,

Metal, ROCm) and support for 12+ platforms including embedded (ESP32, STM32).

## GPU Numbers (RTX 5060 Ti, kernel-level)

| Operation | Throughput | Time/Op |

|-----------|-----------|---------|

| ECDSA Sign (RFC 6979) | **4.88 M/s** | 204.8 ns |

| ECDSA Verify (Shamir+GLV) | **2.44 M/s** | 410.1 ns |

| Schnorr Sign (BIP-340) | **3.66 M/s** | 273.4 ns |

| Schnorr Verify (BIP-340) | **2.82 M/s** | 354.6 ns |

| Field Multiplication | **4,142 M/s** | 0.2 ns |

## What makes it different?

- **Zero dependencies** — no Boost, no OpenSSL. Pure C++20.

- **4 GPU backends** — CUDA, OpenCL, Metal, ROCm. Only open-source lib

doing full ECDSA+Schnorr sign/verify on GPU.

- **Dual security model** — FAST path (variable-time, max throughput) +

CT path (constant-time, no secret-dependent branches). Both always compiled in.

- **12+ platforms** — x86-64, ARM64, RISC-V, WASM, iOS, Android, ESP32-S3,

ESP32, STM32, plus GPU backends.

- **Stable C ABI** (`ufsecp`) with 45 functions — bindings for C#, Python,

Go, Rust, Java, Node.js, Dart, PHP, Ruby, Swift, React Native.

- **Full protocol suite** — ECDSA, Schnorr/BIP-340, ECDH, BIP-32/44,

MuSig2, Taproot, FROST (t-of-n threshold), Pedersen commitments,

adaptor signatures, batch verification.

- **5×52 field repr** with `__int128` lazy reduction — 2.76× faster than 4×64.

- **ESP32-S3** does scalar×G in 2.5ms — viable for IoT signing.

## Packages

Available on npm (`ufsecp`, `react-native-ufsecp`), NuGet, RubyGems, Maven,

plus downloadable archives for Python, Go, Rust, Dart, PHP, Swift, C/C++ headers.

## Important caveat

**This is a research project. It has NOT been independently audited.**

For production systems, use [bitcoin-core/secp256k1](https://github.com/bitcoin-core/secp256k1).

If you need maximum throughput on GPU/embedded/multi-platform and understand the

risks, this might be interesting.

## Links

- **GitHub**: https://github.com/shrec/UltrafastSecp256k1

- **License**: AGPL-3.0

- **Benchmarks**: https://github.com/shrec/UltrafastSecp256k1/blob/main/docs/BENCHMARKS.md

- **API Reference**: https://github.com/shrec/UltrafastSecp256k1/blob/main/docs/API_REFERENCE.md

Happy to answer any questions about the implementation, architecture decisions,

or GPU kernel design.