Kotlin to exe intellij idea

Tutorial: Create your first Kotlin application

You can choose to build your app with one of the four supported build tools.

The instructions are provided for Gradle and Kotlin as DSL. To learn how to accomplish the same using other build tools, use the Build tool switcher at the top of the page.

The instructions are provided for Gradle and Groovy as DSL. To learn how to accomplish the same using other build tools, use the Build tool switcher at the top of the page.

The instructions are provided for Maven. To learn how to accomplish the same using other build tools, use the Build tool switcher at the top of the page.

The instructions are provided for IntelliJ IDEA build tool. To learn how to accomplish the same using other build tools, use the Build tool switcher at the top of the page.

Create a new project

In IntelliJ IDEA, a project helps you organize everything that is necessary for developing your application in a single unit.

1. On the Welcome screen, click New Project . Otherwise, from the main menu, select File | New | Project .
2. From the list on the left, select New Project .
3. Name your new project and change its location if necessary.
4. Select the Create Git repository checkbox to place the new project under version control. You will be able to do it later at any time.
5. From the Language list, select Kotlin .
6. Select the Gradle IntelliJ Maven build system.
7. Choose the Groovy Kotlin language for the build script.
8. From the JDK list, select the JDK that you want to use in your project. If the JDK is installed on your computer, but not defined in the IDE, select Add JDK and specify the path to the JDK home directory. If you don’t have the necessary JDK on your computer, select Download JDK .
9. Enable the Add sample code option to create a file with a sample Hello World! application.
10. Click Create .

Write code

Source code is the central part of your project. In source code, you define what your application will be doing. Real projects may be very big and contain hundreds of thousands lines of code. In this tutorial we are going to start with a simple three-line application that asks the user their name and greets them.

1. In the Project tool window on the left, expand the node named after your project and open the /src/main/kotlin/main.kt file.
2. The file only contains the main() function with print statements. This function is the entry point of your program. Replace the Hello World! sample with the following code snippet:

Now that the program asks users for input, provide them with a way to give it. Also, the program needs to store the input somewhere. Move the caret to the next line and type val name = rl . IntelliJ IDEA will suggest to convert rl to readln() . Hit Enter to accept the suggestion.

Move the caret to the next line, type sout , and hit Enter . This feature is called live templates. To learn about other available live templates or configure your own, go to Settings | Editor | Live Templates | Kotlin .

Place the caret inside the parentheses of the println statement and type «Hello, $» . Press Ctrl+Space to invoke code completion and select the name variable from the list.

Now we have a working code that reads the username from the console, stores it in a read-only variable, and outputs a greeting using the stored value.

Run code from IntelliJ IDEA

Let’s verify that our program works as expected.

IntelliJ IDEA allows you to run applications right from the editor. You don’t need to worry about the technical aspect because IntelliJ IDEA automatically does all the necessary preparations behind the scenes.

• Click the Run icon in the gutter and select Run ‘MainKt’ or press Ctrl+Shift+F10 .

When the program has started, the Run tool window opens, where you can review the output and interact with the program.

Package as JAR

At this point, you know how to write code and run it from IntelliJ IDEA, which is convenient in the development process. However, this is not the way the users are supposed to run applications. For the users to run it on their computers, we are going to build and package the application as a jar file.

JAR is a file format for distributing applications as a single file.

Building the app includes the following steps:

• Compiling the sources – in this step, you translate the code you’ve just written into JVM bytecode. The compiled sources have the .class extension.
• Bundling the dependencies – for the application to function correctly, we need to provide the libraries it depends on. The only required library for this project is Kotlin runtime, but still, it needs to be included. Otherwise, the users will have to provide it themselves every time they run the program, which is not very convenient.

Both the compiled sources and the dependencies end up in the resulting .jar file. The result of the build process such as .jar file is called an artifact .

The instructions are provided for Gradle and Kotlin as DSL. To learn how to accomplish the same using other build tools, use the Build tool switcher at the top of the page.

The instructions are provided for Gradle and Groovy as DSL. To learn how to accomplish the same using other build tools, use the Build tool switcher at the top of the page.

The instructions are provided for Maven. To learn how to accomplish the same using other build tools, use the Build tool switcher at the top of the page.

The instructions are provided for IntelliJ IDEA build tool. To learn how to accomplish the same using other build tools, use the Build tool switcher at the top of the page.

1. Open the build.gradle.kts build.gradle script. The build script is the file that tells the build tool how exactly to build the project. The build script is the file that tells the build tool how exactly to build the project. It is written in Kotlin just like the source code of your program.
2. In the build script, add the following task definition:

tasks.jar < manifest < attributes["Main-Class"] = "MainKt" >configurations[«compileClasspath»].forEach < file: File ->from(zipTree(file.absoluteFile)) > duplicatesStrategy = DuplicatesStrategy.INCLUDE >

The manifest section specifies the entry point of the program, and the rest tells the build tool to recursively scan the project for dependencies and include them in the build.

The resulting JAR appears in the build/libs directory.

1. Go to File | Project Structure Ctrl+Alt+Shift+S and open the Artifacts tab.
2. Click Add , then JAR , then From modules with dependencies .
3. In the Main Class field, click the Browse button, and select Main.kt as the main class. Specify the absolute path to /src/main/resources as the manifest directory, for example: /Users/me.user/IdeaProjects/greeting/src/main/resources
4. Click OK in the Create JAR from Modules dialog.
5. Click OK in the Project Structure dialog.
6. From the main menu, select Build | Build Artifacts , then click Build .

