Marlin Protocol

A verifiable computing protocol leveraging TEEs to allow complex workloads to be deployed over a decentralized cloud.

What is Marlin Protocol?

Marlin Protocol is a verifiable computing protocol that leverages Trusted Execution Environments (TEEs) to enable complex workloads to be deployed over a decentralized cloud infrastructure.

Unlike traditional blockchain scaling solutions, Marlin provides a secure environment for executing arbitrary computations while maintaining verifiability through cryptographic attestations.

This makes it ideal for applications that require both the security guarantees of blockchain and the performance capabilities of traditional cloud computing.

TEEVerifiable ComputingBlockchainDecentralized Cloud

Secure Compute

Verifiable

Decentralized

Key Features

Marlin Protocol offers a comprehensive suite of features for secure, verifiable computing

Secure Computation

Leverage Trusted Execution Environments (TEEs) for tamper-proof, confidential computing that protects sensitive data and code.

Performance Scaling

Boost effective throughput of blockchains by moving computations off-chain to dedicated nodes with on-chain verifiable attestations.

Blockchain Coprocessor

Scale blockchain applications by offloading complex computations while maintaining verifiability through attestations.

Web2 & Web3 Bridge

Access off-chain data via APIs and expose HTTPS endpoints while maintaining compatibility with blockchain ecosystems.

Data Confidentiality

Prevent node operators from viewing sensitive data or program execution details, unlike traditional decentralized cloud solutions.

Circuit/VM Agnostic

Run any program compatible with Linux, unlike ZK coprocessors limited to specific environments like RISC-V, WASM, or MIPS.

Simple to Implement

Deploy confidential computing workloads with just a few lines of code

marlin_deploy.rs

// Import the Marlin SDK
use marlin_sdk::oyster::{CVM, Serverless};
use marlin_sdk::attestation::Verifier;

// Deploy a confidential computing instance
async fn deploy_confidential_workload() {
    // Initialize the CVM with your image
    let cvm = CVM::new("my-secure-image:latest");
    
    // Configure resources
    let instance = cvm.with_resources({
        cpu: "2",
        memory: "4Gi",
    }.deploy().await?;
    
    // Verify the attestation
    let attestation = instance.get_attestation().await?;
    Verifier::verify(attestation)?;
    
    // Your instance is now running securely
    Ok(())
}

Choose Your Solution

Compare Oyster Serverless and Oyster CVM to find the right fit for your needs

Attribute	Oyster Serverless	Oyster CVM
Execution Time	5 minute limit (may be modified)	No limit
Environment	JS or WASM (WIP) sandbox (in a TEE)	Linux (in a TEE)
Scaling	Horizontal	Horizontal + Vertical
Fixed Cost	Zero (pay-as-you-go)	High (requires advanced provisioning)
Operating Cost	Medium	Low
Security	As secure as the Chrome V8 sandbox	As secure as the underlying TEE implementation
Resource Allocation	Shared vCPU (min 5%) and memory (100 MB)	100% of chosen vCPU and memory
Access Modes	Request-Response (either through web2 endpoints or smart contracts); no SSH access	Flexible as per your code (for example, can also include event listeners); no SSH access
Networking	Custom HTTP or HTTPS endpoints	Includes communication over IP (TCP)
Storage	External with a MPC-based persistent key	External with a MPC-based persistent key

Get Started with Marlin

Follow these steps to begin building with Marlin Protocol

Install the SDK

Get started by installing the Marlin SDK using npm, yarn, or cargo depending on your preferred language.

npm install @marlin/sdk

Configure Your Project

Set up your project configuration and choose between Oyster Serverless or Oyster CVM based on your needs.

// marlin.config.js
module.exports = {
  runtime: "serverless",
  resources: {
    cpu: "1",
    memory: "2Gi"
  }
}

Deploy Your Application

Deploy your application to the Marlin network and start leveraging secure, verifiable computing.

marlin deploy