A trusted execution environment (TEE) is a secure area of a main processor. It helps code and data loaded inside it to be isolated from other processes usually at a hardware level in order to provide confidentiality and integrity. Data integrity prevents unauthorized entities from outside the TEE from altering data, while code integrity prevents code in the TEE from being replaced or modified by unauthorized entities, which may also be the computer owner itself.

How does Oyster work?

Oyster is a sub-network of Marlin that specializes in offering TEE-based coprocessors. It is fast, cheap and secure. It allows instances to be rented individually for any stretch of time or for tasks to be delegated amongst a pool of nodes in a serverless way without individually renting instances and paying only for the duration of the task's execution. Nodes can be rented and tasks delegated using both smart contract calls and web 2 APIs. A set of auditors routinely query Oyster nodes to ensure uptime guarantees.

What are the benefits of using Oyster?

Oyster is very flexible and versatile. Developers can port existing web 2 applications on Oyster, write code in the programming language of their choice and use popular libraries and frameworks. Additional benefits include: 1. Secure: Hardware isolation ensures that programs run correctly as intended without exposing their contents and prohibiting interference from the host machine or its owner. 2. Fast: Oyster nodes are essentially like usual servers. There’s no redundancy in computation, complex protocol logic or cryptography. Thus, apart from a little TEE overhead for encrypted memory access, Oyster nodes are very performant and provide an experience similar to running programs on a normal machine. 3. Cheap: TEEs can be considered commoditized. While a little more expensive than vanilla servers, they are very cheap compared to blockchains, MPC, FHE or ZK proofs. Consequently, TEEs are a very affordable mode to carry out computations verifiably.

How can I get involved?

Oyster is a permissionless network. As such, programmers can contribute to its codebase, developers can build trustless web 3 applications by deploying their backends on Oyster nodes and infrastructure providers can run TEE-enabled Oyster nodes.

Scalable coprocessors
for decentralized compute

Develop powerful applications by accessing and processing data verifiably

Start Building

SCALE

The GPU for onchain execution

Marlin allows computations to be delegated to TEE-based offchain microservices
with proofs and attestations verified onchain

Accelerate execution

Verifiable offchain execution doesn't require redundant replication of computations and can thus produce results much faster.

Reduce cost

Onchain verification of proofs is usually orders of magnitude cheaper than carrying out the entire computation completely onchain.

Prevent IP theft

Data and logic of computations carried out offchain are not visible onchain or to the host machine in the case of enclaves and cryptographic schemes.

MODULAR

We know one size doesn't fit all

Easily express your trust, cost and performance preferences

Confidential VMs (CVMs)

Dedicated instances for heavy workloads

Deploy backends or outsource jobs on customizable machines with minimal changes

Discover

Serverless

Shared instances for unpredictable demand

Deploy functions that scale automatically and pay based on usage without renting a server

Explore

Chain abstraction

Ability to run trustless services offchain enables light-weight onchain execution abstracting away the underlying chain

Modular x Integrated

Easily plug-and-play coprocessors on any chain via a relay contract and offer users a uniquely integrated experience

Scalable

Auto-scaling and fault tolerance allow applications to seamlessly cater to increasing workloads without failing

EXPRESSIVE

Write code using familiar languages and frameworks

Execute verifiable programs on a serverless infrastructure that scales easily

Fast development cycles

Port existing Python, C++ or Go apps or use your favourite zkVM

Easy maintenance

Seamlessly import Rust crates, ML or crypto libraries for better auditability

Fire-and-forget

Deploy your programs reliably with a single click and scale with demand

Support private inputs

Keep models and prompts private via confidential computing on H100s

Cheap verification

Trustlessly verify results using ZK proofs or TEE attestations

Infinite composability

Effortlessly consume results of one computation as input to another

STREAMLINED

Oyster

A comprehensive framework to build and deploy applications on TEEs

Reproducible Builds

Oyster uses Nix to ensure that code, along with any dependencies, deterministically builds to produce the same binary hash

Expose web2 endpoints, make network calls or even store and use TLS certificates without rewriting services to be TEE-aware

Docs

GitHub

RA-based TLS

Establish secure channels between enclaves or with them through Remote Attestation-based TLS for encrypted communication

Docs

GitHub

Learn More

Explore the ecosystem

Discover the vast variety of dApps that can leverage Marlin coprocessors

Asula

Sigmoid

Scale AI models without compromises

Train and deploy ML models verifiably with the choice to keep both models and inputs private

Transform DeFi, social & gaming apps

Leverage offchain computing to price options, make dynamic autonomous worlds or generate recommendations

BACKED BY THE BEST

Oyster

Kalypso

Github

Docs

Relay

Discord

MEV

AI

DEX

Decentralized Frontends

Decentralized Gateways

Oracles

Explore Ecosystem

Forum

Blog

Ethereum-Arbitrum Bridge

POND-MPond Bridge

Contribute