dominaezzz / kgl Goto Github PK

View Code? Open in Web Editor NEW

101.0 6.0 11.0 2.46 MB

Thin multiplatform wrappers for graphics.

License: Apache License 2.0

Kotlin 98.79% C 1.21%

kotlin kotlin-native kotlin-multiplatform vulkan glfw3 vulkan-api kgl graphics opengl

kgl's People

Contributors

Stargazers

Watchers

Forkers

nikkyai brunosilvafreire cybernetics btx638 archecraft breimerr crc-32 gergelydaniel sellmair study-game-engines gerald24

kgl's Issues

How can one best contribute to this library?

Is there a todo list for a stable release that one could get involved in?

Provide VirtualStack implementation

On native platforms there's a com.kgl.utils.VirtualStack used for allocations for temporaries when interacting with C. At the moment it just forwards allocations to nativeHeap which is not ideal.
Ideally VirtualStack should create a large chunk of memory (about 64KB) to be re-used for function calls.

`kgl-stb` doesn't not have a "load from file" function

unsigned char* stbi_load(const char* filename, int* x, int* y, int* channels_in_file, int desired_channels)

or equivalent

fun STBImage.loadFrom(filename: String, desiredChannels: Int? = null)

are not present in kgl-stb, and at this point, there is no good way to interact with files using kotlinx-io because of the massive restructuring they're doing right now.

The cinterop def explicitly defines STB_NO_STDIO, which prevents the generation of stbi_load, but stbi_load works fine with cinterop. What was the reason for defining STB_NO_STDIO?

OpenGL wrapper/bindings

For the OpenGL wrapper, I want to support all targets provided by Kotlin, although it is currently limited by the platforms supported by kotlinx-io which is used for raw memory handling.

The plan is to provide a common interface that calls either OpenGL, OpenGL ES or WebGL on the appropriate platform.
I don't think OpenGL ES 1.0/1.1 should be supported as it doesn't have much in common with the others.

Since there are multiple versions of the api, I'm not sure if expect/actual will help. An interface in common with implementations for each platforms may work better.

Whether to provide top level functions or an object to call functions on is still undecided. (Depends on how OpenGL is exposed on each platform I guess).

can't resolve kgl-glfw-static library

Could not resolve com.kgl:kgl-glfw-static:0.1.11.

Using dependencies block from your imgui project. commenting the single glfw-static dependency solves it.

val imguiVersion = "0.1.9"
val kglVersion = "0.1.11"

repositories {
    mavenCentral()

    maven ("https://maven.pkg.github.com/Dominaezzz/kotlin-imgui") {
        credentials {
            username = project.findProperty("gpr.user") as String ?: System.getenv("GITHUB_USER")
            password = project.findProperty("gpr.password") as String ?: System.getenv("GITHUB_TOKEN")
        }
    }
}

dependencies {
    implementation(kotlin("stdlib"))

    // Dear::ImGui bindings for kotlin
    implementation("com.kotlin-imgui:imgui:$imguiVersion")
    implementation("com.kotlin-imgui:imgui-glfw:$imguiVersion")
    implementation("com.kotlin-imgui:imgui-opengl:$imguiVersion")

    // For jvm binaries
    implementation("com.kotlin-imgui:cimgui-jvmlinuxx64:$imguiVersion")
    implementation("com.kotlin-imgui:cimgui-jvmmacosx64:$imguiVersion")
    implementation("com.kotlin-imgui:cimgui-jvmmingwx64:$imguiVersion")

    // Optional
    implementation("com.kgl:kgl-glfw:$kglVersion")
    implementation("com.kgl:kgl-glfw-static:$kglVersion")
    implementation("com.kgl:kgl-opengl:$kglVersion")
    implementation("com.kgl:kgl-stb:$kglVersion")
}

Vulkan Code Generation

GLFW KeyboardKey `value` and `from` are internal preventing easy conversion from GLFW to custom class

This also applies to MouseButton. Having the value be inaccessible makes it very difficult to convert the library-specific KeyboardKey into a library-agnostic custom class. Making value and from public would solve the issue.

Could not find io.ktor:ktor-io:1.4.0.

I am using the OpenGL sample and I edited it to use a more recent version of kotlin

Here is my build.gradle.kts code:

import org.gradle.internal.os.OperatingSystem;
import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinNativeTarget

plugins {
    kotlin("multiplatform") version "1.6.21"
}

