Is anyone able to debug Kotlin Native code, that is compiled for Apple iOS? (llvm/lldb) Does not matter if you use Android Studio or Xcode. Could you please share you setup & versions? I’m not able to make it work with Kotlin 1.8.0/1.7.4, Xcode 14.2.

x-posting here coz it is also relevant https://kotlinlang.slack.com/archives/C9JM6Q2UX/p1673858839828369

How can I encode rpath for shared libs when using gradle? I've been trying by passing -Wl,-R/path/to/dynamiclib/ with linkerOpts but no matter what when I try to run it on a different device (Linux) it doesn't seem to encode it so that I can export the binary with its own shared libs rather than having user installing them/building them themselves

Does Kotlin Native have a function that returns the Kotlin version as a String?

Does the Kotlin Native team have a methodology that they follow for measuring performance of Kotlin Native programs on non mobile platforms (Linux, Embedded Linux, Windows, Mac OS etc)?

Would anyone be able to explain to me when and what for would you use reinterpret function? The lack of documentations on it makes it slightly hard to grasp

Is there a way to check, that K/N tests will work with specific ios/macos/etc version. F.e. like NSURLSessionWebSocketTask supported only from ios 13, so I want to somehow receive a failure running tests with this code (f.e. by setting some min-ios flag somewhere) - is it possible?

I’m creating a cross-platform Kotlin Native library (for RocksDB). It’s working on Mac, but failing on Windows (and maybe also Linux?) I think because of a mismatched GCC version, as described in this issue: https://youtrack.jetbrains.com/issue/KT-51975

> Task :modules:rocksdb-interop:linkDebugTestMingwX64 FAILED
e: C:\Users\runneradmin\.konan\dependencies\llvm-11.1.0-windows-x64-essentials/bin/clang++ invocation reported errors
The C:\Users\runneradmin\.konan\dependencies\llvm-11.1.0-windows-x64-essentials/bin/clang++ command returned non-zero exit code: 1.
output:
lld-link: error: undefined symbol: std::__throw_bad_array_new_length()

(full log here) So I guess I need to figure out how to change the GCC version of the .a library. How can I find out what GCC version I should use for Kotlin 1.8? Is it the same as 1.7, 9.2.0?

Hello, I would like to port a library written in Kotlin JVM to Kotlin Native, I'm finding that the difference among the Standard Library in those two platforms requires me to change many things. I would like to know: • Will the Kotlin Stdlib wrap classes from the Java Stdlib (making them available to Native)? I.e.:

File

or

URL

• Is there any roadmap on the Native Stdlib classes to be implemented? If so, could you please share the link here? Thank you very much!

Are value classes that are exposed to Swift expected to be erased to

Any

? I searched YouTrack and didn’t see anything.

@JvmInline value class Url(val value: String) {
    init {
        require(value.isValidUrl()) {
            "$value is not valid URL."
        }
    }
}

Is it possible to force an iOS simulator to not run in headless mode during K/N iOS unit tests? I’m working with

CADisplayLink

and suspect that the headless mode does not tick the display link clock and therefore my tests never pass.

I’ve got an example directory with multiple Kotlin/Native files, each with a

fun main() {}

. Is there an easy way with Gradle to create executables for each file? So one Kotlin/Native Gradle project can produce multiple executables? I’ve tried creating a separate target for each file, but it’s really messy - with conflicting Configurations and overlapping sources…

Hi, I’m benchmarking Collections fast api and Collections stdlib api. The fast api implements random-access of List. It is implemented like this: ListUtils.kt I expected the fast api to be always fast. The fast api calculates size only once, and the stdlib api calculates size in every

next()

operation. (stdlib api transforms to Iterator) (

next()

implementation code: ArrayList.java) But sometimes the stdlib api comes out faster. At higher numbers, the stdlib api is faster in most cases. Why is this result occurring? I’ll post the benchmarking code I used in a thread.

Has anyone tried K/N with mold? I am thinking of giving it a try because linking is a large part of my incremental rebuild time https://github.com/rui314/mold

I wrote an article, I created an interpreter and compiler/VM for the Monkey Language in Kotlin https://marioarias.hashnode.dev/comparing-implementations-of-the-monkey-language-xi-going-native-and-js-with-kotlin

Using Kotlin 1.8.0, Ktor 2.2.2, SqlDelight 1.5.5. I am getting these warnings, which I am not sure how to fix:

w: Could not find "io.ktor:ktor-utils-cinterop-threadUtils" in [/Users/xxxxx/.konan/klib, /Users/xxxxx/.konan/kotlin-native-prebuilt-macos-x86_64-1.8.0/klib/common, /Users/xxxxx/.konan/kotlin-native-prebuilt-macos-x86_64-1.8.0/klib/platform/ios_x64]

w: Could not find "org.jetbrains.kotlin.native.platform.linux" in [/Users/xxxxx/.konan/klib, /Users/xxxxx/.konan/kotlin-native-prebuilt-macos-x86_64-1.8.0/klib/common, /Users/xxxxx/.konan/kotlin-native-prebuilt-macos-x86_64-1.8.0/klib/platform/ios_x64]

