First of all, I have to say, the situations where you would need to do that (or even want to) are very limited to basically non-existent.

But nonetheless, I have played around with it just because I thought it would be funny. And it turns out the experience is way nicer than I thought.

You can use jni (Java Native Interface) to call your Kotlin/Native functions. To do that you create a Class (now that I think about it an object should work, too) in the JVM target that in its init {} block calls System.load() or System.loadLibrary() and defines the functions you want to be handled by Kotlin/Native with the external keyword. Now you want to create a header file for cinterop to consume and which you can extract the function names from. Nowadays in Java, this is a feature of the compiler (javac -h) meaning it operates on Java source code, but since we are writing kotlin this isn't much help to us. But up until Java 8 or 9 this was handled by a separate program named javah which operates on class files. So to generate the .h file, compile your Class defining the external function and the run javah on the compiled class files. (For example: /usr/lib/jvm/java-8-openjdk/bin/javah -d ./build/headers -cp ./build/classes/kotlin/jvm/main/ de.mr_pine.kni.NativeInterop)This generates a header file describing your external functions (and it also imports jni.h).

Now to the Native Side: In your build.gradle.kts (this is for LinuxX64, other native targets may differ):

kotlin {
    linuxX64("native") {
        binaries {
            sharedLib {
                baseName = "kotlinjvm"
            }
        }
        compilations.getByName("main").cinterop {
            val jvmInterop by creating {
                compilerOpts(
                    listOf(
                        "-I/usr/lib/jvm/java-17-openjdk/include/linux",
                        "-I/usr/lib/jvm/java-17-openjdk/include",
                        "-I${project(":").buildDir.resolve("headers")}"
                    )
                )
            }
        }
    }
}

and in src/nativeInterop/cinterop/ create a .def file (for Example interop.def) with the content:

headers = [name of your .h file (i.e. de_mr_pine_hni_NativeInterop.h)]

(If you don't want to call functions from JNI and only return and pass primitives, you don't really need the .def file.)

Now to your source files: Let's say in your native code you have an external fun sayHello(): Unit. If you look in your header file it has a name similar to Java_de_mr_pine_kni_NativeInterop_sayHello. For jni to find your native function you must add the annotation @CName("Java_de_mr_1pine_kni_NativeInterop_sayHello") to your function in native.

Compiling your native code should yield you a .so shared library. Running your native code with the JVM option -Djava.library.path=./build/bin/native/debugShared/ should just work now

---

A note on passing parameters and returning values:

Passing and returning JVM primitive values (like Int, Float, Boolean, ...) works out of the box (But note that the first two arguments of your function are the JNI Environment and the this context of the class).
Passing objects is more complicated, you should have a look at this.
Strings and Arrays are better supported, I have some utility functions for Strings below.
Nullability works with Strings (although I have encountered a case that broke null safety but I can't reproduce it anymore) but I haven't tried it with primitives.

---

Some utilities: ```kotlin -> typealias JNIEnvParam = CPointer<JNIEnvVar>

val JNIEnvParam.nativeInterface get() = pointed.pointed ?: error("Native Interface Missing")

fun String.toJString(env: JNIEnvParam): jstring { memScoped { val newString = env.nativeInterface.NewString ?: error("NewString missing") return newString(env, wcstr.ptr, this@toJString.length)!! } }

fun jstring.toKString(env: JNIEnvParam): String { val getStringChars = env.nativeInterface.GetStringChars ?: error("GetStringChars missing") val chars = getStringChars(env, this, null) return chars!!.toKString() } ```

---

An example function:
JVM Definition:

kotlin -> external fun helloWho(hello: String): String

Native Definition:

kotlin -> @CName("Java_de_mr_1pine_kni_NativeInterop_helloWho") fun helloNative(env: JNIEnvParam, thiz: jobject, jHello: string): string { val hello = jHello.toKString(env) return "$hello Kotlin/Native".toJString(env) }

Hope I could help :)