# 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](/products/meta-hook-router.md) | Token-2022 Transfer Hook multiplexer — run compliance, royalties, analytics on every SPL transfer | In Progress     |
| [Rome SDK](/products/rome-sdk.md)                 | Typed Solidity interfaces for Solana programs — SPL Token, System Program, Meteora, oracles       | Partially Built |
| [App Sovereignty](/products/app-sovereignty.md)   | Launch your own EVM chain on Solana with custom gas token                                         | Live            |
| [Oracle Gateway](/products/oracle-gateway.md)     | Pyth and Switchboard as Chainlink AggregatorV3Interface                                           | V1 Shipped      |
| [DeFi Composer](/products/defi-composer.md)       | 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](/getting-started/key-concepts.md))

## What's Next

* [Why Rome?](/getting-started/why-rome.md) — how Rome compares to other approaches
* [Architecture](/getting-started/architecture.md) — deep dive into how EVM execution works on Solana
* [Quickstart](/getting-started/quickstart.md) — deploy your first Solidity contract in under 5 minutes


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.rome.builders/getting-started/what-is-rome.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.