The Skip command-line interface (CLI) is a tool that can be run from the terminal on macOS, Linux, or Windows. It provides an interface for creating new Skip projects (both framework and app projects), building and testing for Android, managing the Swift Android SDK and emulators, and exporting built artifacts for publication.

The skip CLI is installed using Homebrew ↗. Skip is distributed as a binary Homebrew “Cask” for macOS, Linux, and Windows (with WSL 2 ↗). For complete details, see the Getting Started Guide.

Once Homebrew is set up, Skip can be installed (and updated) by running the Terminal command:

brew install skip

This will download and install the skip tool itself, as well as the Android SDK dependencies that are necessary for building and testing the Kotlin/Android side of your apps.

To upgrade to the latest version:

skip upgrade

USAGE: skip <subcommand>

SUBCOMMANDS:
  version                 Print the skip version
  doctor                  Evaluate and diagnose Skip development environment
  checkup                 Run tests to ensure Skip is in working order
  upgrade                 Upgrade to the latest Skip version
  create                  Create a new Skip project interactively
  init                    Initialize a new Skip project
  verify                  Verify Skip project
  icon                    Create and manage app icons
  app                     Build, run, and manage Skip apps
  android                 Build, run, and test Swift packages for Android
  export                  Export the Gradle project and built artifacts
  devices                 List connected devices and emulators/simulators
  test                    Run parity tests and generate reports

Run skip help <subcommand> for detailed help on any command, or skip <subcommand> --help for the full list of flags.

Most commands share a set of common option groups:

Output Options control how results are displayed:

Tool Options override the default paths for external tools:

Create a new Skip project through interactive prompts. This will ask you to choose between a native (Fuse) or transpiled (Lite) project, app or library, and walk you through configuration options.

skip create

For non-interactive project creation, use skip init instead.

Initialize a new Skip project with a single command. This is the non-interactive alternative to skip create.

# Create a native (Fuse) app project
skip init --native-app --appid=com.example.myapp my-app MyApp

# Create a transpiled (Lite) app project
skip init --transpiled-app --appid=com.example.myapp my-app MyApp

# Create a native library project
skip init --native-model my-lib MyModule

# Create a transpiled library project
skip init --transpiled-model my-lib MyModule

# Create an app with multiple modules
skip init --native-app --appid=com.example.myapp my-app MyApp DataModel

Key flags:

Validate the structure and configuration of a Skip project. Checks Package.swift layout, skip.yml files, and module dependencies.

# Verify the current project
skip verify

# Verify a specific project
skip verify --project path/to/project

# Attempt to automatically fix issues
skip verify --fix

Create and manage app icons for both iOS and Android. Generates all required sizes from a single input image.

# Resize a PNG for all required icon sizes
skip icon app_icon.png

# Generate icons with a colored background and SVG overlay
skip icon --background #5C6BC0-#3B3F54 symbol.svg

# Preview the generated icons
skip icon --open-preview --random-icon --random-background

Key flags:

Build and export Skip modules as distributable artifacts. Libraries are exported as .aar files and apps as .apk/.aab files.

# Export debug archives
skip export --debug

# Export a specific module
skip export --module ModuleName

# Export to a custom output folder
skip export --dir output/

Build and launch a conventional Skip app on the booted iOS Simulator and a running Android emulator together in one step. Reads PRODUCT_NAME and PRODUCT_BUNDLE_IDENTIFIER from Skip.env, then drives xcodebuild, xcrun simctl install, and xcrun simctl launch for iOS while letting the Skip build plugin handle the Android Gradle build and install via adb.

# Build and launch on both iOS simulator and Android emulator (default)
skip app launch

# Build and launch a release build
skip app launch --configuration release

# Build and launch only the iOS app on the booted simulator
skip app launch --ios

# Build and launch only the Android app via the Skip plugin
skip app launch --android

Pre-flight:

• The project must be a conventional Skip app project, meaning it contains a Project.xcworkspace, a Skip.env configuration file, and Darwin/ and Android/ folders alongside Package.swift. skip init --transpiled-app and skip init --native-app produce projects in this shape.
• You must boot an iOS Simulator yourself (xcrun simctl boot <UDID>; open -a Simulator) and start an Android emulator (emulator -avd <name> or skip android emulator launch). skip app launch does not start either for you. If no simulator is booted the iOS install step fails; if no emulator is running the Android install step fails.

When you have both a USB-connected Android device and a running emulator, scope the install to the emulator with the standard ANDROID_SERIAL environment variable:

ANDROID_SERIAL=emulator-5554 skip app launch

skip app launch has no --android-serial flag; the env var is the documented way to target a specific Android device.

Check system configuration and prerequisites for Skip development. Validates Xcode, Android Studio, JDK, Gradle, and SDK versions.

# Run basic environment checks
skip doctor

# Include checks for native Swift-on-Android support
skip doctor --native

This is a subset of skip checkup (which also creates and builds a sample project).

Perform a full system evaluation by running all the checks from skip doctor and then creating and building a sample Skip project to verify everything works end to end.

# Full system checkup
skip checkup

# Include native app support checks
skip checkup --native

Check for and install the latest version of the Skip toolchain.

skip upgrade

