Solutions

Products

Pricing

Resources

Github

SOLUTIONS

Research

Meet Stoffel

Your private by design teammate

Build privacy-first products your users can trust from the start

Run the quickstart

Review privacy fit

stoffel quickstart

$ stoffel init my-app --template rust
✓ created my-app

$ stoffel compile src/main.stfl -o build/main.stflb
✓ private computation compiled

$ stoffel run build/main.stflb --input amount=42
✓ result opened: 42

Your app should not need every private detail to be useful

Encryption and access control protect the edges. The hard part is when your product needs sensitive context to score, match, train, or generate a key.

Usual stack

1

Encrypt data at rest on the device

2

Encrypt it in transit to your server

3

Decrypt to run app logic

4

Your app becomes the place users have to trust

Stoffel stack

1

Encrypt data at rest on the device

2

Encrypt it in transit to your server

3

Compute over shares. Your logic runs across private shares.

4

Private details stay outside the app path

What teams try before Stoffel

Most alternatives protect where data rests or who can access it. Stoffel changes the step where your product computes on sensitive context.

Alternative

Where it helps

Where it stops

Encryption at rest / in transit

Protects storage and movement

The app still decrypts before it computes

Access control and consent

Limits who can use the system

The approved system may still see too much

Anonymization or policy promises

Supports reporting and review language

Joined datasets can make private details legible again

Bespoke MPC research

Can fit narrow custom protocols

Hard to make part of a normal dev loop

Stoffel changes the compute step.

Sensitive context becomes shares before your product computes. Your app opens only the data it needs.

Keep private details out of your app

Turn sensitive context into shares. Open only what your product needs.

Run the quickstart

Inside the stack

Privacy built into the architecture, not patched on after review

def random_bit() -> secret bool:
  while True:
    var r = Share.random_field()
    var r_squared = Share.open_field(Share.mul(r, r))

    if Field.is_zero(r_squared):
      continue

    var r_prime = Field.sqrt(r_squared)              # canonical root in (0, p/2)
    var r_prime_inv = Field.inverse(r_prime)         # r'^-1
    var two_inv = Field.inverse(Field.from_int(2))   # 2^-1

    var c = Share.mul_field(r, r_prime_inv)          # [c] = r'^-1 [r] in {-1, +1}
    var a = Share.mul_field(Share.add_field(c, Field.one()), two_inv)
    # `a` holds 0 or 1; retag the wide field share as a 1-bit `secret bool`.
    return Share.retag(a, 1)

Define the private logic

Write the product logic that decides what data can open: a match, score, aggregate, key, or model update.

def random_bit() -> secret bool:
  while True:
    var r = Share.random_field()
    var r_squared = Share.open_field(Share.mul(r, r))

    if Field.is_zero(r_squared):
      continue

    var r_prime = Field.sqrt(r_squared)              # canonical root in (0, p/2)
    var r_prime_inv = Field.inverse(r_prime)         # r'^-1
    var two_inv = Field.inverse(Field.from_int(2))   # 2^-1

    var c = Share.mul_field(r, r_prime_inv)          # [c] = r'^-1 [r] in {-1, +1}
    var a = Share.mul_field(Share.add_field(c, Field.one()), two_inv)
    # `a` holds 0 or 1; retag the wide field share as a 1-bit `secret bool`.
    return Share.retag(a, 1)

Define the private logic

Write the product logic that decides what data can open: a match, score, aggregate, key, or model update.

def random_bit() -> secret bool:
  while True:
    var r = Share.random_field()
    var r_squared = Share.open_field(Share.mul(r, r))

    if Field.is_zero(r_squared):
      continue

    var r_prime = Field.sqrt(r_squared)              # canonical root in (0, p/2)
    var r_prime_inv = Field.inverse(r_prime)         # r'^-1
    var two_inv = Field.inverse(Field.from_int(2))   # 2^-1

    var c = Share.mul_field(r, r_prime_inv)          # [c] = r'^-1 [r] in {-1, +1}
    var a = Share.mul_field(Share.add_field(c, Field.one()), two_inv)
    # `a` holds 0 or 1; retag the wide field share as a 1-bit `secret bool`.
    return Share.retag(a, 1)

