Menu

Glossary of Terms

This page is a reference of terms used in the Skip documentation, covering Skip-specific concepts, iOS development, and Android development.

Skip-Specific Terms

Skip

A technology that enables iOS developers to build native iOS and Android apps from a single Swift codebase using SwiftUI. Skip can operate in Lite mode, where it transpiles Swift code to Kotlin, or it can operate in Fuse mode, where it uses the Swift SDK for Android to compile Swift code natively for Android. In both cases, Skip utilizes a SwiftUI to Jetpack Compose translation process that produces genuinely native apps for both platforms.

Resources:

External Resources:

Skip Lite

Skip’s transpilation mode where Swift code is converted (or transpiled) to Kotlin for Android. Contrast with Skip Fuse, which uses the Swift SDK for Android to facilitate using compiled Swift for the Android platform. Both modes produce fully native apps.

Related Terms: Skip Fuse, Transpiler, Skip Zero

Learn More: Skip Lite vs. Fuse Documentation

Skip Fuse

Skip’s modern app development mode that uses native Swift built with the Swift SDK for Android. Skip Fuse does not have any limitations on Swift language support, but it does lead to larger app sizes.

Related Terms: Skip Lite

Learn More: Native and Transpiled Mode

See Also:

Skip Plugin

An Xcode and SwiftPM plugin — also known as skipstone — that handles the conversion of an iOS project into an Android project. The plugin handles resource conversion and packaging, localization processing, building bridges between Swift and Kotlin in Skip Fuse mode, and performing Swift to Kotlin transpilation in Skip Lite mode. In both modes, the plugin automatically translates SwiftUI into Jetpack Compose as you develop.

Related Terms: Xcode, Transpiler, SwiftPM, Skip Lite, Skip Fuse, Skip Bridge

External Resources:

Skip CLI

The skip command-line tool that is used to create and manage Skip projects, handle interaction with gradle and the Android emulator, and perform system checkups and project validation. The Skip CLI is installed and managed with the Homebrew package management system.

Related Terms: Xcode, SwiftPM, Transpiler

Reference: Installation, Skip CLI References

SkipUI

A Skip framework that bridges SwiftUI to Jetpack Compose, allowing SwiftUI views to render natively on Android using Compose. Part of the core Skip framework stack.

Related Terms: SwiftUI, Jetpack Compose

Reference: SkipUI

SkipFoundation

A Skip framework that provides Android implementations of Swift Foundation APIs, enabling common functionality like date handling, networking, and data structures to work across both platforms.

Related Terms: Swift Foundation, Transpiler

Reference: SkipFoundation

SkipLib

The core Skip library that provides fundamental transpilation support and runtime utilities for converting Swift code to Kotlin.

Reference: SkipLib

SkipBridge

A framework that facilitates seamless integration between Swift and Kotlin code, enabling direct calls between iOS and Android platform-specific implementations. The bridging is handled automatically and transparently by the Skip Plugin, and is implemented through a combination of source processing by Skip Lite and JNI interfaces generated by Skip Fuse.

Related Terms: Platform Customization

Reference: SkipBridge

SkipModel

A Skip framework that provides cross-platform support for Swift’s Observation framework by bridging it to the Compose Runtime. SkipModel enables reactive state management patterns to work seamlessly across iOS and Android, allowing @Observable classes to trigger UI updates in both SwiftUI and Jetpack Compose.

Related Terms: Observation, Compose Runtime, SwiftUI, Jetpack Compose

Reference: SkipModel

SkipUnit

A Skip framework that bridges Apple’s XCTest framework to Android’s JUnit testing framework, enabling developers to write tests once in Swift and have them automatically run on both platforms. SkipUnit is essential for parity testing in Skip projects.

Related Terms: XCTest, JUnit, Parity Testing, Unit Testing

Reference: SkipUnit

Skip Zero

A mode in Skip Lite that enables the iOS side of the app to strip out all Skip dependencies, meaning your iOS app has no runtime dependencies on any Skip frameworks. This results in minimal app size and memory footprint and eliminates any reliance on Skip for the iOS side of the app.

Related Terms: Skip Lite

Ejectability

