> 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/pt-br/introducao/what-is-rome.md).

# O que é Rome?

Rome é um ambiente de execução EVM dentro da Solana. Tudo o que você construir fica aberto para usuários EVM, usuários da Solana e usuários de outras chains. Quatro maneiras de construir.

Rome é um ambiente de execução do EVM que roda dentro da Solana. Tudo o que você constrói na Rome fica aberto para todos ao mesmo tempo — usuários de EVM, usuários da Solana e usuários de outras chains. Você constrói uma vez, e todos eles podem acessá-lo.

## Como Rome funciona

Rome incorpora um interpretador completo de bytecode EVM como um programa on-chain da Solana. Quando você implanta um contrato Solidity na Rome, ele vive na Solana; quando ele executa, roda dentro do runtime da Solana com acesso direto a qualquer programa da Solana — SPL Token, Jupiter, Kamino, Meteora ou seu próprio programa — de forma atômica, em uma única transação. EVM e Solana compartilham o mesmo estado, então um token na Solana e sua forma ERC-20 no EVM são a mesma conta: nada é transferido por bridge nem wrapped.

Como tudo roda na Solana, **qualquer uma das carteiras usa os mesmos apps.** Um usuário do MetaMask assina uma transação EVM da maneira habitual. Um usuário do Phantom assina com sua **Solana** chave — sem par de chaves EVM, sem endereço separado — e usa diretamente os mesmos apps em Solidity. Ambos acessam os mesmos contratos e o mesmo estado, cada um com a identidade que já possui.

```mermaid
flowchart LR
    MM["MetaMask (chave EVM)"] --> APPS
    PH["Phantom (chave Solana)"] --> APPS
    APPS["Rome: seus apps em Solidity<br/>um único estado compartilhado, dentro da Solana"] --> PROGS["Programas da Solana<br/>Jupiter, Meteora, Pyth"]
```

## Como usar Rome

Há quatro maneiras de construir na Rome. Cada uma tem um guia e código funcional para você ler.

### Leve seu Solidity

Implante seus contratos Solidity existentes exatamente como estão. Na Rome eles podem chamar programas da Solana de forma atômica — uma troca, uma leitura de preço — dentro de uma única transação, e o mesmo contrato fica aberto para carteiras EVM, carteiras Solana e usuários vindos de outras chains.

**Como construí-lo:** [Implante em Solidity](/pt-br/guias-do-desenvolvedor/deploy-solidity.md), depois [Chamar Solana a partir da EVM](/pt-br/guias-do-desenvolvedor/call-solana-from-evm.md).

**Exemplos para ler:** Compound v3 e Aave v3 rodam na Rome sem alterações — [compound-on-rome-comet](https://github.com/rome-protocol/compound-on-rome-comet), [rome-aave-v3](https://github.com/rome-protocol/rome-aave-v3). [Aerarium](https://github.com/rome-protocol/aerarium) é um app de empréstimos em que usuários de EVM e Solana compartilham um único mercado.

### Leve seu programa da Solana

Seu programa da Solana continua fazendo o que já faz para seus usuários da Solana. Na Rome, ele também passa a ser acessível a partir de Solidity, então usuários de EVM — e usuários de outras chains — também podem usá-lo, sem nenhuma alteração no programa.

**Como construí-lo:** [Chame um programa da Solana a partir do EVM](/pt-br/guias-do-desenvolvedor/call-solana-from-evm.md); [Chamar EVM a partir da Solana](/pt-br/guias-do-desenvolvedor/call-evm-from-solana.md) cobre a direção oposta.

**Exemplos para ler:** [cardo](https://github.com/rome-protocol/cardo) alcança Jupiter, Meteora, Marinade e Mango a partir de uma conta EVM.

### Traga sua ideia

Comece algo novo que use os dois lados desde o início — um pool compartilhado por usuários de EVM e Solana, um mercado do qual ambos os lados tomam empréstimo, um oráculo que leva os preços da Solana para o EVM. Todo público pode usá-lo desde o primeiro dia.

**Como construí-lo:** primeiro [escolha seu núcleo](/pt-br/conceitos-principais/choose-your-core.md), depois [Chamar Solana a partir da EVM](/pt-br/guias-do-desenvolvedor/call-solana-from-evm.md) e os [padrões de DeFi](/pt-br/casos-de-uso/defi-protocols.md).

**Exemplos para ler:** [rome-dex](https://github.com/rome-protocol/rome-dex) é um único pool negociado por carteiras EVM e Solana; [rome-oracle-gateway](https://github.com/rome-protocol/rome-oracle-gateway) lê feeds de preços da Solana e os disponibiliza para Solidity por meio de uma interface padrão da Chainlink.

### De casa

Seus usuários não precisam se mover. A partir da chain de origem — Arbitrum, Monad ou qualquer outra chain — eles podem acessar um app da Rome e chegar à Solana sem sair de onde já estão.

**Como construí-lo:** [Da chain de origem: acesse Rome a partir de outra chain](/pt-br/guias-do-desenvolvedor/from-home.md).

**Exemplos para ler:** [appia](https://github.com/rome-protocol/appia) — os usuários trazem USDC da sua chain de origem e usam DeFi do lado da Rome; [rome-bridge-api](https://github.com/rome-protocol/rome-bridge-api) é o orquestrador da ponte.

## Execute-o na sua própria chain

Quando estiver pronto, você pode executar qualquer uma dessas opções na sua própria chain Rome, com seu próprio token de gas e taxas que acumulam para seu app. Veja [Soberania do app](/pt-br/produtos/app-sovereignty.md).

## Pré-requisitos

* Experiência com Solidity (Hardhat ou Foundry), ou um programa da Solana para trazer
* Uma carteira — MetaMask e/ou uma carteira Solana como a Phantom
* Uma noção básica do modelo de contas da Solana (veja [Conceitos-chave](/pt-br/introducao/key-concepts.md))

## O que Vem a Seguir

* [Início rápido](/pt-br/introducao/quickstart.md) — implante seu primeiro contrato em minutos
* [Arquitetura](/pt-br/introducao/architecture.md) — como a execução EVM funciona dentro da Solana
* [Apps na Rome](/pt-br/apps-na-rome/apps.md) — o catálogo completo de apps em produção e seus repositórios


---

# 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/pt-br/introducao/what-is-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.