Define the private logic

Write the product logic that decides what data can open: a match, score, aggregate, key, or model update.

Keep sensitive data at the source

Turn sensitive context into shares before it becomes another readable app dependency.

Keep sensitive data at the source

Turn sensitive context into shares before it becomes another readable app dependency.

Run the computation

StoffelVM runs the compiled program across the selected backend path and opens only the data the product needs.

A private step your team can explain

Show where private details stay, where computation happens, and what your product is allowed to open.

A private step your team can explain

Show where private details stay, where computation happens, and what your product is allowed to open.

Use sensitive context without collecting the whole story

When privacy review arrives, show what never entered your app.

When the architecture gets reviewed

If your app is reviewed tomorrow

Traditional stack

Stoffel stack

What gets exposed

Readable private data

Shares and approved results

What spreads

More risk inside the app

Less sensitive data in app storage

The architecture story

“The app had to see it, so now we need to defend it”

“The private details stayed outside the app path”

What the product keeps

User trust and product focus

The opened data the product needs, not the full private context

Build the features users expect without collecting what they fear

Compute over shares. Open only the result. Keep private details out of your app.

AI / ML

Train together without pooling user data

Compute model updates over shares while private training data stays distributed.

Learn more

Key management

Generate keys without one holder

Create and use key shares across teams or partners without one service holding the complete key.

Learn more

The Stoffel Stack

Use the full stack or each as you need.

01 Start building

Use the CLI and Rust SDK to move from Stoffel Lang to a working Rust integration without stitching repos together.

Open quickstart

Rust SDK docs

02 Define the Logic

Define allowed outputs using Stoffel-Lang (match scores, aggregations, eligibility signals)

Read language docs

View examples

03 Own the stack

Run your own MPC network with the coordinator, networking, and protocol crates when your team is ready to operate the infrastructure.

View infrastructure repos

Coordinator repo

The Stoffel Stack

Use the full stack or each as you need.

01 Start building

Use the CLI and Rust SDK to move from Stoffel Lang to a working Rust integration without stitching repos together.

Open quickstart

Rust SDK docs

02 Define the Logic

Define allowed outputs using Stoffel-Lang (match scores, aggregations, eligibility signals)

Read language docs

View examples

03 Own the stack

Run your own MPC network with the coordinator, networking, and protocol crates when your team is ready to operate the infrastructure.

View infrastructure repos

Coordinator repo

The Stoffel Stack

Use the full stack or each as you need.

01 Start building

Use the CLI and Rust SDK to move from Stoffel Lang to a working Rust integration without stitching repos together.

Open quickstart

Rust SDK docs

02 Define the Logic

Define allowed outputs using Stoffel-Lang (match scores, aggregations, eligibility signals)

Read language docs

View examples

03 Own the stack

Run your own MPC network with the coordinator, networking, and protocol crates when your team is ready to operate the infrastructure.

View infrastructure repos

Coordinator repo

Questions teams ask before they trust the architecture

Bring us one sensitive workflow. We’ll help you review privacy fit.

Review privacy fit

Isn’t encryption enough?

Encryption helps at rest and in transit. Stoffel is for the moment your product needs to compute over sensitive context without bringing all of it back into the app.

Will this slow the team down?

The goal is to make the first private workflow concrete. Start locally, check the logic, and use the MPC path when the product boundary is worth it.

Is this right for every workflow?

No. Stoffel is strongest when your app needs to compute on sensitive user context and open only a specific score, match, aggregate, key, or decision.

Do we need to become cryptographers?

No. The developer path is Stoffel Lang, the VM, and SDK calls your team can inspect. The cryptographic machinery supports the build path; it should not become the page’s first job.

What should we bring to Stoffel?

Bring one workflow where the app needs sensitive context but should not see the full private details. We’ll help map what stays private, what gets computed, and what opens back to the product.