Start with what we know. Hyperliquid processes 200,000 orders per second with 0.2-second finality. It has no MEV or gas fees and substantially less slippage than AMM-based DEXs. It was built by 11 people and captures over 70% of decentralized perp volume. On pretty much every measurable dimension of performance and cost, it beats Ethereum and every other general purpose chain by a wide margin.

And it's not alone. Aster, Lighter, Nado, and every other serious new entrant in perps trading is choosing app-specific infrastructure over general purpose chains.

App chains are winning. And it's not close.

The question isn't whether app chains are better for trading. They are. The question is whether that matters as much as we think it does — and what it means for the future of general purpose chains like Ethereum, Solana, Base, and the broader onchain economy.

The debate between app chains and general purpose chains isn’t new. But with the gap feeling larger than ever, it’s a good time to update the framework for what each architectural choice means for cost, performance, and where onchain value ultimately settles.

Theoretically, app chains will always inherently be more performant than general purpose chains

Using perps as a case study shows us app chains processing hundreds of thousands of orders per second with sub-second finality. The honest truth is that no general purpose L1 or L2 chain can do that confidently today, and the gap is mostly measured in orders of magnitude.

This advantage is permanent. No matter how fast general purpose chains get — and they are getting faster — an app chain built for the same use case will always be faster because it can make optimizations that a general purpose chain can't. A chain that does everything will never outperform a chain that does one thing. That's not to say general purpose chains won't eventually reach the throughput and finality required for perps — they likely will. It's that by the time they get there, there'll be app chains that have evolved to be leagues ahead in some other aspect or dimension.

So do we even need general purpose chains?

App chains are faster (and often cheaper). If you're trading perps right now, the case is closed.

So why would anyone build or trade perps on a general purpose chain? Performance is only the deciding factor when the use case actually demands it. Looking at actual throughput, perp trading only needs somewhere between 5,000–10,000 TPS of sustained throughput with sub-200ms latency and deterministic ordering. GP chain perps are already here — Avantis, Ostium, and Variational are all building on GP infrastructure. Current chain limits make them less performant than their app chain competitors, but they're catching up.

On the infrastructure side, Base is moving to a unified stack enabling 5k TPS and beyond. Purpose-built L1s are emerging in the gap between GP and app chains — Stripe's Tempo is targeting 100,000 TPS with sub-second finality for payments, and Pod Network is targeting 300k TPS with 150ms latency and it solves the MEV problem. As the performance gap narrows, what made Hyperliquid special becomes table stakes.

But matching the performance threshold isn't enough to displace incumbents. So why would volume want to move back to GP chains at all?

Because in the same way that app chains will always be more performant than GP chains, GP chains will always inherently be the highest-opportunity venue for primitives and mature applications. The argument for GP chains isn't about speed. It's about where onchain value ultimately wants to live.

The lifecycle of onchain use cases

The main arguments for general purpose chains are well known: preventing fragmented liquidity, enabling composability, neutrality, and avoiding single-party dependencies. These are all lovely arguments. But it feels like nobody is making them when it comes to perps. And there's a reason why.

That's not because the tradeoffs don't matter. It's because applications follow a lifecycle, and each stage correlates to which venue offers the highest opportunity. To understand why perps remain on app chains — and the circumstances that might ever shift them to GP — we need to understand this lifecycle.

Before a use case is well defined, GP chains are the innovation layer. GP chains offer the highest opportunity in this phase because of distribution and trust guarantees. Builders need existing users, existing liquidity, and credible chains they can distribute through in a trustless way. Token launches are a prime example. We rely on standards like ERC-20 and swap protocols like Uniswap to gain confidence buying assets that launched out of nowhere. The buyers already exist on the chain. The liquidity already exists on the chain. The trust infrastructure already exists on the chain.

Once a use case becomes more established — there's an accepted, scalable way to create value — we enter the growth phase. App chains dominate here. Performance and cost efficiency matter most. The use case demands more than GP infrastructure can deliver, so purpose-built chains capture it and scale it.

We've observed this multiple times. This is where we are with perps. And often it can seem like the end of the cycle. Sometimes it is. But there are circumstances that move a use case into a more evolved state. Two things must happen: the GP chain must reach sufficient performance for the use case, and there must be enough advanced applications that require it as a primitive — a settled, composable building block that other applications depend on to function.

We can tell we're approaching this point when arbitrage starts to accumulate. Arbitrage is a reliable measure of the cost of fragmentation, lack of composability, and lack of neutrality.

Fragmentation → creates price discrepancies when the same asset trades at different prices on isolated platforms.

Lack of composability → creates arbitrage when the friction of using an app as a primitive means only sophisticated parties can execute aggregate strategies — capturing the spread that everyone else can't reach.

Lack of neutrality → creates arbitrage when some parties simply can't use the application — perp platforms being banned in various countries is a straightforward example.

As arbitrage increases, so does the opportunity for a GP-native solution where decentralization, neutrality, reliability, and composability make the use case more valuable as a primitive. Aave is a clear example of a use case that completed this arc — lending started as isolated protocols, matured into composable infrastructure, and now serves as a building block that hundreds of other applications plug into permissionlessly.

The convergence cycle

The best part about this lifecycle is that it doesn't end. It feeds itself.

GP chains spawn innovation. Innovation finds product-market fit — and app chains are born to scale it. App chain performance improvements push GP chains to level up and close the gap. Once GP reaches sufficiency, the application returns to GP as a primitive. Increased performance and new primitives spawn the next wave of innovation. The cycle repeats.

We've already watched this play out one level up. Centralized exchanges are the original app chains — vertically integrated, high performance, single purpose. DEX share of CEX spot volume has tripled from 6% to 21% in four years. Not because DEXs got faster. Because they got sufficient — and continue to grow as the number of advanced applications that need spot trading as a primitive increases.

The cycle never ends because innovation never stops — and performance demands always exceed current infrastructure. Until they don't.

Application: perps, prediction markets, AI agents, and tokenized assets

The convergence cycle is more useful as a lens than a prediction. Here's how the framework maps to some of the categories being talked about right now.

The framework doesn't tell you where each category will end up. It tells you what to look for as each one evolves.

Key takeaways

App chains and GP chains aren't competitors. They're two phases of the same system.

App chains will always be more performant for a given use case. That advantage is structural and permanent. But performance alone doesn't determine where value settles.

GP chains will always be the highest-opportunity venue for primitives and mature applications — because liquidity, composability, neutrality, and distribution compound there over time.

Not every category follows the same path. Perps needed app chains. Prediction markets don't. The framework helps us understand where an application has the best chance of success and what factors could drive architectural shifts over time. Recognizing which phase each use case is in — and building accordingly.