w: Could not find "co.touchlab:sqliter-driver-cinterop-sqlite3" in [/Users/xxxxx/.konan/klib, /Users/xxxxx/.konan/kotlin-native-prebuilt-macos-x86_64-1.8.0/klib/common, /Users/xxxxx/.konan/kotlin-native-prebuilt-macos-x86_64-1.8.0/klib/platform/ios_x64]

I’ve generated some cinterop code from a

.def

file, and I’ve written some helper functions to interact with the generated code, but it’s a little awkward because the helper functions and generated cinterop functions are named similarly, so they easy to confuse. Is it possible to either mark all code generated by cinterop as

internal

, or to add an

@OptIn

annotation to all generated code? I’ve got some code that can parse the generated

.klib

(see 🧵) and add an

@OptIn

, but I’m not sure how to write the

KlibModuleMetadata

back out into a

.klib

.

Hello, quick question, I’m creating a library using kotlin 1.7.21, Ktor 2.2.2 and some other dependencies. I need to create a fat framework and export dependencies to be used on ios, I’m using transitive export and embedding the bitcode and get these warnings:

w: Interop library /Users/user/.gradle/caches/modules-2/files-2.1/io.ktor/ktor-utils-iosarm64/2.2.2/f59a995d3f453c22d7fcfb1106a531277cf20b7e/ktor-utils-cinterop-threadUtils can't be exported with -Xexport-library
w: Interop library /Users/user/.gradle/caches/modules-2/files-2.1/org.jetbrains.kotlinx/atomicfu-iosarm64/0.18.5/8fe7737c1da3850eb99980cba0598ea2e8886be9/atomicfu-cinterop-interop can't be exported with -Xexport-library

I wasn’t getting these warnings on previous versions of kotlin or the dependencies, is there anything I could do to fix this?

Some memory management problems have been encountered while running a Kotlin Native program ( https://gitlab.com/embed-soft/lvgl-kt/samples/widget-showcase-sample ) targeting linuxArm32Hfp. All problems are connected with the use of LVGL's Roller widget ( https://docs.lvgl.io/8.3/widgets/core/roller.html ). When selecting an item repeatedly, and very quickly in the Roller for an extended period of time the program eventually crashes with the following message:

malloc(): memory corruption (fast)

In other cases when selecting an item repeatedly, at a very slow rate in the Roller, and tapping on the Back button afterwords the program crashes with the following message:

free(): invalid pointer

In many cases this problem occurs, but not always. None of the memory management problems occur with the linuxX64 version of the Kotlin Native program, even though it uses the same view that contains the Roller widget as the linuxArm32Hfp version of the program.

How would I set up Gradle to build the android native targets (arm64, armv7, x86) using kotlin-native rather than cmake?

Here is a theoretical question for the Kotlin team. Is it possible for the experimental Kotlin Native GC to cause memory management issues (eg seg faults) in a Kotlin Native program, and if so what issues might appear?

I’ve started using the

kotlinArtifacts

DSL to build our shared layer for iOS, and I was wondering if anybody has tips on how to improve incremental build performance? Right now it’s up to ~20sec per configuration/arch combo, so we’re pushing 40-50sec for an incremental debug iOS build. I also wonder if it would be feasible to have the individual framework tasks run in parallel… given that they don’t seem to have any dependency on each other?

If anyone is experiencing the same issue, I created a bug on youtrack: https://youtrack.jetbrains.com/issue/KTOR-5491/unable-to-export-internal-dependencies-on-native

I was under the impression that

String#encodeToByteArray

would add a null terminator, since it’s used by cstr, however, this does not appear to be the case. Should I manually add

0.toChar()

to each string I need to pass to C? I also noticed that ‘\0’ is not valid in Kotlin, saying it’s an illegal escape.

hot tip for editing

.def

files in IntelliJ: add

#language=c

before the

---

and IntelliJ will recognise it as C, and help out with highlighting, formatting, and auto completion

I noticed that this example of cinterop declares an inline method in C. How does the interop work with inline methods? Is there some level of inlining that can be done at the bitcode level?

👋 I wanted to see what the community thinks about enums in Kotlin. I had a discussion with a colleague and I learned that enums seem to be taking a back seat to sealed classes and interfaces. I was really surprised given that I come from a Swift background where enums are very important and widely used.

I'm trying to cinterop with a C library where the structs can have a different name for some targets (mostly Foo/Foo_). I figured I could commonize them myself using simple typedefs, but I'm running into what look like some limitations of the K/N compiler.

How do types like

NSArrayAsKList

work? Are we basically just reinterpreting the pointer to the

NSArray

as one of these instances on the C-side?

I'm using a custom entry point for my iOS and macOS native tests that runs the tests on a background thread and starts the main run loop, to allow testing callbacks that dispatch on the main thread (see YouTrack). This has worked great until updating to Kotlin 1.8.0. It's no longer calling the custom entry point function. Any idea why this code would no longer work for this in 1.8?

kotlin {
    ...
    targets.withType<KotlinNativeTarget> {
        if (konanTarget.family.isAppleFamily) {
            compilations["test"].kotlinOptions {
                freeCompilerArgs += listOf("-e", "testlauncher.mainBackground")
            }
        }
    }
}