• Stars
    star
    2,056
  • Rank 21,364 (Top 0.5 %)
  • Language
    Kotlin
  • License
    Apache License 2.0
  • Created over 4 years ago
  • Updated 3 months ago

Reviews

There are no reviews yet. Be the first to send feedback to the community and the maintainers!

Repository Details

KotlinX multiplatform date/time library

kotlinx-datetime

Kotlin Alpha JetBrains official project GitHub license Maven Central Kotlin KDoc link Slack channel TeamCity build

A multiplatform Kotlin library for working with date and time.

See Using in your projects for the instructions how to setup a dependency in your project.

Design overview

There are a few guiding principles in the design of kotlinx-datetime. First of all, it is pragmatic, focused on the most common problems developers face every day (pun intended) when working with dates and times. It is not all-encompassing and lacks some domain-specific utilities that special-purpose applications might need. We chose convenience over generality, so the API surface this library provides is as minimal as possible to meet the use-cases.

The library puts a clear boundary between the physical time of an instant and the local, time-zone dependent civil time, consisting of components such as year, month, etc that people use when talking about time. We intentionally avoid entities in the library that mix both together and could be misused. However, there are convenience operations that take, for example, a physical instant and perform a calendar-based adjustment (such as adding a month); all such operations explicitly take a time-zone information as parameter to clearly state that their result depends on the civil time-zone rules which are subject to change at any time.

The library is based on the ISO 8601 international standard, other ways to represent dates and times are out of its scope. Internationalization (such as locale-specific month and day names) is out the scope, too.

Types

The library provides a basic set of types for working with date and time:

  • Instant to represent a moment on the UTC-SLS time scale;
  • Clock to obtain the current instant;
  • LocalDateTime to represent date and time components without a reference to the particular time zone;
  • LocalDate to represent the components of date only;
  • LocalTime to represent the components of time only;
  • TimeZone and FixedOffsetTimeZone provide time zone information to convert between Instant and LocalDateTime;
  • Month and DayOfWeek enums;
  • DateTimePeriod to represent a difference between two instants decomposed into date and time units;
  • DatePeriod is a subclass of DateTimePeriod with zero time components, it represents a difference between two LocalDate values decomposed into date units.
  • DateTimeUnit provides a set of predefined date and time units to use in arithmetic operations on Instant and LocalDate.
  • UtcOffset represents the amount of time the local date/time at a particular time zone differs from the date/time at UTC.

Type use-cases

Here is some basic advice on how to choose which of the date-carrying types to use in what cases:

  • Use Instant to represent a timestamp of the event that had already happened in the past (like a timestamp of a log entry) or will definitely happen in a well-defined instant of time in the future not far away from now (like an order confirmation deadline in 1 hour from now).

  • Use LocalDateTime to represent a time of the event that is scheduled to happen in the far future at a certain local time (like a scheduled meeting in a few months from now). You'll have to keep track of the TimeZone of the scheduled event separately. Try to avoid converting future events to Instant in advance, because time-zone rules might change unexpectedly in the future. In this blog post, you can read more about why it's not always a good idea to use Instant everywhere.

    Also, use LocalDateTime to decode an Instant to its local date-time components for display and UIs.

  • Use LocalDate to represent the date of an event that does not have a specific time associated with it (like a birth date).

  • Use LocalTime to represent the time of an event that does not have a specific date associated with it.

Operations

With the above types you can get the following operations done.

Getting the current moment of time

The current moment of time can be captured with the Instant type. To obtain an Instant corresponding to the current moment of time, use now() function of the Clock interface:

val clock: Clock = ...
val currentMoment = clock.now()

An instance of Clock can be injected through the function/class parameters, or you can use its default implementation Clock.System that represents the system clock:

val currentMoment = Clock.System.now()

Converting an instant to local date and time components

An Instant is just a counter of high resolution time intervals since the beginning of time scale. To get human readable components from an Instant value, you need to convert it to the LocalDateTime type that represents date and time components without a reference to the particular time zone.

The TimeZone type provides the rules to convert instants from and to date/time components.

val currentMoment: Instant = Clock.System.now()
val datetimeInUtc: LocalDateTime = currentMoment.toLocalDateTime(TimeZone.UTC)
val datetimeInSystemZone: LocalDateTime = currentMoment.toLocalDateTime(TimeZone.currentSystemDefault())

