I have defined:

kotlin {
    mingwX64("native") {
        binaries {
            executable()
        }
    }
}

That results in

ModuleVersionNotFoundException: Could not find :kotlin-native-prebuilt-windows-aarch64:1.6.10.

I am currently using the ARM version of Windows 11, which has the ability to run x64 code. I would like to know how I can modify my Gradle configuration to prioritize the use of the x64 version instead of searching for the aarch64 version.

Hi everyone, I'm working on a GIR generator to create kotlin native bindings for GTK and other GObject based libraries. I reached a stage where I can almost compile the bindings for GLib but I'm stuck with the handling of `vararg`s. For example

g_string_append_printf

, which is mapped with this:

@kotlinx.cinterop.internal.CCall public external fun g_string_append_printf(string: kotlinx.cinterop.CValuesRef<native.glib.GString /* = native.glib._GString */>?, @kotlinx.cinterop.internal.CCall.CString format: kotlin.String?, vararg variadicArguments: kotlin.Any?): kotlin.Unit { /* compiled code */ }

It seems to expect a

vararg variadicArguments: kotlin.Any?

, but if I send that to it like this:

public fun appendPrintf(format: String, vararg variadicArguments: Any): Unit {
        g_string_append_printf(cPointer.reinterpret(), format, variadicArguments)
    }

I get this error when I build the module:

type kotlin.Array<out kotlin.Any>  is not supported here: doesn't correspond to any C type

The GIR parameter only gives a name (

...

) and has a tag `varargs`:

<parameter name="..." transfer-ownership="none">
            <doc xml:space="preserve"
                 filename="glib-2.0.c"
                 line="32361">the parameters to insert into the format string</doc>
            <varargs/>
          </parameter>

But there are no other information about the type. I am an Android developer and not very familiar with C Interop. Does anyone have a suggestion of what this

vararg variadicArguments: kotlin.Any?

should be converted to?

I'm trying to write some code using

termios

in K/N.

termios

is a struct which has a bitflag field called

c_lflag

; its type is

platform.posix.tcflag_t

which appears to be an int on mac and a uint on linux. I'm trying to do some bit logic like this:

newTermios.c_lflag.and((_ECHO_.or(_ICANON_.or(_IEXTEN_))).inv())

(equivalent to

c_lflag & ~(ECHO | ICNON | IEXTEN)

in C). In order to support both targets, I thought

ECHO.or(...) as tcflag_t

would work, but I'm getting a warning that the cast will never succeed. What's the right solution here?

What would be a good approach for K/N libraries that "wrap" native libraries with possibly different versions where new minor upstream versions have additional functions/types and possibly deprecations? (for example GTK) In the

gtk-rs

case in Rust land they handle it with Cargo features where an application developer can depend on the

gtk4

crate which exposes the

4.0

API by default and

features = [4_2]

can be used in Cargo.toml to unlock newer API functions. - One possible solution is to have different library versions for each upstream dependency version but that can get unwieldy quickly. - Maybe something is possible with Kotlin annotations that conditionally enable additional methods based on properties in Gradle (equivalent to Cargo features). - Another approach could be to not distribute generated bindings and instead wrap the bindings-generator (GIR-based) into a Gradle plugin that is configured with the desired library version in the gradle DSL and generates the bindings at build-time. Has anyone already done something like this? Any thoughts?

I get this strange type mismatch when I call `gtk_cell_area_foreach_alloc`:

Type mismatch: inferred type is GtkCellAllocCallback /* = CPointer<CFunction<(CPointer<GtkCellRenderer /* = _GtkCellRenderer */>?, CPointer<GdkRectangle /* = native.gdk._cairo_rectangle_int */>?, CPointer<GdkRectangle /* = native.gdk._cairo_rectangle_int */>?, CPointer<out CPointed>?) -> gboolean /* = Int */>> */ but GtkCellAllocCallback? /* = CPointer<CFunction<(CPointer<GtkCellRenderer /* = _GtkCellRenderer */>?, CPointer<GdkRectangle /* = native.gtk._cairo_rectangle_int */>?, CPointer<GdkRectangle /* = native.gtk._cairo_rectangle_int */>?, gpointer? /* = CPointer<out CPointed>? */) -> gboolean /* = Int */>>? */ was expected

I really don't get what the issue is: it is expecting a

GtkCellAllocCallback?

and I'm giving it a

GtkCellAllocCallback?

. Does anyone have a clue of what the issue could be?

Is there a way to have different input types for setters? For example,

var bar: String = "5"
var foo: String
    get() { return bar }
    set(value: String) { bar = value }
    set(value: Int) { bar = value.toString() }
    set(value: Float) { bar = round(value).toInt().toString() }

The

GetFileVersionInfoSizeW

function is in the

platform.windows.*

package, but why am I getting

lld-link: error: undefined symbol: GetFileVersionInfoSizeW

?

Is there a possibility to disable cinterop for selected pods?

build.gradle.kts

