We’re introducing a new development paradigm called vApps, or verifiable applications, in partnership with LayerZero. vApps allow you to build applications that give users web3-level security and transparency with a familiar web2 developer experience. We know that dApp developers are tired of the constraints they face today. They’re forced to use Solidity, deal with the EVM, and assume low throughput. In short, they’re forced to build in a box. vApps move away from the pattern of EVM forks and give developers the ability to write normal applications and turn them verifiable with a simple Rust SDK. 

Succinct is building a decentralized prover network, powered by SP1, which acts as a key piece of infrastructure enabling vApps. By providing every vApp with a verifiable computing layer that can generate ZK proofs of code execution, the Succinct Network makes it easy for developers to focus their attention on their core application logic. In the vApp framework, instead of having to use specialized languages like Solidity and implementing backend workflows blending on-chain and off-chain components, developers simply write a Rust application; all the proving, interoperability, and settlement is handled for them. vApps allow existing web2 applications and new web3 applications alike to become verifiable with one simple plugin. 

With vApps, we can finally have real applications benefit from the magic of crypto. Whether it’s a verifiable ad exchange, settling billions of impressions a day for publishers and advertisers, a game, with thousands of in-game events a second, or doctor matching in critical fields like healthcare, the verifiability afforded by the vApp framework can transform any application. The vApp SDK is under development today. Read the vApp paper and join the builder Telegram for more information.    

dApp Development is Broken

Decentralized applications promised users and developers several important features that were an upgrade to the traditional web:  

• Trustlessness: By settling transactions to public blockchains, dApps aimed to enable a trustless user experience. Instead of asking third parties to execute transactions and attest to their correctness, as is the case in the traditional financial system, dApps would enable anyone to verify correct transaction execution by checking the chain. This allowed for vastly more transparent and publicly auditable versions of traditional financial applications and beyond. 
• Composability: dApps promised to compose with each other, leading to rich user experiences. In finance, composability would lead to shared liquidity and the ability to engage in complex transactions such as cross-chain swaps and lending. In short, composability would make applications “feel as one”, enabling experiences that are not possible on the web today. 
• Permissionless innovation: dApp developers could launch new applications, fork, or upgrade existing applications without anyone’s permission. This would enable far more innovation, as application developers could build on top of open standards. The permissionlessness of dApp development led to significant progress in decentralized finance applications for trading and lending. 

The current state of decentralized app development, however, has fallen far short of this promise. Today, to get these properties for their apps, dApp developers are forced to build with significant constraints. To build on blockchains like Ethereum or their rollup stacks, they have to:

• Deal with the semantics of the EVM and other general purpose virtual machines.
• Use specialized languages like Solidity.
• Think about complex backend infrastructure, including databases, indexers, and on-chain settlement to connect onchain state to offchain data stores.

There is no blockchain or rollup stack that lets developers write applications in a web2 fashion and get verifiability out of the box.

Virtual Machines Impose Constraints

A primary cost that is imposed on developers when working with rollup stacks on layers like Ethereum is the constraints of using generalized virtual machines such as the EVM. There is a high price of verifiability for the EVM. Writing your application logic in the EVM and then making it verifiable through the interpreter that is proven through SP1 introduces a huge amount of overhead (up to 832x), as shown in Figure 1. 

In the vApp framework, we demonstrate how native Rust execution can dramatically reduce the work required to verifiably run applications inside SP1, which promises to be a powerful alternative to app development on rollups today.

Specialized Programming Languages Slow Developers

Programming applications in the current paradigm requires developers to incur overhead due to specialized languages such as Solidity. Compare the nearly 3 million Rust developers worldwide to Solidity developers, which are a small fraction of this. As noted by industry leaders (Figure 2), Solidity development is challenging and causes developers to have to inherit the technical debt of the language improvement roadmap. 

In vApps, developers can write their applications in safe languages like Rust and have the complicated on-chain engineering be completely abstracted from them.

Backend Infrastructure Doesn’t Just Work

dApps cause developers to have backend functionality for replicating on-chain state and maintaining consistency across authenticated databases. This functionality typically includes an authenticated database, an indexing service, and on-chain settlement infrastructure. This duplication is inefficient and causes every app to have to re-implement the same features internally. Particularly in apps that have both web2 and web3 components, this can lead to inconsistent state; app teams need to allocate specific engineering talent only to maintain this backend infrastructure.  