A LocalDateTime instance exposes familiar components of the Gregorian calendar: year, month, dayOfMonth, hour, and so on up to nanosecond. The property dayOfWeek shows what weekday that date is, and dayOfYear shows the day number since the beginning of a year.

Additional time zones can be acquired by their string identifier with the TimeZone.of(id: String) function.

val tzBerlin = TimeZone.of("Europe/Berlin")
val datetimeInBerlin = currentMoment.toLocalDateTime(tzBerlin)

A LocalDateTime instance can be constructed from individual components:

val kotlinReleaseDateTime = LocalDateTime(2016, 2, 15, 16, 57, 0, 0)

An instant can be obtained from LocalDateTime by interpreting it as a time moment in a particular TimeZone:

val kotlinReleaseInstant = kotlinReleaseDateTime.toInstant(TimeZone.of("UTC+3"))

Getting local date components

A LocalDate represents a local date without time. You can obtain one from an Instant by converting it to LocalDateTime and taking its date property.

val now: Instant = Clock.System.now()
val today: LocalDate = now.toLocalDateTime(TimeZone.currentSystemDefault()).date
// or shorter
val today: LocalDate = Clock.System.todayIn(TimeZone.currentSystemDefault())

Note, that today's date really depends on the time zone in which you're observing the current moment.

LocalDate can be constructed from three components, year, month, and day:

val knownDate = LocalDate(2020, 2, 21)

Getting local time components

A LocalTime represents local time without date. You can obtain one from an Instant by converting it to LocalDateTime and taking its time property.

val now: Instant = Clock.System.now()
val thisTime: LocalTime = now.toLocalDateTime(TimeZone.currentSystemDefault()).time

A LocalTime can be constructed from four components, hour, minute, second and nanosecond:

val knownTime = LocalTime(hour = 23, minute = 59, second = 12)
val timeWithNanos = LocalTime(hour = 23, minute = 59, second = 12, nanosecond = 999)
val hourMinute = LocalTime(hour = 12, minute = 13)

Converting instant to and from unix time

An Instant can be converted to a number of milliseconds since the Unix/POSIX epoch with the toEpochMilliseconds() function. To convert back, use the companion object function Instant.fromEpochMilliseconds(Long).

Converting instant and local date/time to and from the ISO 8601 string

Instant, LocalDateTime, LocalDate and LocalTime provide shortcuts for parsing and formatting them using the extended ISO-8601 format. The toString() function is used to convert the value to a string in that format, and the parse function in companion object is used to parse a string representation back.

val instantNow = Clock.System.now()
instantNow.toString()  // returns something like 2015-12-31T12:30:00Z
val instantBefore = Instant.parse("2010-06-01T22:19:44.475Z")

LocalDateTime uses a similar format, but without Z UTC time zone designator in the end.

LocalDate uses a format with just year, month, and date components, e.g. 2010-06-01.

LocalTime uses a format with just hour, minute, second and (if non-zero) nanosecond components, e.g. 12:01:03.

LocalDateTime.parse("2010-06-01T22:19:44")
LocalDate.parse("2010-06-01")
LocalTime.parse("12:01:03")
LocalTime.parse("12:00:03.999")
LocalTime.parse("12:0:03.999") // fails with an IllegalArgumentException

Working with other string formats

When some data needs to be formatted in some format other than ISO-8601, one can define their own format or use some of the predefined ones:

// import kotlinx.datetime.format.*

val dateFormat = LocalDate.Format {
    monthNumber(padding = Padding.SPACE)
    char('/')
    dayOfMonth()
    char(' ')
    year()
}

val date = dateFormat.parse("12/24 2023")
println(date.format(LocalDate.Formats.ISO_BASIC)) // "20231224"

Using Unicode format strings (like yyyy-MM-dd)

Given a constant format string like the ones used by Java's DateTimeFormatter.ofPattern can be converted to Kotlin code using the following invocation:

// import kotlinx.datetime.format.*

println(DateTimeFormat.formatAsKotlinBuilderDsl(DateTimeComponents.Format {
    byUnicodePattern("uuuu-MM-dd'T'HH:mm:ss[.SSS]Z")
}))

// will print:
/*
date(LocalDate.Formats.ISO)
char('T')
hour()
char(':')
minute()
char(':')
second()
alternativeParsing({
}) {
    char('.')
    secondFraction(3)
}
offset(UtcOffset.Formats.FOUR_DIGITS)
 */

When your format string is not constant, with the FormatStringsInDatetimeFormats opt-in, you can use the format without converting it to Kotlin code beforehand:

val formatPattern = "yyyy-MM-dd'T'HH:mm:ss[.SSS]"

@OptIn(FormatStringsInDatetimeFormats::class)
val dateTimeFormat = LocalDateTime.Format {
    byUnicodePattern(formatPattern)
}

dateTimeFormat.parse("2023-12-24T23:59:59")

Parsing and formatting partial, compound or out-of-bounds data

Sometimes, the required string format doesn't fully correspond to any of the classes kotlinx-datetime provides. In these cases, DateTimeComponents, a collection of all date-time fields, can be used instead.

// import kotlinx.datetime.format.*

val yearMonth = DateTimeComponents.Format { year(); char('-'); monthNumber() }
    .parse("2024-01")
println(yearMonth.year)
println(yearMonth.monthNumber)

val dateTimeOffset = DateTimeComponents.Formats.ISO_DATE_TIME_OFFSET
    .parse("2023-01-07T23:16:15.53+02:00")
println(dateTimeOffset.toUtcOffset()) // +02:00
println(dateTimeOffset.toLocalDateTime()) // 2023-01-07T23:16:15.53

Occasionally, one can encounter strings where the values are slightly off: for example, 23:59:60, where 60 is an invalid value for the second. DateTimeComponents allows parsing such values as well and then mutating them before conversion.

val time = DateTimeComponents.Format { time(LocalTime.Formats.ISO) }
    .parse("23:59:60").apply {
        if (second == 60) second = 59
    }.toLocalTime()
println(time) // 23:59:59

Because DateTimeComponents is provided specifically for parsing and formatting, there is no way to construct it normally. If one needs to format partial, complex or out-of-bounds data, the format function allows building DateTimeComponents specifically for formatting it:

DateTimeComponents.Formats.RFC_1123.format {
    // the receiver of this lambda is DateTimeComponents
    setDate(LocalDate(2023, 1, 7))
    hour = 23
    minute = 59
    second = 60
    setOffset(UtcOffset(hours = 2))
} // Sat, 7 Jan 2023 23:59:60 +0200

Instant arithmetic

val now = Clock.System.now()
val instantInThePast: Instant = Instant.parse("2020-01-01T00:00:00Z")
val durationSinceThen: Duration = now - instantInThePast
val equidistantInstantInTheFuture: Instant = now + durationSinceThen

Duration is a type from the experimental kotlin.time package in the Kotlin standard library. This type holds the amount of time that can be represented in different time units: from nanoseconds to 24H days.

To get the calendar difference between two instants you can use the Instant.periodUntil(Instant, TimeZone) function.

val period: DateTimePeriod = instantInThePast.periodUntil(Clock.System.now(), TimeZone.UTC)

A DateTimePeriod represents a difference between two particular moments as a sum of calendar components, like "2 years, 3 months, 10 days, and 22 hours".

The difference can be calculated as an integer amount of specified date or time units:

val diffInMonths = instantInThePast.until(Clock.System.now(), DateTimeUnit.MONTH, TimeZone.UTC)

There are also shortcuts yearsUntil(...), monthsUntil(...), and daysUntil(...).

A particular amount of date/time units or a date/time period can be added to an Instant with the plus function:

val now = Clock.System.now()
val systemTZ = TimeZone.currentSystemDefault()
val tomorrow = now.plus(2, DateTimeUnit.DAY, systemTZ)
val threeYearsAndAMonthLater = now.plus(DateTimePeriod(years = 3, months = 1), systemTZ)

Note that plus and ...until operations require a TimeZone as a parameter because the calendar interval between two particular instants can be different, when calculated in different time zones.

Date arithmetic

Similar operations with date units are provided for LocalDate type:

  • LocalDate.plus(number, DateTimeUnit.DateBased)
  • LocalDate.plus(DatePeriod)
  • LocalDate.until(LocalDate, DateTimeUnit.DateBased) and the shortcuts yearsUntil, monthUntil, daysUntil
  • LocalDate.periodUntil(LocalDate): DatePeriod and LocalDate.minus(LocalDate): DatePeriod

Notice that, instead of the general DateTimeUnit and DateTimePeriod types, we're using their subtypes DateTimeUnit.DateBased and DatePeriod respectively. This allows preventing the situations when time components are being added to a date at compile time.

Date + time arithmetic