repositories {
    maven("https://maven.pkg.github.com/Dominaezzz/kgl") {
        credentials {
            username = "USERNAME"
            password = "TOKEN"
        }
    }
}

val kglVersion = "0.1.11"

kotlin {
    val os = OperatingSystem.current()

    if (os.isWindows) mingwX64()
    if (os.isLinux) linuxX64()
    if (os.isMacOsX) macosX64()

    targets.withType<KotlinNativeTarget> {
        binaries {
            executable {
                entryPoint = "main"
            }
        }
        compilations {
            "main" {
                defaultSourceSet {
                    kotlin.srcDir("src/main/kotlin")
                    resources.srcDir("src/main/resources")
                }
                dependencies {
                    implementation("com.kgl:kgl-glfw:$kglVersion")
                    implementation("com.kgl:kgl-glfw-static:$kglVersion")
                    implementation("com.kgl:kgl-opengl:$kglVersion")
                    implementation("com.kgl:kgl-stb:$kglVersion")
                }
            }
            "test" {
                defaultSourceSet {
                    kotlin.srcDir("src/test/kotlin")
                    resources.srcDir("src/test/resources")
                }
            }
        }
    }

    sourceSets {
        // Note: To enable common source sets please comment out "kotlin.import.noCommonSourceSets" property
        // in gradle.properties file and re-import your project in IDE.
    }

    sourceSets.all {
        languageSettings.apply {
            enableLanguageFeature("InlineClasses")
            optIn("kotlin.ExperimentalUnsignedTypes")
        }
    }
}

Update KGL to Kotlin 1.3.70

Native targets break with 1.3.70, and syntax highlighting breaks with the new plugin. There seems to have been some kind of breaking ABI change.

Port KGL to Kotlin 1.8.21

Originally, I encountered the following error:

Caused by: java.lang.IllegalStateException: Artifacts of dependency io.ktor:ktor-io-metadata:1.4.0 is built by old Kotlin Gradle Plugin and can't be consumed in this way

It happened because KGL uses an absolutely ancient version of Kotlin (1.3.10 iirc)

Here's the exact place where the error was caused:

// build.gradle.kts:21
val ktorIoVersion: String by extra("1.4.0")