When using Skip Zero with Skip Lite, ejectability refers to the potential to remove Skip completely from a project and still have fully-functional iOS and Kotlin apps that can be iterated on separately. It de-risks the adoption of Skip by providing an insurance policy for technology developed with Skip that it will continue to be viable going forward even if the project decides against continuing with Skip in the future.

Related Terms: Skip Lite

Transpiler

A source-to-source compiler that translates code from one programming language to another. Skip Lite’s transpiler converts Swift code to Kotlin and SwiftUI views to Jetpack Compose components. Transpilation is one of the functions of the Skip Plugin.

Related Terms: Swift, Kotlin, Compiler

External Resources:

Platform Customization

The ability to write platform-specific code for iOS and Android within a Skip project, allowing developers to leverage native APIs and frameworks when shared code isn’t sufficient.

Related Terms: SkipBridge, Conditional Compilation

Learn More: Platform Customization Guide

Dual-Platform Development

The practice of developing for both iOS and Android simultaneously from a single codebase, which is Skip’s core value proposition. Skip facilitates using a single language (Swift) and a single IDE (Xcode) to iteratively develop an app for both iOS and Android simultaneously.

Related Terms: Cross-Platform Development

Parity Testing

A testing methodology unique to Skip where the same test cases are executed on both iOS (via XCTest) and Android (via JUnit) to verify identical behavior across platforms. Parity testing ensures that shared business logic produces consistent results on both platforms and helps catch platform-specific bugs early in development. The Skip CLI includes a skip test command that runs parity tests and generates a comparison report.

Related Terms: Unit Testing, XCTest, JUnit, Skip CLI

Learn More: Testing Documentation

iOS Development Terms

Xcode

Apple’s integrated development environment (IDE) for macOS, used to develop software for iOS, macOS, watchOS, and tvOS. Xcode is the primary IDE for Skip development, which relies on the Skip Build Plugin to automatically translate iOS projects in Android projects whenever the project is built.

Related Terms: Swift, SwiftUI, IDE

External Resources:

Swift

A modern, type-safe programming language developed by Apple for iOS, macOS, and other Apple platforms. Swift is the primary language used in Skip development for writing code that runs on both iOS and Android.

Related Terms: Xcode, SwiftUI, Kotlin

External Resources:

Swift SDK for Android

The officially-supported cross-compilation SDK that can compile Swift code to the Android platform and is distributed by swift.org. The Swift SDK for Android was jointly developed by the Skip team alongside Swift community members and was officially released in 2025.

Related Terms: Skip Fuse, Swift

See Also:

External Resources:

SwiftUI

Apple’s declarative UI framework for building user interfaces across all Apple platforms. In Skip, SwiftUI code is used to create UIs that render natively as SwiftUI on iOS and Jetpack Compose on Android.

Related Terms: Swift, Jetpack Compose, Declarative UI

External Resources:

Swift Foundation

Apple’s fundamental framework providing essential data types, collections, and operating system services. Skip Foundation provides Android implementations of many Foundation APIs.

Related Terms: Swift, SkipFoundation

External Resources:

Observation

A Swift framework introduced in iOS 17 and macOS 14 that provides a modern approach to observable state management using the @Observable macro. SkipModel bridges Observation to Android’s Compose Runtime, allowing observable patterns to work across both platforms in Skip apps.

Related Terms: SwiftUI, SkipModel, Compose Runtime

External Resources:

SwiftPM (Swift Package Manager)

Apple’s official dependency manager for Swift projects, integrated into Xcode. Skip projects use SwiftPM to manage both iOS and Android dependencies.

Related Terms: Swift, Xcode, Package Manager

External Resources:

UIKit

Apple’s older imperative UI framework for iOS development, predating SwiftUI. Skip focuses on SwiftUI rather than UIKit.

Related Terms: SwiftUI, Declarative UI, Imperative UI

External Resources:

iOS

Apple’s mobile operating system that powers iPhones and iPads. Skip enables developers to build iOS apps that also run natively on Android.

Related Terms: Android, Xcode

External Resources:

Liquid Glass