Arithmetic on LocalDateTime is intentionally omitted. The reason for this is that the presence of daylight saving time transitions (changing from standard time to daylight saving time and back) causes LocalDateTime arithmetic to be ill-defined. For example, consider time gaps (or, as dst tag wiki on Stack Overflow calls them, "spring forward" transitions), that is, ranges of date + time combinations that never occur in a given time zone due to clocks moving forward. If we allowed LocalDateTime arithmetic that ignored time zones, then it could result in LocalDateTime instances that are inside a time gap and are invalid in the implied time zone.

Therefore, the recommended way to use a LocalDateTime is to treat it as a representation of an Instant, perform all the required arithmetic on Instant values, and only convert to LocalDateTime when a human-readable representation is needed.

val timeZone = TimeZone.of("Europe/Berlin")
val localDateTime = LocalDateTime.parse("2021-03-27T02:16:20")
val instant = localDateTime.toInstant(timeZone)

val instantOneDayLater = instant.plus(1, DateTimeUnit.DAY, timeZone)
val localDateTimeOneDayLater = instantOneDayLater.toLocalDateTime(timeZone)
// 2021-03-28T03:16:20, as 02:16:20 that day is in a time gap

val instantTwoDaysLater = instant.plus(2, DateTimeUnit.DAY, timeZone)
val localDateTimeTwoDaysLater = instantTwoDaysLater.toLocalDateTime(timeZone)
// 2021-03-29T02:16:20

Implementation

The implementation of date/time types, such as Instant, LocalDateTime, TimeZone and so on, relies on:

Known/open issues, work TBD

  • Some kind of Clock interface is needed as a pluggable replacement for Instant.now().
  • Flexible locale-neutral parsing and formatting facilities are needed to support various date/time interchange formats that are used in practice (in particular, various RFCs).

Using in your projects

Note that the library is experimental, and the API is subject to change.

The library is published to Maven Central.

The library is compatible with the Kotlin Standard Library not lower than 1.9.0.

If you target Android devices running below API 26, you need to use Android Gradle plugin 4.0 or newer and enable core library desugaring.

Gradle

  • Add the Maven Central repository if it is not already there:
repositories {
    mavenCentral()
}
  • In multiplatform projects, add a dependency to the commonMain source set dependencies
kotlin {
    sourceSets {
        commonMain {
             dependencies {
                 implementation("org.jetbrains.kotlinx:kotlinx-datetime:0.6.0-RC.2")
             }
        }
    }
}
  • To use the library in a single-platform project, add a dependency to the dependencies block.
dependencies {
    implementation("org.jetbrains.kotlinx:kotlinx-datetime:0.6.0-RC.2")
}

Note about time zones in JS

By default, there's only one time zone available in Kotlin/JS: the SYSTEM time zone with a fixed offset.

If you want to use all time zones in Kotlin/JS platform, you need to add the following npm dependency:

kotlin {
    sourceSets {
        val jsMain by getting {
            dependencies {
                implementation(npm("@js-joda/timezone", "2.3.0"))
            }
        }
    }
}

and after that add the following initialization code in your project:

@JsModule("@js-joda/timezone")
@JsNonModule
external object JsJodaTimeZoneModule

private val jsJodaTz = JsJodaTimeZoneModule

Maven

Add a dependency to the <dependencies> element. Note that you need to use the platform-specific -jvm artifact in Maven.

<dependency>
    <groupId>org.jetbrains.kotlinx</groupId>
    <artifactId>kotlinx-datetime-jvm</artifactId>
    <version>0.6.0-RC.2</version>
</dependency>

Building

The project requires JDK 8 to build classes and to run tests. Gradle will try to find it among the installed JDKs or provision it automatically if it couldn't be found. The path to JDK 8 can be additionally specified with the environment variable JDK_8. For local builds, you can use a later version of JDK if you don't have that version installed. Specify the version of this JDK with the java.mainToolchainVersion Gradle property.

After that, the project can be opened in IDEA and built with Gradle.

For building and running benchmarks, see README.md

More Repositories

1

anko

Pleasant Android application development
Kotlin
15,927
star
2

kotlinx.coroutines

Library support for Kotlin coroutines
Kotlin
12,203
star
3

kotlinx.serialization

Kotlin multiplatform / multi-format serialization
Kotlin
4,951
star
4

dokka

API documentation engine for Kotlin
Kotlin
3,220
star
5

kotlin-examples

Various examples for Kotlin
3,177
star
6

KEEP

Kotlin Evolution and Enhancement Process
Markdown
3,109
star
7

kotlin-koans