vApps solve this problem by giving every app access to a canonical verifiable database and messaging service that interfaces with on-chain verification. With vApps, developers don’t have to do repetitive backend engineering to build their apps. vApps, while avoiding duplicated backend infrastructure, also allow apps to avoid “noisy neighbors”, because apps do not share generalized blockspace.

The vApp SDK

The vApp SDK sits at the core of the framework and allows you to build real apps. It abstracts all the necessary components for your app so that all you have to write is your application logic. This is how it is in traditional web development, and this is how it should be in crypto. vApps use modular components for on-chain artifacts, such as proof verification & state commitments, and off-chain artifacts, such as proof generation, verifiable database, and indexing to allow you to focus on your application logic. 

The SDK comes with a Rust-based domain specific language that easily allows developers to wrap their application logic in the required components. In Figure 4, we show how the vApp SDK can implement a simple token transfer. The SDK makes use of annotations like #[derive(ProvableState)] to ensure that balance updates are captured in a commitment-friendly data structure and the #[vApp:Handler] entry point encodes the application logic that passes through the prover. Importantly, the developer only writes Rust. The rest just works.  

Succinct Enables vApps

The Succinct Prover Network serves as critical infrastructure for vApps by providing them with a high-performance verifiable computing layer. Performant vApps are uniquely enabled by advances in verifiable computing, particularly by zkVMs like SP1. 

With Succinct’s Prover Network, vApps benefit from zero knowledge proofs that can prove the integrity of the vApp’s transaction execution and make every vApp verifiable, from web2 to web3. Instead of being restricted to narrow, application-specific use cases that required developers to build custom circuits and understand complex cryptography, Succinct makes it possible to generate zero-knowledge proofs directly from normal code.

In the vApp paper, with a benchmark study of zkVMs, we demonstrate that vApps’ architecture can leverage native execution to avoid VM overhead, precompilation to reduce work, and hardware acceleration to speed up proof generation.

Native Execution Avoids VM Overhead

vApps use native Rust execution in SP1 to avoid up to an 832x overhead in the EVM and other interpreters. Native Rust execution allows app developers to experience large performance improvements in their proving costs and latencies. By using only app-specific function calls as opposed to generalized EVM execution, app developers get tremendous performance benefits. Further, native execution can be optimized with improvements in the core proof system. 

Precompilation Reduces Work

vApps can use precompiles for the zkVM to reduce the proving work required for common cryptographic operations by up to 95%, as shown in Figure 6. SP1 is already optimized with precompiles, which are pre-built circuits that accelerate proving for repetitive operations. Many apps require “general plumbing” work: recovering account data, initializing authenticated databases, and doing state reads and writes. Already, SP1 uses the ECDSA recovery precompile to accelerate account recovery in Ethereum proving. Precompiles can accelerate proof generation for vApps. 

Hardware Acceleration Speeds Up Proofs 

zkVMs are highly optimizable with accelerated hardware. GPUs increase throughput by up to 30x, as shown in Figure 7. Parallelization in clusters of GPUs can multiply this by orders of magnitude. Already, Succinct runs thousands of GPUs for our production customers. As vApps get built out, the Succinct network will become a key piece of infrastructure for app developers to use proof generation services out-of-the-box, with high reliability. 

What vApps Can You Build?

We’re excited to support vApp developers as they develop new, exciting use cases. We’ve talked about verifiable exchanges that allow for provable deposits and forced withdrawals in various contexts. But more importantly, vApps also enable any web2 application to become easily verifiable. 

For example, games that follow traditional web development practices can easily integrate verifiable computing without needing to learn an entirely new platform. Earlier this year, we wrote about the crisis of trust. vApps enable any application, web2 or web3, to escape this crisis. We’re excited about: 

• Ad exchanges that prove auction outcomes to publishers and advertisers
• Verifiable games with hundreds of events a second
• Doctor matching that can be checked by any third party
• Credit scoring that reports auditable credit scores

To get started with vApp development and contribute to the SDK, join the builder Telegram today.