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

# 2. What you can build

The six kinds of app Rome is built for, ranked by where it is strongest, each with an app or guide that shows it and the lessons that teach it.

Rome runs EVM chains inside Solana, so the strongest apps on it are the ones that need both sides. This lesson ranks six use cases, most important first, so you can decide where to aim before you write code.

## What you'll learn

* The six use cases Rome is built for, in order of strength.
* Why Rome fits each one, and a real app or guide that shows it.
* Which lessons of the course teach each use case.
* How to choose where to start.

## Before you start

Read [lesson 1](https://docs.rome.builders/rome-academy/01-what-you-are-building.md). You need the idea of one state seen from two wallet lanes. You do not need a wallet or any code yet.

## How the list is ranked

Rome makes EVM and Solana one market. EVM users and Solana users are equal parties: they use the same contracts and the same pools, and each side can call the other. The use cases at the top use that directly. The ones further down build on it or add something around it.

Each example links to an app or guide you can inspect before building. [Apps on Rome](https://docs.rome.builders/apps-on-rome/apps.md) is the full catalog. Unless a page says otherwise, the apps named here run on [Hadrian](https://docs.rome.builders/networks/hadrian.md), the public testnet.

## 1. Solidity apps that use Solana's liquidity and programs

**What it is.** A Solidity contract calls a Solana program in the middle of its own function, such as a swap or a staking deposit, or reads a Solana account, such as a price. The pattern pages also sketch a lending protocol that prices its collateral from Solana oracles.

**Why Rome fits.** The call runs in the same transaction as the rest of your function. If any step fails, the whole transaction reverts, so there is no half-finished swap to clean up.

**See it.**

* [Cardo](https://docs.rome.builders/apps-on-rome/apps.md) reaches Jupiter perps, Meteora swaps and Marinade staking from an EVM account by calling the CPI precompile directly, and composes several of them in one atomic flow.
* [Oracle Gateway](https://docs.rome.builders/products/oracle-gateway.md) serves Pyth and Switchboard prices to Solidity through the Chainlink interface. It is deployed on Hadrian and Rubicon, it is a preview, and it is not audited.
* [DeFi protocols](https://docs.rome.builders/use-cases/defi-protocols.md) shows the patterns as sketches.

**Learn it.** [Lesson 5](https://docs.rome.builders/rome-academy/05-call-solana-from-solidity.md) and [lesson 6](https://docs.rome.builders/rome-academy/06-tokens-on-both-sides.md). [Lesson 4](https://docs.rome.builders/rome-academy/04-how-rome-runs-your-code.md) explains what happens underneath.

## 2. One app for both kinds of wallet

**What it is.** One deployment serves MetaMask users and Solana wallet users. Both reach the same contracts, the same state and the same liquidity. Rome calls this a dual-lane app.

**Why Rome fits.** A Solana wallet signs with its own key. Rome derives an EVM address from that key, so the user needs no EVM key. The app needs only one deployment. Liquidity stays in one pool instead of splitting by wallet type.

**See it.**

* [Rome DEX](https://docs.rome.builders/apps-on-rome/apps.md): one native Solana pool that EVM and Solana wallets both trade.
* [Aerarium](https://docs.rome.builders/apps-on-rome/apps.md): a Compound v3 lending market that both sides supply to and borrow from.
* [Build a dual-lane app](https://docs.rome.builders/developer-guides/dual-lane-app.md) walks through the smallest version, a vault.
* [Choose your core](https://docs.rome.builders/core-concepts/choose-your-core.md) compares a Solidity core with a native Solana core.

**Learn it.** [Lesson 7](https://docs.rome.builders/rome-academy/07-open-to-solana-wallets.md) opens an EVM app to Solana wallets. [Lesson 9](https://docs.rome.builders/rome-academy/09-build-a-dual-lane-app.md) builds the full app.

## 3. Solana programs that reach EVM users

**What it is.** A Solana program you already run becomes usable by people who hold only an EVM wallet. The program does not change.

**Why Rome fits.** Every EVM address has a Solana identity on Rome. Your program sees an ordinary Solana signer and never has to know about EVM addresses.

**See it.**

* [Cardo](https://docs.rome.builders/apps-on-rome/apps.md) lets an EVM wallet use programs that were built for Solana users.
* [Rome DEX](https://docs.rome.builders/apps-on-rome/apps.md) keeps its core in a native Solana program and gives EVM users a thin router in front of it.
* [Integrate a Solana program](https://docs.rome.builders/developer-guides/integrate-solana-program.md) covers who signs, how value gets in and out, and the limits that shape the design.

**Learn it.** [Lesson 8](https://docs.rome.builders/rome-academy/08-open-your-solana-program-to-evm-users.md).

## 4. Assets and users across chains

**What it is.** Users arrive from Ethereum, Base, Arbitrum and other chains, use your app, and take their funds back out. Your app embeds the bridge instead of asking users to find one.

**Why Rome fits.** The Rome Bridge settles on-chain under the user's own signature. It holds no custody keys, and its public API quotes a route and sponsors the settle fee.

**See it.**

* [Rome Bridge](https://docs.rome.builders/apps-on-rome/bridge-api.md) runs on Rubicon, the mainnet, and on Hadrian. USDC moves over CCTP v2 from several EVM chains, and SOL and USDC move from a Solana wallet.
* Solgate connects Solana assets to AggLayer EVM chains in both directions, on mainnet and testnet. On testnet, SPL token registration is permissionless. USDC uses CCTP. See [One market](https://docs.rome.builders/getting-started-1/one-market.md) for the overview.
* [From home](https://docs.rome.builders/developer-guides/from-home.md) shows how to wire your app to the bridge API.
* [Appia](https://docs.rome.builders/apps-on-rome/apps.md) lets users enter from an EVM chain, manage a position on Solana and exit home. The catalog marks it as in validation.

**Learn it.** [Lesson 10](https://docs.rome.builders/rome-academy/10-from-other-chains.md). [Lesson 11](https://docs.rome.builders/rome-academy/11-ship-to-rubicon.md) takes it to mainnet.

## 5. Permissioned real-world assets on both lanes

**What it is.** An issuer creates an asset once, and holders buy and hold it from EVM wallets and Solana wallets. The rule about who may hold the asset lives in the token contract itself.

This example builds on use case 2. It is one Solidity asset served to both lanes, with Trade pools and a Credit lending market on Rome that work on the same asset.

**Why Rome fits.** Because the rule sits in the asset, it holds on every transfer from either lane. The same token and deployment serve both wallet types.

**See it.**

* [Bloom](https://docs.rome.builders/apps-on-rome/bloom.md) is the app. It has guides for investors, issuers and builders, plus a Trade app for pools and a Credit app for lending on the same assets. It runs on Hadrian.
* [Building on Bloom](https://docs.rome.builders/apps-on-rome/bloom/building.md) takes a Solidity asset onto Rome as a permissioned token, step by step.

**Learn it.** No lesson is dedicated to it. Lessons 6, 7 and 9 teach the parts it uses.

## 6. Your own chain with your own gas token

**What it is.** Your app runs on its own Rome chain with its own chain id, and users pay gas in an SPL token you choose. Fees accrue to your app. The chain is still reached by MetaMask and shares state with Solana.

**Why Rome fits.** Most of what you built in the earlier use cases moves to your chain unchanged. The change is in the economics: who earns the gas, and which token pays it.

**See it.** [App Sovereignty](https://docs.rome.builders/products/app-sovereignty.md) lists what you get and how a chain is brought up. The Rome team runs the chain's infrastructure. The page marks the product as live with partners.

**Learn it.** [Lesson 12](https://docs.rome.builders/rome-academy/12-launch-your-own-chain.md), a short overview.

## How to choose where to start

Pick the row that matches what you have today.

| You have                             | Start with                                  | Then                                             |
| ------------------------------------ | ------------------------------------------- | ------------------------------------------------ |
| A Solidity contract                  | Use case 1: call a Solana program from it   | Use case 2, to open it to Solana wallets         |
| A Solana program                     | Use case 3: open it to EVM users            | Use case 2, if you also want a Solidity front    |
| A new idea                           | Use case 2: build it dual-lane from day one | Use case 4, to bring users in                    |
| An app that already works on Hadrian | Use case 4, then mainnet                    | Use case 6, if you need your own chain economics |

Start at use case 1 or 2 and add the others later. Use case 6 is the last step, not the first.

Rome is not the fit in every case. If you only need a standard Solana program for Solana users, build it natively. If you need settlement on Ethereum mainnet, Rome does not provide it. If you need cross-chain messaging without EVM execution, use a messaging protocol directly. [Why Rome?](https://docs.rome.builders/getting-started-1/why-rome.md) covers the comparison.

## Check yourself

1. Your team has an audited Solana lending program and wants MetaMask users to supply to it. Which use case is that, and which lesson do you read? *Use case 3,* [*lesson 8*](https://docs.rome.builders/rome-academy/08-open-your-solana-program-to-evm-users.md)*.*
2. Why does a dual-lane app keep one pool instead of one pool per wallet type? *Both wallet types reach the same contract and the same state, so liquidity is shared.*
3. Which use case is the last step rather than the first? *Use case 6, your own chain. It changes who earns the gas, and the earlier use cases carry over to it.*

## Next

[Lesson 3: Your first contract on Hadrian](https://docs.rome.builders/rome-academy/03-first-contract-on-hadrian.md). You fund a wallet and deploy a contract on the 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/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.
