> For the complete documentation index, see [llms.txt](https://docs.rome.builders/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.rome.builders/getting-started-1/why-rome.md).

# Why Rome?

Rome makes EVM and Solana one market. How Rome differs from other EVM-on-Solana approaches: atomic CPI composability, single shared state, and app chains with custom gas tokens.

Rome makes EVM and Solana one market.

Several projects bring EVM compatibility to Solana. Rome takes a different approach. It runs EVM chains inside Solana, so any EVM protocol can deploy once and open itself to Solana wallets, and a Solidity contract can call Solana programs directly. EVM users and Solana users are equal parties in one market.

## Core Differentiators

### 1. Atomic Composability via CPI

Rome is the only EVM environment where Solidity contracts can call Solana programs within the same transaction. A single Solidity function can:

```solidity
// All in one atomic transaction:
int256 price = IPyth(PYTH).getPrice("SOL/USD");        // Read Pyth oracle
uint256 quote = IJupiter(JUPITER).getQuote(USDC, SOL);  // Get Jupiter quote
IJupiter(JUPITER).swap(USDC, SOL, amount, minOut);       // Execute swap
IKamino(KAMINO).deposit(SOL, collateralAmount);          // Supply to Kamino
```

If any step fails, the entire transaction reverts. No partial execution, no race conditions.

### 2. Single State

Inside Rome, a wallet's SPL token and its ERC-20 wrapper read the same token account, so a Solidity contract that moves USDC moves the actual SPL USDC.

This means:

* **No liquidity fragmentation** — Solana DeFi and EVM DeFi share the same pools
* **One balance** — a wallet's USDC is the same balance whether a Solidity contract or a Solana program reads it.
* **Real-time composability** — EVM contracts see Solana state changes immediately

### 3. App Sovereignty

Each application on Rome gets its own EVM environment:

* **Custom chain ID** — your app is its own chain
* **Custom gas token** — any SPL token, priced via Meteora LP pool
* **Gas revenue** — fees accrue to your application, not Rome protocol
* **Full EVM tooling** — your users connect MetaMask, your devs use Hardhat

## When to Use Rome

**Use Rome when:**

* You want EVM contracts with direct access to Solana DeFi
* You want a sovereign EVM chain on Solana with your own gas token
* You're porting Ethereum contracts that need Solana's speed and liquidity
* You need atomic operations across EVM and Solana programs

**Consider alternatives when:**

* You only need standard Solana programs (use native Solana/Anchor)
* You need Ethereum mainnet settlement (use a traditional L2)
* You need cross-chain messaging without EVM execution (use Wormhole/Hyperlane directly)

## What's Next

* [Architecture](https://docs.rome.builders/getting-started-1/architecture.md) — how Rome EVM works inside Solana
* [Quickstart](https://docs.rome.builders/getting-started-1/quickstart.md) — deploy your first contract


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

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

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.rome.builders/getting-started-1/why-rome.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

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.