Kotlin workshop
Kotlin
2,602
star
8

kmm-production-sample

This is an open-source, mobile, cross-platform application built with Kotlin Multiplatform Mobile. It's a simple RSS reader, and you can download it from the App Store and Google Play. It's been designed to demonstrate how KMM can be used in real production projects.
Kotlin
1,868
star
9

coroutines-examples

Examples for coroutines design in Kotlin
1,465
star
10

kotlindl

High-level Deep Learning Framework written in Kotlin and inspired by Keras
Kotlin
1,373
star
11

kotlin-fullstack-sample

Kotlin Full-stack Application Example
Kotlin
1,218
star
12

kotlinx-kover

Kotlin
1,185
star
13

kotlin-jupyter

Kotlin kernel for Jupyter/IPython
Kotlin
1,037
star
14

kotlinx.collections.immutable

Immutable persistent collections for Kotlin
Kotlin
1,005
star
15

kmm-basic-sample

Example of Kotlin multiplatform project
Kotlin
887
star
16

kotlinx-cli

Pure Kotlin implementation of a generic CLI parser.
Kotlin
886
star
17

kotlinx-io

Kotlin multiplatform I/O library
Kotlin
817
star
18

kotlinx-atomicfu

The idiomatic way to use atomic operations in Kotlin
Kotlin
716
star
19

dataframe

Structured data processing in Kotlin
Kotlin
688
star
20

binary-compatibility-validator

Public API management tool
Kotlin
657
star
21

kotlinconf-spinner

Kotlin
603
star
22

workshop

JetBrains Kotlin Workshop Material
Kotlin
594
star
23

kotlin-interactive-shell

Kotlin Language Interactive Shell
Java
574
star
24

kotlin-frontend-plugin

