I'd suggest adding the possibility of creating pure common libraries. Without having to manually implement them. Example: https://github.com/korlibs/korge/tree/ad5089fcf6fbc3849c8c8592752ba98ac735b804 Here I have a lot of sublibraries/extensions that I have to implement per target. Which is a bit crazy. Because all of them uses other common libraries and no platform-specific code. I think that you can just upload common versions and "instantiate" platform specific-artifacts locally. Either at build/ or in an external cache folder. Or even allowing to create a single jar with JVM code + other code embedded. Since the initial implementation should be simple I understand that it is not a priority right now, but I'd vote for it for a later release 🙂

I still have to check how kotlinx.serialization works and how to create a plugin to do the same for my asynchronous injector and avoid to manually or automatically having to generate a file like this: https://github.com/korlibs/korge-samples/blob/master/korge-tic-tac-toe/src/com.soywiz.korge.tictactoe/InjectExt.kt#L8

One question on visibility: I have a common module with a function indicated as

internal

. I have a jvm module that implements this module. My test code inside the jvm module does not see the internal function. Is this normal?

Trying to create multiplafrom project by: File > New > Project > Kotlin > Kotlin (Multiplatform - Experimental). Error after gradle import complete: https://pastebin.com/fZ2euzpS Same with https://github.com/jstuyts/kotlin-multiplatform-recipes/tree/syntax-1.2 (branch syntax-1.2).

Which version of IDEA, IDEA plugin and Gradle plugin is preferred for working with multiplatform project? In 1.2-EAP references from application module to common module not resolved in idea (red)

Is there a way for using

org.intellij.lang.annotations.Language

annotation in common code?

Hey! I'm trying to use Reagent (github.com/jakewharton/reagent), but I get a "Unresolved Reference: Observable" error when compiling This is my code:

import reagent.Observable

expect interface ExampleAPI {

    fun getUsers(): Observable<UserModel>

}

This is the error from Gradle:

Unresolved reference: Observable

Anything I'm not seeing there? This code is in the common module of my project

Is this reported? https://travis-ci.org/soywiz/kpspemu/builds/294470924#L967

e: java.lang.IllegalStateException: Cannot get FQ name of local class: class <no name provided>
	at org.jetbrains.kotlin.serialization.StringTableImpl.getFqNameIndexOfLocalAnonymousClass(StringTableImpl.kt:79)
        ...

I'm facing an intermittent

Actual ... has no corresponding expected declaration

since first version, when compiling with gradle. I have recorded a video reproducing the problem. It seems that it happens when modifying a file containing an actual. When having two modules with expectedBy using platform-jvm. I have android + jvm doing this.

@Deactivated User Could you debug it a little? I'll DM you the hints.

@snrostov This case isn't supported, feel free to open a feature request for that, but please describe your use case there.

I have a Kotlin common module that is being consumed by JVM and JS code and it works using Gradle; IntelliJ keeps complaining about classes like

Int

missing in the common module, though, even though the module's target platform is marked as

Common (experimental)

and the language version is at 1.2 - any hints on what I could try?

@voddan No there's no such plans: first, platform modules would not be a convenient replacement for this feature, second, splitting the standard library for each JVM version would fragment the libraries that built on top of it.

Tests in a common module are run as part of the tests of the actual platform modules

@spierce7 Yes, to run tests in JS you need to add some setup to the js project, see this post for details and samples: https://discuss.kotlinlang.org/t/unit-testing-in-kotlin-js/3943

can someone help us out with my broken understanding: If I have multiplatform project with a jvm target, js target and common project- how do I handle incompatibilities with common datatypes (e.g. kotlin.String vs java.lang.String) and the apparent lack of

Int

?

so … as is the rule when asking for help online- moments later I stumbled to the solution. I had to specify the common project as expectedBy my jvm target- which is like the first step of any of this, but my jvm target isn’t really providing any implementations, just sharing common classes currently

I have a case that I'm not sure is supported. Basically I have a library that provides XML related functions for Android, JVM and JS with a common api. All three targets have different underlying libraries that I will use. At the same time Android and JVM do share some commonalities that are not present for JS. As such I would like to have a common module ("common-android-jvm") that provides the implementation for some expects as that are declared in the fully common module. It doesn't seem possible to do that. Of course the android and jvm modules could duplicate the code (but I'd like to avoid that). Anyone know whether this is an oversight of me, or is this a "missing" feature

Hi, can I find a sample of native kotlin targeting Android and iOS on the same code?

I am still new to this multiplatform but why is this a type error:

Required: (kotlin.text.Appendable /* = java.lang.Appendable */) -> Unit
Found: (kotlin.text.Appendable) -> Unit

If anyone would like to take a look: https://github.com/spand/kotlin-multi-platform It builds in gradle but IDEA fails the build. Also hovering on

app

variable read in foo/kotlin/.../Foo.kt the previous mentioned type error is shown

But is there an

expect

definition in the stdlib for common? I’m using 1.2.0 and IntelliJ is showing compilation errors for uses of Comparator in common modules

IDEA still has some issues with multiplatform code

Is it possible to have Android module which is also platform module? To omit common-jvm?

How to resolve the "Cannot add extension with name 'kotlin', as there is an extension already registered with that name." error ?

Has anyone found a good option for multiplatform localisation/L10n? Preferably a typesafe option. I'm trying to migrate a GWT project which uses type-safe messages (http://www.gwtproject.org/javadoc/latest/com/google/gwt/i18n/client/Messages.html). Basically the GWT compiler generates the English .properties file from a messages interface - method names become property keys, annotation values provide the English strings - and also generates runtime classes to provide the translations (taken from the translated .properties files). I don't need compile-time class generation - Java/ES6 Proxy objects at runtime would be fine, but I would need a way to generate the English .properties file in the

common

(not

jvm

or

js

) module - which means I can't just use reflection to examine .class files from a Gradle plugin. I'm starting to think I need an annotation processor - but will that work in a

common

module? (Update: apparently it won't.)

ive only seen examples for multiplatform where Android is used as the app. is there an example of a multiplatform project that has android as a library? ive tried applying

com.android.library

with

kotlin-platform-jvm

which doesnt work. also there isn't a

kotlin-platform-android

. Is there something I am doing wrong here?

Hey @elizarov or any other helpful friends, I'm currently messing around with a multi-platform project and I am trying to get coroutines up and running. I have

kotlinx-corountines-core

imported through my common module and I have been successfully using it transitively in the JVM project (a little TornadoFx visualizer) to do a bit of processing off of the main thread. However, I am now trying to speed up some of the common logic and I've just started getting an unresolved reference to

kotlinx

,

runBlocking

and

launch

when compiling the common module. Is there something special I need to do in the Gradle imports to ensure that I am getting an implementation of coroutines that is compatible with Kotlin common? Some other trick that I am missing?

Hello, I was wondering if you are considering adding some warnings around when a developer includes a dependency that targets the JVM? I am currently developing a multiplatform project and chose to use Kategory to build out my core architecture, but it appears it’s a JVM only project right now. While this is fine because I am going to build out Android first, I was wondering what the future may hold for warnings and other build tooling around the detection of such things.