Merge pull request 'dev' (!55 ) from dev into master

Reviewed-on: #55
Merge pull request 'Kotlin 2.3.0' (!54 ) from beta/2.3.0-Beta1 into dev
2025-12-17 08:15:45 +03:00 · 2025-12-17 08:14:27 +03:00 · 2025-12-17 08:12:36 +03:00 · 2025-12-17 08:07:02 +03:00 · 2025-10-12 23:07:52 +03:00 · 2025-10-10 18:03:41 +03:00
40 changed files with 2237 additions and 1573 deletions
--- a/.github/workflows/build.yml
+++ b/.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: 21
+          distribution: liberica
+      - uses: gradle/gradle-build-action@v2
+        with:
+          arguments: build
--- a/.github/workflows/publish.yml
+++ b/.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: 21
+          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 }}
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,11 +1,11 @@
 # 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]
+## Unreleased
+
 ### Added

 ### Changed
@@ -18,92 +18,340 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0

 ### Security

-## [0.9.5]
+## 0.20.2-kotlin-2.3.0 - 2025-12-17
+
 ### Added
+
+- WasmWasi target
+
+### Changed
+
+- Kotlin 2.3.0
+- Maturity moved to kscience extension.
+- Readme extension now requires kscience extension.
+- Project plugin overhaul (not only publish)
+- ABI validation is configurable from the root project
+
+### Fixed
+
+- Context parameter flag
+- Deploy problem with opensavvy-resources
+
+## 0.19.0-kotlin-2.2.0 - 2025-07-24
+
+### Changed
+
+- Replace manual JS dependency resource handling with `opensavvy` plugin.
+- Replace `useContextRecievers` with `useContextParameters`.
+- Submodule readme generated for all projects, not only for root
+- Replace `wasm` plugin configuration block with `wasmJs`
+
+### Deprecated
+
+- `useContextRecievers`
+- `wasm` configuration block
+
+### Removed
+
+- `fullStackApplication` configuration. Replaced by optional field in `fullStack`
+- Jupyter integration
+
+## 0.17.0
+
+### Added
+
+- kotlinx-io dependency in version catalog
+
+### Changed
+
+- Use the new jvm executable option for full-stack instead of gradle application plugin.
+
+### Removed
+
+- `application` option
+
+### Fixed
+
+- Fix readme generation
+
+## 0.16.0-kotlin-2.1.0 - 2025-01-02
+
+### Changed
+
+- Kotlin 2.1.0
+- Publication to central via `com.vanniktech.maven.publish.base`
+
+## 0.15.4-kotlin-2.0.0 - 2024-06-04
+
+### Added
+
+- Pass `compose` extension to the kscience extension so compose dependencies could be called directly from kscience block
+
+### Changed
+
+- Use ES6 modules by default in JS
+- Kotlin 2.0
+
+## 0.15.2-kotlin-1.9.22 - 2024-02-09
+
+### Added
+
+- Add development mode for fullstack.
+
+### Changed
+
+- Kotlin 1.9.20
+- Remove publishing defaults for Space and GitHub. Now publishing repositories is configured quasi-manually. Property keys for username and tokens are generated automatically.
+- All publishing targets are enabled by default. Introduce `publishing.targets` variable to regulate what is added to the module.
+
+### Deprecated
+
+- JVM plugin in favor of Mpp.
+
+### Removed
+
+- JS plugin. It is deprecated in favor of MPP.
+- Unnecessary `dependsOn` for native dependencies. 
+- Groovy gradle dependency notation.
+
+## 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

-### Deprecated
-
 ### Removed
+
 - Publish plugin. Use MavenPublish instead

 ### Fixed
+
 - Removed unnecessary `afterEvaluate` for compatibility with gradle 7.0

-### Security
+## 0.9.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

-### Fixed
+## 0.8.4

-### Security
-
-## [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

-### Deprecated
-
-### Removed
-
 ### Fixed
+
 - Plugin loading order for publishing
 - Release task
 - Readme generation for multi-module project

-### Security
+## 0.8.1

-## [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

-### Deprecated
-
 ### Removed
+
 - kaml

 ### Fixed
+
 - Fix publishing load order for sonatype
 - Fix root project readme

