Quickstart - Revyl Documentation

Set up with an agent

Paste one prompt and your coding agent does the rest.

Setup prompt

Run this app's first Revyl cloud build.

Read https://docs.revyl.com/remote-builds/quickstart.md and follow it. It's the current Revyl guide for this, so prefer it over anything you remember about Revyl.

The project must be a Git worktree, and the recipe's `app_id` must be the UUID of a Revyl app for that platform. Build the recipe `revyl init` wrote with `revyl build --profile <profile> --platform ios`, naming the profile when the config has more than one; use `--platform ios` first if the app builds both.

You're done when `revyl build` finishes and the new build appears in Revyl.

Ask me before anything that needs my login or approval.

Prerequisites

A Revyl account with cloud-build credits and available capacity
Your mobile app project in a Git worktree
A Revyl app for the selected platform, with its UUID configured in the recipe's app_id before submission

Install the CLI

curl -fsSL https://revyl.com/install.sh | sh
revyl auth login

Run init

revyl init

revyl init creates .revyl/config.yaml with a stable project ID and detected named build profiles. Use revyl app list --platform ios (or android) to find your app UUID, or revyl app create to create one.

Configure the build

Configure the build commands in .revyl/config.yaml:

build:
  framework: expo
  profiles:
    development:
      ios:
        app_id: "<your-ios-app-uuid>"
        setup_commands:
          - bun install
          - bunx expo prebuild --platform ios
          - cd ios && pod install
        build_commands:
          - cd ios && xcodebuild -workspace YourApp.xcworkspace -scheme YourApp -configuration Release -sdk iphonesimulator -destination 'generic/platform=iOS Simulator' -derivedDataPath build ARCHS=arm64
        output_path: ios/build/Build/Products/Release-iphonesimulator/*.app
      android:
        app_id: "<your-android-app-uuid>"
        setup_commands:
          - bun install
          - bunx expo prebuild --platform android
        build_commands:
          - cd android && ./gradlew assembleRelease
        output_path: android/app/build/outputs/apk/release/*.apk

For the full set of build options — artifact requirements, environment variables, toolchain images, and more — see Configuration.

Replace the app_id placeholders with your app UUIDs and validate the config:

revyl config validate

Run the build

revyl build --profile development --platform ios

The profile and platform select one recipe, which runs in the cloud by default. When an omitted value has exactly one eligible choice, the CLI resolves it. Otherwise, interactive use prompts and non-interactive use fails with the available choices. No profile is stored as active or default.

Cloud builds upload your working tree. --branch <name> selects the Revyl destination branch. Without it, the build goes to the Git branch of the source it submits, or the app's default branch when there is none. Keep secrets out of source and use encrypted build secrets instead.

Useful variations:

revyl build --profile development --platform ios --debug     # stream full build logs
revyl build --profile development --platform android --json  # machine-readable result
revyl build --profile development --platform ios --detach    # queue and return a job ID

For a detached build:

revyl build status <build-job-id> --follow
revyl build cancel <build-job-id>

Use the build

The new build lands on the destination branch above. With --json, a completed remote build returns status: success and build_version_id. A detached submission returns build_job_id; monitor it with build status, whose successful JSON result contains version_id. Use that uploaded build ID to boot a device and run a test against the exact artifact:

revyl device start --platform ios --build-version-id <uploaded-build-id>
revyl test run <test-alias> --build-id <uploaded-build-id>

To refresh a shared Atlas after merges or weekly, use the maintenance recipe, which explores the exact uploaded build and handles bounded monitoring and cleanup.