# The every CLI

Installing the [`ruby_everywhere` gem](/docs/diy/introduction) gives you the
`every` command. It is the one entry point for everything: checking your
machine, setting an app up, developing, building, releasing, publishing
updates, and talking to the [Platform](/docs/platform/overview).

```bash title="Terminal"
gem install ruby_everywhere
every --help          # list commands
every version         # or -v / --version
```

## The commands

| Command | What it does |
| --- | --- |
| [`every doctor`](#every-doctor) | Check that this machine can build. |
| [`every install`](#every-install) | Set an app up for RubyEverywhere. |
| [`every dev`](#every-dev) | Run the dev server inside native shells. |
| [`every preview`](#every-preview) | Share the dev server through a tunnel, for the Jump app. |
| [`every logs`](#every-logs) | Stream iOS or Android shell logs. |
| [`every build`](#every-build) | Package the app for desktop, iOS or Android. |
| [`every release`](#every-release) | Sign, notarize, and write a build receipt. |
| [`every publish`](#every-publish) | Push a release to your update bucket. |
| [`every updates keygen`](#every-updates-keygen) | Mint the keypair that signs updates. |
| [`every icon`](#every-icon) | Generate app icons from one PNG. |
| [`every clean`](#every-clean) | Delete the shared build caches. |
| [`every shell-dir`](#every-shell-dir) | Print the path of the bundled shell. |
| [`every platform …`](#platform-commands) | Log in to the Platform and build there. |

## Project commands

These run inside an app directory and work the same whether you build locally
or on the Platform.

### `every doctor`

Check the toolchain and say what is missing. Every section always prints, so
one run answers "what can this machine build?", but only the sections your
`build.targets` name (or `--target` names) can fail the run.

```bash title="Terminal"
every doctor
every doctor --target android
```

```plaintext title="Output"
→ Desktop target
✓ rbe-tebako installed
✓ cargo installed
✓ homebrew bison

→ iOS target (not in build.targets, informational)
✓ full Xcode selected
✓ iOS Simulator SDK
✓ Simulator runtime matches the iOS SDK (xcodebuild -downloadPlatform iOS)
✓ bundled iOS shell template

→ Android target
✓ Android SDK (~/Library/Android/sdk)
✓ JDK 17+ (found 17)
✓ Android SDK command-line tools (~/Library/Android/sdk/cmdline-tools/latest/bin/sdkmanager)
✓ adb (~/Library/Android/sdk/platform-tools/adb)
✓ emulator (~/Library/Android/sdk/emulator/emulator)
✓ an Android virtual device (Medium_Phone_API_35)
✓ platforms;android-36 (have android-35, android-36)
✓ bundled Android shell template

✓ ready to build
```

Every `✗` carries the exact command that fixes it.

| Option | Default | What it does |
| --- | --- | --- |
| `--root` | `.` | App root. Its `build.targets` pick which sections gate the run. |
| `--target` | none | Require one target's toolchain, such as `ios-arm64`. |

### `every install`

Set the current app up: write the boot stub, write `config/everywhere.yml`, pin
the JavaScript bridge, and make the small config changes the shell needs. Apps
start in remote mode (a native shell around your deployed site). Pass `--local`
to compile and ship the app itself, which works on desktop only and needs
SQLite.

```bash title="Terminal"
every install
every install --local
every install --agents
```

| Option | Default | What it does |
| --- | --- | --- |
| `--root` | `.` | App root. |
| `--local` | `false` | Set up local mode instead of remote mode. |
| `--agents` | `false` | Write an `AGENTS.md` guide so AI coding agents understand this app. |

### `every dev`

Run your dev server with native shells on top of it. Live reload, no packaging.
With no shell flag it starts the server and waits, with every shell one keypress
away. Pass flags to open some straight away.

```bash title="Terminal"
every dev                 # server only
every dev --desktop       # plus the desktop window
every dev --ios           # plus the iOS Simulator
every dev --android       # plus an emulator, or a plugged-in phone
every dev --mobile        # both mobile shells
every dev --port 4000
```

| Option | Default | What it does |
| --- | --- | --- |
| `--port` | `3000` | Dev server port. |
| `--target` | none | Open a single shell: `macos`, `ios` or `android`. |
| `--desktop` | `false` | Open the desktop shell. |
| `--ios` | `false` | Open the iOS Simulator shell. |
| `--android` | `false` | Open the Android emulator shell. |
| `--mobile` | `false` | Open both mobile shells. |
| `--browser` | `false` | Open the app in your default browser. |
| `--dev-url` | none | The URL the device loads, such as a LAN address for a physical Android phone. |
| `--shell-dir` | none | Path to the shell's `src-tauri` directory. |

While it runs, these keys work in the terminal:

| Key | Does |
| --- | --- |
| `d` | Open, or rebuild and relaunch, the desktop shell. |
| `i` | The same for the iOS Simulator. |
| `a` | The same for Android, on a plugged-in phone or an emulator. |
| `r` | Open the app in your browser. |
| `l` | Toggle the device log stream alongside the server output. |

Ctrl-C stops everything. Piped or headless runs cannot take keystrokes, so they
open the desktop shell by default.

### `every preview`

Run the dev server behind a shareable tunnel and print a QR code that opens it
in the Jump app, so someone else can hold your work in progress. The tunnel is
a free Cloudflare quick tunnel by default.

```bash title="Terminal"
every preview
every preview --lan                       # no tunnel, share the LAN address
every preview --tunnel-name notes --tunnel-host preview.example.com
```

| Option | Default | What it does |
| --- | --- | --- |
| `--port` | `3000` | Dev server port. |
| `--lan` | `false` | Skip the tunnel and share the LAN address. |
| `--tunnel-name` | none | Run a named tunnel from your own Cloudflare account. |
| `--tunnel-host` | none | The public hostname that named tunnel routes to. |

### `every logs`

Stream the native shell's logs, scoped to your app and filtered down to what
you wrote plus Hotwire Native's own output.

```bash title="Terminal"
every logs --ios
every logs --ios --last 5m
every logs --android
every logs --android --last 500
```

| Option | Default | What it does |
| --- | --- | --- |
| `--ios` | `false` | iOS Simulator logs. |
| `--android` | `false` | Android logcat. |
| `--last` | none | Show history instead of watching: `5m`, `1h`, or a line count on Android. |
| `--udid` | booted one | Which Simulator to read. |
| `--serial` | running emulator | Which Android device to read. |
| `--app-id` | from config | Android applicationId to filter on. |
| `--verbose` | `false` | Everything the shell logs, debug level included. |

### `every build`

Package the app. On desktop this presses your app and the Ruby runtime into one
binary and wraps it in a `.app`; on mobile it stamps and compiles the native
shell around your deployed URL. The first desktop build is the slow one. See
[your first build](/docs/diy/first-build).

```bash title="Terminal"
every build                          # the host desktop target
every build --skip-press             # reuse the pressed binary, rebuild the .app
every build --ios                    # a Simulator .app
every build --ios --device           # a device .ipa
every build --android                # dist/<Name>.apk
every build --android --format aab   # dist/<Name>.aab, for Google Play
```

| Option | Default | What it does |
| --- | --- | --- |
| `--root` | `.` | App root. |
| `--output` | `dist/<app>` | Output binary path. |
| `--ruby` | `4.0.6` | Ruby version to package. |
| `--entry` | `native_boot.rb` | Entry point script, relative to root. |
| `--app-name` | capitalized app dir | Bundle name. |
| `--target` | host platform | Build target as `os-arch`. Overrides `build.targets`. |
| `--ios` | `false` | Short for `--target ios-arm64`. |
| `--android` | `false` | Short for `--target android-arm64`. |
| `--device` | `false` | iOS: archive and export a device `.ipa` instead of a Simulator `.app`. |
| `--format` | `apk` | Android artifact: `apk` or `aab`. |
| `--channel` | `direct` | Distribution channel. macOS takes `direct`; iOS takes `direct`, `testflight` or `app_store`; Android takes `direct` or `play`. |
| `--shell-dir` | bundled | Path to the shell's `src-tauri` directory. |
| `--template-dir` | bundled | Path to the mobile shell template. |
| `--skip-press` | `false` | Reuse the existing pressed binary. |

### `every release`

Sign, notarize, staple, and write `dist/release.json`, the receipt
[`every publish`](#every-publish) reads. On macOS it reads Apple signing secrets
from a dotenv file, `.env.release` by default. See
[signing and notarization](/docs/diy/signing-notarization).

```bash title="Terminal"
every release
every release --target macos-arm64 --channel direct
every release --skip-build            # sign what is already in dist/
```

| Option | Default | What it does |
| --- | --- | --- |
| `--root` | `.` | App root. |
| `--target` | host platform | Build target as `os-arch`. |
| `--channel` | `direct` | Distribution channel, as for `every build`. |
| `--ruby` | `build.ruby`, else `4.0.6` | Ruby version to package. |
| `--entry` | `native_boot.rb` | Entry point script, relative to root. |
| `--app-name` | from config | Bundle name. |
| `--format` | `apk` | Android artifact: `apk` or `aab`. |
| `--env-file` | `.env.release` | Dotenv file holding the `APPLE_*` secrets. |
| `--shell-dir` | bundled | Path to the shell's `src-tauri` directory. |
| `--skip-build` | `false` | Sign the existing build instead of rebuilding. |

> macOS has one channel, `direct`: every macOS release signs with Developer ID
> and notarizes. `every release --target ios-arm64 --channel testflight` uploads
> to App Store Connect from the build machine, which needs Xcode.

### `every publish`

Sign the released artifact and push it, with its update manifest, to your
S3-compatible bucket. Reads `dist/release.json`. See
[app updates](/docs/diy/app-updates).

```bash title="Terminal"
every publish
every publish --channel beta --notes "Fixes the sync bug."
every publish --rollback-to 1.3.2
```

| Option | Default | What it does |
| --- | --- | --- |
| `--root` | `.` | App root. |
| `--receipt` | `dist/release.json` | Build receipt to publish. |
| `--channel` | `updates.channel`, else `stable` | Release channel. |
| `--notes` | none | Release notes shown to users. |
| `--notes-file` | none | Read the notes from a file instead. |
| `--key` | `~/.rubyeverywhere/keys/<bundle_id>.key` | Signing key. |
| `--rollback-to` | none | Point `latest.json` back at a published version. |
| `--latest-alias` / `--no-latest-alias` | on | Maintain the `App-latest.zip` download alias. |
| `--force` | `false` | Overwrite a version already published with different bytes. |

### `every updates keygen`

Mint the keypair that signs your updates. The secret key lands in
`~/.rubyeverywhere/keys/<bundle_id>.key` and never enters your repo; the command
prints the `updates:` block to paste into `everywhere.yml`.

```bash title="Terminal"
every updates keygen
every updates keygen --passphrase
```

| Option | Default | What it does |
| --- | --- | --- |
| `--root` | `.` | App root. |
| `--passphrase` | `false` | Encrypt the secret key with a passphrase it prompts for. |
| `--force` | `false` | Overwrite an existing keypair. |

> Overwriting strands every shipped app: an app signed with the old key refuses
> updates signed with a new one. Back the secret key up somewhere safe.

### `every icon`

Generate macOS `.icns`, Windows `.ico`, and Linux icons from one square PNG.
`every build` does this for you; run it by hand to inspect the output.

```bash title="Terminal"
every icon
every icon path/to/icon.png --output tmp/icons
```

| Option | Default | What it does |
| --- | --- | --- |
| `--root` | `.` | App root, used to find the default icon. |
| `--output` | `dist/icons` | Output directory. |

The source argument defaults to `app.icon` from `everywhere.yml`, then
`icon.png` at the app root.

### `every clean`

Delete the shared build caches under `~/.rubyeverywhere` (or
`$RUBYEVERYWHERE_HOME`): the cargo shell cache, the staged desktop shells, the
iOS DerivedData and package checkouts, and the Android Gradle home, icon font
and stamped projects. Everything there is derived output, so this is safe any
time. The next build is a cold one, and on Android that means downloading
Gradle and the icon font again.

```bash title="Terminal"
every clean
```

### `every shell-dir`

Print the path of the shell that ships inside the gem: the Tauri `src-tauri`
directory, or a mobile template. CI uses it to find the shell without vendoring
a copy.

```bash title="Terminal"
every shell-dir
every shell-dir --target ios
```

| Option | Default | What it does |
| --- | --- | --- |
| `--target` | `macos` | Which shell to print, as an os or `os-arch`. |

## Platform commands

These talk to the [RubyEverywhere Platform](/docs/platform/overview). Start by
[connecting the CLI](/docs/platform/connect-cli).

### `every platform login` / `logout` / `auth status`

Authorize this machine through the device flow, sign out, or check who you are
signed in as.

```bash title="Terminal"
every platform login
every platform auth status
every platform logout
```

| Option | Default | What it does |
| --- | --- | --- |
| `--url` | `$EVERYWHERE_PLATFORM_URL`, else production | Platform base URL. |

### `every platform build`

Build this app on hosted runners. See
[hosted builds](/docs/platform/hosted-builds). It waits for the build and
downloads the artifacts unless you say otherwise.

```bash title="Terminal"
every platform build
every platform build --target macos-arm64 --no-wait
every platform build --target ios-arm64:testflight,android-arm64:play
```

| Option | Default | What it does |
| --- | --- | --- |
| `--root` | `.` | App root. |
| `--url` | production | Platform base URL. |
| `--target` | from `everywhere.yml` | Targets, comma separated, as `os-arch[:channel]`. |
| `--channel` | `direct` | Channel for targets with no `:channel` suffix. |
| `--ruby` | `build.ruby`, else `4.0.6` | Ruby version. |
| `--output` | `<root>/dist` | Where to save artifacts. |
| `--wait` / `--no-wait` | wait | Wait for the build and download the results. |
| `--download` / `--no-download` | download | Download finished artifacts. |

> `every platform runner` also exists. The Platform's own build runners call it;
> you never will.

The every CLI

Installing the ruby_everywhere gem gives you the every command. It is the one entry point for everything: checking your machine, setting an app up, developing, building, releasing, publishing updates, and talking to the Platform.

Terminal bash

gem install ruby_everywhere
every --help          # list commands
every version         # or -v / --version

The commands

Command	What it does
`every doctor`	Check that this machine can build.
`every install`	Set an app up for RubyEverywhere.
`every dev`	Run the dev server inside native shells.
`every preview`	Share the dev server through a tunnel, for the Jump app.
`every logs`	Stream iOS or Android shell logs.
`every build`	Package the app for desktop, iOS or Android.
`every release`	Sign, notarize, and write a build receipt.
`every publish`	Push a release to your update bucket.
`every updates keygen`	Mint the keypair that signs updates.
`every icon`	Generate app icons from one PNG.
`every clean`	Delete the shared build caches.
`every shell-dir`	Print the path of the bundled shell.
`every platform …`	Log in to the Platform and build there.

Project commands

These run inside an app directory and work the same whether you build locally or on the Platform.

`every doctor`

Check the toolchain and say what is missing. Every section always prints, so one run answers "what can this machine build?", but only the sections your build.targets name (or --target names) can fail the run.

Terminal bash

every doctor
every doctor --target android

Output text

→ Desktop target
✓ rbe-tebako installed
✓ cargo installed
✓ homebrew bison

→ iOS target (not in build.targets, informational)
✓ full Xcode selected
✓ iOS Simulator SDK
✓ Simulator runtime matches the iOS SDK (xcodebuild -downloadPlatform iOS)
✓ bundled iOS shell template

→ Android target
✓ Android SDK (~/Library/Android/sdk)
✓ JDK 17+ (found 17)
✓ Android SDK command-line tools (~/Library/Android/sdk/cmdline-tools/latest/bin/sdkmanager)
✓ adb (~/Library/Android/sdk/platform-tools/adb)
✓ emulator (~/Library/Android/sdk/emulator/emulator)
✓ an Android virtual device (Medium_Phone_API_35)
✓ platforms;android-36 (have android-35, android-36)
✓ bundled Android shell template

✓ ready to build

Every ✗ carries the exact command that fixes it.

Option	Default	What it does
`--root`	`.`	App root. Its `build.targets` pick which sections gate the run.
`--target`	none	Require one target's toolchain, such as `ios-arm64`.

`every install`

Set the current app up: write the boot stub, write config/everywhere.yml, pin the JavaScript bridge, and make the small config changes the shell needs. Apps start in remote mode (a native shell around your deployed site). Pass --local to compile and ship the app itself, which works on desktop only and needs SQLite.

Terminal bash

every install
every install --local
every install --agents

Option	Default	What it does
`--root`	`.`	App root.
`--local`	`false`	Set up local mode instead of remote mode.
`--agents`	`false`	Write an `AGENTS.md` guide so AI coding agents understand this app.

`every dev`

Run your dev server with native shells on top of it. Live reload, no packaging. With no shell flag it starts the server and waits, with every shell one keypress away. Pass flags to open some straight away.

Terminal bash

every dev                 # server only
every dev --desktop       # plus the desktop window
every dev --ios           # plus the iOS Simulator
every dev --android       # plus an emulator, or a plugged-in phone
every dev --mobile        # both mobile shells
every dev --port 4000

Option	Default	What it does
`--port`	`3000`	Dev server port.
`--target`	none	Open a single shell: `macos`, `ios` or `android`.
`--desktop`	`false`	Open the desktop shell.
`--ios`	`false`	Open the iOS Simulator shell.
`--android`	`false`	Open the Android emulator shell.
`--mobile`	`false`	Open both mobile shells.
`--browser`	`false`	Open the app in your default browser.
`--dev-url`	none	The URL the device loads, such as a LAN address for a physical Android phone.
`--shell-dir`	none	Path to the shell's `src-tauri` directory.

While it runs, these keys work in the terminal:

Key	Does
`d`	Open, or rebuild and relaunch, the desktop shell.
`i`	The same for the iOS Simulator.
`a`	The same for Android, on a plugged-in phone or an emulator.
`r`	Open the app in your browser.
`l`	Toggle the device log stream alongside the server output.

Ctrl-C stops everything. Piped or headless runs cannot take keystrokes, so they open the desktop shell by default.

`every preview`

Run the dev server behind a shareable tunnel and print a QR code that opens it in the Jump app, so someone else can hold your work in progress. The tunnel is a free Cloudflare quick tunnel by default.

Terminal bash

every preview
every preview --lan                       # no tunnel, share the LAN address
every preview --tunnel-name notes --tunnel-host preview.example.com

Option	Default	What it does
`--port`	`3000`	Dev server port.
`--lan`	`false`	Skip the tunnel and share the LAN address.
`--tunnel-name`	none	Run a named tunnel from your own Cloudflare account.
`--tunnel-host`	none	The public hostname that named tunnel routes to.

`every logs`

Stream the native shell's logs, scoped to your app and filtered down to what you wrote plus Hotwire Native's own output.

Terminal bash

every logs --ios
every logs --ios --last 5m
every logs --android
every logs --android --last 500

Option	Default	What it does
`--ios`	`false`	iOS Simulator logs.
`--android`	`false`	Android logcat.
`--last`	none	Show history instead of watching: `5m`, `1h`, or a line count on Android.
`--udid`	booted one	Which Simulator to read.
`--serial`	running emulator	Which Android device to read.
`--app-id`	from config	Android applicationId to filter on.
`--verbose`	`false`	Everything the shell logs, debug level included.

`every build`

Package the app. On desktop this presses your app and the Ruby runtime into one binary and wraps it in a .app; on mobile it stamps and compiles the native shell around your deployed URL. The first desktop build is the slow one. See your first build.

Terminal bash

every build                          # the host desktop target
every build --skip-press             # reuse the pressed binary, rebuild the .app
every build --ios                    # a Simulator .app
every build --ios --device           # a device .ipa
every build --android                # dist/<Name>.apk
every build --android --format aab   # dist/<Name>.aab, for Google Play

Option	Default	What it does
`--root`	`.`	App root.
`--output`	`dist/<app>`	Output binary path.
`--ruby`	`4.0.6`	Ruby version to package.
`--entry`	`native_boot.rb`	Entry point script, relative to root.
`--app-name`	capitalized app dir	Bundle name.
`--target`	host platform	Build target as `os-arch`. Overrides `build.targets`.
`--ios`	`false`	Short for `--target ios-arm64`.
`--android`	`false`	Short for `--target android-arm64`.
`--device`	`false`	iOS: archive and export a device `.ipa` instead of a Simulator `.app`.
`--format`	`apk`	Android artifact: `apk` or `aab`.
`--channel`	`direct`	Distribution channel. macOS takes `direct`; iOS takes `direct`, `testflight` or `app_store`; Android takes `direct` or `play`.
`--shell-dir`	bundled	Path to the shell's `src-tauri` directory.
`--template-dir`	bundled	Path to the mobile shell template.
`--skip-press`	`false`	Reuse the existing pressed binary.

`every release`

Sign, notarize, staple, and write dist/release.json, the receipt every publish reads. On macOS it reads Apple signing secrets from a dotenv file, .env.release by default. See signing and notarization.

Terminal bash

every release
every release --target macos-arm64 --channel direct
every release --skip-build            # sign what is already in dist/

Option	Default	What it does
`--root`	`.`	App root.
`--target`	host platform	Build target as `os-arch`.
`--channel`	`direct`	Distribution channel, as for `every build`.
`--ruby`	`build.ruby`, else `4.0.6`	Ruby version to package.
`--entry`	`native_boot.rb`	Entry point script, relative to root.
`--app-name`	from config	Bundle name.
`--format`	`apk`	Android artifact: `apk` or `aab`.
`--env-file`	`.env.release`	Dotenv file holding the `APPLE_*` secrets.
`--shell-dir`	bundled	Path to the shell's `src-tauri` directory.
`--skip-build`	`false`	Sign the existing build instead of rebuilding.

macOS has one channel, direct: every macOS release signs with Developer ID and notarizes. every release --target ios-arm64 --channel testflight uploads to App Store Connect from the build machine, which needs Xcode.

`every publish`

Sign the released artifact and push it, with its update manifest, to your S3-compatible bucket. Reads dist/release.json. See app updates.

Terminal bash

every publish
every publish --channel beta --notes "Fixes the sync bug."
every publish --rollback-to 1.3.2

Option	Default	What it does
`--root`	`.`	App root.
`--receipt`	`dist/release.json`	Build receipt to publish.
`--channel`	`updates.channel`, else `stable`	Release channel.
`--notes`	none	Release notes shown to users.
`--notes-file`	none	Read the notes from a file instead.
`--key`	`~/.rubyeverywhere/keys/<bundle_id>.key`	Signing key.
`--rollback-to`	none	Point `latest.json` back at a published version.
`--latest-alias` / `--no-latest-alias`	on	Maintain the `App-latest.zip` download alias.
`--force`	`false`	Overwrite a version already published with different bytes.

`every updates keygen`

Mint the keypair that signs your updates. The secret key lands in ~/.rubyeverywhere/keys/<bundle_id>.key and never enters your repo; the command prints the updates: block to paste into everywhere.yml.

Terminal bash

every updates keygen
every updates keygen --passphrase

Option	Default	What it does
`--root`	`.`	App root.
`--passphrase`	`false`	Encrypt the secret key with a passphrase it prompts for.
`--force`	`false`	Overwrite an existing keypair.

Overwriting strands every shipped app: an app signed with the old key refuses updates signed with a new one. Back the secret key up somewhere safe.

`every icon`

Generate macOS .icns, Windows .ico, and Linux icons from one square PNG. every build does this for you; run it by hand to inspect the output.

Terminal bash

every icon
every icon path/to/icon.png --output tmp/icons

Option	Default	What it does
`--root`	`.`	App root, used to find the default icon.
`--output`	`dist/icons`	Output directory.

The source argument defaults to app.icon from everywhere.yml, then icon.png at the app root.

`every clean`

Delete the shared build caches under ~/.rubyeverywhere (or $RUBYEVERYWHERE_HOME): the cargo shell cache, the staged desktop shells, the iOS DerivedData and package checkouts, and the Android Gradle home, icon font and stamped projects. Everything there is derived output, so this is safe any time. The next build is a cold one, and on Android that means downloading Gradle and the icon font again.

Terminal bash

every clean

`every shell-dir`

Print the path of the shell that ships inside the gem: the Tauri src-tauri directory, or a mobile template. CI uses it to find the shell without vendoring a copy.

Terminal bash

every shell-dir
every shell-dir --target ios

Option	Default	What it does
`--target`	`macos`	Which shell to print, as an os or `os-arch`.

Platform commands

These talk to the RubyEverywhere Platform. Start by connecting the CLI.

`every platform login` / `logout` / `auth status`

Authorize this machine through the device flow, sign out, or check who you are signed in as.

Terminal bash

every platform login
every platform auth status
every platform logout

Option	Default	What it does
`--url`	`$EVERYWHERE_PLATFORM_URL`, else production	Platform base URL.

`every platform build`

Build this app on hosted runners. See hosted builds. It waits for the build and downloads the artifacts unless you say otherwise.

Terminal bash

every platform build
every platform build --target macos-arm64 --no-wait
every platform build --target ios-arm64:testflight,android-arm64:play

Option	Default	What it does
`--root`	`.`	App root.
`--url`	production	Platform base URL.
`--target`	from `everywhere.yml`	Targets, comma separated, as `os-arch[:channel]`.
`--channel`	`direct`	Channel for targets with no `:channel` suffix.
`--ruby`	`build.ruby`, else `4.0.6`	Ruby version.
`--output`	`<root>/dist`	Where to save artifacts.
`--wait` / `--no-wait`	wait	Wait for the build and download the results.
`--download` / `--no-download`	download	Download finished artifacts.

every platform runner also exists. The Platform's own build runners call it; you never will.

The every CLI

The commands#

Project commands#

every doctor#

every install#

every dev#

every preview#

every logs#

every build#

every release#

every publish#

every updates keygen#

every icon#

every clean#

every shell-dir#

Platform commands#

every platform login / logout / auth status#

every platform build#

The commands

Project commands

`every doctor`

`every install`

`every dev`

`every preview`

`every logs`

`every build`

`every release`

`every publish`

`every updates keygen`

`every icon`

`every clean`

`every shell-dir`

Platform commands

`every platform login` / `logout` / `auth status`

`every platform build`