Infrastructure is the underlying factor driving the development of Web3.
Marlin Protocol enables developers to easily build innovative DApps and promote decentralization! Let's learn more about Marlin Protocol through the Web3 Roundtable.
Introduction to Marlin Protocol
Marlin is a verifiable computation protocol. At a high level, it allows you to run trustless servers off-chain and verify the computation results on-chain. This design is commonly referred to as a coprocessor. It allows you to outsource computation to other machines while still ensuring that the results they return to you are correct. Therefore, coprocessors do not need to publicly expose all data and redundantly execute computations on a large number of machines like blockchains do. Instead, they allow a single machine to execute programs in a way that ensures computational integrity and data confidentiality.
The advantage of this approach is that it can enable new decentralized applications that were previously not feasible due to high costs and slow speeds. For example, running AI models requires a GPU cluster on-chain, hence the need for AI coprocessors. In the gaming aspect, currently there are either very simple on-chain games, also known as autonomous worlds.
On the other hand, most game servers for Web3 games are run centrally by project teams. Similarly, most games in DeFi are overcollateralized. Pseudonymous accounts do not allow individuals to build their reputation through their on-chain activities, which can be used to expand low-collateral loans or for more efficient airdrop programs.
Imagine if you could build completely trustless AI agents to update LTV or other risk parameters for DeFi protocols, run trading bots without the risk of bots or operators running away with user funds, and have the environment of on-chain games dynamically updated while supporting thousands of players like centralized game servers. Marlin makes all of this possible.
What needs does Marlin Protocol address? What changes will these solutions bring to the blockchain?
It is well known that blockchains have throughput limitations. This has led to many scalability innovations such as L2, rollups, parallel EVM, SVM, etc. However, these solutions also have their limitations.
-
Most of them use block-based data structures. Therefore, you need to aggregate transactions into blocks that are propagated at a certain frequency.
-
These transactions are executed in virtual machines designed for smart contracts. Therefore, there is a performance overhead. You cannot have ultra-low code execution latency and fast confirmation of correct execution.
-
You need to write smart contracts using Solidity or paradigms compatible with the native virtual machine of the blockchain.
-
It is not possible to reliably use off-chain data.
Marlin allows for off-chain computation, just like running on a regular cloud server. Therefore, its execution speed is very fast. You can code in any language (Python, Go, Rust). Existing libraries and frameworks can be used (such as TensorFlow for ML, Unity for games). You can access and compute off-chain data without trust, whether it's weather data, price information from centralized exchanges, or blockchain historical data. You can also use private data for these computations while ensuring that the data is not leaked or read by others.
Fundamentally, with Marlin, you can "decentralize" existing Web 2 applications without sacrificing performance. Therefore, over time, we hope to see more powerful DeFi applications with user experiences comparable to centralized exchanges, on-chain games with latency and interactivity comparable to Web 2 games, and social applications with intelligent recommendations using Marlin.
Introduction to Marlin's two breakthrough and innovative products: Oyster and Kalypso
When computation is outsourced to decentralized clouds or third-party nodes, there are two main issues:
They can manipulate the execution flow of the program, resulting in incorrect results.
They can peek into your private data and even potentially leak it to others.
To address this problem, several techniques exist for performing verifiable computation. You may have heard of Trusted Execution Environments (TEE), zero-knowledge encryption or ZKP, multi-party computation (MPC), and fully homomorphic encryption (FHE). FHE is very slow, and MPC has an issue where nodes may collude without any observer knowing. Therefore, Marlin focuses on TEE and ZKP. TEEs are secure enclaves within processors. They act like vaults inside the main processor of a device, protecting sensitive data and code. The computations that happen inside them are isolated from other processes.
Oyster is a network of node operators that provide TEEs. It is very cost-effective, fast, and practical for many crypto x AI applications, such as running automation or guardian bots, liquidation bots, matching engines for trading platforms, or game servers. Existing NodeJS servers can run on Oyster and terminate HTTPS connections, making it ideal for decentralized frontends.
On the other hand, Kalypso is a ZK proof marketplace. It is circuit-agnostic and supports private inputs. Therefore, any zk dApp, zkVM, or zkRollup can outsource proof generation to Kalypso. This increases the liveliness and censorship resistance of the protocol. It helps improve the user experience of zk applications as client-side proof generation is very time-consuming and can cause user devices to lag.
Which areas are the solutions provided by Marlin Protocol mainly applicable to? Do ordinary users have the opportunity to interact with the protocol?
Ultimately, Marlin is a decentralized computing network, and many applications require high-performance computing. Today, due to computational limitations, dApps are designed in a way that they can either run entirely on-chain (thus with limited functionality) or rely on trusted parties to move critical components off-chain. Verifiable off-chain computation networks open up a whole new paradigm of asynchronous programming.
For example:
Oyster can be used in areas such as AI, MEV, deploying matching engines or order book exchanges.
DAOs can deploy liquidation or MEV bots where MEV profits can flow back to the DAO.
Bitcoin can be made programmable through coprocessors. In the decentralized frontend space, integration with 3DNS is cutting-edge, as DAOs can own domains and deploy backend servers that will have more expressive and flexible variants in the future.
Not limited to any blockchain VM. No need to use blockchain-like data structures. You can simply code in any language as usual and have functionality executed in a trustless and verifiable manner. This is how the next generation of dApps will be deployed. Even existing dApps on L1 and L2 can use this feature to achieve functionalities that were previously not possible.
What are the future plans for Marlin Protocol? How will it expand its influence?
We believe that decentralized computing networks will play a crucial role in powering decentralized services. Use cases based on artificial intelligence are just the beginning. We can consider using Oyster to develop coprocessors that bring programmability to Bitcoin. For Kalypso, we are exploring the possibility of a symbiotic system for its reconstruction to reduce the security costs of the protocol. We encourage developers to try out Oyster and Kalypso, participate in hackathons, and reach out to us for any form of ecosystem support.