> 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/de/erste-schritte/what-is-rome.md).

# Was ist Rome?

Rome ist eine EVM-Ausführungsumgebung, die in Solana läuft. Was immer du auf Rome baust, ist gleichzeitig für alle offen — EVM-Nutzer, Solana-Nutzer und Nutzer auf anderen Chains. Du baust einmal, und jeder von ihnen kann darauf zugreifen.

## Wie Rome funktioniert

Rome bettet einen vollständigen EVM-Bytecode-Interpreter als On-Chain-Programm auf Solana ein. Wenn du einen Solidity-Vertrag auf Rome deployest, lebt er auf Solana; wenn er läuft, läuft er innerhalb von Solanas Runtime mit direktem Zugriff auf jedes Solana-Programm — SPL Token, Jupiter, Kamino, Meteora oder dein eigenes Programm — atomar, in einer einzigen Transaktion. EVM und Solana teilen sich denselben State, sodass ein Token auf Solana und seine ERC-20-Form in der EVM dasselbe Konto sind: Es wird nichts überbrückt oder gewrappt.

Weil alles auf Solana läuft, **steuert jede Wallet dieselben Apps.** Ein MetaMask-Nutzer signiert eine EVM-Transaktion auf die übliche Weise. Ein Phantom-Nutzer signiert mit seinem **Solana** Schlüssel — kein EVM-Keypair, keine separate Adresse — und verwendet direkt genau dieselben Solidity-Apps. Beide erreichen dieselben Verträge und denselben State, jeweils mit der Identität, die sie bereits haben.

```mermaid
flowchart LR
    MM["MetaMask (EVM-Schlüssel)"] --> APPS
    PH["Phantom (Solana-Schlüssel)"] --> APPS
    APPS["Rome: deine Solidity-Apps<br/>ein gemeinsamer State, innerhalb von Solana"] --> PROGS["Solana-Programme<br/>Jupiter, Meteora, Pyth"]
```

## Wie man Rome benutzt

Es gibt vier Möglichkeiten, auf Rome zu bauen. Für jede gibt es eine Anleitung und lauffähigen Code, den du lesen kannst.

### Bring deinen Solidity-Code mit

Deploye deine bestehenden Solidity-Verträge unverändert. Auf Rome können sie Solana-Programme atomar aufrufen — einen Swap, eine Preisabfrage — innerhalb einer Transaktion, und derselbe Vertrag ist offen für EVM-Wallets, Solana-Wallets und Nutzer, die von anderen Chains kommen.

**So baust du es:** [Solidity deployen](/de/entwicklerleitfaden/deploy-solidity.md), dann [Solana aus der EVM aufrufen](/de/entwicklerleitfaden/call-solana-from-evm.md).

**Beispiele zum Nachlesen:** Compound v3 und Aave v3 laufen unverändert auf Rome — [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) ist eine Lending-App, bei der EVM- und Solana-Nutzer sich einen Markt teilen.

### Bring dein Solana-Programm mit

Dein Solana-Programm macht weiterhin das, was es bereits für deine Solana-Nutzer tut. Auf Rome ist es auch aus Solidity heraus erreichbar, sodass EVM-Nutzer — und Nutzer auf anderen Chains — es ebenfalls nutzen können, ohne dass am Programm etwas geändert werden muss.

**So baust du es:** [Ein Solana-Programm aus der EVM aufrufen](/de/entwicklerleitfaden/call-solana-from-evm.md); [Die EVM aus Solana aufrufen](/de/entwicklerleitfaden/call-evm-from-solana.md) deckt die andere Richtung ab.

**Beispiele zum Nachlesen:** [cardo](https://github.com/rome-protocol/cardo) erreicht Jupiter, Meteora, Marinade und Mango von einem EVM-Konto aus.

### Bring deine Idee mit

Starte etwas Neues, das von Anfang an beide Seiten nutzt — einen Pool, den sich EVM- und Solana-Nutzer teilen, einen Markt, aus dem beide Seiten Kredite aufnehmen, ein Oracle, das Solana-Preise in die EVM bringt. Jede Zielgruppe kann es vom ersten Tag an nutzen.

**So baust du es:** zuerst [wähle deinen Kern](/de/kernkonzepte/choose-your-core.md), dann [Solana aus der EVM aufrufen](/de/entwicklerleitfaden/call-solana-from-evm.md) und die [DeFi-Muster](/de/anwendungsfalle/defi-protocols.md).

**Beispiele zum Nachlesen:** [rome-dex](https://github.com/rome-protocol/rome-dex) ist ein einziger Pool, der von EVM- und Solana-Wallets gehandelt wird; [rome-oracle-gateway](https://github.com/rome-protocol/rome-oracle-gateway) liest Solana-Preisdaten und stellt sie Solidity über eine standardmäßige Chainlink-Schnittstelle bereit.

### Von zu Hause aus

Deine Nutzer müssen nicht wechseln. Von ihrer Heimat-Chain — Arbitrum, Monad oder jeder anderen Chain — aus können sie eine Rome-App erreichen und zu Solana gelangen, ohne ihren bisherigen Ort zu verlassen.

**So baust du es:** [Von zu Hause aus: Rome von einer anderen Chain aus erreichen](/de/entwicklerleitfaden/from-home.md).

**Beispiele zum Nachlesen:** [appia](https://github.com/rome-protocol/appia) — Nutzer bringen USDC von ihrer Heimat-Chain mit und nutzen DeFi auf der Rome-Seite; [rome-bridge-api](https://github.com/rome-protocol/rome-bridge-api) ist der Bridge-Orchestrator.

## Betreibe es auf deiner eigenen Chain

Wenn du bereit bist, kannst du all das auf deiner eigenen Rome-Chain betreiben, mit deinem eigenen Gas-Token und Gebühren, die deiner App zufließen. Siehe [App-Souveränität](/de/produkte/app-sovereignty.md).

## Voraussetzungen

* Erfahrung mit Solidity (Hardhat oder Foundry) oder ein Solana-Programm, das du mitbringen kannst
* Eine Wallet — MetaMask und/oder eine Solana-Wallet wie Phantom
* Ein grundlegendes Verständnis von Solanas Kontomodell (siehe [Schlüsselkonzepte](/de/erste-schritte/key-concepts.md))

## Wie geht's weiter

* [Schnellstart](/de/erste-schritte/quickstart.md) — deploye deinen ersten Vertrag in wenigen Minuten
* [Architektur](/de/erste-schritte/architecture.md) — wie die EVM-Ausführung innerhalb von Solana funktioniert
* [Apps auf Rome](/de/apps-auf-rome/apps.md) — der vollständige Katalog der live verfügbaren Apps und ihrer Repos


---

# 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 dynamically by asking a question.

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

```
GET https://docs.rome.builders/de/erste-schritte/what-is-rome.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.