plugins {
        kotlin("native.cocoapods")
...
kotlin {
  cocoapods {
        pod("pod_a") {
            version = "1.0"
            source = path(project.file("../pod_a"))
        }
        pod("pod_b") {
            version = "1.0"
            source = path(project.file("../pod_b"))
        }
...

e.g. How can I disable cinterop for pod_a?

I want to try making a program using https://learn.microsoft.com/en-us/windows/win32/api/_coreaudio/. I see that the headers are in konan, but there doesn't seem to be any imports for the classes and interfaces? Am I missing something or is there a compiler option I need to use

I'm looking for a fairly low level language (need access to platform APIs, building shared libraries, pointers), and I'm wondering if Kotlin/Native might suffice for that. I've ruled out C/C++ and Rust already because I'd prefer something else. Decent community support/libraries would also be nice. Thoughts?

Hi! I can't figure out if it's a bug or a feature, maybe someone with experience can help 🙂 I'm building a shared (

.dll

) library on Windows. If I build a vanilla Kotlin/Native project, the DLL exported symbols seem to be all public functions (screenshot 1). My own top-level

@CName

function is exported, I can see it. However, if I add an implementation dependency on kotlin-libui (cc @msink), DLL exported symbols are UI only (screenshot 2). My top-level

@CName

function is NOT exported, neither are any other K/N functions. Looks like the exports are taken from libui only and the rest is ignored. The

.def

and

.h

files are the same, so they contain my top-level function, but of course it fails in runtime whenever I try to load the DLL.

kotlin {
    val nativeMain by sourceSets.getting {
        dependencies {
            implementation("com.github.msink:libui:0.1.8")
        }
    }
}

Is there a way to tell the compiler to export all public functions, or override the list? I tried multiple options (including linker ones), tried removing exports from libui and some other things - nothing helped 😞 I basically want both ui and my own top-level function to be exported.

I'm planning on created a kotlin script which will be compiled to "Native", but I will need a FTP library. Does anyone know of any FTP library that will work for this?

This might be a weird question but I wanted to throw it out there anyway to gather ideas: Is it possible/supported to build a klib manually without going the

cinterop

route to interpret headers? So manually writing (or generating) the necessary

@CCall

functions to call into a native library. Is there a reason why I should not attempt this?

Has anyone written a function to get a device's ip address when targeting iOS? I know it can be done by calling the same APIs as used here: https://stackoverflow.com/questions/6807788/how-to-get-ip-address-of-iphone-programmatically Just hoping someone's already done it before I sink time into actually digesting the pain which is objective C 😆

Hi there, We see strange crashes on iOS, maybe someone faced with something similar before. We’re not sure if it’s connected directly with Kotlin/Native, however we see these stack-traces in Firebase and not able to reproduce the issue locally: GC Timer thread

void kotlin::RepeatedTimer<kotlin::steady_clock>::Run<kotlin::gc::internal::GCSchedulerDataWithTimer<kotlin::steady_clock>::GCSchedulerDataWithTimer(kotlin::gc::GCSchedulerConfig&, std::__1::function<void ()>)::'lambda'()>(kotlin::gc::internal::GCSchedulerDataWithTimer<kotlin::steady_clock>::GCSchedulerDataWithTimer(kotlin::gc::GCSchedulerConfig&, std::__1::function<void ()>)::'lambda'()&&) + 4373751076
4

void* std::__1::__thread_proxy<std::__1::tuple<std::__1::unique_ptr<std::__1::__thread_struct, std::__1::default_delete<std::__1::__thread_struct> >, void (*)(kotlin::ScopedThread::attributes, void (kotlin::RepeatedTimer<kotlin::steady_clock>::*&&)(kotlin::gc::internal::GCSchedulerDataWithTimer<kotlin::steady_clock>::GCSchedulerDataWithTimer(kotlin::gc::GCSchedulerConfig&, std::__1::function<void ()>)::'lambda'()&&) noexcept, kotlin::RepeatedTimer<kotlin::steady_clock>*&&, kotlin::gc::internal::GCSchedulerDataWithTimer<kotlin::steady_clock>::GCSchedulerDataWithTimer(kotlin::gc::GCSchedulerConfig&, std::__1::function<void ()>)::'lambda'()&&), kotlin::ScopedThread::attributes, void (kotlin::RepeatedTimer<kotlin::steady_clock>::*)(kotlin::gc::internal::GCSchedulerDataWithTimer<kotlin::steady_clock>::GCSchedulerDataWithTimer(kotlin::gc::GCSchedulerConfig&, std::__1::function<void ()>)::'lambda'()&&) noexcept, kotlin::RepeatedTimer<kotlin::steady_clock>*, kotlin::gc::internal::GCSchedulerDataWithTimer<kotlin::steady_clock>::GCSchedulerDataWithTimer(kotlin::gc::GCSchedulerConfig&, std::__1::function<void ()>)::'lambda'()> >(void*) + 4373751760

GC thread

std::__1::invoke_result<kotlin::gc::ConcurrentMarkAndSweep::ConcurrentMarkAndSweep(kotlin::mm::ObjectFactory<kotlin::gc::ConcurrentMarkAndSweep>&, kotlin::gc::GCScheduler&)::$_2>::type kotlin::ScopedThread::Run<kotlin::gc::ConcurrentMarkAndSweep::ConcurrentMarkAndSweep(kotlin::mm::ObjectFactory<kotlin::gc::ConcurrentMarkAndSweep>&, kotlin::gc::GCScheduler&)::$_2>(kotlin::ScopedThread::attributes, kotlin::gc::ConcurrentMarkAndSweep::ConcurrentMarkAndSweep(kotlin::mm::ObjectFactory<kotlin::gc::ConcurrentMarkAndSweep>&, kotlin::gc::GCScheduler&)::$_2&&) + 4373763056
4

void* std::__1::__thread_proxy<std::__1::tuple<std::__1::unique_ptr<std::__1::__thread_struct, std::__1::default_delete<std::__1::__thread_struct> >, void (*)(kotlin::ScopedThread::attributes, kotlin::gc::ConcurrentMarkAndSweep::ConcurrentMarkAndSweep(kotlin::mm::ObjectFactory<kotlin::gc::ConcurrentMarkAndSweep>&, kotlin::gc::GCScheduler&)::$_2&&), kotlin::ScopedThread::attributes, kotlin::gc::ConcurrentMarkAndSweep::ConcurrentMarkAndSweep(kotlin::mm::ObjectFactory<kotlin::gc::ConcurrentMarkAndSweep>&, kotlin::gc::GCScheduler&)::$_2> >(void*) + 4373768160

We use Kotlin 1.7.20

Is there a way to force cinterop to always use

strictEnums

or

nonStrictEnums

without using the heuristics mentioned on https://kotlinlang.org/docs/native-c-interop.html#definition-file-hints ?

I'm trying to use tdlib in Kotlin Native. Anything wrong with my code?

kotlin {
    macosX64()
    linuxX64()
    mingwX64()
    targets.withType<KotlinNativeTarget> {
        compilations["main"].cinterops {
            create("tdlib")
        }
    }
}

linkerOpts = \
    -ltdactor \
    -ltdapi \
    -ltdclient \
    -ltdcore \
    -ltddb \
    -ltdjson \
    -ltdjson_private \
    -ltdjson_static \
    -ltdnet \
    -ltdsqlite \
    -ltdutils

linkerOpts.mingw = \
    -I"D:\Git\Omico\telegram-bot\TDLib\tdlib\include" \
    -L"D:\Git\Omico\telegram-bot\TDLib\tdlib\lib"

Hello. How to find current executable's path (not working path) on MacOS? I can't find

_NSGetExecutablePath()

function in K/N macos target.

Is there any way to register some code to be executed when K/N object is being garbage collected (like java's finalize)? Trying to figure out how to properly dispose of the cinterop pointers that my wrapper classes own.

Any ideas on a good approach to map C bitfields often used as flags in C functions to a nice typesafe (or at least descriptive/discoverable) Kotlin API ? I'm trying to become an API like

val application = Application("myapp", ApplicationFlags.NONE.or(ApplicationFlags.REPLACE))

where I want the signature to read something like

class Application(val name: String, flags: ApplicationFlags)

So the user does not have to go hunt for random constants.

Hi, is there any up to date sample for collecting code coverage for native? And is it possible to do it inside gradle?

What would be the Kotlin Native way to do what the Java based String.format does?

I’m building a shared object file that will be used by the JVM via JNI. Is it safe to just build it for linuxX64 and linuxArm64, and re-use the same binaries for androidNativeArm64 and androidNativeX64, or will I have to create separate binaries for linux vs. android NDK? Android is built off Linux, so I’d assume the only issue is that I won’t have access to android-specific methods.

I'm getting

platform.posix.TIOCGWINSZ

showing up as undefined on macos. But as far as I can tell, that constant should be supported on the mac platform?

I'm having a hard time figuring out what the platform APIs expose. Better documentation is really needed for native

When running Kotlin/Native tasks, I’ve been seeing

Could not initialize class org.jetbrains.kotlin.backend.konan.env.env

, does anyone know what could be the cause?

I'm having a performance issue on Windows for Kotlin Native. We have a small application in Kotlin Native that interacts with a C library to stream text to us. We provide the library a static c function, and it streams the log to us.

staticCFunction { cByte, _ ->
            val c = cByte.toInt().toChar()
            print(c)
        }

The streaming gets backed up and starts to significantly lag on Windows Machines. The same code on Mac seems to perform fine. We've removed the print, and started buffering the characters before we print (so we only print once a line). The issue is still present. The same code in C++ doesn't have the same performance issues. What else could we do to improve performance in Kotlin?

I’d like to handle arrow keys from the standard input in my Kotlin Native console app (to handle history and current line editing). Is this possible? Maybe some libraries exist to support the use case?

I know Win7 is past end of life, but I had a report from a user that my K/N program triggered a "The procedure entry point EnumDynamicTimeZoneInformation could not be located in the dynamic link library ADVAPI32.dll" for them on a Win7 machine. Is there any chance that anyone has seen this before? Edit: Probably "solved". Sounds like another dependency, not mine.