-### Security
-
-## [0.7.4]
+## 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.
@@ -112,6 +360,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - 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`.
@@ -122,28 +371,25 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - 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.

-
-### Fixed
-
-### Security
-## [0.6.0]
+## 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.

-### Changed
-Publishing in bintray now is automatic.
-
-## [0.5.2]
+## 0.5.2

 ### Added
- Copy resources for jvm modules and jvm source sets in mpp.
+
+- Copy resources for jvm modules and jvm source sets in mpp.
--- a/README.md
+++ b/README.md
@@ -1,29 +1,19 @@
+[![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.

-## ru.mipt.npm.gradle.common
+## space.kscience.gradle.common
 A primary plugin. When used with kotlin-jvm, kotlin-js or kotlin-mulitplatform configures the project for appropriate target.

-## ru.mipt.npm.gradle.project
+## space.kscience.gradle.project
 Root project tool including JetBrains changelog plugin an kotlin binary compatibility validator tool.

-## ru.mipt.npm.gradle.publish
-Enables publishing to maven-central, bintray, Space and github.
-
-## ru.mipt.npm.gradle.mpp
-`= kotlin("multiplatform") + ru.mipt.npm.gradle.common`
+## space.kscience.gradle.mpp
+`= kotlin("multiplatform") + space.kscience.gradle.common`

 Includes JVM-IR and JS-IR-Browser targets.

-## ru.mipt.npm.gradle.jvm
-`= kotlin("jvm") + ru.mipt.npm.gradle.common`
-
-## ru.mipt.npm.gradle.js
-`= kotlin("js") + ru.mipt.npm.gradle.common`
-
-## ru.mipt.npm.gradle.native
-add default native targets to `ru.mipt.npm.gradle.mpp`
-
-## ru.mipt.npm.gradle.node
-add node target to `ru.mipt.npm.gradle.mpp`
+## space.kscience.gradle.jvm
+`= kotlin("jvm") + space.kscience.gradle.common`
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -1,20 +1,20 @@
 plugins {
    `java-gradle-plugin`
    `kotlin-dsl`
-    `maven-publish`
-    signing
-    id("org.jetbrains.changelog") version "1.1.2"
-    id("org.jetbrains.dokka") version "1.4.32"
+//    `maven-publish`
+    `version-catalog`
+    alias(libs.plugins.jetbrains.changelog)
+    alias(libs.plugins.jetbrains.dokka)
+    alias(libs.plugins.versions.update)
+    alias(libs.plugins.maven.publish.base)
 }

-group = "ru.mipt.npm"
-version = "0.9.5"
+group = "space.kscience"
+version = libs.versions.tools.get()

-description = "Build tools for DataForge and kscience projects"
+description = "Build tools for kotlin for science projects"

-changelog{
-    version = project.version.toString()
-}
+changelog.version.set(project.version.toString())

 repositories {
    mavenCentral()
@@ -22,167 +22,160 @@ repositories {
    maven("https://repo.kotlin.link")
 }

-val kotlinVersion = "1.5.0"
-
-java {
-    targetCompatibility = JavaVersion.VERSION_1_8
-}
-
-// Add plugins used in buildSrc as dependencies, also we should specify version only here
 dependencies {
-    implementation("org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion")
-    implementation("org.jetbrains.kotlin:kotlin-serialization:$kotlinVersion")
-    implementation("org.jetbrains.kotlinx:atomicfu-gradle-plugin:0.16.1")
-    implementation("org.jetbrains.dokka:dokka-gradle-plugin:1.4.32")
-    implementation("org.jetbrains.intellij.plugins:gradle-changelog-plugin:1.1.2")
-    implementation("org.jetbrains.kotlinx:binary-compatibility-validator:0.5.0")
+    api("org.jetbrains.kotlin:kotlin-gradle-plugin:${libs.versions.kotlin.asProvider().get()}")
+    api("org.gradle.toolchains:foojay-resolver:1.0.0")
+    api("com.vanniktech:gradle-maven-publish-plugin:0.34.0")
+    api("org.jetbrains.intellij.plugins:gradle-changelog-plugin:${libs.versions.changelog.get()}")
+    api("org.jetbrains.dokka:dokka-gradle-plugin:${libs.versions.dokka.get()}")
+
+    implementation("dev.opensavvy.resources.producer:dev.opensavvy.resources.producer.gradle.plugin:${libs.versions.opensavvy.resources.get()}")
+    implementation("dev.opensavvy.resources.consumer:dev.opensavvy.resources.consumer.gradle.plugin:${libs.versions.opensavvy.resources.get()}")
+
+    implementation(libs.kotlin.serialization)
+    implementation(libs.kotlinx.html)
+    implementation(libs.tomlj)
+
+    implementation(libs.freemarker)
+
+    testImplementation(kotlin("test"))
 }

-project.extensions.findByType<GradlePluginDevelopmentExtension>()?.apply {
-    plugins {
-        create("common") {
-            id = "ru.mipt.npm.gradle.common"
-            description = "The generalized kscience plugin that works in conjunction with any kotlin plugin"
-            implementationClass = "ru.mipt.npm.gradle.KScienceCommonPlugin"
-        }
+tasks.test {
+    useJUnitPlatform()
+}

+//declaring exported plugins
+
+gradlePlugin {
+    plugins {
        create("project") {
-            id = "ru.mipt.npm.gradle.project"
-            description = "The root plugin for multimodule project infrastructure"
-            implementationClass = "ru.mipt.npm.gradle.KScienceProjectPlugin"
+            id = "space.kscience.gradle.project"
+            description = "The root plugin for multi-module project infrastructure"
+            implementationClass = "space.kscience.gradle.KScienceProjectPlugin"
        }

        create("mpp") {
-            id = "ru.mipt.npm.gradle.mpp"
+            id = "space.kscience.gradle.mpp"
            description = "Pre-configured multiplatform project"
-            implementationClass = "ru.mipt.npm.gradle.KScienceMPPlugin"
+            implementationClass = "space.kscience.gradle.KScienceMPPlugin"
        }

        create("jvm") {
-            id = "ru.mipt.npm.gradle.jvm"
+            id = "space.kscience.gradle.jvm"
            description = "Pre-configured JVM project"
-            implementationClass = "ru.mipt.npm.gradle.KScienceJVMPlugin"
-        }
-
-        create("js") {
-            id = "ru.mipt.npm.gradle.js"
-            description = "Pre-configured JS project"
-            implementationClass = "ru.mipt.npm.gradle.KScienceJSPlugin"
-        }
-
-        create("native") {
-            id = "ru.mipt.npm.gradle.native"
-            description = "Additional native targets to be use alongside mpp"
-            implementationClass = "ru.mipt.npm.gradle.KScienceNativePlugin"
-        }
-
-        create("node") {
-            id = "ru.mipt.npm.gradle.node"
-            description = "Additional nodejs target to be use alongside mpp"
-            implementationClass = "ru.mipt.npm.gradle.KScienceNodePlugin"
+            implementationClass = "space.kscience.gradle.KScienceJVMPlugin"
        }
    }
 }

-afterEvaluate {
-    publishing {
-        val vcs = "https://github.com/mipt-npm/gradle-tools"
+tasks.register("version") {
+    group = "publishing"
+    val versionFileProvider = project.layout.buildDirectory.file("project-version.txt")
+    outputs.file(versionFileProvider)
+    doLast {
+        val versionFile = versionFileProvider.get().asFile
+        versionFile.createNewFile()
+        versionFile.writeText(project.version.toString())
+    }
+}

-        val sourcesJar: Jar by tasks.creating(Jar::class) {
-            archiveClassifier.set("sources")
-            from(sourceSets.named("main").get().allSource)
+//publishing version catalog
+
+catalog.versionCatalog {
+    from(files("gradle/libs.versions.toml"))
+}
+
+java {
+    withSourcesJar()
+    withJavadocJar()
+}
+
+//publishing the artifact
+mavenPublishing {
+    publishing.publications.create<MavenPublication>("version-catalog") {
+        from(components["versionCatalog"])
+        artifactId = "version-catalog"
+
+        pom {
+            name.set("version-catalog")
        }
+    }

-        val javadocsJar: Jar by tasks.creating(Jar::class) {
-            group = "documentation"
-            archiveClassifier.set("javadoc")
-            from(tasks.dokkaHtml)
-        }
+    val vcs = "https://git.sciprog.center/kscience/gradle-tools"

-        // Process each publication we have in this project
-        publications.filterIsInstance<MavenPublication>().forEach { publication ->
-            publication.apply {
-                artifact(sourcesJar)
-                artifact(javadocsJar)
+    pom {
+        name.set(project.name)
+        description.set(project.description)
+        url.set(vcs)

-                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)
-                        tag.set(project.version.toString())
-                    }
-                }
+        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")
            }
        }

-        val spaceRepo: String = "https://maven.pkg.jetbrains.space/mipt-npm/p/mipt-npm/maven"
-        val spaceUser: String? = project.findProperty("publishing.space.user") as? String
-        val spaceToken: String? = project.findProperty("publishing.space.token") as? String
-
-        if (spaceUser != null && spaceToken != null) {
-            project.logger.info("Adding mipt-npm Space publishing to project [${project.name}]")
-            repositories {
-                maven {
-                    name = "space"
-                    url = uri(spaceRepo)
-                    credentials {
-                        username = spaceUser
-                        password = spaceToken
-                    }
-
-                }
+        developers {
+            developer {
+                id.set("SPC")
+                name.set("Scientific Programming Centre")
+                organization.set("SPC")
+                organizationUrl.set("https://sciprog.center/")
            }
        }

-        val sonatypeUser: String? = project.findProperty("publishing.sonatype.user") as? String
-        val sonatypePassword: String? = project.findProperty("publishing.sonatype.password") as? String
+        scm {
+            url.set(vcs)
+            tag.set(project.version.toString())
+        }
+    }

-        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"
-            }
+    val spaceRepo = "https://maven.sciprog.center/kscience"
+    val spcUser: String? = findProperty("publishing.spc.user") as? String
+    val spcToken: String? = findProperty("publishing.spc.token") as? String

-            if (plugins.findPlugin("signing") == null) {
-                plugins.apply("signing")
-            }
+    if (spcUser != null && spcToken != null) {
+        publishing.repositories.maven {
+            name = "spc"
+            url = uri(spaceRepo)

-            repositories {
-                maven {
-                    name = "sonatype"
-                    url = uri(sonatypeRepo)
-                    credentials {
-                        username = sonatypeUser
-                        password = sonatypePassword
-                    }
-                }
-            }
-            signing {
-                //useGpgCmd()
-                sign(publications)
+            credentials {
+                username = spcUser
+                password = spcToken
            }
        }
    }

+    val centralUser: String? = project.findProperty("mavenCentralUsername") as? String
+    val centralPassword: String? = project.findProperty("mavenCentralPassword") as? String
+
+    if (centralUser != null && centralPassword != null) {
+        publishToMavenCentral()
+        signAllPublications()
+    }
 }

+kotlin {
+    abiValidation
+    explicitApiWarning()
+    jvmToolchain(21)
+}
+
+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>())
+}
+
+versionCatalogUpdate {
+    sortByKey.set(false)
+
+    keep.keepUnusedVersions = true
+}
+ 
--- a/gradle.properties
+++ b/gradle.properties
@@ -0,0 +1,5 @@
+kotlin.code.style=official
+
+nl.littlerobots.vcu.resolver=true
+
+org.jetbrains.dokka.experimental.gradle.pluginMode=V2Enabled
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -0,0 +1,115 @@
+[versions]
+# @pin
+kotlin = "2.3.0"
+# @pin
+tools = "0.20.2-kotlin-2.3.0"
+atomicfu = "0.29.0"
+changelog = "2.5.0"
+compose = "1.9.3"
+dokka = "2.1.0"
+jsBom = "2025.12.6"
+junit = "5.10.2"
+# @pin
+kotlin-jupyter = "0.15.0-634"
+kotlinx-benchmark = "0.4.15"
+kotlinx-cli = "0.3.6"
+kotlinx-coroutines = "1.10.2"
+kotlinx-datetime = "0.7.1"
+kotlinx-html = "0.12.0"
+kotlinx-knit = "0.5.0"
+kotlinx-nodejs = "0.0.7"
+kotlinx-serialization = "1.9.0"
+kotlinx-io = "0.8.2"
+kover = "0.9.4"
+ktor = "3.3.3"
+ksp = "2.3.4"
+logback = "1.5.22"
+slf4j = "2.0.17"
+xmlutil = "0.91.3"
+yamlkt = "0.13.0"
+opensavvy-resources = "0.6.0"
+
+[plugins]
+maven-publish = "com.vanniktech.maven.publish:0.35.0"
+maven-publish-base = "com.vanniktech.maven.publish.base:0.35.0"
+compose-compiler = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" }
+compose-jb = { id = "org.jetbrains.compose", version.ref = "compose" }
+jetbrains-changelog = { id = "org.jetbrains.changelog", version.ref = "changelog" }
+jetbrains-dokka = { id = "org.jetbrains.dokka", version.ref = "dokka" }
+kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }
+kotlin-android-extensions = { id = "org.jetbrains.kotlin.android.extensions", version.ref = "kotlin" }
+kotlin-dsl = "org.gradle.kotlin.kotlin-dsl:6.5.1"
+kotlin-multiplatform = { id = "org.jetbrains.kotlin.multiplatform", version.ref = "kotlin" }
+kotlin-jvm = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlin" }
+kotlin-js = { id = "org.jetbrains.kotlin.js", version.ref = "kotlin" }
+kotlin-jupyter-api = { id = "org.jetbrains.kotlin.jupyter.api", version.ref = "kotlin-jupyter" }
+kotlin-kapt = { id = "org.jetbrains.kotlin.kapt", 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" }
+atomicfu = { id = "org.jetbrains.kotlinx.atomicfu", version.ref = "atomicfu" }
+kotlinx-benchmark = { id = "org.jetbrains.kotlinx.benchmark", version.ref = "kotlinx-benchmark" }
+kotlinx-kover = { id = "org.jetbrains.kotlinx.kover", version.ref = "kover" }
+kscience-mpp = { id = "space.kscience.gradle.mpp", version.ref = "tools" }
+kscience-project = { id = "space.kscience.gradle.project", version.ref = "tools" }
+ksp = { id = "com.google.devtools.ksp", version.ref = "ksp" }
+ktor = { id = "io.ktor.plugin", version.ref = "ktor" }
+opensavvy-resources-producer = { id = "dev.opensavvy.resources.producer", version.ref = "opensavvy-resources" }
+opensavvy-resources-consumer = { id = "dev.opensavvy.resources.consumer", version.ref = "opensavvy-resources" }
+versions = "com.github.ben-manes.versions:0.53.0"
+versions-update = "nl.littlerobots.version-catalog-update:1.0.1"
+
+[libraries]
+atomicfu = { module = "org.jetbrains.kotlinx:atomicfu", version.ref = "atomicfu" }
+freemarker = "org.freemarker:freemarker:2.3.34"
+kotlin-js-wrappers = { module = "org.jetbrains.kotlin-wrappers:kotlin-wrappers-bom", version.ref = "jsBom" }
+kotlin-reflect = { module = "org.jetbrains.kotlin:kotlin-reflect", version.ref = "kotlin" }
+kotlin-sam-with-receiver-compiler-plugin-embeddable = { module = "org.jetbrains.kotlin:kotlin-sam-with-receiver-compiler-plugin-embeddable", version.ref = "kotlin" }
+kotlin-scripting-compiler-embeddable = { module = "org.jetbrains.kotlin:kotlin-scripting-compiler-embeddable", version.ref = "kotlin" }
+kotlin-serialization = { module = "org.jetbrains.kotlin:kotlin-serialization", version.ref = "kotlin" }
+kotlin-stdlib = { module = "org.jetbrains.kotlin:kotlin-stdlib", version.ref = "kotlin" }
+kotlin-test = { module = "org.jetbrains.kotlin:kotlin-test" }
+kotlinx-benchmark-runtime = { module = "org.jetbrains.kotlinx:kotlinx-benchmark-runtime", version.ref = "kotlinx-benchmark" }
+kotlinx-cli = { module = "org.jetbrains.kotlinx:kotlinx-cli", version.ref = "kotlinx-cli" }
+kotlinx-coroutines-android = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-android", version.ref = "kotlinx-coroutines" }
+kotlinx-coroutines-core = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "kotlinx-coroutines" }
+kotlinx-coroutines-debug = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-debug", version.ref = "kotlinx-coroutines" }
+kotlinx-coroutines-guava = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-guava", version.ref = "kotlinx-coroutines" }
+kotlinx-coroutines-javafx = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-javafx", version.ref = "kotlinx-coroutines" }
+kotlinx-coroutines-jdk8 = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-jdk8", version.ref = "kotlinx-coroutines" }
+kotlinx-coroutines-play-services = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-play-services", 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-slf4j = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-slf4j", version.ref = "kotlinx-coroutines" }
+kotlinx-coroutines-swing = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-swing", version.ref = "kotlinx-coroutines" }
+kotlinx-coroutines-test = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-test", version.ref = "kotlinx-coroutines" }
+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-properties = { module = "org.jetbrains.kotlinx:kotlinx-serialization-properties", version.ref = "kotlinx-serialization" }
+kotlinx-serialization-protobuf = { module = "org.jetbrains.kotlinx:kotlinx-serialization-protobuf", version.ref = "kotlinx-serialization" }
+kotlinx-browser = "org.jetbrains.kotlinx:kotlinx-browser:0.5.0"
+kotlinx-io-core = { module = "org.jetbrains.kotlinx:kotlinx-io-core", version.ref = "kotlinx-io" }
+kotlinx-io-bytestring = { module = "org.jetbrains.kotlinx:kotlinx-io-bytestring", version.ref = "kotlinx-io" }
+ksp-api = { module = "com.google.devtools.ksp:symbol-processing-api", version.ref = "ksp" }
+ktor-bom = { module = "io.ktor:ktor-bom", version.ref = "ktor" }
+logback-classic = { module = "ch.qos.logback:logback-classic", version.ref = "logback" }
+slf4j = { module = "org.slf4j:slf4j-api", version.ref = "slf4j" }
+tomlj = "org.tomlj:tomlj:1.1.1"
+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" }
--- a/gradle/wrapper/gradle-wrapper.jar
+++ b/gradle/wrapper/gradle-wrapper.jar
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.0-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.2.0-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
--- a/269
+++ b/269
@@ -1,7 +1,7 @@
-#!/usr/bin/env sh
+#!/bin/sh

 #
-# Copyright 2015 the original author or authors.
+# 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.
@@ -17,67 +17,101 @@
 #

 ##############################################################################
-##
-##  Gradle start up script for UN*X
-##
+#
+#   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
-PRG="$0"
-# Need this for relative symlinks.
-while [ -h "$PRG" ] ; do
-    ls=`ls -ld "$PRG"`
-    link=`expr "$ls" : '.*-> \(.*\)$'`
-    if expr "$link" : '/.*' > /dev/null; then
-        PRG="$link"
-    else
-        PRG=`dirname "$PRG"`"/$link"
-    fi
+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
-SAVED="`pwd`"
-cd "`dirname \"$PRG\"`/" >/dev/null
-APP_HOME="`pwd -P`"
-cd "$SAVED" >/dev/null
+
+APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit

 APP_NAME="Gradle"
-APP_BASE_NAME=`basename "$0"`
+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"
+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
-    ;;
-  MINGW* )
-    msys=true
-    ;;
-  NONSTOP* )
-    nonstop=true
-    ;;
+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
@@ -87,9 +121,9 @@ CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 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"
+        JAVACMD=$JAVA_HOME/jre/sh/java
    else
-        JAVACMD="$JAVA_HOME/bin/java"
+        JAVACMD=$JAVA_HOME/bin/java
    fi
    if [ ! -x "$JAVACMD" ] ; then
        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
@@ -98,7 +132,7 @@ Please set the JAVA_HOME variable in your environment to match the
 location of your Java installation."
    fi
 else
-    JAVACMD="java"
+    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
@@ -106,80 +140,95 @@ location of your Java installation."
 fi

 # Increase the maximum file descriptors if we can.
-if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
-    MAX_FD_LIMIT=`ulimit -H -n`
-    if [ $? -eq 0 ] ; then
-        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
-            MAX_FD="$MAX_FD_LIMIT"
-        fi
-        ulimit -n $MAX_FD
-        if [ $? -ne 0 ] ; then
-            warn "Could not set maximum file descriptor limit: $MAX_FD"
-        fi
-    else
-        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
-    fi
-fi
-
-# For Darwin, add options to specify how the application appears in the dock
-if $darwin; then
-    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
-fi
-
-# For Cygwin or MSYS, switch paths to Windows format before running java
-if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
-    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
-    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
-
-    JAVACMD=`cygpath --unix "$JAVACMD"`
-
-    # We build the pattern for arguments to be converted via cygpath
-    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
-    SEP=""
-    for dir in $ROOTDIRSRAW ; do
-        ROOTDIRS="$ROOTDIRS$SEP$dir"
-        SEP="|"
-    done
-    OURCYGPATTERN="(^($ROOTDIRS))"
-    # Add a user-defined pattern to the cygpath arguments
-    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
-        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
-    fi
-    # Now convert the arguments - kludge to limit ourselves to /bin/sh
-    i=0
-    for arg in "$@" ; do
-        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
-        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
-
-        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
-            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
-        else
-            eval `echo args$i`="\"$arg\""
-        fi
-        i=`expr $i + 1`
-    done
-    case $i in
-        0) set -- ;;
-        1) set -- "$args0" ;;
-        2) set -- "$args0" "$args1" ;;
-        3) set -- "$args0" "$args1" "$args2" ;;
-        4) set -- "$args0" "$args1" "$args2" "$args3" ;;
-        5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
-        6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
-        7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
-        8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
-        9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+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

