Author: ponyo_fp (Four Pillars Research Team)
Compiled by: AididiaoJP, Foresight Newsna
Key Takeaways
HyperEVM should be viewed as a smart contract layer, whose core value lies in enabling applications to directly read and utilize HyperCore's trading, collateral, positions, and risk data.
The simplest way to judge whether a HyperEVM application is valuable is to ask two questions: Why does it need EVM? Why does it need Hyperliquid?
Basic functions like swaps, lending, and asset wrappers are certainly necessary, but what truly creates a competitive edge are products that cannot function properly without HyperCore.
In the long run, the ultimate form is a highly integrated account—users can perform all operations like trading, lending, yield farming, hedging, and payments using just one balance.
Exchange First
Most smart contract platforms follow the 'chain first, then find applications' route: first launch infrastructure, subsidize liquidity, attract developers, and finally hope that applications naturally create financial gravity.
Hyperliquid's path is completely opposite. It builds the exchange first, possessing a native spot and perpetual order book, trader mindshare, a protocol-owned liquidity system, and real trading volume already flowing through HyperCore. This fundamentally changes the positioning of HyperEVM—it is not another place to simply fork DeFi contracts, but rather to make the exchange itself programmable.
This article is not a comprehensive list of all factors that can drive Hyperliquid's growth (HIP 3 markets, builder codes, portfolio margin, native liquidity, Unit assets, fee recycling, etc., are also important). It focuses on just one question: What characteristics should truly worthwhile applications on HyperEVM possess?
A valuable native HyperEVM application needs to satisfy three points simultaneously:
- Can express general logic not achievable by HyperCore itself (requiring EVM's flexibility);
- Relies on unique states not available on other chains (HyperCore's composability);
- Makes Hyperliquid more useful as a financial venue.
HyperCore is the home for trading, collateral, and risk engines. HyperEVM is the place to write application logic. Through precompiles, contracts can directly query HyperCore data such as balances, positions, prices, staking delegation, and vault equity; through CoreWriter, contracts can write operations back to HyperCore.
This design turns the exchange into a native input source for applications. Collateral, execution, settlement, and allocation can be more tightly integrated on the same ledger.
Of course, not all HyperEVM applications need to pursue 'novelty'. The ecosystem first needs familiar primitives for users to naturally perform swaps, lending, leveraging, rebalancing, and exits. A local financial surface can keep capital within the system, making the entire ecosystem truly usable.
But the deeper opportunity is definitely not simply forking existing lending protocols with a new front end. It's building credit, asset management, payments, and structured finance around the exchange ledger—things ordinary EVM chains cannot replicate even by issuing incentives.
CoreWriter will not turn HyperEVM into a synchronous extension of the order book either. Cross-environment operations have ordering constraints, delayed writes, and state coordination issues. Builders must handle failure rollbacks, delayed execution, cross-environment collateral accounting, and risk management. While this narrows some design spaces, it also forms a unique moat.
Understanding the HyperEVM Economy Through a 2×2 Matrix
The best framework for evaluating HyperEVM applications is a two-dimensional matrix:
- Horizontal Axis: Does the application require general EVM logic?
- Vertical Axis: Does the application directly compose with HyperCore's state or execution?
Category labels are not important; the key is the product's non-removable dependencies.
Local EVM Finance
Applications in this category need smart contracts, but their product models are largely portable. AMMs, money markets, CDPs, routers, option venues, leverage products, and yield markets belong to this quadrant.
Felix is a typical example. HyperLend also started here, as one of the main credit venues on HyperEVM (its roadmap later evolves towards programmable HyperCore).
This quadrant is easily underestimated but is actually very important. Any financial center needs banks, brokers, liquidity venues, and risk transfer markets to support more complex balance sheet products. Portability makes them the foundational layer for user activity.
Core-Native Extensions
Applications in this category are more directly dependent on Hyperliquid, but EVM's role is mainly wrapping, tokenizing, or composing native primitives.
Typical examples include: Kinetiq, StakedHYPE, Kintsu, HLP wrappers, Unit-linked assets, etc. Their core task is to make assets inside Hyperliquid more useful.
This quadrant is crucial—collateral is the raw material for all financial activity. Money markets need assets users are willing to borrow, structured products need assets that can be staked or hedged, and unified accounts require balances that can freely flow between different functions.
Programmable HyperCore
This is the quadrant with the most imagination: applications require both the general logic of EVM and deeply depend on HyperCore's state and execution. Here, exchange activity truly begins to be 'productized'.
- Rysk: Converts options into volatility income for assets users already own;
- Liminal: Packages Hyperliquid strategies into tokenized products;
- Hyperbeat: Delta-neutral strategies combining Core positions with ERC-20 composability.
Derive sits at the edge—it enables HYPE and kHYPE to be used as collateral for options/perpetuals via HyperEVM-vault bridging, but its core trading and settlement logic remains within its own stack. It expands HYPE collateral usage but does not strictly belong to the native programmable HyperCore category.
Currently, projects strictly meeting the 'contract-custodied assets + reading HyperCore state + using CoreWriter for execution' criteria are still early. Valantis Prime is a representative public beta case: it uses HyperEVM smart accounts as a control layer, operates HyperCore via CoreWriter, and sets constraints like permissions, proxies, session keys, and guardians, making the account itself a programmable interface to the exchange.
HyperLend and Rysk also point towards the same frontier from different angles, but ultimately must be measured against the standard of 'whether assets are truly custodied and CoreWriter is deeply integrated.'
The Financial Account is the Ultimate Form
The most valuable HyperEVM application might not look like an 'application' at all, but more like an account.
Today, crypto users still have to switch between multiple interfaces: exchange balances for trading, wallet balances for DeFi, vault shares for yield, borrowing capacity hidden in money markets, hedging requires opening another platform... This fragmentation is not just a user experience issue; it reflects the fact that liquidity, collateral, execution, and risk are scattered across different systems.
HyperEVM has the opportunity to compress these systems into the same account. Users can deposit assets like BTC, ETH, SOL, HYPE just once and start from the same balance: trade on HyperCore, lend on HyperEVM, earn yield through vaults, hedge with perpetuals, and directly spend from the payment account. The product is not a bridge; the product is that balance that can flow across functions.
Centralized exchanges have long understood this—their accounts feel unified because trading, margin, lending, and yield all exist in one controlled environment. But the problem is the closed ledger, opaque risk engines, and the inability for external developers to build freely.
General-purpose public chains are the opposite: users truly control accounts, but the financial stack is highly fragmented.
Hyperliquid sits at the sweet spot: HyperCore provides exchange-level liquidity and risk infrastructure, while HyperEVM provides an open application surface. The end result is a unified financial account completely controlled by the user yet backed by HyperCore as a powerful balance sheet engine—this is the strongest manifestation of the 'all-in-one financial home' vision.
Future evidence will appear at the account level: collateral follows users across trading, lending, saving, hedging, and spending; risk is priced in real-time from HyperCore state; liquidations are executed via HyperCore depth; structured products directly hedge with Core liquidity; ERC-20s represent claims on various financial activities within the system.
The first wave of HyperEVM makes the ecosystem usable; the next wave will make HyperCore truly programmable.
