Drop 64 Verified Operations Into Your Code. Today.

What Are the SDKs?

The BRIK64 SDKs bring the 64 verified monomers directly into your existing codebase. Instead of writing PCD and compiling, you call monomer functions from your language of choice. Each function carries its formal verification proof — you get the guarantees of Digital Circuitality without leaving your ecosystem.

Three SDKs are shipping today: Rust, JavaScript, and Python. The three languages that matter most.

Installation

Rust

cargo add brik64

JavaScript / TypeScript

npm install @brik64/sdk

Python

pip install brik64

Code Examples

Each SDK provides the exact same monomer functions with identical behavior across all three languages. Call certified operations directly from your Rust, JavaScript, or Python code — arithmetic, hashing, logic, string operations, and more. Every single function carries its mathematical certification, and cross-language reproducibility is not aspirational — it is guaranteed. Bit for bit.

The Monomers

Every SDK exposes the complete monomer set: 64 core operations for 8-bit integer arithmetic and 64 extended operations for floating-point and system interaction. That is 128 building blocks, organized into 8 core families — arithmetic, logic, memory, control flow, I/O, strings, cryptography, and system operations — plus 8 extended families for floating-point math, transcendentals, networking, graphics, audio, filesystem, concurrency, and interop. Everything you need to build verified computation.

And here is what makes this extraordinary: these are the exact same monomers in every SDK, in every language. The behavior is identical. The certifications are identical. A hash("hello") in Rust produces the exact same output as hash("hello") in Python. Not similar. Not approximately the same. Identical. That has never existed before in software.

Deterministic Arithmetic

BRIK64 arithmetic operates on bounded integers with fully defined overflow behavior. Every monomer has a precise, bounded specification — no undefined behaviors, no platform-dependent results. The same operation produces the same output in every language, on every platform. This determinism is what makes formal verification possible: the behavior is fully defined for all possible input combinations.

Mixing SDK Functions with Existing Code

SDKs are designed to integrate into existing projects. You don't need to rewrite your application in PCD. Use BRIK64 monomers for the critical paths — the parts that need to be verified — and keep your existing code for everything else:

// Your existing Express.js server
app.post("/transfer", async (req, res) => {
  const { from, to, amount } = req.body;

  // Use BRIK64 SDK for the critical computation
  // Fee calculation, net amount, integrity checksum — all verified
  const { net, checksum } = brik64.computeTransfer(from, to, amount);

  // Use your existing code for the rest
  await db.transfer(from, to, net, checksum);
  res.json({ success: true, net, checksum });
});

The BRIK64 functions are verified. Your surrounding code is not. But the critical computation — the fee calculation, the net amount, the integrity checksum — carries a mathematical proof. This is a pragmatic approach: verify what matters, integrate with what exists.

Certification: SDK Functions Carry Their Proof

Every SDK function is backed by a mathematical certification file. When you call add8(200, 100), you are not just calling a function — you are invoking a computation that has been mathematically proven correct for all possible inputs. Every single combination. The proof is not checked at runtime — it was completed at build time of the SDK itself. You inherit the proof simply by using the function. That is the power of certified building blocks.

You can verify this yourself:

brikc verify-sdk rust    # Verify Rust SDK proofs
brikc verify-sdk js      # Verify JavaScript SDK proofs
brikc verify-sdk python  # Verify Python SDK proofs

When to Use SDK vs PCD Compiler

Use SDKs when you want to add certified computations to an existing project without changing anything else, when you need to integrate with existing libraries and frameworks, or when your team already works in Rust, JavaScript, or Python and does not want to learn a new language.

Use PCD compiler when you are building a new application from scratch and want maximum certification, when you want full-program certification (Φ_c = 1 for the entire program), or when you need to compile to 14 different targets from a single source.

Use both when you want the best of everything: PCD for core logic with full certification, and SDKs for the integration layers that connect to the real world. The PCD compiler generates SDK-compatible code, and SDK functions can be used inside PCD circuits as certified externals. They are designed to work together.