Patch changelog

Fix a wrong iOS target

.github/workflows/build.yml

@@ -0,0 +1,21 @@
+name: Gradle build
+
+on:
+  push:
+    branches: [ dev, master ]
+  pull_request:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    timeout-minutes: 40
+
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-java@v2.5.0
+        with:
+          java-version: 11
+          distribution: liberica
+      - uses: gradle/gradle-build-action@v2
+        with:
+          arguments: build

.github/workflows/publish.yml

@@ -0,0 +1,24 @@
+name: Gradle publish
+
+on:
+  workflow_dispatch:
+  release:
+    types: [ created ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    timeout-minutes: 40
+
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-java@v2.5.0
+        with:
+          java-version: 11
+          distribution: liberica
+      - uses: gradle/gradle-build-action@v2
+        with:
+          arguments: |
+            publishAllPublicationsToSpaceRepository
+            -Ppublishing.space.user=${{ secrets.SPACE_APP_ID }}
+            -Ppublishing.space.token=${{ secrets.SPACE_APP_SECRET }}

.space.kts

@@ -0,0 +1,43 @@
+import kotlin.io.path.readText
+
+job("Build") {
+    gradlew("openjdk:11", "build")
+}
+
+job("Publish"){
+    startOn {
+        gitPush { enabled = false }
+    }
+    container("openjdk:11") {
+        env["SPACE_USER"] = Secrets("space_user")
+        env["SPACE_TOKEN"] = Secrets("space_token")
+        kotlinScript { api ->
+
+            val spaceUser = System.getenv("SPACE_USER")
+            val spaceToken = System.getenv("SPACE_TOKEN")
+
+            // write version to the build directory
+            api.gradlew("version")
+
+            //read version from build file
+            val version = java.nio.file.Path.of("build/project-version.txt").readText()
+
+            api.space().projects.automation.deployments.start(
+                project = api.projectIdentifier(),
+                targetIdentifier = TargetIdentifier.Key("gradle-tools"),
+                version = version,
+                // automatically update deployment status based on a status of a job
+                syncWithAutomationJob = true
+            )
+            try {
+                api.gradlew(
+                    "publishAllPublicationsToSpaceRepository",
+                    "-Ppublishing.space.user=\"$spaceUser\"",
+                    "-Ppublishing.space.token=\"$spaceToken\"",
+                )
+            } catch (ex: Exception) {
+                println("Publish failed")
+            }
+        }
+    }
+}

CHANGELOG.md

@@ -0,0 +1,250 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## Unreleased
+
+### Added
+
+### Changed
+
+### Deprecated
+
+### Removed
+
+### Fixed
+
+### Security
+
+## 0.14.4-kotlin-1.8.20-RC - 2023-03-12
+
+### Added
+- Easier dependency handling in `kscience` block
+- Customizable base jdk version
+
+### Changed
+- MPP does not use JVM and JS(IR) targets anymore. They could be turned manually via `js()`, `jvm()` or `fullStack()`
+- Signing is not applied if signingId is not provided
+
+### Removed
+- FX plugins
+- Unnecessary library shortcuts (html and datetime)
+- deploy/release tasks
+
+### Fixed
+- Gradle 8 compatibility
+- Dokka publication
+- issues with test sourcesets
+
+## 0.13.4-kotlin-1.8.0 - 2022-12-31
+
+### Added
+- Public `isInDevelopment` project flag
+
+### Changed
+- Require manual pom config for publications
+- Kotlin 1.8.0
+- Versions update
+- Project group changed to `space.kscience`
+- Moved `yarn.lock` to `gradle` directory
+
+### Deprecated
+- FX configuration
+
+### Removed
+- Xjdk-release flag because it is broken until https://youtrack.jetbrains.com/issue/KT-52823
+- Use CSS loader in JS by default
+
+## 0.11.6-kotlin-1.7.0
+
+### Changed
+- Coroutines tests are applied only when explicit `useCoroutines` is used.
+
+### Removed
+- Atomicfu support inside the plugin
+
+### Fixed
+- Rollback coroutines to 1.6.1
+
+## 0.11.5-kotlin-1.7.0
+
+### Added
+- Coroutine tests as default dependency for tests
+- Context receiver flag
+
+### Changed
+- Separate release tasks for each target
+- Kotlin 1.7.0
+- Ktor 2.0.1
+- ExplicitAPI does not override existing value
+
+### Removed
+- Ktor specific artifacts from version catalog
+
+### Fixed
+- Moved signing out of sonatype block
+
+## 0.11.1-kotlin-1.6.10
+
+### Added
+- Default templates for README and ARTIFACT
+
+### Changed
+- Replaced Groovy templates by FreeMarker
+
+### Fixed
+- JS publication sources jar
+
+## 0.10.9-kotlin-1.6.10
+
+### Added
+- html builders for readme
+
+### Changed
+- Kotlin 1.6.0
+- Use indy lambdas by default #32
+- Change version scheme to `<version>-kotlin-<kotlin version>`
+
+### Fixed
+- remove `nativeMain` dependency from `nativeTest`
+
+## 0.10.4
+
+### Changed
+- Kotlin 1.6
+
+### Fixed
+- Some issues with opt-ins
+
+## 0.10.2
+
+### Added
+- Experimental automatic JS project bundling in MPP
+
+### Changed
+- Remove vcs requirement for Space publication
+
+## 0.10.0
+
+### Added
+- Lazy readme properties
+- BOM for kotlin-wrappers on JS
+- Jupyter loader
+
+### Changed
+- API validation disabled for dev versions
+- Kotlin plugins are propagated downstream
+
+### Removed
+- bson support
+
+## 0.9.5
+
+### Added
+- Disable API validation for snapshots
+- `-Xjvm-default=all` on JVM
+
+### Changed
+- `publication.platform` changed to `publishing.platform`
+- Dokka version to `1.4.30`
+- `useDateTime` in extension
+- Kotlin 1.5
+
+### Removed
+- Publish plugin. Use MavenPublish instead
+
+### Fixed
+- Removed unnecessary `afterEvaluate` for compatibility with gradle 7.0
+
+## 0.9.0
+
+### Added
+- Skip sonatype publishing for dev versions
+
+### Changed
+- Publishing repositories are explicit and defined in the top level project
+- Paths to publishing properties now use dot notation like `publishing.github.user`
+
+### Deprecated
+- Publishing plugin
+
+### Removed
+- Bintray publishing
+
+## 0.8.4
+
+### Added
+- Adaptive support for host OS in native
+- CSS support for JS targets
+
+### Changed
+- Kotlin 1.4.31
+- Coroutines 1.4.3
+
+### Fixed
+- Plugin loading order for publishing
+- Release task
+- Readme generation for multi-module project
+
+## 0.8.1
+
+### Added
+- Ktor version to versions
+- Add sonatype publishing
+- Per-platform release publishing
+
+### Changed
+- Kotlin to 1.4.30 stable.
+- Added intermediate jsCommon main/test sourcesSet for node plugin.
+- Plugin names changed to `ru.mipt.npm` package.
+- Common plugin id changed to `common`
+- Plugins group changed to `ru.mipt.npm` with `gradle` prefix
+
+### Removed
+- kaml
+
+### Fixed
+- Fix publishing load order for sonatype
+- Fix root project readme
+
+## 0.7.4
+
+### Added
+- Changelog plugin automatically applied to `project`.
+- Feature matrix and Readme generation task for a `project` plugin.
+- Add `binary-compatibility-validator` to the `project` plugin.
+- Separate `yamlKt` serialization target
+- Moved all logic to a common plugin, leaving only proxies for platform plugins
+- Suppress API validation for modules with maturity below DEVELOPMENT
+
+### Changed
+- Remove node plugin. Node binaries should be turned on manually.
+- Use default webpack distribution path.
+- `ru.mipt.npm.base` -> `ru.mipt.npm.project`.
+- Move publishing out of general extension and apply it to project plugin instead.
+- Platform plugins are now simple references to common plugin
+- FX configuration moved to extension
+- Moved internals to internals
+- Kotlin 1.4.30-RC
+
+### Deprecated
+- Support of `kaml` and `snake-yaml` in favor of `yamlKt`
+- Publish plugin
+
+### Removed
+- `useDokka` method. Documentation jar should be added manually if needed.
+
+## 0.6.0
+
+### Added
+- Migrate to kotlin 1.4.0
+- Separate Native (current platform) and nodeJs plugins.
+- Add `application()` toggle in plugin configuration to produce binaries on JS and applicaion plugin on jvm.
+- Add `publish` to expose publishing configuration.
+
+## 0.5.2
+
+### Added
+- Copy resources for jvm modules and jvm source sets in mpp.

README.md

@@ -0,0 +1,28 @@
+[![Maven Central](https://img.shields.io/maven-central/v/space.kscience.gradle.project/space.kscience.gradle.project.gradle.plugin.svg?label=Maven%20Central)](https://search.maven.org/search?q=g:%22space.kscience.gradle.project%22%20AND%20a:%22space.kscience.gradle.project.gradle.plugin%22)
+
+# KScience build tools
+
+A collection of gradle plugins for building and publish in *kscience* and *dataforge* projects.
+
+## space.kscience.gradle.common
+A primary plugin. When used with kotlin-jvm, kotlin-js or kotlin-mulitplatform configures the project for appropriate target.
+
+## space.kscience.gradle.project
+Root project tool including JetBrains changelog plugin an kotlin binary compatibility validator tool.
+
+## space.kscience.gradle.mpp
+`= kotlin("multiplatform") + space.kscience.gradle.common`
+
+Includes JVM-IR and JS-IR-Browser targets.
+
+## space.kscience.gradle.jvm
+`= kotlin("jvm") + space.kscience.gradle.common`
+
+## space.kscience.gradle.js
+`= kotlin("js") + space.kscience.gradle.common`
+
+## space.kscience.gradle.native
+add default native targets to `space.kscience.gradle.mpp`
+
+## space.kscience.gradle.node
+add node target to `space.kscience.gradle.mpp`

build.gradle.kts

@@ -1,134 +1,229 @@
-import java.util.*
-
 plugins {
+    `java-gradle-plugin`
     `kotlin-dsl`
     `maven-publish`
-    id("com.jfrog.bintray") version "1.8.4"
+    signing
+    `version-catalog`
+    alias(libs.plugins.changelog)
+    alias(libs.plugins.dokka)
 }
 
-group = "scientifik"
+group = "space.kscience"
-version = "0.1.4"
+version = libs.versions.tools.get()
+
+description = "Build tools for kotlin for science projects"
+
+changelog.version.set(project.version.toString())
 
 repositories {
+    mavenCentral()
     gradlePluginPortal()
-    jcenter()
+    maven("https://repo.kotlin.link")
-    maven("https://kotlin.bintray.com/kotlinx")
-    maven("https://dl.bintray.com/kotlin/kotlin-eap")
 }
 
-val kotlinVersion = "1.3.50-eap-5"
+kotlin.explicitApiWarning()
 
-// Add plugins used in buildSrc as dependencies, also we should specify version only here
 dependencies {
-    implementation("org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion")
+    api(libs.kotlin.gradle)
-    implementation("org.jetbrains.kotlin:kotlin-serialization:$kotlinVersion")
+    implementation(libs.binary.compatibility.validator)
-    implementation("org.jetbrains.kotlinx:kotlinx-metadata-jvm:0.1.0")
+    implementation(libs.changelog.gradle)
-    implementation("org.jetbrains.kotlinx:atomicfu-gradle-plugin:0.12.9")
+    implementation(libs.dokka.gradle)
-    implementation("org.jfrog.buildinfo:build-info-extractor-gradle:4.9.7")
+    implementation(libs.kotlin.jupyter.gradle)
-    implementation("com.jfrog.bintray.gradle:gradle-bintray-plugin:1.8.4")
+    implementation(libs.kotlin.serialization)
-    implementation("org.jetbrains.dokka:dokka-gradle-plugin:0.9.18")
+    implementation(libs.kotlinx.html)
+    implementation("org.tomlj:tomlj:1.1.0")
+//    // nexus publishing plugin
+//    implementation("io.github.gradle-nexus:publish-plugin:1.1.0")
+
+    implementation("org.freemarker:freemarker:2.3.31")
+
+    testImplementation(kotlin("test"))
 }
 
+tasks.test {
+    useJUnitPlatform()
+}
+
+//declaring exported plugins
+
 gradlePlugin {
     plugins {
-        create("scientifik-publish") {
+        create("project") {
-            id = "scientifik.publish"
+            id = "space.kscience.gradle.project"
-            description = "The publication plugin for bintray and artifactory"
+            description = "The root plugin for multi-module project infrastructure"
-            implementationClass = "scientifik.ScientifikPublishPlugin"
+            implementationClass = "space.kscience.gradle.KScienceProjectPlugin"
         }
 
-        create("scientifik-mpp") {
+        create("mpp") {
-            id = "scientifik.mpp"
+            id = "space.kscience.gradle.mpp"
             description = "Pre-configured multiplatform project"
-            implementationClass = "scientifik.ScientifikMPPlugin"
+            implementationClass = "space.kscience.gradle.KScienceMPPlugin"
         }
 
-        create("scientifik-jvm") {
+        create("jvm") {
-            id = "scientifik.jvm"
+            id = "space.kscience.gradle.jvm"
             description = "Pre-configured JVM project"
-            implementationClass = "scientifik.ScientifikJVMPlugin"
+            implementationClass = "space.kscience.gradle.KScienceJVMPlugin"
         }
 
-        create("scientifik-js") {
+        create("js") {
-            id = "scientifik.js"
+            id = "space.kscience.gradle.js"
             description = "Pre-configured JS project"
-            implementationClass = "scientifik.ScientifikJSPlugin"
+            implementationClass = "space.kscience.gradle.KScienceJSPlugin"
-        }
-
-        create("scientifik-atomic") {
-            id = "scientifik.atomic"
-            description = "Add kotlin atomic plugin to any flafor"
-            implementationClass = "scientifik.ScientifikAtomicPlugin"
         }
     }
 }
 
+tasks.create("version") {
+    group = "publishing"
+    val versionFile = project.buildDir.resolve("project-version.txt")
+    outputs.file(versionFile)
+    doLast {
+        versionFile.createNewFile()
+        versionFile.writeText(project.version.toString())
+        println(project.version)
+    }
+}
+
+//publishing version catalog
+
+catalog.versionCatalog {
+    from(files("gradle/libs.versions.toml"))
+}
+
+//publishing the artifact
+
+val sourcesJar by tasks.creating(Jar::class) {
+    archiveClassifier.set("sources")
+    from(sourceSets.named("main").get().allSource)
+}
+
+val javadocsJar by tasks.creating(Jar::class) {
+    group = JavaBasePlugin.DOCUMENTATION_GROUP
+    archiveClassifier.set("javadoc")
+    from(tasks.dokkaHtml)
+}
+
+val emptyJavadocJar by tasks.creating(Jar::class) {
+    group = JavaBasePlugin.DOCUMENTATION_GROUP
+    archiveBaseName.set("empty")
+    archiveClassifier.set("javadoc")
+}
+
+
+val emptySourcesJar by tasks.creating(Jar::class) {
+    archiveClassifier.set("sources")
+    archiveBaseName.set("empty")
+}
+
 publishing {
-    repositories {
+    val vcs = "https://github.com/mipt-npm/gradle-tools"
-        maven("https://bintray.com/mipt-npm/scientifik")
-    }
-
-    val vcs = "https://github.com/mipt-npm/scientifik-gradle-tools"
 
     // Process each publication we have in this project
-    publications.filterIsInstance<MavenPublication>().forEach { publication ->
+    publications {
+        create<MavenPublication>("catalog") {
+            from(components["versionCatalog"])
+            artifactId = "version-catalog"
 
-        @Suppress("UnstableApiUsage")
+            pom {
-        publication.pom {
+                name.set("version-catalog")
-            name.set(project.name)
-            description.set(project.description)
-            url.set(vcs)
-
-            licenses {
-                license {
-                    name.set("The Apache Software License, Version 2.0")
-                    url.set("http://www.apache.org/licenses/LICENSE-2.0.txt")
-                    distribution.set("repo")
-                }
             }
-            developers {
+        }
-                developer {
-                    id.set("MIPT-NPM")
-                    name.set("MIPT nuclear physics methods laboratory")
-                    organization.set("MIPT")
-                    organizationUrl.set("http://npm.mipt.ru")
-                }
 
-            }
+        withType<MavenPublication> {
-            scm {
+            // thanks @vladimirsitnikv for the fix
+            artifact(if (name == "catalog") emptySourcesJar else sourcesJar)
+            artifact(if (name == "catalog") emptyJavadocJar else javadocsJar)
+
+
+            pom {
+                name.set(project.name)
+                description.set(project.description)
                 url.set(vcs)
+
+                licenses {
+                    license {
+                        name.set("The Apache Software License, Version 2.0")
+                        url.set("https://www.apache.org/licenses/LICENSE-2.0.txt")
+                        distribution.set("repo")
+                    }
+                }
+
+                developers {
+                    developer {
+                        id.set("MIPT-NPM")
+                        name.set("MIPT nuclear physics methods laboratory")
+                        organization.set("MIPT")
+                        organizationUrl.set("https://npm.mipt.ru")
+                    }
+                }
+
+                scm {
+                    url.set(vcs)
+                    tag.set(project.version.toString())
+                }
             }
         }
     }
 
-    bintray {
+    val spaceRepo = "https://maven.pkg.jetbrains.space/spc/p/sci/maven"
-        user = project.findProperty("bintrayUser") as? String ?: System.getenv("BINTRAY_USER")
+    val spaceUser: String? = findProperty("publishing.space.user") as? String
-        key = project.findProperty("bintrayApiKey") as? String? ?: System.getenv("BINTRAY_API_KEY")
+    val spaceToken: String? = findProperty("publishing.space.token") as? String
-        publish = true
-        override = true // for multi-platform Kotlin/Native publishing
 
-        // We have to use delegateClosureOf because bintray supports only dynamic groovy syntax
+    if (spaceUser != null && spaceToken != null) {
-        // this is a problem of this plugin
+        project.logger.info("Adding mipt-npm Space publishing to project [${project.name}]")
-        pkg.apply {
+
-            userOrg = "mipt-npm"
+        repositories.maven {
-            repo = if (project.version.toString().contains("dev")) "dev" else "scientifik"
+            name = "space"
-            name = project.name
+            url = uri(spaceRepo)
-            issueTrackerUrl = "$vcs/issues"
+
-            setLicenses("Apache-2.0")
+            credentials {
-            vcsUrl = vcs
+                username = spaceUser
-            version.apply {
+                password = spaceToken
-                name = project.version.toString()
+            }
-                vcsTag = project.version.toString()
+        }
-                released = Date().toString()
+    }
+
+    val sonatypeUser: String? = project.findProperty("publishing.sonatype.user") as? String
+    val sonatypePassword: String? = project.findProperty("publishing.sonatype.password") as? String
+
+    if (sonatypeUser != null && sonatypePassword != null) {
+        val sonatypeRepo: String = if (project.version.toString().contains("dev")) {
+            "https://oss.sonatype.org/content/repositories/snapshots"
+        } else {
+            "https://oss.sonatype.org/service/local/staging/deploy/maven2"
+        }
+
+        repositories.maven {
+            name = "sonatype"
+            url = uri(sonatypeRepo)
+
+            credentials {
+                username = sonatypeUser
+                password = sonatypePassword
             }
         }
 
-        //workaround bintray bug
+        signing {
-        project.afterEvaluate {
+            //useGpgCmd()
-            setPublications(*project.extensions.findByType<PublishingExtension>()!!.publications.names.toTypedArray())
+            sign(publications)
         }
-
     }
 }
 
 
+kotlin {
+    jvmToolchain {
+        languageVersion.set(JavaLanguageVersion.of(11))
+    }
+}
+
+tasks.processResources.configure {
+    duplicatesStrategy = DuplicatesStrategy.INCLUDE
+    from("gradle/libs.versions.toml")
+}
+
+// Workaround for https://github.com/gradle/gradle/issues/15568
+tasks.withType<AbstractPublishToMaven>().configureEach {
+    mustRunAfter(tasks.withType<Sign>())
+}

gradle.properties

@@ -0,0 +1 @@
+kotlin.code.style=official

gradle/libs.versions.toml

@@ -0,0 +1,116 @@
+[versions]
+tools = "0.14.4-kotlin-1.8.20-RC"
+kotlin = "1.8.20-RC"
+atomicfu = "0.19.0"
+binary-compatibility-validator = "0.12.1"
+changelog = "2.0.0"
+dokka = "1.7.20"
+kotlin-jupyter = "0.11.0-317"
+kotlinx-benchmark = "0.4.7"
+kotlinx-cli = "0.3.5"
+kotlinx-coroutines = "1.6.4"
+kotlinx-datetime = "0.4.0"
+kotlinx-html = "0.8.0"
+kotlinx-knit = "0.4.0"
+kotlinx-nodejs = "0.0.7"
+kotlinx-serialization = "1.4.1"
+ktor = "2.2.3"
+xmlutil = "0.84.3"
+yamlkt = "0.12.0"
+jsBom = "1.0.0-pre.509"
+junit = "5.9.2"
+compose = "1.3.0"
+logback = "1.4.5"
+
+[libraries]
+atomicfu-gradle = { module = "org.jetbrains.kotlinx:atomicfu-gradle-plugin", version.ref = "atomicfu" }
+atomicfu = { module = "org.jetbrains.kotlinx:atomicfu", version.ref = "atomicfu" }
+
+binary-compatibility-validator = { module = "org.jetbrains.kotlinx:binary-compatibility-validator", version.ref = "binary-compatibility-validator" }
+
+changelog-gradle = { module = "org.jetbrains.intellij.plugins:gradle-changelog-plugin", version.ref = "changelog" }
+
+dokka-gradle = { module = "org.jetbrains.dokka:dokka-gradle-plugin", version.ref = "dokka" }
+
+kotlin-gradle = { module = "org.jetbrains.kotlin:kotlin-gradle-plugin", version.ref = "kotlin" }
+kotlin-serialization = { module = "org.jetbrains.kotlin:kotlin-serialization", version.ref = "kotlin" }
+
+kotlin-jupyter-gradle = { module = "org.jetbrains.kotlin:kotlin-jupyter-api-gradle-plugin", version.ref = "kotlin-jupyter" }
+
+kotlinx-benchmark-runtime = { module = "org.jetbrains.kotlinx:kotlinx-benchmark-runtime", version.ref = "kotlinx-benchmark" }
+
+kotlinx-coroutines-core = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "kotlinx-coroutines" }
+kotlinx-coroutines-test = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-test", version.ref = "kotlinx-coroutines" }
+kotlinx-coroutines-debug = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-debug", version.ref = "kotlinx-coroutines" }
+kotlinx-coroutines-reactive = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-reactive", version.ref = "kotlinx-coroutines" }
+kotlinx-coroutines-reactor = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-reactor", version.ref = "kotlinx-coroutines" }
+kotlinx-coroutines-rx2 = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-rx2", version.ref = "kotlinx-coroutines" }
+kotlinx-coroutines-rx3 = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-rx3", version.ref = "kotlinx-coroutines" }
+kotlinx-coroutines-android = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-android", version.ref = "kotlinx-coroutines" }
+kotlinx-coroutines-javafx = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-javafx", version.ref = "kotlinx-coroutines" }
+kotlinx-coroutines-swing = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-swing", version.ref = "kotlinx-coroutines" }
+kotlinx-coroutines-jdk8 = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-jdk8", version.ref = "kotlinx-coroutines" }
+kotlinx-coroutines-guava = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-guava", version.ref = "kotlinx-coroutines" }
+kotlinx-coroutines-slf4j = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-slf4j", version.ref = "kotlinx-coroutines" }
+kotlinx-coroutines-play-services = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-play-services", version.ref = "kotlinx-coroutines" }
+
+kotlinx-cli = { module = "org.jetbrains.kotlinx:kotlinx-cli", version.ref = "kotlinx-cli" }
+
+kotlinx-datetime = { module = "org.jetbrains.kotlinx:kotlinx-datetime", version.ref = "kotlinx-datetime" }
+
+kotlinx-html = { module = "org.jetbrains.kotlinx:kotlinx-html", version.ref = "kotlinx-html" }
+
+kotlinx-knit = { module = "org.jetbrains.kotlinx:kotlinx-knit", version.ref = "kotlinx-knit" }
+
+kotlinx-nodejs = { module = "org.jetbrains.kotlinx:kotlinx-nodejs", version.ref = "kotlinx-nodejs" }
+
+kotlinx-serialization-cbor = { module = "org.jetbrains.kotlinx:kotlinx-serialization-cbor", version.ref = "kotlinx-serialization" }
+kotlinx-serialization-core = { module = "org.jetbrains.kotlinx:kotlinx-serialization-core", version.ref = "kotlinx-serialization" }
+kotlinx-serialization-hocon = { module = "org.jetbrains.kotlinx:kotlinx-serialization-hocon", version.ref = "kotlinx-serialization" }
+kotlinx-serialization-json = { module = "org.jetbrains.kotlinx:kotlinx-serialization-json", version.ref = "kotlinx-serialization" }
+kotlinx-serialization-protobuf = { module = "org.jetbrains.kotlinx:kotlinx-serialization-protobuf", version.ref = "kotlinx-serialization" }
+kotlinx-serialization-properties = { module = "org.jetbrains.kotlinx:kotlinx-serialization-properties", version.ref = "kotlinx-serialization" }
+
+ktor-bom = { module = "io.ktor:ktor-bom", version.ref = "ktor" }
+
+xmlutil-core = { module = "io.github.pdvrieze.xmlutil:core", version.ref = "xmlutil" }
+xmlutil-ktor = { module = "io.github.pdvrieze.xmlutil:ktor", version.ref = "xmlutil" }
+xmlutil-serialization = { module = "io.github.pdvrieze.xmlutil:serialization", version.ref = "xmlutil" }
+
+yamlkt = { module = "net.mamoe.yamlkt:yamlkt", version.ref = "yamlkt" }
+
+logback-classic = {module = "ch.qos.logback:logback-classic", version.ref = "logback"}
+
+[plugins]
+changelog = { id = "org.jetbrains.changelog", version.ref = "changelog" }
+
+dokka = { id = "org.jetbrains.dokka", version.ref = "dokka" }
+compose = {id = "org.jetbrains.compose", version.ref = "compose"}
+
+gradle-common = { id = "space.kscience.gradle.common", version.ref = "tools" }
+gradle-project = { id = "space.kscience.gradle.project", version.ref = "tools" }
+gradle-mpp = { id = "space.kscience.gradle.mpp", version.ref = "tools" }
+gradle-jvm = { id = "space.kscience.gradle.jvm", version.ref = "tools" }
+gradle-js = { id = "space.kscience.gradle.js", version.ref = "tools" }
+gradle-native = { id = "space.kscience.gradle.native", version.ref = "tools" }
+gradle-node = { id = "space.kscience.gradle.node", version.ref = "tools" }
+
+kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }
+kotlin-android-extensions = { id = "org.jetbrains.kotlin.android.extensions", version.ref = "kotlin" }
+kotlin-js = { id = "org.jetbrains.kotlin.js", version.ref = "kotlin" }
+kotlin-jvm = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlin" }
+kotlin-kapt = { id = "org.jetbrains.kotlin.kapt", version.ref = "kotlin" }
+kotlin-multiplatform = { id = "org.jetbrains.kotlin.multiplatform", version.ref = "kotlin" }
+kotlin-native-cocoapods = { id = "org.jetbrains.kotlin.native.cocoapods", version.ref = "kotlin" }
+kotlin-plugin-allopen = { id = "org.jetbrains.kotlin.plugin.allopen", version.ref = "kotlin" }
+kotlin-plugin-jpa = { id = "org.jetbrains.kotlin.plugin.jpa", version.ref = "kotlin" }
+kotlin-plugin-lombok = { id = "org.jetbrains.kotlin.plugin.lombok", version.ref = "kotlin" }
+kotlin-plugin-noarg = { id = "org.jetbrains.kotlin.plugin.noarg", version.ref = "kotlin" }
+kotlin-plugin-parcelize = { id = "org.jetbrains.kotlin.plugin.parcelize", version.ref = "kotlin" }
+kotlin-plugin-scripting = { id = "org.jetbrains.kotlin.plugin.scripting", version.ref = "kotlin" }
+kotlin-plugin-serialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" }
+kotlin-plugin-spring = { id = "org.jetbrains.kotlin.plugin.spring", version.ref = "kotlin" }
+
+kotlin-jupyter-api = { id = "org.jetbrains.kotlin.jupyter.api", version.ref = "kotlin-jupyter" }
+
+kotlinx-benchmark = { id = "org.jetbrains.kotlinx.benchmark", version.ref = "kotlinx-benchmark" }

gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,5 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.0.2-bin.zip
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists

gradlew

@@ -0,0 +1,234 @@
+#!/bin/sh
+
+#
+# Copyright © 2015-2021 the original authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+##############################################################################
+#
+#   Gradle start up script for POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/master/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
+##############################################################################
+
+# Attempt to set APP_HOME
+
+# Resolve links: $0 may be a link
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
+done
+
+APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
+
+APP_NAME="Gradle"
+APP_BASE_NAME=${0##*/}
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD=maximum
+
+warn () {
+    echo "$*"
+} >&2
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+} >&2
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=true ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD=$JAVA_HOME/jre/sh/java
+    else
+        JAVACMD=$JAVA_HOME/bin/java
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD=java
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+    case $MAX_FD in #(
+      max*)
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
+    esac
+fi
+
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
+
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
+
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
+        fi
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
+    done
+fi
+
+# Collect all arguments for the java command;
+#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
+#     shell script including quotes and variable substitutions, so put them in
+#     double quotes to make sure that they get re-expanded; and
+#   * put everything else in single quotes, so that it's not re-expanded.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -classpath "$CLASSPATH" \
+        org.gradle.wrapper.GradleWrapperMain \
+        "$@"
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
+
+exec "$JAVACMD" "$@"

gradlew.bat

@@ -0,0 +1,89 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto execute
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto execute
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

settings.gradle

@@ -1,2 +0,0 @@
-rootProject.name = 'gradle-tools'
-

settings.gradle.kts

@@ -0,0 +1 @@
+rootProject.name = "gradle-tools"

src/main/kotlin/Scientifik.kt

@@ -1,9 +0,0 @@
-/**
- * Build constants
- */
-object Scientifik {
-    const val ioVersion = "0.1.13"
-    const val coroutinesVersion = "1.2.2"
-    const val atomicfuVersion = "0.12.9"
-    const val serializationVersion = "0.11.1"
-}

src/main/kotlin/scientifik/ScientifikAtomicPlugin.kt

@@ -1,68 +0,0 @@
-package scientifik
-
-import Scientifik
-import org.gradle.api.Plugin
-import org.gradle.api.Project
-import org.gradle.kotlin.dsl.*
-import org.jetbrains.kotlin.gradle.dsl.KotlinJsProjectExtension
-import org.jetbrains.kotlin.gradle.dsl.KotlinJvmProjectExtension
-import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
-
-class ScientifikAtomicPlugin : Plugin<Project> {
-    override fun apply(target: Project) {
-        with(target) {
-            plugins.apply("kotlinx-atomicfu")
-
-            pluginManager.withPlugin("org.jetbrains.kotlin.multiplatform") {
-                project.configure<KotlinMultiplatformExtension> {
-                    sourceSets.invoke {
-                        val commonMain by getting {
-                            dependencies {
-                                implementation("org.jetbrains.kotlinx:atomicfu-common:${Scientifik.atomicfuVersion}")
-                            }
-                        }
-
-                        val jvmMain by getting {
-                            dependencies {
-                                implementation("org.jetbrains.kotlinx:atomicfu:${Scientifik.atomicfuVersion}")
-                            }
-                        }
-                        val jsMain by getting {
-                            dependencies {
-                                implementation("org.jetbrains.kotlinx:atomicfu-common-js:${Scientifik.atomicfuVersion}")
-                            }
-                        }
-                        val jsTest by getting {
-                            dependencies {
-                                implementation(kotlin("test-js"))
-                            }
-                        }
-                    }
-                }
-                //TODO add native clause
-            }
-
-            pluginManager.withPlugin("org.jetbrains.kotlin.jvm") {
-                configure<KotlinJvmProjectExtension> {
-                    sourceSets["main"].apply {
-                        dependencies {
-                            implementation("org.jetbrains.kotlinx:atomicfu:${Scientifik.atomicfuVersion}")
-                        }
-                    }
-                }
-            }
-
-            pluginManager.withPlugin("org.jetbrains.kotlin.js") {
-                configure<KotlinJsProjectExtension> {
-                    sourceSets["main"].apply {
-                        dependencies {
-                            implementation("org.jetbrains.kotlinx:atomicfu-js:${Scientifik.atomicfuVersion}")
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
-
-

src/main/kotlin/scientifik/ScientifikExtension.kt

@@ -1,17 +0,0 @@
-package scientifik
-
-import org.gradle.api.Project
-import org.gradle.kotlin.dsl.create
-import org.gradle.kotlin.dsl.findByType
-
-open class ScientifikExtension {
-    var githubProject: String? = null
-    var vcs: String? = null
-    var bintrayRepo: String? = null
-    var kdoc: Boolean = true
-    var serialization = false
-    var io = false
-}
-
-internal val Project.scientifik: ScientifikExtension
-    get() = extensions.findByType() ?: extensions.create("scientifik")

src/main/kotlin/scientifik/ScientifikJSPlugin.kt

@@ -1,77 +0,0 @@
-package scientifik
-
-import Scientifik
-import org.gradle.api.Plugin
-import org.gradle.api.Project
-import org.gradle.api.tasks.Copy
-import org.gradle.kotlin.dsl.*
-import org.jetbrains.kotlin.gradle.dsl.KotlinJsProjectExtension
-import org.jetbrains.kotlin.gradle.targets.js.webpack.KotlinWebpack
-import java.io.File
-
-open class ScientifikJSPlugin : Plugin<Project> {
-    override fun apply(project: Project) {
-        val extension = project.scientifik
-
-        with(project) {
-            plugins.apply("org.jetbrains.kotlin.js")
-            plugins.apply("kotlinx-serialization")
-            plugins.apply("kotlinx-atomicfu")
-
-
-            repositories.applyRepos()
-
-            configure<KotlinJsProjectExtension> {
-                target {
-                    browser()
-                }
-                sourceSets["main"].apply {
-                    languageSettings.applySettings()
-
-                    dependencies {
-                        api(kotlin("stdlib-jdk8"))
-                        afterEvaluate {
-                            if (extension.serialization) {
-                                implementation("org.jetbrains.kotlinx:kotlinx-serialization-runtime:${Scientifik.serializationVersion}")
-                            }
-                            if (extension.io) {
-                                api("org.jetbrains.kotlinx:kotlinx-io-js:${Scientifik.ioVersion}")
-                            }
-                        }
-                    }
-                }
-            }
-
-            tasks.apply {
-                val browserWebpack by getting(KotlinWebpack::class) {
-                    afterEvaluate {
-                        val destination = listOf(archiveBaseName, archiveAppendix, archiveVersion, archiveClassifier)
-                            .filter { it != null && it.isNotBlank() }
-                            .joinToString("-")
-                        destinationDirectory = destinationDirectory?.resolve(destination)
-                    }
-                    archiveFileName = "main.bundle.js"
-                }
-
-                afterEvaluate {
-                    val installJsDist by creating(Copy::class) {
-                        group = "distribution"
-                        dependsOn(browserWebpack)
-                        from(fileTree("src/main/web"))
-                        into(browserWebpack.destinationDirectory!!)
-                        doLast{
-                            val indexFile = File(browserWebpack.destinationDirectory!!,"index.html")
-                            if(indexFile.exists()){
-                                println("Run JS distribution at: ${indexFile.canonicalPath}")
-                            }
-                        }
-                    }
-
-                    findByName("assemble")?.dependsOn(installJsDist)
-
-                }
-            }
-        }
-
-    }
-}

src/main/kotlin/scientifik/ScientifikJVMPlugin.kt

@@ -1,48 +0,0 @@
-package scientifik
-
-import Scientifik
-import org.gradle.api.Plugin
-import org.gradle.api.Project
-import org.gradle.kotlin.dsl.configure
-import org.gradle.kotlin.dsl.get
-import org.gradle.kotlin.dsl.withType
-import org.jetbrains.kotlin.gradle.dsl.KotlinJvmProjectExtension
-import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
-
-open class ScientifikJVMPlugin : Plugin<Project> {
-    override fun apply(project: Project) {
-        val extension = project.scientifik
-
-        with(project) {
-            plugins.apply("org.jetbrains.kotlin.jvm")
-            plugins.apply("kotlinx-serialization")
-
-            repositories.applyRepos()
-
-            tasks.withType<KotlinCompile> {
-                kotlinOptions {
-                    jvmTarget = "1.8"
-                }
-            }
-
-            configure<KotlinJvmProjectExtension> {
-                sourceSets["main"].apply {
-                    languageSettings.applySettings()
-
-                    dependencies {
-                        api(kotlin("stdlib-jdk8"))
-                        afterEvaluate {
-                            if (extension.serialization) {
-                                implementation("org.jetbrains.kotlinx:kotlinx-serialization-runtime:${Scientifik.serializationVersion}")
-                            }
-                            if (extension.io) {
-                                api("org.jetbrains.kotlinx:kotlinx-io-jvm:${Scientifik.ioVersion}")
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
-    }
-}

src/main/kotlin/scientifik/ScientifikMPPlugin.kt

@@ -1,134 +0,0 @@
-package scientifik
-
-import Scientifik
-import org.gradle.api.Plugin
-import org.gradle.api.Project
-import org.gradle.api.tasks.Copy
-import org.gradle.kotlin.dsl.*
-import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
-import org.jetbrains.kotlin.gradle.targets.js.webpack.KotlinWebpack
-import java.io.File
-
-open class ScientifikMPPlugin : Plugin<Project> {
-    override fun apply(project: Project) {
-        val extension = project.scientifik
-
-        project.plugins.apply("org.jetbrains.kotlin.multiplatform")
-        project.plugins.apply("kotlinx-serialization")
-
-        project.repositories.applyRepos()
-
-        project.configure<KotlinMultiplatformExtension> {
-            jvm {
-                compilations.all {
-                    kotlinOptions {
-                        jvmTarget = "1.8"
-                    }
-                }
-            }
-
-            js {
-                browser {}
-            }
-
-
-            sourceSets.invoke {
-                val commonMain by getting {
-                    dependencies {
-                        api(kotlin("stdlib"))
-                        project.afterEvaluate {
-                            if (extension.serialization) {
-                                implementation("org.jetbrains.kotlinx:kotlinx-serialization-runtime-common:${Scientifik.serializationVersion}")
-                            }
-                            if(extension.io){
-                                api("org.jetbrains.kotlinx:kotlinx-io:${Scientifik.ioVersion}")
-                            }
-                        }
-                    }
-                }
-                val commonTest by getting {
-                    dependencies {
-                        implementation(kotlin("test-common"))
-                        implementation(kotlin("test-annotations-common"))
-                    }
-                }
-                val jvmMain by getting {
-                    dependencies {
-                        api(kotlin("stdlib-jdk8"))
-                        project.afterEvaluate {
-                            if (extension.serialization) {
-                                implementation("org.jetbrains.kotlinx:kotlinx-serialization-runtime:${Scientifik.serializationVersion}")
-                            }
-
-                            if (extension.io) {
-                                api("org.jetbrains.kotlinx:kotlinx-io-jvm:${Scientifik.ioVersion}")
-                            }
-                        }
-                    }
-                }
-                val jvmTest by getting {
-                    dependencies {
-                        implementation(kotlin("test"))
-                        implementation(kotlin("test-junit"))
-                    }
-                }
-                val jsMain by getting {
-                    dependencies {
-                        api(kotlin("stdlib-js"))
-                        project.afterEvaluate {
-                            if (extension.serialization) {
-                                implementation("org.jetbrains.kotlinx:kotlinx-serialization-runtime-js:${Scientifik.serializationVersion}")
-                            }
-
-                            if (extension.io) {
-                                api("org.jetbrains.kotlinx:kotlinx-io-js:${Scientifik.ioVersion}")
-                            }
-                        }
-                    }
-                }
-                val jsTest by getting {
-                    dependencies {
-                        implementation(kotlin("test-js"))
-                    }
-                }
-            }
-
-            targets.all {
-                sourceSets.all {
-                    languageSettings.applySettings()
-                }
-            }
-        }
-
-        project.tasks.apply {
-            val jsBrowserWebpack by getting(KotlinWebpack::class) {
-                archiveClassifier = "js"
-                project.afterEvaluate {
-                    val destination = listOf(archiveBaseName, archiveAppendix, archiveVersion, archiveClassifier)
-                        .filter { it != null && it.isNotBlank() }
-                        .joinToString("-")
-                    destinationDirectory = destinationDirectory?.resolve(destination)
-                }
-                archiveFileName = "main.bundle.js"
-            }
-
-            project.afterEvaluate {
-                val installJsDist by creating(Copy::class) {
-                    group = "distribution"
-                    dependsOn(jsBrowserWebpack)
-                    from(project.fileTree("src/jsMain/web"))
-                    into(jsBrowserWebpack.destinationDirectory!!)
-                    doLast{
-                        val indexFile = File(jsBrowserWebpack.destinationDirectory!!,"index.html")
-                        if(indexFile.exists()){
-                            println("Run JS distribution at: ${indexFile.canonicalPath}")
-                        }
-                    }
-                }
-
-                findByName("assemble")?.dependsOn(installJsDist)
-            }
-        }
-
-    }
-}

src/main/kotlin/scientifik/ScientifikNativePlugin.kt

@@ -1,40 +0,0 @@
-package scientifik
-
-import org.gradle.api.Plugin
-import org.gradle.api.Project
-import org.gradle.kotlin.dsl.*
-import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
-
-class ScientifikNativePlugin : Plugin<Project> {
-    override fun apply(target: Project) {
-        target.pluginManager.withPlugin("org.jetbrains.kotlin.multiplatform") {
-            target.configure<KotlinMultiplatformExtension> {
-                linuxX64()
-                mingwX64()
-
-                sourceSets.apply {
-                    val commonMain by getting {}
-
-                    val native by creating {
-                        dependsOn(commonMain)
-
-                        dependencies {
-                            //TODO add stdlib here
-                            target.afterEvaluate {
-                                //TODO add optional libraries here
-                            }
-                        }
-                    }
-
-                    mingwX64().compilations["main"].defaultSourceSet {
-                        dependsOn(native)
-                    }
-
-                    linuxX64().compilations["main"].defaultSourceSet {
-                        dependsOn(native)
-                    }
-                }
-            }
-        }
-    }
-}

src/main/kotlin/scientifik/ScientifikPublishPlugin.kt

@@ -1,293 +0,0 @@
-package scientifik
-
-import com.jfrog.bintray.gradle.BintrayExtension
-import com.jfrog.bintray.gradle.tasks.BintrayUploadTask
-import groovy.lang.GroovyObject
-import org.gradle.api.Plugin
-import org.gradle.api.Project
-import org.gradle.api.plugins.JavaBasePlugin
-import org.gradle.api.publish.PublishingExtension
-import org.gradle.api.publish.maven.MavenPublication
-import org.gradle.api.publish.maven.internal.artifact.FileBasedMavenArtifact
-import org.gradle.api.publish.maven.tasks.PublishToMavenRepository
-import org.gradle.api.tasks.bundling.Jar
-import org.gradle.kotlin.dsl.*
-import org.jetbrains.dokka.gradle.DokkaTask
-import org.jetbrains.kotlin.gradle.dsl.KotlinJvmProjectExtension
-import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
-import org.jfrog.gradle.plugin.artifactory.dsl.ArtifactoryPluginConvention
-import org.jfrog.gradle.plugin.artifactory.dsl.PublisherConfig
-import org.jfrog.gradle.plugin.artifactory.dsl.ResolverConfig
-import org.jfrog.gradle.plugin.artifactory.task.ArtifactoryTask
-
-
-// recursively search up the project chain for configuration
-private val Project.bintrayRepo: String?
-    get() = extensions.findByType<ScientifikExtension>()?.bintrayRepo
-        ?: parent?.bintrayRepo
-        ?: (findProperty("bintrayRepo") as? String)
-
-private val Project.githubProject: String?
-    get() = extensions.findByType<ScientifikExtension>()?.githubProject
-        ?: parent?.githubProject
-        ?: (findProperty("githubProject") as? String)
-
-private val Project.vcs: String?
-    get() = extensions.findByType<ScientifikExtension>()?.vcs
-        ?: parent?.vcs
-        ?: (findProperty("vcs") as? String)
-        ?: githubProject?.let { "https://github.com/mipt-npm/$it" }
-
-open class ScientifikPublishPlugin : Plugin<Project> {
-
-    override fun apply(project: Project) {
-
-        project.plugins.apply("maven-publish")
-        val extension = project.scientifik
-
-        project.afterEvaluate {
-
-            if (extension.kdoc) {
-                project.plugins.apply("org.jetbrains.dokka")
-            }
-
-            val bintrayRepo = if (project.version.toString().contains("dev")) {
-                "dev"
-            } else {
-                project.bintrayRepo
-            }
-
-            val vcs = project.vcs
-
-            if (vcs == null) {
-                project.logger.warn("[${project.name}] Missing deployment configuration. Skipping publish.")
-                return@afterEvaluate
-            }
-
-            project.plugins.apply("com.jfrog.bintray")
-            project.plugins.apply("com.jfrog.artifactory")
-
-            project.configure<PublishingExtension> {
-                // Process each publication we have in this project
-                publications.filterIsInstance<MavenPublication>().forEach { publication ->
-
-                    @Suppress("UnstableApiUsage")
-                    publication.pom {
-                        name.set(project.name)
-                        description.set(project.description)
-                        url.set(vcs)
-
-                        licenses {
-                            license {
-                                name.set("The Apache Software License, Version 2.0")
-                                url.set("http://www.apache.org/licenses/LICENSE-2.0.txt")
-                                distribution.set("repo")
-                            }
-                        }
-                        developers {
-                            developer {
-                                id.set("MIPT-NPM")
-                                name.set("MIPT nuclear physics methods laboratory")
-                                organization.set("MIPT")
-                                organizationUrl.set("http://npm.mipt.ru")
-                            }
-
-                        }
-                        scm {
-                            url.set(vcs)
-                        }
-                    }
-                }
-
-                val githubUser: String? by project
-                val githubToken: String? by project
-
-                val githubProject = project.githubProject
-
-                if (githubProject != null && githubUser != null && githubToken != null) {
-                    repositories {
-                        val repository = maven {
-                            name = "github"
-                            url = uri("https://maven.pkg.github.com/mipt-npm/$githubProject/")
-                            credentials {
-                                username = githubUser
-                                password = githubToken
-                            }
-                        }
-
-                        val githubPublishTasks = publications.filterIsInstance<MavenPublication>().map { publication ->
-                            tasks.register<PublishToMavenRepository>("publish${publication.name.capitalize()}ToGithub") {
-                                group = "publishing"
-                                this.publication = publication
-                                this.repository = repository
-                            }
-                        }
-
-                        tasks.register<PublishToMavenRepository>("publishToGithub") {
-                            group = "publishing"
-                            dependsOn(githubPublishTasks)
-                        }
-
-                    }
-                }
-            }
-
-            if (extension.kdoc) {
-
-                extensions.findByType<KotlinMultiplatformExtension>()?.apply {
-                    val dokka by tasks.getting(DokkaTask::class) {
-                        outputFormat = "html"
-                        outputDirectory = "$buildDir/javadoc"
-                        jdkVersion = 8
-
-                        kotlinTasks {
-                            // dokka fails to retrieve sources from MPP-tasks so we only define the jvm task
-                            listOf(tasks.getByPath("compileKotlinJvm"))
-                        }
-                        sourceRoot {
-                            // assuming only single source dir
-                            path = sourceSets["commonMain"].kotlin.srcDirs.first().toString()
-                            platforms = listOf("Common")
-                        }
-                        // although the JVM sources are now taken from the task,
-                        // we still define the jvm source root to get the JVM marker in the generated html
-                        sourceRoot {
-                            // assuming only single source dir
-                            path = sourceSets["jvmMain"].kotlin.srcDirs.first().toString()
-                            platforms = listOf("JVM")
-                        }
-
-                    }
-
-                    val kdocJar by tasks.registering(Jar::class) {
-                        group = JavaBasePlugin.DOCUMENTATION_GROUP
-                        dependsOn(dokka)
-                        archiveClassifier.set("javadoc")
-                        from("$buildDir/javadoc")
-                    }
-
-                    configure<PublishingExtension> {
-
-                        targets.all {
-                            val publication = publications.findByName(name) as MavenPublication
-
-                            // Patch publications with fake javadoc
-                            publication.artifact(kdocJar.get())
-                        }
-
-                        tasks.filter { it is ArtifactoryTask || it is BintrayUploadTask }.forEach {
-                            it.doFirst {
-                                publications.filterIsInstance<MavenPublication>()
-                                    .forEach { publication ->
-                                        val moduleFile =
-                                            buildDir.resolve("publications/${publication.name}/module.json")
-                                        if (moduleFile.exists()) {
-                                            publication.artifact(object : FileBasedMavenArtifact(moduleFile) {
-                                                override fun getDefaultExtension() = "module"
-                                            })
-                                        }
-                                    }
-                            }
-                        }
-                    }
-                }
-
-
-                extensions.findByType<KotlinJvmProjectExtension>()?.apply {
-
-                    val sourcesJar by tasks.registering(Jar::class) {
-                        archiveClassifier.set("sources")
-                        from(sourceSets["main"].kotlin.srcDirs.first())
-                    }
-
-                    val dokka by tasks.getting(DokkaTask::class) {
-                        outputFormat = "html"
-                        outputDirectory = "$buildDir/javadoc"
-                        jdkVersion = 8
-                    }
-
-                    val kdocJar by tasks.registering(Jar::class) {
-                        group = JavaBasePlugin.DOCUMENTATION_GROUP
-                        dependsOn(dokka)
-                        archiveClassifier.set("javadoc")
-                        from("$buildDir/javadoc")
-                    }
-
-                    configure<PublishingExtension> {
-                        publications {
-                            register("jvm", MavenPublication::class) {
-                                from(components["java"])
-                                artifact(sourcesJar.get())
-                                artifact(kdocJar.get())
-                            }
-                        }
-                    }
-                }
-
-            }
-
-            project.configure<ArtifactoryPluginConvention> {
-                val artifactoryUser: String? by project
-                val artifactoryPassword: String? by project
-                val artifactoryContextUrl = "http://npm.mipt.ru:8081/artifactory"
-
-                setContextUrl(artifactoryContextUrl)//The base Artifactory URL if not overridden by the publisher/resolver
-                publish(delegateClosureOf<PublisherConfig> {
-                    repository(delegateClosureOf<GroovyObject> {
-                        setProperty("repoKey", "gradle-dev-local")
-                        setProperty("username", artifactoryUser)
-                        setProperty("password", artifactoryPassword)
-                    })
-
-                    defaults(delegateClosureOf<GroovyObject> {
-                        invokeMethod("publications", arrayOf("jvm", "js", "kotlinMultiplatform", "metadata"))
-                    })
-                })
-                resolve(delegateClosureOf<ResolverConfig> {
-                    repository(delegateClosureOf<GroovyObject> {
-                        setProperty("repoKey", "gradle-dev")
-                        setProperty("username", artifactoryUser)
-                        setProperty("password", artifactoryPassword)
-                    })
-                })
-            }
-
-            if (bintrayRepo == null) {
-                project.logger.warn("[${project.name}] Bintray repository not defined")
-            } else {
-
-                project.configure<PublishingExtension> {
-                    repositories {
-                        maven("https://bintray.com/mipt-npm/$bintrayRepo")
-                    }
-                }
-
-                project.configure<BintrayExtension> {
-                    user = project.findProperty("bintrayUser") as? String?
-                    key = project.findProperty("bintrayApiKey") as? String?
-                    publish = true
-                    override = true
-
-                    // We have to use delegateClosureOf because bintray supports only dynamic groovy syntax
-                    // this is a problem of this plugin
-                    pkg.apply {
-                        userOrg = "mipt-npm"
-                        repo = bintrayRepo
-                        name = project.name
-                        issueTrackerUrl = "$vcs/issues"
-                        setLicenses("Apache-2.0")
-                        vcsUrl = vcs
-                        version.apply {
-                            name = project.version.toString()
-                            vcsTag = project.version.toString()
-                            released = java.util.Date().toString()
-                        }
-                    }
-
-                    //workaround bintray bug
-                    setPublications(*project.extensions.findByType<PublishingExtension>()!!.publications.names.toTypedArray())
-                }
-            }
-        }
-    }
-}

src/main/kotlin/scientifik/common.kt

@@ -1,20 +0,0 @@
-package scientifik
-
-import org.gradle.api.artifacts.dsl.RepositoryHandler
-import org.gradle.kotlin.dsl.maven
-import org.jetbrains.kotlin.gradle.plugin.LanguageSettingsBuilder
-
-internal fun LanguageSettingsBuilder.applySettings(): Unit {
-    progressiveMode = true
-    enableLanguageFeature("InlineClasses")
-    useExperimentalAnnotation("kotlin.ExperimentalUnsignedType")
-}
-
-internal fun RepositoryHandler.applyRepos(): Unit{
-    mavenCentral()
-    jcenter()
-    maven("https://dl.bintray.com/kotlin/kotlin-eap")
-    maven("https://kotlin.bintray.com/kotlinx")
-    maven("https://dl.bintray.com/mipt-npm/scientifik")
-    maven("https://dl.bintray.com/mipt-npm/dev")
-}

src/main/kotlin/space/kscience/gradle/KScienceExtension.kt

@@ -0,0 +1,548 @@
+package space.kscience.gradle
+
+import org.gradle.api.Project
+import org.gradle.api.file.DuplicatesStrategy
+import org.gradle.api.plugins.ApplicationPlugin
+import org.gradle.api.provider.Property
+import org.gradle.api.tasks.Copy
+import org.gradle.api.tasks.testing.Test
+import org.gradle.jvm.toolchain.JavaLanguageVersion
+import org.gradle.kotlin.dsl.*
+import org.gradle.language.jvm.tasks.ProcessResources
+import org.jetbrains.kotlin.gradle.dsl.KotlinJsProjectExtension
+import org.jetbrains.kotlin.gradle.dsl.KotlinJvmProjectExtension
+import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
+import org.jetbrains.kotlin.gradle.dsl.KotlinProjectExtension
+import org.jetbrains.kotlin.gradle.plugin.KotlinDependencyHandler
+import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinNativeTarget
+import org.jetbrains.kotlin.gradle.targets.js.dsl.ExperimentalWasmDsl
+import org.jetbrains.kotlin.gradle.targets.js.dsl.KotlinJsBrowserDsl
+import org.jetbrains.kotlin.gradle.targets.js.dsl.KotlinJsTargetDsl
+import org.jetbrains.kotlin.gradle.targets.js.dsl.KotlinWasmTargetDsl
+import org.jetbrains.kotlin.gradle.targets.jvm.KotlinJvmTarget
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+import org.jetbrains.kotlinx.jupyter.api.plugin.tasks.JupyterApiResourcesTask
+import space.kscience.gradle.internal.defaultKotlinJvmArgs
+import space.kscience.gradle.internal.fromJsDependencies
+import space.kscience.gradle.internal.useCommonDependency
+
+public enum class DependencyConfiguration {
+    API,
+    IMPLEMENTATION,
+    COMPILE_ONLY,
+}
+
+public enum class DependencySourceSet(public val setName: String, public val suffix: String) {
+    MAIN("main", "Main"),
+    TEST("test", "Test")
+}
+
+
+/**
+ * Check if this project version has a development tag (`development` property to true, "dev" in the middle or "SNAPSHOT" in the end).
+ */
+public val Project.isInDevelopment: Boolean
+    get() = findProperty("development") == true
+            || "dev" in version.toString()
+            || version.toString().endsWith("SNAPSHOT")
+
+
+private const val defaultJdkVersion = 11
+
+public open class KScienceExtension(public val project: Project) {
+
+    public val jdkVersionProperty: Property<Int> = project.objects.property<Int>().apply {
+        set(defaultJdkVersion)
+    }
+
+    public var jdkVersion: Int by jdkVersionProperty
+
+    /**
+     * Use coroutines-core with default version or [version]
+     */
+    public fun useCoroutines(
+        version: String = KScienceVersions.coroutinesVersion,
+        sourceSet: DependencySourceSet = DependencySourceSet.MAIN,
+        configuration: DependencyConfiguration = DependencyConfiguration.API,
+    ) {
+        project.useCommonDependency(
+            "org.jetbrains.kotlinx:kotlinx-coroutines-core:$version",
+            dependencySourceSet = sourceSet,
+            dependencyConfiguration = configuration
+        )
+        project.useCommonDependency(
+            "org.jetbrains.kotlinx:kotlinx-coroutines-test:$version",
+            dependencySourceSet = DependencySourceSet.TEST,
+            dependencyConfiguration = DependencyConfiguration.IMPLEMENTATION
+        )
+    }
+
+    /**
+     * Use core serialization library and configure targets
+     */
+    public fun useSerialization(
+        version: String = KScienceVersions.serializationVersion,
+        sourceSet: DependencySourceSet = DependencySourceSet.MAIN,
+        configuration: DependencyConfiguration = DependencyConfiguration.API,
+        block: SerializationTargets.() -> Unit = {},
+    ): Unit = project.run {
+        plugins.apply("org.jetbrains.kotlin.plugin.serialization")
+        val artifactName = if (version.startsWith("0")) {
+            "kotlinx-serialization-runtime"
+        } else {
+            "kotlinx-serialization-core"
+        }
+        useCommonDependency(
+            "org.jetbrains.kotlinx:$artifactName:$version",
+            dependencySourceSet = sourceSet,
+            dependencyConfiguration = configuration
+        )
+        SerializationTargets(sourceSet, configuration).block()
+    }
+
+    public fun useKtor(version: String = KScienceVersions.ktorVersion): Unit = with(project) {
+        pluginManager.withPlugin("org.jetbrains.kotlin.multiplatform") {
+            configure<KotlinMultiplatformExtension> {
+                sourceSets.findByName("commonMain")?.apply {
+                    dependencies {
+                        api(platform("io.ktor:ktor-bom:$version"))
+                    }
+                }
+            }
+        }
+        pluginManager.withPlugin("org.jetbrains.kotlin.jvm") {
+            configure<KotlinJvmProjectExtension> {
+                sourceSets.findByName("main")?.apply {
+                    dependencies {
+                        api(platform("io.ktor:ktor-bom:$version"))
+                    }
+                }
+            }
+        }
+        pluginManager.withPlugin("org.jetbrains.kotlin.js") {
+            configure<KotlinJsProjectExtension> {
+                sourceSets.findByName("main")?.apply {
+                    dependencies {
+                        api(platform("io.ktor:ktor-bom:$version"))
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * Apply jupyter plugin and add entry point for the jupyter library.
+     * If left empty applies a plugin without declaring library producers
+     */
+    public fun jupyterLibrary(vararg pluginClasses: String) {
+        project.plugins.apply("org.jetbrains.kotlin.jupyter.api")
+        project.tasks.named("processJupyterApiResources", JupyterApiResourcesTask::class.java) {
+            libraryProducers = pluginClasses.toList()
+        }
+    }
+
+    /**
+     * Apply common dependencies for different kind of targets
+     */
+    public fun dependencies(sourceSet: String? = null, dependencyBlock: KotlinDependencyHandler.() -> Unit) {
+        project.pluginManager.withPlugin("org.jetbrains.kotlin.jvm") {
+            project.configure<KotlinJvmProjectExtension> {
+                sourceSets.getByName(sourceSet ?: "main") {
+                    dependencies(dependencyBlock)
+                }
+            }
+        }
+
+        project.pluginManager.withPlugin("org.jetbrains.kotlin.js") {
+            project.configure<KotlinJsProjectExtension> {
+                sourceSets.getByName(sourceSet ?: "main") {
+                    dependencies(dependencyBlock)
+                }
+            }
+        }
+
+        project.pluginManager.withPlugin("org.jetbrains.kotlin.multiplatform") {
+            project.configure<KotlinMultiplatformExtension> {
+                sourceSets.getByName(sourceSet ?: "commonMain") {
+                    dependencies(dependencyBlock)
+                }
+            }
+        }
+    }
+
+    public fun testDependencies(sourceSet: String? = null, dependencyBlock: KotlinDependencyHandler.() -> Unit) {
+        project.pluginManager.withPlugin("org.jetbrains.kotlin.jvm") {
+            project.configure<KotlinJvmProjectExtension> {
+                sourceSets.getByName(sourceSet ?: "test") {
+                    dependencies(dependencyBlock)
+                }
+            }
+        }
+
+        project.pluginManager.withPlugin("org.jetbrains.kotlin.js") {
+            project.configure<KotlinJsProjectExtension> {
+                sourceSets.getByName(sourceSet ?: "test") {
+                    dependencies(dependencyBlock)
+                }
+            }
+        }
+
+        project.pluginManager.withPlugin("org.jetbrains.kotlin.multiplatform") {
+            project.configure<KotlinMultiplatformExtension> {
+                sourceSets.getByName(sourceSet ?: "commonTest") {
+                    dependencies(dependencyBlock)
+                }
+            }
+        }
+    }
+
+    public class DefaultSourceSet(public val key: String)
+
+    public fun dependencies(
+        defaultSourceSet: DefaultSourceSet,
+        dependencyBlock: KotlinDependencyHandler.() -> Unit,
+    ): Unit = dependencies(defaultSourceSet.key, dependencyBlock)
+
+
+    /**
+     * Mark this module as an application module. JVM application should be enabled separately
+     */
+    public fun application() {
+        project.extensions.findByType<KotlinProjectExtension>()?.apply {
+            explicitApi = null
+        }
+
+        project.pluginManager.withPlugin("org.jetbrains.kotlin.jvm") {
+            project.apply<ApplicationPlugin>()
+        }
+
+        project.extensions.findByType<KotlinJsProjectExtension>()?.apply {
+            js(IR) {
+                binaries.executable()
+            }
+        }
+
+        project.extensions.findByType<KotlinMultiplatformExtension>()?.apply {
+            targets.withType<KotlinJsTargetDsl> {
+                binaries.executable()
+            }
+
+            targets.withType<KotlinNativeTarget> {
+                binaries.executable()
+            }
+
+            targets.withType<KotlinWasmTargetDsl> {
+                binaries.executable()
+            }
+        }
+    }
+
+    /**
+     * Add context receivers to this project and all subprojects
+     */
+    public fun useContextReceivers() {
+        project.tasks.withType<KotlinCompile> {
+            kotlinOptions {
+                freeCompilerArgs = freeCompilerArgs + "-Xcontext-receivers"
+            }
+        }
+    }
+
+    public operator fun DefaultSourceSet.invoke(dependencyBlock: KotlinDependencyHandler.() -> Unit) {
+        dependencies(this, dependencyBlock)
+    }
+
+    public val commonMain: DefaultSourceSet get() = DefaultSourceSet("commonMain")
+    public val commonTest: DefaultSourceSet get() = DefaultSourceSet("commonTest")
+
+    public val jvmMain: DefaultSourceSet get() = DefaultSourceSet("jvmMain")
+    public val jvmTest: DefaultSourceSet get() = DefaultSourceSet("jvmTest")
+    public val jsMain: DefaultSourceSet get() = DefaultSourceSet("jsMain")
+    public val jsTest: DefaultSourceSet get() = DefaultSourceSet("jsTest")
+    public val nativeMain: DefaultSourceSet get() = DefaultSourceSet("nativeMain")
+    public val nativeTest: DefaultSourceSet get() = DefaultSourceSet("nativeTest")
+    public val wasmMain: DefaultSourceSet get() = DefaultSourceSet("wasmMain")
+    public val wasmTest: DefaultSourceSet get() = DefaultSourceSet("wasmTest")
+
+}
+
+public enum class KotlinNativePreset {
+    linuxX64,
+    mingwX64,
+    macosX64,
+    macosArm64,
+    iosX64,
+    iosArm64,
+    iosSimulatorArm64,
+}
+
+public data class KScienceNativeTarget(
+    val preset: KotlinNativePreset,
+    val targetName: String = preset.name,
+    val targetConfiguration: KotlinNativeTarget.() -> Unit = { },
+) {
+    public companion object {
+        public val linuxX64: KScienceNativeTarget = KScienceNativeTarget(KotlinNativePreset.linuxX64)
+        public val mingwX64: KScienceNativeTarget = KScienceNativeTarget(KotlinNativePreset.mingwX64)
+        public val macosX64: KScienceNativeTarget = KScienceNativeTarget(KotlinNativePreset.macosX64)
+        public val macosArm64: KScienceNativeTarget = KScienceNativeTarget(KotlinNativePreset.macosX64)
+        public val iosX64: KScienceNativeTarget = KScienceNativeTarget(KotlinNativePreset.iosX64)
+        public val iosArm64: KScienceNativeTarget = KScienceNativeTarget(KotlinNativePreset.iosArm64)
+        public val iosSimulatorArm64: KScienceNativeTarget = KScienceNativeTarget(KotlinNativePreset.iosSimulatorArm64)
+    }
+}
+
+public class KScienceNativeConfiguration {
+
+
+    internal companion object {
+        private fun defaultNativeTargets(): Map<KotlinNativePreset, KScienceNativeTarget> {
+
+            val hostOs = System.getProperty("os.name")
+            return when {
+                hostOs.startsWith("Windows") -> listOf(
+                    KScienceNativeTarget.linuxX64,
+                    KScienceNativeTarget.mingwX64
+                )
+
+                hostOs == "Mac OS X" -> listOf(
+                    KScienceNativeTarget.macosX64,
+                    KScienceNativeTarget.macosArm64,
+                    KScienceNativeTarget.iosX64,
+                    KScienceNativeTarget.iosArm64,
+                    KScienceNativeTarget.iosSimulatorArm64,
+                )
+
+                hostOs == "Linux" -> listOf(KScienceNativeTarget.linuxX64)
+                else -> {
+                    emptyList()
+                }
+            }.associateBy { it.preset }
+        }
+    }
+
+
+    internal var targets: Map<KotlinNativePreset, KScienceNativeTarget> = defaultNativeTargets()
+
+
+    /**
+     * Replace all targets
+     */
+    public fun setTargets(vararg target: KScienceNativeTarget) {
+        targets = target.associateBy { it.preset }
+    }
+
+    /**
+     * Add a native target
+     */
+    public fun target(target: KScienceNativeTarget) {
+        targets += target.preset to target
+    }
+
+    public fun target(
+        preset: KotlinNativePreset,
+        targetName: String = preset.name,
+        targetConfiguration: KotlinNativeTarget.() -> Unit = { },
+    ): Unit = target(KScienceNativeTarget(preset, targetName, targetConfiguration))
+}
+
+public open class KScienceMppExtension(project: Project) : KScienceExtension(project) {
+    /**
+     * Enable jvm target
+     */
+    public fun jvm(block: KotlinJvmTarget.() -> Unit = {}) {
+        project.pluginManager.withPlugin("org.jetbrains.kotlin.multiplatform") {
+            project.configure<KotlinMultiplatformExtension> {
+                jvm {
+                    compilations.all {
+                        kotlinOptions {
+                            freeCompilerArgs = freeCompilerArgs + defaultKotlinJvmArgs
+                        }
+                    }
+                    block()
+                }
+                sourceSets {
+                    getByName("jvmTest") {
+                        dependencies {
+                            implementation(kotlin("test-junit5"))
+                            implementation("org.junit.jupiter:junit-jupiter:${KScienceVersions.junit}")
+                        }
+                    }
+                }
+                jvmToolchain {
+                    languageVersion.set(jdkVersionProperty.map { JavaLanguageVersion.of(it) })
+                }
+            }
+            project.tasks.withType<Test> {
+                useJUnitPlatform()
+            }
+        }
+    }
+
+    /**
+     * Enable JS-IR (browser) target.
+     */
+    public fun js(block: KotlinJsTargetDsl.() -> Unit = {}) {
+        project.pluginManager.withPlugin("org.jetbrains.kotlin.multiplatform") {
+            project.configure<KotlinMultiplatformExtension> {
+                js(IR) {
+                    browser()
+                    block()
+                }
+                sourceSets {
+                    getByName("jsTest") {
+                        dependencies {
+                            implementation(kotlin("test-js"))
+                        }
+                    }
+                }
+            }
+            (project.tasks.findByName("jsProcessResources") as? Copy)?.apply {
+                fromJsDependencies("jsRuntimeClasspath")
+            }
+        }
+    }
+
+    @OptIn(ExperimentalWasmDsl::class)
+    public fun wasm(block: KotlinWasmTargetDsl.() -> Unit = {}) {
+        project.pluginManager.withPlugin("org.jetbrains.kotlin.multiplatform") {
+            project.configure<KotlinMultiplatformExtension> {
+                wasm {
+                    browser()
+                    block()
+                }
+            }
+        }
+    }
+
+    public fun jvmAndJs() {
+        jvm()
+        js()
+    }
+
+    /**
+     * Jvm and Js source sets including copy of Js bundle into JVM resources
+     */
+    public fun fullStack(
+        bundleName: String = "js/bundle.js",
+        jvmConfig: KotlinJvmTarget.() -> Unit = {},
+        jsConfig: KotlinJsTargetDsl.() -> Unit = {},
+        browserConfig: KotlinJsBrowserDsl.() -> Unit = {},
+    ) {
+        js {
+            binaries.executable()
+            browser {
+                webpackTask {
+                    outputFileName = bundleName
+                }
+                browserConfig()
+            }
+            jsConfig()
+        }
+        jvm {
+            val processResourcesTaskName =
+                compilations[org.jetbrains.kotlin.gradle.plugin.KotlinCompilation.MAIN_COMPILATION_NAME]
+                    .processResourcesTaskName
+
+            val jsBrowserDistribution = project.tasks.getByName("jsBrowserDistribution")
+
+            project.tasks.getByName<ProcessResources>(processResourcesTaskName) {
+                duplicatesStrategy = DuplicatesStrategy.WARN
+                dependsOn(jsBrowserDistribution)
+                from(jsBrowserDistribution)
+            }
+            jvmConfig()
+        }
+    }
+
+    /**
+     * Enable all supported native targets
+     */
+    public fun native(block: KScienceNativeConfiguration.() -> Unit = {}): Unit = with(project) {
+        val nativeConfiguration = KScienceNativeConfiguration().apply(block)
+        pluginManager.withPlugin("org.jetbrains.kotlin.multiplatform") {
+            configure<KotlinMultiplatformExtension> {
+                val nativeTargets: List<KotlinNativeTarget> =
+                    nativeConfiguration.targets.values.map { nativeTarget ->
+                        when (nativeTarget.preset) {
+                            KotlinNativePreset.linuxX64 -> linuxX64(
+                                nativeTarget.targetName,
+                                nativeTarget.targetConfiguration
+                            )
+
+                            KotlinNativePreset.mingwX64 -> mingwX64(
+                                nativeTarget.targetName,
+                                nativeTarget.targetConfiguration
+                            )
+
+                            KotlinNativePreset.macosX64 -> macosX64(
+                                nativeTarget.targetName,
+                                nativeTarget.targetConfiguration
+                            )
+
+                            KotlinNativePreset.macosArm64 -> macosArm64(
+                                nativeTarget.targetName,
+                                nativeTarget.targetConfiguration
+                            )
+
+                            KotlinNativePreset.iosX64 -> iosX64(
+                                nativeTarget.targetName,
+                                nativeTarget.targetConfiguration
+                            )
+
+                            KotlinNativePreset.iosArm64 -> iosArm64(
+                                nativeTarget.targetName,
+                                nativeTarget.targetConfiguration
+                            )
+
+                            KotlinNativePreset.iosSimulatorArm64 -> iosSimulatorArm64(
+                                nativeTarget.targetName,
+                                nativeTarget.targetConfiguration
+                            )
+
+//                                else -> {
+//                                    logger.error("Native preset ${nativeTarget.preset} not recognised.")
+//                                    null
+//                                }
+                        }
+                    }
+
+                sourceSets {
+                    val commonMain by getting
+                    val commonTest by getting
+
+                    val nativeMain by creating {
+                        dependsOn(commonMain)
+                    }
+
+                    val nativeTest by creating {
+                        //should NOT depend on nativeMain because automatic dependency by plugin
+                        dependsOn(commonTest)
+                    }
+
+                    configure(nativeTargets) {
+                        compilations["main"]?.apply {
+                            configure(kotlinSourceSets) {
+                                dependsOn(nativeMain)
+                            }
+                        }
+
+                        compilations["test"]?.apply {
+                            configure(kotlinSourceSets) {
+                                dependsOn(nativeTest)
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+
+internal inline fun <reified T : KScienceExtension> Project.registerKScienceExtension(constructor: (Project) -> T): T {
+    extensions.findByType<T>()?.let { return it }
+    return constructor(this).also {
+        extensions.add("kscience", it)
+    }
+}

src/main/kotlin/space/kscience/gradle/KScienceJSPlugin.kt

@@ -0,0 +1,56 @@
+package space.kscience.gradle
+
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.tasks.Copy
+import org.gradle.kotlin.dsl.apply
+import org.gradle.kotlin.dsl.configure
+import org.gradle.kotlin.dsl.get
+import org.jetbrains.dokka.gradle.DokkaPlugin
+import org.jetbrains.kotlin.gradle.dsl.KotlinJsProjectExtension
+import space.kscience.gradle.internal.applySettings
+import space.kscience.gradle.internal.fromJsDependencies
+
+public open class KScienceJSPlugin : Plugin<Project> {
+    override fun apply(project: Project): Unit = project.run {
+        if (!plugins.hasPlugin("org.jetbrains.kotlin.js")) {
+            plugins.apply("org.jetbrains.kotlin.js")
+        } else {
+            logger.info("Kotlin JS plugin is already present")
+        }
+        registerKScienceExtension(::KScienceExtension)
+
+        //logger.info("Applying KScience configuration for JS project")
+        configure<KotlinJsProjectExtension> {
+            js(IR) { browser { } }
+
+            sourceSets.all {
+                languageSettings.applySettings()
+            }
+
+            sourceSets["main"].apply {
+                dependencies {
+                    api(project.dependencies.platform("org.jetbrains.kotlin-wrappers:kotlin-wrappers-bom:${KScienceVersions.jsBom}"))
+                }
+            }
+
+            sourceSets["test"].apply {
+                dependencies {
+                    implementation(kotlin("test-js"))
+                }
+            }
+
+            if (explicitApi == null) explicitApiWarning()
+        }
+
+        (tasks.findByName("processResources") as? Copy)?.apply {
+            fromJsDependencies("runtimeClasspath")
+        }
+
+
+        // apply dokka for all projects
+        if (!plugins.hasPlugin("org.jetbrains.dokka")) {
+            apply<DokkaPlugin>()
+        }
+    }
+}

src/main/kotlin/space/kscience/gradle/KScienceJVMPlugin.kt

@@ -0,0 +1,61 @@
+package space.kscience.gradle
+
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.tasks.testing.Test
+import org.gradle.jvm.toolchain.JavaLanguageVersion
+import org.gradle.kotlin.dsl.apply
+import org.gradle.kotlin.dsl.configure
+import org.gradle.kotlin.dsl.get
+import org.gradle.kotlin.dsl.withType
+import org.jetbrains.dokka.gradle.DokkaPlugin
+import org.jetbrains.kotlin.gradle.dsl.KotlinJvmProjectExtension
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+import space.kscience.gradle.internal.applySettings
+import space.kscience.gradle.internal.defaultKotlinJvmArgs
+
+public open class KScienceJVMPlugin : Plugin<Project> {
+    override fun apply(project: Project): Unit = project.run {
+        if (!plugins.hasPlugin("org.jetbrains.kotlin.jvm")) {
+            plugins.apply("org.jetbrains.kotlin.jvm")
+        } else {
+            logger.info("Kotlin JVM plugin is already present")
+        }
+        val extension = registerKScienceExtension(::KScienceExtension)
+
+        //logger.info("Applying KScience configuration for JVM project")
+        configure<KotlinJvmProjectExtension> {
+            sourceSets.all {
+                languageSettings.applySettings()
+            }
+
+            sourceSets["test"].apply {
+                dependencies {
+                    implementation(kotlin("test-junit5"))
+                    implementation("org.junit.jupiter:junit-jupiter:${KScienceVersions.junit}")
+                }
+            }
+
+            if (explicitApi == null) explicitApiWarning()
+            jvmToolchain {
+                languageVersion.set(extension.jdkVersionProperty.map { JavaLanguageVersion.of(it) })
+            }
+        }
+
+        tasks.withType<KotlinCompile> {
+            kotlinOptions {
+                freeCompilerArgs = freeCompilerArgs + defaultKotlinJvmArgs
+            }
+        }
+
+        tasks.withType<Test> {
+            useJUnitPlatform()
+        }
+
+        // apply dokka for all projects
+        if (!plugins.hasPlugin("org.jetbrains.dokka")) {
+            apply<DokkaPlugin>()
+        }
+    }
+
+}

src/main/kotlin/space/kscience/gradle/KScienceMPPlugin.kt

@@ -0,0 +1,54 @@
+package space.kscience.gradle
+
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.apply
+import org.gradle.kotlin.dsl.configure
+import org.gradle.kotlin.dsl.hasPlugin
+import org.gradle.kotlin.dsl.invoke
+import org.jetbrains.dokka.gradle.DokkaPlugin
+import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
+import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinMultiplatformPlugin
+import space.kscience.gradle.internal.applySettings
+
+public open class KScienceMPPlugin : Plugin<Project> {
+    override fun apply(project: Project): Unit = project.run {
+        if (!plugins.hasPlugin(KotlinMultiplatformPlugin::class)) {
+            //apply<KotlinMultiplatformPlugin>() for some reason it does not work
+            plugins.apply("org.jetbrains.kotlin.multiplatform")
+        } else {
+            logger.info("Kotlin MPP plugin is already present")
+        }
+
+        registerKScienceExtension(::KScienceMppExtension)
+
+        configure<KotlinMultiplatformExtension> {
+
+            sourceSets {
+                getByName("commonMain"){
+                    dependencies {
+                        api(project.dependencies.platform("org.jetbrains.kotlin-wrappers:kotlin-wrappers-bom:${KScienceVersions.jsBom}"))
+                    }
+                }
+                getByName("commonTest"){
+                    dependencies {
+                        implementation(kotlin("test-common"))
+                        implementation(kotlin("test-annotations-common"))
+                    }
+                }
+            }
+
+            sourceSets.all {
+                languageSettings.applySettings()
+            }
+
+            if (explicitApi == null) explicitApiWarning()
+        }
+
+
+        // apply dokka for all projects
+        if (!plugins.hasPlugin("org.jetbrains.dokka")) {
+            apply<DokkaPlugin>()
+        }
+    }
+}

src/main/kotlin/space/kscience/gradle/KScienceProjectPlugin.kt

@@ -0,0 +1,262 @@
+package space.kscience.gradle
+
+import kotlinx.validation.ApiValidationExtension
+import kotlinx.validation.BinaryCompatibilityValidatorPlugin
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.publish.maven.MavenPom
+import org.gradle.api.publish.maven.tasks.AbstractPublishToMaven
+import org.gradle.kotlin.dsl.*
+import org.gradle.plugins.signing.Sign
+import org.jetbrains.changelog.ChangelogPlugin
+import org.jetbrains.changelog.ChangelogPluginExtension
+import org.jetbrains.dokka.gradle.AbstractDokkaTask
+import org.jetbrains.dokka.gradle.DokkaPlugin
+import space.kscience.gradle.internal.*
+
+/**
+ * Simplifies adding repositories for Maven publishing, responds for releasing tasks for projects.
+ */
+public class KSciencePublishingExtension(public val project: Project) {
+    private var isVcsInitialized = false
+
+    /**
+     * Configures Git repository (sources) for the publication.
+     *
+     * @param vcsUrl URL of the repository's web interface.
+     * @param connectionUrl URL of the Git repository.
+     * @param developerConnectionUrl URL of the Git repository for developers.
+     */
+    public fun pom(
+        vcsUrl: String,
+        connectionUrl: String? = null,
+        developerConnectionUrl: String? = connectionUrl,
+        connectionPrefix: String = "scm:git:",
+        pomConfig: MavenPom.() -> Unit,
+    ) {
+        if (!isVcsInitialized) {
+            project.setupPublication {
+                url.set(vcsUrl)
+
+                scm {
+                    url.set(vcsUrl)
+                    connectionUrl?.let { connection.set("$connectionPrefix$it") }
+                    developerConnectionUrl?.let { developerConnection.set("$connectionPrefix$it") }
+                }
+                pomConfig()
+            }
+
+            isVcsInitialized = true
+        }
+    }
+
+    /**
+     * Adds GitHub as VCS and adds GitHub Packages Maven repository to publishing.
+     *
+     * @param githubProject the GitHub project.
+     * @param githubOrg the GitHub user or organization.
+     * @param deploy publish packages in the `deploy` task to the GitHub repository.
+     */
+    public fun github(
+        githubOrg: String,
+        githubProject: String,
+        deploy: Boolean = project.requestPropertyOrNull("publishing.github") == "true",
+    ) {
+        if (deploy) {
+            try {
+                project.addGithubPublishing(githubOrg, githubProject)
+            } catch (t: Throwable) {
+                project.logger.error("Failed to set up github publication", t)
+            }
+        }
+    }
+
+    /**
+     * Adds Space Packages Maven repository to publishing.
+     *
+     * @param spaceRepo the repository URL.
+     * @param deploy publish packages in the `deploy` task to the Space repository.
+     */
+    public fun space(
+        spaceRepo: String,
+    ) {
+        project.addSpacePublishing(spaceRepo)
+    }
+
+    /**
+     * Adds Sonatype Maven repository to publishing.
+     *
+     * @param addToRelease  publish packages in the `release` task to the Sonatype repository.
+     */
+    public fun sonatype() {
+        require(isVcsInitialized) { "The project vcs is not set up use 'pom' method to do so" }
+        project.addSonatypePublishing()
+    }
+}
+
+/**
+ * Applies third-party plugins (Dokka, Changelog, binary compatibility validator); configures Maven publishing, README
+ * generation.
+ */
+public open class KScienceProjectPlugin : Plugin<Project> {
+    override fun apply(target: Project): Unit = target.run {
+        apply<ChangelogPlugin>()
+        apply<DokkaPlugin>()
+        apply<BinaryCompatibilityValidatorPlugin>()
+
+        allprojects{
+            repositories{
+                mavenCentral()
+                maven("https://repo.kotlin.link")
+                maven("https://maven.pkg.jetbrains.space/spc/p/sci/dev")
+            }
+
+            // Workaround for https://github.com/gradle/gradle/issues/15568
+            tasks.withType<AbstractPublishToMaven>().configureEach {
+                mustRunAfter(tasks.withType<Sign>())
+            }
+        }
+
+        afterEvaluate {
+            if (isInDevelopment) {
+                configure<ApiValidationExtension> {
+                    validationDisabled = true
+                }
+            } else {
+                configure<ChangelogPluginExtension> {
+                    version.set(project.version.toString())
+                }
+            }
+        }
+
+        val rootReadmeExtension = KScienceReadmeExtension(this)
+        val ksciencePublish = KSciencePublishingExtension(this)
+        extensions.add("ksciencePublish", ksciencePublish)
+        extensions.add("readme", rootReadmeExtension)
+
+        //Add readme generators to individual subprojects
+        subprojects {
+            val readmeExtension = KScienceReadmeExtension(this)
+            extensions.add("readme", readmeExtension)
+
+            @Suppress("UNUSED_VARIABLE")
+            val generateReadme by tasks.creating {
+                group = "documentation"
+                description = "Generate a README file if stub is present"
+
+                if (readmeExtension.readmeTemplate.exists()) {
+                    inputs.file(readmeExtension.readmeTemplate)
+                }
+                readmeExtension.inputFiles.forEach {
+                    if (it.exists()) {
+                        inputs.file(it)
+                    }
+                }
+
+                val readmeFile = this@subprojects.file("README.md")
+                outputs.file(readmeFile)
+
+                doLast {
+                    val readmeString = readmeExtension.readmeString()
+                    if (readmeString != null) {
+                        readmeFile.writeText(readmeString)
+                    }
+                }
+            }
+
+//            tasks.withType<AbstractDokkaTask> {
+//                dependsOn(generateReadme)
+//            }
+        }
+
+        val generateReadme by tasks.creating {
+            group = "documentation"
+            description = "Generate a README file and a feature matrix if stub is present"
+
+            subprojects {
+                tasks.findByName("generateReadme")?.let {
+                    dependsOn(it)
+                }
+            }
+
+            if (rootReadmeExtension.readmeTemplate.exists()) {
+                inputs.file(rootReadmeExtension.readmeTemplate)
+            }
+
+            rootReadmeExtension.inputFiles.forEach {
+                if (it.exists()) {
+                    inputs.file(it)
+                }
+            }
+
+            val readmeFile = project.file("README.md")
+            outputs.file(readmeFile)
+
+            doLast {
+//                val projects = subprojects.associate {
+//                    val normalizedPath = it.path.replaceFirst(":","").replace(":","/")
+//                    it.path.replace(":","/") to it.extensions.findByType<KScienceReadmeExtension>()
+//                }
+
+                if (rootReadmeExtension.readmeTemplate.exists()) {
+
+                    val modulesString = buildString {
+                        subprojects.forEach { subproject ->
+//                            val name = subproject.name
+                            subproject.extensions.findByType<KScienceReadmeExtension>()?.let { ext ->
+                                val path = subproject.path.replaceFirst(":", "").replace(":", "/")
+                                appendLine("\n### [$path]($path)")
+                                appendLine("> ${ext.description}")
+                                appendLine(">\n> **Maturity**: ${ext.maturity}")
+                                val featureString = ext.featuresString(itemPrefix = "> - ", pathPrefix = "$path/")
+                                if (featureString.isNotBlank()) {
+                                    appendLine(">\n> **Features:**")
+                                    appendLine(featureString)
+                                }
+                            }
+                        }
+                    }
+
+                    rootReadmeExtension.property("modules", modulesString)
+
+                    rootReadmeExtension.readmeString()?.let {
+                        readmeFile.writeText(it)
+                    }
+                }
+
+            }
+        }
+
+        tasks.withType<AbstractDokkaTask> {
+            dependsOn(generateReadme)
+        }
+
+        tasks.create("version") {
+            group = "publishing"
+            val versionFile = project.buildDir.resolve("project-version.txt")
+            outputs.file(versionFile)
+            doLast {
+                versionFile.createNewFile()
+                versionFile.writeText(project.version.toString())
+                println(project.version)
+            }
+        }
+
+        // Disable API validation for snapshots
+        if (isInDevelopment) {
+            extensions.findByType<ApiValidationExtension>()?.apply {
+                validationDisabled = true
+                logger.warn("API validation is disabled for snapshot or dev version")
+            }
+        }
+
+        plugins.withType(org.jetbrains.kotlin.gradle.targets.js.yarn.YarnPlugin::class.java) {
+            rootProject.the<org.jetbrains.kotlin.gradle.targets.js.yarn.YarnRootExtension>().lockFileDirectory =
+                rootDir.resolve("gradle")
+        }
+    }
+
+    public companion object {
+        public const val DEPLOY_GROUP: String = "deploy"
+    }
+}

src/main/kotlin/space/kscience/gradle/KScienceReadmeExtension.kt

@@ -0,0 +1,180 @@
+package space.kscience.gradle
+
+import freemarker.cache.StringTemplateLoader
+import freemarker.template.Configuration
+import freemarker.template.Template
+import freemarker.template.TemplateNotFoundException
+import kotlinx.html.TagConsumer
+import kotlinx.html.div
+import kotlinx.html.stream.createHTML
+import kotlinx.validation.ApiValidationExtension
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.findByType
+import java.io.File
+import java.io.StringWriter
+import kotlin.collections.component1
+import kotlin.collections.component2
+import kotlin.collections.set
+
+public enum class Maturity {
+    PROTOTYPE,
+    EXPERIMENTAL,
+    DEVELOPMENT,
+    STABLE,
+    DEPRECATED
+}
+
+private fun Template.processToString(args: Map<String, Any?>): String {
+    val writer = StringWriter()
+    process(args, writer)
+    return writer.toString()
+}
+
+
+public class KScienceReadmeExtension(public val project: Project) {
+    public var description: String = project.description ?: ""
+
+    public var maturity: Maturity = Maturity.EXPERIMENTAL
+        set(value) {
+            field = value
+            val projectName = project.name
+            if (value == Maturity.EXPERIMENTAL || value == Maturity.PROTOTYPE) {
+                project.rootProject.run {
+                    plugins.withId("org.jetbrains.kotlinx.binary-compatibility-validator") {
+                        extensions.findByType<ApiValidationExtension>()?.apply {
+                            project.logger.warn("$value project $projectName is excluded from API validation")
+                            ignoredProjects.add(projectName)
+                        }
+                    }
+                }
+            }
+        }
+
+    /**
+     * If true, use default templates provided by plugin if override is not defined
+     */
+    public var useDefaultReadmeTemplate: Boolean = true
+
+    /**
+     * Use this template file if it is provided, otherwise use default template
+     */
+    public var readmeTemplate: File = project.file("docs/README-TEMPLATE.md")
+        set(value) {
+            field = value
+            if (value.exists()) {
+                fmLoader.putTemplate("readme", value.readText())
+            }
+        }
+
+    private val fmLoader = StringTemplateLoader().apply {
+        putTemplate(
+            "artifact",
+            this@KScienceReadmeExtension.javaClass.getResource("/templates/ARTIFACT-TEMPLATE.md")!!.readText()
+        )
+        if (readmeTemplate.exists()) {
+            putTemplate("readme", readmeTemplate.readText())
+        } else if (useDefaultReadmeTemplate) {
+            putTemplate(
+                "readme",
+                this@KScienceReadmeExtension.javaClass.getResource("/templates/README-TEMPLATE.md")!!.readText()
+            )
+        }
+    }
+
+    private val fmCfg = Configuration(Configuration.VERSION_2_3_31).apply {
+        defaultEncoding = "UTF-8"
+        templateLoader = fmLoader
+    }
+
+    public data class Feature(val id: String, val description: String, val ref: String?, val name: String = id)
+
+    public val features: MutableList<Feature> = ArrayList()
+
+    public fun feature(id: String, ref: String? = null, name: String = id, description: () -> String) {
+        features += Feature(id, description(), ref, name)
+    }
+
+    public fun featureWithHtml(
+        id: String,
+        ref: String? = null,
+        name: String = id,
+        htmlBuilder: TagConsumer<String>.() -> Unit,
+    ) {
+        val text = createHTML().apply {
+            div("readme-feature") {
+                htmlBuilder()
+            }
+        }.finalize()
+        features += Feature(id, text, ref, name)
+    }
+
+    private val properties: MutableMap<String, () -> Any?> = mutableMapOf(
+        "name" to { project.name },
+        "group" to { project.group },
+        "version" to { project.version },
+        "description" to { project.description ?: "" },
+        "features" to { featuresString() },
+        "published" to { project.plugins.findPlugin("maven-publish") != null },
+        "artifact" to {
+            val projectProperties = mapOf(
+                "name" to project.name,
+                "group" to project.group,
+                "version" to project.version
+            )
+            fmCfg.getTemplate("artifact").processToString(projectProperties)
+        }
+    )
+
+    public fun getPropertyValues(): Map<String, Any?> = properties.mapValues { (_, value) -> value() }
+
+    public fun property(key: String, value: Any?) {
+        properties[key] = { value }
+    }
+
+    public fun property(key: String, value: () -> Any?) {
+        properties[key] = value
+    }
+
+    public fun propertyByTemplate(key: String, templateString: String) {
+        //need to freeze it, otherwise values could change
+        val actual = getPropertyValues()
+        fmLoader.putTemplate(key, templateString)
+        val template = fmCfg.getTemplate(key)
+
+        properties[key] = { template.processToString(actual) }
+    }
+
+    /**
+     * Files that are use in readme generation
+     */
+    internal val inputFiles = ArrayList<File>()
+
+    public fun propertyByTemplate(key: String, templateFile: File) {
+        //need to freeze it, otherwise values could change
+        val actual = getPropertyValues()
+        fmLoader.putTemplate(key, templateFile.readText())
+        val template: Template = fmCfg.getTemplate(key)
+
+        properties[key] = { template.processToString(actual) }
+        inputFiles += templateFile
+    }
+
+    /**
+     * Generate a markdown string listing features
+     */
+    internal fun featuresString(itemPrefix: String = " - ", pathPrefix: String = ""): String = buildString {
+        features.forEach {
+            appendLine("$itemPrefix[${it.name}]($pathPrefix${it.ref ?: "#"}) : ${it.description}")
+        }
+    }
+
+    /**
+     * Generate a readme string from the template
+     */
+    public fun readmeString(): String? = try {
+        fmCfg.getTemplate("readme").processToString(getPropertyValues())
+    } catch (ex: TemplateNotFoundException) {
+        project.logger.warn("Template with name ${ex.templateName} not found in ${project.name}")
+        null
+    }
+}

src/main/kotlin/space/kscience/gradle/KScienceVersions.kt

@@ -0,0 +1,30 @@
+package space.kscience.gradle
+
+
+import org.tomlj.Toml
+
+/**
+ * Build constants
+ */
+public object KScienceVersions {
+
+    private val toml by lazy {
+        Toml.parse(javaClass.getResource("/libs.versions.toml")!!.readText())
+    }
+
+    public val kotlinVersion: String get() = toml.getString("versions.kotlin")!!
+    public val kotlinxNodeVersion: String get() = toml.getString("versions.kotlinx-nodejs")!!
+    public val coroutinesVersion: String get() = toml.getString("versions.kotlinx-coroutines")!!
+    public val serializationVersion: String get() = toml.getString("versions.kotlinx-serialization")!!
+    public val atomicVersion: String get() = toml.getString("versions.atomicfu")!!
+    public val ktorVersion: String get() = toml.getString("versions.ktor")!!
+    public val htmlVersion: String get() = toml.getString("versions.kotlinx-html")!!
+    public val dateTimeVersion: String get() = toml.getString("versions.kotlinx-datetime")!!
+    public val jsBom: String get() = toml.getString("versions.jsBom")!!
+    internal val junit: String get() = toml.getString("versions.junit")!!
+
+    public object Serialization {
+        public val xmlVersion: String get() = toml.getString("versions.xmlutil")!!
+        public val yamlKtVersion: String get() = toml.getString("versions.yamlkt")!!
+    }
+}

src/main/kotlin/space/kscience/gradle/SerializationTargets.kt

@@ -0,0 +1,49 @@
+package space.kscience.gradle
+
+import org.gradle.api.Project
+import space.kscience.gradle.internal.useCommonDependency
+
+public class SerializationTargets(
+    public val sourceSet: DependencySourceSet,
+    public val configuration: DependencyConfiguration,
+) {
+    public fun Project.json(
+        version: String = KScienceVersions.serializationVersion,
+    ): Unit = useCommonDependency(
+        "org.jetbrains.kotlinx:kotlinx-serialization-json:$version",
+        dependencySourceSet = sourceSet,
+        dependencyConfiguration = configuration,
+    )
+
+    public fun Project.cbor(
+        version: String = KScienceVersions.serializationVersion,
+    ): Unit = useCommonDependency(
+        "org.jetbrains.kotlinx:kotlinx-serialization-cbor:$version",
+        dependencySourceSet = sourceSet,
+        dependencyConfiguration = configuration,
+    )
+
+    public fun Project.protobuf(
+        version: String = KScienceVersions.serializationVersion,
+    ): Unit = useCommonDependency(
+        "org.jetbrains.kotlinx:kotlinx-serialization-protobuf:$version",
+        dependencySourceSet = sourceSet,
+        dependencyConfiguration = configuration,
+    )
+
+    public fun Project.xml(
+        version: String = KScienceVersions.Serialization.xmlVersion,
+    ): Unit = useCommonDependency(
+        "io.github.pdvrieze.xmlutil:serialization:$version",
+        dependencySourceSet = sourceSet,
+        dependencyConfiguration = configuration,
+    )
+
+    public fun Project.yamlKt(
+        version: String = KScienceVersions.Serialization.yamlKtVersion,
+    ): Unit = useCommonDependency(
+        "net.mamoe.yamlkt:yamlkt:$version",
+        dependencySourceSet = sourceSet,
+        dependencyConfiguration = configuration,
+    )
+}

src/main/kotlin/space/kscience/gradle/internal/common.kt

@@ -0,0 +1,54 @@
+package space.kscience.gradle.internal
+
+import org.gradle.api.artifacts.ProjectDependency
+import org.gradle.api.tasks.Copy
+import org.gradle.kotlin.dsl.get
+import org.jetbrains.kotlin.gradle.plugin.LanguageSettingsBuilder
+import space.kscience.gradle.KScienceVersions
+
+
+internal val defaultKotlinJvmArgs: List<String> =
+    listOf("-Xjvm-default=all", "-Xlambdas=indy"/* "-Xjdk-release=${KScienceVersions.JVM_TARGET}"*/)
+
+internal fun resolveKotlinVersion(): KotlinVersion {
+    val (major, minor, patch) = KScienceVersions.kotlinVersion.split(".", "-")
+    return KotlinVersion(major.toInt(), minor.toInt(), patch.toInt())
+}
+
+internal fun LanguageSettingsBuilder.applySettings(
+    kotlinVersion: KotlinVersion = resolveKotlinVersion(),
+) {
+    val versionString = "${kotlinVersion.major}.${kotlinVersion.minor}"
+    languageVersion = versionString
+    apiVersion = versionString
+    progressiveMode = true
+
+    optIn("kotlin.RequiresOptIn")
+    optIn("kotlin.ExperimentalUnsignedTypes")
+    optIn("kotlin.ExperimentalStdlibApi")
+    optIn("kotlin.time.ExperimentalTime")
+    optIn("kotlin.contracts.ExperimentalContracts")
+    optIn("kotlin.js.ExperimentalJsExport")
+}
+
+internal fun Copy.fromJsDependencies(configurationName: String) = project.run {
+    val configuration = configurations[configurationName]
+        ?: error("Configuration with name $configurationName could not be resolved.")
+    val projectDeps = configuration.allDependencies.filterIsInstance<ProjectDependency>().map {
+        it.dependencyProject
+    }
+    projectDeps.forEach { dep ->
+        dep.pluginManager.withPlugin("org.jetbrains.kotlin.multiplatform") {
+            dep.tasks.findByName("jsProcessResources")?.let { task ->
+                dependsOn(task)
+                from(task)
+            }
+        }
+        dep.pluginManager.withPlugin("org.jetbrains.kotlin.js") {
+            dep.tasks.findByName("processResources")?.let { task ->
+                dependsOn(task)
+                from(task)
+            }
+        }
+    }
+}

src/main/kotlin/space/kscience/gradle/internal/dependencies.kt

@@ -0,0 +1,119 @@
+package space.kscience.gradle.internal
+
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.configure
+import org.gradle.kotlin.dsl.invoke
+import org.jetbrains.kotlin.gradle.dsl.KotlinJsProjectExtension
+import org.jetbrains.kotlin.gradle.dsl.KotlinJvmProjectExtension
+import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
+import space.kscience.gradle.DependencyConfiguration
+import space.kscience.gradle.DependencySourceSet
+
+internal fun Project.useDependency(
+    vararg pairs: Pair<String, String>,
+    dependencySourceSet: DependencySourceSet = DependencySourceSet.MAIN,
+    dependencyConfiguration: DependencyConfiguration = DependencyConfiguration.IMPLEMENTATION
+) {
+    pluginManager.withPlugin("org.jetbrains.kotlin.multiplatform") {
+        configure<KotlinMultiplatformExtension> {
+            sourceSets {
+                pairs.forEach { (target, dep) ->
+                    val name = target + dependencySourceSet.suffix
+                    findByName(name)?.apply {
+                        dependencies {
+                            when (dependencyConfiguration) {
+                                DependencyConfiguration.API -> api(dep)
+                                DependencyConfiguration.IMPLEMENTATION -> implementation(dep)
+                                DependencyConfiguration.COMPILE_ONLY -> compileOnly(dep)
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    pairs.find { it.first == "jvm" }?.let { dep ->
+        pluginManager.withPlugin("org.jetbrains.kotlin.jvm") {
+            configure<KotlinJvmProjectExtension> {
+                sourceSets.findByName(dependencySourceSet.setName)?.apply {
+                    dependencies.apply {
+                        val configurationName = when (dependencyConfiguration) {
+                            DependencyConfiguration.API -> apiConfigurationName
+                            DependencyConfiguration.IMPLEMENTATION -> implementationConfigurationName
+                            DependencyConfiguration.COMPILE_ONLY -> compileOnlyConfigurationName
+                        }
+                        add(configurationName, dep.second)
+                    }
+                }
+            }
+        }
+    }
+
+    pairs.find { it.first == "js" }?.let { dep ->
+        pluginManager.withPlugin("org.jetbrains.kotlin.js") {
+            configure<KotlinJsProjectExtension> {
+                sourceSets.findByName(dependencySourceSet.setName)?.apply {
+                    dependencies.apply {
+                        val configurationName = when (dependencyConfiguration) {
+                            DependencyConfiguration.API -> apiConfigurationName
+                            DependencyConfiguration.IMPLEMENTATION -> implementationConfigurationName
+                            DependencyConfiguration.COMPILE_ONLY -> compileOnlyConfigurationName
+                        }
+                        add(configurationName, dep.second)
+                    }
+                }
+            }
+        }
+    }
+}
+
+internal fun Project.useCommonDependency(
+    dep: String,
+    dependencySourceSet: DependencySourceSet = DependencySourceSet.MAIN,
+    dependencyConfiguration: DependencyConfiguration = DependencyConfiguration.IMPLEMENTATION
+): Unit = pluginManager.run {
+    withPlugin("org.jetbrains.kotlin.multiplatform") {
+        configure<KotlinMultiplatformExtension> {
+            sourceSets.findByName("common${dependencySourceSet.suffix}")?.apply {
+                dependencies {
+                    when (dependencyConfiguration) {
+                        DependencyConfiguration.API -> api(dep)
+                        DependencyConfiguration.IMPLEMENTATION -> implementation(dep)
+                        DependencyConfiguration.COMPILE_ONLY -> compileOnly(dep)
+                    }
+                }
+            }
+        }
+    }
+
+    withPlugin("org.jetbrains.kotlin.jvm") {
+        configure<KotlinJvmProjectExtension> {
+            sourceSets.findByName(dependencySourceSet.setName)?.apply {
+                dependencies.apply {
+                    val configurationName = when (dependencyConfiguration) {
+                        DependencyConfiguration.API -> apiConfigurationName
+                        DependencyConfiguration.IMPLEMENTATION -> implementationConfigurationName
+                        DependencyConfiguration.COMPILE_ONLY -> compileOnlyConfigurationName
+                    }
+                    add(configurationName, dep)
+                }
+            }
+        }
+    }
+
+    withPlugin("org.jetbrains.kotlin.js") {
+        configure<KotlinJsProjectExtension> {
+            sourceSets.findByName(dependencySourceSet.setName)?.apply {
+                dependencies.apply {
+                    val configurationName = when (dependencyConfiguration) {
+                        DependencyConfiguration.API -> apiConfigurationName
+                        DependencyConfiguration.IMPLEMENTATION -> implementationConfigurationName
+                        DependencyConfiguration.COMPILE_ONLY -> compileOnlyConfigurationName
+                    }
+                    add(configurationName, dep)
+                }
+            }
+        }
+    }
+}

src/main/kotlin/space/kscience/gradle/internal/publishing.kt

@@ -0,0 +1,218 @@
+package space.kscience.gradle.internal
+
+import org.gradle.api.Project
+import org.gradle.api.publish.PublishingExtension
+import org.gradle.api.publish.maven.MavenPom
+import org.gradle.api.publish.maven.MavenPublication
+import org.gradle.api.tasks.bundling.Jar
+import org.gradle.kotlin.dsl.*
+import org.gradle.plugins.signing.SigningExtension
+import org.gradle.plugins.signing.SigningPlugin
+import org.jetbrains.kotlin.gradle.dsl.KotlinJsProjectExtension
+import org.jetbrains.kotlin.gradle.dsl.KotlinJvmProjectExtension
+import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.util.targets
+import space.kscience.gradle.isInDevelopment
+
+internal fun Project.requestPropertyOrNull(propertyName: String): String? = findProperty(propertyName) as? String
+    ?: System.getenv(propertyName)
+
+internal fun Project.requestProperty(propertyName: String): String = requestPropertyOrNull(propertyName)
+    ?: error("Property $propertyName not defined")
+
+
+internal fun Project.setupPublication(mavenPomConfiguration: MavenPom.() -> Unit = {}) = allprojects {
+    plugins.withId("maven-publish") {
+        configure<PublishingExtension> {
+
+            plugins.withId("org.jetbrains.kotlin.js") {
+                val kotlin: KotlinJsProjectExtension = extensions.findByType()!!
+
+                val sourcesJar by tasks.creating(Jar::class) {
+                    archiveClassifier.set("sources")
+                    kotlin.sourceSets.forEach {
+                        from(it.kotlin)
+                    }
+                }
+
+                publications.create<MavenPublication>("js") {
+                    kotlin.targets.flatMap { it.components }.forEach {
+                        from(it)
+                    }
+
+                    artifact(sourcesJar)
+                }
+
+            }
+
+            plugins.withId("org.jetbrains.kotlin.jvm") {
+                val kotlin = extensions.findByType<KotlinJvmProjectExtension>()!!
+
+                val sourcesJar by tasks.creating(Jar::class) {
+                    archiveClassifier.set("sources")
+                    kotlin.sourceSets.forEach {
+                        from(it.kotlin)
+                    }
+                }
+
+                publications.create<MavenPublication>("jvm") {
+                    kotlin.target.components.forEach {
+                        from(it)
+                    }
+
+                    artifact(sourcesJar)
+                }
+            }
+
+            // Process each publication we have in this project
+            publications.withType<MavenPublication> {
+                pom {
+                    name.set(project.name)
+                    description.set(project.description ?: project.name)
+
+                    scm {
+                        tag.set(project.version.toString())
+                    }
+
+                    mavenPomConfiguration()
+                }
+            }
+
+            plugins.withId("org.jetbrains.dokka") {
+                val dokkaJar by tasks.creating(Jar::class) {
+                    group = "documentation"
+                    archiveClassifier.set("javadoc")
+                    from(tasks.findByName("dokkaHtml"))
+                }
+                publications.withType<MavenPublication> {
+                    artifact(dokkaJar)
+                }
+            }
+
+            if (requestPropertyOrNull("publishing.signing.id") != null || requestPropertyOrNull("signing.gnupg.keyName") != null) {
+
+                if (!plugins.hasPlugin("signing")) {
+                    apply<SigningPlugin>()
+                }
+
+                extensions.configure<SigningExtension>("signing") {
+                    val signingId: String? = requestPropertyOrNull("publishing.signing.id")
+                    if (!signingId.isNullOrBlank()) {
+                        val signingKey: String = requestProperty("publishing.signing.key")
+                        val signingPassphrase: String = requestProperty("publishing.signing.passPhrase")
+
+                        // if key is provided, use it
+                        useInMemoryPgpKeys(signingId, signingKey, signingPassphrase)
+                    } // else use agent signing
+                    sign(publications)
+                }
+            } else {
+                logger.warn("Signing information is not provided. Skipping artefact signing.")
+            }
+        }
+    }
+}
+
+internal fun Project.addGithubPublishing(
+    githubOrg: String,
+    githubProject: String,
+) {
+    if (requestPropertyOrNull("publishing.enabled") != "true") {
+        logger.info("Skipping github publishing because publishing is disabled")
+        return
+    }
+    if (requestPropertyOrNull("publishing.github") != "false") {
+        logger.info("Skipping github publishing  because `publishing.github != true`")
+        return
+    }
+
+    val githubUser: String = requestProperty("publishing.github.user")
+    val githubToken: String = requestProperty("publishing.github.token")
+
+    allprojects {
+        plugins.withId("maven-publish") {
+            configure<PublishingExtension> {
+                logger.info("Adding github publishing to project [${project.name}]")
+
+                repositories.maven {
+                    name = "github"
+                    url = uri("https://maven.pkg.github.com/$githubOrg/$githubProject/")
+
+                    credentials {
+                        username = githubUser
+                        password = githubToken
+                    }
+                }
+            }
+        }
+    }
+}
+
+internal fun Project.addSpacePublishing(spaceRepo: String) {
+    if (requestPropertyOrNull("publishing.enabled") != "true") {
+        logger.info("Skipping space publishing because publishing is disabled")
+        return
+    }
+
+    if (requestPropertyOrNull("publishing.space") == "false") {
+        logger.info("Skipping space publishing because `publishing.space == false`")
+        return
+    }
+
+    val spaceUser: String = requestProperty("publishing.space.user")
+    val spaceToken: String = requestProperty("publishing.space.token")
+
+    allprojects {
+        plugins.withId("maven-publish") {
+            configure<PublishingExtension> {
+                project.logger.info("Adding mipt-npm Space publishing to project [${project.name}]")
+
+                repositories.maven {
+                    name = "space"
+                    url = uri(spaceRepo)
+
+                    credentials {
+                        username = spaceUser
+                        password = spaceToken
+                    }
+                }
+            }
+        }
+    }
+}
+
+internal fun Project.addSonatypePublishing() {
+    if (requestPropertyOrNull("publishing.enabled") != "true") {
+        logger.info("Skipping sonatype publishing because publishing is disabled")
+        return
+    }
+
+    if (isInDevelopment) {
+        logger.info("Sonatype publishing skipped for development version")
+        return
+    }
+
+    if (requestPropertyOrNull("publishing.sonatype") == "false") {
+        logger.info("Skipping sonatype publishing because `publishing.sonatype == false`")
+        return
+    }
+
+    val sonatypeUser: String = requestProperty("publishing.sonatype.user")
+    val sonatypePassword: String = requestProperty("publishing.sonatype.password")
+
+    allprojects {
+        plugins.withId("maven-publish") {
+            configure<PublishingExtension> {
+                repositories.maven {
+                    val sonatypeRepo = "https://s01.oss.sonatype.org/service/local/staging/deploy/maven2"
+                    name = "sonatype"
+                    url = uri(sonatypeRepo)
+
+                    credentials {
+                        username = sonatypeUser
+                        password = sonatypePassword
+                    }
+                }
+            }
+        }
+    }
+}

src/main/kotlin/space/kscience/gradle/pomConfig.kt

@@ -0,0 +1,24 @@
+package space.kscience.gradle
+
+import org.gradle.api.publish.maven.MavenPom
+
+public fun MavenPom.useApache2Licence(){
+    licenses {
+        license {
+            name.set("The Apache Software License, Version 2.0")
+            url.set("https://www.apache.org/licenses/LICENSE-2.0.txt")
+            distribution.set("repo")
+        }
+    }
+}
+
+public fun MavenPom.useSPCTeam(){
+    developers {
+        developer {
+            id.set("SPC")
+            name.set("Scientific programming centre")
+            organization.set("MIPT")
+            organizationUrl.set("https://sciprog.center/")
+        }
+    }
+}

src/main/resources/templates/ARTIFACT-TEMPLATE.md

@@ -0,0 +1,26 @@
+## Artifact:
+
+The Maven coordinates of this project are `${group}:${name}:${version}`.
+
+**Gradle Groovy:**
+```groovy
+repositories {
+    maven { url 'https://repo.kotlin.link' }
+    mavenCentral()
+}
+
+dependencies {
+    implementation '${group}:${name}:${version}'
+}
+```
+**Gradle Kotlin DSL:**
+```kotlin
+repositories {
+    maven("https://repo.kotlin.link")
+    mavenCentral()
+}
+
+dependencies {
+    implementation("${group}:${name}:${version}")
+}
+```

src/main/resources/templates/README-TEMPLATE.md

@@ -0,0 +1,15 @@
+# Module ${name}
+
+${description}
+
+<#if features?has_content>
+## Features
+
+${features}
+
+</#if>
+<#if published>
+## Usage
+
+${artifact}
+</#if>

src/test/kotlin/TestVersions.kt

@@ -0,0 +1,9 @@
+import org.junit.jupiter.api.Test
+import space.kscience.gradle.KScienceVersions
+
+class TestPlugins {
+    @Test
+    fun testVersions() {
+        println(KScienceVersions.coroutinesVersion)
+    }
+}