> 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/rome-academy/02-what-you-can-build.md).

# 2. Was du bauen kannst

Die sechs Arten von Apps, für die Rome gebaut ist, nach ihrer Stärke geordnet, jeweils mit einer App oder einem Leitfaden, der sie zeigt, und den Lektionen, die sie vermitteln.

Rome führt EVM-Chains innerhalb von Solana aus. Die stärksten Apps darauf sind daher diejenigen, die beide Seiten brauchen. In dieser Lektion werden sechs Anwendungsfälle nach ihrer Bedeutung geordnet – der wichtigste zuerst –, damit du entscheiden kannst, worauf du dich konzentrieren möchtest, bevor du Code schreibst.

## Das lernst du

* Die sechs Anwendungsfälle, für die Rome entwickelt wurde, nach ihrer Stärke geordnet.
* Warum Rome für jeden Anwendungsfall geeignet ist und welche echte App oder Anleitung ihn veranschaulicht.
* Welche Kurslektionen die einzelnen Anwendungsfälle behandeln.
* So entscheidest du, womit du anfangen möchtest.

## Bevor du loslegst

Lies [Lektion 1](https://docs.rome.builders/de/rome-academy/01-what-you-are-building.md). Du brauchst die Vorstellung eines Zustands, der über zwei Wallet-Pfade hinweg gemeinsam genutzt wird. Eine Wallet oder Code brauchst du noch nicht.

## So ist die Liste geordnet

Rome vereint EVM und Solana zu einem Markt. EVM-Nutzer und Solana-Nutzer sind gleichberechtigte Parteien: Sie verwenden dieselben Contracts und dieselben Pools, und jede Seite kann die andere aufrufen. Die Anwendungsfälle an der Spitze nutzen das unmittelbar. Die weiter unten bauen darauf auf oder ergänzen es um weitere Funktionen.

Zu jedem Beispiel gibt es einen Link zu einer App oder Anleitung, die du dir vor dem Entwickeln ansehen kannst. [Apps auf Rome](https://docs.rome.builders/de/apps-auf-rome/apps.md) ist der vollständige Katalog. Sofern nicht anders angegeben, laufen die hier genannten Apps auf [Hadrian](https://docs.rome.builders/de/netzwerke/hadrian.md), dem öffentlichen Testnetz.

## 1. Solidity-Apps, die Solanas Liquidität und Programme nutzen

**Worum es geht.** Ein Solidity-Contract ruft mitten in einer eigenen Funktion ein Solana-Programm auf, etwa für einen Swap oder eine Staking-Einzahlung, oder liest ein Solana-Konto aus, zum Beispiel einen Preis. Auf den Seiten zu den Mustern wird außerdem ein Lending-Protokoll skizziert, das seine Sicherheiten anhand von Solana-Oracles bewertet.

**Warum Rome dafür geeignet ist.** Der Aufruf läuft in derselben Transaktion wie der Rest deiner Funktion. Schlägt ein Schritt fehl, wird die gesamte Transaktion zurückgesetzt – es bleibt also kein unvollständiger Swap zurück, den du bereinigen musst.

**Beispiele ansehen.**

* [Cardo](https://docs.rome.builders/de/apps-auf-rome/apps.md) greift von einem EVM-Konto aus auf Jupiter-Perps, Meteora-Swaps und Marinade-Staking zu, indem es direkt das CPI-Precompile aufruft, und kombiniert mehrere davon in einem atomaren Ablauf.
* [Oracle Gateway](https://docs.rome.builders/de/produkte/oracle-gateway.md) stellt Solidity über die Chainlink-Schnittstelle Pyth- und Switchboard-Preise bereit. Es ist auf Hadrian und Rubicon bereitgestellt, ist eine Vorschauversion und wurde nicht auditiert.
* [DeFi-Protokolle](https://docs.rome.builders/de/anwendungsfalle/defi-protocols.md) veranschaulicht die Muster anhand von Skizzen.

**Lerne mehr.** [Lektion 5](https://docs.rome.builders/de/rome-academy/05-call-solana-from-solidity.md) und [Lektion 6](https://docs.rome.builders/de/rome-academy/06-tokens-on-both-sides.md). [Lektion 4](https://docs.rome.builders/de/rome-academy/04-how-rome-runs-your-code.md) erklärt, was im Hintergrund passiert.

## 2. Eine App für beide Wallet-Arten

**Worum es geht.** Eine Bereitstellung bedient sowohl MetaMask-Nutzer als auch Nutzer von Solana-Wallets. Beide greifen auf dieselben Contracts, denselben Zustand und dieselbe Liquidität zu. Rome nennt das eine Dual-Lane-App.

**Warum Rome dafür geeignet ist.** Eine Solana-Wallet signiert mit ihrem eigenen Schlüssel. Rome leitet aus diesem Schlüssel eine EVM-Adresse ab, sodass der Nutzer keinen EVM-Schlüssel benötigt. Die App muss nur einmal bereitgestellt werden. Die Liquidität bleibt in einem Pool, statt sich nach Wallet-Art aufzuteilen.

**Beispiele ansehen.**

* [Rome DEX](https://docs.rome.builders/de/apps-auf-rome/apps.md): ein nativer Solana-Pool, auf dem sowohl EVM- als auch Solana-Wallets handeln.
* [Aerarium](https://docs.rome.builders/de/apps-auf-rome/apps.md): ein Lending-Markt auf Basis von Compound v3, auf dem beide Seiten Einlagen bereitstellen und Kredite aufnehmen.
* [Eine Dual-Lane-App entwickeln](https://docs.rome.builders/de/entwicklerleitfaden/dual-lane-app.md) führt durch die kleinste Variante: einen Vault.
* [Wähle deinen Kern](https://docs.rome.builders/de/kernkonzepte/choose-your-core.md) vergleicht einen Solidity-Kern mit einem nativen Solana-Kern.

**Lerne mehr.** [Lektion 7](https://docs.rome.builders/de/rome-academy/07-open-to-solana-wallets.md) macht eine EVM-App für Solana-Wallets zugänglich. [Lektion 9](https://docs.rome.builders/de/rome-academy/09-build-a-dual-lane-app.md) erstellt die vollständige App.

## 3. Solana-Programme, die EVM-Nutzer erreichen

**Worum es geht.** Ein Solana-Programm, das Sie bereits betreiben, wird für Nutzer verfügbar, die nur eine EVM-Wallet besitzen. Das Programm selbst bleibt unverändert.

**Warum Rome passt.** Jede EVM-Adresse hat auf Rome eine Solana-Identität. Ihr Programm sieht einen gewöhnlichen Solana-Signer und muss nie etwas über EVM-Adressen wissen.

**Beispiele ansehen.**

* [Cardo](https://docs.rome.builders/de/apps-auf-rome/apps.md) ermöglicht es EVM-Wallets, Programme zu nutzen, die für Solana-Nutzer entwickelt wurden.
* [Rome DEX](https://docs.rome.builders/de/apps-auf-rome/apps.md) behält seinen Kern in einem nativen Solana-Programm und stellt EVM-Nutzern einen schlanken Router voran.
* [Ein Solana-Programm integrieren](https://docs.rome.builders/de/entwicklerleitfaden/integrate-solana-program.md) erläutert, wer signiert, wie Werte hinein- und hinausgelangen und welche Einschränkungen das Design prägen.

**Mehr erfahren.** [Lektion 8](https://docs.rome.builders/de/rome-academy/08-open-your-solana-program-to-evm-users.md).

## 4. Vermögenswerte und Nutzer über mehrere Chains hinweg

**Worum es geht.** Nutzer kommen von Ethereum, Base, Arbitrum und anderen Chains, verwenden Ihre App und nehmen ihre Gelder anschließend wieder mit. Ihre App bindet die Bridge ein, statt die Nutzer selbst danach suchen zu lassen.

**Warum Rome passt.** Die Rome Bridge wickelt Transaktionen on-chain mit der Signatur des Nutzers selbst ab. Sie verwahrt keine Schlüssel und ihre öffentliche API berechnet ein Angebot für eine Route und übernimmt die Gebühren für die Abwicklung.

**Beispiele ansehen.**

* [Rome Bridge](https://docs.rome.builders/de/apps-auf-rome/bridge-api.md) läuft auf Rubicon, dem Mainnet, sowie auf Hadrian. USDC wird über CCTP v2 von mehreren EVM-Chains übertragen; SOL und USDC lassen sich von einer Solana-Wallet übertragen.
* Solgate verbindet Solana-Vermögenswerte in beide Richtungen mit AggLayer-EVM-Chains – im Mainnet und im Testnet. Im Testnet ist die Registrierung von SPL-Token erlaubnisfrei. Für USDC wird CCTP verwendet. Siehe [One market](https://docs.rome.builders/de/erste-schritte-1/one-market.md) für die Übersicht.
* [Von Anfang an](https://docs.rome.builders/de/entwicklerleitfaden/from-home.md) zeigt, wie Sie Ihre App mit der Bridge-API verbinden.
* [Appia](https://docs.rome.builders/de/apps-auf-rome/apps.md) ermöglicht es Nutzern, von einer EVM-Chain aus einzusteigen, eine Position auf Solana zu verwalten und wieder zur Ausgangs-Chain zurückzukehren. Im Katalog ist die App als in Validierung gekennzeichnet.

**Mehr erfahren.** [Lektion 10](https://docs.rome.builders/de/rome-academy/10-from-other-chains.md). [Lektion 11](https://docs.rome.builders/de/rome-academy/11-ship-to-rubicon.md) bringt es ins Mainnet.

## 5. Regulierte reale Vermögenswerte auf beiden Lanes

**Worum es geht.** Ein Emittent erstellt einen Vermögenswert einmalig, und Inhaber kaufen und halten ihn mit EVM- und Solana-Wallets. Die Regeln dafür, wer den Vermögenswert halten darf, sind im Token-Contract selbst festgelegt.

Dieses Beispiel baut auf Anwendungsfall 2 auf. Es handelt sich um einen Solidity-Vermögenswert, der auf beiden Lanes verfügbar ist, mit Trade-Pools und einem Kreditmarkt auf Rome, die denselben Vermögenswert nutzen.

**Warum Rome passt.** Da die Regel im Vermögenswert selbst verankert ist, gilt sie für jede Übertragung von beiden Lanes aus. Derselbe Token und dieselbe Bereitstellung bedienen beide Wallet-Typen.

**Beispiele ansehen.**

* [Bloom](https://docs.rome.builders/de/apps-auf-rome/bloom.md) ist die App. Sie bietet Anleitungen für Investoren, Emittenten und Entwickler sowie eine Trade-App für Pools und eine Credit-App für die Kreditvergabe mit denselben Vermögenswerten. Sie läuft auf Hadrian.
* [Auf Bloom aufbauen](https://docs.rome.builders/de/apps-auf-rome/bloom/building.md) zeigt Schritt für Schritt, wie ein Solidity-Vermögenswert als erlaubnispflichtiger Token auf Rome bereitgestellt wird.

**Mehr erfahren.** Es gibt keine eigene Lektion dazu. In den Lektionen 6, 7 und 9 lernen Sie die dafür benötigten Komponenten kennen.

## 6. Ihre eigene Chain mit Ihrem eigenen Gas-Token

**Worum es geht.** Ihre App läuft auf ihrer eigenen Rome-Chain mit einer eigenen Chain-ID, und Nutzer zahlen die Gasgebühren mit einem von Ihnen ausgewählten SPL-Token. Die Gebühren fließen Ihrer App zu. Die Chain ist weiterhin über MetaMask erreichbar und teilt ihren Zustand mit Solana.

**Warum Rome passt.** Der Großteil dessen, was Sie in den vorherigen Anwendungsfällen entwickelt haben, lässt sich unverändert auf Ihre Chain übertragen. Die Änderung betrifft die wirtschaftlichen Aspekte: Wer die Gasgebühren erhält und mit welchem Token sie bezahlt werden.

**Mehr dazu.** [App-Souveränität](https://docs.rome.builders/de/produkte/app-sovereignty.md) listet auf, was Sie erhalten und wie eine Chain gestartet wird. Das Rome-Team betreibt die Infrastruktur der Chain. Die Seite kennzeichnet das Produkt als live und mit Partnern.

**Lernen Sie es kennen.** [Lektion 12](https://docs.rome.builders/de/rome-academy/12-launch-your-own-chain.md), ein kurzer Überblick.

## So wählen Sie den richtigen Einstieg

Wählen Sie die Zeile aus, die Ihrer aktuellen Situation entspricht.

| Sie haben                                      | Beginnen Sie mit                                       | Dann                                                                |
| ---------------------------------------------- | ------------------------------------------------------ | ------------------------------------------------------------------- |
| Einen Solidity-Contract                        | Anwendungsfall 1: Ein Solana-Programm damit aufrufen   | Anwendungsfall 2: Für Solana-Wallets öffnen                         |
| Ein Solana-Programm                            | Anwendungsfall 3: Für EVM-Nutzer öffnen                | Anwendungsfall 2, wenn Sie zusätzlich ein Solidity-Frontend möchten |
| Eine neue Idee                                 | Anwendungsfall 2: Von Anfang an zweigleisig entwickeln | Anwendungsfall 4: Nutzer gewinnen                                   |
| Eine App, die bereits auf Hadrian funktioniert | Anwendungsfall 4, danach das Mainnet                   | Anwendungsfall 6, wenn Sie eine eigene Chain-Ökonomie benötigen     |

Beginnen Sie mit Anwendungsfall 1 oder 2 und ergänzen Sie die anderen später. Anwendungsfall 6 ist der letzte Schritt, nicht der erste.

Rome passt nicht in jedem Fall. Wenn Sie lediglich ein standardmäßiges Solana-Programm für Solana-Nutzer benötigen, entwickeln Sie es nativ. Wenn Sie eine Abwicklung auf dem Ethereum-Mainnet benötigen, bietet Rome diese nicht. Wenn Sie Cross-Chain-Messaging ohne EVM-Ausführung benötigen, verwenden Sie direkt ein Messaging-Protokoll. [Warum Rome?](https://docs.rome.builders/de/erste-schritte-1/why-rome.md) behandelt den Vergleich.

## Selbst überprüfen

1. Ihr Team hat ein geprüftes Solana-Kreditvergabeprogramm und möchte, dass MetaMask-Nutzer darauf einzahlen können. Um welchen Anwendungsfall handelt es sich, und welche Lektion lesen Sie? *Anwendungsfall 3,* [*Lektion 8*](https://docs.rome.builders/de/rome-academy/08-open-your-solana-program-to-evm-users.md)*.*
2. Warum verwendet eine zweigleisige App einen gemeinsamen Pool statt eines Pools pro Wallet-Typ? *Beide Wallet-Typen greifen auf denselben Contract und denselben Zustand zu, sodass die Liquidität gemeinsam genutzt wird.*
3. Welcher Anwendungsfall ist der letzte Schritt und nicht der erste? *Anwendungsfall 6: Ihre eigene Chain. Dadurch ändert sich, wer die Gasgebühren erhält, und die früheren Anwendungsfälle lassen sich darauf übertragen.*

## Weiter

[Lektion 3: Ihr erster Contract auf Hadrian](https://docs.rome.builders/de/rome-academy/03-first-contract-on-hadrian.md). Sie laden eine Wallet auf und deployen einen Contract im Testnet.


---

# 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/rome-academy/02-what-you-can-build.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.