Apple’s next-generation user interface released for iOS 26. Apple’s system-wide visual design language introduced in iOS 26, representing an aesthetic overhaul that replaces flat elements with a “digital meta-material” characterized by dynamic translucency, real-time light refraction, and fluid motion. Skip apps fully support Liquid Glass.

See Also:

External Resources:

Apple App Store

Apple’s digital distribution platform for iOS apps. Skip-built apps can be published to the App Store alongside Google Play Store distribution.

Related Terms: Google Play Store

External Resources:

XCTest

Apple’s testing framework for writing unit tests and UI tests in Swift and Objective-C. In Skip projects, XCTest cases are automatically transpiled or bridged to JUnit tests via SkipUnit, enabling parity testing across both platforms.

Related Terms: Unit Testing, JUnit, SkipUnit, Swift

External Resources:

Android Development Terms

Android

Google’s open-source mobile operating system powering billions of devices worldwide. Skip transpiles iOS apps to run natively on Android using Kotlin and Jetpack Compose.

Related Terms: iOS, Kotlin, Android Studio

External Resources:

Android Studio

The official integrated development environment (IDE) for Android development, based on IntelliJ IDEA. While Skip’s primary IDE is Xcode, Android Studio can be used for advanced Android customization.

Related Terms: Xcode, IDE, Kotlin

External Resources:

Kotlin

A modern, statically-typed programming language that runs on the JVM and is Google’s preferred language for Android development. Skip’s transpiler converts Swift code to Kotlin for Android.

Related Terms: Swift, Java, Transpiler

External Resources:

Jetpack Compose

Android’s modern declarative UI toolkit, similar to SwiftUI. Skip translates SwiftUI views into Jetpack Compose components, producing native Android UIs.

Related Terms: SwiftUI, Kotlin, Declarative UI

External Resources:

Android Views

Android’s original imperative UI toolkit, similar to UIKit on iOS. Android Views are sometimes known as XML Views and have been supplanted by Jetpack Compose as the recommended technology for building modern Android apps.

Related Terms: Jetpack Compose, Java, Imperative UI

Gradle

A build automation system used for Android projects. Skip-generated Android projects use Gradle for building, testing, and dependency management for the Android side of the app. Gradle can be thought of as the Java/Kotlin equivalent for the Swift Package Manager.

Related Terms: Android Studio, Build System, SwiftPM

External Resources:

Fastlane

A suite of open source tools designed to automate the process of building and distributing mobile apps for both the Apple App Store and the Google Play Store. It streamlines tasks such as generating screenshots, handling code signing, managing app metadata, and uploading builds to app stores. Skip will automatically generate fastlane project templates when creating an app project with skip create or skip init.

Reference: Deployment, Skip CLI References

External Resources:

See Also:

Android SDK (Software Development Kit)

A collection of tools, libraries, and APIs required for developing Android applications. Skip developers need the Android SDK installed for building Android versions of their apps.

Related Terms: Android Studio, Gradle

External Resources:

JVM (Java Virtual Machine)

The runtime environment that executes Java and Kotlin bytecode. Android apps written in Kotlin run on the Android Runtime (ART), which is based on JVM principles.

Related Terms: Kotlin, Java, Android Runtime

External Resources:

JNI (Java Native Interface)

A foreign function interface designed for non-Java programming languages (like Swift) to interface with Java libraries. JNI is a necessary part of Skip Fuse’s ability to create bridges to the Android SDK and thereby enable the creation of useful apps on the Android platform.

Related Terms: Kotlin, Java, Android Runtime

External Resources:

Android Runtime (ART)

Android’s managed runtime environment that executes app code. ART replaced Dalvik and provides improved performance through ahead-of-time (AOT) compilation.

Related Terms: JVM, Kotlin

External Resources:

Google Play Store

Google’s official app distribution platform for Android. Skip-built apps can be published to Google Play alongside App Store distribution.

Related Terms: Apple App Store, Android

External Resources:

Java

A widely-used programming language for Android development before Kotlin became Google’s preferred language. Both Kotlin and Java target the JVM and Android Runtime. Skip’s transpilation and bridging targets Kotlin rather than Java.

Related Terms: Kotlin, JVM, Android Runtime

External Resources:

Robolectric

