What is Rome?

Rome Protocol is an EVM execution environment running natively inside the Solana runtime. Solidity smart contracts deploy and execute on Solana through Cross-Program Invocation (CPI), with atomic access to all Solana programs and liquidity — no bridges, no message passing, no sync delays.

How It Works

Rome embeds a full EVM bytecode interpreter as a Solana on-chain program. When you deploy a Solidity contract on Rome, it lives on Solana. When that contract executes, it runs inside Solana's runtime with direct CPI access to any Solana program — SPL Token, Jupiter, Kamino, Drift, Meteora, or your own Anchor program.

┌──────────────────────────────────────────────────────────┐
│ Solana Runtime                                           │
│                                                          │
│   ┌──────────────┐    CPI    ┌──────────────────────┐    │
│   │  Rome EVM    │◄────────►│  Any Solana Program   │    │
│   │  Program     │          │  (Jupiter, Kamino,    │    │
│   │              │          │   Drift, SPL Token,   │    │
│   │  ┌────────┐  │          │   Your Program...)    │    │
│   │  │Solidity│  │          └──────────────────────┘    │
│   │  │Contract│  │                                      │
│   │  └────────┘  │                                      │
│   └──────────────┘                                      │
└──────────────────────────────────────────────────────────┘
         ▲
         │ Standard Ethereum JSON-RPC
         │
   ┌─────┴─────┐
   │  MetaMask  │  Hardhat  │  Foundry  │  ethers.js
   └───────────────────────────────────────────────┘

Key Properties

Single State — EVM contracts and Solana programs share the same state. A USDC balance on Solana and its ERC-20 representation in Rome EVM are the same underlying SPL token account. No bridging delay, no fragmented liquidity.

Standard EVM Tooling — Deploy with Hardhat or Foundry. Interact with MetaMask. Write Solidity. Rome is EVM-compatible — your existing contracts, tools, and workflows work unchanged.

Cross-Program Invocation — Solidity contracts call any Solana program directly via CPI precompiles. Swap on Jupiter, deposit into Kamino, read Pyth prices — all from Solidity, all atomic.

Solana Performance — Transactions settle in ~400ms with Solana's throughput. No separate consensus, no rollup delay.

App Sovereignty — Each application gets its own EVM environment with a custom chain ID, its own gas token (any SPL token), and gas fees that accrue to the app — not a shared protocol.

What Rome Is Not

Rome is not a bridge. There's no message relay between two separate chains. Rome EVM runs inside Solana's runtime as a first-class program.

Rome is not a rollup in the traditional sense. There's no separate consensus mechanism or data availability layer. EVM state IS Solana state.

Products Built on Rome

Product	What It Does	Status
Meta-Hook Router	Token-2022 Transfer Hook multiplexer — run compliance, royalties, analytics on every SPL transfer	In Progress
Rome SDK	Typed Solidity interfaces for Solana programs — SPL Token, System Program, Meteora, oracles	Partially Built
App Sovereignty	Launch your own EVM chain on Solana with custom gas token	Live
Oracle Gateway	Pyth and Switchboard as Chainlink AggregatorV3Interface	V1 Shipped
DeFi Composer	Yearn-style multi-protocol vaults in Solidity via CPI	Designed

Prerequisites

To build on Rome, you need:

• Solidity development experience (Hardhat or Foundry)

• A wallet (MetaMask works out of the box)

• Basic understanding of Solana's account model (covered in Key Concepts)

What's Next

• Why Rome? — how Rome compares to other approaches

• Architecture — deep dive into how EVM execution works on Solana

• Quickstart — deploy your first Solidity contract in under 5 minutes