The resulting JAR appears in the out/artifacts directory.

Run the JAR

Run from IntelliJ IDEA

• In the Project tool window, right-click the .jar file and select Run . This is a quick way to run a .jar file from IntelliJ IDEA.

Run from CLI

• Open the terminal and from the containing folder, run: java -jar consoleApp.jar java -jar greeting.jar java -jar greeting-1.0-SNAPSHOT.jar This is how the users of your application would run it. JDK 1.8 or later is required to run the .jar

Источник

Think. Do. Learn.

How to create a desktop app using Kotlin and Compose Desktop

Let’s quickly and simply create a desktop app using Kotlin and Compose for Desktop.

1. In IntelliJ IDEA, install the Compose Multiplatform plugin (Settings > Plugins, then search for and install ‘Compose Multiplatform IDE Support’ by JetBrains). Restart IJ to load the plugin.
2. In IntelliJ IDEA, click ‘New Project’, select ‘Kotlin’ on the left, then select ‘Compose Desktop Application’, then click ‘Next’
3. Leave the defaults alone, then click ‘Finish’
4. After the project loads, run ‘Main.kt’ to ensure that you have everything working. It should look similar to the following picture:
5. Let’s add an app bar. Replace the code in Main.kt with the following:

 import androidx.compose.material.MaterialTheme import androidx.compose.desktop.ui.tooling.preview.Preview import androidx.compose.material.Button import androidx.compose.material.Icon import androidx.compose.material.IconButton import androidx.compose.material.Scaffold import androidx.compose.material.Text import androidx.compose.material.TopAppBar import androidx.compose.material.icons.Icons import androidx.compose.material.icons.filled.Add import androidx.compose.material.icons.filled.Favorite import androidx.compose.material.icons.filled.Menu import androidx.compose.runtime.Composable import androidx.compose.runtime.getValue import androidx.compose.runtime.mutableStateOf import androidx.compose.runtime.remember import androidx.compose.runtime.setValue import androidx.compose.ui.window.Window import androidx.compose.ui.window.application @Composable @Preview fun App() < var text by remember < mutableStateOf("Hello, World!") >MaterialTheme < Scaffold( topBar = < MyTopAppBar() >) < Button(onClick = < text = "Hello, Desktop!" >) < Text(text) >> > > fun main() = application < Window(onCloseRequest = ::exitApplication) < App() >> @Composable fun MyTopAppBar() < TopAppBar( title = < Text("Simple TopAppBar") >, navigationIcon = < IconButton(onClick = < /* doSomething() */ >) < Icon(Icons.Filled.Menu, contentDescription = null) >>, actions = < // RowScope here, so these icons will be placed horizontally IconButton(onClick = < /* doSomething() */ >) < Icon(Icons.Filled.Favorite, contentDescription = "Localized description") >IconButton(onClick = < /* doSomething() */ >) < Icon(Icons.Filled.Add, contentDescription = "Localized description") >> ) > 

To learn more about the available GUIs and views, see https://developer.android.com/jetpack/compose/layouts

Now, let’s create the executable file and run the app on the desktop!

1. In the terminal, at the root of the project, run ./gradlew createDistributable
2. Confirm that your runnable app is in ‘build/compose/binaries/main/app/’
3. If you are on Windows, then run the EXE (or MSI) file. The other supported targets/platforms are macOS (.dmg, .pkg) and Linux (.deb, .rpm)

Congrats for making your first Kotlin desktop app! Feel free to reach out for any questions, comments, or support. 🙂

Источник

Начните работу с Kotlin/JVM

В этом руководстве показано,как использовать IntelliJ IDEA для создания консольного приложения.

Для начала сначала загрузите и установите последнюю версию IntelliJ IDEA .

Создать проект

1. В IntelliJ IDEA выберите Файл | Новый | Проект .
2. На панели слева выберите New Project .
3. Назовите новый проект и при необходимости измените его местоположение. Установите флажок «Создать репозиторий Git» , чтобы поместить новый проект под контроль версий. Вы сможете сделать это позже в любое время.
4. В списке языков выберите Kotlin .
5. Выберите систему сборки IntelliJ . Это собственный конструктор, который не требует загрузки дополнительных артефактов. Если вы хотите создать более сложный проект, требующий дополнительной настройки, выберите Maven или Gradle. Для Gradle выберите язык скрипта сборки: Kotlin или Groovy.
6. В списке JDK выберите JDK , который вы хотите использовать в своем проекте.
   • Если JDK установлен на вашем компьютере, но не определен в IDE, выберите Добавить JDK и укажите путь к домашнему каталогу JDK.
   • Если на вашем компьютере нет необходимого JDK, выберите Загрузить JDK .
7. Включите параметр «Добавить пример кода» , чтобы создать файл с образцом «Hello World!» заявление.
8. Click Create.

Создайте приложение

1. Если вы выбрали систему сборки Gradle, в вашем проекте есть файл сценария сборки build.gradle(.kts) .Он включает плагин kotlin(«jvm») и зависимости, необходимые для вашего консольного приложения. Убедитесь, что вы используете последнюю версию плагина:

plugins < kotlin("jvm") version "1.7.20" application >

fun main() < println("What's your name?") val name = readln() println("Hello, $name!") >