> ## Documentation Index
> Fetch the complete documentation index at: https://gora.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Gora developer docs

> Build locally, deploy to Gora Devnet, and connect app results to Base, Solana, or Algorand.

# Gora developer docs

Gora runs your app code off-chain, produces a verifiable result, and gives wallets or contracts the information they need to act on-chain.

The normal development setup is:

```text theme={null}
Devnet VM runs Gora + Dev Bridge + local chains + ngrok
        ↓
Your local computer runs the Gora CLI and app code
        ↓
Your app deploys to the Gora ngrok URL
        ↓
Gora returns results, attestations, contract metadata, and signing requests
```

You do not need the VM's chain files on your local machine. For example, a local Algorand developer should use the Gora Devnet endpoint to resolve the deployed Algorand `app_id`, not ask for the VM's `--datadir`.

## Start here

If you are the Devnet operator on the VM:

```bash theme={null}
gora devnet up
```

This starts the local chains, the Gora dev HTTP API, the Dev Bridge, ngrok tunnels, and the contract metadata registry.

If you are developing from your local computer:

```bash theme={null}
gora init my-agent --template agent-mobile-signing --chain algorand --yes
cd my-agent

gora config set node.url https://gora-dev.ngrok.app
gora contract deploy --chain algorand --node https://gora-dev.ngrok.app
gora contract link --chain algorand

gora build
gora validate
gora deploy
gora invoke --app my_agent --input fixtures/request.json --wait
```

## What to read

| Goal                                     | Page                                                                |
| ---------------------------------------- | ------------------------------------------------------------------- |
| Understand the system                    | [How Gora apps work](./concepts/how-gora-apps-work)                 |
| Understand validators and consensus      | [Validators and consensus](./concepts/validators-and-consensus)     |
| Use verifiable randomness                | [Randomness and VRF](./concepts/randomness-and-vrf)                 |
| Call external HTTP endpoints from an app | [External calls](./concepts/external-calls)                         |
| Create an app                            | [Create a Gora app](./app/create-offchain-wasm-app)                 |
| Add or resolve chain contracts           | [Add chain contracts](./app/add-smart-contract)                     |
| Build an app that holds value on-chain   | [Build an attested on-chain app](./app/build-attested-on-chain-app) |
| Rebuild a working reference app          | [Examples](./examples)                                              |
| Configure permissions and payments       | [Set policy and payments](./app/set-policy-and-payments)            |
| Run the full Devnet flow                 | [Devnet quickstart](./launch/devnet-js-ts-quickstart)               |
| Build the three MVP app flows            | [Canonical Gora app flows](./launch/canonical-flows)                |
| Deploy an existing app                   | [Deploy to Gora](./launch/deploy-to-gora)                           |
| Test mobile approval/signing             | [Test with mobile](./launch/test-with-mobile)                       |
| Fix common problems                      | [Troubleshooting](./launch/troubleshooting)                         |

## The golden path

```bash theme={null}
gora init my-app --template agent-mobile-signing --chain base --yes
cd my-app

gora config set node.url https://DEVNET-ENDPOINT

gora contract doctor --chain base --node https://DEVNET-ENDPOINT
gora contract deploy --chain base --node https://DEVNET-ENDPOINT
gora contract link --chain base

gora build
gora validate
gora package
gora deploy

gora invoke --app my_app --input fixtures/request.json --wait
gora inspect result <request-id>
gora inspect attestation <request-id>
gora status --app my_app
```

## Safety rules

* Gora app code returns JSON; it should not hold private keys.
* `gora deploy` deploys the Gora app package, not chain contracts.
* `gora contract deploy --node <url>` resolves or records chain contract metadata from Gora Devnet.
* Chain execution happens through a gateway, wallet, contract, mobile signature, or submitter.
* Devnet keys and mnemonics are for local testing only.