A mode of unit testing Android frameworks where tests execute locally on a JVM rather then connecting to an Android emulator or device. Rests run with Robolectric are more lightweight and run faster than connected tests, but do not cover the complete Android API surface and do not support testing user-interface components.

Related Terms: Unit Testing, JVM, Android Runtime

External Resources:

JUnit

A widely-used testing framework for Java and Kotlin applications. In Skip projects, XCTest cases are automatically converted to JUnit tests via SkipUnit, enabling the same tests to run on both iOS and Android.

Related Terms: Unit Testing, XCTest, SkipUnit, Kotlin, Robolectric

External Resources:

Compose Runtime

The reactive state management system that underlies Jetpack Compose. Compose Runtime handles state observation, recomposition, and UI updates. SkipModel bridges Swift’s Observation framework to Compose Runtime, enabling reactive patterns to work across both platforms.

Related Terms: Jetpack Compose, SkipModel, Observation

External Resources:

ADB (Android Debug Bridge)

A command-line tool that facilitates communication between a development computer and Android devices or emulators. Skip developers use ADB for tasks like viewing logs (adb logcat), installing apps, and managing connected devices. The ANDROID_SERIAL environment variable can be set to target specific devices when running Skip tests.

Related Terms: Android SDK, Android Studio, Gradle

External Resources:

APK (Android Package Kit)

The package file format used to distribute and install applications on Android devices. Skip’s skip export command generates an APK file containing the compiled Android version of your app. APK files are analogous to iOS’s .ipa files.

Related Terms: Android, Google Play Store, Gradle

External Resources:

General Development Concepts

Cross-Platform Development

The practice of building applications that run on multiple operating systems or platforms from a single codebase. Skip is a cross-platform solution specifically designed for iOS and Android.

Related Terms: Dual-Platform Development, Native Development

Native Development

Building applications using platform-specific languages, frameworks, and tools designed for a particular operating system. Skip produces truly native apps for both iOS and Android.

Related Terms: Cross-Platform Development

Declarative UI

A programming paradigm where UI is described as a function of state, focusing on what the UI should look like rather than how to construct it. Both SwiftUI and Jetpack Compose are declarative UI frameworks.

Related Terms: SwiftUI, Jetpack Compose, Imperative UI

External Resources:

Imperative UI

A programming paradigm where UI is constructed through explicit step-by-step instructions. UIKit on iOS is an example of imperative UI.

Related Terms: Declarative UI, UIKit, Android Views

IDE (Integrated Development Environment)

A software application providing comprehensive facilities for software development, typically including a code editor, debugger, and build tools. Xcode and Android Studio are IDEs.

Related Terms: Xcode, Android Studio

Compiler

A program that translates source code from a high-level programming language to machine code or intermediate code. Unlike a transpiler, which translates to another high-level language.

Related Terms: Transpiler, Build System

Build System

Software that automates the process of compiling source code into executable programs. Gradle is Android’s build system, while SwiftPM and Xcode’s build system handle iOS builds.

Related Terms: Gradle, SwiftPM, Compiler

Package Manager

A tool that automates the process of installing, upgrading, and managing software dependencies. SwiftPM manages Swift dependencies, while Gradle handles Android dependencies.

Related Terms: SwiftPM, Gradle

Homebrew

A package manager for macOS (and Linux) used to install and manage software packages. The Skip CLI and its prerequisites are distributed via Homebrew using the command brew install skiptools/skip/skip.

Related Terms: Skip CLI, Package Manager

External Resources:

Conditional Compilation

A preprocessor feature that allows including or excluding code based on compile-time conditions. Skip developers use conditional compilation to write platform-specific code for iOS vs. Android.

Related Terms: Platform Customization

External Resources:

API (Application Programming Interface)

A set of rules and protocols that allows different software components to communicate. Skip bridges iOS and Android APIs for dual-platform development.

Related Terms: Framework, SDK

Framework

A reusable software platform providing core functionality that can be extended by developers. SwiftUI, Jetpack Compose, and Skip’s own frameworks are examples.

Related Terms: API, Library

Library

A collection of pre-written code that developers can use to optimize tasks. Unlike frameworks, libraries are called by your code rather than calling your code.

