what does it mean when you are asked, What is a return type in Kotlin?

Can I have the XCode "malloc guards" but when running a

test.kexe

binary?

In 1.5.31, do release XCFrameworks include dSYM files? The docs on the Symbolicating iOS Crash Reports page say

By default, Kotlin/Native compiler produces 

.dSYM

 for release (i.e. optimized) binaries on Darwin platforms

But the docs for building XCFrameworks only mention dSYMs for the debug task Digging in deeper, the source for

XCFrameworkTask

seems to only check for

dSYM

files for debug builds.

It it possible to run a Kotlin/Native binary on CentOS 6? Or more specifically CloudLinux, which is apparently based on CentOS 6. A normal executable fails because of the extremely ancient glibc, so I tried building a static library and bootstrapping it from a C program compiled on the target host with

gcc -ldl -lm -lpthread -lstdc++ hello-kt.c libuntitled.a

, but that fails due to various undefined symbols such as

std::chrono::_V2::steady_clock::now()

and

__cpu_model

.

I see that KotlinRoadMap update the status of interoperability with C++ from ⏸️(Postponed) to ❌(Removed) lately.Is that show kotlin directly C++interop is impossiable forever?What are the difficulties of C++Interop?

Adding all the darwin targets (

macosArm64

,

iosArm64

,

watchosArm64

,

watchosSimulatorArm64

,

tvosArm64

,

tvosX64

,

tvosSimulatorArm64

, ...) our CI build times took a 40min hit 😕 . Is there any chance the compiler could optimize "something" down there as from the distance it looks like it's doing the same thing over and over again?

Somewhat related to the above, what is the difference between

iOSArm64

and

iOSSimulatorArm64

? Could they somehow be merged as the instruction sets are the same? Or are the APIs different somehow?

For those of you who haven't yet fully descended down the rabbit hole that is building a truly universal XCFramework for all iOS and macOS platform variants, I have published a gist with some custom gradle tasks that generate the desired result. Specifically, if you have a Kotlin Multiplatform library targeting all modern Macs (M1 Apple Silicon and Intel) and all iOS devices and simulators: •

iosx64

•

iosArm64

•

iosSimulatorArm64

•

macosX64

•

macosArm64

...you can use these tasks to generate an XCFramework that works for all of them. XCFramework.kts The only 'official' Apple documentation on how to create such a framework (at least that I could find) is in an Apple forums post, so hopefully sharing this will (a) save other people time, and (b) lead to improvements on my amateurish gradle code!

Does somebody know what I'm doing wrong? https://youtrack.jetbrains.com/issue/KT-49558 The main Problem for me is the:

LDAP *ld

and then

