Kotlin/Native is an LLVM backend for the Kotlin compiler. It consists of a machine code generation facility using the LLVM toolchain and a native runtime implementation.
Kotlin/Native is primarily designed to allow compilation for platforms where virtual machines are not desirable or possible (such as iOS or embedded targets), or where the developer needs to produce a reasonably-sized self-contained binary that doesn't require an additional execution runtime.
The Kotlin/Native compiler produces mostly portable (modulo pointer size and target triplet) LLVM bitcode, and as such can easily support any platform, as long as there's an LLVM code generator for the platform. However, as actually producing native code requires a platform linker and some basic runtime shipped along with the translator, we only support a subset of all possible target platforms. Currently Kotlin/Native is being shipped and tested with support for the following platforms:
-target macos_x64|macos_arm64, default on macOS hosts)-target linux_x64, default on Linux hosts, hosted on Linux, Windows and macOS).-target mingw_x64, default on Windows hosts, hosted on Linux, Windows and macOS).-target mingw_x86), hosted on Linux, Windows and macOS.-target ios_arm32|ios_arm64|ios_x64|ios_simulator_arm64), hosted on macOS.-target tvos_arm64|tvos_x64|tvos_simulator_arm64), hosted on macOS.-target watchos_arm32|watchos_arm64|watchos_x86|watchos_x64|watchos_simulator_arm64), hosted on macOS.-target raspberrypi), hosted on Linux, Windows and macOS-target mips), hosted on Linux.-target mipsel), hosted on Linux.-target android_x86|android_x64|android_arm32|android_arm64) targets, hosted on Linux, macOS and Windows.-target wasm32) target, hosted on Linux, Windows or macOS. Webassembly support is experimental and could be discontinued in further releases.-target zephyr_stm32f4_disco) is available on macOS, Linux and Windows hosts. “Experimental” here also means that support for this target might be broken at the moment, and UX might be disappointing.To run Kotlin/Native compiler JDK 8 or later (JDK) for the host platform has to be installed. Produced programs are fully self-sufficient and do not need JVM or other runtime.
On macOS it also requires Xcode 12.5 or newer to be installed.
The language and library version supported by this release match Kotlin 1.6. However, there are certain limitations, see section Known Limitations.
Currently Kotlin/Native uses reference counting based memory management scheme with a cycle collection algorithm. Multiple threads could be used, but objects must be explicitly transferred between threads, and same object couldn't be accessed by two threads concurrently unless it is frozen. See the relevant documentation. We are going to lift these multithreading restrictions, which involves implementing a new memory manager. More details are available in the corresponding roadmap item, KT-49520.
Kotlin/Native provides efficient bidirectional interoperability with C and Objective-C. See the samples, the documentation, and the tutorials.
The most complete experience with Kotlin/Native can be achieved by using Gradle, IntelliJ IDEA or Android Studio with KMM plugin if you target iOS.
If you are interested in using Kotlin/Native for iOS, then Kotlin Multiplatform Mobile portal might also be useful for you.
Command line compiler is also available.
More information can be found in the overviews of Kotlin/Native and Kotlin Multiplatform.
*** DO NOT USE THIS PREVIEW RELEASE FOR ANY PERFORMANCE ANALYSIS ***
This beta version of Kotlin/Native technology is not yet tuned for benchmarking and competitive analysis of any kind.
The standard library in Kotlin/Native is known match common standard library in other Kotlin variants. Note, that standard Java APIs, such as java.math.BigDecimal or java.io is not available in current Kotlin standard library, but using C interoperability, one could call similar APIs from the POSIX library, see this sample. Also Kotlin/Native standard library contains certain native-specific extensions, mostly around memory management and concurrency.
Full reflection is not implemented, but class can be referenced and its name could be retrieved. Notice that property delegation (including lazy properties) does work.
Only 64-bit Windows is currently supported as compilation host, both 32-bit and 64-bit Windows could be targets.
Kotlin/Native supports source-level debugging on produced executables with lldb debugger. Produce your binary with debugging information by specifying -g Kotlin/Native compiler switch. See documentation for further information.