Introducing the Hyli Guide
Curious about what makes Hyli different? The new Hyli Guide explains why we built it, how it works, and the future it unlocks.
This is the Hyli Guide, your entry point to understanding why we’re building a new proof-powered Layer 1, how it works, and the future it enables.
Why Hyli?
Blockchains today have issues.
When the Hyli co-founders first thought of the blockchain they wanted to create, zero-knowledge proofs had become very practical to scale execution. This made them wonder: Why does the L1 even handle execution? Why not just sequence the transaction and verify the proofs? And if something other than zero-knowledge proofs appeared, how would that L1 support it?
So the question was how to create a new Layer 1 with a future-proof architecture that can scale and solve these limitations. The answer: a Layer 1 that can horizontally scale thanks to validity proofs, handle millions of TPS, and never get burdened with the ever-growing onchain state.
This section explores why we work on Hyli. As you read, you’ll understand why the Hyli architecture is the endgame of blockchain infrastructure.
A history of blockchain architecture
Let’s start by recapping the evolution of blockchain architectures. That way, we can understand how we arrived at this point and the next set of challenges that the Hyli architecture addresses.
Bitcoin: The first app chain
It all starts with Bitcoin, an app-specific chain built after the 2008 financial crisis to solve the problems of sound money.
Bitcoin tackled the hard problems of that time: creating a sound digital asset that is permissionless to use, offers self-custody, and is secured by mathematical and economic security.
Bitcoin solved critical problems, but it had issues:
- Not scalable, ~7 TPS
- Not highly programmable. You cannot build complex applications with it.
Following the creation of Bitcoin, people started building app-specific chains.
The issue with the model is that economic security cannot be shared between these app chains, and every app needs to bootstrap its economic security from scratch.
Ethereum: The first general-purpose chain
Ethereum was launched to solve the lack of general-purpose programmability.
It ships with the EVM (Ethereum Virtual Machine), which allows for launching a suite of applications on the same base chain. This has led to the boom of DeFi and primitives such as AMMs, Money Markets, and NFTs.
All these apps could launch directly on top of Ethereum, inheriting its economic security.
However, Ethereum operates at ~15-20 TPS and thus becomes very expensive to use during periods of high usage and congestion.
Ethereum did not solve the scalability problem.
Solana: The first high-throughput general-purpose chain
Solana was launched with a new execution model, incorporating parallelization to provide high throughput on a general-purpose chain.
Now, you can build onchain apps and distribute them with low fees.
Solana currently achieves ~1,000 true TPS and plans to grow that number.
Solana has inspired multiple other chains that also aim to increase throughput, such as Sui, Aptos, Sei, Monad, etc.
Problems with existing Layer 1 architecture
General-purpose high-throughput chains are emerging. However, we haven’t yet solved the scaling problem.
No single chain can be the world computer.
To scale and meet the demand for decentralized, permissionless, and trustless computing, Layer 1s have focused on scaling a single chain vertically.
This quest is misguided. The truth is that the internet itself has scaled horizontally. There is no single server that meets the world's demand for Web2 applications, and the same holds true for blockchains.
You can build a 100k+ TPS chain, but eventually, the world’s demand will grow enough that scaling onchain compute will be a problem again. You cannot solve blockspace congestion, slowness, and high fees by scaling a single chain.
The ultimate goal is a horizontally scalable, decentralized infrastructure for building applications.
Proofs open up a new design space.
The current innovation in cryptography, particularly zero-knowledge proofs, has enabled a new approach to building verifiable applications.
Rather than relying on multiple machines replicating the same app logic, a single validity proof can be generated. The proof makes the app's state instantly verifiable for millions of devices, even those that would not be powerful enough to execute the app’s logic.
This paves the way for a new blockchain architecture where applications run computations off-chain and periodically settle proof of their state transition to a common settlement layer.
The Layer 1 of tomorrow must do sequencing, DA, and verification of validity proofs. Nothing else.
With zero-knowledge proofs, now the Layer 1 can just focus on:
- Sequencing: ordering transactions for applications
- Data availability: making sure that the data is available for verification
- Verification: verifying that applications are working correctly and settling onchain accordingly
This way, all the computation can be left to the choice of app builders. An app can use a Layer 1 to order transactions and resist censorship while providing periodic proofs of its correct behavior.
Hyli: speedrunning the Layer 1 endgame
We introduce Hyli, a Layer 1 that fixes the issues outlined above.
Hyli is a new Layer 1 blockchain that focuses only on sequencing, data availability, and proof verification. The computation is handled directly via the apps. This lays the foundation for a horizontally scalable, decentralized network of applications that are performant, secure, and interoperable.
This novel architecture allows us to focus only on increasing speed and scalability, allowing us to design and innovate in ways that traditional general-purpose Layer 1s cannot.
Hyli uses various new primitives to ship the fastest and most cost-effective L1 of its type. It uses AutoBahn, a new consensus with Multiple Concurrent Proposers, for faster data propagation and finalization.
It enshrines various proof system verifications, allowing for the building of verifiable apps with superior DX. zkVMs, such as SP1 and RISC-0, and zkDSLs, like Noir, are already live on Hyli, with more in the pipeline.
Hyli allows you to just build your app.
Bring your zkVM and use whatever language you want. You get censorship-resistant ordering and verifiability out of the box, allowing you to focus on building and distributing your app.
The use of a common sequencing and verification layer also enables interoperability between all Hyli-based apps without bridges.
Most importantly, this architecture scales horizontally. As more clients join the network, verifications are horizontally distributed among them and do not reach the bottleneck that the current L1s have been suffering from, thanks to our state-of-the-art consensus protocol based on Autobahn.
Core components of Hyli
This section introduces various primitives and components that Hyli has developed to implement a novel Layer 1 that can meet the world’s demand for computation.
Offchain execution
Hyli's design is opinionated, focusing only on sequencing, data availability, and verifying zk proofs. This focus enables it to delegate computation to apps. Since execution is verifiable thanks to cryptographic techniques, the system remains decentralized and trustless.
Traditional Layer 1s suffer from a lack of horizontal scalability as they pursue a single layer with all components integrated: sequencing, validation, execution, and state. They become bottlenecked as the demand for execution and state increases.
An increase in demand for these L1s means managing more application state and more computation on a single layer. To meet the demand, they increase resource requirements for validators: larger and faster disks, higher network bandwidth, more RAM, and more computer cores.
This is where Hyli shines.
Hyli only sequences the transactions for applications. The applications are responsible for validating these transactions, executing them, and managing the application state. This allows Hyli to scale horizontally because all applications handle their validation, execution, and state management.
Hyli scales decentralized applications the way the internet has scaled, which is through horizontal scaling, and hence is pursuing the endgame architecture of building a universal proof layer.
Transactions on Hyli
Hyli provides two transaction types, which are:
- Blob transactions
- Proof transactions
Let’s take a look at both individually.
Blob transactions
Hyli is the source of truth for the order of transactions for applications.
Blob transactions provide an application transaction to be sequenced (ordered) and finalized on Hyli. This transaction contains a payload, which includes data that an application can use to verify and execute it.
This way, multiple application transactions are sequenced and finalized on Hyli, and their verification and execution are handled directly by the applications.
Proof transactions
After your transaction has been sequenced and finalized on Hyli, the application executes it and needs to settle the application state post-execution.
This is where Proof transactions come into play.
Once a transaction has been sequenced on Hyli, a Proof transaction follows, accompanied by a proof and the new application state. Once a proof transaction has been provided and successfully verified for a previous blob transaction, that blob transaction and its corresponding application state can be considered settled.
Read more about transactions on Hyli.
Why separate sequencing from proving?
Having separate transactions for sequencing and proving an application enables a Web2-like user experience while maintaining decentralization and security. Proving will never be fully instantaneous, and pipelined proving easily removes this overhead time.
For example, imagine doing a swap on Hyli, rather than waiting for a proof to be generated:
- The user transaction is immediately sequenced.
- The application immediately executes it and provides the latest application state to the user (which would be confirmation that their swap is done).
- The user can keep using the app. Meanwhile, the new state proving happens asynchronously in the background. The app will roll back if proving fails.
This has the added benefit of avoiding initial state conflicts.
Read more about pipelined proving on Hyli.
Consensus: Autobahn
Hyli is pursuing a new design by only focusing on sequencing and verifying proofs. This means that it doesn’t get bottlenecked by onchain computation and the corresponding state growth.
This also means that the faster Hyli can propagate data and finalize transactions, the faster the apps built on top of Hyli will be.
This is why Hyli uses Autobahn as its consensus mechanism. It allows multiple concurrent proposers and uses data availability certificates for fast finality.
Autobahn enables Hyli to process more data and finalize transactions faster than traditional BFT consensus algorithms, such as Tendermint. It makes Hyli the best choice for building low-latency, high-throughput applications.
Multiple concurrent proposers also provide censorship resistance: transactions are sent to multiple validators to ensure inclusion, even if one of them is censoring the user.
In Autobahn, every proposer maintains its unique lane, where it proposes new batches and disseminates them to other validators. In parallel, validators finalize various batches into a single block. A block is finalized once it has received a threshold number of signatures.
The approach helps decouple data dissemination from the consensus over this data, unlocking higher throughput and faster finality.
Autobahn makes Hyli the destination for building high-throughput, low-latency applications, from onchain games to onchain order books.
Read more about consensus on Hyli.
Application architecture on Hyli
Hyli provides a new infrastructure for building the next generation of scalable, secure, cryptographically protected applications. This also means building an application differs from the traditional developer experience of using smart contracts.
Let’s dive deep into the various components of building an app on Hyli.
There are a few important things an application needs:
- Ordering of transactions
- Execution of the app logic for the finalized transactions
- State updates after successful execution
Ordering of transactions
Hyli takes care of this part.
With its Autobahn consensus under the hood, it provides very fast sequencing so builders know what base state they need to use for their proof.
Execution of finalized transactions
Users send the actions they intend to take (such as making a swap or buying a game asset) via blob transactions, which Hyli sequences and finalizes.
Once transactions have been finalized on Hyli, applications can start consuming their respective transactions and verifying and executing the app logic. For this, applications host their apps off-chain. Unlike smart-contract-based execution, this approach enables Hyli to break free from the burden of onchain computation and state, which is a significant bottleneck for other L1s.
The application executes its transactions and creates a proof of successful execution using whatever stack works best for the developer. Users interact directly with the application to get the status of their transaction's execution.
As more applications come, the system scales horizontally and doesn’t burden or hamper Hyli.
State updates
This is the final stage of executing an application transaction: committing the latest state of the application after a transaction has been executed. This ensures the application's verifiability and also protects users in various scenarios, such as withdrawing funds from the application.
Applications on Hyli maintain their state off-chain and can leverage various storage options, including decentralized storage providers such as Arweave, Filecoin, and Walrus, or centralized ones like Amazon S3 and Cloud Storage.
Applications only commit a small, fixed-sized commitment to their application state and periodically publish new state roots after applying a transaction, along with a validity proof.
This allows Hyli to escape the state growth problem, which has plagued blockchains since their dawn.
On legacy blockchains, as more applications emerge and grow, so does their storage, which every validator in the network must bear.
Hyli enables provable applications with validity proofs. Applications only submit their latest state commitment; the state remains off-chain, but all updates to the application are verifiable via validity proofs, allowing the state to be easily reconstructed.
This enables the creation of bulletproof, secure, and scalable apps that are sustainable over time as they grow.
Practical example: a Dex on Hyli
Let’s take the example of a transaction of a Dex product on Hyli and examine the lifecycle of a user transaction.
Step 1: User sends a transaction
The user sends transactions describing their intended actions, such as deploying liquidity, withdrawing liquidity, or swapping.
At this point, nothing has been proved.
Step 2: Dex application consumes the transaction
The Dex application follows the Hyli L1 with the help of an indexer. It consumes every new block, filters out the transactions intended for itself, applies the application logic, and updates the respective state.
The developer is free to write their application in any language of their choice as long as they can generate a validity proof for it! This could be Rust, C++, or domain-specific languages like Cairo, Noir, Circom, etc.
The application state typically resides in a decentralized storage layer.
Step 3: User gets confirmation on their transaction
Users don’t need to wait for their transaction to be proven to get a confirmation. The application provides immediate confirmation post-execution and updates its state temporarily. This is a softer confirmation than the proof being settled, but since the application generates validity proofs, it cannot lie to the user.
This enables the creation of a real-time user experience for our Dex. The user sends the transactions, which are immediately finalized and executed, and then the user is free to take any business action on top of it.
Step 4: Transaction is proven and settled
The application asynchronously proves all transactions. This proof can be generated by a prover network like Boundless or Succinct, by the application itself, or event client-side: in the context of our Dex, the app generates the proofs.
Once the proof has been generated, the application finalizes the transaction with a proof transaction, which also includes the app's new state commitment.
Since applications built on Hyli provide validity proofs, everything the indexer follows and operates on top is proved and verified on Hyli for integrity. Hyli verifies the proof and settles the transaction, updating the application's new state onchain. What was "sequenced" is now "confirmed": the app can update its state for good and the user gets a final confirmation.
Hyli's approach to building applications enables the creation of scalable, secure, verifiable, and censorship-free apps that deliver real-time, Web2-like latencies and user experiences.
Hyli is the endgame for building verifiable apps!
A vision of the future with Hyli
This final section of the guide discusses the future that Hyli aims to bring forward. Discussions span from the end-user experiences that Hyli will make possible to the evolution of infrastructure and new market opportunities the stack can create.
A world full of verifiable apps on Hyli
Hyli is the next evolution of user applications: sovereign, verifiable, and censorship-resistant. Applications built on Hyli offer these properties without compromising on user experience and speed.
One of the key features of applications built on top of Hyli is their ability to interoperate with each other easily. Multiple instructions can be sent via a single blob transaction, and through sync and async protocols, a single transaction can span across multiple applications.
Interoperable Applications
You could withdraw liquidity from a money market, swap with the asset on a different application, and deposit liquidity for the swapped asset back to the money market, all in a single transaction. And each of these apps is a different rollup: no need for bridges, everything is natively composable.
Hyli is building the settlement layer of the next wave of internet applications, enabling anyone to perform multiple interactions with these applications in a single transaction. It’s a better way to build applications.
Private Apps
One of the key components in the Hyli architecture is that applications only post state commitment to Hyli, so the application state itself is off-chain: the proof is what guarantees the integrity of any action, even if the details of the action are not made public. This enables the development of private applications on Hyli.
Take, for example, a private payments app. In such a system, each user's balance is encrypted and private by default. Users generate zero-knowledge proofs that their transactions are valid (e.g., that they own sufficient funds and are transferring them correctly) without ever revealing their balance or transaction history.
Because of Hyli’s design, we can achieve both privacy and high TPS, which is not imaginable on the vast majority of privacy-first chains.
These proofs are submitted onchain, and the protocol verifies them without decrypting the underlying data. This enables full privacy while maintaining the system's integrity.
Hyli, due to its high data throughput, serves as the backbone for the construction of a new wave of privacy-focused applications, where Hyli handles ordering and censorship resistance. At the same time, apps focus on fast, privacy-protecting execution.
Uncensorable Applications
Hyli is building the common source of truth for the new wave of internet applications. Hyli verifies proofs of what has happened (user transactions) and in what order.
Applications on Hyli must respect transactions sent to Hyli and their order, as this is a core part of their application logic that needs to be verified on Hyli to advance the application state.
Hyli’s innovation lies in its fast data dissemination and finality via Autobahn. Users directly submit their transactions to Hyli, where they are finalized very quickly. Once finalized, transactions are guaranteed for execution by the corresponding applications.
Hyli has multiple concurrent proposers, which means users can send their transactions to multiple proposers in parallel, protecting them from being censored by a single proposer. This ensures that both Hyli and its applications are censorship-resistant for their users.
Proving Networks
Hyli enables verifiable, censorship-resistant applications and leverages proofs as a core part of building these applications: Hyli applications rely on proving their application logic.
Rather than execute code directly on a blockchain, the provers and proving networks become the execution engine: the code is executed there, proven, and verified on Hyli.
Teams like Boundless, Succinct, Fermah, and zkCloud have been working on decentralized proving networks.
A proving network as a piece of infrastructure ensures that applications on Hyli:
- Don’t have a central point of failure
- Get the most cost-efficient and fastest proving services
- Benefit from highly efficient proving infrastructure
In a decentralized proving network, operators compete to be the fastest, the cheapest, and the most reliable. At the same time, multiple providers eliminate any central point of failure.
The Hyli stack, along with its wave of new internet applications, will create sustained demand for these proving networks, thereby also accelerating cheaper and faster proving. This will have a net positive impact on the ecosystem.
The fastest, most abundant DA layer
Hyli, with its Autobahn consensus, is all set to break the limits of how fast data can be disseminated and finalized by a decentralized set of validators.
Since Hyli focuses only on data availability and proof verification, it is laser-focused on scaling these two properties:
- The amount of data that can be propagated, finalized, and made available;
- The number of integrity proofs that the chain can verify per second.
The above focus makes Hyli the default choice for applications looking for a data availability solution.
Applications such as chat applications, AI agents, decentralized courts, and governance platforms can all utilize Hyli to store their data and make it available for a meaningful period.
Hyli will continue to push the metrics on data availability, speed of finalization, and the number of proofs it can verify, leveraging ever-improving technology and the continuous decentralization of its validator set. Hyli is well-positioned to be the world’s fastest, most abundant DA layer.
Hyli is still evolving quickly, and the possibilities it opens up are expanding every week. If you’d like to dive deeper and follow the most up-to-date version of this guide, head to our docs and follow us on X!