Temporary solution: Override the KGL dependency using your own (doesn't work for JS):

dependencies {
    api("io.ktor:ktor-io:2.3.0")
}

One problem with the above: The Kotlin Version. Really, this solution isn't possible to be PRed into KGL - it uses too ancient of a Kotlin version. Porting KGL to Kotlin 1.8.21 (or an older version; really, anything newer could be nice) will also give KGL the ability to use new features, for example, the following feature was implemented:

Platform specific extensions have not been implemented yet. Mostly because of this.

Using a non-ktor class could solve the issue - and a PR exists for this - but more and more issues like this will arrive.

I see no reason to stay on an ancient version of Kotlin - and if there is one, please, let me know. I'm going to heavily use KGL soon - in fact, I'm currently implementing a math library (definitely not because the one I've found calls its vectors Float3). If KGL isn't maintained anymore, I would like to help.

Best approach for a kgl-math library?

API largely on GLM, with some Kotlinic modifications to the naming
Native library wrapped by Kotlin classes should work well
glm is C++-only, so maybe cglm? Although from their readme, they seem to be missing some features of glm atm. Not sure if unaligned vectors and matrices are important.

What about updates and development?

Hello, you doing awesome work, but i have several questions:

Why you stop develop this library?
Why you support only desktop platforms? (A lot of people use kotlin for mobile instead desktop development)
Can i help you develop your library? (For example you have a vision of project but have not enough time for development)
Thank you for your job!

kgl-opengl on macOS creates 2.1 context instead of 4.1 context by default

kgl-opengl currently can only create an OpenGL context up version 2.1, because Apple. Platform lib only supports up to 3.2+ (no 4), but there's nothing to be done about that. Calling gl functions from 4+ throws NullPointerException because the function loader can't find them.

GLFW and multi-threading

As mentioned in #27

Some concerns:

How does having a @ThreadLocal Glfw object impact multithreaded applications?
Should GLFW calls be limited to only the "main" thread (and throw an exception otherwise)?
How is multithreadedness handled in a C/C++ application with GLFW?

Vulkan pNext DSL

Regular command calls with struct inputs have DSLs like so

val layers: List<String> = TODO()
val extensions: List<String> = TODO()

val instance = Instance.create(layers, extensions) { // this: InstanceCreateInfoBuilder
    applicationInfo { // this: ApplicationInfoBuilder
        applicationName = "Kgl App"
        applicationVersion = VkVersion(1u, 1u, 0u)
        engineName = "No engine yet"
        engineVersion = VkVersion(1u, 0u, 0u)
        apiVersion = VkVersion(1u, 1u, 0u)
    }
}

We need a way to allow users to append structs to the pNext pointer of input structs, while also making order and pNext nature obvious.
Also when generating DSL builders for struct members, the member name and type are known but for pNext structs, only the type is known. A solution which doesn't involve hand written names would be ideal.

Solution 1:

val instance = Instance.create(layers, extensions) { // this: InstanceCreateInfoBuilder
    applicationInfo { // this: ApplicationInfoBuilder
        applicationName = "Kgl App"
        applicationVersion = VkVersion(1u, 1u, 0u)
        engineName = "No engine yet"
        engineVersion = VkVersion(1u, 0u, 0u)
        apiVersion = VkVersion(1u, 1u, 0u)
    }

    next(ValidationFlagsEXT) {
        disabledValidationChecks(ValidationCheckEXT.ALL, ValidationCheckEXT.SHADERS)
    }
    next(ValidationFeaturesEXT) {
        enabled(ValidationFeatureEnableEXT.GPU_ASSISTED)
        disabled(ValidationFeatureDisableEXT.THREAD_SAFETY)
    }
    next(DebugReportCallbackCreateInfoEXT) {
        flags = DebugReportFlagBitsEXT.WARNING or DebugReportFlagBitsEXT.ERROR
        callback { flags, objectType, object, location, messageCode, layerPrefix, message ->
            println("Debug Message: $message")
        }
    }
}

Solution 2:

val instance = Instance.create(layers, extensions) { // this: InstanceCreateInfoBuilder
    applicationInfo { // this: ApplicationInfoBuilder
        applicationName = "Kgl App"
        applicationVersion = VkVersion(1u, 1u, 0u)
        engineName = "No engine yet"
        engineVersion = VkVersion(1u, 0u, 0u)
        apiVersion = VkVersion(1u, 1u, 0u)
    }

    next(ValidationFlagsEXT) {
        disabledValidationChecks(ValidationCheckEXT.ALL, ValidationCheckEXT.SHADERS)

        next(ValidationFeaturesEXT) {
            enabled(ValidationFeatureEnableEXT.GPU_ASSISTED)
            disabled(ValidationFeatureDisableEXT.THREAD_SAFETY)

            next(DebugReportCallbackCreateInfoEXT) {
                flags = DebugReportFlagBitsEXT.WARNING or DebugReportFlagBitsEXT.ERROR
                callback { _, _, _, _, _, _, message ->
                    println("Debug Message: $message")
                }
            }
        }
    }
}

Solution 3:

val instance = Instance.create(layers, extensions) { // this: InstanceCreateInfoBuilder
    applicationInfo { // this: ApplicationInfoBuilder
        applicationName = "Kgl App"
        applicationVersion = VkVersion(1u, 1u, 0u)
        engineName = "No engine yet"
        engineVersion = VkVersion(1u, 0u, 0u)
        apiVersion = VkVersion(1u, 1u, 0u)
    }

    next_ValidationFlagsEXT(ValidationCheckEXT.ALL, ValidationCheckEXT.SHADERS)
    next_ValidationFeaturesEXT(
        enabled = listOf(ValidationFeatureEnableEXT.GPU_ASSISTED),
        disabled = listOf(ValidationFeatureDisableEXT.THREAD_SAFETY)
    )
    next_DebugReportCallbackCreateInfoEXT {
        flags = DebugReportFlagBitsEXT.WARNING or DebugReportFlagBitsEXT.ERROR
        callback { flags, objectType, object, location, messageCode, layerPrefix, message ->
            println("Debug Message: $message")
        }
    }
}

Solution 4:

val instance = Instance.create(layers, extensions) { // this: InstanceCreateInfoBuilder
    applicationInfo { // this: ApplicationInfoBuilder
        applicationName = "Kgl App"
        applicationVersion = VkVersion(1u, 1u, 0u)
        engineName = "No engine yet"
        engineVersion = VkVersion(1u, 0u, 0u)
        apiVersion = VkVersion(1u, 1u, 0u)
    }

    next {
        ValidationFlagsEXT(ValidationCheckEXT.ALL, ValidationCheckEXT.SHADERS)
        ValidationFeaturesEXT(
            enabled = listOf(ValidationFeatureEnableEXT.GPU_ASSISTED),
            disabled = listOf(ValidationFeatureDisableEXT.THREAD_SAFETY)
        )
        DebugReportCallbackCreateInfoEXT {
            flags = DebugReportFlagBitsEXT.WARNING or DebugReportFlagBitsEXT.ERROR
            callback { _, _, _, _, _, _, message ->
                println("Debug Message: $message")
            }
        }
    }
}

Use inline classes for the struct DSLs

At the moment all the struct DSL classes are regular class that wrap a simple platform specific representation of vulkan structs. Since most of these classes only have a single (private) property, they can be inlined and drastically reduce dynamic allocation when calling complex vulkan functions.

This is blocked on KT-26456 or KT-27854 and possibly KT-28056.

can't switch from fullscreen to windowed mode

to switch to windowed mode the monitor ptr must be set to null, however the monitor param of kgl's window.setMonitor() function is non-nullable, making this operation impossible

Static glfw

At the moment, glfw is setup for dynamic linking. So users of kgl-glfw need to have glfw installed on their system. In most cases, glfw 3.2.1 has to be built from source and is not available from a package manager, this is not very beginner friendly :).
So I want to bundle a static build of glfw with the KLIBs, so that way, they are self-contained and link automatically.
I'm currently looking at the implications of doing it this way.

kgl-stb: cstb.stbi_load and STBImage.load both crash on Windows 10

Error code -1073741819. Googling this suggests a file system error, but I have no idea. Trying any of the suggested fixes yields no results.

I've copied the entire stb_image.h into a cinterop def with the following headings, and it works fine, but using kgl-stb makes it crash:

excludedFunctions = stbi__err
compilerOpts = -DSTB_IMAGE_IMPLEMENTATION

move to new maven repository due to Bintray shutdown

kgl is currently unavailable as a maven/gradle dependency because of this

also can you push a new release while you're at it ? still waiting for #34 to become available

Provide multiplatform stb bindings.

https://github.com/nothings/stb

No conversion from cinterop types to Kotlin types done by code generator

Functions like glGetString are generated with a return type of CPointer<GLubyteVar> rather than String. This requires a conversion using a !!.reinterpret<ByteVar>().toKString(), which could be included in the generated code to make the kotlin-facing functions more kotlinic.

Can't compile with version kgl-opengl 0.1.9-dev-6, compiler crash

Will have to test more in isolation (mini project), but there seems to be an issue somewhere with the conversion from Boolean to UByte. Code works fine with kgl-opengl 0.1.9-dev-5 (ie before the addition of nice_opengl changes.

e: Compilation failed: actual type is kotlin.Boolean, expected kotlin.UByte

 * Source files: 
 * Compiler version info: Konan: 1.3.61 / Kotlin: 1.3.60
 * Output kind: PROGRAM

e: java.lang.IllegalStateException: actual type is kotlin.Boolean, expected kotlin.UByte
e: Compilation failed: actual type is kotlin.Boolean, expected kotlin.UByte

	at org.jetbrains.kotlin.backend.konan.BoxingKt.getTypeConversionImpl(Boxing.kt:40)
	at org.jetbrains.kotlin.backend.konan.BoxingKt.getTypeConversion(Boxing.kt:28)
	at org.jetbrains.kotlin.backend.konan.lower.AutoboxingTransformer.adaptIfNecessary(Autoboxing.kt:161)
	at org.jetbrains.kotlin.backend.konan.lower.AutoboxingTransformer.useAs(Autoboxing.kt:125)
	at org.jetbrains.kotlin.backend.konan.lower.AutoboxingTransformer.visitCall(Autoboxing.kt:200)
	at org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid.visitCall(IrElementTransformerVoid.kt:170)
	at org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid.visitCall(IrElementTransformerVoid.kt:24)
	at org.jetbrains.kotlin.ir.expressions.impl.IrCallImpl.accept(IrCallImpl.kt:89)
	at org.jetbrains.kotlin.ir.expressions.IrExpression$DefaultImpls.transform(IrExpression.kt:28)
	at org.jetbrains.kotlin.ir.expressions.impl.IrExpressionBase.transform(IrExpressionBase.kt:24)
	at org.jetbrains.kotlin.ir.expressions.impl.IrCallWithIndexedArgumentsBase.transformChildren(IrCallWithIndexedArgumentsBase.kt:70)
	at org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoidKt.transformChildrenVoid(IrElementTransformerVoid.kt:285)
	at org.jetbrains.kotlin.backend.common.AbstractValueUsageTransformer.visitFunctionAccess(AbstractValueUsageTransformer.kt:91)
	at org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid.visitCall(IrElementTransformerVoid.kt:169)
	at org.jetbrains.kotlin.backend.konan.lower.AutoboxingTransformer.visitCall(Autoboxing.kt:205)
	at org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid.visitCall(IrElementTransformerVoid.kt:170)
	at org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid.visitCall(IrElementTransformerVoid.kt:24)
	at org.jetbrains.kotlin.ir.expressions.impl.IrCallImpl.accept(IrCallImpl.kt:89)
	at org.jetbrains.kotlin.ir.expressions.IrExpression$DefaultImpls.transform(IrExpression.kt:28)
	at org.jetbrains.kotlin.ir.expressions.impl.IrExpressionBase.transform(IrExpressionBase.kt:24)
	at org.jetbrains.kotlin.ir.declarations.impl.IrVariableImpl.transformChildren(IrVariableImpl.kt:93)
	at org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoidKt.transformChildrenVoid(IrElementTransformerVoid.kt:285)
	at org.jetbrains.kotlin.backend.common.AbstractValueUsageTransformer.visitVariable(AbstractValueUsageTransformer.kt:174)
	at org.jetbrains.kotlin.backend.common.AbstractValueUsageTransformer.visitVariable(AbstractValueUsageTransformer.kt:32)
	at org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid.visitVariable(IrElementTransformerVoid.kt:85)
	at org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid.visitVariable(IrElementTransformerVoid.kt:24)
	at org.jetbrains.kotlin.ir.declarations.impl.IrVariableImpl.accept(IrVariableImpl.kt:86)
	at org.jetbrains.kotlin.ir.declarations.IrDeclaration$DefaultImpls.transform(IrDeclaration.kt:42)
	at org.jetbrains.kotlin.ir.declarations.impl.IrDeclarationBase.transform(IrDeclarationBase.kt:27)
	at org.jetbrains.kotlin.ir.expressions.impl.IrBlockBodyImpl.transformChildren(IrBlockBodyImpl.kt:49)
	at org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoidKt.transformChildrenVoid(IrElementTransformerVoid.kt:285)
	at org.jetbrains.kotlin.backend.common.AbstractValueUsageTransformer.visitBlockBody(AbstractValueUsageTransformer.kt:107)
	at org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid.visitBlockBody(IrElementTransformerVoid.kt:97)
	at org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid.visitBlockBody(IrElementTransformerVoid.kt:24)
	at org.jetbrains.kotlin.ir.expressions.impl.IrBlockBodyImpl.accept(IrBlockBodyImpl.kt:40)
	at org.jetbrains.kotlin.ir.expressions.IrBody$DefaultImpls.transform(IrBody.kt:24)
	at org.jetbrains.kotlin.ir.expressions.IrBlockBody$DefaultImpls.transform(IrBody.kt)
	at org.jetbrains.kotlin.ir.expressions.impl.IrBlockBodyImpl.transform(IrBlockBodyImpl.kt:26)
	at org.jetbrains.kotlin.ir.declarations.impl.IrFunctionBase.transformChildren(IrFunctionBase.kt:77)
	at org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoidKt.transformChildrenVoid(IrElementTransformerVoid.kt:285)
	at org.jetbrains.kotlin.backend.common.AbstractValueUsageTransformer.visitFunction(AbstractValueUsageTransformer.kt:248)
	at org.jetbrains.kotlin.backend.konan.lower.AutoboxingTransformer.visitFunction(Autoboxing.kt:77)
	at org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid.visitSimpleFunction(IrElementTransformerVoid.kt:55)
	at org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid.visitSimpleFunction(IrElementTransformerVoid.kt:56)
	at org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid.visitSimpleFunction(IrElementTransformerVoid.kt:24)
	at org.jetbrains.kotlin.ir.declarations.impl.IrFunctionImpl.accept(IrFunctionImpl.kt:90)
	at org.jetbrains.kotlin.ir.declarations.IrDeclaration$DefaultImpls.transform(IrDeclaration.kt:42)
	at org.jetbrains.kotlin.ir.declarations.impl.IrDeclarationBase.transform(IrDeclarationBase.kt:27)
	at org.jetbrains.kotlin.ir.declarations.impl.IrClassImpl.transformChildren(IrClassImpl.kt:100)
	at org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoidKt.transformChildrenVoid(IrElementTransformerVoid.kt:285)
	at org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid.transformChildrenVoid(IrElementTransformerVoid.kt:280)
	at org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid.transformChildren(IrElementTransformerVoid.kt:25)
	at org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid.visitDeclaration(IrElementTransformerVoid.kt:46)
	at org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid.visitClass(IrElementTransformerVoid.kt:49)
	at org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid.visitClass(IrElementTransformerVoid.kt:50)
	at org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid.visitClass(IrElementTransformerVoid.kt:24)
	at org.jetbrains.kotlin.ir.declarations.impl.IrClassImpl.accept(IrClassImpl.kt:89)
	at org.jetbrains.kotlin.ir.declarations.IrDeclaration$DefaultImpls.transform(IrDeclaration.kt:42)
	at org.jetbrains.kotlin.ir.declarations.impl.IrDeclarationBase.transform(IrDeclarationBase.kt:27)
	at org.jetbrains.kotlin.ir.declarations.impl.IrFileImpl.transformChildren(IrFileImpl.kt:71)
	at org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoidKt.transformChildrenVoid(IrElementTransformerVoid.kt:285)
	at org.jetbrains.kotlin.backend.konan.lower.Autoboxing.lower(Autoboxing.kt:48)
	at org.jetbrains.kotlin.backend.common.phaser.PhaseBuildersKt$makeIrFilePhase$1.invoke(PhaseBuilders.kt:173)
	at org.jetbrains.kotlin.backend.common.phaser.PhaseBuildersKt$makeIrFilePhase$1.invoke(PhaseBuilders.kt:171)
	at org.jetbrains.kotlin.backend.common.phaser.AbstractNamedPhaseWrapper$runBody$1.invoke(CompilerPhase.kt:128)
	at org.jetbrains.kotlin.backend.common.phaser.CompilerPhaseKt.downlevel(CompilerPhase.kt:24)
	at org.jetbrains.kotlin.backend.common.phaser.AbstractNamedPhaseWrapper.runBody(CompilerPhase.kt:127)
	at org.jetbrains.kotlin.backend.common.phaser.AbstractNamedPhaseWrapper.invoke(CompilerPhase.kt:105)
	at org.jetbrains.kotlin.backend.common.phaser.CompositePhase.invoke(PhaseBuilders.kt:28)
	at org.jetbrains.kotlin.backend.common.phaser.PhaseBuildersKt$performByIrFile$1.invoke(PhaseBuilders.kt:144)
	at org.jetbrains.kotlin.backend.common.phaser.PhaseBuildersKt$performByIrFile$1.invoke(PhaseBuilders.kt:136)
	at org.jetbrains.kotlin.backend.common.phaser.AbstractNamedPhaseWrapper$runBody$1.invoke(CompilerPhase.kt:128)
	at org.jetbrains.kotlin.backend.common.phaser.CompilerPhaseKt.downlevel(CompilerPhase.kt:24)
	at org.jetbrains.kotlin.backend.common.phaser.AbstractNamedPhaseWrapper.runBody(CompilerPhase.kt:127)
	at org.jetbrains.kotlin.backend.common.phaser.AbstractNamedPhaseWrapper.invoke(CompilerPhase.kt:105)
	at org.jetbrains.kotlin.backend.common.phaser.CompositePhase.invoke(PhaseBuilders.kt:28)
	at org.jetbrains.kotlin.backend.common.phaser.AbstractNamedPhaseWrapper$runBody$1.invoke(CompilerPhase.kt:128)
	at org.jetbrains.kotlin.backend.common.phaser.CompilerPhaseKt.downlevel(CompilerPhase.kt:24)
	at org.jetbrains.kotlin.backend.common.phaser.AbstractNamedPhaseWrapper.runBody(CompilerPhase.kt:127)
	at org.jetbrains.kotlin.backend.common.phaser.AbstractNamedPhaseWrapper.invoke(CompilerPhase.kt:105)
	at org.jetbrains.kotlin.backend.konan.ToplevelPhasesKt$dependenciesLowerPhase$1.invoke(ToplevelPhases.kt:319)
	at org.jetbrains.kotlin.backend.konan.ToplevelPhasesKt$dependenciesLowerPhase$1.invoke(ToplevelPhases.kt:305)
	at org.jetbrains.kotlin.backend.common.phaser.AbstractNamedPhaseWrapper$runBody$1.invoke(CompilerPhase.kt:128)
	at org.jetbrains.kotlin.backend.common.phaser.CompilerPhaseKt.downlevel(CompilerPhase.kt:24)
	at org.jetbrains.kotlin.backend.common.phaser.AbstractNamedPhaseWrapper.runBody(CompilerPhase.kt:127)
	at org.jetbrains.kotlin.backend.common.phaser.AbstractNamedPhaseWrapper.invoke(CompilerPhase.kt:105)
	at org.jetbrains.kotlin.backend.common.phaser.CompositePhase.invoke(PhaseBuilders.kt:28)
	at org.jetbrains.kotlin.backend.common.phaser.AbstractNamedPhaseWrapper$runBody$1.invoke(CompilerPhase.kt:128)
	at org.jetbrains.kotlin.backend.common.phaser.CompilerPhaseKt.downlevel(CompilerPhase.kt:24)
	at org.jetbrains.kotlin.backend.common.phaser.AbstractNamedPhaseWrapper.runBody(CompilerPhase.kt:127)
	at org.jetbrains.kotlin.backend.common.phaser.AbstractNamedPhaseWrapper.invoke(CompilerPhase.kt:105)
	at org.jetbrains.kotlin.backend.common.phaser.CompositePhase.invoke(PhaseBuilders.kt:28)
	at org.jetbrains.kotlin.backend.common.phaser.AbstractNamedPhaseWrapper$runBody$1.invoke(CompilerPhase.kt:128)
	at org.jetbrains.kotlin.backend.common.phaser.CompilerPhaseKt.downlevel(CompilerPhase.kt:24)
	at org.jetbrains.kotlin.backend.common.phaser.AbstractNamedPhaseWrapper.runBody(CompilerPhase.kt:127)
	at org.jetbrains.kotlin.backend.common.phaser.AbstractNamedPhaseWrapper.invoke(CompilerPhase.kt:105)
	at org.jetbrains.kotlin.backend.common.phaser.CompilerPhaseKt.invokeToplevel(CompilerPhase.kt:42)
	at org.jetbrains.kotlin.backend.konan.KonanDriverKt.runTopLevelPhases(KonanDriver.kt:27)
	at org.jetbrains.kotlin.cli.bc.K2Native.doExecute(K2Native.kt:74)
	at org.jetbrains.kotlin.cli.bc.K2Native.doExecute(K2Native.kt:34)
	at org.jetbrains.kotlin.cli.common.CLICompiler.execImpl(CLICompiler.kt:84)
	at org.jetbrains.kotlin.cli.common.CLICompiler.execImpl(CLICompiler.kt:42)
	at org.jetbrains.kotlin.cli.common.CLITool.exec(CLITool.kt:104)
	at org.jetbrains.kotlin.cli.common.CLITool.exec(CLITool.kt:82)
	at org.jetbrains.kotlin.cli.common.CLITool.exec(CLITool.kt:50)
	at org.jetbrains.kotlin.cli.common.CLITool$Companion.doMainNoExit(CLITool.kt:215)
	at org.jetbrains.kotlin.cli.common.CLITool$Companion.doMain(CLITool.kt:207)
	at org.jetbrains.kotlin.cli.bc.K2Native$Companion$main$1.invoke(K2Native.kt:225)
	at org.jetbrains.kotlin.cli.bc.K2Native$Companion$main$1.invoke(K2Native.kt:222)
	at org.jetbrains.kotlin.util.UtilKt.profileIf(Util.kt:27)
	at org.jetbrains.kotlin.util.UtilKt.profile(Util.kt:21)
	at org.jetbrains.kotlin.cli.bc.K2Native$Companion.main(K2Native.kt:224)
	at org.jetbrains.kotlin.cli.bc.K2NativeKt.main(K2Native.kt:304)
	at org.jetbrains.kotlin.cli.utilities.MainKt.main(main.kt:16)

Upgrade to the latest kotlin version

Current version of abi is far behind the latest stable.

Could you please upgrade it?

Replace IoBuffer with something more ergonomic

kotlinx.io.core.IoBuffer is going to be deprecated soon. kotlinx.io.bits.Memory will be a a better substitute for representing void* in kotlin.

Kotlin/kotlinx-io#39