HyperCore vs HyperEVM: What's the Difference?

Overview

Hyperliquid is not a single monolithic blockchain — it is a dual-layer architecture. HyperCore handles the native perpetual order book and spot trading, while HyperEVM provides a general-purpose smart contract environment. Both layers run on the same L1 with shared consensus, but they serve fundamentally different purposes and have different programming models.

Understanding the distinction between these two layers is essential for anyone building on, trading on, or investing in the Hyperliquid ecosystem. This guide breaks down what each layer does, how they connect, and which one matters for different use cases.

What Is HyperCore?

HyperCore is the native execution environment of Hyperliquid. It is purpose-built for financial operations: perpetual futures trading, spot order books, vaults, staking, and the HIP token standards. HyperCore is not a general-purpose smart contract platform — it is a deterministic state machine optimized for one thing: processing orders and managing positions as fast as possible.

When you trade on the Hyperliquid app, you are interacting with HyperCore. Your orders are submitted via an API (not a smart contract call), processed by the chain validators, and matched against the order book. The entire flow happens in under a second with no gas fees.

HyperCore also manages HIP-1 (native token standard), HIP-2 (spot liquidity bootstrapping), and HIP-3 (permissionless perpetual markets). These are native protocol-level features, not smart contracts. They are hardcoded into the chain logic and executed with the same speed as the core trading engine.

What Is HyperEVM?

HyperEVM is a fully EVM-compatible execution environment running on the same Hyperliquid L1. Think of it as an Ethereum-compatible smart contract layer that shares security and finality with HyperCore, but supports arbitrary Solidity code.

Developers can deploy any EVM smart contract to HyperEVM — lending protocols, DEX AMMs, NFT contracts, governance systems, yield vaults, and more. It uses HYPE as the native gas token and benefits from Hyperliquid's fast block times, though transactions on HyperEVM do require gas (unlike HyperCore trading).

HyperEVM is where the broader DeFi ecosystem lives. Protocols like HyperLend (lending), Felix Protocol (CDP stablecoin), HyperSwap (spot DEX), and Kinetiq (liquid staking) are all deployed on HyperEVM. The composability of EVM contracts means these protocols can build on each other — a user can stake HYPE, borrow against their LST, and deploy the proceeds into a yield vault, all in a single transaction chain.

How They Interact

HyperCore and HyperEVM share the same consensus layer and the same validators. They run on a single L1, not as separate chains with a bridge between them. This means assets can move between the two environments with native speed and without the trust assumptions of cross-chain bridges.

In practice, HyperEVM contracts can read HyperCore state (e.g., oracle prices from the perp order book) through precompiles. This gives HyperEVM DeFi protocols access to deeply liquid price feeds without relying on external oracles. It also means that HyperCore trading fees and funding rates can be used as inputs for HyperEVM-based yield strategies.

The shared security model is a significant advantage. Unlike L2 rollups that inherit security from Ethereum with a delay, HyperEVM transactions are finalized with the same speed and guarantees as HyperCore transactions. There is one chain, one validator set, one finality.

Side-by-Side Comparison

Which Projects Live Where?

The simplest way to think about it: if a project is a trading interface, analytics dashboard, or trading bot that interacts with the Hyperliquid order book, it typically operates on HyperCore. If it involves smart contracts, DeFi primitives, or token issuance, it lives on HyperEVM. Some projects span both layers — for example, yield protocols that route strategies through both HyperCore vaults and HyperEVM lending markets.

HyperCore projects include the Hyperliquid DEX itself, trading terminals like Hyperdrive Trade, and copy trading platforms like Coinpilot.

HyperEVM projects include the full DeFi stack: lending (HyperLend, Felix), liquid staking (Kinetiq, StakedHYPE), DEXs (HyperSwap, KittenSwap), and more.

For Builders: Which to Choose?

If you are building a trading tool, analytics product, or bot that needs to interact with the Hyperliquid order book, you should use the HyperCore API. It is the fastest path to market, requires no smart contract deployment, and benefits from zero gas costs. The trade-off is that you are limited to what the API and HIP standards expose.

If you are building a DeFi protocol, a novel financial product, or anything that requires custom on-chain logic, HyperEVM is the right choice. You get full EVM compatibility, existing Solidity tooling (Hardhat, Foundry, etc.), and the ability to compose with other HyperEVM protocols. Gas costs are minimal, and the finality is the same as HyperCore.

