Why is Hyli a Layer 1?

“Why is Hyli an L1 and not an L2?”
“Why isn’t Hyli reusing the Cosmos SDK/Substrate/Reth/Geth?”
“Why aren’t you using X/Y/Z for Hyli?”

We are often asked these questions, and they all boil down to the same thing: “Why did you build everything from scratch rather than reuse what already existed?”

It’s a fair ask. The blockchain space has a strong open-source culture. Contributors work together to enhance, tweak, and fix the entire stack. And with great success!

Bitcoin doesn’t have any project manager. Anyone can contribute to Ethereum and push an EIP. Open-source toolkits exist to help projects build faster by reusing existing technical building blocks: Base is built with the OPStack, Celestia with the Cosmos SDK, and Phala with Substrate.

So why do the hard thing?

We do it because Hyli isn’t trying to patch the past; it’s trying to define what comes next.

Three essential reasons are motivating our decision.

L1s are L2s, L2s are L1s

The scaling roadmap of Ethereum has centered on L2s: separate blockchains that leverage Ethereum’s security while enabling faster transaction speeds and lower fees. They’re seen as the gold standard for secure scaling. So why isn’t Hyli an Ethereum L2?

L2s indeed lowered fees and increased transaction speed, but only on their specific shard. Liquidity is fragmented across competing rollups. UX is worse than ever: bridging, wrapping, waiting, and guessing which network your assets are on. Each L2 operates like its own ecosystem rather than as an extension of Ethereum.

Sequencers are slow to decentralize. Most rollups extract value from ordering transactions while only retaining a small cut for Ethereum. This incentive mismatch is now obvious. Even Ethereum’s own roadmap is pivoting back to L1 improvements.

With the advent of zk, the difference between L1 and L2 is blurring. When you can prove blockchains in real time and verify them on other blockchains, there is no functional difference between L1s and L2s. Once we prove Hyli’s consensus to Ethereum, Hyli effectively becomes an Ethereum L2.

(For more information on this, I’d recommend reading Jon Charbonneau’s Rollups Are L1s (& L2s)) and John Prestwitch’s Defining Rollups articles.)

Hyli is an L1 because, eventually, everything is an L1.

Independence: own your stack

The first version of Hyli was actually built using the Cosmos SDK! You can still find it on our GitHub.

We supported Risc0, Cairo, and SP1. We even built a verifiable application called Vibe Check, which would send tokens to you if we could assert that you were smiling with a (somewhat shaky) zkML proof.

But we already knew we’d need to build everything from scratch.

First of all, the Cosmos SDK is built in Go, meaning that calling the different Rust-based proving systems creates significant overhead.

Then, adding modules to the Cosmos SDK works great, but once you start removing stuff like signatures, everything starts unraveling. Hyli fundamentally rethinks how blockchains work, which clashes with many design decisions in the Cosmos SDK.

The third and most important reason of all was independence.

Reusing an existing stack meant we were dependent on another team. We didn’t want our roadmap to be impacted by decisions on which we had no control. Owning your stack isn’t about pride, it’s about freedom: and we didn’t want to beg for upstream merges to ship our vision.

But we’re not rebuilding everything from scratch. We have a lot of respect for projects like Fuel, Aleo, Mina, or Starknet: not only are they building chains, but they’re also creating proof systems, execution environments, and sometimes entire consensus algorithms. That makes them extremely hard to build.

We went the other way by choosing to be compatible with existing zk-stacks. Hyli embeds existing tools that are already used by developers (Risc0, SP1, Noir).

Our mission is to develop the most advanced blockchain for proof-based applications. So that’s exactly what we did. We listed down what we needed, and the team went to work.

You can just ship things.

Disruption: sometimes, you have to kill the father

Blockchains like Ethereum and Bitcoin are supported by thousands of developers who propose incremental changes and contribute to the ecosystem. Each incremental piece of code stands on the shoulders of the giants that preceded it.

Incremental improvement also has drawbacks. The EVM is a highly complex piece of engineering, with many unusual design decisions leading teams to go to incredible lengths to deliver basic functions. It feels more like plumbing and duct-taping than innovation.

I’d even go so far as to call this incremental improvement mindset one of the core dogmas of the current blockchain zeitgeist.

At Hyli we’re convinced the current blockchain dogma is reformism.

The current dogma is that you can save everything with just one more tiny EIP, one more minor improvement, and assembling a DA layer, an AVS, and a settlement layer with varying degrees of security to run your application.

We can do much simpler, much better.

Hyli has an opinionated stack: you have to use proofs. Rust applications are favored. Hyli doesn’t store the full state of your app. Yes, that’s different from Ethereum. Yes, you need a backend.

It’s different, yes. All new things are.

But it’s easier to use than Solidity. You can customize it any way you want. You don’t need to think about security; you can just use proofs.

Fortunately for us, there is precedent for this in web2! The most well-known example is Apple killing Flash when it didn’t align with the new generation of hardware and web technologies.

We’re making the same bet for blockchains.

TL;DR

We built an L1 because it was the right choice.

We’ll prove our consensus to Ethereum and become verifiable there. That makes us functionally equivalent to an L2 while keeping the benefits of owning our own optimized stack.

The tech choices we’ve made aren’t reactions to trends. They’re commitments to the kind of blockchain we want to exist. A chain that treats proofs as first-class citizens. A stack that isn’t afraid to rethink what a chain should be.

Because we believe that…

Impossible n’est pas français.