Related Terms: Framework, Package Manager

SDK (Software Development Kit)

A collection of tools, libraries, documentation, and samples that enable development for a specific platform. The Android SDK is required for Skip development.

Related Terms: API, Framework

Runtime

The period during which a program is executing, or the software environment that executes a program. Skip’s Skip Zero approach means no additional runtime is added to iOS apps.

Related Terms: JVM, Android Runtime

Source Code

Human-readable program instructions written in a programming language. Skip’s transpiler converts Swift source code to Kotlin source code.

Related Terms: Compiler, Transpiler

Unit Testing

A software testing technique in which individual units of code—such as functions, methods, or classes—are tested in isolation to verify that they behave as expected. Unit tests are typically automated and run frequently during development to catch regressions early.

In Skip projects, unit testing is especially valuable because shared business logic written in Swift can be tested once and validated across both iOS and Android targets, increasing confidence in cross-platform correctness.

Related Terms: Integration Testing, Source Code, API

External Resources:

Integration Testing

A software testing practice where multiple components or modules are tested together to verify their interactions work correctly. Unlike unit testing, which tests components in isolation, integration testing validates that different parts of the system integrate properly. In Skip projects, integration tests can verify that iOS and Android implementations interact correctly with platform-specific APIs and services.

Related Terms: Unit Testing, XCTest, JUnit

External Resources:

Continuous Integration

A development practice where code changes are automatically built and tested frequently, typically on every commit to version control. Skip projects support CI through standard tools like GitHub Actions, using the Skip CLI to run parity tests on both iOS and Android in automated workflows.

Related Terms: Unit Testing, Parity Testing, Build System

External Resources:

Localization

The process of adapting an application to support multiple languages and regions. Skip supports localization through SwiftUI’s string catalog system (.xcstrings files), which are automatically processed for both iOS and Android. This enables a single translation source to work across both platforms.

Related Terms: SwiftUI, Skip Plugin, Platform Customization

Learn More: Localization Documentation

External Resources:

Comparison Terms

Flutter

An open-source UI framework developed by Google for building cross-platform applications from a single codebase written in Dart. Flutter renders its UI using a custom graphics engine rather than native platform UI frameworks.

Compared to Skip, Flutter has several notable disadvantages:

  • Non-native UI rendering: Flutter does not use SwiftUI or Jetpack Compose, which can lead to subtle differences in platform behavior, accessibility, and visual fidelity.
  • Additional runtime and engine: Flutter apps ship with a large runtime and rendering engine, increasing app size and memory usage compared to Skip’s native output.
  • Limited platform integration: Deep integration with platform-specific APIs often requires writing and maintaining platform “channels” in Swift/Objective-C and Kotlin/Java.
  • Language fragmentation: Flutter introduces Dart as a third language, whereas Skip allows iOS developers to remain entirely within the Swift ecosystem.

Skip, by contrast, produces genuinely native apps using platform-standard UI frameworks and tooling, with no custom rendering engine and no mandatory additional runtime.

Related Terms: Skip, Cross-Platform Development, Native Development, Runtime

External Resources:

React Native

A cross-platform mobile development framework created by Meta (Facebook) that allows developers to build apps using JavaScript or TypeScript with a React-based UI model.

Compared to Skip, React Native presents several drawbacks:

  • JavaScript bridge overhead: React Native relies on a bridge (or JSI-based runtime) between JavaScript and native code, which can introduce performance bottlenecks and debugging complexity.
  • Non-native development model: While React Native renders native views, application logic runs in a JavaScript runtime rather than using platform-native languages like Swift or Kotlin.
  • Toolchain fragmentation: Developers must manage Node.js, npm/yarn, Metro, and native build systems in parallel, increasing project complexity.
  • Weaker platform parity: Platform-specific behaviors, APIs, and UI conventions often require custom native modules and duplicated logic.

Skip avoids these issues by enabling development directly in Swift, integrating tightly with Xcode, producing native SwiftUI and Jetpack Compose UIs, and eliminating any JavaScript runtime or bridge.

Related Terms: Skip, Cross-Platform Development, Native Development, Runtime

External Resources:

Xamarin

