How do you clear a console screen?

Are there any guides on porting native kotlin to Android and vise verse, aka create a multi-platform application that targets desktop and Android? And is it only possible in the Intellej IDE?

I see that K/N converts nested structs themselves into Vals (immutable) for example here:

@kotlinx.cinterop.internal.CStruct public final class Camera2D public constructor(rawPtr: kotlinx.cinterop.NativePtr /* = kotlin.native.internal.NativePtr */) : kotlinx.cinterop.CStructVar {
    @kotlinx.cinterop.internal.CStruct.VarType @kotlin.Deprecated public companion object : kotlinx.cinterop.CStructVar.Type {
    }

    public final val offset: kaylib.Vector2 /* compiled code */

    public final var rotation: kotlin.Float /* compiled code */

    public final val target: kaylib.Vector2 /* compiled code */

    public final var zoom: kotlin.Float /* compiled code */
}

offset and target are both vals and I can't simply modify them once alloc'ed, but I can modify their values which are .x and .y which isn't that much of a problem, but it does cause a little bit of dull modifications of .x and .y one by one (and I'm very sure its for a good reason) There is no other way to mitigate this at all by somehow being able to mutate offset or target as one, rather than mutating its members?

I have a C function that's being called from Kotlin that prints to stdout.

static inline void io_uring_prep_rw(int op, struct io_uring_sqe *sqe, int fd,
				    const void *addr, unsigned len,
				    __u64 offset)
{
    fprintf(stdout, "SQE pointer %p", sqe);

For the life of me I cannot get this to be printed to stdout and I don't know why. Calls to Kotlin's

println

are working fine so I suspect there's something funky going on in kotlin native modules. Does anyone have any idea why this might be happening?

I just ran into a use case where I needed to compare two pointers, and I noticed that there’s nothing like the below in kotlinx.cinterop. Would this be worth adding to the cinterop library?

operator fun COpaquePointer?.compareTo(other: COpaquePointer?): Int {
    return (toLong() - other.toLong()).toInt()
}

Happy new year! I want to make a Kotlin Native app that will capture some text messages and then forward them to a server. The messages need to be ordered, and I’m targeting Windows/Mac/Linux. Can anyone recommend a persistent file-based FIFO queue, or advice on implementing one? I’m trying with SQLDelight, but I wondered if there are alternatives.

Is there any way for cinterop to be generated as internal? I wouldn't want C library symbols leaking out from my gradle module.

Hello all, I've been hacking on GTK bindings for Kotlin Native this holiday period as a way to deep-dive in both KN and GTK/GNOME and it has been a great experience. One of the things I'm currently looking at is how I can include my KDoc documentation in the published libraries using Gradle (publish to mavenLocal for now). Is this supported?

Is it possible to call Kotlin code from a callback on the C side (especially in a concurrent environment), and if so what are the key things to watch out for? The cinterop tool has a severe bug ( https://youtrack.jetbrains.com/issue/KT-55030 ) where it doesn't support C structs/unions that contain bit fields. I am trying to work around the issue which is proving to be very difficult to deal with.

Is it possible to use a pure Swift Library for Kotlin Native using cinterop? I know that as is, that is that possible, but is there any way or work around that I could do to make this work?

Hello I am getting some random crashes usually sometime after the user has moved the app to the background. The stacktrace reports

kotlin::FormatToSpan(kotlin::std_support::span<char, ...>, char const*, ...) + 10

which is mentioned in this channel before. This is the stacktrace in detail:

Crashed: com.apple.main-thread
0  libsystem_kernel.dylib         0x7b38 __pthread_kill + 8
1  libsystem_pthread.dylib        0x73bc pthread_kill + 268
2  libsystem_c.dylib              0x20524 abort + 168
3  ios                            0x118b4f8 kotlin::FormatToSpan(kotlin::std_support::span<char, 18446744073709551615ul>, char const*, ...) + 10
4  ios                            0x11b3850 ReportBacktraceToIosCrashLog(ObjHeader*) + 38
5  ios                            0x11b3688 void (anonymous namespace)::$_0::operator()<(anonymous namespace)::terminateWithUnhandledException(ObjHeader*)::$_1>((anonymous namespace)::terminateWithUnhandledException(ObjHeader*)::$_1) + 80
6  ios                            0x11b33d0 (anonymous namespace)::TerminateHandler::queuedHandler() + 10
7  ios                            0x11b3384 (anonymous namespace)::processUnhandledException(ObjHeader*) + 64
8  ios                            0x148d3ac kfun:kotlinx.coroutines#handleCoroutineExceptionImpl(kotlin.coroutines.CoroutineContext;kotlin.Throwable){} + 13 (CoroutineExceptionHandlerImpl.kt:13)
9  ios                            0x1380520 kfun:kotlinx.coroutines#handleCoroutineException(kotlin.coroutines.CoroutineContext;kotlin.Throwable){} + 33 (CoroutineExceptionHandler.kt:33)
10 ios                            0x1372c04 kfun:kotlinx.coroutines.StandaloneCoroutine.handleJobException#internal + 196 (Builders.common.kt:196)
11 ios                            0x138e614 kfun:kotlinx.coroutines.JobSupport.finalizeFinishingState#internal + 229 (JobSupport.kt:229)
12 ios                            0x1398794 kfun:kotlinx.coroutines.JobSupport.continueCompleting#internal + 935 (JobSupport.kt:935)
13 ios                            0x139b5c8 kfun:kotlinx.coroutines.JobSupport.ChildCompletion.invoke#internal + 1155 (JobSupport.kt:1155)
14 ios                            0x1390c3c kfun:kotlinx.coroutines.JobSupport.notifyCompletion#internal + 368 (JobSupport.kt:368)
15 ios                            0x138fea4 kfun:kotlinx.coroutines.JobSupport.completeStateFinalization#internal + 323 (JobSupport.kt:323)
16 ios                            0x138e4d4 kfun:kotlinx.coroutines.JobSupport.finalizeFinishingState#internal + 240 (JobSupport.kt:240)
17 ios                            0x1397ac4 kfun:kotlinx.coroutines.JobSupport.tryMakeCompletingSlowPath#internal + 906 (JobSupport.kt:906)
18 ios                            0x13974d0 kfun:kotlinx.coroutines.JobSupport.tryMakeCompleting#internal + 863 (JobSupport.kt:863)
19 ios                            0x13970b0 kfun:kotlinx.coroutines.JobSupport#makeCompletingOnce(kotlin.Any?){}kotlin.Any? + 828 (JobSupport.kt:828)
20 ios                            0x136d0e8 kfun:kotlinx.coroutines.AbstractCoroutine#resumeWith(kotlin.Result<1:0>){} + 100 (AbstractCoroutine.kt:100)
21 ios                            0x1024a38 kfun:kotlin.coroutines.native.internal.BaseContinuationImpl#resumeWith(kotlin.Result<kotlin.Any?>){} + 43 (ContinuationImpl.kt:43)
22 ios                            0x145c138 kfun:kotlinx.coroutines.DispatchedTask#run(){} + 54 (Continuation.kt:54)
23 ios                            0x1496b14 kfun:kotlinx.coroutines.DarwinMainDispatcher.dispatch$lambda$0#internal + 44 (Dispatchers.kt:44)
24 ios                            0x1496e84 kfun:kotlinx.coroutines.DarwinMainDispatcher.$dispatch$lambda$0$FUNCTION_REFERENCE$75.invoke#internal + 43 (Dispatchers.kt:43)
25 ios                            0x1496f68 kfun:kotlinx.coroutines.DarwinMainDispatcher.$dispatch$lambda$0$FUNCTION_REFERENCE$75.$<bridge-UNN>invoke(){}#internal + 43 (Dispatchers.kt:43)
26 ios                            0x1497fec _6f72672e6a6574627261696e732e6b6f746c696e783a6b6f746c696e782d636f726f7574696e65732d636f7265_knbridge13 + 43 (Dispatchers.kt:43)
27 libdispatch.dylib              0x1e6c _dispatch_call_block_and_release + 32
28 libdispatch.dylib              0x3a30 _dispatch_client_callout + 20
29 libdispatch.dylib              0x11f48 _dispatch_main_queue_drain + 928
30 libdispatch.dylib              0x11b98 _dispatch_main_queue_callback_4CF + 44
31 CoreFoundation                 0x51800 __CFRUNLOOP_IS_SERVICING_THE_MAIN_DISPATCH_QUEUE__ + 16
32 CoreFoundation                 0xb704 __CFRunLoopRun + 2532
33 CoreFoundation                 0x1ebc8 CFRunLoopRunSpecific + 600
34 GraphicsServices               0x1374 GSEventRunModal + 164
35 UIKitCore                      0x514b58 -[UIApplication _run] + 1100
36 UIKitCore                      0x296090 UIApplicationMain + 364
37 SwiftUI                        0x23ff24 closure #1 in KitRendererCommon(_:) + 164
38 SwiftUI                        0x16de08 runApp<A>(_:) + 252
39 SwiftUI                        0x14f0f4 static App.main() + 128
40 ios                            0x437fcc static iOSApp.$main() + 40 (<compiler-generated>:40)
41 ios                            0x438074 main + 12 (iOSApp.swift:12)
42 ???                            0x105285da4 (Missing)

Are there any suggestions on where I can start looking for the reason of the crash?

Have there been any attempts at wrapping posix in a typesafe library in K/N? Lots of bitmasks and flags in libc which are easy footguns.

What is the recommended way to link against (and/or provide) other native libraries for a kotlin native project? I'm currently experimenting a bit with sqlite3 using SqlDelight (which uses SQLiter under the hood) and it quickly becomes linker hell because of mismatched libc versions. In the end I kind of get it working after recompiling sqlite3 using the konan gcc

export CC=<konan-gcc>
export LDFLAGS=-L<konan-lib-folder>
./configure --prefix=/tmp/somelibfolder

and linking that in my final output binary.

For binary projects (for example an application I want to distribute) I can configure this custom sqlite3 build in my build scripts and provide the .so (or static .a) as part of the application package. But I'm not sure how to handle this situation when writing a library.

is it possible to define

noStringConversion

with the cocoapods plugin?

Are there other ways to distribute K/N libs without uploading to maven? From my understanding Jitpack only accepts JVM's. Are you able to add a dependency via git by any chance? gitRepository?

Is there a flag to have tests print the name of the current running test? I’m seeing one test infinitely loop on one of my laptops, but all I can see is

:modulename:iosSimulatorArm64Test > 122 tests completed

. I’d like to know which test is currently running. If I run in the IDE, where it does show the current test, no tests infinite loop.

Hi guys, after reading this thread https://kotlinlang.slack.com/archives/C3SGXARS6/p1672834441246099 , I find out a good way to ship my prebuilt static libraries with klib, thank @kpgalligan for sharing these two undocumented flags. Actually it’s quit simple, when adding a native target, e.g. linuxX64, in groovy:

kotlin {
  linuxX64 {
    compilations.main {
      cinterops {
        xlog {
          defFile "src/cppCommon/cinterop/xlog.def"
          includeDirs {
            allHeaders "${project.projectDir}/src/cppCommon/cpp"
          }
        }
      }

      kotlinOptions.freeCompilerArgs += [
          "-include-binary",
          "${project.projectDir}/src/linuxMain/libs/x64/libkmp_xlog.a".toString()
      ]
    }
  }
}

The key point is setting

kotlinOptions.freeCompilerArgs

. I’m wondering another thing: my c++ code depends on

pthread

and

z

, so in module which produces executable, my lib users need to add these two linker flags,

kotlin {
  linuxX64 {
    binaries {
      all {
        linkerOpts = [
          "-lpthread",
          "-lz",
          ]
      }

      executable("kmp_xlog") {
        entryPoint = "com.piasy.kmp.xlog.example.main"
      }
    }
  }
}

Is it possible that I specify these two linker flags in my library module, so they can be added to dependent modules automatically? So my lib users only need to add a gradle dependency, no need to set linkerOpts.

I’ve generated some bindings from the RocksDB C headers, and I’m trying to open a database. This is the generated binding:

public external expect fun rocksdb_open(
  options: CValuesRef<rocksdb_options_t>?, 
  name: String?, 
  errptr: CValuesRef<CPointerVar<ByteVar>>?
): CPointer<rocksdb_t>?

I need to pass in

errptr

, but how can I create a value with type

CValuesRef<CPointerVar<ByteVar>>

?

I'm slightly confused about klibs.. I have a klib created, its created fine via cinterop and installed via klib, has all the knms and all and is located in .konan/klib folder, but why am I unable to simply import it to a project? I was under the assumption that K/N is aware of klibs and where they're? Am I missing something here to be able just do import myPkg ?

One minor bug that I’ve noticed is that when working with def files, the target is supposed to have a red underline if it is incorrect, but

ios_simulator_arm64

is always underlined. For example,

linkerOpts.ios_x64

shows as correct, but

linkerOpts.ios_simulator_arm64

shows as an error. When I run tests or the app on ios arm64 simulator, everything works fine, it’s just a bit annoying to see the false error. What’s the best place to report this?

I've just found target-sysroot-4-embedded in my .konan and inspecting it I can see quite the amount of interesting header files and even sdl2-config in bin. Could someone tell me how is this used? Is this used by wasm target? Because I can also see emscripten and wasm-libc symbols, GLFW, GL and other bits that are not present in other targets. I tried to search around but couldn't find anything on this

Every few launches of a Kotlin Native program an intermittent seg fault occurs. Not every launch of the program causes a seg fault. With the seg fault I am trying to determine what is causing it. One of the C library dependencies (LVGL and LV Drivers) is most likely causing the seg fault to occur. • Are there any techniques for effectively identifying the cause of a seg fault with a Kotlin Native program (using the new memory model)? • What is the current method for debugging memory issues with a Kotlin Native program (using the new memory model)?

Does anyone know how to call an extension function that is also an instance of a type? For example:

fun test() {
    val bar = Bar()
    val foo = Foo()
    bar.doSomething() // How do you call this function
}

class Foo {
    fun Bar.doSomething() {
        // ...
    }
}

class Bar {
    // ...
}

Anyone found a way to build a Kotlin/Native project inside docker on a Mac M1?

My multiplatform backend project stopped compiling for the MacOS targets. Fails with

e: Could not find "org.jetbrains.kotlin.native.platform.CoreFoundationBase" in [/Users/ribesg/Projects/Inboxbooster-Mailer/HttpReceiver, /Users/ribesg/.konan/klib, /Users/ribesg/.konan/kotlin-native-prebuilt-macos-aarch64-1.7.22/klib/common, /Users/ribesg/.konan/kotlin-native-prebuilt-macos-aarch64-1.7.22/klib/platform/macos_arm64]

during

compileKotlinMacosArm64

and

compileKotlinMacosX64

. It worked before, it appeared when I added a dependency on

com.squareup.okio:okio:3.3.0

, but the problem is that I don't understand the error. It's open source so you can try for yourself here https://github.com/wizbii/Inboxbooster-Mailer/tree/feature/kotlin-receiver/HttpReceiver ✅ Was caused by Okio 3.3.0 being built for Kotlin 1.8 while I am using 1.7.22.

By what mechanism do Kotlin/Native workers request an underlying thread to terminate? I've managed to find

requestTerminationInternal

which is an

external fun

so I'm not quite sure how to keep digging on this. I imagine it differs on each platform, but is this documented functionality anywhere? https://github.com/JetBrains/kotlin/blob/30788566012c571aa1d3590912468d1ebe59983d/[…]ve/runtime/src/main/kotlin/kotlin/native/concurrent/Internal.kt

Anyone who is able to debug (e.g. stop on line) the KMM code from the iOS simulator? I’m having hard times. Tried Android Studio and Xcode, both with negative results. If you have any experiences, please share them in thread in #kotlin-native https://kotlinlang.slack.com/archives/C3PQML5NU/p1673631195903349 Thanks a lot! 🙏

I've found a weird performance inconsistency with my code on Linux and Windows... I'm working on a Raylib binding to K/N (game dev framework) and I've created a bunnymark test. What makes no sense to me that on my main PC - 32GB RAM, Ryzen 5 5600X and a RX5600XT I can render max 6500 entities (on Windows) until FPS drops down to 30... On my Linux laptop that runs on 16GB RAM, i7 11th gen with Iris iGPU I score 124200 entities till 30fps? Is there anything that could be causing this issue? Does K/N on Windows use different memory allocator or something that could also be causing this?

Is kotlin (specifically native) decoupled from java or is it still built on top of java?