The most powerful applications will eventually span both layers — using HyperCore for trading execution and HyperEVM for DeFi composability. This is the direction the ecosystem is heading.

Real Examples: What Lives on Each Layer

The best way to understand the HyperCore vs HyperEVM distinction is to look at what is actually running on each layer today. The division is clean: HyperCore handles everything related to the order book and native protocol features, while HyperEVM hosts the broader DeFi ecosystem that has grown around the trading platform.

On HyperCore, the centerpiece is the perpetual futures order book itself — all 229 listed perp markets execute natively on HyperCore with sub-second matching and zero gas fees. The spot order book also runs on HyperCore, providing native trading pairs for HIP-1 tokens. The HLP vault, which acts as the protocol's market maker across all perpetual markets, is a HyperCore-native construct — deposits, withdrawals, and the vault's trading activity all happen at the protocol level, not through smart contracts.

Native HYPE staking is also a HyperCore feature. When you delegate HYPE to a validator, that transaction is processed by HyperCore's staking module, not by an EVM contract. The HIP token standards — HIP-1 for native token issuance, HIP-2 for spot liquidity bootstrapping, and HIP-3 for permissionless perpetual markets — are all native HyperCore features. This is a crucial design choice: by making these standards protocol-level rather than smart-contract-level, they inherit the full speed and reliability of the core trading engine.

On HyperEVM, the ecosystem has exploded since the EVM layer launched in early 2025. Felix Protocol has grown to over $1B in TVL as a CDP (Collateralized Debt Position) platform, allowing users to mint the feUSD stablecoin against HYPE and liquid staking tokens. Morpho, the established lending protocol that expanded to HyperEVM, holds over $500M in lending markets — a vote of confidence from one of DeFi's most respected protocols.

Kinetiq leads the liquid staking sector with over $470M in staked HYPE, issuing kHYPE tokens that have become the most widely accepted liquid staking derivative on the chain. HyperSwap, the primary AMM DEX on HyperEVM, processes approximately $57M in daily spot trading volume for HyperEVM-native tokens that are not listed on HyperCore's spot order book. LayerZero's bridge integration enables cross-chain asset transfers to and from HyperEVM, connecting the ecosystem to the broader multi-chain world. Drip Trade has established the NFT market on HyperEVM, demonstrating that the EVM layer supports more than just financial applications.

Bridging Between Layers

One of the most common questions from new Hyperliquid users is how to move assets between HyperCore and HyperEVM. The answer is surprisingly simple: it is a native transfer, not an external bridge. Because both layers run on the same L1 with shared state and shared validators, moving assets between them is fundamentally different from bridging between two separate blockchains.

USDC and HYPE are the two primary assets that can be transferred between HyperCore and HyperEVM. When you transfer USDC from your HyperCore trading account to your HyperEVM wallet, the operation is processed by the L1 itself — there is no third-party bridge contract, no lock-and-mint mechanism, and no multi-sig holding your funds in escrow. The same USDC that was in your HyperCore margin account is now available in your HyperEVM wallet, and the transfer completes in the same sub-second timeframe as any other Hyperliquid transaction.

This near-instant native bridging has significant practical implications. On other ecosystems, moving assets between an L1 and an L2, or between two L2s, can take minutes to hours and involves trust assumptions in bridge contracts. On Hyperliquid, a trader can close a perpetual position on HyperCore, transfer their USDC to HyperEVM, deposit it into a lending protocol like HyperLend, and start earning yield — all within a few seconds. This speed of capital reallocation is a genuine competitive advantage that makes the entire ecosystem more capital-efficient.

For developers, the bridging mechanism is equally straightforward. HyperEVM applications can read HyperCore state via precompiles — special contracts baked into the EVM layer that expose data from the native trading environment. This means a HyperEVM smart contract can query the current price of any Hyperliquid perpetual market, check funding rates, or read position data without relying on an external oracle service. The data comes directly from the source, with no delay and no additional trust assumptions beyond the chain itself.

Developer Perspective

Choosing between HyperCore and HyperEVM is the first architectural decision any Hyperliquid developer needs to make. The choice is not always binary — some of the most successful projects on Hyperliquid span both layers — but understanding when to use each one will save significant development time and produce a better end product.