ldap_initialize(&ld, ...

ldap_set_option(ld, ...

How to properly implement this? Thanks!

Hi, I'm learning kotlin. Is it possible to use Apple's Metal with kotlin native ? I see openGL and Metal as an exemple of "nativity" for kotlin but I can't find any more than that

Is there already some sort of documentation/specification for K/N's new experimental memory model? I'm thinking of something similar to https://docs.oracle.com/javase/specs/jls/se17/html/jls-17.html

In particular I'm looking for some kind of volatile/acquire/release semantics

struct arrays are apparently a bit of a grey area in K/N:

#!c
typedef struct request {
    int event_type;
    int iovec_count;
    int client_socket;
    struct iovec iov[];// <--- this 
};

in 1.5.31 this has no members, presumably silently errors during generation. in 1.6.0-RC it gains four members

#!kotlin

@kotlinx.cinterop.internal.CStruct public final class request 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 var client_socket: <http://kotlin.Int|kotlin.Int> /* compiled code */
    public final var event_type: <http://kotlin.Int|kotlin.Int> /* compiled code */
    public final val iov: kotlinx.cinterop.CArrayPointer<platform.posix.iovec> /* = kotlinx.cinterop.CPointer<platform.posix.iovec> */ /* compiled code */
    public final var iovec_count: <http://kotlin.Int|kotlin.Int> /* compiled code */
}

I have been naively porting this source c code using nativeHeap.alloc() and finally come to the part where the code does malloc(request.size+iov.size*6) the pointer needs to be long lived as this gets passed to the linux kernel and is immediately freed when the kernel returns it. that said, the goal is using uring with stable kotlin pointers when im done porting the webserver sample, not to preserve c code. should i stick with a factory method that takes the array size and uses malloc or is there a similar OO snippet somewhere that can get the job done with an aligned flat byte-expanse?

Hey, Have a question: I am using MVVM pattern in the app & my approach is: After button click from From Fragment A, navigate to Fragment B, call viewmodel, call APIs from the server (usecase, repo & repo impl part), and the result would we shown to UI (Fragment B) after observing the data. So is there any way that, after button click from Fragment A, call the API and based on the response of the API, show updated UI in the Fragments B. Current Behaviour -> Fragment A -> click button-> navigate to Fragment B and do api calls via MVVM Expected Behaviour -> Fragment A -> click button -> API call -> show Updated UI in Fragment B Does anyone know how to achieve this kind of behaviour in our android application? TIA

What's the difference between Pinned and StableRef? They look so similar besides maybe one being a data class and another a value class. Wouldn't one of them be enough?

For anyone on an m1 mac, how has your experience with kotlin native been? any snags or has that all been worked out?

I'm linking a c lib which succeeds at finding the headers and satisfying the def linker requirements

-luring

and shows up as complete in the kotlin/idea compiled cinterop code. the exe compiles and runs but when it hits the liburing struct definition there should be a static const int size, but instead the exe bails with a cryptic error code. there are a number of glibc/kernel headers which are getting the job done until it gets to this missing constant.

Hi there, anyone know how I might provide a custom cinterop def file when using a cocoapod? For some context, I am wanting to use a framework in a cocoapod which contains C++ and C header files, but am wanting to specify header filters to ignore the C++ headers, otherwise cinterop fails. Downloading the framework and referencing it locally works using the header filter, but curious as to whether I can specify this when using a cocoapod. Thanks, Michael

Trying to translate

NewSettings.c_lflag &= ~( ICANON | ECHO );

(C language) to Kotlin, and have hit a brick wall 🧱 with the bit manipulation since there appears to be some bit manipulation operations that can't be done in Kotlin, unless there are some workarounds available. Below is the full C code I am trying to translate into Kotlin:

#include <termios.h>
static struct termios OriginalSettings, NewSettings;
void terminal_setup()
{
    tcgetattr(STDIN_FILENO, &OriginalSettings);
    NewSettings = OriginalSettings;
    NewSettings.c_lflag &= ~( ICANON | ECHO );
    tcsetattr(STDIN_FILENO, TCSANOW, &NewSettings);
    printf("\e[?25l");
}
void terminal_reset()
{
    tcsetattr (STDIN_FILENO, TCSAFLUSH, &OriginalSettings);
}

Does Kotlin Native have a feature for copying values from one struct to another that is of the same type? Currently doing the following which is tedious/error prone:

// ...
private val globalArena = Arena()
private val originalSettings = globalArena.alloc<termios>()
private val newSettings = globalArena.alloc<termios>()
// ...
private fun setupTerminal() {
    tcgetattr(STDIN_FILENO, originalSettings.ptr)
    newSettings.run {
        c_ispeed = originalSettings.c_ispeed
        c_ospeed = originalSettings.c_ospeed
        c_line = originalSettings.c_line
        c_oflag = originalSettings.c_oflag
        c_cflag = originalSettings.c_cflag
        c_iflag = originalSettings.c_iflag
        // ...
    }
    // ...
}

I am trying to link to a C library in my program I am cross-compiling, I have compiled a

.so

library on my target, and copied it back to my development box. I can use library functions and the project compiles, but it fails at linking with:

.[..]/.konan/dependencies/arm-unknown-linux-gnueabihf-gcc-8.3.0-glibc-2.19-kernel-4.9-2/arm-unknown-linux-gnueabihf/bin/ld.bfd: src/nativeInterop/cinterop/libpigpio.so: undefined reference to glob@GLIBC_2.27'

It looks like Kotlin/Native is trying to compile with a different version of glibc than I compiled the library with, and it doesn't work. But how do I choose the glibc version in my project?

I have this develoment board: STM32F429I-DISCO, and I want to try Kotlin on it. My first idea is to skip the JVM stuff (in theory possible since you can have linux there) and try Kotlin/Native. I see here that @BradW you tried it - any luck? This ticket from 3 years ago and this thread don't give much hope, however these release notes mentioning "Experimental support for Zephyr RTOS" do give hope 🙂 Anyone could share their experience?

I'm hitting the weirdest bug in production randomly (automated reporting) and I don't know how to reproduce... This code:

fun apiUrl(param: String): String {
    return "/v2/$param"
}

Is somehow returning

"/v2/kotlin.Unit"

and hitting my server. Anyone seen anything like this? My code is multiplatform (Android/iOS/JS), but these are only coming from the iOS Kotlin/native version.

Kotlin/Native application using

gtk-kt

to play video. (There is audio, but pipewire is being a tad buggy so it is not included) I made this in under an hour, with a bit of debugging. It's impressively easy to make a GTK video player with Kotlin/Native :D

Does anyone has an example of building osx builds with travis?

@Artyom Degtyarev [JB] - Why is there no official Kotlin Linux/Embedded Linux development survey?

I've just published a blog post on generating swift code for kotlin native using KSP and swiftpoet: https://medium.com/@woitaschek/kotlin-native-using-swift-not-objective-c-d7742c040539 I'd love to hear your feedback on this 🙂

I implemented an XML parser on KMM and I'm calling it from iOS at the press of a button. But when the function ends its scope, I'm not seeing a reduction in memory usage. What am I missing?

class ViewController: UIViewController {

    @IBAction func importDatabase(_ sender: UIButton) {
        let xmlImporter = AirportXMLImporter(airportDatabaseService: DatabaseService())

        (1...5).forEach{ index in
            xmlImporter.parseXmlFile(path: Bundle.main.path(forResource: "airports-mundial", ofType: "xml")!)
                .subscribe(isThreadLocal: false,
                           onError: {error in},
                           onSuccess: {result in }).dispose()

        }
    }

    override func viewDidLoad() {
        super.viewDidLoad()
    }

}

The XML parser is the AirportXMLImporter. DatabaseService is injected as a persistence layer. DatabaseService is implemented in Swift.

Goodbye GitHub, Hello GitLab https://gitlab.com/gtk-kt/gtk-kt (Also who loves logos, I made this one with kotlin colors :D)