Gradle Kotlin (http://kotlinlang.org) plugin for frontend development
Kotlin
570
star
25

multik

Kotlin
550
star
26

dukat

Converter of <any kind of declarations> to Kotlin external declarations
Kotlin
535
star
27

kdoctor

Environment analysis tool
Kotlin
509
star
28

kotlin-spark-api

This projects gives Kotlin bindings and several extensions for Apache Spark. We are looking to have this as a part of Apache Spark 3.x
Kotlin
435
star
29

kotlin-by-example

The sources of Kotlin by Example.
396
star
30

kotlin-wasm-examples

Examples with Kotlin/Wasm
Kotlin
395
star
31

kotlinx-benchmark

Kotlin multiplatform benchmarking toolkit
Kotlin
387
star
32

kotlin-spec

Kotlin Language Specification:
Kotlin
358
star
33

kotlin-in-action

Code samples from the "Kotlin in Action" book
Kotlin
343
star
34

ts2kt

ts2kt is officially deprecated, please use https://github.com/Kotlin/dukat instead. // Converter of TypeScript definition files to Kotlin external declarations
Kotlin
320
star
35

kotlin-numpy

Kotlin bindings for NumPy
Kotlin
312
star
36

kotlin-style-guide

Work-in-progress notes for the Kotlin style guide
289
star
37

kotlinx-knit

Kotlin source code documentation management tool
Kotlin
287
star
38

anko-example

A small application built with Anko DSL
Kotlin
285
star
39

full-stack-web-jetbrains-night-sample

Full-stack demo application written with Kotlin MPP
Kotlin
271
star
40

kotlin-script-examples

Examples of Kotlin Scripts and usages of the Kotlin Scripting API
Kotlin
262
star
41

kotlinx-nodejs

Kotlin external declarations for using the Node.js API from Kotlin code targeting JavaScript
Kotlin
212
star
42

kotlin-eclipse

Kotlin Plugin for Eclipse
Kotlin
185
star
43

kotlinx.reflect.lite

Lightweight library allowing to introspect basic stuff about Kotlin symbols
Kotlin
150
star
44

api-guidelines

Best practices to consider when writing an API for your library
142
star
45

kotlin-benchmarks

This is the project to verify and investigate performance issues in Kotlin and standard library.
Kotlin
136
star
46

kotlin-libs-publisher

Gradle plugin for publishing of Kotlin libs
Kotlin
114
star
47

kandy

Kotlin plotting library.
Kotlin
107
star
48

KMP-App-Template

Kotlin Multiplatform app template with shared UI
Kotlin
100
star
49

kotlinx-browser

Kotlin browser API
Kotlin
100
star
50

kotlindl-app-sample

This repo demonstrates how to use KotlinDL for neural network inference on Android devices.
Kotlin
96
star
51

kotlin-koans-edu

Kotlin Koans for Educational Plugin and play.kotl.in
Kotlin
93
star
52

grammar-tools

Tokenization and parsing Kotlin code using the ANTLR Kotlin grammar
Kotlin
83
star
53

kmm-integration-sample

Kotlin
76
star
54

kmm-with-cocoapods-sample

This project represents the case when Cocoapods dependencies are added in Kotlin and there is no existing Xcode project
Kotlin
57
star
55

kotlin-koans-edu-obsolete

Obsolete: check https://github.com/Kotlin/kotlin-koans-edu for the latest version.
Kotlin
55
star
56

kotlin-native-calculator-sample

55
star
57

kotlinx.support

Extension and top-level functions to use JDK7/JDK8 features in Kotlin 1.0
Kotlin
54
star
58

js-externals

External declarations for Kotlin/JS
53
star
59

coroutines-workshop

Materials for a full-day workshop on Kotlin Coroutines
Kotlin
42
star
60

kotlin-playground-wp-plugin

WordPress plugin which allows to embed interactive Kotlin playground to any post via [kotlin] shortcode
PHP
35
star
61

io2019-serverside-demo

E2E Sample
Kotlin
31
star
62

kotlin-jupyter-libraries

Library descriptors for Kotlin kernel for Jupyter
23
star
63

kmm-with-cocoapods-multitarget-xcode-sample

This project is intended to demonstrate how to connect Kotlin library to Xcode project with several targets: iOS, macOS, tvOS, watchOS
Swift
23
star
64

KMP-App-Template-Native

Kotlin Multiplatform app template with native UI
Kotlin
22
star
65

kmp-native-wizard

A mostly-empty template to get started creating a Kotlin/Native project.
Kotlin
22
star
66

xcode-compat

AppCode helper for Kotlin/Native and Xcode
Kotlin
21
star
67

kotlin-in-action-2e

Code samples for the second edition of "Kotlin in Action".
Kotlin
20
star
68

kotlinx.dom

Kotlin
17
star
69

dokka-plugin-template

Dokka plugin quickstart template with pre-configured dependencies and publishing
Kotlin
13
star
70

kotlin-wasm-benchmarks

Kotlin Multiplatform Collection of Benchmarks focused on Kotlin/Wasm performance
Kotlin
12
star
71

kotlinx.team.infra

Kotlin
10
star
72

multiplatform-library-template

Kotlin
10
star
73

kotlin-js-inspection-pack-plugin

Adds useful inspections, intentions, and quick-fixes for working with Kotlin/JS projects.
Kotlin
10
star
74

kotlin-wasm-compose-template

A template repository for Compose Multiplatform with Kotlin/Wasm target
Kotlin
9
star
75

obsolete-kotlin-swing

Experimental library providing some helper functions and extensions for creating Swing user interfaces.
Kotlin
8
star
76

kotlin-in-action-2e-jkid

Sample project accompanying the second edition of "Kotlin in Action". JSON serialization/deserialization library for Kotlin data classes
Kotlin
8
star
77

obsolete-kotlin-jdbc

Experimental library providing some helper functions and extensions for working with JDBC in Kotlin.
Kotlin
7
star
78

kotlin-grammar-gpl2

Kotlin grammar ANTLR sources (under GPLv2)
ANTLR
6
star
79

community-project-gradle-plugin

Kotlin
6
star
80

website-grammar-generator

Kotlin ANTLR grammar converter to XML for the Kotlin website or text file
Kotlin
6
star
81

kotlin-spark-shell

Kotlin Language support for Apache Spark
Kotlin
5
star
82

web-site-samples

Examples repository for kotlinlang.org
4
star
83

kotlin-wasm-browser-template

A template repository for Kotlin/Wasm on browser
HTML
4
star
84

kotlin-cocoapods-spec

Ruby
3
star
85

kotlin-build-report-sample

Kotlin
3
star
86

spec-tests-relinking-recommender

Tool for relinking recommendation of the Kotlin compiler spec tests, that are inconsistent to the latest Kotlin specification
Python
1
star
87

kmm-with-cocoapods-xcode-two-kotlin-libraries-sample

This project is intended to demonstrate the connection of two Kotlin libraries to existing Xcode project through Cocoapods
Kotlin
1
star
88

kotlin-wasm-wasi-template

A template repository for Kotlin/Wasm with WASI
Kotlin
1
star