List all connected Android emulators/devices (via adb) and iOS simulators/devices (via simctl and devicectl). Useful for verifying which targets are available before running or testing.

skip devices

Output includes device IDs, platform, type, and model information in JSON format.

Build and run Swift (XCTest) and transpiled Kotlin (JUnit) tests, then produce a side-by-side parity report. By default, Kotlin tests run locally via Robolectric. Use --android-serial to run instrumented tests on a connected device or emulator.

# Run parity tests locally (Robolectric)
skip test

# Run tests for a specific project
skip test --project path/to/project

# Run instrumented tests on a connected device
skip test --android-serial auto

# Target a specific emulator
skip test --android-serial emulator-5554

Key flags:

The skip android command group provides tools for cross-compiling Swift packages with the Swift Android SDK, running executables and tests on Android devices or emulators, and managing the SDK, toolchain, and emulator images.

USAGE: skip android <subcommand>

SUBCOMMANDS:
  build                   Build the native project for Android
  run                     Run the executable target on an Android device or emulator
  test                    Test the native project on an Android device or emulator
  home                    Install and manage the Android SDK in ANDROID_HOME
  sdk                     Manage installation of Swift Android SDK
  emulator                Manage Android emulators
  toolchain               Manage installation of Swift Android Host Toolchain

Cross-compile a Swift package for Android using the installed Swift Android SDK.

# Build for Android (debug)
skip android build

# Build for release
skip android build --configuration release

# Build and archive output to a folder
skip android build --dir output/

# Build for a specific architecture
skip android build --arch aarch64

Additional swift build flags can be passed as trailing arguments.

Build a Swift package for Android, push the executable and shared library dependencies to a connected device or emulator, and run it.

# Run the default executable
skip android run

# Run a specific executable with arguments
skip android run MyExecutable -- --flag value

# Target a specific emulator
skip android run --android-serial emulator-5554

Key flags:

Build Swift tests for Android, push them to a device or emulator, and execute them. By default, tests run as a native executable via adb shell. With --apk, tests are packaged as an Android APK and run via instrumentation.

# Run tests on a connected device
skip android test

# Run tests as an APK (instrumented tests)
skip android test --apk

# Target a specific emulator
skip android test --android-serial emulator-5554

# Run only Swift Testing tests
skip android test --testing-library testing

# Run only XCTest tests
skip android test --testing-library xctest

Key flags:

The build, run, and test subcommands share these toolchain options for controlling the cross-compilation:

Manage the Swift cross-compilation SDK for Android. The SDK is required for compiling Swift code to run natively on Android (Skip Fuse mode).

Install the Swift Android SDK. By default, installs the latest released version.

# Install the latest release
skip android sdk install

# Install a specific version
skip android sdk install --version 6.3

# Install the latest nightly build
skip android sdk install --version nightly-main

List installed Swift Android SDKs.

# List locally installed SDKs
skip android sdk list

# List available remote SDKs
skip android sdk list --remote

Remove installed Swift Android SDKs.

# Uninstall all installed SDKs
skip android sdk uninstall

# Uninstall a specific version
skip android sdk uninstall --version swift-6.3-RELEASE_android

Create, list, and launch Android emulator images (AVDs). Emulators are used for testing when no physical Android device is connected.

Install a system image and create an Android Virtual Device (AVD).

# Create the default emulator (API 34)
skip android emulator create

# Create a custom emulator
skip android emulator create \
  --name pixel_7_api_36 \
  --device-profile pixel_7 \
  --android-api-level 36 \
  --system-image google_apis_playstore_ps16k

Launch an Android emulator. If only one AVD is installed, it is launched automatically. Otherwise, the default emulator name is used, or you can specify one with --name.

# Launch the default emulator
skip android emulator launch

# Launch a specific emulator
skip android emulator launch --name emulator-34-medium_phone

# Launch in the background (returns after boot completes)
skip android emulator launch --background

# Launch headless (no window, for CI)
skip android emulator launch --headless --background

Key flags:

List installed Android emulator images (AVDs).

skip android emulator list

Set up the base Android SDK in your ANDROID_HOME directory. Installs cmdline-tools, platform-tools, and the emulator component.

skip android home install

This is typically only needed once, or after a fresh system setup. Most users will have Android Studio handle SDK installation.

Show the version of the installed Swift Android Host Toolchain.

skip android toolchain version

Add -v or --verbose to any command to see detailed output, including the exact shell commands being executed. This is invaluable for diagnosing build or configuration issues.

skip android test --verbose

When multiple Android devices or emulators are connected, commands that target a device will automatically prefer emulators over physical devices. To target a specific device, use the --android-serial flag:

# List connected devices to find serial numbers
skip devices

# Target a specific device
skip android test --android-serial emulator-5554

You can also set the ANDROID_SERIAL environment variable, which will be respected by all commands.

For continuous integration, a typical setup looks like:

# Install Skip and the Android SDK
brew install skip
skip android sdk install
skip android emulator create

# Launch an emulator in the background (headless, waits for boot)
skip android emulator launch --background --headless

# Run tests
skip android test

The emulator launch command waits until the device is fully booted before returning, so the test command can run immediately after.

Every command supports --help for a full list of available flags:

skip android test --help

For further assistance, visit the Skip forums ↗ or join our Slack.