Kotlin Native Performance

How To Work With Kotlin Native

How To Work With Kotlin Native?

Kotlin is a programming language that has become the standard for developing Android apps in recent times. And what, then, is Kotlin/Native?

Because of Kotlin/Native, code written in Kotlin may be compiled into native binaries that don’t require a virtual machine. The foundation of Kotlin/Native is the LLVM compiler. Multi-platform development is feasible with Kotlin/Native. Kotlin/Native, for instance, can be used for iOS development. In this article, we’ll explore Kotlin/Native configuration in detail. 

Building an Environment for Kotlin and Native with a CLI Compiler

Here, we will use the command-line compiler to set up Kotlin/Native.

Basic requirements

Kotlin/Native, a compiler 

Windows users should have some familiarity with command prompts and terminals.

Compiling Kotlin using Native Libraries

It is necessary to obtain the Kotlin/Native compiler first. All Windows, Mac, and Linux users can get it. Visit this link to download the compiler from GitHub. Obtain the version that is compatible with your computer. For instance, the kotlin-native-macos-x86 64 asset should be downloaded if your macOS device has an Intel-based processor. As soon as the compressed file has finished downloading, you should unpack its contents into a new directory. 

Include Kotlin/Native in the Environment Variables

Take note of where the “bin” folder is located in the archive’s extracted content. The next step is to set the path as an environment variable on your computer. In different OSes, this is done in different ways. However, “how to create an environment variable” for your OS should return results that will be helpful. Here, we will use a Mac running macOS and a zsh-based terminal as an example. If you’re running the same OS, follow these steps.

Start up the command prompt and type in these instructions:

sudo nano ~/.zshenv


Running the preceding command will launch the nano text editor and load the.zshenv configuration file. Then, on a new line, include the following code to specify the location of bin:

export PATH=$PATH:{full/path/to/kotlin/native/compiler/bin/}

Then, on a new line, include the following code to specify the location of bin:

export PATH=$PATH:{full/path/to/kotlin/native/compiler/bin/} Sh

For your own machine, replace “full/path/to/kotlin/native/compiler/bin/” with the correct path to the file.\(Exclude the brackets)

Once you’ve finished editing an environment variable, you must restart the terminal before your changes will take effect.

Coding in Kotlin

All necessary settings for the current environment have been made. So now we can put our setup to the test by writing some Kotlin code. For this phase, we’ll choose nano as our coding editor of choice. However, any text editor will do.

First, you’ll need to make a new folder where the Kotlin file can live. The next step is to set your current directory as the new one. In order to move to a new directory, type the following command into the terminal:

cd {/path/to/folder}


When you’re ready, open nano and type the following command to make a new Kotlin file:

nano hello.kt Sh

The following Kotlin code needs to be pasted into nano

fun main() { qprintln(“Hello Kotlin!”)


Then you may save your work by pressing ctrl + x and clicking the save button.

Initiate the Program

Okay, it’s time to put our code to the test. Launch the command prompt, change the current directory to where you saved the code, and then type in the following:

kotlinc-native hello.kt -o hello

A successful build means you’ve executed your first Kotlin/Native program.

Advantages of Using a Kotlin/ Native Command-Line Compiler

  • Absolutely no unusual IDE is needed. Any text editor will do for the initial stages.
  • Perfect for quick, low-risk experiments. This is ideal for executing a minimal bit of Kotlin/Native code because to the low prerequisites and fewer files.


  • Not sufficient for a big job. Because of its limitations, this technique should be used primarily for testing very little software systems.
  • At first, you’ll need to manually install the compiler by downloading it and setting its location in an environment variable. This is not user-friendly and could increase development time.

Using the IntelliJ IDE to Make a Kotlin/Native Project

Let’s start a new project in IntelliJ now.

Basic requirements

The IntelliJ IDE is the only pre-requisite for this project. IntelliJ is available for free download on this page.


Each of the below processes was carried out in IntelliJ 2021.2.1. If you’re using an older or newer version of IntelliJ, the user interface may look a little bit different. While there may be some differences, it shouldn’t be a problem.

  1. Start a New Project

Make a new project in Kotlin/Native to begin. Simply open IntelliJ and go to File > New > Project. There will soon be a fresh opportunity to work on projects.

Making a brand-new thing

Choose Kotlin on the left and Native Application in the center. Then, after giving the undertaking a title, you may proceed by clicking Next. After the previous screen, the next one should load automatically.

Choosing native system

When making a selection, choose the appropriate native Target for your system, and then hit the Finish button. Then, sit tight as the IDE creates your new project. Depending on the speed of your internet connection, this first set up could take a while.

  1. Writing Kotlin Code

First, let’s discuss how we’ll organize the files for this new endeavor. The src folder contains your Kotlin source code. Main.kt (found in “project/src/nativeMain/kotlin”) is the main entry point for our Kotlin/Native program.

entry point by default

The following code should be pasted into the Main.kt file and replaced with its whole contents.

fun main() { println(“Hello Kotlin!”)


A simple program that displays “Hello Kotlin” is shown above.

  1. Run Programs

By clicking the green play button next to the main method in Main.kt, you can quickly run the code and see its results. The program’s results will be displayed in IntelliJ’s Run window.

The tests folder in your Kotlin/Native app’s root directory is where you should create any automated tests you plan on running (for example, nativeTest).

  1. Test Automation

In the tests directory, you may create a subset for your app’s automated tests to run on Kotlin and Native (for example, nativeTest).

Advantages of setting Kotlin/Native Pros Using IntelliJ

  • Unlike the command line approach, this one needs no additional configuration on the user’s part. Creating a new project is as simple as opening the IDE and clicking through the onscreen prompts.
  • Auto-complete code recommendations, lint warning, and other IntelliJ-only IDE features can help developers save time and avoid mistakes.
  • Useful for creating elaborate plans. In order to facilitate development, files have been organized.


  • Which IDE you use makes a difference (IntelliJ). Installing IntelliJ is a requirement for developers.


It is now feasible to extend the Kotlin programming language’s capabilities beyond Android with the help of the Kotlin/Native library. Kotlin/Native, for instance, enables the development of native applications that are compatible with both macOS and iOS.

Leave a Comment