Build on HyperCore when your application needs direct access to exchange primitives. If you are building a trading bot, a market-making system, an arbitrage engine, or a portfolio management tool, the HyperCore API is the right foundation. The API provides WebSocket streams for real-time order book data, REST endpoints for order placement and position management, and programmatic access to all HIP-3 market operations. There is zero gas cost for order placement and cancellation, which is essential for high-frequency strategies that may place and cancel thousands of orders per minute.

HyperCore is also the right choice for trading terminals and analytics platforms. These applications read data from the chain (positions, funding rates, historical trades) and present it through a UI, but they do not need to deploy on-chain logic. The HyperCore API is well-documented, performant, and familiar to anyone who has worked with centralized exchange APIs.

Build on HyperEVM when your application requires custom on-chain logic, composability with other smart contracts, or any functionality that the HyperCore API does not natively support. This includes DeFi protocols (lending, borrowing, yield aggregation), token launches with custom mechanics, governance systems, NFT marketplaces, DAOs, and any application that needs to custody funds in a smart contract.

The HyperEVM development experience is nearly identical to building on Ethereum or any other EVM chain. Standard tooling works out of the box: Hardhat and Foundry for smart contract development and testing, ethers.js and viem for frontend integration, and familiar Solidity patterns for contract design. Developers do not need to learn a new language or a new framework. If you have built on Ethereum, Arbitrum, or Base, you can build on HyperEVM with minimal friction.

The gas costs on HyperEVM are low — fractions of a cent for simple transactions — and HYPE is used as the gas token. Block times match HyperCore's sub-second finality, meaning contract interactions confirm quickly. For developers coming from Ethereum mainnet, the speed improvement is dramatic. For those coming from L2s like Arbitrum or Base, the experience is comparable but with the added benefit of native access to HyperCore's order book data.

The Shared State Advantage

The ability for HyperEVM to read HyperCore state is arguably the single most underappreciated technical feature of the Hyperliquid architecture. On every other blockchain, DeFi protocols that need price data must rely on external oracle networks — Chainlink, Pyth, Redstone, or similar services. These oracles introduce latency (prices are typically updated every few seconds or on a heartbeat), cost (someone has to pay for oracle updates), and trust assumptions (the oracle operator could theoretically provide incorrect data).

On Hyperliquid, HyperEVM contracts can read the real-time mid-price of any perpetual market listed on HyperCore through a precompile call. This is not an oracle in the traditional sense — it is a direct state read from the same L1. The price is the actual current price on the order book, updated with every trade, with zero latency and zero additional cost. For any asset that Hyperliquid lists as a perpetual market, this provides the highest-quality price feed available anywhere in DeFi.

Beyond prices, HyperEVM contracts can access funding rate data from HyperCore perp markets. Funding rates reflect the cost of holding a leveraged position and are recalculated hourly based on the spread between the perpetual price and the spot index. This data is valuable for yield protocols, delta-neutral strategies, and any application that needs to understand the cost of leverage on a given asset.

Position data is another powerful input. HyperEVM contracts can, through precompiles, query information about positions held on HyperCore. This capability has already enabled novel DeFi applications — most notably, Sentiment, a lending protocol that accepts HyperCore perpetual positions as collateral. A trader can have an open perp position on HyperCore and borrow against it on HyperEVM, without closing the position. This is only possible because HyperEVM can verify the existence and value of the position by reading HyperCore state directly.

The shared state model also has implications for risk management. Lending protocols on HyperEVM can monitor the health of collateral positions in real-time by reading HyperCore state. If a borrower's perp position moves against them, the lending protocol can see it immediately and trigger liquidation if necessary — without waiting for an oracle update. This tighter feedback loop means more efficient liquidations, lower bad debt risk, and ultimately safer lending markets.

For the broader ecosystem, the shared state advantage creates a network effect. Every new perpetual market listed on HyperCore automatically becomes a price feed available to every HyperEVM protocol. Every new DeFi protocol on HyperEVM can leverage the liquidity and price discovery of HyperCore without building its own oracle infrastructure. The two layers are not just coexisting — they are mutually reinforcing, and that composability between native and EVM execution is something no other blockchain currently offers.