> 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 innerhalb von Solana. Was auch immer du baust, ist für EVM-Nutzer, Solana-Nutzer und Nutzer auf anderen Chains offen. Vier Möglichkeiten zum Bauen.

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

## Wie Rome funktioniert

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

Weil alles auf Solana läuft, **steuern beide Wallets dieselben Apps.** Ein MetaMask-Nutzer signiert eine EVM-Transaktion auf die übliche Weise. Ein Phantom-Nutzer signiert mit seinem **Solana** Schlüssel — kein EVM-Schlüsselpaar, keine separate Adresse — und nutzt direkt genau dieselben Solidity-Apps. Beide erreichen dieselben Verträge und denselben Zustand, 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 Zustand, innerhalb von Solana"] --> PROGS["Solana-Programme<br/>Jupiter, Meteora, Pyth"]
```

## So nutzt du Rome

Es gibt vier Möglichkeiten, auf Rome zu bauen. Jede hat eine Anleitung und funktionierenden Code, den du lesen kannst.

### Bring deinen Solidity-Code mit

Stelle deine bestehenden Solidity-Verträge unverändert bereit. Auf Rome können sie Solana-Programme atomar aufrufen — einen Swap, einen Preisabruf — innerhalb einer einzigen Transaktion, und derselbe Vertrag ist für EVM-Wallets, Solana-Wallets und Nutzer aus anderen Chains offen.

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

**Beispiele zum Lesen:** Compound v3 und Aave v3 laufen auf Rome unverändert — [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 sich EVM- und Solana-Nutzer 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 wird es außerdem aus Solidity heraus erreichbar, sodass auch EVM-Nutzer — und Nutzer auf anderen Chains — es nutzen können, ohne Änderungen am Programm.

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

**Beispiele zum Lesen:** [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 EVM- und Solana-Nutzer gemeinsam verwenden, einen Markt, aus dem beide Seiten leihen, ein Orakel, das Solana-Preise ins EVM bringt. Jedes Publikum 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 EVM aufrufen](/de/entwicklerleitfaden/call-solana-from-evm.md) und die [DeFi-Muster](/de/anwendungsfalle/defi-protocols.md).

**Beispiele zum Lesen:** [rome-dex](https://github.com/rome-protocol/rome-dex) ist ein Pool, der sowohl von EVM- als auch von Solana-Wallets gehandelt wird; [rome-oracle-gateway](https://github.com/rome-protocol/rome-oracle-gateway) liest Solana-Preisfeeds aus und stellt sie Solidity über eine Standard-Chainlink-Schnittstelle bereit.

### Von zu Hause

Deine Nutzer müssen nicht wechseln. Von ihrer Heimat-Chain — Arbitrum, Monad oder einer anderen Chain — aus können sie eine Rome-App erreichen und zu Solana gelangen, ohne ihren gewohnten 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 Lesen:** [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 ausführen, mit deinem eigenen Gas-Token und Gebühren, die deiner App zugutekommen. Siehe [App-Souveränität](/de/produkte/app-sovereignty.md).

## Voraussetzungen

* Erfahrung mit Solidity (Hardhat oder Foundry) oder ein Solana-Programm zum Mitbringen
* Eine Wallet — MetaMask und/oder eine Solana-Wallet wie Phantom
* Ein grundlegendes Verständnis des Solana-Kontomodells (siehe [Schlüsselkonzepte](/de/erste-schritte/key-concepts.md))

## Wie es weitergeht

* [Schnellstart](/de/erste-schritte/quickstart.md) — deploye deinen ersten Vertrag in 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-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 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/de/erste-schritte/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.