TUTORIALMAR 21, 2026

From JavaScript to Rust in 3 Commands

You have a JavaScript function that works. You need it in Rust. Three commands. Verified. Done.

The Problem with Language Migration

You have a JavaScript function that works. You need it in Rust. What do you do today?

Option A: Rewrite it by hand. Hope you got the edge cases right. Write new tests. Debug for a week.

Option B: Ask an AI to translate it. Get something that looks right. Discover a subtle integer overflow bug in production three months later.

Option C: Three commands.

brikc lift utils.js        # 1. Convert to verified blueprint
brikc check utils.pcd      # 2. Verify the blueprint
brikc build utils.pcd \
  --target rust             # 3. Export to Rust + tests

Let's walk through a real example.

Step 1: Lift

You have this JavaScript:

// utils.js
function fibonacci(n) {
  if (n <= 1) return n;
  let a = 0, b = 1;
  for (let i = 2; i <= n; i++) {
    let temp = a + b;
    a = b;
    b = temp;
  }
  return b;
}

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

function gcd(a, b) {
  while (b !== 0) {
    let temp = b;
    b = a % b;
    a = temp;
  }
  return a;
}

Run the Lifter:

$ brikc lift utils.js

⚡ Lifting utils.js (JavaScript)...

Summary: 3/3 functions liftable
Overall score: 100%

  ✓ LIFTABLE fibonacci — 100%
  ✓ LIFTABLE clamp     — 100%
  ✓ LIFTABLE gcd       — 100%

3 circuits lifted

All three functions are pure (no side effects, deterministic). The Lifter converts them to PCD blueprints automatically.

Step 2: Check

Verify that the blueprints are correct:

$ brikc check fibonacci.pcd
  ✓ fibonacci: verified (0.001s)

$ brikc check clamp.pcd
  ✓ clamp: verified (0.001s)

$ brikc check gcd.pcd
  ✓ gcd: verified (0.001s)

Each blueprint is mathematically verified. The logic is correct for every possible input. Not "tested against some cases" — proven for all cases.

Step 3: Build

Export to Rust:

$ brikc build fibonacci.pcd --target rust
  ✓ Generated: fibonacci.rs
  ✓ Generated: fibonacci_test.rs (6 test cases)

$ brikc build clamp.pcd --target rust
  ✓ Generated: clamp.rs
  ✓ Generated: clamp_test.rs (8 test cases)

$ brikc build gcd.pcd --target rust
  ✓ Generated: gcd.rs
  ✓ Generated: gcd_test.rs (5 test cases)

You now have idiomatic Rust with auto-generated tests. Not a line-by-line translation — the code is generated from the verified blueprint, following Rust conventions.

But wait — what about the other direction?

The same blueprint can export to any language:

# To Python
$ brikc build fibonacci.pcd --target python
  ✓ fibonacci.py + test_fibonacci.py

# To JavaScript (yes, back to JS — but now with generated tests)
$ brikc build fibonacci.pcd --target javascript
  ✓ fibonacci.js + fibonacci.test.js

# To WebAssembly
$ brikc build fibonacci.pcd --target wasm32
  ✓ fibonacci.wasm

# To native binary
$ brikc build fibonacci.pcd --target native
  ✓ fibonacci (x86-64 ELF)

One blueprint. Five outputs. All verified. All with tests.

Why this is better than AI translation

When an AI translates JavaScript to Rust, it's pattern matching — "this JS pattern usually maps to this Rust pattern." It works most of the time. But "most of the time" is exactly the problem.

When BRIK-64 exports from a PCD blueprint:

1. The logic is verified (mathematically proven correct). 2. The target code is generated from the verified specification. 3. The tests are derived from the verification, not guessed. 4. Every export produces the same behavior — JS, Rust, Python all implement the same verified blueprint.

It's not translation. It's generation from a proven specification.

The complete migration workflow

1. brikc lift legacy-app/src/ --format json
   → See which functions are migratable (usually 60-80%)

2. Review the liftability report
   → Pure functions: ready to migrate
   → Impure functions: need architectural decisions

3. brikc build *.pcd --target rust
   → Generate Rust code + tests for all liftable functions

4. Push to new GitHub repo
   → Certified, tested, ready for production

Getting started

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

# Try it on your code
brikc lift your-file.js

# Export to your target language
brikc build your-function.pcd --target rust

Three commands. Verified migration. Tests included.