# Was ist Rome?

Rome Protocol ist eine EVM-Ausführungsumgebung, die nativ innerhalb der Solana-Runtime läuft. Solidity-Smart-Contracts werden auf Solana über Cross-Program Invocation (CPI) bereitgestellt und ausgeführt, mit atomarem Zugriff auf alle Solana-Programme und Liquidität — keine Bridges, kein Nachrichtenaustausch, keine Synchronisationsverzögerungen.

## So funktioniert es

Rome bettet einen vollständigen EVM-Bytecode-Interpreter als On-Chain-Programm auf Solana ein. Wenn du einen Solidity-Vertrag auf Rome bereitstellst, lebt er auf Solana. Wenn dieser Vertrag ausgeführt wird, läuft er innerhalb der Solana-Runtime mit direktem CPI-Zugriff auf jedes Solana-Programm — SPL Token, Jupiter, Kamino, Drift, Meteora oder dein eigenes Anchor-Programm.

```
┌──────────────────────────────────────────────────────────┐
│ Solana-Runtime                                           │
│                                                          │
│   ┌──────────────┐    CPI    ┌──────────────────────┐    │
│   │  Rome EVM    │◄────────►│  Jedes Solana-Programm│    │
│   │  Programm    │          │  (Jupiter, Kamino,    │    │
│   │              │          │   Drift, SPL Token,   │    │
│   │  ┌────────┐  │          │   dein Programm...)   │    │
│   │  │Solidity│  │          └──────────────────────┘    │
│   │  │Vertrag │  │                                      │
│   │  └────────┘  │                                      │
│   └──────────────┘                                      │
└──────────────────────────────────────────────────────────┘
         ▲
         │ Standardmäßiges Ethereum-JSON-RPC
         │
   ┌─────┴─────┐
   │  MetaMask  │  Hardhat  │  Foundry  │  ethers.js
   └───────────────────────────────────────────────┘
```

## Wesentliche Eigenschaften

**Einzelner Zustand** — EVM-Verträge und Solana-Programme teilen sich denselben Zustand. Ein USDC-Guthaben auf Solana und seine ERC-20-Darstellung in Rome EVM sind dasselbe zugrunde liegende SPL-Token-Konto. Keine Bridging-Verzögerung, keine fragmentierte Liquidität.

**Standard-EVM-Tooling** — Bereitstellung mit Hardhat oder Foundry. Interaktion mit MetaMask. Solidity schreiben. Rome ist EVM-kompatibel — deine bestehenden Verträge, Tools und Workflows funktionieren unverändert.

**Cross-Program Invocation** — Solidity-Verträge rufen jedes Solana-Programm direkt über CPI-Precompiles auf. Auf Jupiter tauschen, in Kamino einzahlen, Pyth-Preise lesen — alles aus Solidity, alles atomar.

**Solana-Performance** — Transaktionen werden in etwa 400 ms mit dem Durchsatz von Solana abgewickelt. Kein separater Konsens, keine Rollup-Verzögerung.

**App-Souveränität** — Jede Anwendung erhält ihre eigene EVM-Umgebung mit einer benutzerdefinierten Chain-ID, ihrem eigenen Gas-Token (beliebiges SPL-Token) und Gasgebühren, die der App zugutekommen — nicht einem gemeinsamen Protokoll.

## Was Rome nicht ist

Rome ist **keine Bridge**. Es gibt kein Nachrichten-Relay zwischen zwei separaten Chains. Rome EVM läuft innerhalb der Solana-Runtime als erstklassiges Programm.

Rome ist **kein Rollup** im traditionellen Sinne. Es gibt keinen separaten Konsensmechanismus und keine Data-Availability-Schicht. EVM-Zustand IST Solana-Zustand.

## Produkte auf Rome-Basis

| Produkt                                              | Was es tut                                                                                                    | Status             |
| ---------------------------------------------------- | ------------------------------------------------------------------------------------------------------------- | ------------------ |
| [Meta-Hook Router](/de/produkte/meta-hook-router.md) | Token-2022-Transfer-Hook-Multiplexer — Compliance, Royalties und Analysen bei jeder SPL-Übertragung ausführen | In Arbeit          |
| [Rome SDK](/de/produkte/rome-sdk.md)                 | Typisierte Solidity-Interfaces für Solana-Programme — SPL Token, System Program, Meteora, Orakel              | Teilweise erstellt |
| [App-Souveränität](/de/produkte/app-sovereignty.md)  | Starte deine eigene EVM-Chain auf Solana mit benutzerdefiniertem Gas-Token                                    | Live               |
| [Oracle Gateway](/de/produkte/oracle-gateway.md)     | Pyth und Switchboard als Chainlink AggregatorV3Interface                                                      | V1 ausgeliefert    |
| [DeFi Composer](/de/produkte/defi-composer.md)       | Yearn-ähnliche Multi-Protokoll-Vaults in Solidity über CPI                                                    | Entworfen          |

## Voraussetzungen

Um auf Rome zu bauen, brauchst du:

* Erfahrung in der Solidity-Entwicklung (Hardhat oder Foundry)
* Eine Wallet (MetaMask funktioniert sofort)
* Grundlegendes Verständnis des Solana-Account-Modells (abgedeckt in [Wichtige Konzepte](/de/erste-schritte/key-concepts.md))

## Was kommt als Nächstes

* [Warum Rome?](/de/erste-schritte/why-rome.md) — wie Rome im Vergleich zu anderen Ansätzen abschneidet
* [Architektur](/de/erste-schritte/architecture.md) — detaillierter Einblick, wie EVM-Ausführung auf Solana funktioniert
* [Quickstart](/de/erste-schritte/quickstart.md) — deploye deinen ersten Solidity-Vertrag in unter 5 Minuten


---

# 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/de/erste-schritte/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.