Your Code Already Exists. Now Verify It.

Introducing the BRIK-64 Lifter

You have a codebase. Thousands of functions. Some you wrote, some your teammates wrote, some an AI wrote at 2 AM. They all work — probably. Tests pass — mostly. Code review happened — sometimes.

But here's the question nobody asks: which of your functions are mathematically correct?

Not "tested." Not "reviewed." Correct. As in: provably, formally, impossible to produce wrong output for any input.

Until now, answering that question required rewriting everything in a formal language. Nobody has time for that.

Today that changes.

Meet the Lifter

The BRIK-64 Lifter is a reverse compiler. It takes your existing JavaScript or TypeScript code and analyzes every function:

$ brikc lift src/utils.js

⚡ Lifting src/utils.js (JavaScript)...

Summary: 8/12 functions liftable (1 partial, 3 unliftable)
Overall score: 72%

  ✓ LIFTABLE  calculateTotal    — 100%
  ✓ LIFTABLE  formatCurrency    — 100%
  ✓ LIFTABLE  validateEmail     — 95%
  ✓ LIFTABLE  fibonacci         — 100%
  ✗ BLOCKED   fetchFromAPI      — side effect: network request
  ✗ BLOCKED   writeToFile       — side effect: filesystem
  ✗ BLOCKED   updateDOM         — side effect: DOM mutation

No configuration. No annotations. No rewriting. Just point it at your code.

What happens behind the scenes

The Lifter does three things:

1. Analyzes each function for "liftability"

It checks whether a function is pure — deterministic, no side effects, no external dependencies. Pure functions can be formally verified. Impure ones can't (and the Lifter tells you exactly why).

2. Converts liftable functions to PCD blueprints

PCD (Printed Circuit Description) is a language where every program is a verified blueprint. The Lifter translates your JavaScript logic into PCD automatically. You don't need to learn PCD — the Lifter speaks both languages.

3. Generates a liftability report

You get a clear picture of your codebase: what percentage is verifiable, what isn't, and exactly what's blocking each function.

A real example

Let's take a simple utility file:

// utils.js

function add(a, b) {
  return a + b;
}

function clamp(value, min, max) {
  if (value < min) return min;
  if (value > max) return max;
  return value;
}

async function fetchUser(id) {
  const res = await fetch(`/api/users/${id}`);
  return res.json();
}

Run the Lifter:

$ brikc lift utils.js

⚡ Lifting utils.js (JavaScript)...
  ✓ LIFTABLE add     — 100%
  ✓ LIFTABLE clamp   — 100%
  ✗ BLOCKED  fetchUser — async function (non-deterministic)

2 circuits lifted, 3 functions analyzed

add and clamp are now PCD blueprints. fetchUsercan't be lifted because network requests are inherently non-deterministic — and the Lifter tells you that upfront. No surprises.

Now export to any language — with tests

The blueprints are verified. Now generate production code:

# Export to Rust
$ brikc build add.pcd --target rust
  ✓ Generated: add.rs
  ✓ Generated: add_test.rs (4 test cases)

# Export to Python
$ brikc build clamp.pcd --target python
  ✓ Generated: clamp.py
  ✓ Generated: test_clamp.py (6 test cases)

The tests are auto-generated from the blueprint's verification. They're not guesses — they cover the verified behavior.

What this means for your codebase

Run the Lifter across your entire project:

$ find src -name "*.js" -exec brikc lift {} \;

You'll get a map of your codebase's formal verifiability. Some teams find that 60-80% of their utility functions are liftable. That's 60-80% of your logic that can be mathematically proven correct — without changing a line.

The functions that can't be lifted are fine

Not everything needs to be formally verified. Network requests, DOM manipulation, file I/O — these are inherently side-effectful. The Lifter doesn't judge them. It just tells you the boundary between what's provable and what's not.

The insight is: most business logic (validation, calculation, transformation, parsing) is pure. And pure means verifiable.

Get started

# Install
curl -fsSL https://brik64.dev/install | sh

# Analyze your code
brikc lift src/utils.js

# See the full report
brikc lift src/utils.js --format json

Your code already exists. Now you know which parts are bulletproof.