Building with SDKs

What Are the SDKs?

The BRIK-64 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 available today: Rust, JavaScript, and Python.

Installation

Rust

cargo add brik64

JavaScript / TypeScript

npm install @brik64/sdk

Python

pip install brik64

Code Examples

Each SDK provides the same monomer functions with identical behavior across languages. Call verified operations directly from your Rust, JavaScript, or Python code — arithmetic, hashing, logic, and more. Every function carries its formal verification proof, and cross-language reproducibility is guaranteed.

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. They are organized into 8 families covering 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.

These are the same monomers in every SDK, in every language. The behavior is identical. The proofs are identical. A hash("hello") in Rust produces the exact same output as hash("hello") in Python. Cross-language reproducibility is guaranteed.

Deterministic Arithmetic

BRIK-64 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 BRIK-64 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 BRIK-64 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 BRIK-64 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 Coq proof file. When you call add8(200, 100), you're not just calling a function — you're invoking a computation that has been formally proven correct for all possible inputs. The proof is not at runtime; it was done at build time of the SDK itself. You inherit the proof by using the function.

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 verified computations to an existing project, when you need to integrate with existing libraries and frameworks, or when your team already works in Rust/JS/Python.

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

Use both when you want PCD for core logic and SDKs for integration layers. The PCD compiler can generate SDK-compatible code, and SDK functions can be used inside PCD circuits as verified externals.