A cross-platform development framework (now part of .NET MAUI) that allows building iOS and Android apps using C# and .NET. Unlike Skip, which uses native UI frameworks (SwiftUI and Jetpack Compose), Xamarin historically used either native UI bindings (Xamarin.iOS/Android) or a cross-platform UI abstraction (Xamarin.Forms, now .NET MAUI). Xamarin requires developers to learn C# rather than leveraging existing Swift knowledge.

Contrast With: Skip, Flutter, React Native

Related Terms: Cross-Platform Development

External Resources:

Cordova

A mobile application development framework (also known as Apache Cordova or PhoneGap) that enables building apps using HTML, CSS, and JavaScript running in a WebView. Unlike Skip, which produces genuinely native apps, Cordova apps are essentially web applications wrapped in a native container, resulting in non-native UI, performance limitations, and restricted access to platform capabilities.

Contrast With: Skip, Native Development

Related Terms: Cross-Platform Development, Runtime

External Resources:

Android and Apple Platforms

Developers familiar with iOS and other Apple platforms use a number of different tools and technologies, such as Swift, Xcode, and SwiftPM. When beginning to work with the Android platform, much of the terminology around Android development may seem alien at first. But in general, each component of iOS development has an analogue in the world of Android development.

Skip handles translating some of these elements between Apple platforms and Android. This table outlines the various Apple-specific terms and maps them to their equivalent Android term, as well as highlighting whether Skip helps in the translation process.

Platform Apple [Skip] Android
Language (modern) Swift1 → Kotlin2
Language (legacy) Objective-C3   Java4
UI Framework (modern) SwiftUI5 → Jetpack Compose6
UI Framework (legacy) UIKit7   Android Views8
Build Tool SwiftPM9 → Gradle10
IDE Xcode11   Android Studio12
Debugger lldb13   adb14
Unit Testing XCTest15 → JUnit16
UI Testing XCUITest17   Espresso18
Local Testing macOS19 → JVM w/ Robolectric20
Local App Runner iOS Simulator21 → Android Emulator22
Design Language HIG23   Material Design24

  1. Swift: https://www.swift.org ↩

  2. Kotlin: https://kotlinlang.org ↩

  3. Objective-C: https://developer.apple.com/​library/​archive/​documentation/​Cocoa/​Conceptual/​ObjectiveC/​Introduction/​introObjectiveC.html ↩

  4. Java: https://www.java.com/en/download/help/whatis_java.html ↩

  5. SwiftUI: https://developer.apple.com/xcode/swiftui/ ↩

  6. Jetpack Compose: https://developer.android.com/develop/ui/compose ↩

  7. UIKit: https://developer.apple.com/documentation/uikit ↩

  8. Android Views: https://developer.android.com/develop/ui/views/layout/declaring-layout ↩

  9. Swift Package Manager (SwiftPM): https://www.swift.org/documentation/package-manager/ ↩

  10. Gradle: https://gradle.org ↩

  11. Xcode: https://developer.apple.com/xcode/ ↩

  12. Android Studio: https://developer.android.com/studio ↩

  13. The LLDB Debugger: https://lldb.llvm.org ↩

  14. Android Debug Bridge (adb): https://developer.android.com/tools/adb ↩

  15. XCTest: https://developer.apple.com/documentation/xctest ↩

  16. JUnit: https://junit.org/junit4/ ↩

  17. User Interface Tests (XCUITest): https://developer.apple.com/documentation/xctest/user_interface_tests ↩

  18. Espresso: https://developer.android.com/training/testing/espresso/ ↩

  19. Cross-platform testing: https://developer.apple.com/documentation/xcode/creating-a-standalone-swift-package-with-xcode#Make-your-Swift-package-cross-platform-compatible ↩

  20. Robolectric: https://robolectric.org ↩

  21. iOS Simulator: https://developer.apple.com/documentation/xcode/running-your-app-in-simulator-or-on-a-device/ ↩

  22. Android Emulator: https://developer.android.com/studio/run/emulator ↩

  23. HIG: https://developer.apple.com/design/human-interface-guidelines/ ↩

  24. Material Design: https://m3.material.io/develop/android/jetpack-compose ↩