-# Escape application args
-save () {
-    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
-    echo " "
-}
-APP_ARGS=`save "$@"`
+# 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.

-# Collect all arguments for the java command, following the shell quoting and substitution rules
-eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+# 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" "$@"
--- a/settings.gradle
+++ b/settings.gradle
@@ -1,2 +0,0 @@
-rootProject.name = 'gradle-tools'
-
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -0,0 +1,14 @@
+rootProject.name = "gradle-tools"
+
+pluginManagement {
+    repositories {
+        gradlePluginPortal()
+        mavenCentral()
+        maven("https://repo.kotlin.link")
+    }
+}
+
+plugins {
+    id("org.gradle.toolchains.foojay-resolver-convention") version("1.0.0")
+}
+
--- a/src/main/kotlin/ru/mipt/npm/gradle/KScienceCommonPlugin.kt
+++ b/src/main/kotlin/ru/mipt/npm/gradle/KScienceCommonPlugin.kt
@@ -1,166 +0,0 @@
-package ru.mipt.npm.gradle
-
-import org.gradle.api.Plugin
-import org.gradle.api.Project
-import org.gradle.api.plugins.JavaPluginExtension
-import org.gradle.api.tasks.Copy
-import org.gradle.api.tasks.testing.Test
-import org.gradle.kotlin.dsl.*
-import org.jetbrains.kotlin.gradle.dsl.KotlinJsProjectExtension
-import org.jetbrains.kotlin.gradle.dsl.KotlinJvmCompile
-import org.jetbrains.kotlin.gradle.dsl.KotlinJvmProjectExtension
-import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
-import ru.mipt.npm.gradle.internal.applyRepos
-import ru.mipt.npm.gradle.internal.applySettings
-import ru.mipt.npm.gradle.internal.fromJsDependencies
-
-open class KScienceCommonPlugin : Plugin<Project> {
-    override fun apply(project: Project): Unit = project.run {
-        //Common configuration
-        registerKScienceExtension()
-        repositories.applyRepos()
-
-        //Configuration for K-JVM plugin
-        pluginManager.withPlugin("org.jetbrains.kotlin.jvm") {
-            //logger.info("Applying KScience configuration for JVM project")
-            configure<KotlinJvmProjectExtension> {
-                explicitApiWarning()
-
-                sourceSets["main"].apply {
-                    languageSettings.applySettings()
-                }
-
-                sourceSets["test"].apply {
-                    languageSettings.applySettings()
-                    dependencies {
-                        implementation(kotlin("test-junit5"))
-                        implementation("org.junit.jupiter:junit-jupiter:5.6.1")
-                    }
-                }
-            }
-            tasks.withType<KotlinJvmCompile> {
-                kotlinOptions {
-                    useIR = true
-                    jvmTarget = KScienceVersions.JVM_TARGET.toString()
-                    freeCompilerArgs = freeCompilerArgs + "-Xjvm-default=all"
-                }
-            }
-
-            extensions.findByType<JavaPluginExtension>()?.apply {
-                targetCompatibility = KScienceVersions.JVM_TARGET
-            }
-
-            tasks.apply {
-                withType<Test> {
-                    useJUnitPlatform()
-                }
-            }
-        }
-
-        pluginManager.withPlugin("org.jetbrains.kotlin.js") {
-            //logger.info("Applying KScience configuration for JS project")
-            configure<KotlinJsProjectExtension> {
-                explicitApiWarning()
-
-                js(IR) {
-                    browser{
-                        commonWebpackConfig {
-                            cssSupport.enabled = true
-                        }
-                    }
-                }
-
-                sourceSets["main"].apply {
-                    languageSettings.applySettings()
-                }
-
-                sourceSets["test"].apply {
-                    languageSettings.applySettings()
-                    dependencies {
-                        implementation(kotlin("test-js"))
-                    }
-                }
-            }
-
-            (tasks.findByName("processResources") as? Copy)?.apply {
-                fromJsDependencies("runtimeClasspath")
-            }
-
-        }
-
-        pluginManager.withPlugin("org.jetbrains.kotlin.multiplatform") {
-            configure<KotlinMultiplatformExtension> {
-                explicitApiWarning()
-
-                jvm {
-                    compilations.all {
-                        kotlinOptions {
-                            useIR = true
-                            jvmTarget = KScienceVersions.JVM_TARGET.toString()
-                            freeCompilerArgs = freeCompilerArgs + "-Xjvm-default=all"
-                        }
-                    }
-                }
-
-                js(IR) {
-                    browser{
-                        commonWebpackConfig {
-                            cssSupport.enabled = true
-                        }
-                    }
-                }
-
-                sourceSets.invoke {
-                    val commonMain by getting
-                    val commonTest by getting {
-                        dependencies {
-                            implementation(kotlin("test-common"))
-                            implementation(kotlin("test-annotations-common"))
-                        }
-                    }
-                    val jvmMain by getting
-                    val jvmTest by getting {
-                        dependencies {
-                            implementation(kotlin("test-junit5"))
-                            implementation("org.junit.jupiter:junit-jupiter:5.6.1")
-                        }
-                    }
-                    val jsMain by getting
-                    val jsTest by getting {
-                        dependencies {
-                            implementation(kotlin("test-js"))
-                        }
-                    }
-                }
-
-                afterEvaluate {
-                    targets.all {
-                        sourceSets.all {
-                            languageSettings.applySettings()
-                        }
-                    }
-                }
-
-                (tasks.findByName("jsProcessResources") as? Copy)?.apply {
-                    fromJsDependencies("jsRuntimeClasspath")
-                }
-
-                extensions.findByType<JavaPluginExtension>()?.apply {
-                    targetCompatibility = KScienceVersions.JVM_TARGET
-                }
-
-                tasks.apply {
-                    withType<Test> {
-                        useJUnitPlatform()
-                    }
-                }
-            }
-        }
-
-        // apply dokka for all projects
-        if (!plugins.hasPlugin("org.jetbrains.dokka")) {
-            plugins.apply("org.jetbrains.dokka")
-        }
-
-    }
-}
--- a/src/main/kotlin/ru/mipt/npm/gradle/KScienceExtension.kt
+++ b/src/main/kotlin/ru/mipt/npm/gradle/KScienceExtension.kt
@@ -1,159 +0,0 @@
-package ru.mipt.npm.gradle
-
-import org.gradle.api.Project
-import org.gradle.api.plugins.ApplicationPlugin
-import org.gradle.api.publish.maven.plugins.MavenPublishPlugin
-import org.gradle.kotlin.dsl.apply
-import org.gradle.kotlin.dsl.findByType
-import org.jetbrains.kotlin.gradle.dsl.KotlinJsProjectExtension
-import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
-import org.jetbrains.kotlin.gradle.dsl.KotlinProjectExtension
-import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinNativeTarget
-import ru.mipt.npm.gradle.internal.defaultPlatform
-import ru.mipt.npm.gradle.internal.useCommonDependency
-import ru.mipt.npm.gradle.internal.useFx
-
-enum class FXModule(val artifact: String, vararg val dependencies: FXModule) {
-    BASE("javafx-base"),
-    GRAPHICS("javafx-graphics", BASE),
-    CONTROLS("javafx-controls", GRAPHICS, BASE),
-    FXML("javafx-fxml", BASE),
-    MEDIA("javafx-media", GRAPHICS, BASE),
-    SWING("javafx-swing", GRAPHICS, BASE),
-    WEB("javafx-web", CONTROLS, GRAPHICS, BASE)
-}
-
-enum class FXPlatform(val id: String) {
-    WINDOWS("win"),
-    LINUX("linux"),
-    MAC("mac")
-}
-
-enum class DependencyConfiguration {
-    API,
-    IMPLEMENTATION,
-    COMPILE_ONLY
-}
-
-enum class DependencySourceSet(val setName: String, val suffix: String) {
-    MAIN("main", "Main"),
-    TEST("test", "Test")
-}
-
-
-class KScienceExtension(val project: Project) {
-
-    /**
-     * Use coroutines-core with default version or [version]
-     */
-    fun useCoroutines(
-        version: String = KScienceVersions.coroutinesVersion,
-        sourceSet: DependencySourceSet = DependencySourceSet.MAIN,
-        configuration: DependencyConfiguration = DependencyConfiguration.API
-    ): Unit = project.useCommonDependency(
-        "org.jetbrains.kotlinx:kotlinx-coroutines-core:$version",
-        dependencySourceSet = sourceSet,
-        dependencyConfiguration = configuration
-    )
-
-    /**
-     * Use kotlinx-atmicfu plugin and library
-     */
-    fun useAtomic(
-        version: String = KScienceVersions.atomicVersion,
-        sourceSet: DependencySourceSet = DependencySourceSet.MAIN,
-        configuration: DependencyConfiguration = DependencyConfiguration.IMPLEMENTATION
-    ): Unit = project.run {
-        plugins.apply("kotlinx-atomicfu")
-        useCommonDependency(
-            "org.jetbrains.kotlinx:atomicfu:$version",
-            dependencySourceSet = sourceSet,
-            dependencyConfiguration = configuration
-        )
-    }
-
-    /**
-     * Use core serialization library and configure targets
-     */
-    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).apply(block)
-    }
-
-    fun useFx(
-        vararg modules: FXModule,
-        configuration: DependencyConfiguration = DependencyConfiguration.COMPILE_ONLY,
-        version: String = "11",
-        platform: FXPlatform = defaultPlatform
-    ) = project.useFx(modules.toList(), configuration, version, platform)
-
-    fun useHtml(
-        version: String = KScienceVersions.atomicVersion,
-        sourceSet: DependencySourceSet = DependencySourceSet.MAIN,
-        configuration: DependencyConfiguration = DependencyConfiguration.IMPLEMENTATION
-    ): Unit = project.useCommonDependency(
-        "org.jetbrains.kotlinx:kotlinx-html:$version",
-        dependencySourceSet = sourceSet,
-        dependencyConfiguration = configuration
-    )
-
-    /**
-     * Use kotlinx-datetime library with default version or [version]
-     */
-    fun useDateTime(version: String = KScienceVersions.dateTimeVersion){
-        project.useCommonDependency("org.jetbrains.kotlinx:kotlinx-datetime:$version")
-    }
-
-    /**
-     * Mark this module as an application module. JVM application should be enabled separately
-     */
-    fun application() {
-        project.extensions.findByType<KotlinProjectExtension>()?.apply {
-            explicitApi = null
-        }
-
-        project.pluginManager.withPlugin("org.jetbrains.kotlin.jvm") {
-            project.plugins.apply(ApplicationPlugin::class.java)
-        }
-
-        project.extensions.findByType<KotlinJsProjectExtension>()?.apply {
-            js {
-                binaries.executable()
-            }
-        }
-
-        project.extensions.findByType<KotlinMultiplatformExtension>()?.apply {
-            js {
-                binaries.executable()
-            }
-            targets.filterIsInstance<KotlinNativeTarget>().forEach {
-                it.binaries.executable()
-            }
-        }
-    }
-
-    fun publish() {
-        project.plugins.apply(MavenPublishPlugin::class)
-    }
-}
-
-internal fun Project.registerKScienceExtension() {
-    if (extensions.findByType<KScienceExtension>() == null) {
-        extensions.add("kscience", KScienceExtension(this))
-    }
-}
--- a/src/main/kotlin/ru/mipt/npm/gradle/KScienceJSPlugin.kt
+++ b/src/main/kotlin/ru/mipt/npm/gradle/KScienceJSPlugin.kt
@@ -1,16 +0,0 @@
-package ru.mipt.npm.gradle
-
-import org.gradle.api.Plugin
-import org.gradle.api.Project
-import org.gradle.kotlin.dsl.apply
-
-open class KScienceJSPlugin : Plugin<Project> {
-    override fun apply(project: Project): Unit = project.run {
-        if (plugins.findPlugin("org.jetbrains.kotlin.js") == null) {
-            pluginManager.apply("org.jetbrains.kotlin.js")
-        } else {
-            logger.info("Kotlin JS plugin is already present")
-        }
-        plugins.apply(KScienceCommonPlugin::class)
-    }
-}
--- a/src/main/kotlin/ru/mipt/npm/gradle/KScienceJVMPlugin.kt
+++ b/src/main/kotlin/ru/mipt/npm/gradle/KScienceJVMPlugin.kt
@@ -1,16 +0,0 @@
-package ru.mipt.npm.gradle
-
-import org.gradle.api.Plugin
-import org.gradle.api.Project
-import org.gradle.kotlin.dsl.apply
-
-open class KScienceJVMPlugin : Plugin<Project> {
-    override fun apply(project: Project): Unit = project.run {
-        if (plugins.findPlugin("org.jetbrains.kotlin.jvm") == null) {
-            pluginManager.apply("org.jetbrains.kotlin.jvm")
-        } else {
-            logger.info("Kotlin JVM plugin is already present")
-        }
-        plugins.apply(KScienceCommonPlugin::class)
-    }
-}
--- a/src/main/kotlin/ru/mipt/npm/gradle/KScienceMPPlugin.kt
+++ b/src/main/kotlin/ru/mipt/npm/gradle/KScienceMPPlugin.kt
@@ -1,16 +0,0 @@
-package ru.mipt.npm.gradle
-
-import org.gradle.api.Plugin
-import org.gradle.api.Project
-import org.gradle.kotlin.dsl.apply
-
-open class KScienceMPPlugin : Plugin<Project> {
-    override fun apply(project: Project): Unit = project.run {
-        if (plugins.findPlugin("org.jetbrains.kotlin.multiplatform") == null) {
-            pluginManager.apply("org.jetbrains.kotlin.multiplatform")
-        } else {
-            logger.info("Kotlin MPP plugin is already present")
-        }
-        plugins.apply(KScienceCommonPlugin::class)
-     }
-}
--- a/src/main/kotlin/ru/mipt/npm/gradle/KScienceNativePlugin.kt
+++ b/src/main/kotlin/ru/mipt/npm/gradle/KScienceNativePlugin.kt
@@ -1,68 +0,0 @@
-package ru.mipt.npm.gradle
-
-import org.gradle.api.Action
-import org.gradle.api.NamedDomainObjectContainer
-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.findPlugin
-import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
-import org.jetbrains.kotlin.gradle.plugin.KotlinSourceSet
-
-private fun KotlinMultiplatformExtension.sourceSets(configure: Action<NamedDomainObjectContainer<KotlinSourceSet>>): Unit =
-    (this as org.gradle.api.plugins.ExtensionAware).extensions.configure("sourceSets", configure)
-
-class KScienceNativePlugin : Plugin<Project> {
-    override fun apply(project: Project) = project.run {
-        //Apply multiplatform plugin is not applied, apply it
-        if (plugins.findPlugin("org.jetbrains.kotlin.multiplatform") == null) {
-            logger.info("Kotlin multiplatform plugin is not resolved. Adding it automatically")
-            pluginManager.apply("org.jetbrains.kotlin.multiplatform")
-        }
-        if (plugins.findPlugin(KScienceCommonPlugin::class) == null) {
-            logger.info("KScience plugin is not resolved. Adding it automatically")
-            pluginManager.apply(KScienceCommonPlugin::class)
-        }
-
-        configure<KotlinMultiplatformExtension> {
-            val hostOs = System.getProperty("os.name")
-
-            val isLinux = hostOs == "Linux"
-            val isMinGw = hostOs.startsWith("Windows")
-            val isMacOs = hostOs == "Mac OS X"
-
-            if (isLinux || isMinGw) {
-                linuxX64()
-            }
-            if (isMinGw) {
-                mingwX64()
-            }
-            if (isMacOs) {
-                macosX64()
-            }
-
-            sourceSets {
-                val commonMain = findByName("commonMain")!!
-                val commonTest = findByName("commonTest")!!
-
-                val nativeMain = create("nativeMain").apply {
-                    dependsOn(commonMain)
-                }
-
-                val nativeTest = create("nativeTest").apply {
-                    dependsOn(commonTest)
-                }
-
-                findByName("linuxX64Main")?.dependsOn(nativeMain)
-                findByName("linuxX64Test")?.dependsOn(nativeTest)
-
-                findByName("mingwX64Main")?.dependsOn(nativeMain)
-                findByName("mingwX64Test")?.dependsOn(nativeTest)
-
-                findByName("macosX64Main")?.dependsOn(nativeMain)
-                findByName("macosX64Test")?.dependsOn(nativeTest)
-            }
-        }
-    }
-}
--- a/src/main/kotlin/ru/mipt/npm/gradle/KScienceNodePlugin.kt
+++ b/src/main/kotlin/ru/mipt/npm/gradle/KScienceNodePlugin.kt
@@ -1,61 +0,0 @@
-package ru.mipt.npm.gradle
-
-import org.gradle.api.Action
-import org.gradle.api.NamedDomainObjectContainer
-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.findPlugin
-import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
-import org.jetbrains.kotlin.gradle.plugin.KotlinSourceSet
-
-private fun KotlinMultiplatformExtension.sourceSets(configure: Action<NamedDomainObjectContainer<KotlinSourceSet>>): Unit =
-    (this as org.gradle.api.plugins.ExtensionAware).extensions.configure("sourceSets", configure)
-
-/**
- * Create a separate target for node
- */
-class KScienceNodePlugin : Plugin<Project> {
-    override fun apply(target: Project) = target.run {
-        //Apply multiplatform plugin is not applied, apply it
-        if (plugins.findPlugin("org.jetbrains.kotlin.multiplatform") == null) {
-            logger.info("Kotlin multiplatform plugin is not resolved. Adding it automatically")
-            pluginManager.apply("org.jetbrains.kotlin.multiplatform")
-        }
-        if (plugins.findPlugin(KScienceCommonPlugin::class) == null) {
-            logger.info("KScience plugin is not resolved. Adding it automatically")
-            pluginManager.apply(KScienceCommonPlugin::class)
-        }
-
-        configure<KotlinMultiplatformExtension> {
-            js(name = "node", compiler = IR) {
-                nodejs()
-            }
-
-            sourceSets {
-                val commonMain = findByName("commonMain")!!
-                val commonTest = findByName("commonTest")!!
-
-                val jsCommonMain = create("jsCommonMain").apply {
-                    dependsOn(commonMain)
-                }
-
-                val jsCommonTest = create("jsCommonTest").apply {
-                    dependsOn(commonTest)
-                }
-
-                findByName("jsMain")?.dependsOn(jsCommonMain)
-                findByName("jsTest")?.dependsOn(jsCommonTest)
-
-                findByName("nodeMain")?.apply {
-                    dependsOn(jsCommonMain)
-                    dependencies {
-                        api("org.jetbrains.kotlinx:kotlinx-nodejs:${KScienceVersions.kotlinxNodeVersion}")
-                    }
-                }
-                findByName("nodeTest")?.dependsOn(jsCommonMain)
-            }
-        }
-    }
-}
--- a/src/main/kotlin/ru/mipt/npm/gradle/KScienceProjectPlugin.kt
+++ b/src/main/kotlin/ru/mipt/npm/gradle/KScienceProjectPlugin.kt
@@ -1,191 +0,0 @@
-package ru.mipt.npm.gradle
-
-import groovy.text.SimpleTemplateEngine
-import kotlinx.validation.ApiValidationExtension
-import kotlinx.validation.BinaryCompatibilityValidatorPlugin
-import org.gradle.api.Plugin
-import org.gradle.api.Project
-import org.gradle.kotlin.dsl.*
-import org.jetbrains.changelog.ChangelogPlugin
-import org.jetbrains.dokka.gradle.DokkaPlugin
-import org.jetbrains.dokka.gradle.DokkaTask
-import ru.mipt.npm.gradle.internal.*
-
-@Suppress("unused")
-class KSciencePublishingExtension(val project: Project) {
-    private var initializedFlag = false
-
-    fun configurePublications(vcsUrl: String) {
-        if (!initializedFlag) {
-            project.setupPublication(vcsUrl)
-            initializedFlag = true
-        }
-    }
-
-    /**
-     * github publishing
-     */
-    fun github(githubProject: String, githubOrg: String = "mipt-npm") {
-        //automatically initialize vcs using github
-        if (!initializedFlag) {
-            configurePublications("https://github.com/$githubOrg/$githubProject")
-        }
-        project.addGithubPublishing(githubOrg, githubProject)
-    }
-
-    /**
-     *  Space publishing
-     */
-    fun space(spaceRepo: String = "https://maven.pkg.jetbrains.space/mipt-npm/p/sci/maven") {
-        require(initializedFlag) { "The publishing is not set up use 'configurePublications' method to do so" }
-        project.addSpacePublishing(spaceRepo)
-    }
-
-//    // Bintray publishing
-//    var bintrayOrg: String? by project.extra
-//    var bintrayUser: String? by project.extra
-//    var bintrayApiKey: String? by project.extra
-//    var bintrayRepo: String? by project.extra
-
-    /**
-     *  Sonatype publishing
-     */
-    fun sonatype() {
-        require(initializedFlag) { "The publishing is not set up use 'configurePublications' method to do so" }
-        project.addSonatypePublishing()
-    }
-}
-
-
-/**
- * Apply extension and repositories
- */
-open class KScienceProjectPlugin : Plugin<Project> {
-    override fun apply(target: Project): Unit = target.run {
-        apply<ChangelogPlugin>()
-        apply<DokkaPlugin>()
-        apply<BinaryCompatibilityValidatorPlugin>()
-
-        val rootReadmeExtension = KScienceReadmeExtension(this)
-        extensions.add("ksciencePublish", KSciencePublishingExtension(this))
-        extensions.add("readme", rootReadmeExtension)
-
-        //Add readme generators to individual subprojects
-        subprojects {
-            val readmeExtension = KScienceReadmeExtension(this)
-            extensions.add("readme", readmeExtension)
-            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.additionalFiles.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<DokkaTask> {
-                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.additionalFiles.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
-                            val path = subproject.path.replaceFirst(":", "").replace(":", "/")
-                            val ext = subproject.extensions.findByType<KScienceReadmeExtension>()
-                            appendLine("<hr/>")
-                            appendLine("\n* ### [$name]($path)")
-                            if (ext != null) {
-                                appendLine("> ${ext.description}")
-                                appendLine(">\n> **Maturity**: ${ext.maturity}")
-                                val featureString = ext.featuresString(itemPrefix = "> - ", pathPrefix = "$path/")
-                                if (featureString.isNotBlank()) {
-                                    appendLine(">\n> **Features:**")
-                                    appendLine(featureString)
-                                }
-                            }
-                        }
-                        appendLine("<hr/>")
-                    }
-
-                    val rootReadmeProperties: Map<String, Any?> =
-                        rootReadmeExtension.actualizedProperties + ("modules" to modulesString)
-
-                    readmeFile.writeText(
-                        SimpleTemplateEngine().createTemplate(rootReadmeExtension.readmeTemplate)
-                            .make(rootReadmeProperties).toString()
-                    )
-                }
-
-            }
-        }
-
-        tasks.withType<DokkaTask> {
-            dependsOn(generateReadme)
-        }
-
-        //val patchChangelog by tasks.getting
-
-        val release by tasks.creating {
-            group = RELEASE_GROUP
-            description = "Publish development or production release based on version suffix"
-            dependsOn(generateReadme)
-        }
-
-        // Disable API validation for snapshots
-        if (isSnapshot()) {
-            extensions.findByType<ApiValidationExtension>()?.apply {
-                validationDisabled = true
-                logger.warn("API validation is disabled for snapshot or dev version")
-            }
-        }
-    }
-
-    companion object {
-        const val RELEASE_GROUP = "release"
-    }
-}
--- a/src/main/kotlin/ru/mipt/npm/gradle/KScienceReadmeExtension.kt
+++ b/src/main/kotlin/ru/mipt/npm/gradle/KScienceReadmeExtension.kt
@@ -1,99 +0,0 @@
-package ru.mipt.npm.gradle
-
-import groovy.text.SimpleTemplateEngine
-import kotlinx.validation.ApiValidationExtension
-import org.gradle.api.Project
-import org.gradle.kotlin.dsl.getByType
-import java.io.File
-
-enum class Maturity {
-    PROTOTYPE,
-    EXPERIMENTAL,
-    DEVELOPMENT,
-    STABLE
-}
-
-
-class KScienceReadmeExtension(val project: Project) {
-    var description: String = project.description ?: ""
-    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.getByType<ApiValidationExtension>().apply {
-                            project.logger.warn("$value project $projectName is excluded from API validation")
-                            ignoredProjects.add(projectName)
-                        }
-                    }
-                }
-            }
-        }
-
-    var readmeTemplate: File = project.file("docs/README-TEMPLATE.md")
-
-    data class Feature(val id: String, val description: String, val ref: String?, val name: String = id)
-
-    val features = ArrayList<Feature>()
-
-    @Deprecated("Use lambda builder instead")
-    fun feature(id: String, description: String, ref: String? = null, name: String = id) {
-        features.add(Feature(id, description, ref, name))
-    }
-
-    fun feature(id: String, ref: String? = null, name: String = id, description: () -> String) {
-        features.add(Feature(id, description(), ref, name))
-    }
-
-    private val properties: MutableMap<String, () -> Any?> = mutableMapOf(
-        "name" to { project.name },
-        "group" to { project.group },
-        "version" to { project.version },
-        "features" to { featuresString() }
-    )
-
-    val actualizedProperties
-        get() = properties.mapValues { (_, value) ->
-            value.invoke()
-        }
-
-    fun property(key: String, value: Any?) {
-        properties[key] = { value }
-    }
-
-    fun propertyByTemplate(key: String, template: String) {
-        val actual = actualizedProperties
-        properties[key] = { SimpleTemplateEngine().createTemplate(template).make(actual).toString() }
-    }
-
-    internal val additionalFiles = ArrayList<File>()
-
-    fun propertyByTemplate(key: String, template: File) {
-        val actual = actualizedProperties
-        properties[key] = { SimpleTemplateEngine().createTemplate(template).make(actual).toString() }
-        additionalFiles.add(template)
-    }
-
-    /**
-     * Generate a markdown string listing features
-     */
-    fun featuresString(itemPrefix: String = " - ", pathPrefix: String = "") = buildString {
-        features.forEach {
-            appendLine("$itemPrefix[${it.name}]($pathPrefix${it.ref ?: "#"}) : ${it.description}")
-        }
-    }
-
-    /**
-     * Generate a readme string from the stub
-     */
-    fun readmeString(): String? {
-        return if (readmeTemplate.exists()) {
-            val actual = actualizedProperties
-            SimpleTemplateEngine().createTemplate(readmeTemplate).make(actual).toString()
-        } else {
-            null
-        }
-    }
-}
--- a/src/main/kotlin/ru/mipt/npm/gradle/KScienceVersions.kt
+++ b/src/main/kotlin/ru/mipt/npm/gradle/KScienceVersions.kt
@@ -1,25 +0,0 @@
-package ru.mipt.npm.gradle
-
-import org.gradle.api.JavaVersion
-
-/**
- * Build constants
- */
-object KScienceVersions {
-    const val kotlinVersion = "1.5.0"
-    const val kotlinxNodeVersion = "0.0.7"
-    const val coroutinesVersion = "1.4.3"
-    const val serializationVersion = "1.1.0"
-    const val atomicVersion = "0.16.1"
-    const val ktorVersion = "1.5.3"
-    const val htmlVersion = "0.7.3"
-    const val dateTimeVersion = "0.1.1"
-
-    val JVM_TARGET = JavaVersion.VERSION_11
-
-    object Serialization{
-        const val xmlVersion = "0.81.2"
-        const val bsonVersion = "0.4.4"
-        const val yamlKtVersion = "0.9.0"
-    }
-}
--- a/src/main/kotlin/ru/mipt/npm/gradle/SerializationTargets.kt
+++ b/src/main/kotlin/ru/mipt/npm/gradle/SerializationTargets.kt
@@ -1,76 +0,0 @@
-package ru.mipt.npm.gradle
-
-import org.gradle.api.Project
-import org.gradle.kotlin.dsl.maven
-import org.gradle.kotlin.dsl.repositories
-import ru.mipt.npm.gradle.internal.useCommonDependency
-import ru.mipt.npm.gradle.internal.useDependency
-
-class SerializationTargets(
-    val sourceSet: DependencySourceSet,
-    val configuration: DependencyConfiguration
-) {
-
-    fun Project.json(
-        version: String = KScienceVersions.serializationVersion
-    ) {
-        useCommonDependency(
-            "org.jetbrains.kotlinx:kotlinx-serialization-json:$version",
-            dependencySourceSet = sourceSet,
-            dependencyConfiguration = configuration
-        )
-    }
-
-    fun Project.cbor(
-        version: String = KScienceVersions.serializationVersion
-    ) {
-        useCommonDependency(
-            "org.jetbrains.kotlinx:kotlinx-serialization-cbor:$version",
-            dependencySourceSet = sourceSet,
-            dependencyConfiguration = configuration
-        )
-    }
-
-    fun Project.protobuf(
-        version: String = KScienceVersions.serializationVersion
-    ) {
-        useCommonDependency(
-            "org.jetbrains.kotlinx:kotlinx-serialization-protobuf:$version",
-            dependencySourceSet = sourceSet,
-            dependencyConfiguration = configuration
-        )
-    }
-
-    fun Project.xml(
-        version: String = KScienceVersions.Serialization.xmlVersion
-    ) {
-        repositories {
-            maven("https://dl.bintray.com/pdvrieze/maven")
-        }
-        useCommonDependency(
-            "net.devrieze:xmlutil-serialization:$version",
-            dependencySourceSet = sourceSet,
-            dependencyConfiguration = configuration
-        )
-    }
-
-    fun Project.yamlKt(
-        version: String = KScienceVersions.Serialization.yamlKtVersion
-    ) {
-        useCommonDependency(
-            "net.mamoe.yamlkt:yamlkt:$version",
-            dependencySourceSet = sourceSet,
-            dependencyConfiguration = configuration
-        )
-    }
-
-    fun Project.bson(
-        version: String = KScienceVersions.Serialization.bsonVersion
-    ) {
-        useDependency(
-            "jvm" to "com.github.jershell:kbson:$version",
-            dependencySourceSet = sourceSet,
-            dependencyConfiguration = configuration
-        )
-    }
-}
--- a/src/main/kotlin/ru/mipt/npm/gradle/internal/common.kt
+++ b/src/main/kotlin/ru/mipt/npm/gradle/internal/common.kt
@@ -1,72 +0,0 @@
-package ru.mipt.npm.gradle.internal
-
-import org.gradle.api.artifacts.ProjectDependency
-import org.gradle.api.artifacts.dsl.RepositoryHandler
-import org.gradle.api.tasks.Copy
-import org.gradle.kotlin.dsl.get
-import org.gradle.kotlin.dsl.maven
-import org.jetbrains.kotlin.gradle.plugin.LanguageSettingsBuilder
-
-internal fun LanguageSettingsBuilder.applySettings(): Unit {
-    languageVersion = "1.5"
-    apiVersion = "1.5"
-    progressiveMode = true
-    useExperimentalAnnotation("kotlin.Experimental")
-    useExperimentalAnnotation("kotlin.ExperimentalUnsignedTypes")
-    useExperimentalAnnotation("kotlin.ExperimentalStdlibApi")
-    useExperimentalAnnotation("kotlin.time.ExperimentalTime")
-    useExperimentalAnnotation("kotlin.contracts.ExperimentalContracts")
-    useExperimentalAnnotation("kotlin.js.ExperimentalJsExport")
-}
-
-internal fun RepositoryHandler.applyRepos(): Unit {
-    mavenCentral()
-    maven("https://repo.kotlin.link")
-    maven("https://maven.pkg.jetbrains.space/public/p/kotlinx-html/maven")
-    maven("https://maven.pkg.jetbrains.space/kotlin/p/kotlin/kotlin-js-wrappers")
-}
-
-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)
-            }
-        }
-     }
-}
-
-
-//
-//internal fun Copy.copyJVMResources(configuration: Configuration): Unit = project.afterEvaluate {
-//    val projectDeps = configuration.allDependencies
-//        .filterIsInstance<ProjectDependency>()
-//        .map { it.dependencyProject }
-//
-//    projectDeps.forEach { dep ->
-//        dep.pluginManager.withPlugin("org.jetbrains.kotlin.multiplatform") {
-//            dep.tasks.findByName("jvmProcessResources")?.let { task ->
-//                dependsOn(task)
-//                from(task)
-//            }
-//        }
-//        dep.pluginManager.withPlugin("org.jetbrains.kotlin.jvm") {
-//            dep.tasks.findByName("processResources")?.let { task ->
-//                dependsOn(task)
-//                from(task)
-//            }
-//        }
-//    }
-//}
--- a/src/main/kotlin/ru/mipt/npm/gradle/internal/fx.kt
+++ b/src/main/kotlin/ru/mipt/npm/gradle/internal/fx.kt
@@ -1,61 +0,0 @@
-package ru.mipt.npm.gradle.internal
-
-import org.apache.tools.ant.taskdefs.condition.Os
-import org.gradle.api.Project
-import org.gradle.kotlin.dsl.findByType
-import org.jetbrains.kotlin.gradle.dsl.KotlinJvmProjectExtension
-import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
-import org.jetbrains.kotlin.gradle.plugin.KotlinDependencyHandler
-import ru.mipt.npm.gradle.DependencyConfiguration
-import ru.mipt.npm.gradle.FXModule
-import ru.mipt.npm.gradle.FXPlatform
-
-val defaultPlatform: FXPlatform = when {
-    Os.isFamily(Os.FAMILY_WINDOWS) -> FXPlatform.WINDOWS
-    Os.isFamily(Os.FAMILY_MAC) -> FXPlatform.MAC
-    Os.isFamily(Os.FAMILY_UNIX) -> FXPlatform.LINUX
-    else -> error("Platform not recognized")
-}
-
-private fun KotlinDependencyHandler.addFXDependencies(
-    modules: List<FXModule>,
-    configuration: DependencyConfiguration,
-    version: String = "14",
-    platform: FXPlatform = defaultPlatform
-) {
-    modules.flatMap { it.dependencies.toList() + it }.distinct().forEach {
-        val notation = "org.openjfx:${it.artifact}:$version:${platform.id}"
-        when (configuration) {
-            DependencyConfiguration.API -> api(notation)
-            DependencyConfiguration.IMPLEMENTATION -> implementation(notation)
-            DependencyConfiguration.COMPILE_ONLY -> compileOnly(notation)
-        }
-    }
-}
-
-internal fun Project.useFx(
-    modules: List<FXModule>,
-    configuration: DependencyConfiguration = DependencyConfiguration.COMPILE_ONLY,
-    version: String = "14",
-    platform: FXPlatform = defaultPlatform
-): Unit = afterEvaluate {
-    pluginManager.withPlugin("org.jetbrains.kotlin.multiplatform") {
-        extensions.findByType<KotlinMultiplatformExtension>()?.apply {
-            sourceSets.findByName("jvmMain")?.apply {
-                dependencies {
-                    addFXDependencies(modules, configuration = configuration, version = version, platform = platform)
-                }
-            }
-        }
-    }
-
-    pluginManager.withPlugin("org.jetbrains.kotlin.jvm") {
-        extensions.findByType<KotlinJvmProjectExtension>()?.apply {
-            sourceSets.findByName("main")?.apply {
-                dependencies {
-                    addFXDependencies(modules, configuration = configuration, version = version, platform = platform)
-                }
-            }
-        }
-    }
-}
--- a/src/main/kotlin/ru/mipt/npm/gradle/internal/publishing.kt
+++ b/src/main/kotlin/ru/mipt/npm/gradle/internal/publishing.kt
@@ -1,242 +0,0 @@
-package ru.mipt.npm.gradle.internal
-
-import org.gradle.api.Project
-import org.gradle.api.publish.PublishingExtension
-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.jetbrains.kotlin.gradle.dsl.KotlinJsProjectExtension
-import org.jetbrains.kotlin.gradle.dsl.KotlinJvmProjectExtension
-
-private fun Project.requestPropertyOrNull(propertyName: String): String? = findProperty(propertyName) as? String
-    ?: System.getenv(propertyName)
-
-private fun Project.requestProperty(propertyName: String): String = requestPropertyOrNull(propertyName)
-    ?: error("Property $propertyName not defined")
-
-
-internal fun Project.setupPublication(vcs: String) = allprojects {
-    plugins.withId("maven-publish") {
-        configure<PublishingExtension> {
-
-            plugins.withId("ru.mipt.npm.gradle.js") {
-                val kotlin = extensions.findByType<KotlinJsProjectExtension>()!!
-
-                val sourcesJar: Jar by tasks.creating(Jar::class) {
-                    archiveClassifier.set("sources")
-                    from(kotlin.sourceSets["main"].kotlin)
-                }
-
-                publications {
-                    create("js", MavenPublication::class) {
-                        from(components["kotlin"])
-                        artifact(sourcesJar)
-                    }
-                }
-            }
-
-            plugins.withId("ru.mipt.npm.gradle.jvm") {
-                val kotlin = extensions.findByType<KotlinJvmProjectExtension>()!!
-
-                val sourcesJar: Jar by tasks.creating(Jar::class) {
-                    archiveClassifier.set("sources")
-                    from(kotlin.sourceSets["main"].kotlin)
-                }
-
-                publications {
-                    create("jvm", MavenPublication::class) {
-                        from(components["kotlin"])
-                        artifact(sourcesJar)
-                    }
-                }
-            }
-
-            val dokkaJar: Jar by tasks.creating(Jar::class) {
-                group = "documentation"
-                archiveClassifier.set("javadoc")
-                from(tasks.findByName("dokkaHtml"))
-            }
-
-            // Process each publication we have in this project
-            afterEvaluate {
-                publications.withType<MavenPublication>().forEach { publication ->
-                    publication.artifact(dokkaJar)
-                    publication.pom {
-                        name.set(project.name)
-                        description.set(project.description ?: project.name)
-                        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)
-                            tag.set(project.version.toString())
-                            //developerConnection = "scm:git:[fetch=]/*ВАША ССЫЛКА НА .git файл*/[push=]/*Повторить предыдущую ссылку*/"
-                        }
-
-                    }
-                }
-            }
-        }
-    }
-}
-
-internal fun Project.isSnapshot() = version.toString().contains("dev") || version.toString().endsWith("SNAPSHOT")
-
-internal val Project.publicationTarget: String
-    get() {
-        val publicationPlatform = project.findProperty("publishing.platform") as? String
-        return if (publicationPlatform == null) {
-            "AllPublications"
-        } else {
-            publicationPlatform.capitalize() + "Publication"
-        }
-    }
-
-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 == false`")
-        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
-                        }
-                    }
-                }
-            }
-            val publicationTask = tasks.getByName("publish${publicationTarget}ToGithubRepository")
-            rootProject.tasks.findByName("release")?.dependsOn(publicationTask)
-        }
-    }
-}
-
-internal fun Project.addSpacePublishing(spaceRepo: String) {
-    if (requestPropertyOrNull("publishing.enabled") != "true") {
-        logger.info("Skipping github 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
-                        }
-
-                    }
-                }
-            }
-            val publicationTask = tasks.getByName("publish${publicationTarget}ToSpaceRepository")
-            rootProject.tasks.findByName("release")?.dependsOn(publicationTask)
-        }
-    }
-}
-
-internal fun Project.addSonatypePublishing() {
-    if(requestPropertyOrNull("publishing.enabled")!="true"){
-        logger.info("Skipping github publishing because publishing is disabled")
-        return
-    }
-    if (isSnapshot()) {
-        logger.info("Sonatype publishing skipped for dev 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")
-    val signingId: String? = requestPropertyOrNull("publishing.signing.id")
-
-    allprojects {
-        plugins.withId("maven-publish") {
-            configure<PublishingExtension> {
-                val sonatypeRepo: String = "https://oss.sonatype.org/service/local/staging/deploy/maven2"
-
-                if (plugins.findPlugin("signing") == null) {
-                    plugins.apply("signing")
-                }
-                extensions.configure<SigningExtension>("signing") {
-                    if (!signingId.isNullOrBlank()) {
-                        val signingKey: String = requestProperty("publishing.signing.key")
-                        val signingPassphrase: String = requestProperty("publishing.signing.passPhrase")
-
-                        //if key is provided, use it
-                        @Suppress("UnstableApiUsage")
-                        useInMemoryPgpKeys(signingId, signingKey, signingPassphrase)
-                    } // else use file signing
-                    sign(publications)
-                }
-
-                repositories {
-                    maven {
-                        name = "sonatype"
-                        url = uri(sonatypeRepo)
-                        credentials {
-                            username = sonatypeUser
-                            password = sonatypePassword
-                        }
-                    }
-                }
-            }
-            val publicationTask = tasks.getByName("publish${publicationTarget}ToSonatypeRepository")
-            rootProject.tasks.findByName("release")?.dependsOn(publicationTask)
-        }
-    }
-}
-
-//internal val Project.bintrayPublish: Boolean
-//    get() = (findProperty("publishing.bintray.publish") as? String)?.toBoolean() ?: false
-//internal val Project.bintrayOrg: String? get() = findProperty("publishing.bintray.org") as? String
-//internal val Project.bintrayUser: String? get() = findProperty("publishing.bintray.user") as? String
-//internal val Project.bintrayApiKey: String? get() = findProperty("publishing.bintray.apiKey") as? String
--- a/src/main/kotlin/space/kscience/gradle/KScienceExtension.kt
+++ b/src/main/kotlin/space/kscience/gradle/KScienceExtension.kt
@@ -0,0 +1,545 @@
+package space.kscience.gradle
+
+import org.gradle.api.Project
+import org.gradle.api.file.DuplicatesStrategy
+import org.gradle.api.plugins.ExtensionAware
+import org.gradle.api.provider.Property
+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.ExperimentalKotlinGradlePluginApi
+import org.jetbrains.kotlin.gradle.ExperimentalWasmDsl
+import org.jetbrains.kotlin.gradle.dsl.HasConfigurableKotlinCompilerOptions
+import org.jetbrains.kotlin.gradle.dsl.KotlinCommonCompilerOptions
+import org.jetbrains.kotlin.gradle.dsl.KotlinJvmProjectExtension
+import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
+import org.jetbrains.kotlin.gradle.plugin.KotlinCompilation
+import org.jetbrains.kotlin.gradle.plugin.KotlinDependencyHandler
+import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinNativeTarget
+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.KotlinWasmJsTargetDsl
+import org.jetbrains.kotlin.gradle.targets.js.dsl.KotlinWasmWasiTargetDsl
+import org.jetbrains.kotlin.gradle.targets.jvm.KotlinJvmTarget
+import space.kscience.gradle.internal.defaultKotlinJvmOpts
+import space.kscience.gradle.internal.requestPropertyOrNull
+import space.kscience.gradle.internal.useCommonDependency
+import javax.inject.Inject
+
+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")
+}
+
+public enum class Maturity {
+    PROTOTYPE,
+    EXPERIMENTAL,
+    DEVELOPMENT,
+    STABLE,
+    DEPRECATED
+}
+
+/**
+ * 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")
+
+
+/**
+ *  Check if the project has a kscience extension that declares it as immature. Returns true if the project does not have readme extension
+ */
+public fun Project.isMature(): Boolean = extensions.findByType<KSciencePlatformExtension>()?.let { ext ->
+    ext.maturity == Maturity.DEVELOPMENT && ext.maturity == Maturity.STABLE
+} ?: true
+
+
+private const val defaultJdkVersion = 21
+
+public interface KSciencePlatformExtension: ExtensionAware {
+    public val project: Project
+    public var maturity: Maturity
+}
+
+public abstract class KScienceExtension @Inject constructor(override val project: Project) : KSciencePlatformExtension {
+
+    public val jdkVersionProperty: Property<Int> = project.objects.property<Int>().apply {
+        set(defaultJdkVersion)
+    }
+
+    public var jdkVersion: Int by jdkVersionProperty
+
+
+    override var maturity: Maturity = Maturity.EXPERIMENTAL
+
+    /**
+     * 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()
+    }
+
+    /**
+     * 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.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.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)
+
+
+    /**
+     * Add context parameters to the project
+     */
+    public fun useContextParameters() {
+        @Suppress("UNCHECKED_CAST")
+        (project.extensions.getByName("kotlin") as? HasConfigurableKotlinCompilerOptions<KotlinCommonCompilerOptions>)?.compilerOptions {
+            freeCompilerArgs.addAll("-Xcontext-parameters")
+        }
+    }
+
+    @Deprecated("Use useContextParameters", ReplaceWith("useContextParameters()"))
+    public fun useContextReceivers(): Unit = useContextParameters()
+
+    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 wasmJsMain: DefaultSourceSet get() = DefaultSourceSet("wasmJsMain")
+    public val wasmJsTest: DefaultSourceSet get() = DefaultSourceSet("wasmJsTest")
+
+}
+
+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.macosArm64)
+        public val iosX64: KScienceNativeTarget = KScienceNativeTarget(KotlinNativePreset.iosX64)
+        public val iosArm64: KScienceNativeTarget = KScienceNativeTarget(KotlinNativePreset.iosArm64)
+        public val iosSimulatorArm64: KScienceNativeTarget = KScienceNativeTarget(KotlinNativePreset.iosSimulatorArm64)
+    }
+}
+
+public class KScienceNativeConfiguration(private val project: Project) {
+
+
+    internal companion object {
+        private fun defaultNativeTargets(project: Project): Set<KScienceNativeTarget> =
+            when (val targets = project.requestPropertyOrNull("publishing.targets")) {
+                null -> setOf(
+                    KScienceNativeTarget.linuxX64,
+                    KScienceNativeTarget.mingwX64,
+                    KScienceNativeTarget.macosX64,
+                    KScienceNativeTarget.macosArm64,
+                    KScienceNativeTarget.iosX64,
+                    KScienceNativeTarget.iosArm64,
+                    KScienceNativeTarget.iosSimulatorArm64,
+                )
+
+                else -> targets.split(",").mapTo(HashSet()) {
+                    KScienceNativeTarget(KotlinNativePreset.valueOf(it))
+                }
+            }
+    }
+
+
+    internal var targets: Set<KScienceNativeTarget> = defaultNativeTargets(project)
+
+
+    /**
+     * Replace all targets
+     */
+    public fun setTargets(vararg target: KScienceNativeTarget) {
+        targets = target.toSet()
+    }
+
+    /**
+     * Add a native target
+     */
+    public fun target(target: KScienceNativeTarget) {
+        targets += target
+    }
+
+    public fun target(
+        preset: KotlinNativePreset,
+        targetName: String = preset.name,
+        targetConfiguration: KotlinNativeTarget.() -> Unit = { },
+    ): Unit = target(KScienceNativeTarget(preset, targetName, targetConfiguration))
+}
+
+public abstract class KScienceMppExtension @Inject constructor(project: Project) : KScienceExtension(project) {
+
+
+    @OptIn(ExperimentalKotlinGradlePluginApi::class)
+    public fun KotlinJvmTarget.application(
+        mainClassName: String
+    ) {
+        binaries {
+            executable {
+                mainClass.set(mainClassName)
+            }
+        }
+    }
+
+    public fun KotlinJsTargetDsl.application(
+        moduleName: String? = null,
+    ) {
+        binaries.executable()
+        this.project.plugins.apply("dev.opensavvy.resources.consumer")
+        moduleName?.let {
+            outputModuleName.set(moduleName)
+        }
+    }
+
+    /**
+     * Enable jvm target
+     */
+    public fun jvm(block: KotlinJvmTarget.() -> Unit = {}) {
+        project.pluginManager.withPlugin("org.jetbrains.kotlin.multiplatform") {
+            project.configure<KotlinMultiplatformExtension> {
+                jvm {
+                    compilerOptions {
+                        defaultKotlinJvmOpts()
+                    }
+                    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 {
+                    browser()
+                    useEsModules()
+                    block()
+                }
+                sourceSets {
+                    getByName("jsMain") {
+                        dependencies {
+                            api(project.dependencies.platform("org.jetbrains.kotlin-wrappers:kotlin-wrappers-bom:${KScienceVersions.jsBom}"))
+                        }
+                    }
+                    getByName("jsTest") {
+                        dependencies {
+                            implementation(kotlin("test-js"))
+                        }
+                    }
+                }
+            }
+        }
+        project.plugins.apply("dev.opensavvy.resources.producer")
+    }
+
+    /**
+     * Add Wasm/Js target
+     */
+    @OptIn(ExperimentalWasmDsl::class)
+    public fun wasmJs(block: KotlinWasmJsTargetDsl.() -> Unit = {}) {
+
+        project.pluginManager.withPlugin("org.jetbrains.kotlin.multiplatform") {
+            project.configure<KotlinMultiplatformExtension> {
+                wasmJs {
+                    browser {
+                        testTask {
+                            useKarma {
+                                useChromeHeadless()
+                            }
+                        }
+                    }
+                    useEsModules()
+                    block()
+                }
+                sourceSets {
+                    getByName("wasmJsTest") {
+                        dependencies {
+                            implementation(kotlin("test-wasm-js"))
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    @OptIn(ExperimentalWasmDsl::class)
+    public fun wasmWasi(block: KotlinWasmWasiTargetDsl.() -> Unit = {}) {
+        project.pluginManager.withPlugin("org.jetbrains.kotlin.multiplatform") {
+            project.configure<KotlinMultiplatformExtension> {
+                wasmWasi {
+                    block()
+                }
+                sourceSets {
+                    getByName("wasmWasiTest") {
+                        dependencies {
+                            implementation(kotlin("test-wasm-wasi"))
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    @Deprecated("Use wasmJs", ReplaceWith("wasmJs(block)"))
+    public fun wasm(block: KotlinWasmJsTargetDsl.() -> Unit = {}): Unit = wasmJs(block)
+
+    public fun jvmAndJs() {
+        jvm()
+        js()
+    }
+
+    /**
+     * Jvm and Js source sets including copy of Js bundle into JVM resources
+     *
+     * @param mainClassName if present, create a jvm application with it as an entry point
+     */
+    public fun fullStack(
+        bundleName: String = "js/bundle.js",
+        mainClassName: String? = null,
+        development: Boolean = false,
+        jvmConfig: KotlinJvmTarget.() -> Unit = {},
+        jsConfig: KotlinJsTargetDsl.() -> Unit = {},
+        browserConfig: KotlinJsBrowserDsl.() -> Unit = {},
+    ) {
+        js {
+            browser {
+                commonWebpackConfig {
+                    outputFileName = bundleName
+                }
+                browserConfig()
+            }
+            useEsModules()
+            jsConfig()
+            application()
+        }
+        jvm {
+            val processResourcesTaskName =
+                compilations[KotlinCompilation.MAIN_COMPILATION_NAME].processResourcesTaskName
+
+
+            val jsBrowserDistribution = project.tasks.getByName(
+                if (development) "jsBrowserDevelopmentExecutableDistribution" else "jsBrowserDistribution"
+            )
+
+            project.tasks.getByName<ProcessResources>(processResourcesTaskName) {
+                duplicatesStrategy = DuplicatesStrategy.WARN
+                dependsOn(jsBrowserDistribution)
+                from(jsBrowserDistribution)
+            }
+            mainClassName?.let {
+                application(it)
+            }
+
+            jvmConfig()
+        }
+    }
+
+    /**
+     * Executable fullstack application
+     */
+    @Deprecated(
+        "Use fullStack",
+        ReplaceWith("fullStack(bundleName, mainClassName, development, jvmConfig, jsConfig, browserConfig)")
+    )
+    public fun fullStackApplication(
+        mainClassName: String,
+        bundleName: String = "js/bundle.js",
+        development: Boolean = false,
+        jvmConfig: KotlinJvmTarget.() -> Unit = {},
+        jsConfig: KotlinJsTargetDsl.() -> Unit = {},
+        browserConfig: KotlinJsBrowserDsl.() -> Unit = {},
+    ): Unit = fullStack(
+        bundleName = bundleName,
+        mainClassName = mainClassName,
+        development = development,
+        jvmConfig = jvmConfig,
+        jsConfig = jsConfig,
+        browserConfig = browserConfig
+    )
+
+    /**
+     * Enable all supported native targets
+     */
+    public fun native(block: KScienceNativeConfiguration.() -> Unit = {}): Unit = with(project) {
+        val nativeConfiguration = KScienceNativeConfiguration(this).apply(block)
+        pluginManager.withPlugin("org.jetbrains.kotlin.multiplatform") {
+            configure<KotlinMultiplatformExtension> {
+                nativeConfiguration.targets.forEach { 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
+                        )
+                    }
+                }
+                applyDefaultHierarchyTemplate()
+            }
+        }
+    }
+}
+
+
+internal inline fun <reified T : KScienceExtension> Project.registerKScienceExtension(): T {
+//    extensions.findByType<T>()?.let { return it }
+//    return constructor(this).also {
+//        extensions.add("kscience", it)
+//    }
+
+    return extensions.create("kscience", T::class.java)
+}
--- a/src/main/kotlin/space/kscience/gradle/KScienceJVMPlugin.kt
+++ b/src/main/kotlin/space/kscience/gradle/KScienceJVMPlugin.kt
@@ -0,0 +1,61 @@
+package space.kscience.gradle
+
+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 space.kscience.gradle.internal.applySettings
+import space.kscience.gradle.internal.defaultKotlinCommonArgs
+import space.kscience.gradle.internal.defaultKotlinJvmOpts
+
+public open class KScienceJVMPlugin : KSciencePlugin {
+    override fun apply(project: Project): Unit = project.run {
+
+        logger.warn("KScience JVM plugin is deprecated. Use MPP.")
+        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()
+                compilerOptions{
+                    defaultKotlinJvmOpts()
+                    compilerOptions.freeCompilerArgs.addAll(defaultKotlinCommonArgs)
+                }
+            }
+
+            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<Test> {
+            useJUnitPlatform()
+        }
+
+        // apply dokka for all projects
+        if (!plugins.hasPlugin("org.jetbrains.dokka")) {
+            apply<DokkaPlugin>()
+        }
+    }
+
+}
--- a/src/main/kotlin/space/kscience/gradle/KScienceMPPlugin.kt
+++ b/src/main/kotlin/space/kscience/gradle/KScienceMPPlugin.kt
@@ -0,0 +1,62 @@
+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.invoke
+import org.jetbrains.dokka.gradle.DokkaPlugin
+import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
+import space.kscience.gradle.internal.applySettings
+import space.kscience.gradle.internal.defaultKotlinCommonArgs
+
+public interface KSciencePlugin : Plugin<Project>
+
+public open class KScienceMPPlugin : KSciencePlugin {
+
+    override fun apply(project: Project): Unit = project.run {
+        if (!plugins.hasPlugin("org.jetbrains.kotlin.multiplatform")) {
+            //apply<KotlinMultiplatformPlugin>() for some reason it does not work
+            plugins.apply("org.jetbrains.kotlin.multiplatform")
+        } else {
+            logger.info("Kotlin MPP plugin is already present")
+        }
+
+        val kscience = registerKScienceExtension<KScienceMppExtension>()
+
+        configure<KotlinMultiplatformExtension> {
+            compilerOptions {
+                freeCompilerArgs.add("-Xexpect-actual-classes")
+            }
+            sourceSets {
+                getByName("commonTest") {
+                    dependencies {
+                        implementation(kotlin("test"))
+                        implementation(kotlin("test-annotations-common"))
+                    }
+                }
+                all {
+                    languageSettings.applySettings()
+                    compilerOptions.freeCompilerArgs.addAll(defaultKotlinCommonArgs)
+                }
+            }
+
+            if (explicitApi == null) explicitApiWarning()
+
+            //pass compose extension inside kscience extensions to make it available inside kscience block
+            plugins.withId("org.jetbrains.compose") {
+                kscience.extensions.add(
+                    "compose",
+                    (this@configure as org.gradle.api.plugins.ExtensionAware).extensions.getByName("compose")
+                )
+            }
+
+        }
+
+
+        // apply dokka for all projects
+        if (!plugins.hasPlugin("org.jetbrains.dokka")) {
+            apply<DokkaPlugin>()
+        }
+    }
+}
--- a/src/main/kotlin/space/kscience/gradle/KScienceProjectPlugin.kt
+++ b/src/main/kotlin/space/kscience/gradle/KScienceProjectPlugin.kt
@@ -0,0 +1,188 @@
+package space.kscience.gradle
+
+import com.vanniktech.maven.publish.MavenPublishBaseExtension
+import com.vanniktech.maven.publish.MavenPublishBasePlugin
+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.DokkaPlugin
+import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
+import org.jetbrains.kotlin.gradle.dsl.abi.AbiValidationVariantSpec
+import org.jetbrains.kotlin.gradle.targets.js.yarn.YarnLockMismatchReport
+import org.jetbrains.kotlin.gradle.targets.js.yarn.YarnPlugin
+import org.jetbrains.kotlin.gradle.targets.js.yarn.YarnRootExtension
+import org.jetbrains.kotlin.gradle.targets.wasm.yarn.WasmYarnPlugin
+import org.jetbrains.kotlin.gradle.targets.wasm.yarn.WasmYarnRootExtension
+import space.kscience.gradle.internal.addPublishing
+import space.kscience.gradle.internal.setupPublication
+import space.kscience.gradle.internal.withKScience
+import javax.inject.Inject
+
+/**
+ * Simplifies adding repositories for Maven publishing, responds for releasing tasks for projects.
+ */
+public abstract class KScienceProjectExtension @Inject constructor(override val project: Project) :
+    KSciencePlatformExtension {
+
+    override var maturity: Maturity = Maturity.EXPERIMENTAL
+
+    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
+        }
+    }
+
+    /**
+     * Add a repository with [repositoryName]. Uses "publishing.$repositoryName.user" and "publishing.$repositoryName.token"
+     * properties pattern to store user and token
+     */
+    public fun publishTo(
+        repositoryName: String,
+        url: String,
+    ) {
+        require(isVcsInitialized) { "The project vcs is not set up use 'pom' method to do so" }
+        project.addPublishing(repositoryName, url)
+    }
+
+    /**
+     * Add publishing to maven central "new" API
+     */
+    public fun publishToCentral(): Unit = with(project) {
+        require(isVcsInitialized) { "The project vcs is not set up use 'pom' method to do so" }
+        if (isInDevelopment) {
+            logger.info("Maven central publishing skipped for development version")
+        } else {
+            allprojects {
+                plugins.withType<MavenPublishBasePlugin> {
+                    extensions.configure<MavenPublishBaseExtension> {
+                        publishToMavenCentral()
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * Configure ABI validation for the project and all subprojects.
+     */
+    public fun abiValidation(block: AbiValidationVariantSpec.() -> Unit): Unit = project.allprojects {
+        extensions.findByType<KotlinMultiplatformExtension>()?.apply {
+            extensions.findByType<AbiValidationVariantSpec>()?.apply(block)
+        }
+    }
+//
+//    @Suppress("UNCHECKED_CAST")
+//    public fun kotlinCompilerOptions(block: KotlinCommonCompilerOptions.() -> Unit): Unit = project.allprojects {
+//        (project.extensions.getByName("kotlin") as? HasConfigurableKotlinCompilerOptions<KotlinCommonCompilerOptions>)?.compilerOptions(
+//            block
+//        )
+//    }
+}
+
+
+/**
+ * Applies third-party plugins (Dokka, Changelog); configures Maven publishing, README
+ * generation.
+ */
+public open class KScienceProjectPlugin : Plugin<Project> {
+
+
+    override fun apply(target: Project): Unit = target.run {
+        apply<ChangelogPlugin>()
+        apply<DokkaPlugin>()
+
+        val kscienceProjectExtension = extensions.create("kscienceProject", KScienceProjectExtension::class.java)
+
+        //configure readme for root project
+        kscienceProjectExtension.configureReadme()
+
+        allprojects {
+
+            //Add repositories
+            repositories {
+                mavenCentral()
+                maven("https://repo.kotlin.link")
+                google()
+            }
+
+            // Workaround for https://github.com/gradle/gradle/issues/15568
+            tasks.withType<AbstractPublishToMaven>().configureEach {
+                mustRunAfter(tasks.withType<Sign>())
+            }
+
+            //configure readme for all subprojects that have KScience plugins. If the root project also has the kscience plugin, it is skipped.
+            withKScience {
+                configureReadme()
+            }
+        }
+
+
+        tasks.register("version") {
+            group = "publishing"
+            val versionFileProvider = project.layout.buildDirectory.file("project-version.txt")
+            outputs.file(versionFileProvider)
+            doLast {
+                val versionFile = versionFileProvider.get().asFile
+                versionFile.createNewFile()
+                versionFile.writeText(project.version.toString())
+            }
+        }
+
+        afterEvaluate {
+            if (!isInDevelopment) {
+                configure<ChangelogPluginExtension> {
+                    version.set(project.version.toString())
+                }
+            }
+        }
+
+        plugins.withType<YarnPlugin> {
+            rootProject.configure<YarnRootExtension> {
+                lockFileDirectory = rootDir.resolve("gradle/js")
+                yarnLockMismatchReport = YarnLockMismatchReport.WARNING
+            }
+        }
+
+        plugins.withType<WasmYarnPlugin> {
+            rootProject.configure<WasmYarnRootExtension> {
+                lockFileDirectory = rootDir.resolve("gradle/wasm")
+                yarnLockMismatchReport = YarnLockMismatchReport.WARNING
+            }
+        }
+    }
+
+    public companion object {
+        public const val DEPLOY_GROUP: String = "deploy"
+    }
+}
--- a/src/main/kotlin/space/kscience/gradle/KScienceReadmeExtension.kt
+++ b/src/main/kotlin/space/kscience/gradle/KScienceReadmeExtension.kt
@@ -0,0 +1,299 @@
+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 org.gradle.api.Project
+import org.gradle.kotlin.dsl.*
+import org.intellij.lang.annotations.Language
+import org.jetbrains.dokka.gradle.AbstractDokkaTask
+import org.jetbrains.kotlin.gradle.dsl.abi.AbiValidationExtension
+import org.jetbrains.kotlin.gradle.dsl.abi.ExperimentalAbiValidation
+import space.kscience.gradle.internal.withKScience
+import space.kscience.gradle.internal.withKotlin
+import java.io.File
+import java.io.Serializable
+import java.io.StringWriter
+
+
+private fun Template.processToString(args: Map<String, Any?>): String {
+    val writer = StringWriter()
+    process(args, writer)
+    return writer.toString()
+}
+
+public class KScienceReadmeExtension(private val kscience: KSciencePlatformExtension) {
+    public val project: Project get() = kscience.project
+
+    public var description: String? = null
+        get() = field ?: project.description
+
+    public var maturity: Maturity by kscience::maturity
+
+    /**
+     * 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",
+            KScienceReadmeExtension::class.java.getResource("/templates/ARTIFACT-TEMPLATE.md")!!.readText()
+        )
+        if (readmeTemplate.exists()) {
+            putTemplate("readme", readmeTemplate.readText())
+        } else if (useDefaultReadmeTemplate) {
+            putTemplate(
+                "readme",
+                KScienceReadmeExtension::class.java.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) :
+        Serializable
+
+    public val features: MutableList<Feature> = mutableListOf()
+
+    /**
+     * A plain readme feature with description
+     */
+    public fun feature(
+        id: String,
+        @Language("File") ref: String? = null,
+        name: String = id,
+        @Language("markdown") description: () -> String,
+    ) {
+        features += Feature(id, description(), ref, name)
+    }
+
+    /**
+     * A readme feature with HTML description
+     */
+    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, Project.() -> Any?> = mutableMapOf(
+        "name" to { name },
+        "group" to { group },
+        "version" to { version },
+        "description" to { description ?: "" },
+        "features" to { featuresString() },
+        "published" to { plugins.findPlugin("maven-publish") != null },
+        "artifact" to {
+            val projectProperties = mapOf(
+                "name" to name,
+                "group" to group,
+                "version" to version
+            )
+            fmCfg.getTemplate("artifact").processToString(projectProperties)
+        },
+        "modules" to {
+            buildString {
+                subprojects.forEach { subproject ->
+                    subproject.extensions.findByType<KScienceReadmeExtension>()?.let { ext ->
+                        val path = subproject.path.replaceFirst(":", "").replace(":", "/")
+                        appendLine("\n### [$path]($path)")
+                        ext.description?.let { appendLine("> ${ext.description}") }
+                        appendLine(">\n> **Maturity**: ${ext.maturity}")
+                        val featureString = ext.featuresString(itemPrefix = "> - ", pathPrefix = "$path/")
+                        if (featureString.isNotBlank()) {
+                            appendLine(">\n> **Features:**")
+                            appendLine(featureString)
+                        }
+                    }
+                }
+            }
+        }
+    )
+
+    public fun getPropertyValues(): Map<String, Any?> = properties.mapValues { (_, value) -> project.value() }
+
+    public fun property(key: String, value: Any?) {
+        properties[key] = { value }
+    }
+
+    public fun property(key: String, value: Project.() -> 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.lines().firstOrNull() ?: ""
+                }"
+            )
+        }
+    }
+
+    /**
+     * 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
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (javaClass != other?.javaClass) return false
+
+        other as KScienceReadmeExtension
+
+        if (project != other.project) return false
+        if (maturity != other.maturity) return false
+        if (useDefaultReadmeTemplate != other.useDefaultReadmeTemplate) return false
+        if (readmeTemplate != other.readmeTemplate) return false
+        if (fmLoader != other.fmLoader) return false
+        if (fmCfg != other.fmCfg) return false
+        if (features != other.features) return false
+        if (properties != other.properties) return false
+        if (inputFiles != other.inputFiles) return false
+
+        return true
+    }
+
+    override fun hashCode(): Int {
+        var result = project.hashCode()
+        result = 31 * result + maturity.hashCode()
+        result = 31 * result + useDefaultReadmeTemplate.hashCode()
+        result = 31 * result + readmeTemplate.hashCode()
+        result = 31 * result + fmLoader.hashCode()
+        result = 31 * result + fmCfg.hashCode()
+        result = 31 * result + features.hashCode()
+        result = 31 * result + properties.hashCode()
+        result = 31 * result + inputFiles.hashCode()
+        return result
+    }
+
+
+}
+
+
+internal fun KSciencePlatformExtension.configureReadme() = with(project) {
+
+    //early return is readme is already configured
+    if (extensions.findByType<KScienceReadmeExtension>() != null) return@with
+
+    //Add readme generators to individual subprojects and root project
+    val readmeExtension = KScienceReadmeExtension(this@configureReadme)
+    this.extensions.add("readme", readmeExtension)
+
+    this@configureReadme.extensions.add("readme", readmeExtension)
+
+
+    val generateReadme by tasks.registering {
+        group = "documentation"
+        description = "Generate a README file if stub is present"
+
+        inputs.property("features", readmeExtension.features)
+
+        if (readmeExtension.readmeTemplate.exists()) {
+            inputs.file(readmeExtension.readmeTemplate)
+        }
+
+        readmeExtension.inputFiles.forEach {
+            if (it.exists()) {
+                inputs.file(it)
+            }
+        }
+
+        // add dependency for this task on subprojects readme tasks
+        subprojects {
+            withKScience {
+                extensions.findByType<KScienceReadmeExtension>()?.let { subProjectReadmeExtension ->
+                    tasks.findByName("generateReadme")?.let { readmeTask ->
+                        dependsOn(readmeTask)
+                    }
+                    inputs.property("features-${name}", subProjectReadmeExtension.features)
+                }
+            }
+        }
+
+        val readmeFile = file("README.md")
+        outputs.file(readmeFile)
+
+        doLast {
+            val readmeString = readmeExtension.readmeString()
+            if (readmeString != null) {
+                readmeFile.writeText(readmeString)
+            }
+        }
+    }
+
+    tasks.withType<AbstractDokkaTask> {
+        dependsOn(generateReadme)
+    }
+
+
+    // Enable API validation for production releases
+    if (!isInDevelopment && isMature()) {
+        withKotlin {
+            extensions.configure<AbiValidationExtension> {
+                @OptIn(ExperimentalAbiValidation::class)
+                enabled.set(true)
+            }
+        }
+    }
+}
--- a/src/main/kotlin/space/kscience/gradle/KScienceVersions.kt
+++ b/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")!!
+    }
+}
--- a/src/main/kotlin/space/kscience/gradle/SerializationTargets.kt
+++ b/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,
+    )
+}
--- a/src/main/kotlin/space/kscience/gradle/internal/common.kt
+++ b/src/main/kotlin/space/kscience/gradle/internal/common.kt
@@ -0,0 +1,68 @@
+package space.kscience.gradle.internal
+
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.findByType
+import org.gradle.kotlin.dsl.withType
+import org.jetbrains.kotlin.gradle.dsl.JvmDefaultMode
+import org.jetbrains.kotlin.gradle.dsl.KotlinBaseExtension
+import org.jetbrains.kotlin.gradle.dsl.KotlinJvmCompilerOptions
+import org.jetbrains.kotlin.gradle.plugin.KotlinBasePlugin
+import org.jetbrains.kotlin.gradle.plugin.LanguageSettingsBuilder
+import space.kscience.gradle.KScienceExtension
+import space.kscience.gradle.KSciencePlugin
+import space.kscience.gradle.KScienceVersions
+
+internal val defaultKotlinCommonArgs: List<String> = listOf(
+    "-Xexpect-actual-classes"
+)
+
+internal fun KotlinJvmCompilerOptions.defaultKotlinJvmOpts() {
+    jvmDefault.set(JvmDefaultMode.NO_COMPATIBILITY)
+}
+
+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.time.ExperimentalTime")
+    optIn("kotlin.ExperimentalUnsignedTypes")
+    optIn("kotlin.ExperimentalStdlibApi")
+    optIn("kotlin.contracts.ExperimentalContracts")
+    optIn("kotlin.js.ExperimentalJsExport")
+}
+
+/**
+ * Configures the project using the `KScienceExtension` provided by the `KSciencePlugin`.
+ *
+ * This function locates the `KSciencePlugin` in the project, and if found, applies the given
+ * configuration block to the `KScienceExtension` associated with the plugin.
+ *
+ * @param block a configuration block that is applied to the `KScienceExtension` instance, allowing
+ *              users to customize the project according to the extension's capabilities.
+ */
+internal fun Project.withKScience(block: KScienceExtension.() -> Unit) {
+    plugins.withType<KSciencePlugin>().configureEach {
+        extensions.findByType<KScienceExtension>()?.apply(block)
+    }
+}
+
+/**
+ * Configures the Kotlin environment in the current project by finding and applying a provided configuration block
+ * to the KotlinBaseExtension if the KotlinBasePlugin is applied.
+ *
+ * @param block The configuration block to apply to the KotlinBaseExtension.
+ */
+internal fun Project.withKotlin(block: KotlinBaseExtension.() -> Unit) {
+    plugins.withType<KotlinBasePlugin>().configureEach {
+        extensions.findByType<KotlinBaseExtension>()?.apply(block)
+    }
+}
--- a/src/main/kotlin/space/kscience/gradle/internal/dependencies.kt
+++ b/src/main/kotlin/space/kscience/gradle/internal/dependencies.kt
@@ -1,4 +1,4 @@
-package ru.mipt.npm.gradle.internal
+package space.kscience.gradle.internal

 import org.gradle.api.Project
 import org.gradle.kotlin.dsl.configure
@@ -6,8 +6,8 @@ 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 ru.mipt.npm.gradle.DependencyConfiguration
-import ru.mipt.npm.gradle.DependencySourceSet
+import space.kscience.gradle.DependencyConfiguration
+import space.kscience.gradle.DependencySourceSet

 internal fun Project.useDependency(
    vararg pairs: Pair<String, String>,
@@ -87,7 +87,6 @@ internal fun Project.useCommonDependency(
        }
    }

-
    withPlugin("org.jetbrains.kotlin.jvm") {
        configure<KotlinJvmProjectExtension> {
            sourceSets.findByName(dependencySourceSet.setName)?.apply {
@@ -102,6 +101,7 @@ internal fun Project.useCommonDependency(
            }
        }
    }
+
    withPlugin("org.jetbrains.kotlin.js") {
        configure<KotlinJsProjectExtension> {
            sourceSets.findByName(dependencySourceSet.setName)?.apply {
@@ -116,4 +116,4 @@ internal fun Project.useCommonDependency(
            }
        }
    }
-}
+}
--- a/src/main/kotlin/space/kscience/gradle/internal/publishing.kt
+++ b/src/main/kotlin/space/kscience/gradle/internal/publishing.kt
@@ -0,0 +1,112 @@
+package space.kscience.gradle.internal
+
+import com.vanniktech.maven.publish.MavenPublishBaseExtension
+import com.vanniktech.maven.publish.MavenPublishBasePlugin
+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.jetbrains.kotlin.gradle.dsl.KotlinJvmProjectExtension
+
+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") {
+        apply<MavenPublishBasePlugin>()
+
+        configure<PublishingExtension> {
+
+            plugins.withId("org.jetbrains.kotlin.jvm") {
+                val kotlin = extensions.findByType<KotlinJvmProjectExtension>()!!
+
+                val sourcesJar by tasks.registering(Jar::class) {
+                    archiveClassifier.set("sources")
+                    kotlin.sourceSets.forEach {
+                        from(it.kotlin)
+                    }
+                }
+
+                publications.create<MavenPublication>("jvm") {
+                    from(project.components["java"])
+
+                    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.registering(Jar::class) {
+                    group = "documentation"
+                    archiveClassifier.set("javadoc")
+                    from(tasks.findByName("dokkaGenerate"))
+                }
+                publications.withType<MavenPublication> {
+                    artifact(dokkaJar)
+                }
+            }
+
+            //apply signing if signing configuration is available
+            if (requestPropertyOrNull("signing.password") != null || requestPropertyOrNull("signing.secretKeyRingFile") != null) {
+                plugins.withType<MavenPublishBasePlugin> {
+                    extensions.configure<MavenPublishBaseExtension> {
+                        signAllPublications()
+                    }
+                }
+            } else {
+                logger.warn("Signing information is not provided. Skipping artefact signing.")
+            }
+        }
+    }
+}
+
+internal fun Project.addPublishing(
+    repositoryName: String,
+    urlString: String
+) {
+    require(repositoryName.matches("\\w*".toRegex())) { "Repository name must contain only letters or numbers" }
+    val user: String? = requestPropertyOrNull("publishing.$repositoryName.user")
+    val token: String? = requestPropertyOrNull("publishing.$repositoryName.token")
+
+    if (user == null || token == null) {
+        logger.info("Skipping $repositoryName publishing because $repositoryName credentials are not defined")
+        return
+    }
+
+    allprojects {
+        plugins.withId("maven-publish") {
+            configure<PublishingExtension> {
+                logger.info("Adding $repositoryName publishing to project [${project.name}]")
+
+                repositories.maven {
+                    name = repositoryName
+                    url = uri(urlString)
+
+                    credentials {
+                        username = user
+                        password = token
+                    }
+                }
+            }
+        }
+    }
+}
--- a/src/main/kotlin/space/kscience/gradle/pomConfig.kt
+++ b/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("SPC")
+            organizationUrl.set("https://sciprog.center/")
+        }
+    }
+}
--- a/src/main/resources/templates/ARTIFACT-TEMPLATE.md
+++ b/src/main/resources/templates/ARTIFACT-TEMPLATE.md
@@ -0,0 +1,15 @@
+## Artifact:
+
+The Maven coordinates of this project are `${group}:${name}:${version}`.
+
+**Gradle Kotlin DSL:**
+```kotlin
+repositories {
+    maven("https://repo.kotlin.link")
+    mavenCentral()
+}
+
+dependencies {
+    implementation("${group}:${name}:${version}")
+}
+```
--- a/src/main/resources/templates/README-TEMPLATE.md
+++ b/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>
--- a/src/test/kotlin/TestVersions.kt
+++ b/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)
+    }
+}